feat: Löschfristen je Datenklasse, Passwort-Zurücksetzen, DPF-Recherche

- Löschfristen (Migration 0020): pro Mandant einstellbar statt fest im
  Regelwerk, da die DSGVO selbst keine festen Fristen nennt (Art. 5
  Abs. 1 lit. e). Jede Firma wird mit risikogestaffelten Vorschlagswerten
  vorbelegt, loeschfrist_max_tage wird jetzt tatsächlich hart gegen
  Werkzeuge gefiltert (schließt rules/OPEN.md Punkt 4).
- Neues internal/mail-Paket (SMTP-Versand + Test-Doppel) und darauf
  aufbauend Passwort-Zurücksetzen (Migration 0019) - bisher nur als
  Absicht in der Rollentabelle genannt, nie gebaut.
- dpf_zertifiziert für alle 20 Katalogeinträge gegen das offizielle
  DPF-Register recherchiert und in der Produktions-DB aktualisiert
  (12 zertifiziert, 5 recherchiert-nicht-gefunden, 3 nicht anwendbar).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

CLAUDE.md

@@ -377,12 +377,25 @@ Das öffnet jetzt auch DeepSeek (Verarbeitung in China) für einen
 künftigen Katalogeintrag — die Sperre lag ausschließlich am alten
 Wertebereich, nicht an einer fachlichen Entscheidung.
 
-**Offen:** `dpf_zertifiziert` ist bei allen 19 Einträgen noch `false` —
-für keinen wurde bisher gezielt recherchiert, ob der jeweilige
-US-Anbieter tatsächlich DPF-zertifiziert ist (das Feld wurde erst mit
-dieser Migration eingeführt, `false` heißt hier "nicht recherchiert",
-nicht "nachweislich nicht zertifiziert"). Nachrecherche pro Anbieter
-noch zu tun.
+**`dpf_zertifiziert` recherchiert (2026-09-01), Offener Punkt erledigt.**
+Für alle 20 Einträge wurde gezielt gegen das offizielle Register
+(dataprivacyframework.gov, per Participant-ID einzeln nachvollziehbar)
+geprüft — nicht gegen die JS-Suchseite selbst (nicht scrapebar), sondern
+gegen das dahinterliegende, von ihr selbst genutzte API. Ergebnis: 12
+zertifiziert (Microsoft 365 Copilot, GitHub Copilot Business, Google
+Gemini, Perplexity Enterprise Pro, Adobe Firefly, Otter.ai Business,
+Notion AI, Grammarly Business, ElevenLabs, Zendesk AI, Canva Magic
+Studio, Zapier), 5 recherchiert aber nicht im Register gefunden
+(ChatGPT Enterprise, Claude for Work, Claude Code, Midjourney, Julius
+AI — `false` heißt hier jetzt "geprüft, kein Eintrag gefunden", nicht
+mehr "nicht recherchiert"), 3 nicht anwendbar (DeepL, Le Chat/Mistral,
+Synthesia — reine EU-Verarbeitung ohne US-Rechtsträger im Register, DPF
+regelt EU→USA-Transfers). Besonderheiten als `einschraenkungen`-Eintrag
+je Werkzeug festgehalten: Perplexity hat nur EU-US/UK-, keine
+Swiss-US-Zertifizierung; Notion AIs Zertifizierung ist als "Active" mit
+bereits abgelaufenem Datum in Re-Zertifizierung; Grammarly ist im
+Register unter dem fusionierten Rechtsträger "Superhuman Platform Inc."
+gelistet, nicht mehr unter "Grammarly, Inc.".
 
 `CurrentKatalogVersion` liefert eine reproduzierbare Kennung des
 aktuellen Katalogzustands (Anzahl Einträge + letzte Änderung) — wird in
@@ -452,8 +465,11 @@ Genehmigungen erhalten ein Ablaufdatum (`gueltig_bis`: 12 Monate, bei
 
 **Schritt 7 (Wiedervorlage, Katalog-Benachrichtigung) ist umgesetzt**
 (`internal/web/wiedervorlage_handlers.go`, `GET /wiedervorlage`, Ebene
-3). Es gibt keine E-Mail-Infrastruktur — "Benachrichtigung" ist bewusst
-eine In-App-Liste, kein Versand. Eine aktive Genehmigung erscheint dort,
+3). Zum Zeitpunkt dieser Umsetzung gab es noch keine E-Mail-Infrastruktur
+(die kam erst 2026-09-01 mit `internal/mail`, siehe „Passwort-
+Zurücksetzen und E-Mail-Versand" weiter unten, bisher nur für
+Passwort-Zurücksetzen genutzt) — "Benachrichtigung" ist deshalb bewusst
+weiterhin eine In-App-Liste, kein E-Mail-Versand. Eine aktive Genehmigung erscheint dort,
 wenn mindestens einer zutrifft: (1) `gueltig_bis` ist erreicht oder
 liegt innerhalb von 30 Tagen, (2) das zugesagte Werkzeug wurde aus dem
 Katalog entfernt, (3) `werkzeugDiff` erkennt eine Abweichung zwischen
@@ -478,6 +494,222 @@ das Register ist eine Genehmigungsliste, kein vollständiges Antragslog
 
 ---
 
+## Freigabe-Workflow (konfigurierbare Mehrfach-Genehmigung, 2026-08-31)
+
+**Bewusste Abkehr von einer dokumentierten v1-Ausschlussentscheidung.**
+Diese CLAUDE.md schloss "konfigurierbare Rollen mit eigener Oberfläche"
+und "Workflow-Designer" ursprünglich explizit für v1 aus (siehe "Nicht
+bauen (v1)" unten). Der Nutzer hat das am 2026-08-31 bewusst und nach
+Rückfrage aufgehoben ("Wir sollten das System schon perfekt bauen! Daher
+auch gerne komplex") — Auslöser war die Frage, ob ein Datenschutz-
+beauftragter und/oder die Geschäftsführung zusätzlich in die Entscheidung
+eingebunden werden müssen. Statt DSB/GF fest zu verdrahten, können
+Mandanten jetzt selbst definieren, wer bei welcher abgeleiteten
+Bedingung zusätzlich zustimmen muss.
+
+**Datenmodell (Migration 0017):** vier neue Tabellen, orthogonal zu den
+fünf bestehenden Zugriffsrollen (`mitarbeiter`/`verantwortlicher`/
+`pruefer`/`admin`/`betreiber` bleiben unverändert):
+
+- `genehmiger_rolle` — eine mandantendefinierte Freigabe-Funktion (z. B.
+  "Datenschutzbeauftragter", "Geschäftsführung"). Kein Zugriffsrecht,
+  nur eine Freigabe-Zuständigkeit.
+- `nutzer_genehmiger_rolle` — Zuordnung Person↔Genehmiger-Rolle,
+  many-to-many. Eine Person kann null, eine oder mehrere davon haben,
+  unabhängig von ihrer `app_user.role`.
+- `freigabe_regel` — "wenn Bedingung X zutrifft, ist zusätzlich eine
+  Freigabe durch Genehmiger-Rolle Y nötig". Die Bedingung ist bewusst
+  **kein freier Regeleditor**, sondern auf die drei Vokabulare
+  beschränkt, die die Bewertungslogik ohnehin schon berechnet:
+  Anforderungs-ID (z. B. `dsfa_erforderlich`), Einstufungs-ID (z. B.
+  `hochrisiko`) oder Datenklasse-ID (z. B. `besondere_kategorie`).
+  Kompromiss zwischen "konfigurierbar" (Nutzeranforderung) und
+  "buildbar/auditierbar" (jede mögliche Bedingung ist bereits eine
+  geprüfte, bekannte Ableitung, keine beliebige Freitext-Regel).
+- `freigabeschritt` — pro Antrag ein Datensatz je ausgelöster
+  Freigabe-Regel, Status `ausstehend`/`genehmigt`/`abgelehnt`.
+
+`antrag.status` hat einen neuen Zwischenwert `wartet_auf_freigabe`
+zwischen `eingereicht` und `entschieden` (CHECK-Constraint erweitert).
+
+**Ablauf:** `handleFallEntscheiden` (`internal/web/fachebene_handlers.go`)
+prüft nach einer Genehmigung/Genehmigung-mit-Auflagen, ob die Bewertung
+mindestens eine `freigabe_regel` des Mandanten auslöst
+(`triggeredGenehmigerRollen`). Falls ja: `antrag.status` wird
+`wartet_auf_freigabe` statt `entschieden`, pro ausgelöster Regel entsteht
+ein `freigabeschritt`, **kein** `registereintrag` entsteht noch. Falls
+keine Regel greift, läuft exakt der alte Pfad (`registriereGenehmigung`)
+— **verifiziert per dediziertem Test**
+(`TestOhneFreigabeRegelnVerhaeltSichWieVorher`), da alle heutigen
+Bestandskunden null Freigabe-Regeln haben und sich für sie nichts ändern
+darf.
+
+**Bestätigte Semantik (2026-08-31, Nutzer: "Beides stimmt!"):**
+1. **Alle** ausgelösten Genehmiger-Rollen müssen zustimmen, nicht nur
+   eine von mehreren — geprüft durch erneutes `ListFreigabeschritteForAntrag`
+   nach jeder Einzelentscheidung.
+2. **Eine Ablehnung kippt den gesamten Antrag**, geht nicht zurück an
+   die Fachebene zur Neuentscheidung. `KaskadiereAblehnung` setzt dabei
+   automatisch alle anderen noch `ausstehend`en Freigabeschritte
+   desselben Antrags ebenfalls auf `abgelehnt` — sonst würde ein
+   Freigabeschritt in der Liste einer anderen Person ewig unbearbeitet
+   hängen bleiben, obwohl der Antrag längst entschieden ist.
+
+Eine Ablehnung (ob direkt oder per Kaskade) mutiert **nicht** die
+ursprüngliche `genehmigt`-Zeile — `entscheidung` bleibt append-only wie
+bisher. Stattdessen entsteht eine neue `entscheidung`-Zeile mit
+`Entscheidung: "abgelehnt"`; `GetLatestEntscheidungForAntrag` (bereits
+bestehender "letzte Zeile gewinnt"-Helfer) zeigt den Override überall
+dort, wo er ohnehin schon verwendet wird — keine weitere Codeänderung
+nötig, um die Überschreibung sichtbar zu machen.
+
+**Frontend** (`internal/web/freigabe_handlers.go` + drei neue Templates):
+`GET/POST /verwaltung/genehmiger-rollen` (Admin: Rolle anlegen, Mitglieder
+zuordnen/entfernen — Formular nutzt einen einzelnen `<select>` mit drei
+`<optgroup>`s für die drei Bedingungstypen, kein abhängiges Dropdown,
+kein JavaScript), `GET/POST /verwaltung/freigabe-regeln` (Admin: Regel
+anlegen/löschen), `GET /freigaben` + `POST /freigaben/{id}/entscheiden`
+(jeder eingeloggte Nicht-Betreiber mit zugeordneter Genehmiger-Rolle:
+eigene offene Freigaben sehen und entscheiden, mit Pflicht-Kommentarfeld
+bei Ablehnung). Fall-Detail (`fall_detail.html`) zeigt die
+Freigabeschritt-Historie mit Ampel-Badge **unabhängig vom aktuellen
+Antragsstatus** — anfangs fälschlich auf `wartet_auf_freigabe`
+beschränkt gebaut, beim Live-Verifizieren aufgefallen: sobald der letzte
+Freigebende zustimmt und der Antrag auf `entschieden` springt, verschwand
+die komplette Freigabehistorie aus der Ansicht, was der Grundregel
+widerspricht, dass eine Entscheidung nie ohne vollständige Herleitung
+gezeigt wird. Der Hinweistext "Genehmigung erst endgültig, wenn alle
+erteilt sind" erscheint entsprechend nur noch, solange der Antrag
+tatsächlich noch auf Freigabe wartet.
+
+**CSS-Bugfix, beim Live-Verifizieren gefunden (sitesweit, nicht nur
+diese Seite betreffend):** `.beitraege-liste > li:not(:has(> a)) form`
+hatte `flex: 0 0 auto` (kein Schrumpfen). Bei den bisherigen Listen
+(Nutzer, Abteilungen) enthielten diese eingebetteten Formulare nur
+Buttons, die naturgemäß schmal bleiben — die Genehmiger-Rollen-Seite ist
+die erste mit einem `<select>` darin, dessen Browser-Eigenbreite
+(bestimmt durch die längste Options-Beschriftung, hier E-Mail-Adressen)
+den ganzen Zeilen-Container über die Mobile-Viewport-Breite hinaustrieb
+(horizontales Scrollen der ganzen Seite). Fix: `max-width: 100%` auf
+derselben Regel ergänzt — generisch, wirkt auf jedes künftige
+`<select>` in diesem Listen-Pattern, nicht nur hier.
+
+**Live end-to-end verifiziert** (curl gegen echten lokalen Server +
+echtes Postgres, nicht nur die Go-Testsuite): Happy Path (eine Regel,
+eine Rolle, Genehmigung → `wartet_auf_freigabe` → Freigabe erteilt →
+`entschieden` + 1 Registereintrag) und Kaskaden-Ablehnung (zwei Regeln,
+zwei Rollen, eine lehnt ab → beide Freigabeschritte `abgelehnt`, Antrag
+direkt `entschieden` als `abgelehnt`, 0 Registereinträge) — beide exakt
+wie spezifiziert. Chromium-Headless-Screenshots (Desktop 1440×900 +
+Mobile 390×844) aller vier neuen/geänderten Seiten bestätigen zusätzlich
+das responsive Layout nach dem enconf-Card-Pattern.
+
+**Standard-Genehmiger-Rollen bei Firmenanlage (2026-08-31, Migration
+0018).** Jede neue Firma bekommt jetzt automatisch vier leere
+Genehmiger-Rollen mit erklärender Beschreibung (`standardGenehmigerRollen`
+in `internal/web/freigabe_handlers.go`, aufgerufen aus `handleRegister`
+und `handleBetreiberAccountCreate` direkt nach `CreateAccount`): 
+
+- **Datenschutzbeauftragter** — "Prüft Anträge mit besonderen
+  Datenschutzanforderungen, z. B. wenn eine Datenschutz-Folgenabschätzung
+  erforderlich ist."
+- **Geschäftsführer** — "Trifft die unternehmerische Entscheidung bei
+  besonders risikobehafteten Vorhaben."
+- **KI-Manager** — "Bewertet den Antrag fachlich."
+- **CISO** — "Prüft den Antrag aus Sicherheitssicht (Auditor)."
+
+Bewusst **ohne** Mitglieder und **ohne** Freigabe-Regel — der Admin muss
+nur noch Personen zuordnen (`/verwaltung/genehmiger-rollen`) und
+optional eine auslösende Bedingung definieren
+(`/verwaltung/freigabe-regeln`), statt bei null anzufangen. Welche
+Bedingung welche Rolle tatsächlich auslöst, bleibt **vollständig
+Sache der Firma** — das System schreibt keine feste fachliche Bindung
+vor (z. B. keine hartkodierte Kopplung "Geschäftsführer ⇒ hochrisiko");
+die Beschreibung ist reine UI-Orientierungshilfe, kein Ableitungsregel-
+Ersatz. `genehmiger_rolle.beschreibung` ist ein freies, optionales
+Textfeld (`NOT NULL DEFAULT ''`) — auch für vom Admin selbst angelegte
+zusätzliche Rollen nutzbar. Getestet via `TestRegisterSeedsStandardGenehmigerRollen`
+und live per curl gegen echten Server + Postgres verifiziert.
+
+---
+
+## Löschfristen je Datenklasse (2026-09-01, Migration 0020)
+
+Schließt `rules/OPEN.md`, Punkt 4. Recherche ergab: die DSGVO nennt
+**keine** festen Speicherfristen (Art. 5 Abs. 1 lit. e verlangt nur "so
+lange wie für den Zweck nötig") — es gibt also keinen fest im Regelwerk
+hinterlegbaren "richtigen" Zahlenwert. Lösung: **pro Mandant einstellbar**
+(`loeschfrist_einstellung`, `GET/POST /verwaltung/loeschfristen`,
+admin-only wie jede andere `/verwaltung/*`-Seite — bewusst NICHT an den
+Namen der Genehmiger-Rolle "Datenschutzbeauftragter" gekoppelt, siehe
+Freigabe-Workflow oben: Genehmiger-Rollen sind explizit ohne eigenes
+Zugriffsrecht). Jede neue Firma wird mit risikogestaffelten
+Vorschlagswerten vorbelegt (`seedStandardLoeschfristen`, aufgerufen wie
+`seedStandardGenehmigerRollen` direkt nach `CreateAccount`):
+`oeffentlich` 365 / `intern` 180 / `auftragsdaten` 90 / `personenbezogen`
+90 / `berufsgeheimnis` 30 / `besondere_kategorie` 30 Tage — eigene
+Einschätzung nach Sensibilität gestaffelt, **keine Rechtsvorgabe**, frei
+editierbar (Formular-Hinweistext sagt das ausdrücklich).
+
+**Harte Filterung jetzt aktiv** (vorher, siehe `rules/OPEN.md` Punkt 4
+alt, wurde `loeschfrist_max_tage` gar nicht geprüft): `ErfuelltAnforderung`
+und `FilterWerkzeuge` (`internal/rules/evaluate.go`) haben einen neuen
+Parameter `loeschfristMaxTage *int`. `nil` (keine Frist konfiguriert)
+verhält sich wie vorher (nicht gefiltert) — Rückwärtskompatibilität.
+Ist eine Frist gesetzt, erfüllt ein Werkzeug ohne bezifferte
+Aufbewahrungsdauer (`werkzeug.aufbewahrung_tage IS NULL`) sie NICHT
+(fail closed, analog zur leeren Länderliste bei `eu_verarbeitung`) —
+dafür wurde `rules.WerkzeugEigenschaften.AufbewahrungTage` von `int` auf
+`*int` geändert, sonst wäre "unbekannt" nicht von "0 Tage" unterscheidbar
+gewesen. `internal/web/antrag_handlers.go:bewerteAntrag` liest die
+Einstellung für die aktuelle Datenklasse des Antrags aus
+`ListLoeschfristEinstellungenForAccount` und reicht sie durch.
+
+---
+
+## Passwort-Zurücksetzen und E-Mail-Versand (2026-09-01)
+
+Neues Paket `internal/mail`: `Mailer`-Interface (`Send(to, subject, body)
+error`), `SMTPMailer` als echte Implementierung (stdlib `net/smtp`,
+STARTTLS falls vom Server angeboten — deckt den Standard-Submission-Port
+587 ab, implizites TLS auf Port 465 wird von `net/smtp` nicht
+unterstützt) und `FakeMailer` als Test-Doppel (sammelt gesendete Mails
+statt sie zu verschicken). Konfiguration über `SMTP_HOST`/`SMTP_PORT`/
+`SMTP_USER`/`SMTP_PASSWORD`/`SMTP_FROM` (alle optional — ohne
+`SMTP_HOST` startet der Dienst normal, nur der tatsächliche Versand
+schlägt dann mit einem klaren Fehler fehl statt einer nie ankommenden
+Mail vorzutäuschen; bewusst kein stiller No-op).
+
+**Erste Anwendung: Passwort-Zurücksetzen** (Ebene 1, öffentlich, bisher
+in der Rollentabelle nur als Absicht genannt, nie gebaut). `GET/POST
+/passwort-vergessen` nimmt eine E-Mail-Adresse entgegen und zeigt
+**immer** dieselbe Erfolgsmeldung ("Falls diese E-Mail-Adresse bei uns
+registriert ist, wurde ein Link verschickt") — unabhängig davon, ob die
+Adresse existiert, aktiv ist, oder der Versand tatsächlich geklappt hat.
+Das ist derselbe User-Enumeration-Schutz wie beim Login (identische
+Fehlermeldung bei falscher E-Mail/falschem Passwort); ein Versandfehler
+wird serverseitig geloggt (`log.Printf`, nicht verschluckt), aber nicht
+an den Client durchgereicht. `password_reset_token` (Migration 0019):
+ein Token ist 1 Stunde gültig, genau einmal verwendbar (`used_at`),
+`GetValidPasswordResetToken` liefert für "nicht gefunden", "abgelaufen"
+und "schon verwendet" identisch `ErrNotFound` — auch hier kein
+Unterschied, der einem Angreifer etwas verraten könnte. `GET/POST
+/passwort-zuruecksetzen/{token}` prüft den Token, setzt bei Erfolg das
+neue Passwort (`store.SetUserPassword`) und verbraucht den Token.
+
+**Live end-to-end verifiziert** — nicht nur gegen `mail.FakeMailer` in
+Tests, sondern gegen einen echten, minimalen SMTP-Server (selbst
+geschriebener TCP-Listener, der die EHLO/MAIL FROM/RCPT TO/DATA-Sequenz
+korrekt beantwortet): Registrierung → Anfrage → tatsächlich empfangene
+Mail mit funktionierendem Link → Formular → neues Passwort → Login mit
+altem Passwort abgelehnt, mit neuem Passwort erfolgreich. Dabei einen
+echten Bug gefunden und behoben: der Versandfehler wurde zunächst mit
+`_ = s.mailer.Send(...)` still verschluckt (Verstoß gegen die
+"keine stillen Fallbacks"-Regel) — beim Debuggen selbst schmerzhaft
+aufgefallen, jetzt geloggt statt verworfen.
+
+---
+
 ## Onboarding
 
 **Firma (Ebene 1, öffentlich, `POST /register`):** Registrierungsformular
@@ -628,9 +860,56 @@ außerhalb des Arbeitsverzeichnisses liegt):
   `@ant-design/icons`, das ist React-spezifisch) — bewusste
   Vereinfachung. Angewendet auf die Startseite (`index.html`).
 
-Noch nicht auf weitere Tabellen/Seiten übertragen (Register,
-Nutzerliste, Abteilungen, Fälle-Posteingang, Betreiber-Dashboard) —
-nächste Kandidaten, falls das Muster fortgesetzt werden soll.
+**Ausgerollt (2026-08-31):** Register, Nutzerverwaltung, Abteilungen,
+Fälle-Posteingang, Betreiber-Dashboard.
+
+- **Register** (`register_liste.html`) und **Fälle-Posteingang**
+  (`faelle_liste.html`) haben jetzt `.page-header` + Freitext-Filter
+  (`q`) + Paginierung. Register zusätzlich `.table-responsive` (war
+  vorher `.table-scroll`) mit `data-label` je `<td>`.
+- **Nutzerverwaltung** (`nutzer_liste.html`) hat `.page-header` +
+  Freitext-Filter (E-Mail/Rolle) + Paginierung — blieb `.beitraege-liste`
+  (schon Karten-artig), keine `.table-responsive`-Umstellung nötig.
+- **Abteilungen** (`abteilung_liste.html`) bekam nur `.page-header` —
+  bewusst ohne Paginierung, Abteilungslisten sind typischerweise klein
+  (Handvoll Stammdaten pro Mandant).
+- **Betreiber-Dashboard** (`betreiber_dashboard.html`) von
+  `.admin-kacheln` auf `.stat-cards` umgestellt (analog zu `index.html`).
+
+Neue gemeinsame Helfer in `pagination.go`: `matchesQuery(q string,
+felder ...string) bool` — eine einzige Freitext-Filter-Basis für alle
+Listen-Seiten, damit nicht jede ihre eigene Such-Logik erfindet.
+
+**Beim Ausrollen gefundener, bereits live gewesener Bug:** `.filter-bar`
+direkt auf einem `<form>`-Element (statt auf einem `<div>` innerhalb
+des Formulars) verlor gegen die allgemeine `form { flex-direction:
+column }`-Regel — beide Selektoren haben für die Property
+`flex-direction` dieselbe Spezifität, aber nur `form` setzte sie
+explizit, `.filter-bar` überließ sie dem Initialwert. Ergebnis: die
+Filterleiste stapelte senkrecht statt in einer Zeile. Betraf bereits
+die im vorigen Schritt ausgelieferte Mandanten-Werkzeugkatalog-Seite.
+Behoben durch explizites `flex-direction: row` in `.filter-bar` selbst
+— jetzt unabhängig davon robust, ob die Klasse auf einem `<form>` oder
+einem `<div>` sitzt.
+
+**Ebenfalls ausgerollt (2026-08-31, zweite Runde):** Betreiber-Accounts
+(`.page-header` + Filter über Firmenname + Paginierung), Betreiber-
+Audit-Log (`.page-header` + Filter über Aktion/Zieltyp/Details +
+Paginierung), "Meine Anträge" (`.page-header` + Filter über Titel/
+Status/Häufigkeit + Paginierung), Wiedervorlage (nur `.page-header`,
+bewusst ohne Paginierung — natürlich begrenzt auf "braucht gerade
+Aufmerksamkeit").
+
+**Bekannte Einschränkung beim Audit-Log:** `ListAuditLog` holt weiterhin
+nur die neuesten `auditLogFetchLimit` (1000) Einträge aus der DB, dann
+wird in Go gefiltert/paginiert (`auditLogFetchLimit`-Konstante in
+`betreiber_handlers.go`) — keine echte DB-seitige Offset-Paginierung.
+Für ein potenziell sehr groß werdendes, append-only Audit-Log ist das
+mittelfristig nicht die saubere Lösung (Einträge jenseits der 1000
+neuesten sind über die Such-/Paginierungs-UI nicht erreichbar), aber
+proportional zum aktuellen Datenvolumen und konsistent mit dem
+In-Memory-Paginierungsmuster der übrigen Listen. Bei echtem Bedarf:
+`store.ListAuditLog` um `offset`/echtes SQL-`LIMIT`/`OFFSET` erweitern.
 
 **Verifikationsmethode für CSS-Änderungen:** Live-Cookie-Auth per
 Chromium-Headless/CDP ist im Sandbox-Environment nicht möglich (kein
@@ -771,12 +1050,22 @@ wiederverwendet aus dem alten Produkt), ebenso `bewertung`,
    (`GET /wiedervorlage`: abgelaufene/bald ablaufende Genehmigungen und
    Genehmigungen, deren Werkzeug sich seither im Katalog geändert hat
    oder entfernt wurde. In-App-Liste, kein E-Mail-Versand.)
+8. ~~Konfigurierbarer Freigabe-Workflow (Mehrfach-Genehmigung)~~ —
+   **erledigt** (siehe "Freigabe-Workflow" weiter oben: Genehmiger-Rollen,
+   Freigabe-Regeln, Freigabeschritte, Migration 0017 — bewusste Abkehr
+   von der ursprünglichen v1-Ausschlussentscheidung, siehe "Nicht bauen
+   (v1)" unten).
 
 Nicht bauen (v1): automatische Genehmigung ohne Mensch, Erkennung
 tatsächlicher Werkzeug-Nutzung, Mitarbeiterüberwachung (nichts, was
-Nutzung einzelner Personen auswertet), konfigurierbare Rollen mit
-eigener Oberfläche, Konzernstrukturen mit Vererbung, mandantenspezifische
-Regelwerke, Workflow-Designer, SAML, Schnittstellen zu Fremdsystemen.
+Nutzung einzelner Personen auswertet), Konzernstrukturen mit Vererbung,
+mandantenspezifische Regelwerke, SAML, Schnittstellen zu Fremdsystemen.
+
+~~konfigurierbare Rollen mit eigener Oberfläche~~ / ~~Workflow-Designer~~
+— **am 2026-08-31 bewusst aufgehoben**, siehe "Freigabe-Workflow"
+weiter oben: Genehmiger-Rollen und Freigabe-Regeln sind jetzt genau das,
+nur mit der Bedingung auf die drei bereits von der Bewertungslogik
+berechneten Vokabulare beschränkt (kein beliebiger Regeleditor).
 
 ---
 
@@ -997,8 +1286,9 @@ journalctl -u deklarix -f
   `kennzeichnungspflicht`/`dsfa_erforderlich` nur als Auflage vermerkt)
   — weiterhin nicht ausdrücklich bestätigt, aber plausibel, keine
   Rückmeldung dazu bisher eingeholt.
-- **Löschfristen je Datenklasse** (konkrete Tageswerte für
-  `loeschfrist_max_tage`) — noch nicht fachlich festgelegt.
+- ~~Löschfristen je Datenklasse~~ — **erledigt 2026-09-01**, siehe
+  „Löschfristen je Datenklasse" weiter oben: pro Mandant einstellbar
+  statt hartkodiert, da die DSGVO selbst keine festen Fristen nennt.
 - **Mandantenisolation auf Datenbankebene (Postgres Row-Level Security)**
   — die Frontend-Spezifikation fordert das explizit ("nicht in der
   Anwendungslogik"), aktuell ist Isolation ausschließlich
@@ -1020,15 +1310,13 @@ journalctl -u deklarix -f
   "sauberer" Lösung — falls künftig eine Firma admin und verantwortlicher
   bewusst auf zwei verschiedene Personen verteilen will, funktioniert das
   weiterhin unverändert (zwei separate Logins mit den jeweiligen Rollen).
-- **Zentraler Werkzeugkatalog muss noch befüllt werden** — die
-  Ebene-5/Betreiber-UI zur Katalogpflege ist jetzt gebaut (`GET
-  /betreiber/werkzeuge` Liste, `GET/POST /betreiber/werkzeuge/neu`
-  anlegen, `GET/POST /betreiber/werkzeuge/{id}` bearbeiten, `POST
-  .../loeschen` löschen — siehe `internal/web/betreiber_werkzeug_handlers.go`.
-  Bearbeitet ausschließlich `account_id IS NULL`-Einträge, ein
-  mandantenspezifischer Eintrag ist über diese Seiten nicht erreichbar
-  [404]). "Werkzeugkatalog aus der Plattform vorbelegt" beim Firma-
-  Onboarding bleibt trotzdem nicht automatisiert — der Katalog ist
-  inhaltlich weiterhin leer, bis der Betreiber tatsächlich Einträge
-  pflegt.
+- ~~Zentraler Werkzeugkatalog muss noch befüllt werden~~ — **erledigt**,
+  20 recherchierte Einträge seit 2026-08-31 (siehe „Werkzeugkatalog"
+  weiter oben). ~~`dpf_zertifiziert` recherchieren~~ — **erledigt
+  2026-09-01** (siehe dort für Details je Anbieter). "Werkzeugkatalog aus
+  der Plattform vorbelegt" beim Firma-Onboarding bleibt weiterhin nicht
+  automatisiert — jede neue Firma sieht sofort den vollen zentralen
+  Katalog (kein Kopiervorgang nötig, `account_id IS NULL` ist für alle
+  Mandanten gleich sichtbar), es gibt nur keine mandantenspezifische
+  Vorauswahl/Kuratierung beim Onboarding.
 - Markenanmeldung Deklarix, sobald erster Kunde zahlt.

cmd/deklarix/main.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"os"
 
+	"github.com/netcell-it/deklarix/internal/mail"
 	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 	"github.com/netcell-it/deklarix/internal/web"
@@ -51,9 +52,17 @@ func main() {
 	log.Printf("Regelwerk geladen: %d Datenklassen, %d KI-VO-Stufen, %d Anforderungen (aus %s)",
 		len(datenklasse.Stufen), len(einstufung.Stufen), len(anforderungen.Anforderungen), rulesDir)
 
+	mailer := mail.NewSMTPMailer(mail.Config{
+		Host:     os.Getenv("SMTP_HOST"),
+		Port:     os.Getenv("SMTP_PORT"),
+		User:     os.Getenv("SMTP_USER"),
+		Password: os.Getenv("SMTP_PASSWORD"),
+		From:     os.Getenv("SMTP_FROM"),
+	})
+
 	server, err := web.NewServer(db, web.Regelwerk{
 		Datenklasse: datenklasse, Einstufung: einstufung, Anforderungen: anforderungen,
-	})
+	}, mailer)
 	if err != nil {
 		log.Fatalf("web server: %v", err)
 	}

internal/mail/mail.go

@@ -0,0 +1,78 @@
+// Package mail versendet E-Mails (aktuell: Passwort-Zurücksetzen-Links)
+// über einen konfigurierten SMTP-Server. Reine Versandlogik, kein
+// Template-Rendering — der Aufrufer (internal/web) baut Betreff/Text
+// selbst zusammen, damit dieses Paket unabhängig vom Web-Layer bleibt.
+package mail
+
+import (
+	"fmt"
+	"net/smtp"
+)
+
+// Mailer ist die Schnittstelle, die internal/web nutzt — austauschbar
+// gegen eine Test-Doppel (siehe FakeMailer), damit Tests keinen echten
+// SMTP-Server brauchen.
+type Mailer interface {
+	Send(to, subject, body string) error
+}
+
+// Config sind die SMTP-Zugangsdaten, aus Umgebungsvariablen gelesen
+// (siehe cmd/deklarix/main.go) — kein neues Geheimnis im Code.
+type Config struct {
+	Host     string
+	Port     string
+	User     string
+	Password string
+	From     string
+}
+
+// SMTPMailer versendet über einen echten SMTP-Server (STARTTLS, falls
+// vom Server angeboten — das deckt den Standard-Submission-Port 587 ab;
+// implizites TLS auf Port 465 wird von net/smtp nicht unterstützt).
+type SMTPMailer struct {
+	cfg Config
+}
+
+func NewSMTPMailer(cfg Config) *SMTPMailer {
+	return &SMTPMailer{cfg: cfg}
+}
+
+// Send verschickt eine reine Text-E-Mail. Liefert einen Fehler, wenn
+// kein SMTP-Host konfiguriert ist — bewusst kein stiller No-op, ein
+// fehlgeschlagener Versand (z. B. Passwort-Reset) muss sichtbar
+// scheitern statt eine E-Mail vorzutäuschen, die nie ankommt.
+func (m *SMTPMailer) Send(to, subject, body string) error {
+	if m.cfg.Host == "" {
+		return fmt.Errorf("mail: SMTP nicht konfiguriert (SMTP_HOST fehlt)")
+	}
+	addr := m.cfg.Host + ":" + m.cfg.Port
+	msg := fmt.Sprintf(
+		"From: %s\r\nTo: %s\r\nSubject: %s\r\nMIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\n\r\n%s",
+		m.cfg.From, to, subject, body,
+	)
+
+	var auth smtp.Auth
+	if m.cfg.User != "" {
+		auth = smtp.PlainAuth("", m.cfg.User, m.cfg.Password, m.cfg.Host)
+	}
+	if err := smtp.SendMail(addr, auth, m.cfg.From, []string{to}, []byte(msg)); err != nil {
+		return fmt.Errorf("mail: senden an %s: %w", to, err)
+	}
+	return nil
+}
+
+// SentMail protokolliert einen Versand für Tests.
+type SentMail struct {
+	To, Subject, Body string
+}
+
+// FakeMailer ist das Test-Doppel für Mailer — sammelt gesendete Mails
+// statt sie zu verschicken.
+type FakeMailer struct {
+	Sent []SentMail
+}
+
+func (f *FakeMailer) Send(to, subject, body string) error {
+	f.Sent = append(f.Sent, SentMail{To: to, Subject: subject, Body: body})
+	return nil
+}

internal/rules/evaluate.go

@@ -194,7 +194,10 @@ type WerkzeugEigenschaften struct {
 	Verarbeitungslaender []string
 	TrainingOptOut       bool
 	TrainingStandard     bool
-	AufbewahrungTage     int
+	// AufbewahrungTage ist nil, wenn der Anbieter keine Aufbewahrungsdauer
+	// beziffert — das erfüllt eine gesetzte Löschfrist-Anforderung NICHT
+	// (fail closed), analog zur leeren Länderliste bei eu_verarbeitung.
+	AufbewahrungTage *int
 }
 
 // euEwrLaender sind die Staaten, für die eine Verarbeitung nicht als
@@ -234,10 +237,15 @@ func alleLaenderInEUEWR(laender []string) bool {
 // Werkzeug-Eigenschaft betreffen (menschliche Aufsicht, Kennzeichnung,
 // DSFA) werden hier nicht hart gefiltert — sie werden als Auflage
 // vermerkt (spätere Ausbaustufe), nicht als Ausschlussgrund für das
-// Werkzeug selbst. loeschfrist_max_tage hat noch keine fachlich
-// festgelegten Tageswerte (rules/OPEN.md, Punkt 4) und wird deshalb
-// ebenfalls noch nicht hart gefiltert.
-func ErfuelltAnforderung(anforderungID string, w WerkzeugEigenschaften) bool {
+// Werkzeug selbst.
+//
+// loeschfristMaxTage ist die vom Mandanten für die aktuelle Datenklasse
+// konfigurierte Frist (siehe store.LoeschfristEinstellung) — nil
+// bedeutet "für diesen Mandanten/diese Datenklasse nicht konfiguriert"
+// und wird NICHT hart gefiltert (Rückwärtskompatibilität, siehe
+// rules/OPEN.md, Punkt 4); ist eine Frist gesetzt, erfüllt ein Werkzeug
+// ohne bezifferte Aufbewahrungsdauer sie NICHT (fail closed).
+func ErfuelltAnforderung(anforderungID string, w WerkzeugEigenschaften, loeschfristMaxTage *int) bool {
 	switch anforderungID {
 	case "avv_erforderlich":
 		return w.AVVVerfuegbar
@@ -245,6 +253,14 @@ func ErfuelltAnforderung(anforderungID string, w WerkzeugEigenschaften) bool {
 		return alleLaenderInEUEWR(w.Verarbeitungslaender)
 	case "kein_training_auf_eingabe":
 		return w.TrainingStandard
+	case "loeschfrist_max_tage":
+		if loeschfristMaxTage == nil {
+			return true
+		}
+		if w.AufbewahrungTage == nil {
+			return false
+		}
+		return *w.AufbewahrungTage <= *loeschfristMaxTage
 	default:
 		return true
 	}
@@ -266,12 +282,13 @@ type WerkzeugKandidat struct {
 
 // FilterWerkzeuge sortiert Werkzeuge aus, die mindestens eine
 // Pflichtanforderung nicht erfüllen, und hält für jedes ausgeschlossene
-// Werkzeug fest, welche Anforderungen fehlten.
-func FilterWerkzeuge(kandidaten []WerkzeugKandidat, anforderungIDs []string) (zulaessig []string, ausgeschlossen []AusschlussGrund) {
+// Werkzeug fest, welche Anforderungen fehlten. loeschfristMaxTage siehe
+// ErfuelltAnforderung.
+func FilterWerkzeuge(kandidaten []WerkzeugKandidat, anforderungIDs []string, loeschfristMaxTage *int) (zulaessig []string, ausgeschlossen []AusschlussGrund) {
 	for _, k := range kandidaten {
 		var fehlend []string
 		for _, reqID := range anforderungIDs {
-			if !ErfuelltAnforderung(reqID, k.Eigenschaften) {
+			if !ErfuelltAnforderung(reqID, k.Eigenschaften, loeschfristMaxTage) {
 				fehlend = append(fehlend, reqID)
 			}
 		}

internal/rules/evaluate_test.go

@@ -150,31 +150,52 @@ func TestDeriveAnforderungenHochrisikoAddsAufsichtUndDsfa(t *testing.T) {
 }
 
 func TestErfuelltAnforderungAVV(t *testing.T) {
-	if rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: false}) {
+	if rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: false}, nil) {
 		t.Error("erwartet: nicht erfuellt ohne AVV")
 	}
-	if !rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: true}) {
+	if !rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: true}, nil) {
 		t.Error("erwartet: erfuellt mit AVV")
 	}
 }
 
 func TestErfuelltAnforderungEUVerarbeitung(t *testing.T) {
-	if !rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland"}}) {
+	if !rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland"}}, nil) {
 		t.Error("erwartet: erfuellt bei einem einzelnen EU/EWR-Land")
 	}
-	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"USA"}}) {
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"USA"}}, nil) {
 		t.Error("erwartet: nicht erfuellt bei USA - die USA sind ein Drittland wie jedes andere")
 	}
-	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland", "USA"}}) {
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland", "USA"}}, nil) {
 		t.Error("erwartet: nicht erfuellt, sobald auch nur ein Land nicht EU/EWR ist")
 	}
-	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{}) {
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{}, nil) {
 		t.Error("erwartet: nicht erfuellt ohne benanntes Land - 'wissen wir nicht' darf nicht als 'ist okay' durchgehen")
 	}
 }
 
+func TestErfuelltAnforderungLoeschfrist(t *testing.T) {
+	dreissig := 30
+	neunzig := 90
+	// Keine Frist konfiguriert -> nicht hart gefiltert (Rückwärtskompatibilität).
+	if !rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{}, nil) {
+		t.Error("erwartet: erfuellt ohne konfigurierte Frist")
+	}
+	// Frist gesetzt, Werkzeug bleibt innerhalb -> erfuellt.
+	if !rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{AufbewahrungTage: &dreissig}, &neunzig) {
+		t.Error("erwartet: erfuellt, wenn Aufbewahrung <= Frist")
+	}
+	// Frist gesetzt, Werkzeug überschreitet -> nicht erfuellt.
+	if rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{AufbewahrungTage: &neunzig}, &dreissig) {
+		t.Error("erwartet: nicht erfuellt, wenn Aufbewahrung > Frist")
+	}
+	// Frist gesetzt, Werkzeug beziffert Aufbewahrung nicht -> fail closed.
+	if rules.ErfuelltAnforderung("loeschfrist_max_tage", rules.WerkzeugEigenschaften{}, &dreissig) {
+		t.Error("erwartet: nicht erfuellt, wenn Aufbewahrungsdauer unbekannt ist ('wissen wir nicht' darf nicht als 'ist okay' durchgehen)")
+	}
+}
+
 func TestErfuelltAnforderungUnbekannteAnforderungIstUnkritisch(t *testing.T) {
-	if !rules.ErfuelltAnforderung("menschliche_aufsicht", rules.WerkzeugEigenschaften{}) {
+	if !rules.ErfuelltAnforderung("menschliche_aufsicht", rules.WerkzeugEigenschaften{}, nil) {
 		t.Error("Prozess-Anforderungen duerfen ein Werkzeug nicht hart aussortieren")
 	}
 }
@@ -184,7 +205,7 @@ func TestFilterWerkzeugeSortsOutMissingAVV(t *testing.T) {
 		{ID: "mit-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: true, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
 		{ID: "ohne-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: false, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
 	}
-	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, []string{"avv_erforderlich"})
+	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, []string{"avv_erforderlich"}, nil)
 	if len(zulaessig) != 1 || zulaessig[0] != "mit-avv" {
 		t.Fatalf("zulaessig = %v, want [mit-avv]", zulaessig)
 	}
@@ -198,7 +219,7 @@ func TestFilterWerkzeugeSortsOutMissingAVV(t *testing.T) {
 
 func TestFilterWerkzeugeNoRequirementsAllowsEverything(t *testing.T) {
 	kandidaten := []rules.WerkzeugKandidat{{ID: "x"}, {ID: "y"}}
-	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, nil)
+	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, nil, nil)
 	if len(zulaessig) != 2 || len(ausgeschlossen) != 0 {
 		t.Fatalf("zulaessig=%v ausgeschlossen=%v, want beide zulaessig", zulaessig, ausgeschlossen)
 	}

internal/store/freigabe.go

@@ -0,0 +1,388 @@
+// Konfigurierbarer Mehrfach-Freigabe-Workflow — siehe Migration 0017
+// und CLAUDE.md. GenehmigerRolle ist eine reine Freigabe-Funktion
+// (z. B. "Datenschutzbeauftragter", "Geschäftsführung"), unabhängig von
+// app_user.role (Zugriffskontrolle) — eine Person kann beides zugleich
+// sein oder keines von beidem.
+package store
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+type GenehmigerRolle struct {
+	ID           string
+	AccountID    string
+	Name         string
+	Beschreibung string
+	CreatedAt    time.Time
+}
+
+// CreateGenehmigerRolle legt eine neue Freigabe-Funktion für einen
+// Mandanten an. Beschreibung ist reiner Freitext zur Orientierung des
+// Admins (z. B. "Prüft den Antrag aus Sicherheitssicht") — bindet keine
+// Bedingung, das bleibt Sache von freigabe_regel.
+func (s *Store) CreateGenehmigerRolle(ctx context.Context, accountID, name, beschreibung string) (GenehmigerRolle, error) {
+	var g GenehmigerRolle
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO genehmiger_rolle (account_id, name, beschreibung) VALUES ($1, $2, $3)
+		RETURNING id, account_id, name, beschreibung, created_at
+	`, accountID, name, beschreibung).Scan(&g.ID, &g.AccountID, &g.Name, &g.Beschreibung, &g.CreatedAt)
+	if err != nil {
+		return GenehmigerRolle{}, fmt.Errorf("store: create genehmiger rolle: %w", err)
+	}
+	return g, nil
+}
+
+// GetGenehmigerRolle liest eine Genehmiger-Rolle anhand ihrer ID.
+func (s *Store) GetGenehmigerRolle(ctx context.Context, id string) (GenehmigerRolle, error) {
+	var g GenehmigerRolle
+	err := s.Pool.QueryRow(ctx, `
+		SELECT id, account_id, name, beschreibung, created_at FROM genehmiger_rolle WHERE id = $1
+	`, id).Scan(&g.ID, &g.AccountID, &g.Name, &g.Beschreibung, &g.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return GenehmigerRolle{}, ErrNotFound
+	}
+	if err != nil {
+		return GenehmigerRolle{}, fmt.Errorf("store: get genehmiger rolle: %w", err)
+	}
+	return g, nil
+}
+
+// ListGenehmigerRollenForAccount liefert alle Genehmiger-Rollen eines
+// Mandanten.
+func (s *Store) ListGenehmigerRollenForAccount(ctx context.Context, accountID string) ([]GenehmigerRolle, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, account_id, name, beschreibung, created_at FROM genehmiger_rolle
+		WHERE account_id = $1 ORDER BY name
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list genehmiger rollen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []GenehmigerRolle
+	for rows.Next() {
+		var g GenehmigerRolle
+		if err := rows.Scan(&g.ID, &g.AccountID, &g.Name, &g.Beschreibung, &g.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan genehmiger rolle: %w", err)
+		}
+		out = append(out, g)
+	}
+	return out, rows.Err()
+}
+
+// DeleteGenehmigerRolle entfernt eine Genehmiger-Rolle. Zuordnungen
+// (nutzer_genehmiger_rolle) und darauf verweisende Freigabe-Regeln
+// hängen per Fremdschlüssel daran — der Aufrufer muss sie vorher
+// entfernen, sonst schlägt das DELETE fehl (bewusst kein CASCADE: ein
+// stillschweigendes Mit-Löschen von Freigabe-Regeln wäre überraschend).
+func (s *Store) DeleteGenehmigerRolle(ctx context.Context, id string) error {
+	tag, err := s.Pool.Exec(ctx, `DELETE FROM genehmiger_rolle WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("store: delete genehmiger rolle: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// AddNutzerGenehmigerRolle weist einer Person eine Genehmiger-Rolle zu.
+func (s *Store) AddNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error {
+	_, err := s.Pool.Exec(ctx, `
+		INSERT INTO nutzer_genehmiger_rolle (app_user_id, genehmiger_rolle_id) VALUES ($1, $2)
+		ON CONFLICT (app_user_id, genehmiger_rolle_id) DO NOTHING
+	`, userID, genehmigerRolleID)
+	if err != nil {
+		return fmt.Errorf("store: add nutzer genehmiger rolle: %w", err)
+	}
+	return nil
+}
+
+// RemoveNutzerGenehmigerRolle entzieht einer Person eine Genehmiger-Rolle.
+func (s *Store) RemoveNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error {
+	_, err := s.Pool.Exec(ctx, `
+		DELETE FROM nutzer_genehmiger_rolle WHERE app_user_id = $1 AND genehmiger_rolle_id = $2
+	`, userID, genehmigerRolleID)
+	if err != nil {
+		return fmt.Errorf("store: remove nutzer genehmiger rolle: %w", err)
+	}
+	return nil
+}
+
+// ListGenehmigerRollenForUser liefert alle Genehmiger-Rollen einer
+// Person — Grundlage dafür, ob und was sie unter "Meine Freigaben" sieht.
+func (s *Store) ListGenehmigerRollenForUser(ctx context.Context, userID string) ([]GenehmigerRolle, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT gr.id, gr.account_id, gr.name, gr.created_at
+		FROM genehmiger_rolle gr
+		JOIN nutzer_genehmiger_rolle ngr ON ngr.genehmiger_rolle_id = gr.id
+		WHERE ngr.app_user_id = $1
+		ORDER BY gr.name
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list genehmiger rollen for user: %w", err)
+	}
+	defer rows.Close()
+
+	var out []GenehmigerRolle
+	for rows.Next() {
+		var g GenehmigerRolle
+		if err := rows.Scan(&g.ID, &g.AccountID, &g.Name, &g.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan genehmiger rolle: %w", err)
+		}
+		out = append(out, g)
+	}
+	return out, rows.Err()
+}
+
+// GenehmigerMitglied ist ein Nutzer, der eine bestimmte Genehmiger-Rolle
+// innehat — für die Anzeige "wer hat diese Rolle" auf der Verwaltungsseite.
+type GenehmigerMitglied struct {
+	UserID string
+	Email  string
+}
+
+// ListNutzerForGenehmigerRolle liefert alle Personen mit einer
+// bestimmten Genehmiger-Rolle.
+func (s *Store) ListNutzerForGenehmigerRolle(ctx context.Context, genehmigerRolleID string) ([]GenehmigerMitglied, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT u.id, u.email
+		FROM app_user u
+		JOIN nutzer_genehmiger_rolle ngr ON ngr.app_user_id = u.id
+		WHERE ngr.genehmiger_rolle_id = $1
+		ORDER BY u.email
+	`, genehmigerRolleID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list nutzer for genehmiger rolle: %w", err)
+	}
+	defer rows.Close()
+
+	var out []GenehmigerMitglied
+	for rows.Next() {
+		var m GenehmigerMitglied
+		if err := rows.Scan(&m.UserID, &m.Email); err != nil {
+			return nil, fmt.Errorf("store: scan genehmiger mitglied: %w", err)
+		}
+		out = append(out, m)
+	}
+	return out, rows.Err()
+}
+
+// FreigabeRegel: "wenn Bedingung X zutrifft, ist zusätzlich eine
+// Freigabe durch GenehmigerRolleID nötig." BedingungTyp ist eine von
+// "anforderung"/"einstufung"/"datenklasse", BedingungWert die jeweilige
+// ID aus dem Regelwerk (z. B. "dsfa_erforderlich", "hochrisiko").
+type FreigabeRegel struct {
+	ID                string
+	AccountID         string
+	BedingungTyp      string
+	BedingungWert     string
+	GenehmigerRolleID string
+	CreatedAt         time.Time
+}
+
+func (s *Store) CreateFreigabeRegel(ctx context.Context, accountID, bedingungTyp, bedingungWert, genehmigerRolleID string) (FreigabeRegel, error) {
+	var f FreigabeRegel
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO freigabe_regel (account_id, bedingung_typ, bedingung_wert, genehmiger_rolle_id)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id, account_id, bedingung_typ, bedingung_wert, genehmiger_rolle_id, created_at
+	`, accountID, bedingungTyp, bedingungWert, genehmigerRolleID).Scan(
+		&f.ID, &f.AccountID, &f.BedingungTyp, &f.BedingungWert, &f.GenehmigerRolleID, &f.CreatedAt,
+	)
+	if err != nil {
+		return FreigabeRegel{}, fmt.Errorf("store: create freigabe regel: %w", err)
+	}
+	return f, nil
+}
+
+func (s *Store) ListFreigabeRegelnForAccount(ctx context.Context, accountID string) ([]FreigabeRegel, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, account_id, bedingung_typ, bedingung_wert, genehmiger_rolle_id, created_at
+		FROM freigabe_regel WHERE account_id = $1 ORDER BY created_at
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list freigabe regeln: %w", err)
+	}
+	defer rows.Close()
+
+	var out []FreigabeRegel
+	for rows.Next() {
+		var f FreigabeRegel
+		if err := rows.Scan(&f.ID, &f.AccountID, &f.BedingungTyp, &f.BedingungWert, &f.GenehmigerRolleID, &f.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan freigabe regel: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
+func (s *Store) DeleteFreigabeRegel(ctx context.Context, id string) error {
+	tag, err := s.Pool.Exec(ctx, `DELETE FROM freigabe_regel WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("store: delete freigabe regel: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// GetFreigabeRegel liest eine einzelne Freigabe-Regel — genutzt, um
+// beim Löschen den Mandanten gegen den angemeldeten Account zu prüfen.
+func (s *Store) GetFreigabeRegel(ctx context.Context, id string) (FreigabeRegel, error) {
+	var f FreigabeRegel
+	err := s.Pool.QueryRow(ctx, `
+		SELECT id, account_id, bedingung_typ, bedingung_wert, genehmiger_rolle_id, created_at
+		FROM freigabe_regel WHERE id = $1
+	`, id).Scan(&f.ID, &f.AccountID, &f.BedingungTyp, &f.BedingungWert, &f.GenehmigerRolleID, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return FreigabeRegel{}, ErrNotFound
+	}
+	if err != nil {
+		return FreigabeRegel{}, fmt.Errorf("store: get freigabe regel: %w", err)
+	}
+	return f, nil
+}
+
+// Freigabeschritt ist eine einzelne, durch eine FreigabeRegel
+// ausgelöste Freigabe-Aufgabe für einen konkreten Antrag. Nicht
+// append-only — ein Schritt geht von "ausstehend" in genau einen
+// Endzustand über, keine Historie mehrerer Entscheidungen zum selben
+// Schritt.
+type Freigabeschritt struct {
+	ID                string
+	AntragID          string
+	GenehmigerRolleID string
+	Status            string // ausstehend/genehmigt/abgelehnt
+	EntschiedenVon    *string
+	EntschiedenAm     *time.Time
+	Kommentar         string
+	CreatedAt         time.Time
+}
+
+func (s *Store) CreateFreigabeschritt(ctx context.Context, antragID, genehmigerRolleID string) (Freigabeschritt, error) {
+	var f Freigabeschritt
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO freigabeschritt (antrag_id, genehmiger_rolle_id) VALUES ($1, $2)
+		RETURNING id, antrag_id, genehmiger_rolle_id, status, entschieden_von, entschieden_am, kommentar, created_at
+	`, antragID, genehmigerRolleID).Scan(
+		&f.ID, &f.AntragID, &f.GenehmigerRolleID, &f.Status, &f.EntschiedenVon, &f.EntschiedenAm, &f.Kommentar, &f.CreatedAt,
+	)
+	if err != nil {
+		return Freigabeschritt{}, fmt.Errorf("store: create freigabeschritt: %w", err)
+	}
+	return f, nil
+}
+
+func (s *Store) GetFreigabeschritt(ctx context.Context, id string) (Freigabeschritt, error) {
+	var f Freigabeschritt
+	err := s.Pool.QueryRow(ctx, `
+		SELECT id, antrag_id, genehmiger_rolle_id, status, entschieden_von, entschieden_am, kommentar, created_at
+		FROM freigabeschritt WHERE id = $1
+	`, id).Scan(&f.ID, &f.AntragID, &f.GenehmigerRolleID, &f.Status, &f.EntschiedenVon, &f.EntschiedenAm, &f.Kommentar, &f.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Freigabeschritt{}, ErrNotFound
+	}
+	if err != nil {
+		return Freigabeschritt{}, fmt.Errorf("store: get freigabeschritt: %w", err)
+	}
+	return f, nil
+}
+
+func (s *Store) ListFreigabeschritteForAntrag(ctx context.Context, antragID string) ([]Freigabeschritt, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, antrag_id, genehmiger_rolle_id, status, entschieden_von, entschieden_am, kommentar, created_at
+		FROM freigabeschritt WHERE antrag_id = $1 ORDER BY created_at
+	`, antragID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list freigabeschritte for antrag: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Freigabeschritt
+	for rows.Next() {
+		var f Freigabeschritt
+		if err := rows.Scan(&f.ID, &f.AntragID, &f.GenehmigerRolleID, &f.Status, &f.EntschiedenVon, &f.EntschiedenAm, &f.Kommentar, &f.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan freigabeschritt: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
+// ListAusstehendeFreigabeschritteForUser liefert alle offenen
+// Freigabeschritte über JEDE Genehmiger-Rolle, die diese Person
+// innehat — Grundlage für "Meine Freigaben".
+func (s *Store) ListAusstehendeFreigabeschritteForUser(ctx context.Context, userID string) ([]Freigabeschritt, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT f.id, f.antrag_id, f.genehmiger_rolle_id, f.status, f.entschieden_von, f.entschieden_am, f.kommentar, f.created_at
+		FROM freigabeschritt f
+		JOIN nutzer_genehmiger_rolle ngr ON ngr.genehmiger_rolle_id = f.genehmiger_rolle_id
+		WHERE ngr.app_user_id = $1 AND f.status = 'ausstehend'
+		ORDER BY f.created_at
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list ausstehende freigabeschritte: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Freigabeschritt
+	for rows.Next() {
+		var f Freigabeschritt
+		if err := rows.Scan(&f.ID, &f.AntragID, &f.GenehmigerRolleID, &f.Status, &f.EntschiedenVon, &f.EntschiedenAm, &f.Kommentar, &f.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan freigabeschritt: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
+// EntscheideFreigabeschritt trägt die Entscheidung einer Person zu
+// einem einzelnen Freigabeschritt ein. Nur von "ausstehend" aus
+// erlaubt — der Aufrufer prüft das vorher (ErrNotFound bei bereits
+// entschiedenen Schritten wäre irreführend, deshalb hier ein
+// generischer Fehler statt eines Sentinels).
+func (s *Store) EntscheideFreigabeschritt(ctx context.Context, id, status, entschiedenVon, kommentar string) (Freigabeschritt, error) {
+	var f Freigabeschritt
+	err := s.Pool.QueryRow(ctx, `
+		UPDATE freigabeschritt
+		SET status = $2, entschieden_von = $3, entschieden_am = now(), kommentar = $4
+		WHERE id = $1 AND status = 'ausstehend'
+		RETURNING id, antrag_id, genehmiger_rolle_id, status, entschieden_von, entschieden_am, kommentar, created_at
+	`, id, status, entschiedenVon, kommentar).Scan(
+		&f.ID, &f.AntragID, &f.GenehmigerRolleID, &f.Status, &f.EntschiedenVon, &f.EntschiedenAm, &f.Kommentar, &f.CreatedAt,
+	)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Freigabeschritt{}, ErrNotFound
+	}
+	if err != nil {
+		return Freigabeschritt{}, fmt.Errorf("store: entscheide freigabeschritt: %w", err)
+	}
+	return f, nil
+}
+
+// KaskadiereAblehnung lehnt alle noch ausstehenden Freigabeschritte
+// eines Antrags automatisch ab, nachdem ein anderer Schritt desselben
+// Antrags bereits abgelehnt wurde — eine einzelne Ablehnung kippt den
+// gesamten Antrag, die übrigen offenen Freigaben werden dadurch
+// gegenstandslos statt für immer in fremden "Meine Freigaben"-Listen
+// hängen zu bleiben.
+func (s *Store) KaskadiereAblehnung(ctx context.Context, antragID, ausloesenderSchrittID string) error {
+	_, err := s.Pool.Exec(ctx, `
+		UPDATE freigabeschritt
+		SET status = 'abgelehnt', entschieden_am = now(),
+			kommentar = 'Automatisch abgelehnt, da eine andere erforderliche Freigabe für diesen Antrag abgelehnt wurde.'
+		WHERE antrag_id = $1 AND status = 'ausstehend' AND id != $2
+	`, antragID, ausloesenderSchrittID)
+	if err != nil {
+		return fmt.Errorf("store: kaskadiere ablehnung: %w", err)
+	}
+	return nil
+}

internal/store/freigabe_test.go

@@ -0,0 +1,174 @@
+package store_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func TestGenehmigerRolleCRUDAndMitgliedschaft(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+
+	g, err := s.CreateGenehmigerRolle(ctx, accID, "Datenschutzbeauftragter", "")
+	if err != nil {
+		t.Fatalf("CreateGenehmigerRolle: %v", err)
+	}
+	if g.AccountID != accID || g.Name != "Datenschutzbeauftragter" {
+		t.Fatalf("GenehmigerRolle = %+v, unerwartete Werte", g)
+	}
+
+	got, err := s.GetGenehmigerRolle(ctx, g.ID)
+	if err != nil || got.Name != "Datenschutzbeauftragter" {
+		t.Fatalf("GetGenehmigerRolle = %+v, err=%v", got, err)
+	}
+
+	liste, err := s.ListGenehmigerRollenForAccount(ctx, accID)
+	if err != nil || len(liste) != 1 {
+		t.Fatalf("ListGenehmigerRollenForAccount = %+v, err=%v", liste, err)
+	}
+
+	user := testUserID(t, s, accID)
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle: %v", err)
+	}
+	// Erneutes Hinzufügen derselben Zuordnung ist ein No-op (ON CONFLICT),
+	// kein Fehler.
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle (erneut): %v", err)
+	}
+
+	rollenDesNutzers, err := s.ListGenehmigerRollenForUser(ctx, user)
+	if err != nil || len(rollenDesNutzers) != 1 || rollenDesNutzers[0].ID != g.ID {
+		t.Fatalf("ListGenehmigerRollenForUser = %+v, err=%v", rollenDesNutzers, err)
+	}
+
+	mitglieder, err := s.ListNutzerForGenehmigerRolle(ctx, g.ID)
+	if err != nil || len(mitglieder) != 1 || mitglieder[0].UserID != user {
+		t.Fatalf("ListNutzerForGenehmigerRolle = %+v, err=%v", mitglieder, err)
+	}
+
+	if err := s.RemoveNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("RemoveNutzerGenehmigerRolle: %v", err)
+	}
+	rollenNachEntfernen, err := s.ListGenehmigerRollenForUser(ctx, user)
+	if err != nil || len(rollenNachEntfernen) != 0 {
+		t.Fatalf("ListGenehmigerRollenForUser nach Entfernen = %+v, err=%v", rollenNachEntfernen, err)
+	}
+
+	if err := s.DeleteGenehmigerRolle(ctx, g.ID); err != nil {
+		t.Fatalf("DeleteGenehmigerRolle: %v", err)
+	}
+	if _, err := s.GetGenehmigerRolle(ctx, g.ID); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err nach Delete = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFreigabeRegelCRUD(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	g, err := s.CreateGenehmigerRolle(ctx, accID, "Geschaeftsfuehrung", "")
+	if err != nil {
+		t.Fatalf("CreateGenehmigerRolle: %v", err)
+	}
+
+	regel, err := s.CreateFreigabeRegel(ctx, accID, "einstufung", "hochrisiko", g.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeRegel: %v", err)
+	}
+	if regel.BedingungTyp != "einstufung" || regel.BedingungWert != "hochrisiko" {
+		t.Fatalf("FreigabeRegel = %+v, unerwartete Werte", regel)
+	}
+
+	liste, err := s.ListFreigabeRegelnForAccount(ctx, accID)
+	if err != nil || len(liste) != 1 {
+		t.Fatalf("ListFreigabeRegelnForAccount = %+v, err=%v", liste, err)
+	}
+
+	got, err := s.GetFreigabeRegel(ctx, regel.ID)
+	if err != nil || got.ID != regel.ID {
+		t.Fatalf("GetFreigabeRegel = %+v, err=%v", got, err)
+	}
+
+	if err := s.DeleteFreigabeRegel(ctx, regel.ID); err != nil {
+		t.Fatalf("DeleteFreigabeRegel: %v", err)
+	}
+	if _, err := s.GetFreigabeRegel(ctx, regel.ID); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err nach Delete = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFreigabeschrittLifecycleUndKaskade(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	user := testUserID(t, s, accID)
+	antrag, err := s.CreateAntrag(ctx, accID, user, nil, "Test-Antrag für Freigabeschritte")
+	if err != nil {
+		t.Fatalf("CreateAntrag: %v", err)
+	}
+	antragID := antrag.ID
+
+	dsb, _ := s.CreateGenehmigerRolle(ctx, accID, "Datenschutzbeauftragter", "")
+	gf, _ := s.CreateGenehmigerRolle(ctx, accID, "Geschaeftsfuehrung", "")
+
+	schrittDSB, err := s.CreateFreigabeschritt(ctx, antragID, dsb.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeschritt: %v", err)
+	}
+	if schrittDSB.Status != "ausstehend" {
+		t.Fatalf("Status = %q, want ausstehend", schrittDSB.Status)
+	}
+	schrittGF, err := s.CreateFreigabeschritt(ctx, antragID, gf.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeschritt: %v", err)
+	}
+
+	alle, err := s.ListFreigabeschritteForAntrag(ctx, antragID)
+	if err != nil || len(alle) != 2 {
+		t.Fatalf("ListFreigabeschritteForAntrag = %+v, err=%v", alle, err)
+	}
+
+	ausstehend, err := s.ListAusstehendeFreigabeschritteForUser(ctx, user)
+	if err != nil {
+		t.Fatalf("ListAusstehendeFreigabeschritteForUser: %v", err)
+	}
+	if len(ausstehend) != 0 {
+		t.Fatalf("erwartet 0 ausstehende Freigaben ohne Genehmiger-Rollen-Zuordnung, got %d", len(ausstehend))
+	}
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, dsb.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle: %v", err)
+	}
+	ausstehend, err = s.ListAusstehendeFreigabeschritteForUser(ctx, user)
+	if err != nil || len(ausstehend) != 1 || ausstehend[0].ID != schrittDSB.ID {
+		t.Fatalf("ListAusstehendeFreigabeschritteForUser = %+v, err=%v", ausstehend, err)
+	}
+
+	entschieden, err := s.EntscheideFreigabeschritt(ctx, schrittDSB.ID, "abgelehnt", user, "nicht ausreichend")
+	if err != nil {
+		t.Fatalf("EntscheideFreigabeschritt: %v", err)
+	}
+	if entschieden.Status != "abgelehnt" || entschieden.EntschiedenVon == nil || *entschieden.EntschiedenVon != user {
+		t.Fatalf("Freigabeschritt nach Entscheidung = %+v, unerwartete Werte", entschieden)
+	}
+
+	// Ein bereits entschiedener Schritt kann nicht erneut entschieden werden.
+	if _, err := s.EntscheideFreigabeschritt(ctx, schrittDSB.ID, "genehmigt", user, ""); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("erneute Entscheidung err = %v, want ErrNotFound", err)
+	}
+
+	if err := s.KaskadiereAblehnung(ctx, antragID, schrittDSB.ID); err != nil {
+		t.Fatalf("KaskadiereAblehnung: %v", err)
+	}
+	nachKaskade, err := s.GetFreigabeschritt(ctx, schrittGF.ID)
+	if err != nil {
+		t.Fatalf("GetFreigabeschritt: %v", err)
+	}
+	if nachKaskade.Status != "abgelehnt" {
+		t.Fatalf("Status nach Kaskade = %q, want abgelehnt", nachKaskade.Status)
+	}
+}

internal/store/loeschfrist.go

@@ -0,0 +1,69 @@
+// Löschfristen je Datenklasse (Migration 0020) — schließt die in
+// rules/OPEN.md, Punkt 4 dokumentierte Lücke: loeschfrist_max_tage war
+// bisher nur als Anforderung "vorhanden", ohne Tageswerte, und wurde
+// deshalb nicht hart gefiltert. Die konkreten Tageswerte sind KEINE
+// gesetzliche Vorgabe (die DSGVO nennt keine festen Fristen, nur den
+// Grundsatz "so lange wie für den Zweck nötig", Art. 5 Abs. 1 lit. e) —
+// deshalb pro Mandant einstellbar statt hartkodiert, vom
+// Datenschutzbeauftragten hinterlegt. Bei Firmenanlage werden
+// risikogestaffelte Vorschlagswerte vorbelegt (siehe
+// internal/web/loeschfrist_handlers.go), frei editierbar.
+package store
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+type LoeschfristEinstellung struct {
+	ID            string
+	AccountID     string
+	DatenklasseID string
+	MaxTage       int
+	UpdatedAt     time.Time
+}
+
+// UpsertLoeschfristEinstellung legt eine Einstellung an oder
+// aktualisiert sie — ein Mandant hat höchstens eine Frist je
+// Datenklasse (UNIQUE-Constraint).
+func (s *Store) UpsertLoeschfristEinstellung(ctx context.Context, accountID, datenklasseID string, maxTage int) (LoeschfristEinstellung, error) {
+	var e LoeschfristEinstellung
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO loeschfrist_einstellung (account_id, datenklasse_id, max_tage)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (account_id, datenklasse_id)
+		DO UPDATE SET max_tage = $3, updated_at = now()
+		RETURNING id, account_id, datenklasse_id, max_tage, updated_at
+	`, accountID, datenklasseID, maxTage).Scan(&e.ID, &e.AccountID, &e.DatenklasseID, &e.MaxTage, &e.UpdatedAt)
+	if err != nil {
+		return LoeschfristEinstellung{}, fmt.Errorf("store: upsert loeschfrist einstellung: %w", err)
+	}
+	return e, nil
+}
+
+// ListLoeschfristEinstellungenForAccount liefert alle konfigurierten
+// Fristen eines Mandanten.
+func (s *Store) ListLoeschfristEinstellungenForAccount(ctx context.Context, accountID string) ([]LoeschfristEinstellung, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, account_id, datenklasse_id, max_tage, updated_at
+		FROM loeschfrist_einstellung WHERE account_id = $1 ORDER BY datenklasse_id
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list loeschfrist einstellungen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []LoeschfristEinstellung
+	for rows.Next() {
+		var e LoeschfristEinstellung
+		if err := rows.Scan(&e.ID, &e.AccountID, &e.DatenklasseID, &e.MaxTage, &e.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan loeschfrist einstellung: %w", err)
+		}
+		out = append(out, e)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list loeschfrist einstellungen: %w", err)
+	}
+	return out, nil
+}

internal/store/loeschfrist_test.go

@@ -0,0 +1,41 @@
+package store_test
+
+import (
+	"context"
+	"testing"
+)
+
+func TestLoeschfristEinstellungUpsert(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+
+	e, err := s.UpsertLoeschfristEinstellung(ctx, accID, "personenbezogen", 90)
+	if err != nil {
+		t.Fatalf("UpsertLoeschfristEinstellung: %v", err)
+	}
+	if e.MaxTage != 90 {
+		t.Fatalf("MaxTage = %d, want 90", e.MaxTage)
+	}
+
+	// Erneutes Upsert für dieselbe Datenklasse überschreibt statt zu duplizieren.
+	if _, err := s.UpsertLoeschfristEinstellung(ctx, accID, "personenbezogen", 30); err != nil {
+		t.Fatalf("UpsertLoeschfristEinstellung (Update): %v", err)
+	}
+	if _, err := s.UpsertLoeschfristEinstellung(ctx, accID, "besondere_kategorie", 14); err != nil {
+		t.Fatalf("UpsertLoeschfristEinstellung: %v", err)
+	}
+
+	liste, err := s.ListLoeschfristEinstellungenForAccount(ctx, accID)
+	if err != nil {
+		t.Fatalf("ListLoeschfristEinstellungenForAccount: %v", err)
+	}
+	if len(liste) != 2 {
+		t.Fatalf("got %d Einstellungen, want 2 (Upsert darf nicht duplizieren)", len(liste))
+	}
+	for _, e := range liste {
+		if e.DatenklasseID == "personenbezogen" && e.MaxTage != 30 {
+			t.Fatalf("personenbezogen MaxTage = %d, want 30 nach Update", e.MaxTage)
+		}
+	}
+}

internal/store/migrations/0017_freigabeworkflow.down.sql

@@ -0,0 +1,9 @@
+ALTER TABLE antrag DROP CONSTRAINT antrag_status_check;
+UPDATE antrag SET status = 'eingereicht' WHERE status = 'wartet_auf_freigabe';
+ALTER TABLE antrag ADD CONSTRAINT antrag_status_check
+  CHECK (status IN ('entwurf', 'eingereicht', 'entschieden'));
+
+DROP TABLE freigabeschritt;
+DROP TABLE freigabe_regel;
+DROP TABLE nutzer_genehmiger_rolle;
+DROP TABLE genehmiger_rolle;

internal/store/migrations/0017_freigabeworkflow.up.sql

@@ -0,0 +1,59 @@
+-- Konfigurierbarer Mehrfach-Freigabe-Workflow (2026-08-31): manche
+-- Anträge brauchen zusätzlich zur normalen Fachebene-Entscheidung eine
+-- Freigabe durch bestimmte Personen (z. B. Datenschutzbeauftragte bei
+-- dsfa_erforderlich, Geschäftsführung bei hochrisiko). Bewusst additiv
+-- zur bestehenden app_user.role (Zugriffskontrolle) — eine
+-- Genehmiger-Rolle ist eine reine Freigabe-Funktion, keine Berechtigung,
+-- und eine Person kann mehrere davon gleichzeitig innehaben.
+
+-- Stammdaten wie abteilung, pro Mandant frei benennbar.
+CREATE TABLE genehmiger_rolle (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    account_id UUID NOT NULL REFERENCES account (id),
+    name TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (account_id, name)
+);
+
+-- Welche Personen eine Genehmiger-Rolle innehaben (n:m).
+CREATE TABLE nutzer_genehmiger_rolle (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    app_user_id UUID NOT NULL REFERENCES app_user (id),
+    genehmiger_rolle_id UUID NOT NULL REFERENCES genehmiger_rolle (id),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (app_user_id, genehmiger_rolle_id)
+);
+
+-- "Wenn Bedingung X zutrifft, ist zusätzlich eine Freigabe durch
+-- Genehmiger-Rolle Y nötig." Bedingung ist bewusst eine der bereits vom
+-- Regelwerk abgeleiteten Größen (Anforderungs-ID, Einstufungs-ID,
+-- Datenklasse-ID) — kein freier Regel-Editor, keine beliebige Logik.
+CREATE TABLE freigabe_regel (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    account_id UUID NOT NULL REFERENCES account (id),
+    bedingung_typ TEXT NOT NULL CHECK (bedingung_typ IN ('anforderung', 'einstufung', 'datenklasse')),
+    bedingung_wert TEXT NOT NULL,
+    genehmiger_rolle_id UUID NOT NULL REFERENCES genehmiger_rolle (id),
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Pro Antrag ein Eintrag je durch eine Regel ausgelöster nötiger
+-- Freigabe. Nicht append-only (wie werkzeug) — ein Freigabeschritt ist
+-- eine einzelne Aufgabe, die von ausstehend in einen Endzustand
+-- übergeht, keine Historie mehrerer Entscheidungen zum selben Schritt.
+CREATE TABLE freigabeschritt (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    antrag_id UUID NOT NULL REFERENCES antrag (id),
+    genehmiger_rolle_id UUID NOT NULL REFERENCES genehmiger_rolle (id),
+    status TEXT NOT NULL DEFAULT 'ausstehend' CHECK (status IN ('ausstehend', 'genehmigt', 'abgelehnt')),
+    entschieden_von UUID REFERENCES app_user (id),
+    entschieden_am TIMESTAMPTZ,
+    kommentar TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Ein Antrag, der auf zusätzliche Freigaben wartet, ist weder "nur
+-- eingereicht" noch schon "entschieden" — eigener Zwischenzustand.
+ALTER TABLE antrag DROP CONSTRAINT antrag_status_check;
+ALTER TABLE antrag ADD CONSTRAINT antrag_status_check
+  CHECK (status IN ('entwurf', 'eingereicht', 'wartet_auf_freigabe', 'entschieden'));

internal/store/migrations/0018_genehmiger_rolle_beschreibung.down.sql

@@ -0,0 +1 @@
+ALTER TABLE genehmiger_rolle DROP COLUMN beschreibung;

internal/store/migrations/0018_genehmiger_rolle_beschreibung.up.sql

@@ -0,0 +1 @@
+ALTER TABLE genehmiger_rolle ADD COLUMN beschreibung TEXT NOT NULL DEFAULT '';

internal/store/migrations/0019_password_reset_token.down.sql

@@ -0,0 +1 @@
+DROP TABLE password_reset_token;

internal/store/migrations/0019_password_reset_token.up.sql

@@ -0,0 +1,10 @@
+CREATE TABLE password_reset_token (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID NOT NULL REFERENCES app_user(id),
+    token TEXT NOT NULL UNIQUE,
+    expires_at TIMESTAMPTZ NOT NULL,
+    used_at TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX password_reset_token_user_id_idx ON password_reset_token(user_id);

internal/store/migrations/0020_loeschfrist_einstellung.down.sql

@@ -0,0 +1 @@
+DROP TABLE loeschfrist_einstellung;

internal/store/migrations/0020_loeschfrist_einstellung.up.sql

@@ -0,0 +1,8 @@
+CREATE TABLE loeschfrist_einstellung (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    account_id UUID NOT NULL REFERENCES account(id),
+    datenklasse_id TEXT NOT NULL,
+    max_tage INTEGER NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    UNIQUE (account_id, datenklasse_id)
+);

internal/store/password_reset.go

@@ -0,0 +1,77 @@
+// Passwort-Zurücksetzen-Tokens (Migration 0019). Ein Token ist einmal
+// verwendbar (used_at) und läuft ab (expires_at) — GetValidPasswordResetToken
+// liefert ErrNotFound für "nicht gefunden", "abgelaufen" und "schon
+// verwendet" gleichermaßen, damit ein Angreifer über die Fehlermeldung
+// nichts über den Zustand eines geratenen Tokens lernt.
+package store
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// PasswordResetTokenDuration ist die Gültigkeitsdauer eines frisch
+// erzeugten Zurücksetzen-Links.
+const PasswordResetTokenDuration = 1 * time.Hour
+
+type PasswordResetToken struct {
+	ID        string
+	UserID    string
+	Token     string
+	ExpiresAt time.Time
+	UsedAt    *time.Time
+	CreatedAt time.Time
+}
+
+// CreatePasswordResetToken legt einen neuen Zurücksetzen-Token für
+// einen Nutzer an. token muss bereits kryptographisch zufällig erzeugt
+// sein (siehe auth.NewSessionToken) — store erzeugt keine Tokens selbst.
+func (s *Store) CreatePasswordResetToken(ctx context.Context, userID, token string) (PasswordResetToken, error) {
+	var t PasswordResetToken
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO password_reset_token (user_id, token, expires_at)
+		VALUES ($1, $2, $3)
+		RETURNING id, user_id, token, expires_at, used_at, created_at
+	`, userID, token, time.Now().Add(PasswordResetTokenDuration)).Scan(
+		&t.ID, &t.UserID, &t.Token, &t.ExpiresAt, &t.UsedAt, &t.CreatedAt,
+	)
+	if err != nil {
+		return PasswordResetToken{}, fmt.Errorf("store: create password reset token: %w", err)
+	}
+	return t, nil
+}
+
+// GetValidPasswordResetToken liest einen Token nur, wenn er existiert,
+// noch nicht abgelaufen und noch nicht verwendet ist.
+func (s *Store) GetValidPasswordResetToken(ctx context.Context, token string) (PasswordResetToken, error) {
+	var t PasswordResetToken
+	err := s.Pool.QueryRow(ctx, `
+		SELECT id, user_id, token, expires_at, used_at, created_at
+		FROM password_reset_token
+		WHERE token = $1 AND used_at IS NULL AND expires_at > now()
+	`, token).Scan(&t.ID, &t.UserID, &t.Token, &t.ExpiresAt, &t.UsedAt, &t.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return PasswordResetToken{}, ErrNotFound
+	}
+	if err != nil {
+		return PasswordResetToken{}, fmt.Errorf("store: get valid password reset token: %w", err)
+	}
+	return t, nil
+}
+
+// MarkPasswordResetTokenUsed verbraucht einen Token, damit derselbe
+// Link kein zweites Mal ein Passwort setzen kann.
+func (s *Store) MarkPasswordResetTokenUsed(ctx context.Context, id string) error {
+	tag, err := s.Pool.Exec(ctx, `UPDATE password_reset_token SET used_at = now() WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("store: mark password reset token used: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}

internal/store/password_reset_test.go

@@ -0,0 +1,58 @@
+package store_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func TestPasswordResetTokenLifecycle(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+
+	tok, err := s.CreatePasswordResetToken(ctx, userID, "test-token-123")
+	if err != nil {
+		t.Fatalf("CreatePasswordResetToken: %v", err)
+	}
+	if tok.UserID != userID || tok.Token != "test-token-123" {
+		t.Fatalf("PasswordResetToken = %+v, unerwartete Werte", tok)
+	}
+
+	got, err := s.GetValidPasswordResetToken(ctx, "test-token-123")
+	if err != nil || got.ID != tok.ID {
+		t.Fatalf("GetValidPasswordResetToken = %+v, err=%v", got, err)
+	}
+
+	if err := s.MarkPasswordResetTokenUsed(ctx, tok.ID); err != nil {
+		t.Fatalf("MarkPasswordResetTokenUsed: %v", err)
+	}
+
+	// Ein verbrauchter Token gilt nicht mehr als gültig.
+	if _, err := s.GetValidPasswordResetToken(ctx, "test-token-123"); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err nach Verbrauch = %v, want ErrNotFound", err)
+	}
+
+	// Ein unbekannter Token ist von Anfang an ErrNotFound.
+	if _, err := s.GetValidPasswordResetToken(ctx, "existiert-nicht"); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err für unbekannten Token = %v, want ErrNotFound", err)
+	}
+}
+
+func TestSetUserPassword(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+
+	if err := s.SetUserPassword(ctx, userID, "neuer-hash"); err != nil {
+		t.Fatalf("SetUserPassword: %v", err)
+	}
+	got, err := s.GetUser(ctx, userID)
+	if err != nil || got.PasswordHash != "neuer-hash" {
+		t.Fatalf("GetUser nach SetUserPassword = %+v, err=%v", got, err)
+	}
+}

internal/store/user.go

@@ -108,6 +108,20 @@ func (s *Store) ListUsersForAccount(ctx context.Context, accountID string) ([]Us
 	return out, nil
 }
 
+// SetUserPassword ersetzt den Passwort-Hash eines Nutzers (Passwort-
+// Zurücksetzen). passwordHash muss bereits gehasht sein, wie bei
+// CreateUser.
+func (s *Store) SetUserPassword(ctx context.Context, id, passwordHash string) error {
+	tag, err := s.Pool.Exec(ctx, `UPDATE app_user SET password_hash = $2 WHERE id = $1`, id, passwordHash)
+	if err != nil {
+		return fmt.Errorf("store: set user password: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
 // SetUserActive (de-)aktiviert einen Login. Ein deaktivierter Nutzer
 // kann sich nicht mehr anmelden (siehe web.handleLogin), bleibt aber
 // als Akteur in bestehenden Anträgen/Entscheidungen/Audit-Log-Einträgen

internal/web/admin_handlers.go

@@ -8,8 +8,10 @@ package web
 
 import (
 	"net/http"
+	"strings"
 
 	"github.com/netcell-it/deklarix/internal/auth"
+	"github.com/netcell-it/deklarix/internal/store"
 )
 
 // mandantenRollen sind die Rollen, die ein Admin innerhalb des eigenen
@@ -35,9 +37,11 @@ type nutzerListItem struct {
 }
 
 type nutzerListeData struct {
-	Title  string
-	Nav    navData
-	Nutzer []nutzerListItem
+	Title      string
+	Nav        navData
+	Nutzer     []nutzerListItem
+	Suche      string
+	Pagination pagination
 }
 
 // handleNutzerListe zeigt alle Logins des eigenen Mandanten.
@@ -48,8 +52,16 @@ func (s *Server) handleNutzerListe(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Nutzer konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := nutzerListeData{Title: "Nutzerverwaltung", Nav: navFor(r)}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var gefiltert []store.User
 	for _, u := range users {
+		if matchesQuery(q, u.Email, u.Role) {
+			gefiltert = append(gefiltert, u)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	data := nutzerListeData{Title: "Nutzerverwaltung", Nav: navFor(r), Suche: q, Pagination: pag}
+	for _, u := range paginate(gefiltert, pag) {
 		data.Nutzer = append(data.Nutzer, nutzerListItem{
 			ID: u.ID, Email: u.Email, Role: u.Role, Active: u.Active, IstSelbst: u.ID == self.ID,
 		})

internal/web/antrag_handlers.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"strings"
 
 	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
@@ -289,16 +290,25 @@ func (s *Server) bewerteAntrag(ctx context.Context, antragID, accountID string,
 		}
 		kandidaten := make([]rules.WerkzeugKandidat, len(werkzeuge))
 		for i, w := range werkzeuge {
-			aufbewahrungTage := 0
-			if w.AufbewahrungTage != nil {
-				aufbewahrungTage = *w.AufbewahrungTage
-			}
 			kandidaten[i] = rules.WerkzeugKandidat{ID: w.ID, Eigenschaften: rules.WerkzeugEigenschaften{
 				AVVVerfuegbar: w.AVVVerfuegbar, Verarbeitungslaender: w.Verarbeitungslaender,
-				TrainingOptOut: w.TrainingOptOut, TrainingStandard: w.TrainingStandard, AufbewahrungTage: aufbewahrungTage,
+				TrainingOptOut: w.TrainingOptOut, TrainingStandard: w.TrainingStandard, AufbewahrungTage: w.AufbewahrungTage,
 			}}
 		}
-		zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, anforderungIDs)
+
+		var loeschfristMaxTage *int
+		loeschfristen, err := s.store.ListLoeschfristEinstellungenForAccount(ctx, accountID)
+		if err != nil {
+			return err
+		}
+		for _, l := range loeschfristen {
+			if l.DatenklasseID == datenklasse.ID {
+				maxTage := l.MaxTage
+				loeschfristMaxTage = &maxTage
+			}
+		}
+
+		zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, anforderungIDs, loeschfristMaxTage)
 		in.ZulaessigeWerkzeuge = zulaessig
 		for _, a := range ausgeschlossen {
 			in.AusgeschlosseneWerkzeuge = append(in.AusgeschlosseneWerkzeuge, store.BewertungAusschluss{WerkzeugID: a.WerkzeugID, NichtErfuellt: a.NichtErfuellt})
@@ -334,9 +344,11 @@ type antragListItem struct {
 }
 
 type antragListData struct {
-	Title    string
-	Nav      navData
-	Antraege []antragListItem
+	Title      string
+	Nav        navData
+	Antraege   []antragListItem
+	Suche      string
+	Pagination pagination
 }
 
 // handleAntragList zeigt die eigenen Anträge (Ebene 2 — "Eigene
@@ -351,8 +363,16 @@ func (s *Server) handleAntragList(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Anträge konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := antragListData{Title: "Meine Anträge", Nav: navFor(r)}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var gefiltert []store.Antrag
 	for _, a := range list {
+		if matchesQuery(q, a.Titel, a.Status, a.Haeufigkeit) {
+			gefiltert = append(gefiltert, a)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	data := antragListData{Title: "Meine Anträge", Nav: navFor(r), Suche: q, Pagination: pag}
+	for _, a := range paginate(gefiltert, pag) {
 		data.Antraege = append(data.Antraege, antragListItem{
 			ID: a.ID, Titel: a.Titel, Status: a.Status, Haeufigkeit: a.Haeufigkeit,
 			CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),

internal/web/antrag_handlers_test.go

@@ -248,6 +248,51 @@ func TestAntragCreateFiltersWerkzeugeByAnforderungen(t *testing.T) {
 	}
 }
 
+func TestAntragCreateFiltertNachLoeschfrist(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccount(t, fs, "Test-Mandant", "test@example.com")
+
+	sess := fs.sessions[cookie.Value]
+	accountID := fs.users[sess.UserID].AccountID
+	// fullAntragForm loest Datenklasse "personenbezogen" aus (b1=ja).
+	fs.loeschfristen[accountID] = map[string]int{"personenbezogen": 30}
+
+	fs.werkzeuge["kurze-aufbewahrung"] = store.Werkzeug{
+		ID: "kurze-aufbewahrung", Name: "Kurz-Tool",
+		AVVVerfuegbar: true, TrainingStandard: true, AufbewahrungTage: intPtr(14),
+	}
+	fs.werkzeuge["lange-aufbewahrung"] = store.Werkzeug{
+		ID: "lange-aufbewahrung", Name: "Lang-Tool",
+		AVVVerfuegbar: true, TrainingStandard: true, AufbewahrungTage: intPtr(90),
+	}
+	fs.werkzeuge["unbekannte-aufbewahrung"] = store.Werkzeug{
+		ID: "unbekannte-aufbewahrung", Name: "Unbekannt-Tool",
+		AVVVerfuegbar: true, TrainingStandard: true,
+	}
+
+	resp := postForm(t, s, cookie, "/antraege", fullAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		antragID = id
+	}
+	b, err := fs.GetLatestBewertungForAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetLatestBewertungForAntrag: %v", err)
+	}
+	if len(b.ZulaessigeWerkzeuge) != 1 || b.ZulaessigeWerkzeuge[0] != "kurze-aufbewahrung" {
+		t.Fatalf("ZulaessigeWerkzeuge = %v, want [kurze-aufbewahrung]", b.ZulaessigeWerkzeuge)
+	}
+	if len(b.AusgeschlosseneWerkzeuge) != 2 {
+		t.Fatalf("AusgeschlosseneWerkzeuge = %+v, want 2 ausgeschlossene", b.AusgeschlosseneWerkzeuge)
+	}
+}
+
+func intPtr(i int) *int { return &i }
+
 func TestBetreiberRedirectedAwayFromAntragPages(t *testing.T) {
 	fs := newFakeStore()
 	s := newServer(t, fs)

internal/web/auth_handlers.go

@@ -8,8 +8,9 @@ import (
 )
 
 type authPageData struct {
-	Title string
-	Error string
+	Title   string
+	Error   string
+	Message string
 }
 
 func (s *Server) renderAuthPage(w http.ResponseWriter, name string, data authPageData) {
@@ -23,7 +24,11 @@ func (s *Server) handleRegisterForm(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) handleLoginForm(w http.ResponseWriter, r *http.Request) {
-	s.renderAuthPage(w, "login", authPageData{Title: "Anmelden"})
+	data := authPageData{Title: "Anmelden"}
+	if r.URL.Query().Get("reset") == "1" {
+		data.Message = "Passwort erfolgreich geändert. Bitte melde dich mit dem neuen Passwort an."
+	}
+	s.renderAuthPage(w, "login", data)
 }
 
 // handleRegister ist die "Firma"-Registrierung (Ebene 1 der Frontend-
@@ -66,6 +71,15 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if err := s.seedStandardGenehmigerRollen(ctx, acc.ID); err != nil {
+		s.renderAuthPage(w, "register", authPageData{Title: "Registrieren", Error: "Genehmiger-Rollen konnten nicht angelegt werden"})
+		return
+	}
+	if err := s.seedStandardLoeschfristen(ctx, acc.ID); err != nil {
+		s.renderAuthPage(w, "register", authPageData{Title: "Registrieren", Error: "Löschfristen konnten nicht angelegt werden"})
+		return
+	}
+
 	if err := s.startSession(w, r, user.ID); err != nil {
 		s.renderAuthPage(w, "register", authPageData{Title: "Registrieren", Error: "Sitzung konnte nicht gestartet werden"})
 		return

internal/web/betreiber_handlers.go

@@ -2,9 +2,11 @@ package web
 
 import (
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/netcell-it/deklarix/internal/auth"
+	"github.com/netcell-it/deklarix/internal/store"
 )
 
 type betreiberDashboardData struct {
@@ -52,9 +54,11 @@ type betreiberAccountListItem struct {
 }
 
 type betreiberAccountListData struct {
-	Title    string
-	Nav      navData
-	Accounts []betreiberAccountListItem
+	Title      string
+	Nav        navData
+	Accounts   []betreiberAccountListItem
+	Suche      string
+	Pagination pagination
 }
 
 // handleBetreiberAccountList listet alle Mandanten der Plattform.
@@ -64,8 +68,16 @@ func (s *Server) handleBetreiberAccountList(w http.ResponseWriter, r *http.Reque
 		http.Error(w, "Accounts konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := betreiberAccountListData{Title: "Accounts", Nav: navFor(r)}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var gefiltert []store.Account
 	for _, a := range accounts {
+		if matchesQuery(q, a.Name) {
+			gefiltert = append(gefiltert, a)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	data := betreiberAccountListData{Title: "Accounts", Nav: navFor(r), Suche: q, Pagination: pag}
+	for _, a := range paginate(gefiltert, pag) {
 		data.Accounts = append(data.Accounts, betreiberAccountListItem{
 			ID: a.ID, Name: a.Name, CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),
 		})
@@ -135,6 +147,20 @@ func (s *Server) handleBetreiberAccountCreate(w http.ResponseWriter, r *http.Req
 		}
 		return
 	}
+	if err := s.seedStandardGenehmigerRollen(ctx, acc.ID); err != nil {
+		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Genehmiger-Rollen konnten nicht angelegt werden: " + err.Error()}
+		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if err := s.seedStandardLoeschfristen(ctx, acc.ID); err != nil {
+		data := betreiberAccountNeuData{Title: "Firma anlegen", Nav: navFor(r), Error: "Löschfristen konnten nicht angelegt werden: " + err.Error()}
+		if err := s.templates.ExecuteTemplate(w, "betreiber-account-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
 	if _, err := s.store.CreateAuditEntry(ctx, currentUser(r).ID, "betreiber_firma_angelegt", "account", acc.ID, accountName+" / "+email); err != nil {
 		http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -218,20 +244,37 @@ type betreiberAuditEntryView struct {
 }
 
 type betreiberAuditLogData struct {
-	Title   string
-	Nav     navData
-	Entries []betreiberAuditEntryView
+	Title      string
+	Nav        navData
+	Entries    []betreiberAuditEntryView
+	Suche      string
+	Pagination pagination
 }
 
+// auditLogFetchLimit begrenzt, wie viele der neuesten Einträge aus der
+// DB geholt werden, bevor im Go-Code gefiltert/paginiert wird — echte
+// DB-seitige Offset-Paginierung wäre für ein potenziell sehr groß
+// werdendes Audit-Log der sauberere Ansatz, ist hier aber (noch) nicht
+// umgesetzt (siehe CLAUDE.md, Offene Punkte).
+const auditLogFetchLimit = 1000
+
 // handleBetreiberAuditLog zeigt das plattformweite Audit-Log.
 func (s *Server) handleBetreiberAuditLog(w http.ResponseWriter, r *http.Request) {
-	entries, err := s.store.ListAuditLog(r.Context(), 200)
+	entries, err := s.store.ListAuditLog(r.Context(), auditLogFetchLimit)
 	if err != nil {
 		http.Error(w, "Audit-Log konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := betreiberAuditLogData{Title: "Audit-Log", Nav: navFor(r)}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var gefiltert []store.AuditEntry
 	for _, e := range entries {
+		if matchesQuery(q, e.Action, e.TargetType, e.Details) {
+			gefiltert = append(gefiltert, e)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	data := betreiberAuditLogData{Title: "Audit-Log", Nav: navFor(r), Suche: q, Pagination: pag}
+	for _, e := range paginate(gefiltert, pag) {
 		data.Entries = append(data.Entries, betreiberAuditEntryView{
 			CreatedAt: e.CreatedAt.Format("02.01.2006 15:04:05"), Action: e.Action,
 			TargetType: e.TargetType, TargetID: e.TargetID, Details: e.Details,

internal/web/fachebene_handlers.go

@@ -5,8 +5,10 @@
 package web
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/netcell-it/deklarix/internal/store"
@@ -20,9 +22,11 @@ type fallListItem struct {
 }
 
 type fallListData struct {
-	Title  string
-	Nav    navData
-	Faelle []fallListItem
+	Title      string
+	Nav        navData
+	Faelle     []fallListItem
+	Suche      string
+	Pagination pagination
 }
 
 // handleFaelleListe zeigt den Posteingang: alle noch offenen (Status
@@ -34,16 +38,25 @@ func (s *Server) handleFaelleListe(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Anträge konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := fallListData{Title: "Posteingang", Nav: navFor(r)}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var offene []fallListItem
 	for _, a := range antraege {
 		if a.Status != "eingereicht" {
 			continue
 		}
-		data.Faelle = append(data.Faelle, fallListItem{
+		if !matchesQuery(q, a.Titel, a.Haeufigkeit) {
+			continue
+		}
+		offene = append(offene, fallListItem{
 			ID: a.ID, Titel: a.Titel, Haeufigkeit: a.Haeufigkeit,
 			CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),
 		})
 	}
+	pag := paginationFromRequest(r, len(offene))
+	data := fallListData{
+		Title: "Posteingang", Nav: navFor(r),
+		Faelle: paginate(offene, pag), Suche: q, Pagination: pag,
+	}
 	if err := s.templates.ExecuteTemplate(w, "faelle-liste", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
 	}
@@ -77,9 +90,18 @@ type fallDetailData struct {
 	Entscheidung     *entscheidungView
 	CanEntscheiden   bool
 	WerkzeugOptionen []werkzeugOption
+	Freigabeschritte []freigabeschrittView
 	Error            string
 }
 
+// freigabeschrittView zeigt den Stand eines einzelnen, zusätzlich zur
+// Fachebene-Entscheidung nötigen Freigabeschritts an.
+type freigabeschrittView struct {
+	RolleName string
+	Status    string
+	Kommentar string
+}
+
 // hatEntscheidungsrecht — "admin" ist bewusst mit eingeschlossen, siehe
 // requireFachebene: die Spezifikation will admin+verantwortlicher auf
 // derselben Person, ohne dass app_user.role zwei Werte tragen kann.
@@ -146,6 +168,24 @@ func (s *Server) handleFallDetail(w http.ResponseWriter, r *http.Request) {
 		data.Entscheidung = v
 	}
 
+	// Nicht auf Status "wartet_auf_freigabe" beschränkt: die Freigabehistorie
+	// bleibt auch nach vollständiger Entscheidung sichtbar (Grundregel: eine
+	// Entscheidung wird nie ohne vollständige Herleitung angezeigt). Für
+	// Anträge ohne ausgelöste Freigabe-Regel liefert die Abfrage einfach
+	// eine leere Liste, das Template blendet den Abschnitt dann aus.
+	schritte, err := s.store.ListFreigabeschritteForAntrag(r.Context(), antrag.ID)
+	if err == nil {
+		for _, schritt := range schritte {
+			rolleName := ""
+			if rolle, err := s.store.GetGenehmigerRolle(r.Context(), schritt.GenehmigerRolleID); err == nil {
+				rolleName = rolle.Name
+			}
+			data.Freigabeschritte = append(data.Freigabeschritte, freigabeschrittView{
+				RolleName: rolleName, Status: schritt.Status, Kommentar: schritt.Kommentar,
+			})
+		}
+	}
+
 	if err := s.templates.ExecuteTemplate(w, "fall-detail", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
 	}
@@ -212,7 +252,6 @@ func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
 		AntragID: antrag.ID, BewertungID: bewertung.ID, EntscheiderUserID: user.ID,
 		Entscheidung: entscheidungTyp, Begruendung: begruendung,
 	}
-	var werkzeugName string
 	if istGenehmigung {
 		zulaessig := false
 		for _, id := range bewertung.ZulaessigeWerkzeuge {
@@ -230,7 +269,6 @@ func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
 			return
 		}
-		werkzeugName = werkzeug.Name
 		in.WerkzeugID = &werkzeugID
 		in.WerkzeugSnapshot = &werkzeug
 		gueltigBis := gueltigkeitFuer(bewertung.Einstufung)
@@ -242,6 +280,39 @@ func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Entscheidung konnte nicht gespeichert werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+
+	// Konfigurierbarer Mehrfach-Freigabe-Workflow (siehe CLAUDE.md): eine
+	// Genehmigung ist nicht zwangsläufig sofort final — löst die
+	// Bewertung eine Freigabe-Regel des Mandanten aus (z. B.
+	// dsfa_erforderlich → Datenschutzbeauftragter), wartet der Antrag
+	// erst auf diese zusätzlichen Freigaben, bevor SetAntragStatus auf
+	// "entschieden" geht und ein Registereintrag entsteht.
+	if istGenehmigung {
+		regeln, err := s.store.ListFreigabeRegelnForAccount(r.Context(), user.AccountID)
+		if err != nil {
+			http.Error(w, "Freigabe-Regeln konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if rollenIDs := triggeredGenehmigerRollen(regeln, bewertung); len(rollenIDs) > 0 {
+			for _, rolleID := range rollenIDs {
+				if _, err := s.store.CreateFreigabeschritt(r.Context(), antrag.ID, rolleID); err != nil {
+					http.Error(w, "Freigabeschritt konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+					return
+				}
+			}
+			if err := s.store.SetAntragStatus(r.Context(), antrag.ID, "wartet_auf_freigabe"); err != nil {
+				http.Error(w, "Antrag konnte nicht aktualisiert werden: "+err.Error(), http.StatusInternalServerError)
+				return
+			}
+			if _, err := s.store.CreateAuditEntry(r.Context(), user.ID, "antrag_wartet_auf_freigabe", "antrag", antrag.ID, entscheidungTyp); err != nil {
+				http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
+				return
+			}
+			http.Redirect(w, r, "/faelle/"+antrag.ID, http.StatusSeeOther)
+			return
+		}
+	}
+
 	if err := s.store.SetAntragStatus(r.Context(), antrag.ID, "entschieden"); err != nil {
 		http.Error(w, "Antrag konnte nicht aktualisiert werden: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -250,27 +321,8 @@ func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-
-	// Jede Genehmigung erzeugt automatisch einen Registereintrag (siehe
-	// CLAUDE.md) — bei "abgelehnt"/"rueckfrage" gibt es nichts
-	// Genehmigtes, das im Register stehen müsste.
 	if istGenehmigung {
-		abteilungName := ""
-		if antrag.AbteilungID != nil {
-			if abt, err := s.store.GetAbteilung(r.Context(), *antrag.AbteilungID); err == nil {
-				abteilungName = abt.Name
-			}
-		}
-		var auflagen []string
-		for _, a := range bewertung.Anforderungen {
-			auflagen = append(auflagen, a.Beschreibung)
-		}
-		if _, err := s.store.CreateRegistereintrag(r.Context(), store.RegistereintragInput{
-			AccountID: user.AccountID, AntragID: antrag.ID, EntscheidungID: entscheidung.ID,
-			Zweck: antrag.Titel, Abteilung: abteilungName, Werkzeug: werkzeugName,
-			Datenklasse: bewertung.Datenklasse, Einstufung: bewertung.Einstufung, Auflagen: auflagen,
-			Verantwortlicher: user.Email, EntschiedenAm: entscheidung.CreatedAt, GueltigBis: entscheidung.GueltigBis,
-		}); err != nil {
+		if err := s.registriereGenehmigung(r.Context(), antrag, entscheidung, bewertung); err != nil {
 			http.Error(w, "Registereintrag konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
@@ -278,3 +330,67 @@ func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
 
 	http.Redirect(w, r, "/faelle/"+antrag.ID, http.StatusSeeOther)
 }
+
+// registriereGenehmigung schließt eine (ggf. erst nach zusätzlichen
+// Freigaben) endgültig genehmigte Entscheidung ab: Registereintrag
+// anlegen (siehe CLAUDE.md — Antragstatus ist an dieser Stelle bereits
+// auf "entschieden" gesetzt). Wiederverwendet von handleFallEntscheiden
+// (keine zusätzliche Freigabe nötig) und handleFreigabeEntscheiden
+// (letzter ausstehender Freigabeschritt wurde soeben genehmigt).
+func (s *Server) registriereGenehmigung(ctx context.Context, antrag store.Antrag, entscheidung store.Entscheidung, bewertung store.Bewertung) error {
+	abteilungName := ""
+	if antrag.AbteilungID != nil {
+		if abt, err := s.store.GetAbteilung(ctx, *antrag.AbteilungID); err == nil {
+			abteilungName = abt.Name
+		}
+	}
+	werkzeugName := ""
+	if entscheidung.WerkzeugSnapshot != nil {
+		werkzeugName = entscheidung.WerkzeugSnapshot.Name
+	}
+	verantwortlicherEmail := ""
+	if u, err := s.store.GetUser(ctx, entscheidung.EntscheiderUserID); err == nil {
+		verantwortlicherEmail = u.Email
+	}
+	var auflagen []string
+	for _, a := range bewertung.Anforderungen {
+		auflagen = append(auflagen, a.Beschreibung)
+	}
+	_, err := s.store.CreateRegistereintrag(ctx, store.RegistereintragInput{
+		AccountID: antrag.AccountID, AntragID: antrag.ID, EntscheidungID: entscheidung.ID,
+		Zweck: antrag.Titel, Abteilung: abteilungName, Werkzeug: werkzeugName,
+		Datenklasse: bewertung.Datenklasse, Einstufung: bewertung.Einstufung, Auflagen: auflagen,
+		Verantwortlicher: verantwortlicherEmail, EntschiedenAm: entscheidung.CreatedAt, GueltigBis: entscheidung.GueltigBis,
+	})
+	return err
+}
+
+// triggeredGenehmigerRollen liefert die eindeutigen Genehmiger-Rollen,
+// deren Freigabe-Regel durch diese Bewertung ausgelöst wird — Bedingung
+// ist eine der vom Regelwerk bereits abgeleiteten Größen (Anforderungs-
+// ID, Einstufung, Datenklasse), kein freier Regel-Editor.
+func triggeredGenehmigerRollen(regeln []store.FreigabeRegel, bewertung store.Bewertung) []string {
+	var out []string
+	seen := map[string]bool{}
+	for _, regel := range regeln {
+		var treffer bool
+		switch regel.BedingungTyp {
+		case "anforderung":
+			for _, a := range bewertung.Anforderungen {
+				if a.ID == regel.BedingungWert {
+					treffer = true
+					break
+				}
+			}
+		case "einstufung":
+			treffer = bewertung.Einstufung == regel.BedingungWert
+		case "datenklasse":
+			treffer = bewertung.Datenklasse == regel.BedingungWert
+		}
+		if treffer && !seen[regel.GenehmigerRolleID] {
+			seen[regel.GenehmigerRolleID] = true
+			out = append(out, regel.GenehmigerRolleID)
+		}
+	}
+	return out
+}

internal/web/freigabe_handlers.go

@@ -0,0 +1,493 @@
+// Konfigurierbarer Mehrfach-Freigabe-Workflow — siehe Migration 0017
+// und CLAUDE.md. Drei Seitengruppen:
+//   - Admin (Ebene 4): Genehmiger-Rollen anlegen/Mitglieder zuweisen,
+//     Freigabe-Regeln definieren ("wenn Bedingung X, dann Freigabe
+//     durch Rolle Y nötig").
+//   - Jeder angemeldete Nutzer: "Meine Freigaben" — eigene ausstehende
+//     Freigabeschritte, unabhängig von app_user.role (eine
+//     Genehmiger-Rolle ist orthogonal zur Zugriffsrolle).
+package web
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+// standardGenehmigerRollen wird bei jeder neuen Firma automatisch angelegt
+// (ohne Mitglieder/Freigabe-Regeln) — der Admin muss nur noch Personen
+// zuordnen und bei Bedarf Freigabe-Regeln ergänzen, statt bei null
+// anzufangen. Die Beschreibung ist reine Orientierungshilfe im UI; welche
+// Bedingung welche Rolle tatsächlich auslöst, entscheidet weiterhin jede
+// Firma selbst über /verwaltung/freigabe-regeln — das System schreibt
+// keine fachliche Bindung vor.
+var standardGenehmigerRollen = []struct {
+	Name         string
+	Beschreibung string
+}{
+	{"Datenschutzbeauftragter", "Prüft Anträge mit besonderen Datenschutzanforderungen, z. B. wenn eine Datenschutz-Folgenabschätzung erforderlich ist."},
+	{"Geschäftsführer", "Trifft die unternehmerische Entscheidung bei besonders risikobehafteten Vorhaben."},
+	{"KI-Manager", "Bewertet den Antrag fachlich."},
+	{"CISO", "Prüft den Antrag aus Sicherheitssicht (Auditor)."},
+}
+
+// seedStandardGenehmigerRollen wird direkt nach dem Anlegen einer neuen
+// Firma aufgerufen (öffentliche Registrierung und Betreiber-Firmenanlage).
+func (s *Server) seedStandardGenehmigerRollen(ctx context.Context, accountID string) error {
+	for _, r := range standardGenehmigerRollen {
+		if _, err := s.store.CreateGenehmigerRolle(ctx, accountID, r.Name, r.Beschreibung); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ─── Admin: Genehmiger-Rollen ───────────────────────────────────────
+
+type genehmigerRolleItem struct {
+	ID           string
+	Name         string
+	Beschreibung string
+	Mitglieder   []nutzerOption
+}
+
+type nutzerOption struct {
+	ID    string
+	Email string
+}
+
+type genehmigerRollenListeData struct {
+	Title  string
+	Nav    navData
+	Rollen []genehmigerRolleItem
+	Nutzer []nutzerOption
+	Error  string
+}
+
+func (s *Server) handleGenehmigerRollenListe(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	rollen, err := s.store.ListGenehmigerRollenForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Genehmiger-Rollen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	users, err := s.store.ListUsersForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Nutzer konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := genehmigerRollenListeData{Title: "Genehmiger-Rollen", Nav: navFor(r)}
+	for _, u := range users {
+		data.Nutzer = append(data.Nutzer, nutzerOption{ID: u.ID, Email: u.Email})
+	}
+	for _, g := range rollen {
+		item := genehmigerRolleItem{ID: g.ID, Name: g.Name, Beschreibung: g.Beschreibung}
+		mitglieder, err := s.store.ListNutzerForGenehmigerRolle(r.Context(), g.ID)
+		if err == nil {
+			for _, m := range mitglieder {
+				item.Mitglieder = append(item.Mitglieder, nutzerOption{ID: m.UserID, Email: m.Email})
+			}
+		}
+		data.Rollen = append(data.Rollen, item)
+	}
+	if err := s.templates.ExecuteTemplate(w, "genehmiger-rollen-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) handleGenehmigerRolleCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	name := strings.TrimSpace(r.FormValue("name"))
+	if name == "" {
+		http.Error(w, "Name ist Pflicht", http.StatusBadRequest)
+		return
+	}
+	beschreibung := strings.TrimSpace(r.FormValue("beschreibung"))
+	if _, err := s.store.CreateGenehmigerRolle(r.Context(), currentUser(r).AccountID, name, beschreibung); err != nil {
+		http.Error(w, "Genehmiger-Rolle konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/genehmiger-rollen", http.StatusSeeOther)
+}
+
+// handleGenehmigerRolleDelete entfernt eine Genehmiger-Rolle. Solange
+// noch Mitglieder zugewiesen sind oder eine Freigabe-Regel darauf
+// verweist, schlägt das per Fremdschlüssel fehl — bewusst kein CASCADE,
+// ein stillschweigendes Mit-Löschen wirksamer Freigabe-Regeln wäre
+// überraschend und sicherheitsrelevant.
+func (s *Server) handleGenehmigerRolleDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	rolle, err := s.store.GetGenehmigerRolle(r.Context(), id)
+	if err != nil || rolle.AccountID != currentUser(r).AccountID {
+		http.Error(w, "Genehmiger-Rolle nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteGenehmigerRolle(r.Context(), id); err != nil {
+		http.Error(w, "Genehmiger-Rolle wird noch verwendet (Mitglieder oder Freigabe-Regeln) und kann nicht gelöscht werden", http.StatusBadRequest)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/genehmiger-rollen", http.StatusSeeOther)
+}
+
+func (s *Server) handleGenehmigerRolleMitgliedHinzufuegen(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	rolleID := r.PathValue("id")
+	rolle, err := s.store.GetGenehmigerRolle(r.Context(), rolleID)
+	if err != nil || rolle.AccountID != accountID {
+		http.Error(w, "Genehmiger-Rolle nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	userID := r.FormValue("user_id")
+	target, err := s.store.GetUser(r.Context(), userID)
+	if err != nil || target.AccountID != accountID {
+		http.Error(w, "Nutzer nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.AddNutzerGenehmigerRolle(r.Context(), userID, rolleID); err != nil {
+		http.Error(w, "Zuweisung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/genehmiger-rollen", http.StatusSeeOther)
+}
+
+func (s *Server) handleGenehmigerRolleMitgliedEntfernen(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	rolleID := r.PathValue("id")
+	rolle, err := s.store.GetGenehmigerRolle(r.Context(), rolleID)
+	if err != nil || rolle.AccountID != accountID {
+		http.Error(w, "Genehmiger-Rolle nicht gefunden", http.StatusNotFound)
+		return
+	}
+	userID := r.PathValue("userID")
+	if err := s.store.RemoveNutzerGenehmigerRolle(r.Context(), userID, rolleID); err != nil {
+		http.Error(w, "Entfernen fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/genehmiger-rollen", http.StatusSeeOther)
+}
+
+// ─── Admin: Freigabe-Regeln ─────────────────────────────────────────
+
+// bedingungOption ist ein Auswahlpunkt im Freigabe-Regel-Formular —
+// Value kodiert "typ:wert" (z. B. "anforderung:dsfa_erforderlich"),
+// damit ein einziges <select> ohne JavaScript reicht statt zweier
+// voneinander abhängiger Dropdowns.
+type bedingungOption struct {
+	Value string
+	Label string
+}
+
+type bedingungGruppe struct {
+	Label    string
+	Optionen []bedingungOption
+}
+
+type freigabeRegelItem struct {
+	ID              string
+	BedingungLabel  string
+	GenehmigerRolle string
+}
+
+type freigabeRegelnListeData struct {
+	Title            string
+	Nav              navData
+	Regeln           []freigabeRegelItem
+	BedingungGruppen []bedingungGruppe
+	RollenOptionen   []store.GenehmigerRolle
+	Error            string
+}
+
+// bedingungGruppenAusRegelwerk baut die Freigabe-Regel-Bedingungsauswahl
+// aus dem tatsächlich geladenen Regelwerk (nicht frei erfunden) — jede
+// Anforderungs-/Einstufungs-/Datenklasse-ID, die das System ohnehin
+// kennt, ist eine mögliche Bedingung.
+func (s *Server) bedingungGruppenAusRegelwerk() []bedingungGruppe {
+	var anforderungen []bedingungOption
+	for _, a := range s.regelwerk.Anforderungen.Anforderungen {
+		label := a.ID
+		if a.Beschreibung != "" {
+			label = a.Beschreibung
+		}
+		anforderungen = append(anforderungen, bedingungOption{Value: "anforderung:" + a.ID, Label: label})
+	}
+	var einstufungen []bedingungOption
+	for _, e := range s.regelwerk.Einstufung.Stufen {
+		einstufungen = append(einstufungen, bedingungOption{Value: "einstufung:" + e.ID, Label: e.ID})
+	}
+	var datenklassen []bedingungOption
+	for _, d := range s.regelwerk.Datenklasse.Stufen {
+		datenklassen = append(datenklassen, bedingungOption{Value: "datenklasse:" + d.ID, Label: d.ID})
+	}
+	return []bedingungGruppe{
+		{Label: "Anforderung", Optionen: anforderungen},
+		{Label: "Einstufung", Optionen: einstufungen},
+		{Label: "Datenklasse", Optionen: datenklassen},
+	}
+}
+
+func (s *Server) handleFreigabeRegelnListe(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	regeln, err := s.store.ListFreigabeRegelnForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Freigabe-Regeln konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	rollen, err := s.store.ListGenehmigerRollenForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Genehmiger-Rollen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	rollenName := map[string]string{}
+	for _, g := range rollen {
+		rollenName[g.ID] = g.Name
+	}
+	data := freigabeRegelnListeData{
+		Title: "Freigabe-Regeln", Nav: navFor(r),
+		BedingungGruppen: s.bedingungGruppenAusRegelwerk(), RollenOptionen: rollen,
+	}
+	for _, regel := range regeln {
+		data.Regeln = append(data.Regeln, freigabeRegelItem{
+			ID:              regel.ID,
+			BedingungLabel:  bedingungTypLabel(regel.BedingungTyp) + ": " + regel.BedingungWert,
+			GenehmigerRolle: rollenName[regel.GenehmigerRolleID],
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "freigabe-regeln-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func bedingungTypLabel(typ string) string {
+	switch typ {
+	case "anforderung":
+		return "Anforderung"
+	case "einstufung":
+		return "Einstufung"
+	case "datenklasse":
+		return "Datenklasse"
+	default:
+		return typ
+	}
+}
+
+func (s *Server) handleFreigabeRegelCreate(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	teile := strings.SplitN(r.FormValue("bedingung"), ":", 2)
+	rolleID := r.FormValue("genehmiger_rolle_id")
+	if len(teile) != 2 || teile[0] == "" || teile[1] == "" || rolleID == "" {
+		http.Error(w, "Bedingung und Genehmiger-Rolle sind Pflicht", http.StatusBadRequest)
+		return
+	}
+	typ, wert := teile[0], teile[1]
+	if typ != "anforderung" && typ != "einstufung" && typ != "datenklasse" {
+		http.Error(w, "ungültiger Bedingungstyp", http.StatusBadRequest)
+		return
+	}
+	rolle, err := s.store.GetGenehmigerRolle(r.Context(), rolleID)
+	if err != nil || rolle.AccountID != accountID {
+		http.Error(w, "Genehmiger-Rolle nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if _, err := s.store.CreateFreigabeRegel(r.Context(), accountID, typ, wert, rolleID); err != nil {
+		http.Error(w, "Freigabe-Regel konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/freigabe-regeln", http.StatusSeeOther)
+}
+
+func (s *Server) handleFreigabeRegelDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	regel, err := s.store.GetFreigabeRegel(r.Context(), id)
+	if err != nil || regel.AccountID != currentUser(r).AccountID {
+		http.Error(w, "Freigabe-Regel nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteFreigabeRegel(r.Context(), id); err != nil {
+		http.Error(w, "Freigabe-Regel konnte nicht gelöscht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/freigabe-regeln", http.StatusSeeOther)
+}
+
+// ─── Meine Freigaben (jeder angemeldete Nutzer) ─────────────────────
+
+type freigabeItem struct {
+	ID          string
+	AntragID    string
+	AntragTitel string
+	RolleName   string
+	CreatedAt   string
+}
+
+type freigabenListeData struct {
+	Title     string
+	Nav       navData
+	Freigaben []freigabeItem
+}
+
+// handleFreigabenListe zeigt die eigenen ausstehenden Freigabeschritte
+// — unabhängig von app_user.role, denn eine Genehmiger-Rolle ist eine
+// orthogonale Freigabe-Funktion, keine Zugriffsrolle.
+func (s *Server) handleFreigabenListe(w http.ResponseWriter, r *http.Request) {
+	user := currentUser(r)
+	schritte, err := s.store.ListAusstehendeFreigabeschritteForUser(r.Context(), user.ID)
+	if err != nil {
+		http.Error(w, "Freigaben konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := freigabenListeData{Title: "Meine Freigaben", Nav: navFor(r)}
+	for _, schritt := range schritte {
+		antrag, err := s.store.GetAntrag(r.Context(), schritt.AntragID)
+		if err != nil {
+			continue
+		}
+		rolleName := ""
+		if rolle, err := s.store.GetGenehmigerRolle(r.Context(), schritt.GenehmigerRolleID); err == nil {
+			rolleName = rolle.Name
+		}
+		data.Freigaben = append(data.Freigaben, freigabeItem{
+			ID: schritt.ID, AntragID: antrag.ID, AntragTitel: antrag.Titel,
+			RolleName: rolleName, CreatedAt: schritt.CreatedAt.Format("02.01.2006 15:04"),
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "freigaben-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleFreigabeEntscheiden trägt die Entscheidung einer Person zu
+// einem einzelnen Freigabeschritt ein. Genehmigt sie den letzten noch
+// ausstehenden Schritt eines Antrags, wird die ursprüngliche Genehmigung
+// jetzt final abgeschlossen (Registereintrag). Lehnt sie ab, kippt das
+// den gesamten Antrag — alle anderen offenen Schritte desselben Antrags
+// werden automatisch mit abgelehnt (KaskadiereAblehnung), und eine neue
+// Entscheidung "abgelehnt" übersteuert die ursprüngliche Genehmigung
+// (entscheidung ist append-only, siehe CLAUDE.md).
+func (s *Server) handleFreigabeEntscheiden(w http.ResponseWriter, r *http.Request) {
+	user := currentUser(r)
+	id := r.PathValue("id")
+
+	schritt, err := s.store.GetFreigabeschritt(r.Context(), id)
+	if err != nil {
+		http.Error(w, "Freigabeschritt nicht gefunden", http.StatusNotFound)
+		return
+	}
+	rollen, err := s.store.ListGenehmigerRollenForUser(r.Context(), user.ID)
+	if err != nil {
+		http.Error(w, "Genehmiger-Rollen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	hatRolle := false
+	for _, rl := range rollen {
+		if rl.ID == schritt.GenehmigerRolleID {
+			hatRolle = true
+			break
+		}
+	}
+	if !hatRolle {
+		http.Error(w, "Freigabeschritt nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if schritt.Status != "ausstehend" {
+		http.Error(w, "dieser Freigabeschritt wurde bereits entschieden", http.StatusBadRequest)
+		return
+	}
+
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	entscheidungTyp := r.FormValue("entscheidung")
+	kommentar := r.FormValue("kommentar")
+	if entscheidungTyp != "genehmigt" && entscheidungTyp != "abgelehnt" {
+		http.Error(w, "ungültige Entscheidung", http.StatusBadRequest)
+		return
+	}
+
+	if _, err := s.store.EntscheideFreigabeschritt(r.Context(), id, entscheidungTyp, user.ID, kommentar); err != nil {
+		http.Error(w, "Freigabeschritt konnte nicht gespeichert werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	antrag, err := s.store.GetAntrag(r.Context(), schritt.AntragID)
+	if err != nil {
+		http.Error(w, "Antrag nicht gefunden", http.StatusInternalServerError)
+		return
+	}
+	rolle, _ := s.store.GetGenehmigerRolle(r.Context(), schritt.GenehmigerRolleID)
+	if _, err := s.store.CreateAuditEntry(r.Context(), user.ID, "freigabeschritt_entschieden", "antrag", antrag.ID, rolle.Name+": "+entscheidungTyp); err != nil {
+		http.Error(w, "Audit-Log konnte nicht geschrieben werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	bewertung, err := s.store.GetLatestBewertungForAntrag(r.Context(), antrag.ID)
+	if err != nil {
+		http.Error(w, "Bewertung nicht gefunden", http.StatusInternalServerError)
+		return
+	}
+
+	if entscheidungTyp == "abgelehnt" {
+		if err := s.store.KaskadiereAblehnung(r.Context(), antrag.ID, id); err != nil {
+			http.Error(w, "Kaskadierung fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if err := s.store.SetAntragStatus(r.Context(), antrag.ID, "entschieden"); err != nil {
+			http.Error(w, "Antrag konnte nicht aktualisiert werden: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		begruendung := "Freigabe durch " + rolle.Name + " wurde verweigert."
+		if kommentar != "" {
+			begruendung += " Kommentar: " + kommentar
+		}
+		if _, err := s.store.CreateEntscheidung(r.Context(), store.EntscheidungInput{
+			AntragID: antrag.ID, BewertungID: bewertung.ID, EntscheiderUserID: user.ID,
+			Entscheidung: "abgelehnt", Begruendung: begruendung,
+		}); err != nil {
+			http.Error(w, "Entscheidung konnte nicht gespeichert werden: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		alle, err := s.store.ListFreigabeschritteForAntrag(r.Context(), antrag.ID)
+		if err != nil {
+			http.Error(w, "Freigabeschritte konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		vollstaendig := true
+		for _, fs := range alle {
+			if fs.Status != "genehmigt" {
+				vollstaendig = false
+				break
+			}
+		}
+		if vollstaendig {
+			letzteEntscheidung, err := s.store.GetLatestEntscheidungForAntrag(r.Context(), antrag.ID)
+			if err != nil {
+				http.Error(w, "Entscheidung nicht gefunden", http.StatusInternalServerError)
+				return
+			}
+			if err := s.store.SetAntragStatus(r.Context(), antrag.ID, "entschieden"); err != nil {
+				http.Error(w, "Antrag konnte nicht aktualisiert werden: "+err.Error(), http.StatusInternalServerError)
+				return
+			}
+			if err := s.registriereGenehmigung(r.Context(), antrag, letzteEntscheidung, bewertung); err != nil {
+				http.Error(w, "Registereintrag konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+				return
+			}
+		}
+	}
+
+	http.Redirect(w, r, "/freigaben", http.StatusSeeOther)
+}

internal/web/freigabe_handlers_test.go

@@ -0,0 +1,283 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/web"
+)
+
+// besondereKategorieAntragForm loest ueber b2=ja die Datenklasse
+// besondere_kategorie aus, die laut rules/anforderungen.yaml die
+// Anforderung dsfa_erforderlich nach sich zieht — Grundlage fuer die
+// Freigabe-Workflow-Tests.
+func besondereKategorieAntragForm() url.Values {
+	return url.Values{
+		"titel": {"Gesundheitsdaten auswerten"}, "beschreibung": {"KI wertet Gesundheitsdaten aus"},
+		"ergebnis": {"Auswertung"}, "haeufigkeit": {"gelegentlich"},
+		"b1": {"nein"}, "b2": {"ja"}, "b3": {"nein"}, "b4": {"nein"}, "b5": {"nein"}, "b6": {"nein"}, "b7": {"nein"},
+		"c1": {"nein"}, "c2": {"nein"}, "c2_folge": {"keine"}, "c3": {"nein"}, "c3_art": {"keine"},
+		"c4": {"nein"}, "c5": {"ja"},
+		"d_werkzeug_freitext": {"ChatGPT"}, "d_zugang": {"firma"}, "d_geraet": {"firma"},
+	}
+}
+
+// seedFreigabeSzenario legt einen Mandanten mit Mitarbeiter (reicht
+// einen Antrag ein, der dsfa_erforderlich ausloest), Verantwortlichem
+// und einem zentralen Werkzeug an — die Grundlage, auf der die
+// einzelnen Freigabe-Workflow-Tests aufbauen.
+func seedFreigabeSzenario(t *testing.T, fs *fakeStore, s *web.Server) (accountID, antragID string, verantwortlicherCookie *http.Cookie) {
+	t.Helper()
+	ctx := context.Background()
+	acc, err := fs.CreateAccount(ctx, "Freigabe-Mandant")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	mitarbeiterCookie := seedUserInAccount(t, fs, acc.ID, "mitarbeiter-fg@example.com", "mitarbeiter")
+
+	werkzeugForm := url.Values{
+		"name": {"ChatGPT Enterprise"}, "anbieter": {"OpenAI"}, "verarbeitungslaender": {"Irland"},
+		"avv_verfuegbar": {"on"}, "avv_url": {"https://example.com/avv"},
+		"training_standard": {"on"}, "letzte_pruefung": {"2026-08-01"}, "quelle": {"https://example.com/beleg"},
+	}
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber FG", "betreiber-fg@example.com", "betreiber")
+	if resp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", werkzeugForm); resp.Code != http.StatusSeeOther {
+		t.Fatalf("Werkzeug anlegen: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	resp := postForm(t, s, mitarbeiterCookie, "/antraege", besondereKategorieAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("Antrag anlegen: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	for id, a := range fs.antraege {
+		if a.AccountID == acc.ID {
+			antragID = id
+		}
+	}
+	if antragID == "" {
+		t.Fatal("kein Antrag im Mandanten gefunden")
+	}
+
+	verantwortlicherCookie = seedUserInAccount(t, fs, acc.ID, "verantwortlicher-fg@example.com", "verantwortlicher")
+	return acc.ID, antragID, verantwortlicherCookie
+}
+
+// werkzeugIDFor findet die ID des einzigen im fakeStore angelegten
+// Werkzeugs — fuer die Genehmigungs-Formulare in diesen Tests reicht ein
+// einziges zentrales Werkzeug.
+func werkzeugIDFor(fs *fakeStore, name string) string {
+	for id, w := range fs.werkzeuge {
+		if w.Name == name {
+			return id
+		}
+	}
+	return ""
+}
+
+func TestOhneFreigabeRegelnVerhaeltSichWieVorher(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	_, antragID, verantwortlicherCookie := seedFreigabeSzenario(t, fs, s)
+	werkzeugID := werkzeugIDFor(fs, "ChatGPT Enterprise")
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {werkzeugID},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("entscheiden: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if fs.antraege[antragID].Status != "entschieden" {
+		t.Fatalf("Status = %q, want entschieden (keine Freigabe-Regel konfiguriert)", fs.antraege[antragID].Status)
+	}
+	regEintraege := fs.registereintraege[fs.antraege[antragID].AccountID]
+	if len(regEintraege) != 1 {
+		t.Fatalf("erwartet 1 Registereintrag ohne Freigabe-Regeln, got %d", len(regEintraege))
+	}
+}
+
+func TestFreigabeWorkflowGatesBisAlleZugestimmtHaben(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID, antragID, verantwortlicherCookie := seedFreigabeSzenario(t, fs, s)
+	werkzeugID := werkzeugIDFor(fs, "ChatGPT Enterprise")
+
+	dsb, err := fs.CreateGenehmigerRolle(context.Background(), accountID, "Datenschutzbeauftragter", "")
+	if err != nil {
+		t.Fatalf("CreateGenehmigerRolle: %v", err)
+	}
+	if _, err := fs.CreateFreigabeRegel(context.Background(), accountID, "anforderung", "dsfa_erforderlich", dsb.ID); err != nil {
+		t.Fatalf("CreateFreigabeRegel: %v", err)
+	}
+	dsbCookie := seedUserInAccount(t, fs, accountID, "dsb@example.com", "mitarbeiter")
+	dsbUser, err := fs.GetUserByEmail(context.Background(), "dsb@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	if err := fs.AddNutzerGenehmigerRolle(context.Background(), dsbUser.ID, dsb.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle: %v", err)
+	}
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {werkzeugID},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("entscheiden: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if got := fs.antraege[antragID].Status; got != "wartet_auf_freigabe" {
+		t.Fatalf("Status = %q, want wartet_auf_freigabe", got)
+	}
+	if len(fs.registereintraege[accountID]) != 0 {
+		t.Fatalf("erwartet noch keinen Registereintrag vor vollstaendiger Freigabe, got %d", len(fs.registereintraege[accountID]))
+	}
+
+	listResp := getWithCookie(t, s, dsbCookie, "/freigaben")
+	if listResp.Code != http.StatusOK || !strings.Contains(listResp.Body.String(), "Gesundheitsdaten auswerten") {
+		t.Fatalf("Meine Freigaben zeigt den Antrag nicht, status=%d body=%s", listResp.Code, listResp.Body.String())
+	}
+
+	var schrittID string
+	for id, fsr := range fs.freigabeschritte {
+		if fsr.AntragID == antragID {
+			schrittID = id
+		}
+	}
+	if schrittID == "" {
+		t.Fatal("kein Freigabeschritt fuer den Antrag gefunden")
+	}
+
+	decideResp := postForm(t, s, dsbCookie, "/freigaben/"+schrittID+"/entscheiden", url.Values{"entscheidung": {"genehmigt"}})
+	if decideResp.Code != http.StatusSeeOther {
+		t.Fatalf("freigabe entscheiden: status = %d, body: %s", decideResp.Code, decideResp.Body.String())
+	}
+	if got := fs.antraege[antragID].Status; got != "entschieden" {
+		t.Fatalf("Status nach vollstaendiger Freigabe = %q, want entschieden", got)
+	}
+	if len(fs.registereintraege[accountID]) != 1 {
+		t.Fatalf("erwartet 1 Registereintrag nach vollstaendiger Freigabe, got %d", len(fs.registereintraege[accountID]))
+	}
+}
+
+func TestFreigabeAblehnungKipptGesamtenAntrag(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID, antragID, verantwortlicherCookie := seedFreigabeSzenario(t, fs, s)
+	werkzeugID := werkzeugIDFor(fs, "ChatGPT Enterprise")
+
+	dsb, _ := fs.CreateGenehmigerRolle(context.Background(), accountID, "Datenschutzbeauftragter", "")
+	gf, _ := fs.CreateGenehmigerRolle(context.Background(), accountID, "Geschaeftsfuehrung", "")
+	fs.CreateFreigabeRegel(context.Background(), accountID, "anforderung", "dsfa_erforderlich", dsb.ID)
+	fs.CreateFreigabeRegel(context.Background(), accountID, "datenklasse", "besondere_kategorie", gf.ID)
+
+	dsbCookie := seedUserInAccount(t, fs, accountID, "dsb2@example.com", "mitarbeiter")
+	dsbUser, _ := fs.GetUserByEmail(context.Background(), "dsb2@example.com")
+	fs.AddNutzerGenehmigerRolle(context.Background(), dsbUser.ID, dsb.ID)
+	seedUserInAccount(t, fs, accountID, "gf@example.com", "mitarbeiter")
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {werkzeugID},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("entscheiden: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	var dsbSchrittID string
+	for id, fsr := range fs.freigabeschritte {
+		if fsr.AntragID == antragID && fsr.GenehmigerRolleID == dsb.ID {
+			dsbSchrittID = id
+		}
+	}
+	if dsbSchrittID == "" {
+		t.Fatal("kein DSB-Freigabeschritt gefunden")
+	}
+
+	decideResp := postForm(t, s, dsbCookie, "/freigaben/"+dsbSchrittID+"/entscheiden", url.Values{
+		"entscheidung": {"abgelehnt"}, "kommentar": {"Nicht ausreichend pseudonymisiert"},
+	})
+	if decideResp.Code != http.StatusSeeOther {
+		t.Fatalf("freigabe ablehnen: status = %d, body: %s", decideResp.Code, decideResp.Body.String())
+	}
+
+	if got := fs.antraege[antragID].Status; got != "entschieden" {
+		t.Fatalf("Status nach Ablehnung = %q, want entschieden", got)
+	}
+	letzte := fs.entscheidungen[antragID]
+	if len(letzte) == 0 || letzte[len(letzte)-1].Entscheidung != "abgelehnt" {
+		t.Fatalf("letzte Entscheidung = %+v, want abgelehnt", letzte)
+	}
+	for _, fsr := range fs.freigabeschritte {
+		if fsr.AntragID == antragID && fsr.Status == "ausstehend" {
+			t.Fatalf("erwartet keine ausstehenden Freigabeschritte mehr nach Ablehnung, gefunden: %+v", fsr)
+		}
+	}
+	if len(fs.registereintraege[accountID]) != 0 {
+		t.Fatalf("erwartet keinen Registereintrag nach Ablehnung, got %d", len(fs.registereintraege[accountID]))
+	}
+}
+
+func TestFreigabeEntscheidenOhneRolleWirdAbgelehnt(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID, antragID, verantwortlicherCookie := seedFreigabeSzenario(t, fs, s)
+	werkzeugID := werkzeugIDFor(fs, "ChatGPT Enterprise")
+
+	dsb, _ := fs.CreateGenehmigerRolle(context.Background(), accountID, "Datenschutzbeauftragter", "")
+	fs.CreateFreigabeRegel(context.Background(), accountID, "anforderung", "dsfa_erforderlich", dsb.ID)
+
+	fremdCookie := seedUserInAccount(t, fs, accountID, "fremd@example.com", "mitarbeiter")
+
+	postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {werkzeugID},
+	})
+	var schrittID string
+	for id, fsr := range fs.freigabeschritte {
+		if fsr.AntragID == antragID {
+			schrittID = id
+		}
+	}
+
+	resp := postForm(t, s, fremdCookie, "/freigaben/"+schrittID+"/entscheiden", url.Values{"entscheidung": {"genehmigt"}})
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 fuer eine Person ohne die noetige Genehmiger-Rolle", resp.Code)
+	}
+}
+
+func TestGenehmigerRolleCRUD(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "GR-Mandant", "admin-gr@example.com", "admin")
+	admin, err := fs.GetUserByEmail(context.Background(), "admin-gr@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/genehmiger-rollen", url.Values{"name": {"Geschaeftsfuehrung"}})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("anlegen: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	var rolleID string
+	for id, g := range fs.genehmigerRollen {
+		if g.Name == "Geschaeftsfuehrung" {
+			rolleID = id
+		}
+	}
+	if rolleID == "" {
+		t.Fatal("Genehmiger-Rolle wurde nicht angelegt")
+	}
+
+	assignResp := postForm(t, s, adminCookie, "/verwaltung/genehmiger-rollen/"+rolleID+"/mitglieder", url.Values{"user_id": {admin.ID}})
+	if assignResp.Code != http.StatusSeeOther {
+		t.Fatalf("zuweisen: status = %d, body: %s", assignResp.Code, assignResp.Body.String())
+	}
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/genehmiger-rollen")
+	if !strings.Contains(list.Body.String(), "admin-gr@example.com") {
+		t.Errorf("erwartet das zugewiesene Mitglied auf der Liste, got: %s", list.Body.String())
+	}
+
+	removeResp := postForm(t, s, adminCookie, "/verwaltung/genehmiger-rollen/"+rolleID+"/mitglieder/"+admin.ID+"/entfernen", url.Values{})
+	if removeResp.Code != http.StatusSeeOther {
+		t.Fatalf("entfernen: status = %d, body: %s", removeResp.Code, removeResp.Body.String())
+	}
+}

internal/web/loeschfrist_handlers.go

@@ -0,0 +1,98 @@
+// Löschfristen je Datenklasse (Migration 0020) — schließt rules/OPEN.md,
+// Punkt 4. Die Tageswerte sind KEINE gesetzliche Vorgabe (die DSGVO
+// nennt keine festen Fristen, nur den Grundsatz "so lange wie für den
+// Zweck nötig", Art. 5 Abs. 1 lit. e) — deshalb pro Mandant einstellbar,
+// vom Datenschutzbeauftragten hinterlegt, mit risikogestaffelten
+// Vorschlagswerten vorbelegt. Wie alle anderen /verwaltung/*-Seiten
+// bewusst admin-only (konsistent mit Nutzer-/Abteilungs-/Genehmiger-
+// Rollen-Verwaltung) statt an den Namen einer Genehmiger-Rolle
+// gekoppelt — Genehmiger-Rollen sind laut Architektur explizit ohne
+// eigenes Zugriffsrecht (siehe CLAUDE.md, Freigabe-Workflow).
+package web
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+)
+
+// standardLoeschfristen sind risikogestaffelte Vorschlagswerte, mit
+// denen jede neue Firma vorbelegt wird — je sensibler die Datenklasse,
+// desto kürzer die vorgeschlagene Frist. Frei editierbar unter
+// /verwaltung/loeschfristen, keine Rechtsvorgabe.
+var standardLoeschfristen = []struct {
+	DatenklasseID string
+	MaxTage       int
+}{
+	{"oeffentlich", 365},
+	{"intern", 180},
+	{"auftragsdaten", 90},
+	{"personenbezogen", 90},
+	{"berufsgeheimnis", 30},
+	{"besondere_kategorie", 30},
+}
+
+// seedStandardLoeschfristen wird direkt nach dem Anlegen einer neuen
+// Firma aufgerufen (öffentliche Registrierung und Betreiber-Firmenanlage),
+// analog zu seedStandardGenehmigerRollen.
+func (s *Server) seedStandardLoeschfristen(ctx context.Context, accountID string) error {
+	for _, l := range standardLoeschfristen {
+		if _, err := s.store.UpsertLoeschfristEinstellung(ctx, accountID, l.DatenklasseID, l.MaxTage); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type loeschfristZeile struct {
+	DatenklasseID string
+	MaxTage       int
+}
+
+type loeschfristenListeData struct {
+	Title       string
+	Nav         navData
+	Zeilen      []loeschfristZeile
+	Error       string
+	Gespeichert bool
+}
+
+func (s *Server) handleLoeschfristenListe(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	einstellungen, err := s.store.ListLoeschfristEinstellungenForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Löschfristen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := loeschfristenListeData{Title: "Löschfristen", Nav: navFor(r), Gespeichert: r.URL.Query().Get("gespeichert") == "1"}
+	for _, e := range einstellungen {
+		data.Zeilen = append(data.Zeilen, loeschfristZeile{DatenklasseID: e.DatenklasseID, MaxTage: e.MaxTage})
+	}
+	if err := s.templates.ExecuteTemplate(w, "loeschfristen-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) handleLoeschfristenSpeichern(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	accountID := currentUser(r).AccountID
+	for _, l := range standardLoeschfristen {
+		raw := r.FormValue("max_tage_" + l.DatenklasseID)
+		if raw == "" {
+			continue
+		}
+		maxTage, err := strconv.Atoi(raw)
+		if err != nil || maxTage < 0 {
+			http.Error(w, "ungültiger Wert für "+l.DatenklasseID, http.StatusBadRequest)
+			return
+		}
+		if _, err := s.store.UpsertLoeschfristEinstellung(r.Context(), accountID, l.DatenklasseID, maxTage); err != nil {
+			http.Error(w, "Speichern fehlgeschlagen: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+	http.Redirect(w, r, "/verwaltung/loeschfristen?gespeichert=1", http.StatusSeeOther)
+}

internal/web/pagination.go

@@ -8,6 +8,7 @@ package web
 import (
 	"net/http"
 	"strconv"
+	"strings"
 )
 
 const defaultPerPage = 20
@@ -65,6 +66,25 @@ func (p pagination) bounds() (start, end int) {
 	return start, end
 }
 
+// matchesQuery prüft, ob q (Freitext-Suche, ohne Beachtung von
+// Groß-/Kleinschreibung) in mindestens einem der übergebenen Felder
+// vorkommt — leeres q trifft immer zu. Gemeinsame Basis für die
+// Freitext-Filter mehrerer Listen-Seiten (Register, Nutzerverwaltung,
+// Posteingang, ...), damit nicht jede Liste ihre eigene Such-Logik
+// erfindet.
+func matchesQuery(q string, felder ...string) bool {
+	if q == "" {
+		return true
+	}
+	q = strings.ToLower(q)
+	for _, f := range felder {
+		if strings.Contains(strings.ToLower(f), q) {
+			return true
+		}
+	}
+	return false
+}
+
 // paginate schneidet den Ausschnitt für die aktuelle Seite aus einer
 // bereits gefilterten/sortierten Liste heraus — generisch, damit jede
 // Listen-Seite (Werkzeuge, Register, ...) dieselbe Funktion nutzt statt

internal/web/passwort_reset_handlers.go

@@ -0,0 +1,103 @@
+// Passwort-Zurücksetzen (Ebene 1, öffentlich) — nutzt internal/mail für
+// den Versand. Wie beim Login verrät keine Fehlermeldung, ob eine
+// E-Mail-Adresse überhaupt existiert (User-Enumeration-Schutz): die
+// Anfrage-Seite zeigt immer dieselbe Erfolgsmeldung, unabhängig davon,
+// ob tatsächlich eine Mail verschickt wurde.
+package web
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/netcell-it/deklarix/internal/auth"
+)
+
+const passwortVergessenHinweis = "Falls diese E-Mail-Adresse bei uns registriert ist, wurde ein Link zum Zurücksetzen verschickt."
+
+func (s *Server) handlePasswortVergessenForm(w http.ResponseWriter, r *http.Request) {
+	s.renderAuthPage(w, "passwort-vergessen", authPageData{Title: "Passwort vergessen"})
+}
+
+func (s *Server) handlePasswortVergessen(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		s.renderAuthPage(w, "passwort-vergessen", authPageData{Title: "Passwort vergessen", Error: "ungültiges Formular"})
+		return
+	}
+	email := r.FormValue("email")
+
+	user, err := s.store.GetUserByEmail(r.Context(), email)
+	if err == nil && user.Active {
+		token, tokenErr := auth.NewSessionToken()
+		if tokenErr == nil {
+			if _, createErr := s.store.CreatePasswordResetToken(r.Context(), user.ID, token); createErr == nil {
+				scheme := "http"
+				if r.TLS != nil {
+					scheme = "https"
+				}
+				link := fmt.Sprintf("%s://%s/passwort-zuruecksetzen/%s", scheme, r.Host, token)
+				body := "Hallo,\n\nüber diesen Link kannst du dein Deklarix-Passwort zurücksetzen (gültig 1 Stunde):\n" + link + "\n\nFalls du das nicht angefordert hast, ignoriere diese E-Mail."
+				// Versandfehler wird bewusst nicht an den Nutzer durchgereicht
+				// (keine Enumeration über unterschiedliches Verhalten bei
+				// Versandfehlern), aber serverseitig geloggt statt
+				// verschluckt — sonst bleibt ein dauerhaft falsch
+				// konfigurierter SMTP-Server unbemerkt.
+				if err := s.mailer.Send(user.Email, "Deklarix — Passwort zurücksetzen", body); err != nil {
+					log.Printf("passwort-vergessen: mail versand fehlgeschlagen: %v", err)
+				}
+			}
+		}
+	}
+
+	s.renderAuthPage(w, "passwort-vergessen", authPageData{Title: "Passwort vergessen", Message: passwortVergessenHinweis})
+}
+
+type passwortZuruecksetzenData struct {
+	Title string
+	Token string
+	Error string
+}
+
+func (s *Server) handlePasswortZuruecksetzenForm(w http.ResponseWriter, r *http.Request) {
+	token := r.PathValue("token")
+	if _, err := s.store.GetValidPasswordResetToken(r.Context(), token); err != nil {
+		http.Error(w, "Link ist ungültig oder abgelaufen", http.StatusNotFound)
+		return
+	}
+	if err := s.templates.ExecuteTemplate(w, "passwort-zuruecksetzen", passwortZuruecksetzenData{Title: "Neues Passwort setzen", Token: token}); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) handlePasswortZuruecksetzen(w http.ResponseWriter, r *http.Request) {
+	token := r.PathValue("token")
+	resetToken, err := s.store.GetValidPasswordResetToken(r.Context(), token)
+	if err != nil {
+		http.Error(w, "Link ist ungültig oder abgelaufen", http.StatusNotFound)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		s.renderPasswortZuruecksetzenError(w, token, "ungültiges Formular")
+		return
+	}
+	passwordHash, err := auth.HashPassword(r.FormValue("password"))
+	if err != nil {
+		s.renderPasswortZuruecksetzenError(w, token, err.Error())
+		return
+	}
+	if err := s.store.SetUserPassword(r.Context(), resetToken.UserID, passwordHash); err != nil {
+		s.renderPasswortZuruecksetzenError(w, token, "Passwort konnte nicht gesetzt werden")
+		return
+	}
+	if err := s.store.MarkPasswordResetTokenUsed(r.Context(), resetToken.ID); err != nil {
+		s.renderPasswortZuruecksetzenError(w, token, "Passwort wurde gesetzt, Token konnte aber nicht als verwendet markiert werden")
+		return
+	}
+	http.Redirect(w, r, "/login?reset=1", http.StatusSeeOther)
+}
+
+func (s *Server) renderPasswortZuruecksetzenError(w http.ResponseWriter, token, msg string) {
+	if err := s.templates.ExecuteTemplate(w, "passwort-zuruecksetzen", passwortZuruecksetzenData{Title: "Neues Passwort setzen", Token: token, Error: msg}); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}

internal/web/passwort_reset_handlers_test.go

@@ -0,0 +1,94 @@
+package web_test
+
+import (
+	"net/http"
+	"net/url"
+	"regexp"
+	"testing"
+)
+
+var resetLinkPattern = regexp.MustCompile(`/passwort-zuruecksetzen/([a-f0-9]+)`)
+
+func TestPasswortVergessenSendetLinkUndSetztNeuesPasswort(t *testing.T) {
+	fs := newFakeStore()
+	s, fm := newServerWithMailer(t, fs)
+
+	regResp := postForm(t, s, nil, "/register", url.Values{
+		"account_name": {"Reset-Firma"}, "email": {"reset@example.com"},
+		"password": {"altes-passwort"},
+	})
+	if regResp.Code != http.StatusSeeOther {
+		t.Fatalf("register status = %d, want 303", regResp.Code)
+	}
+
+	vergessenResp := postForm(t, s, nil, "/passwort-vergessen", url.Values{"email": {"reset@example.com"}})
+	if vergessenResp.Code != http.StatusOK {
+		t.Fatalf("passwort-vergessen status = %d, want 200", vergessenResp.Code)
+	}
+	if len(fm.Sent) != 1 {
+		t.Fatalf("got %d gesendete Mails, want 1", len(fm.Sent))
+	}
+	match := resetLinkPattern.FindStringSubmatch(fm.Sent[0].Body)
+	if match == nil {
+		t.Fatalf("kein Reset-Link in Mail-Body gefunden: %q", fm.Sent[0].Body)
+	}
+	token := match[1]
+
+	getResp := getWithCookie(t, s, nil, "/passwort-zuruecksetzen/"+token)
+	if getResp.Code != http.StatusOK {
+		t.Fatalf("get reset form status = %d, want 200", getResp.Code)
+	}
+
+	resetResp := postForm(t, s, nil, "/passwort-zuruecksetzen/"+token, url.Values{"password": {"neues-passwort-123"}})
+	if resetResp.Code != http.StatusSeeOther {
+		t.Fatalf("reset status = %d, want 303, body: %s", resetResp.Code, resetResp.Body.String())
+	}
+
+	// Derselbe Link darf kein zweites Mal funktionieren.
+	reuseResp := postForm(t, s, nil, "/passwort-zuruecksetzen/"+token, url.Values{"password": {"noch-ein-passwort"}})
+	if reuseResp.Code != http.StatusNotFound {
+		t.Fatalf("reuse status = %d, want 404 (Token bereits verwendet)", reuseResp.Code)
+	}
+
+	// Altes Passwort funktioniert nicht mehr.
+	oldLoginResp := postForm(t, s, nil, "/login", url.Values{"email": {"reset@example.com"}, "password": {"altes-passwort"}})
+	if oldLoginResp.Code != http.StatusOK {
+		t.Fatalf("login mit altem Passwort status = %d, want 200 (abgelehnt)", oldLoginResp.Code)
+	}
+
+	// Neues Passwort funktioniert.
+	newLoginResp := postForm(t, s, nil, "/login", url.Values{"email": {"reset@example.com"}, "password": {"neues-passwort-123"}})
+	if newLoginResp.Code != http.StatusSeeOther {
+		t.Fatalf("login mit neuem Passwort status = %d, want 303", newLoginResp.Code)
+	}
+}
+
+func TestPasswortVergessenFuerUnbekannteEmailVerraetNichts(t *testing.T) {
+	fs := newFakeStore()
+	s, fm := newServerWithMailer(t, fs)
+
+	resp := postForm(t, s, nil, "/passwort-vergessen", url.Values{"email": {"gibt-es-nicht@example.com"}})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", resp.Code)
+	}
+	if len(fm.Sent) != 0 {
+		t.Fatalf("got %d gesendete Mails für unbekannte E-Mail, want 0", len(fm.Sent))
+	}
+	if !containsHinweis(resp.Body.String()) {
+		t.Fatalf("erwartete generische Erfolgsmeldung, body: %s", resp.Body.String())
+	}
+}
+
+func containsHinweis(body string) bool {
+	return regexp.MustCompile(`Falls diese E-Mail-Adresse`).MatchString(body)
+}
+
+func TestPasswortZuruecksetzenMitUngueltigemTokenGibt404(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+
+	resp := getWithCookie(t, s, nil, "/passwort-zuruecksetzen/nicht-existierendes-token")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404", resp.Code)
+	}
+}

internal/web/register_handlers.go

@@ -27,9 +27,11 @@ type registerEintragView struct {
 }
 
 type registerListeData struct {
-	Title     string
-	Nav       navData
-	Eintraege []registerEintragView
+	Title      string
+	Nav        navData
+	Eintraege  []registerEintragView
+	Suche      string
+	Pagination pagination
 }
 
 func (s *Server) registerEintraegeFuerAccount(r *http.Request) ([]registerEintragView, error) {
@@ -61,7 +63,18 @@ func (s *Server) handleRegisterListe(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Register konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := registerListeData{Title: "Register", Nav: navFor(r), Eintraege: views}
+	q := strings.TrimSpace(r.URL.Query().Get("q"))
+	var gefiltert []registerEintragView
+	for _, e := range views {
+		if matchesQuery(q, e.Zweck, e.Abteilung, e.Werkzeug, e.Verantwortlicher) {
+			gefiltert = append(gefiltert, e)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	data := registerListeData{
+		Title: "Register", Nav: navFor(r), Eintraege: paginate(gefiltert, pag),
+		Suche: q, Pagination: pag,
+	}
 	if err := s.templates.ExecuteTemplate(w, "register-liste", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
 	}

internal/web/server.go

@@ -13,6 +13,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/netcell-it/deklarix/internal/mail"
 	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 )
@@ -39,6 +40,12 @@ type Store interface {
 	GetUser(ctx context.Context, id string) (store.User, error)
 	ListUsersForAccount(ctx context.Context, accountID string) ([]store.User, error)
 	SetUserActive(ctx context.Context, id string, active bool) error
+	SetUserPassword(ctx context.Context, id, passwordHash string) error
+	UpsertLoeschfristEinstellung(ctx context.Context, accountID, datenklasseID string, maxTage int) (store.LoeschfristEinstellung, error)
+	ListLoeschfristEinstellungenForAccount(ctx context.Context, accountID string) ([]store.LoeschfristEinstellung, error)
+	CreatePasswordResetToken(ctx context.Context, userID, token string) (store.PasswordResetToken, error)
+	GetValidPasswordResetToken(ctx context.Context, token string) (store.PasswordResetToken, error)
+	MarkPasswordResetTokenUsed(ctx context.Context, id string) error
 	CreateSession(ctx context.Context, token, userID string, expiresAt time.Time) (store.Session, error)
 	CreateImpersonatedSession(ctx context.Context, token, userID, impersonatedByUserID string, expiresAt time.Time) (store.Session, error)
 	GetSession(ctx context.Context, token string) (store.Session, error)
@@ -76,6 +83,27 @@ type Store interface {
 	GetAbteilung(ctx context.Context, id string) (store.Abteilung, error)
 	CreateRegistereintrag(ctx context.Context, in store.RegistereintragInput) (store.Registereintrag, error)
 	ListRegistereintraegeForAccount(ctx context.Context, accountID string) ([]store.Registereintrag, error)
+
+	CreateGenehmigerRolle(ctx context.Context, accountID, name, beschreibung string) (store.GenehmigerRolle, error)
+	GetGenehmigerRolle(ctx context.Context, id string) (store.GenehmigerRolle, error)
+	ListGenehmigerRollenForAccount(ctx context.Context, accountID string) ([]store.GenehmigerRolle, error)
+	DeleteGenehmigerRolle(ctx context.Context, id string) error
+	AddNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error
+	RemoveNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error
+	ListGenehmigerRollenForUser(ctx context.Context, userID string) ([]store.GenehmigerRolle, error)
+	ListNutzerForGenehmigerRolle(ctx context.Context, genehmigerRolleID string) ([]store.GenehmigerMitglied, error)
+
+	CreateFreigabeRegel(ctx context.Context, accountID, bedingungTyp, bedingungWert, genehmigerRolleID string) (store.FreigabeRegel, error)
+	ListFreigabeRegelnForAccount(ctx context.Context, accountID string) ([]store.FreigabeRegel, error)
+	GetFreigabeRegel(ctx context.Context, id string) (store.FreigabeRegel, error)
+	DeleteFreigabeRegel(ctx context.Context, id string) error
+
+	CreateFreigabeschritt(ctx context.Context, antragID, genehmigerRolleID string) (store.Freigabeschritt, error)
+	GetFreigabeschritt(ctx context.Context, id string) (store.Freigabeschritt, error)
+	ListFreigabeschritteForAntrag(ctx context.Context, antragID string) ([]store.Freigabeschritt, error)
+	ListAusstehendeFreigabeschritteForUser(ctx context.Context, userID string) ([]store.Freigabeschritt, error)
+	EntscheideFreigabeschritt(ctx context.Context, id, status, entschiedenVon, kommentar string) (store.Freigabeschritt, error)
+	KaskadiereAblehnung(ctx context.Context, antragID, ausloesenderSchrittID string) error
 }
 
 // Regelwerk bündelt die drei geladenen Regelwerk-Dateien, die die
@@ -94,11 +122,15 @@ type Server struct {
 	store     Store
 	regelwerk Regelwerk
 	templates *template.Template
+	mailer    mail.Mailer
 }
 
 // NewServer erstellt den Server. regelwerk kommt von rules.Load* und
-// wird einmal beim Start geladen, nicht pro Request.
-func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
+// wird einmal beim Start geladen, nicht pro Request. mailer ist
+// austauschbar (siehe mail.FakeMailer für Tests) — ohne konfigurierten
+// SMTP-Server schlägt nur der tatsächliche Versand fehl (z. B.
+// Passwort-Zurücksetzen), der restliche Server bleibt funktionsfähig.
+func NewServer(st Store, regelwerk Regelwerk, mailer mail.Mailer) (*Server, error) {
 	tmpl, err := template.ParseFS(templatesFS, "templates/*.html")
 	if err != nil {
 		return nil, fmt.Errorf("web: templates parsen: %w", err)
@@ -108,6 +140,7 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 		store:     st,
 		regelwerk: regelwerk,
 		templates: tmpl,
+		mailer:    mailer,
 	}
 
 	mux := http.NewServeMux()
@@ -118,6 +151,12 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	mux.HandleFunc("POST /einladung/{token}", s.handleEinladungAnnehmen)
 	mux.HandleFunc("GET /login", s.handleLoginForm)
 	mux.HandleFunc("POST /login", s.handleLogin)
+	mux.HandleFunc("GET /verwaltung/loeschfristen", s.requireAdmin(s.handleLoeschfristenListe))
+	mux.HandleFunc("POST /verwaltung/loeschfristen", s.requireAdmin(s.handleLoeschfristenSpeichern))
+	mux.HandleFunc("GET /passwort-vergessen", s.handlePasswortVergessenForm)
+	mux.HandleFunc("POST /passwort-vergessen", s.handlePasswortVergessen)
+	mux.HandleFunc("GET /passwort-zuruecksetzen/{token}", s.handlePasswortZuruecksetzenForm)
+	mux.HandleFunc("POST /passwort-zuruecksetzen/{token}", s.handlePasswortZuruecksetzen)
 	mux.HandleFunc("POST /logout", s.handleLogout)
 	mux.HandleFunc("GET /{$}", s.requirePage(s.handleIndex))
 	mux.HandleFunc("GET /antraege", s.requirePage(s.handleAntragList))
@@ -151,6 +190,16 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	mux.HandleFunc("GET /verwaltung/werkzeuge/{id}", s.requireAdmin(s.handleMandantWerkzeugEditForm))
 	mux.HandleFunc("POST /verwaltung/werkzeuge/{id}", s.requireAdmin(s.handleMandantWerkzeugUpdate))
 	mux.HandleFunc("POST /verwaltung/werkzeuge/{id}/loeschen", s.requireAdmin(s.handleMandantWerkzeugDelete))
+	mux.HandleFunc("GET /verwaltung/genehmiger-rollen", s.requireAdmin(s.handleGenehmigerRollenListe))
+	mux.HandleFunc("POST /verwaltung/genehmiger-rollen", s.requireAdmin(s.handleGenehmigerRolleCreate))
+	mux.HandleFunc("POST /verwaltung/genehmiger-rollen/{id}/loeschen", s.requireAdmin(s.handleGenehmigerRolleDelete))
+	mux.HandleFunc("POST /verwaltung/genehmiger-rollen/{id}/mitglieder", s.requireAdmin(s.handleGenehmigerRolleMitgliedHinzufuegen))
+	mux.HandleFunc("POST /verwaltung/genehmiger-rollen/{id}/mitglieder/{userID}/entfernen", s.requireAdmin(s.handleGenehmigerRolleMitgliedEntfernen))
+	mux.HandleFunc("GET /verwaltung/freigabe-regeln", s.requireAdmin(s.handleFreigabeRegelnListe))
+	mux.HandleFunc("POST /verwaltung/freigabe-regeln", s.requireAdmin(s.handleFreigabeRegelCreate))
+	mux.HandleFunc("POST /verwaltung/freigabe-regeln/{id}/loeschen", s.requireAdmin(s.handleFreigabeRegelDelete))
+	mux.HandleFunc("GET /freigaben", s.requirePage(s.handleFreigabenListe))
+	mux.HandleFunc("POST /freigaben/{id}/entscheiden", s.requireAPI(s.handleFreigabeEntscheiden))
 	mux.HandleFunc("GET /betreiber", s.requireBetreiber(s.handleBetreiberDashboard))
 	mux.HandleFunc("GET /betreiber/accounts", s.requireBetreiber(s.handleBetreiberAccountList))
 	mux.HandleFunc("GET /betreiber/accounts/neu", s.requireBetreiber(s.handleBetreiberAccountNeuForm))

internal/web/server_test.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/netcell-it/deklarix/internal/auth"
+	"github.com/netcell-it/deklarix/internal/mail"
 	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 	"github.com/netcell-it/deklarix/internal/web"
@@ -38,21 +39,34 @@ type fakeStore struct {
 	entscheidungen    map[string][]store.Entscheidung    // antragID -> Entscheidungen, älteste zuerst
 	registereintraege map[string][]store.Registereintrag // accountID -> Registereintraege
 	werkzeugSperren   map[string][]store.WerkzeugSperre  // accountID -> Sperrungen
+
+	genehmigerRollen       map[string]store.GenehmigerRolle
+	nutzerGenehmigerRollen map[string]map[string]bool // userID -> Set von genehmigerRolleID
+	freigabeRegeln         map[string]store.FreigabeRegel
+	freigabeschritte       map[string]store.Freigabeschritt
+	passwordResetTokens    map[string]store.PasswordResetToken
+	loeschfristen          map[string]map[string]int // accountID -> datenklasseID -> maxTage
 }
 
 func newFakeStore() *fakeStore {
 	return &fakeStore{
-		accounts:          map[string]store.Account{},
-		users:             map[string]store.User{},
-		usersByEmail:      map[string]string{},
-		sessions:          map[string]store.Session{},
-		abteilungen:       map[string][]store.Abteilung{},
-		antraege:          map[string]store.Antrag{},
-		werkzeuge:         map[string]store.Werkzeug{},
-		bewertungen:       map[string][]store.Bewertung{},
-		entscheidungen:    map[string][]store.Entscheidung{},
-		registereintraege: map[string][]store.Registereintrag{},
-		werkzeugSperren:   map[string][]store.WerkzeugSperre{},
+		accounts:               map[string]store.Account{},
+		users:                  map[string]store.User{},
+		usersByEmail:           map[string]string{},
+		sessions:               map[string]store.Session{},
+		abteilungen:            map[string][]store.Abteilung{},
+		antraege:               map[string]store.Antrag{},
+		werkzeuge:              map[string]store.Werkzeug{},
+		bewertungen:            map[string][]store.Bewertung{},
+		entscheidungen:         map[string][]store.Entscheidung{},
+		registereintraege:      map[string][]store.Registereintrag{},
+		werkzeugSperren:        map[string][]store.WerkzeugSperre{},
+		genehmigerRollen:       map[string]store.GenehmigerRolle{},
+		nutzerGenehmigerRollen: map[string]map[string]bool{},
+		freigabeRegeln:         map[string]store.FreigabeRegel{},
+		freigabeschritte:       map[string]store.Freigabeschritt{},
+		passwordResetTokens:    map[string]store.PasswordResetToken{},
+		loeschfristen:          map[string]map[string]int{},
 	}
 }
 
@@ -172,6 +186,73 @@ func (f *fakeStore) SetUserActive(ctx context.Context, id string, active bool) e
 	return nil
 }
 
+func (f *fakeStore) SetUserPassword(ctx context.Context, id, passwordHash string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	u, ok := f.users[id]
+	if !ok {
+		return store.ErrNotFound
+	}
+	u.PasswordHash = passwordHash
+	f.users[id] = u
+	return nil
+}
+
+func (f *fakeStore) CreatePasswordResetToken(ctx context.Context, userID, token string) (store.PasswordResetToken, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	t := store.PasswordResetToken{
+		ID: f.newID(), UserID: userID, Token: token,
+		ExpiresAt: time.Now().Add(store.PasswordResetTokenDuration), CreatedAt: time.Now(),
+	}
+	f.passwordResetTokens[t.ID] = t
+	return t, nil
+}
+
+func (f *fakeStore) GetValidPasswordResetToken(ctx context.Context, token string) (store.PasswordResetToken, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for _, t := range f.passwordResetTokens {
+		if t.Token == token && t.UsedAt == nil && t.ExpiresAt.After(time.Now()) {
+			return t, nil
+		}
+	}
+	return store.PasswordResetToken{}, store.ErrNotFound
+}
+
+func (f *fakeStore) MarkPasswordResetTokenUsed(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	t, ok := f.passwordResetTokens[id]
+	if !ok {
+		return store.ErrNotFound
+	}
+	now := time.Now()
+	t.UsedAt = &now
+	f.passwordResetTokens[id] = t
+	return nil
+}
+
+func (f *fakeStore) UpsertLoeschfristEinstellung(ctx context.Context, accountID, datenklasseID string, maxTage int) (store.LoeschfristEinstellung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.loeschfristen[accountID] == nil {
+		f.loeschfristen[accountID] = map[string]int{}
+	}
+	f.loeschfristen[accountID][datenklasseID] = maxTage
+	return store.LoeschfristEinstellung{AccountID: accountID, DatenklasseID: datenklasseID, MaxTage: maxTage, UpdatedAt: time.Now()}, nil
+}
+
+func (f *fakeStore) ListLoeschfristEinstellungenForAccount(ctx context.Context, accountID string) ([]store.LoeschfristEinstellung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.LoeschfristEinstellung
+	for datenklasseID, maxTage := range f.loeschfristen[accountID] {
+		out = append(out, store.LoeschfristEinstellung{AccountID: accountID, DatenklasseID: datenklasseID, MaxTage: maxTage})
+	}
+	return out, nil
+}
+
 func (f *fakeStore) ListUsersForAccount(ctx context.Context, accountID string) ([]store.User, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -547,6 +628,208 @@ func (f *fakeStore) ListRegistereintraegeForAccount(ctx context.Context, account
 	return f.registereintraege[accountID], nil
 }
 
+func (f *fakeStore) CreateGenehmigerRolle(ctx context.Context, accountID, name, beschreibung string) (store.GenehmigerRolle, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	g := store.GenehmigerRolle{ID: f.newID(), AccountID: accountID, Name: name, Beschreibung: beschreibung, CreatedAt: time.Now()}
+	f.genehmigerRollen[g.ID] = g
+	return g, nil
+}
+
+func (f *fakeStore) GetGenehmigerRolle(ctx context.Context, id string) (store.GenehmigerRolle, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	g, ok := f.genehmigerRollen[id]
+	if !ok {
+		return store.GenehmigerRolle{}, store.ErrNotFound
+	}
+	return g, nil
+}
+
+func (f *fakeStore) ListGenehmigerRollenForAccount(ctx context.Context, accountID string) ([]store.GenehmigerRolle, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.GenehmigerRolle
+	for _, g := range f.genehmigerRollen {
+		if g.AccountID == accountID {
+			out = append(out, g)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) DeleteGenehmigerRolle(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.genehmigerRollen[id]; !ok {
+		return store.ErrNotFound
+	}
+	delete(f.genehmigerRollen, id)
+	return nil
+}
+
+func (f *fakeStore) AddNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.nutzerGenehmigerRollen[userID] == nil {
+		f.nutzerGenehmigerRollen[userID] = map[string]bool{}
+	}
+	f.nutzerGenehmigerRollen[userID][genehmigerRolleID] = true
+	return nil
+}
+
+func (f *fakeStore) RemoveNutzerGenehmigerRolle(ctx context.Context, userID, genehmigerRolleID string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	delete(f.nutzerGenehmigerRollen[userID], genehmigerRolleID)
+	return nil
+}
+
+func (f *fakeStore) ListGenehmigerRollenForUser(ctx context.Context, userID string) ([]store.GenehmigerRolle, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.GenehmigerRolle
+	for grID := range f.nutzerGenehmigerRollen[userID] {
+		if g, ok := f.genehmigerRollen[grID]; ok {
+			out = append(out, g)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) ListNutzerForGenehmigerRolle(ctx context.Context, genehmigerRolleID string) ([]store.GenehmigerMitglied, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.GenehmigerMitglied
+	for userID, set := range f.nutzerGenehmigerRollen {
+		if !set[genehmigerRolleID] {
+			continue
+		}
+		if u, ok := f.users[userID]; ok {
+			out = append(out, store.GenehmigerMitglied{UserID: u.ID, Email: u.Email})
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) CreateFreigabeRegel(ctx context.Context, accountID, bedingungTyp, bedingungWert, genehmigerRolleID string) (store.FreigabeRegel, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	fr := store.FreigabeRegel{
+		ID: f.newID(), AccountID: accountID, BedingungTyp: bedingungTyp,
+		BedingungWert: bedingungWert, GenehmigerRolleID: genehmigerRolleID, CreatedAt: time.Now(),
+	}
+	f.freigabeRegeln[fr.ID] = fr
+	return fr, nil
+}
+
+func (f *fakeStore) ListFreigabeRegelnForAccount(ctx context.Context, accountID string) ([]store.FreigabeRegel, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.FreigabeRegel
+	for _, fr := range f.freigabeRegeln {
+		if fr.AccountID == accountID {
+			out = append(out, fr)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) GetFreigabeRegel(ctx context.Context, id string) (store.FreigabeRegel, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	fr, ok := f.freigabeRegeln[id]
+	if !ok {
+		return store.FreigabeRegel{}, store.ErrNotFound
+	}
+	return fr, nil
+}
+
+func (f *fakeStore) DeleteFreigabeRegel(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.freigabeRegeln[id]; !ok {
+		return store.ErrNotFound
+	}
+	delete(f.freigabeRegeln, id)
+	return nil
+}
+
+func (f *fakeStore) CreateFreigabeschritt(ctx context.Context, antragID, genehmigerRolleID string) (store.Freigabeschritt, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	fs := store.Freigabeschritt{
+		ID: f.newID(), AntragID: antragID, GenehmigerRolleID: genehmigerRolleID,
+		Status: "ausstehend", CreatedAt: time.Now(),
+	}
+	f.freigabeschritte[fs.ID] = fs
+	return fs, nil
+}
+
+func (f *fakeStore) GetFreigabeschritt(ctx context.Context, id string) (store.Freigabeschritt, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	fs, ok := f.freigabeschritte[id]
+	if !ok {
+		return store.Freigabeschritt{}, store.ErrNotFound
+	}
+	return fs, nil
+}
+
+func (f *fakeStore) ListFreigabeschritteForAntrag(ctx context.Context, antragID string) ([]store.Freigabeschritt, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Freigabeschritt
+	for _, fs := range f.freigabeschritte {
+		if fs.AntragID == antragID {
+			out = append(out, fs)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) ListAusstehendeFreigabeschritteForUser(ctx context.Context, userID string) ([]store.Freigabeschritt, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Freigabeschritt
+	for grID := range f.nutzerGenehmigerRollen[userID] {
+		for _, fs := range f.freigabeschritte {
+			if fs.GenehmigerRolleID == grID && fs.Status == "ausstehend" {
+				out = append(out, fs)
+			}
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) EntscheideFreigabeschritt(ctx context.Context, id, status, entschiedenVon, kommentar string) (store.Freigabeschritt, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	fs, ok := f.freigabeschritte[id]
+	if !ok || fs.Status != "ausstehend" {
+		return store.Freigabeschritt{}, store.ErrNotFound
+	}
+	now := time.Now()
+	fs.Status, fs.EntschiedenVon, fs.EntschiedenAm, fs.Kommentar = status, &entschiedenVon, &now, kommentar
+	f.freigabeschritte[id] = fs
+	return fs, nil
+}
+
+func (f *fakeStore) KaskadiereAblehnung(ctx context.Context, antragID, ausloesenderSchrittID string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for id, fs := range f.freigabeschritte {
+		if fs.AntragID == antragID && fs.Status == "ausstehend" && id != ausloesenderSchrittID {
+			fs.Status = "abgelehnt"
+			now := time.Now()
+			fs.EntschiedenAm = &now
+			fs.Kommentar = "Automatisch abgelehnt, da eine andere erforderliche Freigabe für diesen Antrag abgelehnt wurde."
+			f.freigabeschritte[id] = fs
+		}
+	}
+	return nil
+}
+
 // ─── Test-Setup ───────────────────────────────────────────────────────
 
 // loadTestRegelwerk lädt die echten rules/*.yaml-Dateien — dieselben,
@@ -573,11 +856,18 @@ func loadTestRegelwerk(t *testing.T) web.Regelwerk {
 
 func newServer(t *testing.T, fs *fakeStore) *web.Server {
 	t.Helper()
-	s, err := web.NewServer(fs, loadTestRegelwerk(t))
+	s, _ := newServerWithMailer(t, fs)
+	return s
+}
+
+func newServerWithMailer(t *testing.T, fs *fakeStore) (*web.Server, *mail.FakeMailer) {
+	t.Helper()
+	fm := &mail.FakeMailer{}
+	s, err := web.NewServer(fs, loadTestRegelwerk(t), fm)
 	if err != nil {
 		t.Fatalf("NewServer: %v", err)
 	}
-	return s
+	return s, fm
 }
 
 // seedAccountWithRole legt direkt im fakeStore (ohne HTTP) einen
@@ -733,6 +1023,53 @@ func TestRegisterThenLoginThenAccessProtectedPage(t *testing.T) {
 	}
 }
 
+func TestRegisterSeedsStandardGenehmigerRollen(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+
+	regResp := postForm(t, s, nil, "/register", url.Values{
+		"account_name": {"Meine Firma"}, "email": {"neu2@example.com"},
+		"password": {"ein-sicheres-passwort"},
+	})
+	if regResp.Code != http.StatusSeeOther {
+		t.Fatalf("register status = %d, want 303, body: %s", regResp.Code, regResp.Body.String())
+	}
+
+	var accountID string
+	for _, u := range fs.users {
+		if u.Email == "neu2@example.com" {
+			accountID = u.AccountID
+		}
+	}
+	if accountID == "" {
+		t.Fatal("neuer Nutzer nicht gefunden")
+	}
+
+	rollen, err := fs.ListGenehmigerRollenForAccount(context.Background(), accountID)
+	if err != nil {
+		t.Fatalf("ListGenehmigerRollenForAccount: %v", err)
+	}
+	wantNamen := []string{"Datenschutzbeauftragter", "Geschäftsführer", "KI-Manager", "CISO"}
+	if len(rollen) != len(wantNamen) {
+		t.Fatalf("got %d Genehmiger-Rollen, want %d", len(rollen), len(wantNamen))
+	}
+	var namen []string
+	for _, r := range rollen {
+		namen = append(namen, r.Name)
+	}
+	for _, want := range wantNamen {
+		found := false
+		for _, n := range namen {
+			if n == want {
+				found = true
+			}
+		}
+		if !found {
+			t.Fatalf("Standard-Rolle %q wurde nicht angelegt, vorhanden: %v", want, namen)
+		}
+	}
+}
+
 func TestRegisterRejectsDuplicateEmail(t *testing.T) {
 	fs := newFakeStore()
 	s := newServer(t, fs)

internal/web/static/app.css

@@ -440,6 +440,7 @@ nav button {
 .beitraege-liste > li:not(:has(> a)) form {
   margin: 0;
   flex: 0 0 auto;
+  max-width: 100%;
 }
 
 .beitraege-liste > li:not(:has(> a)) button {
@@ -755,6 +756,12 @@ tbody tr:hover {
    pagination.go. */
 .filter-bar {
   display: flex;
+  /* explizit setzen, nicht dem initial-value überlassen: .filter-bar
+     landet manchmal direkt auf einem <form>, und "form { flex-direction:
+     column }" (oben) hat dieselbe Spezifität für DIESE Property, wenn
+     .filter-bar sie nicht selbst deklariert — das Formular würde dann
+     senkrecht stapeln statt in einer Zeile. */
+  flex-direction: row;
   flex-wrap: wrap;
   align-items: center;
   gap: 8px;

internal/web/templates/abteilung_liste.html

@@ -4,8 +4,12 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Abteilungen</h1>
-<p class="hinweis">Stammdaten für den Fragebogen (Feld "Abteilung").</p>
+<div class="page-header">
+  <div>
+    <h1>Abteilungen</h1>
+    <p class="hinweis">Stammdaten für den Fragebogen (Feld "Abteilung").</p>
+  </div>
+</div>
 {{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
 {{if not .Abteilungen}}
 <p class="hinweis">Noch keine Abteilungen.</p>

internal/web/templates/antraege_liste.html

@@ -4,22 +4,42 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Meine Anträge</h1>
-{{if not .Antraege}}
-<p class="hinweis">Noch keine Anträge gestellt.</p>
-{{else}}
-<ul class="beitraege-liste">
-  {{range .Antraege}}
-  <li>
-    <a href="/antraege/{{.ID}}">
-      <strong>{{.Titel}}</strong> · {{.Haeufigkeit}} · {{.CreatedAt}}
-      <span class="status status-{{.Status}}">{{.Status}}</span>
-    </a>
-  </li>
+<div class="page-header">
+  <div>
+    <h1>Meine Anträge</h1>
+    <p class="hinweis">Eigene Anträge und ihr Bearbeitungsstand.</p>
+  </div>
+  <a class="page-header-action" href="/antraege/neu">Neuen Antrag stellen</a>
+</div>
+<form method="get">
+  <div class="filter-bar">
+    <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (Titel, Status, Häufigkeit)">
+    <button type="submit">Filtern</button>
+    {{if .Suche}}<a href="/antraege">Zurücksetzen</a>{{end}}
+  </div>
+
+  {{if not .Antraege}}
+  <p class="hinweis">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Noch keine Anträge gestellt.{{end}}</p>
+  {{else}}
+  <ul class="beitraege-liste">
+    {{range .Antraege}}
+    <li>
+      <a href="/antraege/{{.ID}}">
+        <strong>{{.Titel}}</strong> · {{.Haeufigkeit}} · {{.CreatedAt}}
+        <span class="status status-{{.Status}}">{{.Status}}</span>
+      </a>
+    </li>
+    {{end}}
+  </ul>
+  <div class="pagination">
+    <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+    <span>
+      {{if .Pagination.HasPrev}}<button type="submit" name="page" value="{{.Pagination.PrevPage}}">&larr; Zurück</button>{{end}}
+      {{if .Pagination.HasNext}}<button type="submit" name="page" value="{{.Pagination.NextPage}}">Weiter &rarr;</button>{{end}}
+    </span>
+  </div>
   {{end}}
-</ul>
-{{end}}
-<p><a href="/antraege/neu">Neuen Antrag stellen</a></p>
+</form>
 </div>
 </body>
 </html>

internal/web/templates/betreiber_accounts.html

@@ -5,9 +5,20 @@
 {{template "nav" .Nav}}
 <div class="page">
 <p><a href="/betreiber">&larr; Plattform</a></p>
-<h1>Accounts</h1>
+<div class="page-header">
+  <div>
+    <h1>Accounts</h1>
+    <p class="hinweis">Alle Mandanten der Plattform.</p>
+  </div>
+  <a class="page-header-action" href="/betreiber/accounts/neu">Firma anlegen</a>
+</div>
+<form method="get" class="filter-bar">
+  <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (Firmenname)">
+  <button type="submit">Filtern</button>
+  {{if .Suche}}<a href="/betreiber/accounts">Zurücksetzen</a>{{end}}
+</form>
 {{if not .Accounts}}
-<p class="hinweis">Noch keine Accounts.</p>
+<p class="hinweis">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Noch keine Accounts.{{end}}</p>
 {{else}}
 <ul class="beitraege-liste">
   {{range .Accounts}}
@@ -18,8 +29,26 @@
   </li>
   {{end}}
 </ul>
+<div class="pagination">
+  <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+  <span>
+    {{if .Pagination.HasPrev}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.PrevPage}}">
+      <button type="submit">&larr; Zurück</button>
+    </form>
+    {{end}}
+    {{if .Pagination.HasNext}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.NextPage}}">
+      <button type="submit">Weiter &rarr;</button>
+    </form>
+    {{end}}
+  </span>
+</div>
 {{end}}
-<p><a href="/betreiber/accounts/neu">Firma anlegen</a></p>
 </div>
 </body>
 </html>

internal/web/templates/betreiber_audit_log.html

@@ -5,9 +5,19 @@
 {{template "nav" .Nav}}
 <div class="page">
 <p><a href="/betreiber">&larr; Plattform</a></p>
-<h1>Audit-Log</h1>
+<div class="page-header">
+  <div>
+    <h1>Audit-Log</h1>
+    <p class="hinweis">Plattformweit, append-only — zeigt die neuesten Einträge.</p>
+  </div>
+</div>
+<form method="get" class="filter-bar">
+  <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (Aktion, Zieltyp, Details)">
+  <button type="submit">Filtern</button>
+  {{if .Suche}}<a href="/betreiber/audit-log">Zurücksetzen</a>{{end}}
+</form>
 {{if not .Entries}}
-<p class="hinweis">Noch keine Einträge.</p>
+<p class="hinweis">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Noch keine Einträge.{{end}}</p>
 {{else}}
 <ul class="beteiligte">
   {{range .Entries}}
@@ -17,6 +27,25 @@
   </li>
   {{end}}
 </ul>
+<div class="pagination">
+  <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+  <span>
+    {{if .Pagination.HasPrev}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.PrevPage}}">
+      <button type="submit">&larr; Zurück</button>
+    </form>
+    {{end}}
+    {{if .Pagination.HasNext}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.NextPage}}">
+      <button type="submit">Weiter &rarr;</button>
+    </form>
+    {{end}}
+  </span>
+</div>
 {{end}}
 </div>
 </body>

internal/web/templates/betreiber_dashboard.html

@@ -5,10 +5,25 @@
 {{template "nav" .Nav}}
 <div class="page">
 <h1>Plattform</h1>
-<ul class="admin-kacheln">
-  <li><a href="/betreiber/accounts">Accounts <span class="status">{{.AccountCount}}</span></a></li>
-  <li><a href="/betreiber/werkzeuge">Werkzeugkatalog <span class="status">{{.WerkzeugCount}}</span></a></li>
-  <li><a href="/betreiber/audit-log">Audit-Log <span class="status">{{.RecentAuditCount}} neueste</span></a></li>
+<ul class="stat-cards">
+  <li>
+    <a class="stat-card" href="/betreiber/accounts">
+      <span class="stat-card-value">{{.AccountCount}}</span>
+      <span class="stat-card-label">Accounts</span>
+    </a>
+  </li>
+  <li>
+    <a class="stat-card" href="/betreiber/werkzeuge">
+      <span class="stat-card-value">{{.WerkzeugCount}}</span>
+      <span class="stat-card-label">Werkzeugkatalog</span>
+    </a>
+  </li>
+  <li>
+    <a class="stat-card" href="/betreiber/audit-log">
+      <span class="stat-card-value">{{.RecentAuditCount}}</span>
+      <span class="stat-card-label">Audit-Log (neueste)</span>
+    </a>
+  </li>
 </ul>
 </div>
 </body>

internal/web/templates/faelle_liste.html

@@ -4,20 +4,40 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Posteingang</h1>
-{{if not .Faelle}}
-<p class="keine-findings">Keine offenen Anträge — alles bearbeitet.</p>
-{{else}}
-<ul class="beitraege-liste">
-  {{range .Faelle}}
-  <li>
-    <a href="/faelle/{{.ID}}">
-      <strong>{{.Titel}}</strong> · {{.Haeufigkeit}} · eingereicht am {{.CreatedAt}}
-    </a>
-  </li>
+<div class="page-header">
+  <div>
+    <h1>Posteingang</h1>
+    <p class="hinweis">Alle noch offenen Anträge deines Mandanten.</p>
+  </div>
+</div>
+<form method="get">
+  <div class="filter-bar">
+    <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (Titel, Häufigkeit)">
+    <button type="submit">Filtern</button>
+    {{if .Suche}}<a href="/faelle">Zurücksetzen</a>{{end}}
+  </div>
+
+  {{if not .Faelle}}
+  <p class="keine-findings">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Keine offenen Anträge — alles bearbeitet.{{end}}</p>
+  {{else}}
+  <ul class="beitraege-liste">
+    {{range .Faelle}}
+    <li>
+      <a href="/faelle/{{.ID}}">
+        <strong>{{.Titel}}</strong> · {{.Haeufigkeit}} · eingereicht am {{.CreatedAt}}
+      </a>
+    </li>
+    {{end}}
+  </ul>
+  <div class="pagination">
+    <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+    <span>
+      {{if .Pagination.HasPrev}}<button type="submit" name="page" value="{{.Pagination.PrevPage}}">&larr; Zurück</button>{{end}}
+      {{if .Pagination.HasNext}}<button type="submit" name="page" value="{{.Pagination.NextPage}}">Weiter &rarr;</button>{{end}}
+    </span>
+  </div>
   {{end}}
-</ul>
-{{end}}
+</form>
 </div>
 </body>
 </html>

internal/web/templates/fall_detail.html

@@ -33,6 +33,23 @@
 <p><strong>{{.Entscheidung.Entscheidung}}</strong>{{if .Entscheidung.WerkzeugName}} — {{.Entscheidung.WerkzeugName}}{{end}}<br>
 <span class="hinweis">am {{.Entscheidung.CreatedAt}}{{if .Entscheidung.GueltigBis}}, gültig bis {{.Entscheidung.GueltigBis}}{{end}}</span></p>
 {{if .Entscheidung.Begruendung}}<p>{{.Entscheidung.Begruendung}}</p>{{end}}
+
+{{if .Freigabeschritte}}
+<h2>Zusätzliche Freigaben</h2>
+{{if eq .Status "wartet_auf_freigabe"}}
+<p class="hinweis">Die Genehmigung ist erst endgültig, wenn alle unten stehenden Freigaben erteilt sind.</p>
+{{end}}
+<ul class="beitraege-liste">
+  {{range .Freigabeschritte}}
+  <li>
+    {{.RolleName}}
+    <span class="status {{if eq .Status "genehmigt"}}status-published{{else if eq .Status "abgelehnt"}}status-hoch{{else}}status-mittel{{end}}">{{.Status}}</span>
+    {{if .Kommentar}}<p>{{.Kommentar}}</p>{{end}}
+  </li>
+  {{end}}
+</ul>
+{{end}}
+
 {{else if .CanEntscheiden}}
 <h2>Entscheiden</h2>
 {{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}

internal/web/templates/freigabe_regeln_liste.html

@@ -0,0 +1,93 @@
+{{define "freigabe-regeln-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<div class="page-header">
+  <div>
+    <h1>Freigabe-Regeln</h1>
+    <p class="hinweis">
+      "Wenn Bedingung X zutrifft, ist zusätzlich eine Freigabe durch
+      Genehmiger-Rolle Y nötig." Bedingungen sind die vom Regelwerk
+      abgeleiteten Anforderungen/Einstufungen/Datenklassen — keine
+      freie Regel, sondern eine Auswahl aus dem, was das System ohnehin
+      schon berechnet. Eine Genehmigung durch die Fachebene wartet dann
+      erst auf diese zusätzlichen Freigaben, bevor sie endgültig ist;
+      lehnt eine davon ab, gilt der gesamte Antrag als abgelehnt.
+    </p>
+  </div>
+</div>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+
+{{if not .RollenOptionen}}
+<p class="hinweis">
+  Zuerst mindestens eine <a href="/verwaltung/genehmiger-rollen">Genehmiger-Rolle</a>
+  anlegen, bevor eine Freigabe-Regel definiert werden kann.
+</p>
+{{else}}
+<div class="form-card">
+<form method="post" action="/verwaltung/freigabe-regeln">
+  <fieldset class="form-section">
+    <legend>Neue Freigabe-Regel</legend>
+    <div class="form-grid">
+      <div>
+        <label for="bedingung">Bedingung</label>
+        <select id="bedingung" name="bedingung" required>
+          <option value="">Bitte wählen…</option>
+          {{range .BedingungGruppen}}
+          {{$gruppe := .Label}}
+          <optgroup label="{{$gruppe}}">
+            {{range .Optionen}}
+            <option value="{{.Value}}">{{.Label}}</option>
+            {{end}}
+          </optgroup>
+          {{end}}
+        </select>
+      </div>
+      <div>
+        <label for="genehmiger_rolle_id">Genehmiger-Rolle</label>
+        <select id="genehmiger_rolle_id" name="genehmiger_rolle_id" required>
+          <option value="">Bitte wählen…</option>
+          {{range .RollenOptionen}}
+          <option value="{{.ID}}">{{.Name}}</option>
+          {{end}}
+        </select>
+      </div>
+    </div>
+  </fieldset>
+  <div class="form-actions">
+    <button type="submit">Anlegen</button>
+  </div>
+</form>
+</div>
+{{end}}
+
+{{if not .Regeln}}
+<p class="hinweis">Noch keine Freigabe-Regeln.</p>
+{{else}}
+<div class="table-responsive">
+<table>
+  <thead>
+    <tr><th>Bedingung</th><th>Erforderliche Freigabe</th><th></th></tr>
+  </thead>
+  <tbody>
+    {{range .Regeln}}
+    <tr>
+      <td data-label="Bedingung">{{.BedingungLabel}}</td>
+      <td data-label="Erforderliche Freigabe">{{.GenehmigerRolle}}</td>
+      <td data-label="">
+        <form method="post" action="/verwaltung/freigabe-regeln/{{.ID}}/loeschen" style="display:inline" onsubmit="return confirm('Freigabe-Regel wirklich löschen?')">
+          <button type="submit" class="entfernen">Löschen</button>
+        </form>
+      </td>
+    </tr>
+    {{end}}
+  </tbody>
+</table>
+</div>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/freigaben_liste.html

@@ -0,0 +1,38 @@
+{{define "freigaben-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<div class="page-header">
+  <div>
+    <h1>Meine Freigaben</h1>
+    <p class="hinweis">Anträge, die zusätzlich zur Fachebene-Entscheidung deine Freigabe brauchen.</p>
+  </div>
+</div>
+{{if not .Freigaben}}
+<p class="keine-findings">Keine ausstehenden Freigaben.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Freigaben}}
+  <li>
+    <div class="beteiligter-kopf">
+      <strong>{{.AntragTitel}}</strong> · Freigabe als {{.RolleName}} · seit {{.CreatedAt}}
+    </div>
+    <form method="post" action="/freigaben/{{.ID}}/entscheiden">
+      <label for="kommentar-{{.ID}}">Kommentar (optional, Pflicht bei Ablehnung empfohlen)</label>
+      <input type="text" id="kommentar-{{.ID}}" name="kommentar">
+      <div class="form-actions">
+        <button type="submit" name="entscheidung" value="genehmigt">Freigeben</button>
+        <button type="submit" name="entscheidung" value="abgelehnt" class="entfernen" onclick="return confirm('Wirklich ablehnen? Das lehnt den gesamten Antrag ab.')">Ablehnen</button>
+      </div>
+    </form>
+    <p><a href="/faelle/{{.AntragID}}">Antrag ansehen →</a></p>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/genehmiger_rollen_liste.html

@@ -0,0 +1,83 @@
+{{define "genehmiger-rollen-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<div class="page-header">
+  <div>
+    <h1>Genehmiger-Rollen</h1>
+    <p class="hinweis">
+      Freigabe-Funktionen wie "Datenschutzbeauftragter" oder
+      "Geschäftsführung" — unabhängig von den normalen Zugriffsrollen,
+      eine Person kann beides zugleich sein. Wer wann zusätzlich
+      freigeben muss, legst du unter
+      <a href="/verwaltung/freigabe-regeln">Freigabe-Regeln</a> fest.
+    </p>
+  </div>
+</div>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+
+<div class="form-card">
+<form method="post" action="/verwaltung/genehmiger-rollen">
+  <fieldset class="form-section">
+    <legend>Neue Genehmiger-Rolle</legend>
+    <div class="form-grid">
+      <div>
+        <label for="name">Name</label>
+        <input type="text" id="name" name="name" placeholder="z. B. Datenschutzbeauftragter" required>
+      </div>
+      <div>
+        <label for="beschreibung">Beschreibung (optional)</label>
+        <input type="text" id="beschreibung" name="beschreibung" placeholder="z. B. Prüft den Antrag aus Sicherheitssicht">
+      </div>
+    </div>
+  </fieldset>
+  <div class="form-actions">
+    <button type="submit">Anlegen</button>
+  </div>
+</form>
+</div>
+
+{{if not .Rollen}}
+<p class="hinweis">Noch keine Genehmiger-Rollen.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Rollen}}
+  {{$rolleID := .ID}}
+  <li>
+    <div class="beteiligter-kopf"><strong>{{.Name}}</strong>{{if .Beschreibung}} — {{.Beschreibung}}{{end}}</div>
+    {{if .Mitglieder}}
+    <ul class="beitraege-liste">
+      {{range .Mitglieder}}
+      <li>
+        {{.Email}}
+        <form method="post" action="/verwaltung/genehmiger-rollen/{{$rolleID}}/mitglieder/{{.ID}}/entfernen" style="display:inline">
+          <button type="submit" class="entfernen">Entfernen</button>
+        </form>
+      </li>
+      {{end}}
+    </ul>
+    {{else}}
+    <p class="hinweis">Noch keine Mitglieder.</p>
+    {{end}}
+    <form method="post" action="/verwaltung/genehmiger-rollen/{{$rolleID}}/mitglieder" style="display:inline">
+      <select name="user_id" required>
+        <option value="">Person hinzufügen…</option>
+        {{range $.Nutzer}}
+        <option value="{{.ID}}">{{.Email}}</option>
+        {{end}}
+      </select>
+      <button type="submit">Hinzufügen</button>
+    </form>
+    <form method="post" action="/verwaltung/genehmiger-rollen/{{$rolleID}}/loeschen" style="display:inline" onsubmit="return confirm('Genehmiger-Rolle wirklich löschen?')">
+      <button type="submit" class="entfernen">Rolle löschen</button>
+    </form>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/layout.html

@@ -24,6 +24,7 @@
   <nav class="app-nav">
     <a href="/">Start</a>
     {{if not .IsBetreiber}}<a href="/antraege">Meine Anträge</a>{{end}}
+    {{if not .IsBetreiber}}<a href="/freigaben">Meine Freigaben</a>{{end}}
     {{if .IsFachebene}}<a href="/faelle">Posteingang</a>{{end}}
     {{if .IsFachebene}}<a href="/registereintraege">Register</a>{{end}}
     {{if .IsFachebene}}<a href="/wiedervorlage">Wiedervorlage</a>{{end}}
@@ -31,6 +32,9 @@
     {{if .IsAdmin}}<a href="/verwaltung/einladung">Einladungslink</a>{{end}}
     {{if .IsAdmin}}<a href="/verwaltung/abteilungen">Abteilungen</a>{{end}}
     {{if .IsAdmin}}<a href="/verwaltung/werkzeuge">Werkzeugkatalog</a>{{end}}
+    {{if .IsAdmin}}<a href="/verwaltung/genehmiger-rollen">Genehmiger-Rollen</a>{{end}}
+    {{if .IsAdmin}}<a href="/verwaltung/freigabe-regeln">Freigabe-Regeln</a>{{end}}
+    {{if .IsAdmin}}<a href="/verwaltung/loeschfristen">Löschfristen</a>{{end}}
     {{if .IsBetreiber}}<a href="/betreiber">Plattform</a>{{end}}
     <form method="post" action="/logout">
       <button type="submit">Abmelden</button>

internal/web/templates/loeschfristen_liste.html

@@ -0,0 +1,43 @@
+{{define "loeschfristen-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<div class="page-header">
+  <div>
+    <h1>Löschfristen</h1>
+    <p class="hinweis">
+      Maximale Aufbewahrungsdauer je Datenklasse, gegen die ein Werkzeug
+      hart geprüft wird (Anforderung <code>loeschfrist_max_tage</code>).
+      Die DSGVO nennt keine festen Fristen, nur den Grundsatz "so lange
+      wie für den Zweck nötig" — die Werte unten sind ein Vorschlag,
+      keine Rechtsvorgabe, und sollten vom Datenschutzbeauftragten
+      geprüft und bei Bedarf angepasst werden.
+    </p>
+  </div>
+</div>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+{{if .Gespeichert}}<p class="hinweis">Löschfristen gespeichert.</p>{{end}}
+<div class="form-card">
+<form method="post" action="/verwaltung/loeschfristen">
+  <fieldset class="form-section">
+    <legend>Maximale Aufbewahrungsdauer (Tage)</legend>
+    <div class="form-grid">
+      {{range .Zeilen}}
+      <div>
+        <label for="max_tage_{{.DatenklasseID}}">{{.DatenklasseID}}</label>
+        <input type="number" min="0" id="max_tage_{{.DatenklasseID}}" name="max_tage_{{.DatenklasseID}}" value="{{.MaxTage}}" required>
+      </div>
+      {{end}}
+    </div>
+  </fieldset>
+  <div class="form-actions">
+    <button type="submit">Speichern</button>
+  </div>
+</form>
+</div>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/login.html

@@ -5,6 +5,7 @@
 <div class="page">
 <h1>Anmelden</h1>
 {{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+{{if .Message}}<p class="hinweis">{{.Message}}</p>{{end}}
 <form method="post" action="/login">
   <label for="email">E-Mail</label>
   <input type="email" id="email" name="email" required>
@@ -15,6 +16,7 @@
   <button type="submit">Anmelden</button>
 </form>
 <p><a href="/register">Noch kein Konto? Registrieren</a></p>
+<p><a href="/passwort-vergessen">Passwort vergessen?</a></p>
 </div>
 </body>
 </html>

internal/web/templates/nutzer_liste.html

@@ -4,7 +4,21 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Nutzerverwaltung</h1>
+<div class="page-header">
+  <div>
+    <h1>Nutzerverwaltung</h1>
+    <p class="hinweis">Logins deines Mandanten — ein Login wird deaktiviert statt gelöscht.</p>
+  </div>
+  <a class="page-header-action" href="/verwaltung/nutzer/neu">Nutzer anlegen</a>
+</div>
+<form method="get" class="filter-bar">
+  <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (E-Mail, Rolle)">
+  <button type="submit">Filtern</button>
+  {{if .Suche}}<a href="/verwaltung/nutzer">Zurücksetzen</a>{{end}}
+</form>
+{{if not .Nutzer}}
+<p class="hinweis">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Noch keine weiteren Nutzer.{{end}}</p>
+{{else}}
 <ul class="beitraege-liste">
   {{range .Nutzer}}
   <li>
@@ -25,7 +39,27 @@
   </li>
   {{end}}
 </ul>
-<p><a href="/verwaltung/nutzer/neu">Nutzer anlegen</a> · <a href="/verwaltung/nutzer/import">Per CSV importieren</a></p>
+<div class="pagination">
+  <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+  <span>
+    {{if .Pagination.HasPrev}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.PrevPage}}">
+      <button type="submit">&larr; Zurück</button>
+    </form>
+    {{end}}
+    {{if .Pagination.HasNext}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Suche}}">
+      <input type="hidden" name="page" value="{{.Pagination.NextPage}}">
+      <button type="submit">Weiter &rarr;</button>
+    </form>
+    {{end}}
+  </span>
+</div>
+{{end}}
+<p><a href="/verwaltung/nutzer/import">Per CSV importieren</a></p>
 </div>
 </body>
 </html>

internal/web/templates/passwort_vergessen.html

@@ -0,0 +1,18 @@
+{{define "passwort-vergessen"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+<div class="page">
+<h1>Passwort vergessen</h1>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+{{if .Message}}<p class="hinweis">{{.Message}}</p>{{end}}
+<form method="post" action="/passwort-vergessen">
+  <label for="email">E-Mail</label>
+  <input type="email" id="email" name="email" required>
+  <button type="submit">Link anfordern</button>
+</form>
+<p><a href="/login">Zurück zur Anmeldung</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/passwort_zuruecksetzen.html

@@ -0,0 +1,16 @@
+{{define "passwort-zuruecksetzen"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+<div class="page">
+<h1>Neues Passwort setzen</h1>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="/passwort-zuruecksetzen/{{.Token}}">
+  <label for="password">Neues Passwort</label>
+  <input type="password" id="password" name="password" required minlength="8">
+  <button type="submit">Passwort setzen</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/register_liste.html

@@ -4,36 +4,61 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Register</h1>
-<p class="hinweis">
-  Jede Genehmigung erzeugt automatisch einen Registereintrag —
-  abgelehnte Anträge und Rückfragen stehen nicht im Register.
-</p>
-<p><a href="/registereintraege/export.csv">CSV-Export</a> · <a href="/registereintraege/export.pdf">PDF-Export</a></p>
-{{if not .Eintraege}}
-<p class="hinweis">Noch keine Genehmigungen.</p>
-{{else}}
-<div class="table-scroll">
-<table>
-  <thead>
-    <tr>
-      <th>Zweck</th><th>Abteilung</th><th>Werkzeug</th><th>Datenklasse</th>
-      <th>Einstufung</th><th>Auflagen</th><th>Verantwortliche/r</th>
-      <th>Entschieden am</th><th>Gültig bis</th>
-    </tr>
-  </thead>
-  <tbody>
-    {{range .Eintraege}}
-    <tr>
-      <td>{{.Zweck}}</td><td>{{.Abteilung}}</td><td>{{.Werkzeug}}</td><td>{{.Datenklasse}}</td>
-      <td>{{.Einstufung}}</td><td>{{.Auflagen}}</td><td>{{.Verantwortlicher}}</td>
-      <td>{{.EntschiedenAm}}</td><td>{{.GueltigBis}}</td>
-    </tr>
-    {{end}}
-  </tbody>
-</table>
+<div class="page-header">
+  <div>
+    <h1>Register</h1>
+    <p class="hinweis">
+      Jede Genehmigung erzeugt automatisch einen Registereintrag —
+      abgelehnte Anträge und Rückfragen stehen nicht im Register.
+    </p>
+  </div>
+  <span class="hinweis"><a href="/registereintraege/export.csv">CSV-Export</a> · <a href="/registereintraege/export.pdf">PDF-Export</a></span>
 </div>
-{{end}}
+<form method="get">
+  <div class="filter-bar">
+    <input type="search" name="q" value="{{.Suche}}" placeholder="Suche (Zweck, Abteilung, Werkzeug, Verantwortliche/r)">
+    <button type="submit">Filtern</button>
+    {{if .Suche}}<a href="/registereintraege">Zurücksetzen</a>{{end}}
+  </div>
+
+  {{if not .Eintraege}}
+  <p class="hinweis">{{if .Suche}}Keine Treffer für diese Suche.{{else}}Noch keine Genehmigungen.{{end}}</p>
+  {{else}}
+  <div class="table-responsive">
+  <table>
+    <thead>
+      <tr>
+        <th>Zweck</th><th>Abteilung</th><th>Werkzeug</th><th>Datenklasse</th>
+        <th>Einstufung</th><th>Auflagen</th><th>Verantwortliche/r</th>
+        <th>Entschieden am</th><th>Gültig bis</th>
+      </tr>
+    </thead>
+    <tbody>
+      {{range .Eintraege}}
+      <tr>
+        <td data-label="Zweck">{{.Zweck}}</td>
+        <td data-label="Abteilung">{{.Abteilung}}</td>
+        <td data-label="Werkzeug">{{.Werkzeug}}</td>
+        <td data-label="Datenklasse">{{.Datenklasse}}</td>
+        <td data-label="Einstufung">{{.Einstufung}}</td>
+        <td data-label="Auflagen">{{.Auflagen}}</td>
+        <td data-label="Verantwortliche/r">{{.Verantwortlicher}}</td>
+        <td data-label="Entschieden am">{{.EntschiedenAm}}</td>
+        <td data-label="Gültig bis">{{.GueltigBis}}</td>
+      </tr>
+      {{end}}
+    </tbody>
+  </table>
+  </div>
+  <div class="pagination">
+    <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+    <span>
+      {{if .Pagination.HasPrev}}<button type="submit" name="page" value="{{.Pagination.PrevPage}}">&larr; Zurück</button>{{end}}
+      {{if .Pagination.HasNext}}<button type="submit" name="page" value="{{.Pagination.NextPage}}">Weiter &rarr;</button>{{end}}
+    </span>
+  </div>
+  {{end}}
+</form>
 </div>
 </body>
 </html>

internal/web/templates/wiedervorlage_liste.html

@@ -4,11 +4,15 @@
 <body>
 {{template "nav" .Nav}}
 <div class="page">
-<h1>Wiedervorlage</h1>
-<p class="hinweis">
-  Genehmigungen, die abgelaufen sind, bald ablaufen, oder deren
-  Werkzeug sich seit der Entscheidung im Katalog geändert hat.
-</p>
+<div class="page-header">
+  <div>
+    <h1>Wiedervorlage</h1>
+    <p class="hinweis">
+      Genehmigungen, die abgelaufen sind, bald ablaufen, oder deren
+      Werkzeug sich seit der Entscheidung im Katalog geändert hat.
+    </p>
+  </div>
+</div>
 {{if not .Eintraege}}
 <p class="keine-findings">Nichts zur Wiedervorlage.</p>
 {{else}}

packaging/etc/deklarix/deklarix.env.example

@@ -15,3 +15,12 @@ RULES_DIR=/usr/share/deklarix/rules
 # prüft genau diese Zeile, um den Dienst nicht blind in eine Restart-
 # Schleife gegen einen Platzhalter laufen zu lassen.
 #DATABASE_URL=postgres://user:password@host:5432/deklarix?sslmode=require
+
+# Optional — ohne SMTP_HOST startet der Dienst normal, nur der
+# tatsächliche E-Mail-Versand (aktuell: Passwort-Zurücksetzen) schlägt
+# dann sichtbar fehl statt eine nie ankommende Mail vorzutäuschen.
+#SMTP_HOST=smtp.example.com
+#SMTP_PORT=587
+#SMTP_USER=
+#SMTP_PASSWORD=
+#SMTP_FROM=deklarix@example.com

rules/OPEN.md

@@ -48,18 +48,28 @@ final, nicht mehr Platzhalter. Ob diese drei Varianten fachlich
 vollständig sind, wurde am 2026-08-29 vom Produktverantwortlichen
 **bestätigt (keine Ergänzung nötig).**
 
-## 4. `loeschfrist_max_tage` — konkrete Fristen je Datenklasse
+## 4. `loeschfrist_max_tage` — konkrete Fristen je Datenklasse — GELÖST (2026-09-01, konfigurierbar statt fest)
 
-Die Spezifikation nennt `loeschfrist_max_tage` als Anforderung "aus
-Datenklasse", ohne die konkreten Tageswerte pro Stufe zu nennen.
-`rules/anforderungen.yaml` listet die Anforderung nur als grundsätzlich
-anwendbar (welche Datenklassen sie überhaupt auslösen), ohne
-Zahlenwerte — die eigentlichen Fristen (z. B. "personenbezogen: 90
-Tage") müssen vor Phase 3 fachlich festgelegt werden. **Auswirkung auf
-Schritt 3 (`internal/rules.ErfuelltAnforderung`):** ohne Zahlenwerte
-wird diese Anforderung aktuell NICHT hart gegen Werkzeuge gefiltert
-(jedes Werkzeug gilt hier als "erfüllt") — sobald Fristen feststehen,
-muss die Filterfunktion entsprechend erweitert werden.
+Ursprünglich war unklar, wer die konkreten Tageswerte je Datenklasse
+festlegt. Recherche (2026-09-01) ergab: die DSGVO selbst nennt **keine**
+festen Speicherfristen — Art. 5 Abs. 1 lit. e verlangt nur, Daten "so
+lange wie für den Zweck nötig" zu speichern (Grundsatz der
+Speicherbegrenzung). Es gibt daher keinen einzelnen "richtigen"
+Zahlenwert, den man fest in `rules/anforderungen.yaml` hätte eintragen
+können. Lösung: **pro Mandant einstellbar**, vom Datenschutzbeauftragten
+festgelegt (`loeschfrist_einstellung`, Migration 0020, `GET/POST
+/verwaltung/loeschfristen`) statt einer globalen YAML-Konstante. Jede
+neue Firma wird mit risikogestaffelten Vorschlagswerten vorbelegt
+(`oeffentlich` 365 / `intern` 180 / `auftragsdaten` 90 / `personenbezogen`
+90 / `berufsgeheimnis` 30 / `besondere_kategorie` 30 Tage) — eigene
+Einschätzung, keine Rechtsvorgabe, frei editierbar.
+
+**Auswirkung auf Schritt 3 (`internal/rules.ErfuelltAnforderung`):** die
+Anforderung wird jetzt hart gefiltert, sobald für die betroffene
+Datenklasse eine Frist konfiguriert ist — ein Werkzeug ohne bezifferte
+Aufbewahrungsdauer erfüllt eine gesetzte Frist NICHT (fail closed, wie
+bei `eu_verarbeitung`). Ist keine Frist konfiguriert, bleibt das
+Verhalten wie zuvor (nicht gefiltert).
 
 ## 5. Fallback, wenn keine Datenklasse zutrifft — BESTÄTIGT (2026-08-29)