fix: admin bekommt Fachebene-Rechte (Posteingang, Entscheiden, Register, Wiedervorlage)

Löst einen Blocker im Kernablauf: eine frisch registrierte Firma hat
nur einen admin-Login und konnte damit bislang keinen einzigen
eingereichten Antrag sehen oder entscheiden, weil requireFachebene nur
verantwortlicher/pruefer durchließ. Die Spezifikation will admin+
KI-Verantwortlicher ohnehin auf derselben Person (siehe CLAUDE.md,
Offene Punkte) — statt eines Datenmodell-Umbaus (roles-Array oder
zwei app_user-Zeilen pro Person) bekommt admin jetzt pragmatisch
dieselben Fachebene-Rechte wie verantwortlicher (hatEntscheidungsrecht
in fachebene_handlers.go). pruefer bleibt unverändert nur lesend.

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

CLAUDE.md

@@ -67,11 +67,61 @@ Mandanten-Verwaltung für den eigenen Account) und `betreiber` (Ebene 5,
 Plattform-Betrieb für Netcell-IT über alle Mandanten) sind nicht
 dasselbe, auch wenn beide "Admin"-artige Rechte haben — nur `betreiber`
 ist der Nachfolger dessen, was früher (vor dem Produktwechsel)
-`admin` hieß.
+`admin` hieß. **Praktische Umsetzung dieser Doppelrolle:** `admin`
+bekommt zusätzlich dieselben Fachebene-Rechte wie `verantwortlicher`
+(siehe `requireFachebene`/`hatEntscheidungsrecht`) — pragmatisch gelöst
+ohne Datenmodell-Umbau, siehe Offene Punkte weiter unten.
 
 Rechte werden **als Prüfung an jeder Aktion** durchgesetzt (Middleware
 je Handler), nicht als grob unterschiedene Seitenbereiche.
 
+**Ebene 4 ist inzwischen zu großen Teilen umgesetzt** (Anspruch: alles,
+was im Datenmodell existiert, muss über das Frontend steuerbar sein,
+nicht nur einsehbar — Deklarix soll ein buchbarer Service werden, ein
+reiner Anzeige-Screen reicht nicht):
+
+- **Nutzerverwaltung** (`internal/web/admin_handlers.go`, Middleware
+  `requireAdmin`): `GET /verwaltung/nutzer` listet alle Logins des
+  eigenen Mandanten mit Status (aktiv/deaktiviert), `GET/POST
+  /verwaltung/nutzer/neu` legt einen weiteren Login mit einer der vier
+  Mandanten-Rollen an (`mitarbeiter`, `verantwortlicher`, `pruefer`,
+  `admin` — `betreiber` kann kein Mandanten-Admin vergeben, das ist
+  Ebene 5). Es gibt noch **keine** Einladungsmail — der Admin setzt das
+  Initialpasswort direkt im Formular. Nutzer werden **nicht gelöscht**
+  (`app_user` wird von `antrag`/`entscheidung`/`audit_log` per Foreign
+  Key referenziert — ein Hard-Delete würde die Historie zerstören),
+  sondern über `POST /verwaltung/nutzer/{id}/deaktivieren` bzw.
+  `.../aktivieren` (de-)aktiviert (Spalte `app_user.active`, Migration
+  0012). Ein deaktivierter Login kann sich nicht mehr anmelden
+  (`handleLogin` prüft `Active` erst NACH der Passwortprüfung, um keine
+  Kontoexistenz zu verraten) und verliert eine bereits laufende Sitzung
+  sofort (`authenticate`-Middleware prüft `Active` bei jedem Request).
+  Ein Admin kann sich nicht selbst deaktivieren (Aussperr-Schutz).
+- **Abteilungen** (`GET /verwaltung/abteilungen`, anlegen + löschen):
+  reine Stammdaten für das Fragebogen-Feld "Abteilung" — ohne diese
+  Seite blieb die Abteilung-Auswahl im Fragebogen faktisch leer und
+  unbenutzbar, das war kein Komfort-, sondern ein Funktionsdefizit.
+- **Eigene Werkzeug-Sperrungen und -Einträge** (`internal/web/mandant_werkzeug_handlers.go`,
+  `GET /verwaltung/werkzeuge`): ein Mandant kann einen zentralen
+  Katalogeintrag für sich sperren/entsperren (`werkzeug_sperre`), ohne
+  den zentralen Katalog selbst zu verändern — das bleibt Sache der
+  Plattform (Ebene 5, `betreiber_werkzeug_handlers.go`). Zusätzlich kann
+  ein Mandant eigene, nur für sich sichtbare Katalogeinträge anlegen/
+  bearbeiten/löschen (`GET/POST /verwaltung/werkzeuge/neu`, `GET/POST
+  /verwaltung/werkzeuge/{id}`, `POST /verwaltung/werkzeuge/{id}/loeschen`
+  — `werkzeug.account_id` = der eigene Account). Nutzt dasselbe Formular
+  wie der zentrale Katalog (`werkzeugFormData`/`betreiber-werkzeug-form.html`,
+  ein `ActionBase`-Feld unterscheidet Betreiber- von Mandanten-Ziel-URL)
+  — ein zentraler oder fremder Eintrag ist über diese Route nicht
+  erreichbar (404).
+
+**Weiterhin nicht gebaut:** Anmeldeverfahren-Konfiguration, Rechnungsdaten/
+Abrechnung (kein Abo-System, bewusst "Nicht bauen v1"), Account-
+Verwaltung durch den Betreiber (Ebene 5 zeigt Accounts nur lesend an —
+Bearbeiten/Sperren hängt an der noch nicht getroffenen Abrechnungs-/
+Freischaltungs-Architektur, siehe Offene Punkte: `account.verified`
+wurde beim Produktwechsel sogar entfernt).
+
 **Mandantenfähigkeit:** jede Tabelle trägt `account_id`. Aktuell wird
 Isolation in der Anwendungsschicht erzwungen (Handler vergleichen
 `AccountID` gegen den angemeldeten Account, wie bisher) — die
@@ -205,23 +255,64 @@ mehrfacher Neubewertung eines Antrags erhalten bleibt.
 
 ---
 
-## Entscheidung, Register, Wiedervorlage (geplant, Schritt 5-7)
+## Entscheidung, Register, Wiedervorlage (Schritt 5-7 erledigt)
+
+**Schritt 5 (Entscheidung, Snapshot, Audit-Log) ist umgesetzt.** Ebene 3
+(Fachebene) hat einen Posteingang (`GET /faelle`, alle offenen —
+Status "eingereicht" — Anträge des Mandanten, nicht nur die eigenen)
+und eine Entscheiden-Seite (`GET /faelle/{id}`, `POST
+/faelle/{id}/entscheiden`, siehe `internal/web/fachebene_handlers.go`).
+Rollen `verantwortlicher` und `pruefer` sehen dieselbe Sicht
+(`requireFachebene`), nur `verantwortlicher` hat Entscheidungsrecht —
+ein `pruefer`-POST auf `/entscheiden` bekommt 403 (er darf wissen, dass
+der Fall existiert, nur nicht entscheiden; anders als bei
+`requireFachebene`/`requireBetreiber`, die bei falscher Rolle 404
+liefern, um die Existenz der Seite selbst zu verbergen).
 
 Der/die Verantwortliche wählt: genehmigt / genehmigt mit Auflagen /
-abgelehnt / Rückfrage. Begründungsfeld ist bei Abweichung vom Vorschlag
+abgelehnt / Rückfrage. **Vorschlag-Vergleich:** `vorschlagFuer` leitet
-Pflicht. **Snapshot bei Entscheidung:** Regelwerk-Version, Katalog-
+aus der Bewertung ab, was das System vorschlagen würde (`abgelehnt` bei
-Version und der vollständige Werkzeugdatensatz werden eingefroren — ein
+`verboten`, sonst `genehmigt` wenn mindestens ein zulässiges Werkzeug
-späterer Katalog-Wandel darf nicht rückwirkend verändern, worauf eine
+existiert, sonst `rueckfrage`) — weicht die tatsächliche Entscheidung
-Entscheidung beruhte.
+davon ab, ist das Begründungsfeld Pflicht (sonst 400). **Snapshot bei
+Entscheidung:** `entscheidung.werkzeug_snapshot` (JSONB) friert den
+vollständigen `store.Werkzeug`-Datensatz zum Entscheidungszeitpunkt ein
+— ein späterer Katalog-Wandel darf nicht rückwirkend verändern, worauf
+eine Entscheidung beruhte. Bei "genehmigt"/"genehmigt mit Auflagen" ist
+ein Werkzeug aus der zulässigen Liste der Bewertung Pflicht (hart
+geprüft, kein Override eines ausgeschlossenen Werkzeugs). `entscheidung`
+ist append-only (Migration 0010) wie `bewertung`; jede Entscheidung
+erzeugt zusätzlich einen `audit_log`-Eintrag (Action
+`antrag_entschieden`).
 
-Genehmigungen erhalten ein Ablaufdatum (Vorschlag: 12 Monate, bei
+Genehmigungen erhalten ein Ablaufdatum (`gueltig_bis`: 12 Monate, bei
-`hochrisiko` 6). Ändert sich im Katalog eine Eigenschaft, auf der eine
+`hochrisiko` 6 — `gueltigkeitFuer`).
-aktive Genehmigung beruht, wird der/die Verantwortliche benachrichtigt
-(Wiedervorlage).
 
-Jede Genehmigung erzeugt automatisch einen Registereintrag: Zweck,
+**Schritt 7 (Wiedervorlage, Katalog-Benachrichtigung) ist umgesetzt**
-Abteilung, Werkzeug, Datenklasse, Einstufung, Auflagen, Verantwortliche/
+(`internal/web/wiedervorlage_handlers.go`, `GET /wiedervorlage`, Ebene
-r, Datum, Gültigkeit. Export als PDF und CSV.
+3). Es gibt keine E-Mail-Infrastruktur — "Benachrichtigung" ist bewusst
+eine In-App-Liste, kein 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
+dem eingefrorenen `werkzeug_snapshot` und dem aktuellen Katalogeintrag
+bei AVV-Verfügbarkeit, Training-Standard oder Verarbeitungsort. Keine
+gefundene Abweichung → die Genehmigung erscheint nicht (kein stiller
+Blanko-Eintrag für jede Genehmigung). `store.ListAktiveGenehmigungenForAccount`
+liefert dafür alle `genehmigt`/`genehmigt_mit_auflagen`-Entscheidungen
+eines Mandanten (Join über `antrag.account_id`, da `entscheidung`
+selbst kein `account_id` trägt).
+
+**Schritt 6 (Registereintrag, Export) ist umgesetzt.** Jede Genehmigung
+erzeugt automatisch einen `registereintrag` (append-only, Migration
+0011): Zweck (`antrag.titel`), Abteilung, Werkzeug, Datenklasse,
+Einstufung, Auflagen (die Anforderungen der Bewertung), Verantwortliche/r,
+Entscheidungsdatum, Gültigkeit — siehe `internal/web/register_handlers.go`.
+`GET /registereintraege` (Ebene 3, `verantwortlicher`/`pruefer`) zeigt
+sie, `GET /registereintraege/export.{csv,pdf}` exportiert. Abgelehnte
+Entscheidungen und Rückfragen erzeugen bewusst KEINEN Registereintrag —
+das Register ist eine Genehmigungsliste, kein vollständiges Antragslog
+(das leistet bereits `GET /faelle`).
 
 ---
 
@@ -237,12 +328,28 @@ leere Abteilungsliste, Werkzeugkatalog aus der Plattform vorbelegt
 (noch nicht automatisiert — der zentrale Katalog ist aktuell leer, bis
 Ebene 5/Betreiber-Pflege gebaut ist).
 
-**Mitarbeiter, geplante Reihenfolge:** (1) Einladungslink
+**Mitarbeiter, geplante Reihenfolge:** (1) ~~Einladungslink~~ —
-(Sammellink, Selbstanmeldung, Abteilung beim ersten Antrag), (2) CSV-
+**erledigt** (`internal/web/einladung_handlers.go`: `account.einladung_token`,
-Import, (3) SSO (Entra ID/Google Workspace), (4) Antrag ganz ohne
+Migration 0013, ein Sammellink pro Mandant statt Einmal-Token pro
-vorheriges Konto über Mandantenlink + E-Mail-Bestätigungscode (Konto
+Person, kein Ablaufdatum, per Admin unter `GET /verwaltung/einladung`
-entsteht nebenbei). Keins davon ist gebaut — aktuell nur Firma-
+jederzeit erneuerbar [macht den alten Link sofort ungültig].
-Registrierung.
+`GET/POST /einladung/{token}` — öffentlich, Ebene 1 — legt einen Login
+mit Rolle `mitarbeiter` im Mandanten des Links an und meldet direkt an,
+ohne E-Mail-Bestätigung [noch nicht gebaut, siehe unten]. Die Abteilung
+wählt die Person weiterhin erst beim ersten Antrag, nicht bei der
+Einladung.), (2) ~~CSV-Import~~ — **erledigt** (`internal/web/csv_import_handlers.go`,
+`GET /verwaltung/nutzer/import`: CSV mit Kopfzeile, Pflichtspalte
+"email", optionale Spalte "role" [Standard `mitarbeiter`]. Wie beim
+einzelnen Nutzer-Anlegen gibt es keine Einladungsmail — pro Zeile wird
+ein Einmalpasswort erzeugt [wiederverwendet `auth.NewSessionToken()`],
+das NUR auf der Ergebnisseite direkt nach dem Import angezeigt wird und
+danach nirgendwo mehr abrufbar ist. Kein Alles-oder-nichts-Import:
+gültige Zeilen werden angelegt, eine ungültige Rolle oder bereits
+vergebene E-Mail in einer Zeile blockiert nicht die übrigen Zeilen —
+jede Zeile bekommt ihr eigenes Ergebnis [Passwort oder Fehlermeldung].),
+(3) SSO (Entra ID/Google Workspace), (4) Antrag ganz ohne vorheriges
+Konto über Mandantenlink + E-Mail-Bestätigungscode (Konto entsteht
+nebenbei). (3)-(4) sind weiterhin nicht gebaut.
 
 **Abrechnung:** nach vom Kunden angegebener Mitarbeiterzahl, **nicht**
 nach angelegten Nutzern — sonst entsteht der Anreiz, Mitarbeitende
@@ -250,6 +357,49 @@ nicht anzulegen. Noch nicht gebaut (kein Abo-System).
 
 ---
 
+## Frontend
+
+Anspruch (2026-08-29 explizit vom Nutzer bestätigt, da Deklarix ein
+buchbarer Service werden soll): **für Browser UND Mobile optimiert,
+und jede Entität im Datenmodell muss über das Frontend steuerbar sein**
+— eine reine Anzeige-Seite ohne CRUD ist ein Defizit, kein v1-Kompromiss.
+Stack bleibt `html/template` + htmx, kein React/Vue/SPA (siehe
+Baureihenfolge/Architektur-Entscheidungen) — die responsive Optik wird
+rein mit CSS erreicht, ohne das Template-Modell zu ändern.
+
+**Navigation** (`internal/web/templates/layout.html`, `"nav"`-Block,
+einmal definiert und von jeder Seite eingebunden — Änderungen hier
+wirken auf das ganze Produkt): ein Checkbox-Hack (versteckte Checkbox +
+`<label for=...>` als Klick-Ziel) klappt auf dem Handy ein Menü auf,
+ganz ohne JavaScript. **Nicht** das naheliegendere `<details>`/`<summary>`
+verwenden — aktuelle Chromium-Versionen steuern dessen Auf-/Zuklapp-
+Zustand über eine interne, mit CSS (auch nicht mit `!important`)
+nicht überschreibbare Animation; ein Versuch, `.app-nav { display:
+flex !important }` bei geschlossenem `<details>` zu erzwingen, bleibt
+wirkungslos (mit Chromium-Headless-Screenshot verifiziert). Ab
+960px Breite (`@media (min-width: 960px)`, `app.css`) wird exakt
+dieselbe Markup-Struktur per CSS zu einer permanenten, dunklen
+Seitenleiste (Farb-Tokens aus `design/enterprise.css` übernommen) —
+kein separates Desktop-Template.
+
+**Tabellen** (`table`/`th`/`td` in `app.css`) sind seit dieser Änderung
+gestylt (vorher komplett ungestylt, betraf v. a. `register_liste.html`);
+breite Tabellen stehen in einem `.table-scroll`-Wrapper (horizontales
+Scrollen auf dem Handy statt gequetschter Spalten).
+
+**Verifikationsmethode für CSS-Änderungen:** Live-Cookie-Auth per
+Chromium-Headless/CDP ist im Sandbox-Environment nicht möglich (kein
+websocket-Python-Modul) — stattdessen: Seite per `curl -b cookies.txt`
+authentifiziert abrufen, `/static/...`-Pfade im HTML auf eine absolute
+`http://localhost:<port>/static/...`-URL umschreiben (Assets brauchen
+kein Auth-Cookie), dann `chromium --headless --disable-gpu --no-sandbox
+--window-size=<W>,<H> --screenshot=out.png file:///pfad/zur/seite.html`
+bei mobiler (z. B. 390×844) und Desktop-Breite (z. B. 1440×900)
+screenshotten. Für einen Menü-Aufklapp-Zustand: `checked`-Attribut
+manuell ins gespeicherte HTML einfügen vor dem Screenshot.
+
+---
+
 ## Projektstruktur
 
 ```
@@ -264,7 +414,10 @@ nicht anzulegen. Noch nicht gebaut (kein Abo-System).
 │   └── web/                     # Handler, Templates
 ├── rules/                      # YAML-Regelwerk + OPEN.md (offene fachliche Fragen)
 ├── design/
-│   └── enterprise.css          # Design-System (enconf-Basis, ungenutzt seit Pivot)
+│   └── enterprise.css          # enconf Ant-Design-Theme — Referenz für Design-Tokens
+│                                 (Farben/Radius/Schatten), nicht direkt eingebunden
+│                                 (Ant-Design-Klassennamen passen nicht zu Deklarix'
+│                                 reinem HTML/htmx-Stack, siehe internal/web/static/app.css)
 ├── packaging/
 │   └── DEBIAN/
 │       └── control.tmpl        # .deb Package-Control-Template
@@ -305,12 +458,17 @@ nicht anzulegen. Noch nicht gebaut (kein Abo-System).
   NICHT append-only (normale Zustandsänderung `entwurf` →
   `eingereicht` → `entschieden`, wie `submission` es im alten Produkt
   war).
-- `bewertung`, `entscheidung`, `registereintrag` — **noch nicht
+- `bewertung` — der berechnete Vorschlag (Schritt 4).
-  gebaut**, geplant für Schritt 5/6 der Baureihenfolge.
+- `entscheidung` — die Entscheidung eines/einer Verantwortlichen über
+  einen Antrag, mit Snapshot des gewählten Werkzeugs (`werkzeug_snapshot`,
+  JSONB) und Ablaufdatum (`gueltig_bis`) bei Genehmigung (Schritt 5).
+- `registereintrag` — automatisch bei jeder Genehmigung erzeugt
+  (Schritt 6), denormalisierter Nachweis (eigene Textspalten statt
+  Joins über bewertung/entscheidung/werkzeug).
 
 **Append-only:** kein UPDATE auf `audit_log` (Trigger `forbid_update_delete`,
-wiederverwendet aus dem alten Produkt). `bewertung`/`entscheidung`/
+wiederverwendet aus dem alten Produkt), ebenso `bewertung`,
-`registereintrag` werden bei ihrer Einführung ebenfalls append-only.
+`entscheidung` und `registereintrag`.
 
 ---
 
@@ -341,9 +499,33 @@ wiederverwendet aus dem alten Produkt). `bewertung`/`entscheidung`/
    `bewertung` ist append-only. Getestet inkl. K.-o.-Prüfung
    (`verboten` überspringt die Werkzeugsuche) und hartem Filter
    gegen den Katalog.)
-5. Entscheidung, Snapshot, Audit-Log
+5. ~~Entscheidung, Snapshot, Audit-Log~~ — **erledigt** (Ebene 3:
-6. Registereintrag und Export
+   `GET /faelle` Posteingang, `GET /faelle/{id}` + `POST
-7. Wiedervorlage und Katalog-Benachrichtigung
+   /faelle/{id}/entscheiden`. `verantwortlicher` entscheidet,
+   `pruefer` sieht dieselbe Seite ohne Entscheidungsrecht [403 bei
+   Entscheidungsversuch]. Begründung ist Pflicht bei Abweichung vom
+   abgeleiteten Vorschlag (`vorschlagFuer`), Genehmigung friert den
+   vollständigen Werkzeugdatensatz ein und braucht ein zulässiges
+   Werkzeug aus der Bewertung, `entscheidung` ist append-only, jede
+   Entscheidung erzeugt einen `audit_log`-Eintrag.)
+6. ~~Registereintrag und Export~~ — **erledigt** (`internal/web/register_handlers.go`:
+   `GET /registereintraege` zeigt alle Registereinträge des Mandanten,
+   `GET /registereintraege/export.{csv,pdf}` exportiert sie. Jede
+   Genehmigung — `genehmigt` oder `genehmigt_mit_auflagen` — erzeugt in
+   `handleFallEntscheiden` automatisch einen `registereintrag`
+   [append-only, Migration 0011]: Zweck [`antrag.titel`], Abteilung,
+   Werkzeug, Datenklasse, Einstufung, Auflagen [die Anforderungen der
+   Bewertung], Verantwortliche/r, Entscheidungsdatum, Gültigkeit —
+   bewusst denormalisiert [eigene Textspalten statt Joins], damit ein
+   Eintrag nicht von einem späteren Katalog-/Abteilungs-Wandel abhängt.
+   Abgelehnte Entscheidungen und Rückfragen erzeugen keinen Eintrag.
+   Der PDF-Export nutzt das bereits vorhandene, bis dahin ungenutzte
+   `go-pdf/fpdf` [keine neue Abhängigkeit] mit `UnicodeTranslatorFromDescriptor`
+   für deutsche Umlaute.)
+7. ~~Wiedervorlage und Katalog-Benachrichtigung~~ — **erledigt**
+   (`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.)
 
 Nicht bauen (v1): automatische Genehmigung ohne Mensch, Erkennung
 tatsächlicher Werkzeug-Nutzung, Mitarbeiterüberwachung (nichts, was
@@ -571,12 +753,29 @@ journalctl -u deklarix -f
   ist ein bewusst noch nicht getroffener Architektur-Entscheid —
   Aufwand und Zeitpunkt mit dem Nutzer klären, bevor mehr Tabellen
   entstehen, die sonst nachträglich migriert werden müssten.
-- **"Admin und KI-Verantwortlicher" beim Firma-Onboarding** — die
+- ~~"Admin und KI-Verantwortlicher" beim Firma-Onboarding~~ — **pragmatisch
-  Spezifikation will, dass der erste Nutzer beide Rollen gleichzeitig
+  gelöst, kein Datenmodell-Umbau:** `app_user.role` bleibt ein einzelner
-  hat; `app_user.role` ist aktuell ein einzelner Wert. Muss geklärt
+  Wert (kein `roles`-Array, keine zwei `app_user`-Zeilen pro Person).
-  werden: zwei Rollen pro Nutzer zulassen (Datenmodell-Änderung) oder
+  Stattdessen bekommt die Rolle `admin` in `requireFachebene` (Ebene 3)
-  zwei `app_user`-Zeilen für dieselbe Person?
+  dieselben Rechte wie `verantwortlicher` — sieht Posteingang/Register/
-- **Zentraler Werkzeugkatalog ist leer** — "Werkzeugkatalog aus der
+  Wiedervorlage und darf entscheiden (`hatEntscheidungsrecht` in
-  Plattform vorbelegt" beim Onboarding ist nicht automatisiert, es gibt
+  `fachebene_handlers.go`). Grund: ohne das könnte eine frisch
-  noch keine Ebene-5/Betreiber-UI zur Katalogpflege.
+  registrierte Firma mit nur einem `admin`-Login keinen einzigen
+  eingereichten Antrag sehen oder bearbeiten — der Kernablauf wäre für
+  Einzelpersonen-/Kleinfirmen-Onboarding komplett blockiert. `pruefer`
+  bleibt unverändert nur lesend, ohne Entscheidungsrecht. Kompromiss statt
+  "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.
 - Markenanmeldung Deklarix, sobald erster Kunde zahlt.

internal/store/account.go

@@ -10,20 +10,35 @@ import (
 )
 
 // Account ist ein Mandant (ein Unternehmen, das die Antragsprüfung
-// nutzt). Jeder Antrag gehört genau einem Account.
+// nutzt). Jeder Antrag gehört genau einem Account. EinladungToken ist
+// der Sammellink für die Mitarbeiter-Selbstanmeldung (Ebene 1,
+// "Einladung annehmen") — ein Token pro Account, per Admin erneuerbar.
 type Account struct {
 	ID             string
 	Name           string
+	EinladungToken string
 	CreatedAt      time.Time
 }
 
-// CreateAccount legt einen neuen Mandanten an.
+const accountColumns = `id, name, einladung_token, created_at`
-func (s *Store) CreateAccount(ctx context.Context, name string) (Account, error) {
+
+func scanAccount(row interface {
+	Scan(dest ...any) error
+}) (Account, error) {
 	var a Account
-	err := s.Pool.QueryRow(ctx, `
+	err := row.Scan(&a.ID, &a.Name, &a.EinladungToken, &a.CreatedAt)
+	return a, err
+}
+
+// CreateAccount legt einen neuen Mandanten an. einladung_token wird von
+// der Datenbank per DEFAULT erzeugt (siehe Migration 0013).
+func (s *Store) CreateAccount(ctx context.Context, name string) (Account, error) {
+	row := s.Pool.QueryRow(ctx, `
 		INSERT INTO account (name) VALUES ($1)
-		RETURNING id, name, created_at
+		RETURNING `+accountColumns,
-	`, name).Scan(&a.ID, &a.Name, &a.CreatedAt)
+		name,
+	)
+	a, err := scanAccount(row)
 	if err != nil {
 		return Account{}, fmt.Errorf("store: create account: %w", err)
 	}
@@ -32,10 +47,8 @@ func (s *Store) CreateAccount(ctx context.Context, name string) (Account, error)
 
 // GetAccount liest einen Mandanten anhand seiner ID.
 func (s *Store) GetAccount(ctx context.Context, id string) (Account, error) {
-	var a Account
+	row := s.Pool.QueryRow(ctx, `SELECT `+accountColumns+` FROM account WHERE id = $1`, id)
-	err := s.Pool.QueryRow(ctx, `
+	a, err := scanAccount(row)
-		SELECT id, name, created_at FROM account WHERE id = $1
-	`, id).Scan(&a.ID, &a.Name, &a.CreatedAt)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return Account{}, ErrNotFound
 	}
@@ -45,12 +58,40 @@ func (s *Store) GetAccount(ctx context.Context, id string) (Account, error) {
 	return a, nil
 }
 
+// GetAccountByEinladungToken liest den Mandanten zu einem
+// Einladungslink — für die öffentliche Mitarbeiter-Selbstanmeldung
+// (Ebene 1, kein Login nötig). Liefert ErrNotFound bei unbekanntem
+// oder bereits erneuertem (damit ungültig gewordenem) Token.
+func (s *Store) GetAccountByEinladungToken(ctx context.Context, token string) (Account, error) {
+	row := s.Pool.QueryRow(ctx, `SELECT `+accountColumns+` FROM account WHERE einladung_token = $1`, token)
+	a, err := scanAccount(row)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Account{}, ErrNotFound
+	}
+	if err != nil {
+		return Account{}, fmt.Errorf("store: get account by einladung token: %w", err)
+	}
+	return a, nil
+}
+
+// RegenerateEinladungToken ersetzt den Einladungslink eines Mandanten
+// durch einen neuen — der alte Link wird damit sofort ungültig (z. B.
+// wenn er versehentlich außerhalb des Unternehmens geteilt wurde).
+func (s *Store) RegenerateEinladungToken(ctx context.Context, accountID, newToken string) error {
+	tag, err := s.Pool.Exec(ctx, `UPDATE account SET einladung_token = $2 WHERE id = $1`, accountID, newToken)
+	if err != nil {
+		return fmt.Errorf("store: regenerate einladung token: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
 // ListAccounts liefert alle Mandanten, neueste zuerst — für den
 // Admin-Bereich (Accounts-Verwaltung).
 func (s *Store) ListAccounts(ctx context.Context) ([]Account, error) {
-	rows, err := s.Pool.Query(ctx, `
+	rows, err := s.Pool.Query(ctx, `SELECT `+accountColumns+` FROM account ORDER BY created_at DESC`)
-		SELECT id, name, created_at FROM account ORDER BY created_at DESC
-	`)
 	if err != nil {
 		return nil, fmt.Errorf("store: list accounts: %w", err)
 	}
@@ -58,8 +99,8 @@ func (s *Store) ListAccounts(ctx context.Context) ([]Account, error) {
 
 	var out []Account
 	for rows.Next() {
-		var a Account
+		a, err := scanAccount(rows)
-		if err := rows.Scan(&a.ID, &a.Name, &a.CreatedAt); err != nil {
+		if err != nil {
 			return nil, fmt.Errorf("store: scan account: %w", err)
 		}
 		out = append(out, a)

internal/store/auth_test.go

@@ -25,6 +25,56 @@ func TestAccountCRUD(t *testing.T) {
 	if got.Name != "Beispiel Agentur GmbH" {
 		t.Fatalf("Name = %q, want Beispiel Agentur GmbH", got.Name)
 	}
+	if got.EinladungToken == "" {
+		t.Error("expected a newly created account to have a non-empty EinladungToken")
+	}
+}
+
+func TestGetAccountByEinladungToken(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	acc, err := s.CreateAccount(ctx, "Beispiel Agentur GmbH")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+
+	got, err := s.GetAccountByEinladungToken(ctx, acc.EinladungToken)
+	if err != nil {
+		t.Fatalf("GetAccountByEinladungToken: %v", err)
+	}
+	if got.ID != acc.ID {
+		t.Fatalf("GetAccountByEinladungToken returned a different account")
+	}
+
+	_, err = s.GetAccountByEinladungToken(ctx, "unbekanntes-token")
+	if !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err = %v, want store.ErrNotFound for an unknown token", err)
+	}
+}
+
+func TestRegenerateEinladungToken(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	acc, err := s.CreateAccount(ctx, "Beispiel Agentur GmbH")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	alterToken := acc.EinladungToken
+
+	if err := s.RegenerateEinladungToken(ctx, acc.ID, "ein-neues-token"); err != nil {
+		t.Fatalf("RegenerateEinladungToken: %v", err)
+	}
+
+	if _, err := s.GetAccountByEinladungToken(ctx, alterToken); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("expected the old token to be invalid, got err = %v", err)
+	}
+	got, err := s.GetAccountByEinladungToken(ctx, "ein-neues-token")
+	if err != nil {
+		t.Fatalf("GetAccountByEinladungToken (neu): %v", err)
+	}
+	if got.ID != acc.ID {
+		t.Fatalf("GetAccountByEinladungToken (neu) returned a different account")
+	}
 }
 
 func TestUserCRUD(t *testing.T) {
@@ -52,6 +102,49 @@ func TestUserCRUD(t *testing.T) {
 	if byID.Email != "team@example.com" || byID.AccountID != accID {
 		t.Fatalf("GetUser = %+v, unerwartete Werte", byID)
 	}
+	if !byID.Active {
+		t.Error("expected a newly created user to be Active by default")
+	}
+}
+
+func TestSetUserActive(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	user, err := s.CreateUser(ctx, accID, "deaktivierbar@example.com", "bcrypt-hash", "mitarbeiter")
+	if err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+
+	if err := s.SetUserActive(ctx, user.ID, false); err != nil {
+		t.Fatalf("SetUserActive (false): %v", err)
+	}
+	deaktiviert, err := s.GetUser(ctx, user.ID)
+	if err != nil {
+		t.Fatalf("GetUser: %v", err)
+	}
+	if deaktiviert.Active {
+		t.Fatal("expected the user to be inactive")
+	}
+
+	if err := s.SetUserActive(ctx, user.ID, true); err != nil {
+		t.Fatalf("SetUserActive (true): %v", err)
+	}
+	reaktiviert, err := s.GetUser(ctx, user.ID)
+	if err != nil {
+		t.Fatalf("GetUser: %v", err)
+	}
+	if !reaktiviert.Active {
+		t.Fatal("expected the user to be active again")
+	}
+}
+
+func TestSetUserActiveNotFound(t *testing.T) {
+	s := openTestStore(t)
+	err := s.SetUserActive(context.Background(), "00000000-0000-0000-0000-000000000000", false)
+	if !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err = %v, want store.ErrNotFound", err)
+	}
 }
 
 func TestGetUserByEmailNotFound(t *testing.T) {

internal/store/entscheidung.go

@@ -0,0 +1,146 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// Entscheidung ist die Entscheidung eines/einer Verantwortlichen über
+// einen Antrag, auf Basis einer Bewertung (Vorschlag). Append-only —
+// siehe Migration. WerkzeugSnapshot ist der eingefrorene, vollständige
+// Werkzeug-Datensatz zum Entscheidungszeitpunkt (nil, wenn kein
+// Werkzeug gewählt wurde, z. B. bei "abgelehnt") — ein späterer
+// Katalog-Wandel darf nicht rückwirkend verändern, worauf die
+// Entscheidung beruhte.
+type Entscheidung struct {
+	ID                string
+	AntragID          string
+	BewertungID       string
+	EntscheiderUserID string
+	Entscheidung      string
+	WerkzeugID        *string
+	WerkzeugSnapshot  *Werkzeug
+	Begruendung       string
+	GueltigBis        *time.Time
+	CreatedAt         time.Time
+}
+
+const entscheidungColumns = `id, antrag_id, bewertung_id, entscheider_user_id, entscheidung,
+	werkzeug_id, werkzeug_snapshot, begruendung, gueltig_bis, created_at`
+
+func scanEntscheidung(row interface {
+	Scan(dest ...any) error
+}) (Entscheidung, error) {
+	var e Entscheidung
+	var snapshotRaw []byte
+	err := row.Scan(
+		&e.ID, &e.AntragID, &e.BewertungID, &e.EntscheiderUserID, &e.Entscheidung,
+		&e.WerkzeugID, &snapshotRaw, &e.Begruendung, &e.GueltigBis, &e.CreatedAt,
+	)
+	if err != nil {
+		return Entscheidung{}, err
+	}
+	if snapshotRaw != nil {
+		var w Werkzeug
+		if err := json.Unmarshal(snapshotRaw, &w); err != nil {
+			return Entscheidung{}, fmt.Errorf("store: werkzeug_snapshot unmarshal: %w", err)
+		}
+		e.WerkzeugSnapshot = &w
+	}
+	return e, nil
+}
+
+// EntscheidungInput bündelt die Felder einer neuen Entscheidung.
+type EntscheidungInput struct {
+	AntragID          string
+	BewertungID       string
+	EntscheiderUserID string
+	Entscheidung      string
+	WerkzeugID        *string
+	WerkzeugSnapshot  *Werkzeug
+	Begruendung       string
+	GueltigBis        *time.Time
+}
+
+// CreateEntscheidung speichert eine Entscheidung über einen Antrag.
+func (s *Store) CreateEntscheidung(ctx context.Context, in EntscheidungInput) (Entscheidung, error) {
+	var snapshotJSON []byte
+	if in.WerkzeugSnapshot != nil {
+		var err error
+		snapshotJSON, err = json.Marshal(in.WerkzeugSnapshot)
+		if err != nil {
+			return Entscheidung{}, fmt.Errorf("store: werkzeug_snapshot marshal: %w", err)
+		}
+	}
+
+	row := s.Pool.QueryRow(ctx, `
+		INSERT INTO entscheidung (
+			antrag_id, bewertung_id, entscheider_user_id, entscheidung, werkzeug_id, werkzeug_snapshot, begruendung, gueltig_bis
+		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+		RETURNING `+entscheidungColumns,
+		in.AntragID, in.BewertungID, in.EntscheiderUserID, in.Entscheidung, in.WerkzeugID, snapshotJSON, in.Begruendung, in.GueltigBis,
+	)
+	e, err := scanEntscheidung(row)
+	if err != nil {
+		return Entscheidung{}, fmt.Errorf("store: create entscheidung: %w", err)
+	}
+	return e, nil
+}
+
+// GetLatestEntscheidungForAntrag liefert die zuletzt getroffene
+// Entscheidung eines Antrags. Liefert ErrNotFound, wenn noch keine
+// Entscheidung existiert.
+func (s *Store) GetLatestEntscheidungForAntrag(ctx context.Context, antragID string) (Entscheidung, error) {
+	row := s.Pool.QueryRow(ctx, `
+		SELECT `+entscheidungColumns+`
+		FROM entscheidung WHERE antrag_id = $1 ORDER BY created_at DESC LIMIT 1
+	`, antragID)
+	e, err := scanEntscheidung(row)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Entscheidung{}, ErrNotFound
+	}
+	if err != nil {
+		return Entscheidung{}, fmt.Errorf("store: get latest entscheidung: %w", err)
+	}
+	return e, nil
+}
+
+// ListAktiveGenehmigungenForAccount liefert alle Genehmigungen
+// ("genehmigt"/"genehmigt_mit_auflagen") eines Mandanten — Grundlage
+// für die Wiedervorlage (Schritt 7): abgelaufene/bald ablaufende
+// Genehmigungen und solche, deren zugrunde liegendes Werkzeug sich seit
+// der Entscheidung im Katalog geändert hat, muss der/die Verantwortliche
+// erneut prüfen. entscheidung trägt selbst kein account_id — der Bezug
+// zum Mandanten läuft über den zugehörigen antrag.
+func (s *Store) ListAktiveGenehmigungenForAccount(ctx context.Context, accountID string) ([]Entscheidung, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT e.id, e.antrag_id, e.bewertung_id, e.entscheider_user_id, e.entscheidung,
+			e.werkzeug_id, e.werkzeug_snapshot, e.begruendung, e.gueltig_bis, e.created_at
+		FROM entscheidung e
+		JOIN antrag a ON a.id = e.antrag_id
+		WHERE a.account_id = $1 AND e.entscheidung IN ('genehmigt', 'genehmigt_mit_auflagen')
+		ORDER BY e.created_at DESC
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list aktive genehmigungen for account: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Entscheidung
+	for rows.Next() {
+		e, err := scanEntscheidung(rows)
+		if err != nil {
+			return nil, fmt.Errorf("store: scan entscheidung: %w", err)
+		}
+		out = append(out, e)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list aktive genehmigungen for account: %w", err)
+	}
+	return out, nil
+}

internal/store/entscheidung_test.go

@@ -0,0 +1,153 @@
+package store_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func testAntragMitBewertung(t *testing.T, s *store.Store, accountID, userID string) (store.Antrag, store.Bewertung) {
+	t.Helper()
+	ctx := context.Background()
+	antrag, err := s.CreateAntrag(ctx, accountID, userID, nil, "Testantrag")
+	if err != nil {
+		t.Fatalf("CreateAntrag: %v", err)
+	}
+	b, err := s.CreateBewertung(ctx, testBewertungInput(antrag.ID))
+	if err != nil {
+		t.Fatalf("CreateBewertung: %v", err)
+	}
+	return antrag, b
+}
+
+func TestEntscheidungCreateAndGetLatest(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, b := testAntragMitBewertung(t, s, accID, userID)
+	w, err := s.CreateWerkzeug(ctx, testWerkzeugInput(nil, "ChatGPT Enterprise"))
+	if err != nil {
+		t.Fatalf("CreateWerkzeug: %v", err)
+	}
+	gueltigBis := time.Now().Add(365 * 24 * time.Hour).Truncate(time.Millisecond)
+
+	e, err := s.CreateEntscheidung(ctx, store.EntscheidungInput{
+		AntragID: antrag.ID, BewertungID: b.ID, EntscheiderUserID: userID,
+		Entscheidung: "genehmigt", WerkzeugID: &w.ID, WerkzeugSnapshot: &w,
+		Begruendung: "", GueltigBis: &gueltigBis,
+	})
+	if err != nil {
+		t.Fatalf("CreateEntscheidung: %v", err)
+	}
+	if e.Entscheidung != "genehmigt" || e.WerkzeugSnapshot == nil || e.WerkzeugSnapshot.Name != "ChatGPT Enterprise" {
+		t.Fatalf("CreateEntscheidung = %+v, unerwartete Werte", e)
+	}
+
+	got, err := s.GetLatestEntscheidungForAntrag(ctx, antrag.ID)
+	if err != nil {
+		t.Fatalf("GetLatestEntscheidungForAntrag: %v", err)
+	}
+	if got.ID != e.ID {
+		t.Fatalf("GetLatestEntscheidungForAntrag returned a different row than CreateEntscheidung")
+	}
+}
+
+func TestEntscheidungOhneWerkzeugHatKeinenSnapshot(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, b := testAntragMitBewertung(t, s, accID, userID)
+
+	e, err := s.CreateEntscheidung(ctx, store.EntscheidungInput{
+		AntragID: antrag.ID, BewertungID: b.ID, EntscheiderUserID: userID,
+		Entscheidung: "abgelehnt", Begruendung: "Kein geeignetes Werkzeug im Katalog",
+	})
+	if err != nil {
+		t.Fatalf("CreateEntscheidung: %v", err)
+	}
+	if e.WerkzeugID != nil || e.WerkzeugSnapshot != nil {
+		t.Fatalf("expected no werkzeug/snapshot for an abgelehnt Entscheidung, got %+v", e)
+	}
+}
+
+func TestGetLatestEntscheidungForAntragNotFound(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, err := s.CreateAntrag(ctx, accID, userID, nil, "Ohne Entscheidung")
+	if err != nil {
+		t.Fatalf("CreateAntrag: %v", err)
+	}
+
+	_, err = s.GetLatestEntscheidungForAntrag(ctx, antrag.ID)
+	if !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err = %v, want store.ErrNotFound", err)
+	}
+}
+
+func TestEntscheidungIsAppendOnly(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, b := testAntragMitBewertung(t, s, accID, userID)
+	e, err := s.CreateEntscheidung(ctx, store.EntscheidungInput{
+		AntragID: antrag.ID, BewertungID: b.ID, EntscheiderUserID: userID, Entscheidung: "rueckfrage",
+	})
+	if err != nil {
+		t.Fatalf("CreateEntscheidung: %v", err)
+	}
+
+	_, err = s.Pool.Exec(ctx, `UPDATE entscheidung SET entscheidung = 'genehmigt' WHERE id = $1`, e.ID)
+	if err == nil {
+		t.Fatal("expected UPDATE on entscheidung to be rejected by the append-only trigger")
+	}
+	_, err = s.Pool.Exec(ctx, `DELETE FROM entscheidung WHERE id = $1`, e.ID)
+	if err == nil {
+		t.Fatal("expected DELETE on entscheidung to be rejected by the append-only trigger")
+	}
+}
+
+func TestListAktiveGenehmigungenForAccount(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+
+	antragGenehmigt, b1 := testAntragMitBewertung(t, s, accID, userID)
+	if _, err := s.CreateEntscheidung(ctx, store.EntscheidungInput{
+		AntragID: antragGenehmigt.ID, BewertungID: b1.ID, EntscheiderUserID: userID, Entscheidung: "genehmigt",
+	}); err != nil {
+		t.Fatalf("CreateEntscheidung (genehmigt): %v", err)
+	}
+
+	antragAbgelehnt, b2 := testAntragMitBewertung(t, s, accID, userID)
+	if _, err := s.CreateEntscheidung(ctx, store.EntscheidungInput{
+		AntragID: antragAbgelehnt.ID, BewertungID: b2.ID, EntscheiderUserID: userID, Entscheidung: "abgelehnt",
+	}); err != nil {
+		t.Fatalf("CreateEntscheidung (abgelehnt): %v", err)
+	}
+
+	list, err := s.ListAktiveGenehmigungenForAccount(ctx, accID)
+	if err != nil {
+		t.Fatalf("ListAktiveGenehmigungenForAccount: %v", err)
+	}
+	if len(list) != 1 || list[0].AntragID != antragGenehmigt.ID {
+		t.Fatalf("ListAktiveGenehmigungenForAccount = %+v, want exactly the genehmigt entscheidung", list)
+	}
+
+	otherAcc := testAccountID(t, s)
+	otherList, err := s.ListAktiveGenehmigungenForAccount(ctx, otherAcc)
+	if err != nil {
+		t.Fatalf("ListAktiveGenehmigungenForAccount (other): %v", err)
+	}
+	if len(otherList) != 0 {
+		t.Fatalf("expected no genehmigungen for a different tenant, got %+v", otherList)
+	}
+}

internal/store/migrations/0010_entscheidung.down.sql

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

internal/store/migrations/0010_entscheidung.up.sql

@@ -0,0 +1,25 @@
+-- Entscheidung: der Mensch entscheidet, das System bereitet nur vor
+-- (siehe CLAUDE.md, Grundregel). Eine Entscheidung bezieht sich auf
+-- genau eine Bewertung (den Vorschlag, auf dessen Basis entschieden
+-- wurde) und friert optional ein gewähltes Werkzeug als vollständigen
+-- Datensatz ein (werkzeug_snapshot) — ein späterer Katalog-Wandel darf
+-- nicht rückwirkend verändern, worauf eine Entscheidung beruhte.
+-- Append-only wie bewertung/audit_log: eine Entscheidung wird nicht
+-- korrigiert, sondern durch eine neue Entscheidung auf Basis einer
+-- neuen Bewertung ersetzt (Neubewertung + erneute Entscheidung).
+CREATE TABLE entscheidung (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    antrag_id UUID NOT NULL REFERENCES antrag (id),
+    bewertung_id UUID NOT NULL REFERENCES bewertung (id),
+    entscheider_user_id UUID NOT NULL REFERENCES app_user (id),
+    entscheidung TEXT NOT NULL CHECK (entscheidung IN ('genehmigt', 'genehmigt_mit_auflagen', 'abgelehnt', 'rueckfrage')),
+    werkzeug_id UUID REFERENCES werkzeug (id),
+    werkzeug_snapshot JSONB,
+    begruendung TEXT NOT NULL DEFAULT '',
+    gueltig_bis TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TRIGGER entscheidung_append_only
+    BEFORE UPDATE OR DELETE ON entscheidung
+    FOR EACH ROW EXECUTE FUNCTION forbid_update_delete();

internal/store/migrations/0011_registereintrag.down.sql

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

internal/store/migrations/0011_registereintrag.up.sql

@@ -0,0 +1,27 @@
+-- Registereintrag: wird automatisch bei jeder Genehmigung erzeugt
+-- (genehmigt / genehmigt_mit_auflagen), siehe CLAUDE.md, Entscheidung/
+-- Register/Wiedervorlage. Bewusst denormalisiert (eigene Textspalten
+-- statt Joins über bewertung/entscheidung/werkzeug) — ein Registereintrag
+-- ist ein für sich lesbarer, exportierbarer Nachweis, der nicht von
+-- einem späteren Katalog- oder Abteilungs-Wandel abhängen darf.
+-- Append-only wie bewertung/entscheidung.
+CREATE TABLE registereintrag (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    account_id UUID NOT NULL REFERENCES account (id),
+    antrag_id UUID NOT NULL REFERENCES antrag (id),
+    entscheidung_id UUID NOT NULL REFERENCES entscheidung (id),
+    zweck TEXT NOT NULL,
+    abteilung TEXT NOT NULL DEFAULT '',
+    werkzeug TEXT NOT NULL,
+    datenklasse TEXT NOT NULL,
+    einstufung TEXT NOT NULL,
+    auflagen TEXT[] NOT NULL DEFAULT '{}',
+    verantwortlicher TEXT NOT NULL,
+    entschieden_am TIMESTAMPTZ NOT NULL,
+    gueltig_bis TIMESTAMPTZ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TRIGGER registereintrag_append_only
+    BEFORE UPDATE OR DELETE ON registereintrag
+    FOR EACH ROW EXECUTE FUNCTION forbid_update_delete();

internal/store/migrations/0012_app_user_active.down.sql

@@ -0,0 +1 @@
+ALTER TABLE app_user DROP COLUMN active;

internal/store/migrations/0012_app_user_active.up.sql

@@ -0,0 +1,7 @@
+-- Nutzer können nicht gelöscht werden (app_user wird von antrag,
+-- session, bewertung [über antrag], entscheidung, audit_log,
+-- registereintrag [über antrag] per Foreign Key referenziert — ein
+-- Hard-Delete würde die Historie zerstören). Stattdessen: deaktivieren.
+-- Ein deaktivierter Nutzer kann sich nicht mehr anmelden, bleibt aber
+-- als Akteur in Anträgen/Entscheidungen/Audit-Log nachvollziehbar.
+ALTER TABLE app_user ADD COLUMN active BOOLEAN NOT NULL DEFAULT true;

internal/store/migrations/0013_account_einladung_token.down.sql

@@ -0,0 +1 @@
+ALTER TABLE account DROP COLUMN einladung_token;

internal/store/migrations/0013_account_einladung_token.up.sql

@@ -0,0 +1,8 @@
+-- Sammellink für die Mitarbeiter-Selbstanmeldung (Ebene 1, "Einladung
+-- annehmen" — siehe CLAUDE.md, Onboarding: "Einladungslink [Sammellink,
+-- Selbstanmeldung, Abteilung beim ersten Antrag]"). Ein Token pro
+-- Account, kein Ablaufdatum, per Admin erneuerbar (macht den alten
+-- Link ungültig). DEFAULT gen_random_uuid()::text befüllt bestehende
+-- Zeilen automatisch und liefert künftigen INSERTs einen Wert, ohne
+-- dass store.CreateAccount etwas ändern muss.
+ALTER TABLE account ADD COLUMN einladung_token TEXT UNIQUE NOT NULL DEFAULT gen_random_uuid()::text;

internal/store/registereintrag.go

@@ -0,0 +1,106 @@
+package store
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Registereintrag wird automatisch bei jeder Genehmigung erzeugt
+// (siehe CLAUDE.md, Entscheidung/Register/Wiedervorlage). Append-only
+// — siehe Migration. Bewusst denormalisiert: eigene Textspalten statt
+// Joins über bewertung/entscheidung/werkzeug, damit ein einmal
+// erzeugter Eintrag nicht von einem späteren Katalog- oder Abteilungs-
+// Wandel abhängt.
+type Registereintrag struct {
+	ID               string
+	AccountID        string
+	AntragID         string
+	EntscheidungID   string
+	Zweck            string
+	Abteilung        string
+	Werkzeug         string
+	Datenklasse      string
+	Einstufung       string
+	Auflagen         []string
+	Verantwortlicher string
+	EntschiedenAm    time.Time
+	GueltigBis       *time.Time
+	CreatedAt        time.Time
+}
+
+const registereintragColumns = `id, account_id, antrag_id, entscheidung_id, zweck, abteilung, werkzeug,
+	datenklasse, einstufung, auflagen, verantwortlicher, entschieden_am, gueltig_bis, created_at`
+
+func scanRegistereintrag(row interface {
+	Scan(dest ...any) error
+}) (Registereintrag, error) {
+	var e Registereintrag
+	err := row.Scan(
+		&e.ID, &e.AccountID, &e.AntragID, &e.EntscheidungID, &e.Zweck, &e.Abteilung, &e.Werkzeug,
+		&e.Datenklasse, &e.Einstufung, &e.Auflagen, &e.Verantwortlicher, &e.EntschiedenAm, &e.GueltigBis, &e.CreatedAt,
+	)
+	return e, err
+}
+
+// RegistereintragInput bündelt die Felder eines neuen Registereintrags.
+type RegistereintragInput struct {
+	AccountID        string
+	AntragID         string
+	EntscheidungID   string
+	Zweck            string
+	Abteilung        string
+	Werkzeug         string
+	Datenklasse      string
+	Einstufung       string
+	Auflagen         []string
+	Verantwortlicher string
+	EntschiedenAm    time.Time
+	GueltigBis       *time.Time
+}
+
+// CreateRegistereintrag speichert einen Registereintrag.
+func (s *Store) CreateRegistereintrag(ctx context.Context, in RegistereintragInput) (Registereintrag, error) {
+	if in.Auflagen == nil {
+		in.Auflagen = []string{}
+	}
+	row := s.Pool.QueryRow(ctx, `
+		INSERT INTO registereintrag (
+			account_id, antrag_id, entscheidung_id, zweck, abteilung, werkzeug,
+			datenklasse, einstufung, auflagen, verantwortlicher, entschieden_am, gueltig_bis
+		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+		RETURNING `+registereintragColumns,
+		in.AccountID, in.AntragID, in.EntscheidungID, in.Zweck, in.Abteilung, in.Werkzeug,
+		in.Datenklasse, in.Einstufung, in.Auflagen, in.Verantwortlicher, in.EntschiedenAm, in.GueltigBis,
+	)
+	e, err := scanRegistereintrag(row)
+	if err != nil {
+		return Registereintrag{}, fmt.Errorf("store: create registereintrag: %w", err)
+	}
+	return e, nil
+}
+
+// ListRegistereintraegeForAccount liefert alle Registereinträge eines
+// Mandanten, neueste zuerst.
+func (s *Store) ListRegistereintraegeForAccount(ctx context.Context, accountID string) ([]Registereintrag, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT `+registereintragColumns+` FROM registereintrag WHERE account_id = $1 ORDER BY entschieden_am DESC
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list registereintraege for account: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Registereintrag
+	for rows.Next() {
+		e, err := scanRegistereintrag(rows)
+		if err != nil {
+			return nil, fmt.Errorf("store: scan registereintrag: %w", err)
+		}
+		out = append(out, e)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list registereintraege for account: %w", err)
+	}
+	return out, nil
+}

internal/store/registereintrag_test.go

@@ -0,0 +1,100 @@
+package store_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func testRegistereintragInput(accountID, antragID, entscheidungID string) store.RegistereintragInput {
+	gueltigBis := time.Now().Add(365 * 24 * time.Hour).Truncate(time.Millisecond)
+	return store.RegistereintragInput{
+		AccountID: accountID, AntragID: antragID, EntscheidungID: entscheidungID,
+		Zweck: "Angebotstexte generieren", Abteilung: "Vertrieb", Werkzeug: "ChatGPT Enterprise",
+		Datenklasse: "personenbezogen", Einstufung: "minimal",
+		Auflagen:         []string{"AVV erforderlich", "kein Training auf Eingaben"},
+		Verantwortlicher: "verantwortlicher@example.com", EntschiedenAm: time.Now().Truncate(time.Millisecond),
+		GueltigBis: &gueltigBis,
+	}
+}
+
+func testEntscheidungID(t *testing.T, s *store.Store, antragID, bewertungID, userID string) string {
+	t.Helper()
+	e, err := s.CreateEntscheidung(context.Background(), store.EntscheidungInput{
+		AntragID: antragID, BewertungID: bewertungID, EntscheiderUserID: userID, Entscheidung: "genehmigt",
+	})
+	if err != nil {
+		t.Fatalf("CreateEntscheidung: %v", err)
+	}
+	return e.ID
+}
+
+func TestRegistereintragCreateAndList(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, bewertung := testAntragMitBewertung(t, s, accID, userID)
+	entscheidungID := testEntscheidungID(t, s, antrag.ID, bewertung.ID, userID)
+
+	e, err := s.CreateRegistereintrag(ctx, testRegistereintragInput(accID, antrag.ID, entscheidungID))
+	if err != nil {
+		t.Fatalf("CreateRegistereintrag: %v", err)
+	}
+	if e.Werkzeug != "ChatGPT Enterprise" || len(e.Auflagen) != 2 {
+		t.Fatalf("CreateRegistereintrag = %+v, unerwartete Werte", e)
+	}
+
+	list, err := s.ListRegistereintraegeForAccount(ctx, accID)
+	if err != nil {
+		t.Fatalf("ListRegistereintraegeForAccount: %v", err)
+	}
+	if len(list) != 1 || list[0].ID != e.ID {
+		t.Fatalf("ListRegistereintraegeForAccount = %+v, want exactly one entry", list)
+	}
+}
+
+func TestRegistereintragIsolatesTenants(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accA := testAccountID(t, s)
+	userA := testUserID(t, s, accA)
+	antragA, bewertungA := testAntragMitBewertung(t, s, accA, userA)
+	entscheidungA := testEntscheidungID(t, s, antragA.ID, bewertungA.ID, userA)
+	if _, err := s.CreateRegistereintrag(ctx, testRegistereintragInput(accA, antragA.ID, entscheidungA)); err != nil {
+		t.Fatalf("CreateRegistereintrag (A): %v", err)
+	}
+
+	accB := testAccountID(t, s)
+	list, err := s.ListRegistereintraegeForAccount(ctx, accB)
+	if err != nil {
+		t.Fatalf("ListRegistereintraegeForAccount (B): %v", err)
+	}
+	if len(list) != 0 {
+		t.Fatalf("expected no registereintraege for a different tenant, got %+v", list)
+	}
+}
+
+func TestRegistereintragIsAppendOnly(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userID := testUserID(t, s, accID)
+	antrag, bewertung := testAntragMitBewertung(t, s, accID, userID)
+	entscheidungID := testEntscheidungID(t, s, antrag.ID, bewertung.ID, userID)
+	e, err := s.CreateRegistereintrag(ctx, testRegistereintragInput(accID, antrag.ID, entscheidungID))
+	if err != nil {
+		t.Fatalf("CreateRegistereintrag: %v", err)
+	}
+
+	_, err = s.Pool.Exec(ctx, `UPDATE registereintrag SET werkzeug = 'geaendert' WHERE id = $1`, e.ID)
+	if err == nil {
+		t.Fatal("expected UPDATE on registereintrag to be rejected by the append-only trigger")
+	}
+	_, err = s.Pool.Exec(ctx, `DELETE FROM registereintrag WHERE id = $1`, e.ID)
+	if err == nil {
+		t.Fatal("expected DELETE on registereintrag to be rejected by the append-only trigger")
+	}
+}

internal/store/user.go

@@ -15,28 +15,41 @@ import (
 // Login: falsche E-Mail vs. Datenbankfehler).
 var ErrNotFound = errors.New("store: nicht gefunden")
 
-// User ist ein Login innerhalb eines Account (Mandanten).
+// User ist ein Login innerhalb eines Account (Mandanten). Nutzer werden
+// nicht gelöscht (app_user wird von antrag/session/entscheidung/
+// audit_log per Foreign Key referenziert — ein Hard-Delete würde die
+// Historie zerstören), sondern über Active deaktiviert.
 type User struct {
 	ID           string
 	AccountID    string
 	Email        string
 	PasswordHash string
 	Role         string
+	Active       bool
 	CreatedAt    time.Time
 }
 
+const userColumns = `id, account_id, email, password_hash, role, active, created_at`
+
+func scanUser(row interface {
+	Scan(dest ...any) error
+}) (User, error) {
+	var u User
+	err := row.Scan(&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.Active, &u.CreatedAt)
+	return u, err
+}
+
 // CreateUser legt einen neuen Nutzer innerhalb eines Accounts an.
 // passwordHash muss bereits gehasht sein (siehe internal/auth) — store
 // speichert nur, es hasht nicht selbst.
 func (s *Store) CreateUser(ctx context.Context, accountID, email, passwordHash, role string) (User, error) {
-	var u User
+	row := s.Pool.QueryRow(ctx, `
-	err := s.Pool.QueryRow(ctx, `
 		INSERT INTO app_user (account_id, email, password_hash, role)
 		VALUES ($1, $2, $3, $4)
-		RETURNING id, account_id, email, password_hash, role, created_at
+		RETURNING `+userColumns,
-	`, accountID, email, passwordHash, role).Scan(
+		accountID, email, passwordHash, role,
-		&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.CreatedAt,
 	)
+	u, err := scanUser(row)
 	if err != nil {
 		return User{}, fmt.Errorf("store: create user: %w", err)
 	}
@@ -46,11 +59,8 @@ func (s *Store) CreateUser(ctx context.Context, accountID, email, passwordHash,
 // GetUserByEmail liest einen Nutzer anhand seiner E-Mail-Adresse.
 // Liefert ErrNotFound, wenn keine E-Mail passt (kein Datenbankfehler).
 func (s *Store) GetUserByEmail(ctx context.Context, email string) (User, error) {
-	var u User
+	row := s.Pool.QueryRow(ctx, `SELECT `+userColumns+` FROM app_user WHERE email = $1`, email)
-	err := s.Pool.QueryRow(ctx, `
+	u, err := scanUser(row)
-		SELECT id, account_id, email, password_hash, role, created_at
-		FROM app_user WHERE email = $1
-	`, email).Scan(&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.CreatedAt)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return User{}, ErrNotFound
 	}
@@ -62,11 +72,8 @@ func (s *Store) GetUserByEmail(ctx context.Context, email string) (User, error)
 
 // GetUser liest einen Nutzer anhand seiner ID.
 func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
-	var u User
+	row := s.Pool.QueryRow(ctx, `SELECT `+userColumns+` FROM app_user WHERE id = $1`, id)
-	err := s.Pool.QueryRow(ctx, `
+	u, err := scanUser(row)
-		SELECT id, account_id, email, password_hash, role, created_at
-		FROM app_user WHERE id = $1
-	`, id).Scan(&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.CreatedAt)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return User{}, ErrNotFound
 	}
@@ -80,8 +87,7 @@ func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
 // Admin-Bereich (Account-Detailansicht).
 func (s *Store) ListUsersForAccount(ctx context.Context, accountID string) ([]User, error) {
 	rows, err := s.Pool.Query(ctx, `
-		SELECT id, account_id, email, password_hash, role, created_at
+		SELECT `+userColumns+` FROM app_user WHERE account_id = $1 ORDER BY created_at
-		FROM app_user WHERE account_id = $1 ORDER BY created_at
 	`, accountID)
 	if err != nil {
 		return nil, fmt.Errorf("store: list users for account: %w", err)
@@ -90,8 +96,8 @@ func (s *Store) ListUsersForAccount(ctx context.Context, accountID string) ([]Us
 
 	var out []User
 	for rows.Next() {
-		var u User
+		u, err := scanUser(rows)
-		if err := rows.Scan(&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.CreatedAt); err != nil {
+		if err != nil {
 			return nil, fmt.Errorf("store: scan user: %w", err)
 		}
 		out = append(out, u)
@@ -101,3 +107,18 @@ func (s *Store) ListUsersForAccount(ctx context.Context, accountID string) ([]Us
 	}
 	return out, 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
+// nachvollziehbar — deshalb (de-)aktivieren statt löschen.
+func (s *Store) SetUserActive(ctx context.Context, id string, active bool) error {
+	tag, err := s.Pool.Exec(ctx, `UPDATE app_user SET active = $2 WHERE id = $1`, id, active)
+	if err != nil {
+		return fmt.Errorf("store: set user active: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}

internal/web/abteilung_handlers_test.go

@@ -0,0 +1,96 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestAdminCanCreateAndDeleteAbteilung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/abteilungen", url.Values{"name": {"Vertrieb"}})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("create status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/abteilungen")
+	if !strings.Contains(list.Body.String(), "Vertrieb") {
+		t.Errorf("expected Vertrieb in the Abteilungsliste, got: %s", list.Body.String())
+	}
+
+	var abtID string
+	for accID, abts := range fs.abteilungen {
+		_ = accID
+		for _, a := range abts {
+			if a.Name == "Vertrieb" {
+				abtID = a.ID
+			}
+		}
+	}
+	if abtID == "" {
+		t.Fatal("expected Vertrieb to exist in fakeStore")
+	}
+
+	delResp := postForm(t, s, adminCookie, "/verwaltung/abteilungen/"+abtID+"/loeschen", url.Values{})
+	if delResp.Code != http.StatusSeeOther {
+		t.Fatalf("delete status = %d, body: %s", delResp.Code, delResp.Body.String())
+	}
+	if _, err := fs.GetAbteilung(context.Background(), abtID); err == nil {
+		t.Error("expected the Abteilung to be deleted")
+	}
+}
+
+func TestNeueAntragFormZeigtAngelegteAbteilung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	postForm(t, s, adminCookie, "/verwaltung/abteilungen", url.Values{"name": {"Marketing"}})
+
+	resp := getWithCookie(t, s, adminCookie, "/antraege/neu")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Marketing") {
+		t.Errorf("expected the newly created Abteilung in the Fragebogen, got: %s", resp.Body.String())
+	}
+}
+
+func TestMitarbeiterCannotAccessAbteilungsverwaltung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/abteilungen")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter", resp.Code)
+	}
+}
+
+func TestAdminCannotDeleteForeignAbteilung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminA := seedAccountWithRole(t, fs, "Mandant A", "admin-a@example.com", "admin")
+	postForm(t, s, adminA, "/verwaltung/abteilungen", url.Values{"name": {"Nur A"}})
+	var abtID string
+	for _, abts := range fs.abteilungen {
+		for _, a := range abts {
+			if a.Name == "Nur A" {
+				abtID = a.ID
+			}
+		}
+	}
+	adminB := seedAccountWithRole(t, fs, "Mandant B", "admin-b@example.com", "admin")
+
+	resp := postForm(t, s, adminB, "/verwaltung/abteilungen/"+abtID+"/loeschen", url.Values{})
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a foreign account's Abteilung", resp.Code)
+	}
+	if _, err := fs.GetAbteilung(context.Background(), abtID); err != nil {
+		t.Error("expected the foreign Abteilung to still exist")
+	}
+}

internal/web/admin_fachebene_test.go

@@ -0,0 +1,72 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+// TestAdminHatFachebeneRechte prüft die pragmatische Lösung für "Admin
+// und KI-Verantwortlicher auf derselben Person" (siehe CLAUDE.md,
+// Offene Punkte / requireFachebene): ein admin sieht den Posteingang
+// und kann entscheiden, genau wie ein verantwortlicher.
+func TestAdminSiehtPosteingang(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	_, adminCookie := seedFallImAccount(t, fs, s, "admin")
+
+	resp := getWithCookie(t, s, adminCookie, "/faelle")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected the open antrag in the Posteingang, got: %s", resp.Body.String())
+	}
+}
+
+func TestAdminSiehtEntscheidenFormular(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, adminCookie := seedFallImAccount(t, fs, s, "admin")
+
+	resp := getWithCookie(t, s, adminCookie, "/faelle/"+antragID)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), `name="entscheidung"`) {
+		t.Errorf("expected the Entscheiden form for admin, got: %s", resp.Body.String())
+	}
+}
+
+func TestAdminKannEntscheiden(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, adminCookie := seedFallImAccount(t, fs, s, "admin")
+
+	resp := postForm(t, s, adminCookie, "/faelle/"+antragID+"/entscheiden", url.Values{"entscheidung": {"rueckfrage"}})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	antrag, err := fs.GetAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetAntrag: %v", err)
+	}
+	if antrag.Status != "entschieden" {
+		t.Errorf("Status = %q, want entschieden", antrag.Status)
+	}
+}
+
+func TestAdminSiehtRegisterUndWiedervorlage(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	for _, path := range []string{"/registereintraege", "/wiedervorlage"} {
+		resp := getWithCookie(t, s, adminCookie, path)
+		if resp.Code != http.StatusOK {
+			t.Errorf("GET %s status = %d, want 200 for admin", path, resp.Code)
+		}
+	}
+}

internal/web/admin_handlers.go

@@ -0,0 +1,218 @@
+// Ebene 4 (Mandanten-Verwaltung) — Nutzer/Rollen und Abteilungen für
+// GENAU EINEN Mandanten, siehe CLAUDE.md, Fünf Ebenen. Anmeldeverfahren,
+// Werkzeug-Freigaben/-Sperrungen und Rechnungsdaten sind weiterhin
+// spätere Ausbaustufen. Es gibt noch keinen Einladungslink/CSV-Import/
+// SSO (siehe CLAUDE.md, Onboarding) — ein Admin setzt hier direkt ein
+// Initialpasswort, wie schon bei der Firma-Registrierung.
+package web
+
+import (
+	"net/http"
+
+	"github.com/netcell-it/deklarix/internal/auth"
+)
+
+// mandantenRollen sind die Rollen, die ein Admin innerhalb des eigenen
+// Mandanten vergeben darf — "betreiber" ist Ebene 5 (Plattform) und
+// kann von keinem Mandanten-Admin vergeben werden.
+var mandantenRollen = []string{"mitarbeiter", "verantwortlicher", "pruefer", "admin"}
+
+func istMandantenRolle(role string) bool {
+	for _, r := range mandantenRollen {
+		if r == role {
+			return true
+		}
+	}
+	return false
+}
+
+type nutzerListItem struct {
+	ID        string
+	Email     string
+	Role      string
+	Active    bool
+	IstSelbst bool
+}
+
+type nutzerListeData struct {
+	Title  string
+	Nav    navData
+	Nutzer []nutzerListItem
+}
+
+// handleNutzerListe zeigt alle Logins des eigenen Mandanten.
+func (s *Server) handleNutzerListe(w http.ResponseWriter, r *http.Request) {
+	self := currentUser(r)
+	users, err := s.store.ListUsersForAccount(r.Context(), self.AccountID)
+	if err != nil {
+		http.Error(w, "Nutzer konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := nutzerListeData{Title: "Nutzerverwaltung", Nav: navFor(r)}
+	for _, u := range users {
+		data.Nutzer = append(data.Nutzer, nutzerListItem{
+			ID: u.ID, Email: u.Email, Role: u.Role, Active: u.Active, IstSelbst: u.ID == self.ID,
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleNutzerDeaktivieren sperrt einen Login des eigenen Mandanten —
+// nicht löschen, siehe store.User (Fremdschlüssel auf antrag/entscheidung/
+// audit_log würden das verhindern und die Historie zerstören). Ein Admin
+// kann sich nicht selbst deaktivieren, sonst könnte ein Mandant sich
+// versehentlich komplett aussperren.
+func (s *Server) handleNutzerDeaktivieren(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	self := currentUser(r)
+	if id == self.ID {
+		http.Error(w, "Der eigene Zugang kann nicht deaktiviert werden", http.StatusBadRequest)
+		return
+	}
+	target, err := s.store.GetUser(r.Context(), id)
+	if err != nil || target.AccountID != self.AccountID {
+		http.Error(w, "Nutzer nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.SetUserActive(r.Context(), id, false); err != nil {
+		http.Error(w, "Nutzer konnte nicht deaktiviert werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/nutzer", http.StatusSeeOther)
+}
+
+func (s *Server) handleNutzerAktivieren(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	target, err := s.store.GetUser(r.Context(), id)
+	if err != nil || target.AccountID != currentUser(r).AccountID {
+		http.Error(w, "Nutzer nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.SetUserActive(r.Context(), id, true); err != nil {
+		http.Error(w, "Nutzer konnte nicht aktiviert werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/nutzer", http.StatusSeeOther)
+}
+
+type nutzerNeuData struct {
+	Title  string
+	Nav    navData
+	Rollen []string
+	Error  string
+}
+
+func (s *Server) handleNutzerNeuForm(w http.ResponseWriter, r *http.Request) {
+	data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleNutzerCreate legt einen weiteren Login im eigenen Mandanten an.
+// Es gibt keine Einladungsmail (siehe CLAUDE.md, Onboarding — noch
+// nicht gebaut) — der Admin setzt das Initialpasswort direkt und gibt
+// es dem/der neuen Nutzer:in auf einem anderen Weg weiter.
+func (s *Server) handleNutzerCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	email := r.FormValue("email")
+	password := r.FormValue("password")
+	role := r.FormValue("role")
+	if email == "" || password == "" || !istMandantenRolle(role) {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: "E-Mail, Passwort und eine gültige Rolle sind Pflicht"}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	passwordHash, err := auth.HashPassword(password)
+	if err != nil {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: err.Error()}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	if _, err := s.store.CreateUser(r.Context(), currentUser(r).AccountID, email, passwordHash, role); err != nil {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: "Nutzer konnte nicht angelegt werden — E-Mail evtl. schon vergeben"}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	http.Redirect(w, r, "/verwaltung/nutzer", http.StatusSeeOther)
+}
+
+type abteilungListItem struct {
+	ID   string
+	Name string
+}
+
+type abteilungListeData struct {
+	Title       string
+	Nav         navData
+	Abteilungen []abteilungListItem
+	Error       string
+}
+
+// handleAbteilungListe zeigt alle Abteilungen des eigenen Mandanten
+// mit einem Formular zum Anlegen weiterer — bewusst eine Seite statt
+// Liste+Formular getrennt, da Abteilungen reine Stammdaten ohne
+// weitere Felder sind (nur `name`).
+func (s *Server) handleAbteilungListe(w http.ResponseWriter, r *http.Request) {
+	abteilungen, err := s.store.ListAbteilungenForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Abteilungen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := abteilungListeData{Title: "Abteilungen", Nav: navFor(r)}
+	for _, a := range abteilungen {
+		data.Abteilungen = append(data.Abteilungen, abteilungListItem{ID: a.ID, Name: a.Name})
+	}
+	if err := s.templates.ExecuteTemplate(w, "abteilung-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) handleAbteilungCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	name := r.FormValue("name")
+	if name == "" {
+		http.Error(w, "Name ist Pflicht", http.StatusBadRequest)
+		return
+	}
+	if _, err := s.store.CreateAbteilung(r.Context(), currentUser(r).AccountID, name); err != nil {
+		http.Error(w, "Abteilung konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/abteilungen", http.StatusSeeOther)
+}
+
+// handleAbteilungDelete entfernt eine Abteilung des eigenen Mandanten.
+// Fremde Abteilungen (anderer Mandant) sind über die ID nicht löschbar
+// — GetAbteilung prüft AccountID gegen den angemeldeten Mandanten,
+// bevor gelöscht wird.
+func (s *Server) handleAbteilungDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	abt, err := s.store.GetAbteilung(r.Context(), id)
+	if err != nil || abt.AccountID != currentUser(r).AccountID {
+		http.Error(w, "Abteilung nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteAbteilung(r.Context(), id); err != nil {
+		http.Error(w, "Abteilung konnte nicht gelöscht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/abteilungen", http.StatusSeeOther)
+}

internal/web/admin_handlers_test.go

@@ -0,0 +1,75 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestMitarbeiterCannotAccessNutzerverwaltung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/nutzer")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter on /verwaltung/nutzer", resp.Code)
+	}
+}
+
+func TestAdminCanCreateUserWithMandantenRolle(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"neu@example.com"}, "password": {"ein-langes-passwort"}, "role": {"verantwortlicher"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+
+	u, err := fs.GetUserByEmail(context.Background(), "neu@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	if u.Role != "verantwortlicher" {
+		t.Errorf("Role = %q, want verantwortlicher", u.Role)
+	}
+
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/nutzer")
+	if !strings.Contains(list.Body.String(), "neu@example.com") {
+		t.Errorf("expected the new user in the Nutzerliste, got: %s", list.Body.String())
+	}
+}
+
+func TestAdminCannotCreateBetreiberUser(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"versuch@example.com"}, "password": {"ein-langes-passwort"}, "role": {"betreiber"},
+	})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) for role betreiber", resp.Code)
+	}
+	if _, err := fs.GetUserByEmail(context.Background(), "versuch@example.com"); err == nil {
+		t.Error("expected no user to be created for an invalid role")
+	}
+}
+
+func TestAdminCreateUserRejectsDuplicateEmail(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"admin@example.com"}, "password": {"ein-langes-passwort"}, "role": {"mitarbeiter"},
+	})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) for duplicate email", resp.Code)
+	}
+}

internal/web/auth_handlers.go

@@ -31,8 +31,9 @@ func (s *Server) handleLoginForm(w http.ResponseWriter, r *http.Request) {
 // Nutzer als admin an. Testzugang ist sofort aktiv, der Bezahlbetrieb
 // wird separat vom Betreiber freigeschaltet (nicht Teil dieses Flows).
 // Es gibt bewusst KEINE offene Selbstregistrierung für einzelne
-// Mitarbeiter — die kommen über Einladungslink/CSV-Import/Mandantenlink
+// Mitarbeiter über dieses Formular — die kommen über den
-// (spätere Ausbaustufe), nicht über dieses Formular.
+// Einladungslink (siehe einladung_handlers.go) oder künftig CSV-
+// Import/Mandantenlink (weiterhin nicht gebaut).
 func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 	if err := r.ParseForm(); err != nil {
 		s.renderAuthPage(w, "register", authPageData{Title: "Registrieren", Error: "ungültiges Formular"})
@@ -93,6 +94,13 @@ func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
 		s.renderAuthPage(w, "login", authPageData{Title: "Anmelden", Error: "E-Mail oder Passwort falsch"})
 		return
 	}
+	// Erst NACH erfolgreicher Passwortprüfung unterscheiden — sonst würde
+	// diese Meldung einem Angreifer ohne gültiges Passwort verraten, dass
+	// die E-Mail-Adresse zu einem (deaktivierten) Konto gehört.
+	if !user.Active {
+		s.renderAuthPage(w, "login", authPageData{Title: "Anmelden", Error: "Dieses Konto ist deaktiviert"})
+		return
+	}
 
 	if err := s.startSession(w, r, user.ID); err != nil {
 		s.renderAuthPage(w, "login", authPageData{Title: "Anmelden", Error: "Sitzung konnte nicht gestartet werden"})

internal/web/betreiber_handlers.go

@@ -8,6 +8,7 @@ type betreiberDashboardData struct {
 	Title            string
 	Nav              navData
 	AccountCount     int
+	WerkzeugCount    int
 	RecentAuditCount int
 }
 
@@ -21,6 +22,11 @@ func (s *Server) handleBetreiberDashboard(w http.ResponseWriter, r *http.Request
 		http.Error(w, "Accounts konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+	werkzeuge, err := s.store.ListZentraleWerkzeuge(ctx)
+	if err != nil {
+		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 	auditLog, err := s.store.ListAuditLog(ctx, 5)
 	if err != nil {
 		http.Error(w, "Audit-Log konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
@@ -28,7 +34,8 @@ func (s *Server) handleBetreiberDashboard(w http.ResponseWriter, r *http.Request
 	}
 
 	data := betreiberDashboardData{
-		Title: "Plattform", Nav: navFor(r), AccountCount: len(accounts), RecentAuditCount: len(auditLog),
+		Title: "Plattform", Nav: navFor(r), AccountCount: len(accounts),
+		WerkzeugCount: len(werkzeuge), RecentAuditCount: len(auditLog),
 	}
 	if err := s.templates.ExecuteTemplate(w, "betreiber-dashboard", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)

internal/web/betreiber_werkzeug_handlers.go

@@ -0,0 +1,255 @@
+// Ebene 5 (Plattform) — Pflege des zentralen Werkzeugkatalogs
+// (`werkzeug.account_id IS NULL`). Mandantenspezifische Ergänzungen
+// (`account_id` gesetzt) sind NICHT Teil dieser Seiten — die bleiben
+// Sache des jeweiligen Mandanten (Ebene 4, "eigene Werkzeug-
+// Freigaben/-Sperrungen", noch nicht gebaut), siehe CLAUDE.md.
+package web
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+var gueltigeVerarbeitungsorte = []string{"EU", "USA", "gemischt", "on-prem"}
+
+func istGueltigerVerarbeitungsort(v string) bool {
+	for _, o := range gueltigeVerarbeitungsorte {
+		if o == v {
+			return true
+		}
+	}
+	return false
+}
+
+// splitListe zerlegt ein kommasepariertes Formularfeld (Zertifizierungen,
+// geeignete Zwecke, Einschränkungen) in eine bereinigte Liste — ohne
+// führende/folgende Leerzeichen und ohne leere Einträge.
+func splitListe(s string) []string {
+	var out []string
+	for _, part := range strings.Split(s, ",") {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+type werkzeugListItem struct {
+	ID               string
+	Name             string
+	Anbieter         string
+	Verarbeitungsort string
+	LetztePruefung   string
+}
+
+type werkzeugListeData struct {
+	Title     string
+	Nav       navData
+	Werkzeuge []werkzeugListItem
+}
+
+// handleBetreiberWerkzeugListe zeigt den zentralen Katalog.
+func (s *Server) handleBetreiberWerkzeugListe(w http.ResponseWriter, r *http.Request) {
+	werkzeuge, err := s.store.ListZentraleWerkzeuge(r.Context())
+	if err != nil {
+		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := werkzeugListeData{Title: "Werkzeugkatalog", Nav: navFor(r)}
+	for _, wz := range werkzeuge {
+		data.Werkzeuge = append(data.Werkzeuge, werkzeugListItem{
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+			LetztePruefung: wz.LetztePruefung.Format("02.01.2006"),
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeuge", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// werkzeugFormData bedient sowohl das Betreiber-Formular (zentraler
+// Katalog, ActionBase "/betreiber/werkzeuge") als auch das Mandanten-
+// Formular für eigene Katalogeinträge (ActionBase "/verwaltung/werkzeuge")
+// — dieselbe Template-Datei, siehe betreiber_werkzeug_form.html.
+type werkzeugFormData struct {
+	Title             string
+	Nav               navData
+	ActionBase        string
+	ID                string // leer bei "neu"
+	Name              string
+	Anbieter          string
+	Verarbeitungsorte []string
+	Verarbeitungsort  string
+	AVVVerfuegbar     bool
+	AVVURL            string
+	TrainingOptOut    bool
+	TrainingStandard  bool
+	AufbewahrungTage  int
+	Zertifizierungen  string
+	GeeigneteZwecke   string
+	Einschraenkungen  string
+	LetztePruefung    string
+	Quelle            string
+	Error             string
+}
+
+func (s *Server) handleBetreiberWerkzeugNeuForm(w http.ResponseWriter, r *http.Request) {
+	data := werkzeugFormData{Title: "Werkzeug anlegen", Nav: navFor(r), ActionBase: "/betreiber/werkzeuge", Verarbeitungsorte: gueltigeVerarbeitungsorte}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// werkzeugInputFromForm liest ein WerkzeugInput aus dem Formular.
+// accountID ist nil für den zentralen Katalog (Betreiber) oder gesetzt
+// für einen mandantenspezifischen Eintrag (Ebene 4).
+func werkzeugInputFromForm(r *http.Request, accountID *string) (store.WerkzeugInput, string) {
+	letztePruefung, err := time.Parse("2006-01-02", r.FormValue("letzte_pruefung"))
+	if err != nil {
+		return store.WerkzeugInput{}, "Datum der letzten Prüfung ist ungültig oder fehlt"
+	}
+	verarbeitungsort := r.FormValue("verarbeitungsort")
+	if !istGueltigerVerarbeitungsort(verarbeitungsort) {
+		return store.WerkzeugInput{}, "ungültiger Verarbeitungsort"
+	}
+	name := r.FormValue("name")
+	anbieter := r.FormValue("anbieter")
+	quelle := r.FormValue("quelle")
+	if name == "" || anbieter == "" || quelle == "" {
+		return store.WerkzeugInput{}, "Name, Anbieter und Quelle sind Pflicht"
+	}
+	aufbewahrungTage, _ := strconv.Atoi(r.FormValue("aufbewahrung_tage"))
+
+	return store.WerkzeugInput{
+		AccountID:        accountID,
+		Name:             name,
+		Anbieter:         anbieter,
+		Verarbeitungsort: verarbeitungsort,
+		AVVVerfuegbar:    r.FormValue("avv_verfuegbar") == "on",
+		AVVURL:           r.FormValue("avv_url"),
+		TrainingOptOut:   r.FormValue("training_opt_out") == "on",
+		TrainingStandard: r.FormValue("training_standard") == "on",
+		AufbewahrungTage: aufbewahrungTage,
+		Zertifizierungen: splitListe(r.FormValue("zertifizierungen")),
+		GeeigneteZwecke:  splitListe(r.FormValue("geeignete_zwecke")),
+		Einschraenkungen: splitListe(r.FormValue("einschraenkungen")),
+		LetztePruefung:   letztePruefung,
+		Quelle:           quelle,
+	}, ""
+}
+
+// formDataFromForm baut die Formular-Daten für eine erneute Anzeige bei
+// einem Validierungsfehler — die Eingaben des Nutzers bleiben erhalten,
+// statt das Formular zu leeren.
+func werkzeugFormDataFromRequest(r *http.Request, title, actionBase, id, errMsg string) werkzeugFormData {
+	return werkzeugFormData{
+		Title: title, Nav: navFor(r), ActionBase: actionBase, ID: id, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Name: r.FormValue("name"), Anbieter: r.FormValue("anbieter"), Verarbeitungsort: r.FormValue("verarbeitungsort"),
+		AVVVerfuegbar: r.FormValue("avv_verfuegbar") == "on", AVVURL: r.FormValue("avv_url"),
+		TrainingOptOut: r.FormValue("training_opt_out") == "on", TrainingStandard: r.FormValue("training_standard") == "on",
+		Zertifizierungen: r.FormValue("zertifizierungen"), GeeigneteZwecke: r.FormValue("geeignete_zwecke"),
+		Einschraenkungen: r.FormValue("einschraenkungen"), LetztePruefung: r.FormValue("letzte_pruefung"),
+		Quelle: r.FormValue("quelle"), Error: errMsg,
+	}
+}
+
+// handleBetreiberWerkzeugCreate legt einen zentralen Katalogeintrag an.
+func (s *Server) handleBetreiberWerkzeugCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	in, errMsg := werkzeugInputFromForm(r, nil)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug anlegen", "/betreiber/werkzeuge", "", errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.CreateWerkzeug(r.Context(), in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug anlegen", "/betreiber/werkzeuge", "", "Werkzeug konnte nicht angelegt werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}
+
+// handleBetreiberWerkzeugEditForm zeigt einen zentralen Katalogeintrag
+// zum Bearbeiten. Ein mandantenspezifischer Eintrag (account_id
+// gesetzt) ist hier bewusst nicht erreichbar — das ist Sache des
+// jeweiligen Mandanten, nicht der Plattform.
+func (s *Server) handleBetreiberWerkzeugEditForm(w http.ResponseWriter, r *http.Request) {
+	wz, err := s.store.GetWerkzeug(r.Context(), r.PathValue("id"))
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	data := werkzeugFormData{
+		Title: "Werkzeug bearbeiten", Nav: navFor(r), ActionBase: "/betreiber/werkzeuge", ID: wz.ID, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+		AVVVerfuegbar: wz.AVVVerfuegbar, AVVURL: wz.AVVURL,
+		TrainingOptOut: wz.TrainingOptOut, TrainingStandard: wz.TrainingStandard, AufbewahrungTage: wz.AufbewahrungTage,
+		Zertifizierungen: strings.Join(wz.Zertifizierungen, ", "), GeeigneteZwecke: strings.Join(wz.GeeigneteZwecke, ", "),
+		Einschraenkungen: strings.Join(wz.Einschraenkungen, ", "), LetztePruefung: wz.LetztePruefung.Format("2006-01-02"),
+		Quelle: wz.Quelle,
+	}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleBetreiberWerkzeugUpdate speichert Änderungen an einem zentralen
+// Katalogeintrag. Werkzeug ist nicht append-only (siehe store.UpdateWerkzeug)
+// — eine bereits getroffene Entscheidung hält ihren eigenen, zum
+// Entscheidungszeitpunkt eingefrorenen Snapshot (entscheidung.werkzeug_snapshot).
+func (s *Server) handleBetreiberWerkzeugUpdate(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	in, errMsg := werkzeugInputFromForm(r, nil)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug bearbeiten", "/betreiber/werkzeuge", id, errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.UpdateWerkzeug(r.Context(), id, in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug bearbeiten", "/betreiber/werkzeuge", id, "Werkzeug konnte nicht gespeichert werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}
+
+// handleBetreiberWerkzeugDelete entfernt einen zentralen Katalogeintrag.
+func (s *Server) handleBetreiberWerkzeugDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteWerkzeug(r.Context(), id); err != nil {
+		http.Error(w, "Werkzeug konnte nicht gelöscht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}

internal/web/betreiber_werkzeug_handlers_test.go

@@ -0,0 +1,118 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func werkzeugForm() url.Values {
+	return url.Values{
+		"name": {"ChatGPT Enterprise"}, "anbieter": {"OpenAI"}, "verarbeitungsort": {"EU"},
+		"avv_verfuegbar": {"on"}, "avv_url": {"https://example.com/avv"},
+		"training_opt_out": {"on"}, "training_standard": {"on"}, "aufbewahrung_tage": {"30"},
+		"zertifizierungen": {"ISO 27001, SOC 2"}, "geeignete_zwecke": {"Textgenerierung"},
+		"einschraenkungen": {""}, "letzte_pruefung": {"2026-08-01"}, "quelle": {"https://example.com/beleg"},
+	}
+}
+
+func TestBetreiberCanCreateZentralesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	resp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", werkzeugForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+
+	var w store.Werkzeug
+	for _, wz := range fs.werkzeuge {
+		w = wz
+	}
+	if w.Name != "ChatGPT Enterprise" || w.AccountID != nil {
+		t.Fatalf("Werkzeug = %+v, unerwartete Werte", w)
+	}
+	if len(w.Zertifizierungen) != 2 {
+		t.Errorf("Zertifizierungen = %v, want 2 Einträge", w.Zertifizierungen)
+	}
+
+	list := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge")
+	if !strings.Contains(list.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the new werkzeug in the Katalogliste, got: %s", list.Body.String())
+	}
+}
+
+func TestBetreiberWerkzeugCreateRequiresLetztePruefungUndQuelle(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	form := werkzeugForm()
+	form.Set("letzte_pruefung", "")
+	resp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", form)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) ohne letzte_pruefung", resp.Code)
+	}
+	if len(fs.werkzeuge) != 0 {
+		t.Errorf("expected no werkzeug to be created, got %d", len(fs.werkzeuge))
+	}
+}
+
+func TestBetreiberCanUpdateAndDeleteZentralesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+	postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", werkzeugForm())
+	var id string
+	for wid := range fs.werkzeuge {
+		id = wid
+	}
+
+	editResp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id)
+	if editResp.Code != http.StatusOK || !strings.Contains(editResp.Body.String(), "ChatGPT Enterprise") {
+		t.Fatalf("edit form status = %d, body: %s", editResp.Code, editResp.Body.String())
+	}
+
+	updateForm := werkzeugForm()
+	updateForm.Set("name", "ChatGPT Enterprise (aktualisiert)")
+	updateResp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id, updateForm)
+	if updateResp.Code != http.StatusSeeOther {
+		t.Fatalf("update status = %d, body: %s", updateResp.Code, updateResp.Body.String())
+	}
+	if fs.werkzeuge[id].Name != "ChatGPT Enterprise (aktualisiert)" {
+		t.Errorf("Name = %q nach Update, unerwartet", fs.werkzeuge[id].Name)
+	}
+
+	deleteResp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id+"/loeschen", url.Values{})
+	if deleteResp.Code != http.StatusSeeOther {
+		t.Fatalf("delete status = %d, body: %s", deleteResp.Code, deleteResp.Body.String())
+	}
+	if _, ok := fs.werkzeuge[id]; ok {
+		t.Error("expected the werkzeug to be deleted")
+	}
+}
+
+// TestBetreiberCannotEditMandantenEigenesWerkzeug: ein mandantenspezifischer
+// Katalogeintrag (account_id gesetzt) ist über die Betreiber-Seiten
+// nicht erreichbar — das bleibt Sache des jeweiligen Mandanten.
+func TestBetreiberCannotEditMandantenEigenesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+	acc, err := fs.CreateAccount(context.Background(), "Mandant mit eigenem Werkzeug")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	eigenesID := "eigenes-werkzeug"
+	fs.werkzeuge[eigenesID] = store.Werkzeug{ID: eigenesID, AccountID: &acc.ID, Name: "Mandanten-eigenes Tool"}
+
+	resp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge/"+eigenesID)
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a mandanten-eigenes werkzeug", resp.Code)
+	}
+}

internal/web/csv_import_handlers.go

@@ -0,0 +1,184 @@
+// Ebene 4 — CSV-Import für Mitarbeiter (zweiter Punkt der geplanten
+// Onboarding-Reihenfolge, siehe CLAUDE.md, Onboarding). Es gibt keine
+// E-Mail-Infrastruktur (siehe Einladungslink, Nutzerverwaltung) — wie
+// beim einzelnen "Nutzer anlegen" generiert der Import ein
+// Einmalpasswort pro Zeile, das der Admin nach dem Import EINMALIG
+// sieht und selbst weitergeben muss. Kein Rollback bei Teilfehlern:
+// gültige Zeilen werden angelegt, fehlerhafte werden einzeln gemeldet
+// (keine Alles-oder-nichts-Transaktion — eine falsche Zeile in einer
+// Liste von 50 Mitarbeitenden soll nicht die anderen 49 blockieren).
+package web
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/netcell-it/deklarix/internal/auth"
+)
+
+type csvMitarbeiterZeile struct {
+	Zeile int // 1-basiert, Kopfzeile ist Zeile 1 — für Fehlermeldungen
+	Email string
+	Role  string
+}
+
+// parseCSVMitarbeiter liest eine Mitarbeiter-CSV mit einer Kopfzeile.
+// Pflichtspalte "email" (oder "e-mail"), optionale Spalte "role" (oder
+// "rolle") — fehlt sie oder ist der Wert leer/ungültig, wird das erst
+// beim Anlegen selbst gemeldet, nicht schon beim Parsen (damit eine
+// einzelne falsche Rolle nicht den ganzen Import verhindert).
+func parseCSVMitarbeiter(r io.Reader) ([]csvMitarbeiterZeile, error) {
+	cr := csv.NewReader(r)
+	cr.TrimLeadingSpace = true
+	cr.FieldsPerRecord = -1
+
+	header, err := cr.Read()
+	if err != nil {
+		return nil, fmt.Errorf("Kopfzeile konnte nicht gelesen werden: %w", err)
+	}
+	emailCol, roleCol := -1, -1
+	for i, h := range header {
+		switch strings.ToLower(strings.TrimSpace(h)) {
+		case "email", "e-mail":
+			emailCol = i
+		case "role", "rolle":
+			roleCol = i
+		}
+	}
+	if emailCol == -1 {
+		return nil, fmt.Errorf(`Kopfzeile muss eine Spalte "email" enthalten`)
+	}
+
+	var out []csvMitarbeiterZeile
+	zeile := 1
+	for {
+		record, err := cr.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Zeile %d: %w", zeile+1, err)
+		}
+		zeile++
+		if emailCol >= len(record) {
+			continue
+		}
+		email := strings.TrimSpace(record[emailCol])
+		if email == "" {
+			continue
+		}
+		role := "mitarbeiter"
+		if roleCol != -1 && roleCol < len(record) {
+			if v := strings.TrimSpace(record[roleCol]); v != "" {
+				role = v
+			}
+		}
+		out = append(out, csvMitarbeiterZeile{Zeile: zeile, Email: email, Role: role})
+	}
+	return out, nil
+}
+
+// generateEinmalPasswort erzeugt ein zufälliges Initialpasswort für
+// eine importierte Zeile — wiederverwendet auth.NewSessionToken() statt
+// einen eigenen Zufallsgenerator zu schreiben, nur gekürzt auf eine
+// Länge, die sich noch manuell weitergeben lässt.
+func generateEinmalPasswort() (string, error) {
+	token, err := auth.NewSessionToken()
+	if err != nil {
+		return "", err
+	}
+	return token[:16], nil
+}
+
+type csvImportFormData struct {
+	Title string
+	Nav   navData
+	Error string
+}
+
+func (s *Server) handleNutzerCSVImportForm(w http.ResponseWriter, r *http.Request) {
+	data := csvImportFormData{Title: "Mitarbeiter per CSV importieren", Nav: navFor(r)}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-import", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) renderCSVImportForm(w http.ResponseWriter, r *http.Request, errMsg string) {
+	data := csvImportFormData{Title: "Mitarbeiter per CSV importieren", Nav: navFor(r), Error: errMsg}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-import", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+type csvImportErgebnisZeile struct {
+	Zeile    int
+	Email    string
+	Role     string
+	Passwort string // nur bei Erfolg gesetzt
+	Fehler   string // nur bei Fehler gesetzt
+}
+
+type csvImportErgebnisData struct {
+	Title      string
+	Nav        navData
+	Ergebnisse []csvImportErgebnisZeile
+}
+
+// handleNutzerCSVImportUpload liest die hochgeladene CSV-Datei und legt
+// pro gültiger Zeile einen Login im eigenen Mandanten an. Das Ergebnis
+// (inkl. Einmalpasswort) wird nur EINMAL auf dieser Antwortseite
+// gezeigt — danach ist nur noch der Hash in der Datenbank vorhanden.
+func (s *Server) handleNutzerCSVImportUpload(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseMultipartForm(1 << 20); err != nil { // 1 MB reicht für eine Mitarbeiterliste
+		s.renderCSVImportForm(w, r, "Datei konnte nicht gelesen werden: "+err.Error())
+		return
+	}
+	file, _, err := r.FormFile("csv")
+	if err != nil {
+		s.renderCSVImportForm(w, r, "Bitte eine CSV-Datei auswählen")
+		return
+	}
+	defer file.Close()
+
+	zeilen, err := parseCSVMitarbeiter(file)
+	if err != nil {
+		s.renderCSVImportForm(w, r, err.Error())
+		return
+	}
+	if len(zeilen) == 0 {
+		s.renderCSVImportForm(w, r, "Die Datei enthält keine gültigen Zeilen")
+		return
+	}
+
+	accountID := currentUser(r).AccountID
+	var ergebnisse []csvImportErgebnisZeile
+	for _, z := range zeilen {
+		if !istMandantenRolle(z.Role) {
+			ergebnisse = append(ergebnisse, csvImportErgebnisZeile{Zeile: z.Zeile, Email: z.Email, Fehler: fmt.Sprintf("ungültige Rolle %q", z.Role)})
+			continue
+		}
+		passwort, err := generateEinmalPasswort()
+		if err != nil {
+			ergebnisse = append(ergebnisse, csvImportErgebnisZeile{Zeile: z.Zeile, Email: z.Email, Fehler: "Passwort konnte nicht erzeugt werden"})
+			continue
+		}
+		hash, err := auth.HashPassword(passwort)
+		if err != nil {
+			ergebnisse = append(ergebnisse, csvImportErgebnisZeile{Zeile: z.Zeile, Email: z.Email, Fehler: err.Error()})
+			continue
+		}
+		if _, err := s.store.CreateUser(r.Context(), accountID, z.Email, hash, z.Role); err != nil {
+			ergebnisse = append(ergebnisse, csvImportErgebnisZeile{Zeile: z.Zeile, Email: z.Email, Fehler: "E-Mail evtl. schon vergeben"})
+			continue
+		}
+		ergebnisse = append(ergebnisse, csvImportErgebnisZeile{Zeile: z.Zeile, Email: z.Email, Role: z.Role, Passwort: passwort})
+	}
+
+	data := csvImportErgebnisData{Title: "Import-Ergebnis", Nav: navFor(r), Ergebnisse: ergebnisse}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-import-ergebnis", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}

internal/web/csv_import_handlers_test.go

@@ -0,0 +1,149 @@
+package web_test
+
+import (
+	"bytes"
+	"context"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/web"
+)
+
+// postCSV lädt csvContent als multipart-Formular mit Feldname "csv" hoch
+// — reale Browser-Uploads laufen genauso über multipart/form-data.
+func postCSV(t *testing.T, s *web.Server, cookie *http.Cookie, path, csvContent string) *httptest.ResponseRecorder {
+	t.Helper()
+	var body bytes.Buffer
+	mw := multipart.NewWriter(&body)
+	fw, err := mw.CreateFormFile("csv", "mitarbeiter.csv")
+	if err != nil {
+		t.Fatalf("CreateFormFile: %v", err)
+	}
+	if _, err := fw.Write([]byte(csvContent)); err != nil {
+		t.Fatalf("Write: %v", err)
+	}
+	if err := mw.Close(); err != nil {
+		t.Fatalf("mw.Close: %v", err)
+	}
+
+	req := httptest.NewRequest(http.MethodPost, path, &body)
+	req.Header.Set("Content-Type", mw.FormDataContentType())
+	if cookie != nil {
+		req.AddCookie(cookie)
+	}
+	w := httptest.NewRecorder()
+	s.ServeHTTP(w, req)
+	return w
+}
+
+func TestAdminCanImportMitarbeiterPerCSV(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postCSV(t, s, adminCookie, "/verwaltung/nutzer/import", "email,role\nlisa@example.com,verantwortlicher\ntom@example.com,\n")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	body := resp.Body.String()
+	if !strings.Contains(body, "lisa@example.com") || !strings.Contains(body, "tom@example.com") {
+		t.Fatalf("expected both imported emails in the result, got: %s", body)
+	}
+
+	lisa, err := fs.GetUserByEmail(context.Background(), "lisa@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail (lisa): %v", err)
+	}
+	if lisa.Role != "verantwortlicher" {
+		t.Errorf("lisa.Role = %q, want verantwortlicher", lisa.Role)
+	}
+	tom, err := fs.GetUserByEmail(context.Background(), "tom@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail (tom): %v", err)
+	}
+	if tom.Role != "mitarbeiter" {
+		t.Errorf("tom.Role = %q, want default mitarbeiter", tom.Role)
+	}
+}
+
+func TestCSVImportZeigtEinmalpasswortDasFunktioniert(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postCSV(t, s, adminCookie, "/verwaltung/nutzer/import", "email\nneu@example.com\n")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	// Das angezeigte Einmalpasswort aus der <code>-Zelle extrahieren.
+	body := resp.Body.String()
+	start := strings.Index(body, "<code>")
+	end := strings.Index(body, "</code>")
+	if start == -1 || end == -1 {
+		t.Fatalf("expected a <code>-Zelle mit dem Einmalpasswort, got: %s", body)
+	}
+	passwort := body[start+len("<code>") : end]
+
+	loginResp := postForm(t, s, nil, "/login", map[string][]string{
+		"email": {"neu@example.com"}, "password": {passwort},
+	})
+	if loginResp.Code != http.StatusSeeOther {
+		t.Fatalf("login with the generated password: status = %d, body: %s", loginResp.Code, loginResp.Body.String())
+	}
+}
+
+func TestCSVImportMeldetUngueltigeRolleOhneDieAnderenZuBlockieren(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postCSV(t, s, adminCookie, "/verwaltung/nutzer/import", "email,role\nboese@example.com,betreiber\ngut@example.com,mitarbeiter\n")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if _, err := fs.GetUserByEmail(context.Background(), "boese@example.com"); err == nil {
+		t.Error("expected no user to be created for an invalid role (betreiber)")
+	}
+	if _, err := fs.GetUserByEmail(context.Background(), "gut@example.com"); err != nil {
+		t.Error("expected the valid row to still be imported despite the earlier invalid row")
+	}
+}
+
+func TestCSVImportOhneDateiZeigtFehler(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	var body bytes.Buffer
+	mw := multipart.NewWriter(&body)
+	if err := mw.Close(); err != nil {
+		t.Fatalf("mw.Close: %v", err)
+	}
+	req := httptest.NewRequest(http.MethodPost, "/verwaltung/nutzer/import", &body)
+	req.Header.Set("Content-Type", mw.FormDataContentType())
+	req.AddCookie(adminCookie)
+	w := httptest.NewRecorder()
+	s.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", w.Code, w.Body.String())
+	}
+	if !strings.Contains(w.Body.String(), "CSV-Datei auswählen") {
+		t.Errorf("expected an error asking for a file, got: %s", w.Body.String())
+	}
+}
+
+func TestMitarbeiterCannotAccessCSVImport(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/nutzer/import")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter", resp.Code)
+	}
+}

internal/web/csv_import_parse_test.go

@@ -0,0 +1,64 @@
+package web
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestParseCSVMitarbeiterMitRolle(t *testing.T) {
+	csv := "email,role\nlisa@example.com,verantwortlicher\ntom@example.com,\n"
+	zeilen, err := parseCSVMitarbeiter(strings.NewReader(csv))
+	if err != nil {
+		t.Fatalf("parseCSVMitarbeiter: %v", err)
+	}
+	if len(zeilen) != 2 {
+		t.Fatalf("zeilen = %+v, want 2", zeilen)
+	}
+	if zeilen[0].Email != "lisa@example.com" || zeilen[0].Role != "verantwortlicher" {
+		t.Errorf("zeilen[0] = %+v, unerwartet", zeilen[0])
+	}
+	if zeilen[1].Email != "tom@example.com" || zeilen[1].Role != "mitarbeiter" {
+		t.Errorf("zeilen[1] = %+v, want default role mitarbeiter", zeilen[1])
+	}
+}
+
+func TestParseCSVMitarbeiterOhneRollenspalte(t *testing.T) {
+	csv := "email\nlisa@example.com\n"
+	zeilen, err := parseCSVMitarbeiter(strings.NewReader(csv))
+	if err != nil {
+		t.Fatalf("parseCSVMitarbeiter: %v", err)
+	}
+	if len(zeilen) != 1 || zeilen[0].Role != "mitarbeiter" {
+		t.Fatalf("zeilen = %+v, unerwartet", zeilen)
+	}
+}
+
+func TestParseCSVMitarbeiterUeberspringtLeereEmail(t *testing.T) {
+	csv := "email,role\n,mitarbeiter\nlisa@example.com,mitarbeiter\n"
+	zeilen, err := parseCSVMitarbeiter(strings.NewReader(csv))
+	if err != nil {
+		t.Fatalf("parseCSVMitarbeiter: %v", err)
+	}
+	if len(zeilen) != 1 || zeilen[0].Email != "lisa@example.com" {
+		t.Fatalf("zeilen = %+v, want exactly lisa@example.com", zeilen)
+	}
+}
+
+func TestParseCSVMitarbeiterOhneEmailSpalteSchlaegtFehl(t *testing.T) {
+	csv := "name,role\nLisa,mitarbeiter\n"
+	_, err := parseCSVMitarbeiter(strings.NewReader(csv))
+	if err == nil {
+		t.Fatal("expected an error when the header has no email column")
+	}
+}
+
+func TestParseCSVMitarbeiterZeilennummernZaehlenKopfzeileAlsEins(t *testing.T) {
+	csv := "email\nlisa@example.com\ntom@example.com\n"
+	zeilen, err := parseCSVMitarbeiter(strings.NewReader(csv))
+	if err != nil {
+		t.Fatalf("parseCSVMitarbeiter: %v", err)
+	}
+	if len(zeilen) != 2 || zeilen[0].Zeile != 2 || zeilen[1].Zeile != 3 {
+		t.Fatalf("zeilen = %+v, want Zeile 2 and 3", zeilen)
+	}
+}

internal/web/einladung_handlers.go

@@ -0,0 +1,140 @@
+// Ebene 1 (öffentlich) — Mitarbeiter-Selbstanmeldung über den
+// Sammellink eines Mandanten ("Einladung annehmen", siehe CLAUDE.md,
+// Onboarding: "Einladungslink [Sammellink, Selbstanmeldung, Abteilung
+// beim ersten Antrag]"). Ein Link gilt für beliebig viele Mitarbeiter
+// desselben Mandanten, kein Einmal-Token pro Person — die Abteilung
+// wählt der/die Mitarbeiter:in erst beim ersten Antrag (Fragebogen
+// Abschnitt A), nicht hier.
+package web
+
+import (
+	"net/http"
+
+	"github.com/netcell-it/deklarix/internal/auth"
+)
+
+type einladungFormData struct {
+	Title      string
+	Firmenname string
+	Error      string
+}
+
+// handleEinladungForm zeigt das Selbstanmelde-Formular für einen
+// gültigen Einladungslink. Ein unbekanntes oder erneuertes (damit
+// ungültig gewordenes) Token bekommt dieselbe Fehlermeldung wie ein
+// abgelaufener Link — es wird nicht unterschieden, ob das Token nie
+// existiert hat oder nur nicht mehr gültig ist.
+func (s *Server) handleEinladungForm(w http.ResponseWriter, r *http.Request) {
+	acc, err := s.store.GetAccountByEinladungToken(r.Context(), r.PathValue("token"))
+	if err != nil {
+		s.renderEinladungError(w)
+		return
+	}
+	s.renderEinladungForm(w, acc.Name, "")
+}
+
+func (s *Server) renderEinladungForm(w http.ResponseWriter, firmenname, errMsg string) {
+	data := einladungFormData{Title: "Einladung annehmen", Firmenname: firmenname, Error: errMsg}
+	if err := s.templates.ExecuteTemplate(w, "einladung", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) renderEinladungError(w http.ResponseWriter) {
+	if err := s.templates.ExecuteTemplate(w, "einladung-ungueltig", authPageData{Title: "Einladung"}); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleEinladungAnnehmen legt einen neuen Login mit Rolle
+// "mitarbeiter" im Mandanten des Einladungslinks an und meldet die
+// Person direkt an — wie bei der Firma-Registrierung gibt es keine
+// E-Mail-Bestätigung (noch nicht gebaut, siehe CLAUDE.md, Onboarding).
+func (s *Server) handleEinladungAnnehmen(w http.ResponseWriter, r *http.Request) {
+	acc, err := s.store.GetAccountByEinladungToken(r.Context(), r.PathValue("token"))
+	if err != nil {
+		s.renderEinladungError(w)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		s.renderEinladungForm(w, acc.Name, "ungültiges Formular")
+		return
+	}
+
+	email := r.FormValue("email")
+	password := r.FormValue("password")
+	if email == "" || password == "" {
+		s.renderEinladungForm(w, acc.Name, "E-Mail und Passwort sind Pflicht")
+		return
+	}
+
+	passwordHash, err := auth.HashPassword(password)
+	if err != nil {
+		s.renderEinladungForm(w, acc.Name, err.Error())
+		return
+	}
+
+	user, err := s.store.CreateUser(r.Context(), acc.ID, email, passwordHash, "mitarbeiter")
+	if err != nil {
+		s.renderEinladungForm(w, acc.Name, "Konto konnte nicht angelegt werden — E-Mail evtl. schon vergeben")
+		return
+	}
+
+	if err := s.startSession(w, r, user.ID); err != nil {
+		s.renderEinladungForm(w, acc.Name, "Sitzung konnte nicht gestartet werden")
+		return
+	}
+	http.Redirect(w, r, "/", http.StatusSeeOther)
+}
+
+type einladungVerwaltungData struct {
+	Title string
+	Nav   navData
+	Link  string
+}
+
+// einladungBasisURL leitet Schema+Host aus dem Request ab, damit der
+// vollständige Link (nicht nur das Token) angezeigt werden kann — hinter
+// einem Reverse-Proxy (siehe CLAUDE.md, Testsystem: nginx+TLS) trägt
+// r.TLS bei HTTPS-Terminierung am Proxy nichts, deshalb zusätzlich
+// X-Forwarded-Proto berücksichtigen.
+func einladungBasisURL(r *http.Request) string {
+	scheme := "http"
+	if r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https" {
+		scheme = "https"
+	}
+	return scheme + "://" + r.Host
+}
+
+// handleEinladungVerwaltung zeigt den aktuellen Sammellink des eigenen
+// Mandanten zum Kopieren.
+func (s *Server) handleEinladungVerwaltung(w http.ResponseWriter, r *http.Request) {
+	acc, err := s.store.GetAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Account konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := einladungVerwaltungData{
+		Title: "Einladungslink", Nav: navFor(r),
+		Link: einladungBasisURL(r) + "/einladung/" + acc.EinladungToken,
+	}
+	if err := s.templates.ExecuteTemplate(w, "einladung-verwaltung", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleEinladungErneuern ersetzt den Sammellink des eigenen Mandanten
+// — der alte Link wird sofort ungültig (z. B. wenn er versehentlich
+// außerhalb des Unternehmens geteilt wurde).
+func (s *Server) handleEinladungErneuern(w http.ResponseWriter, r *http.Request) {
+	newToken, err := auth.NewSessionToken()
+	if err != nil {
+		http.Error(w, "Neuer Link konnte nicht erzeugt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if err := s.store.RegenerateEinladungToken(r.Context(), currentUser(r).AccountID, newToken); err != nil {
+		http.Error(w, "Link konnte nicht erneuert werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/einladung", http.StatusSeeOther)
+}

internal/web/einladung_handlers_test.go

@@ -0,0 +1,144 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestEinladungFormZeigtFirmenname(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	acc, err := fs.CreateAccount(context.Background(), "Beispiel GmbH")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+
+	resp := getWithCookie(t, s, nil, "/einladung/"+acc.EinladungToken)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Beispiel GmbH") {
+		t.Errorf("expected the Firmenname on the Einladung page, got: %s", resp.Body.String())
+	}
+}
+
+func TestEinladungMitUnbekanntemTokenZeigtFehler(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+
+	resp := getWithCookie(t, s, nil, "/einladung/unbekanntes-token")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "ungültig") {
+		t.Errorf("expected an invalid-link message, got: %s", resp.Body.String())
+	}
+}
+
+func TestEinladungAnnehmenLegtMitarbeiterAn(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	acc, err := fs.CreateAccount(context.Background(), "Beispiel GmbH")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+
+	resp := postForm(t, s, nil, "/einladung/"+acc.EinladungToken, url.Values{
+		"email": {"neu@example.com"}, "password": {"ein-langes-passwort"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+	if len(resp.Result().Cookies()) == 0 {
+		t.Fatal("expected a session cookie to be set")
+	}
+
+	user, err := fs.GetUserByEmail(context.Background(), "neu@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	if user.Role != "mitarbeiter" || user.AccountID != acc.ID {
+		t.Errorf("User = %+v, want role mitarbeiter in account %s", user, acc.ID)
+	}
+
+	cookie := resp.Result().Cookies()[0]
+	protected := getWithCookie(t, s, cookie, "/antraege")
+	if protected.Code != http.StatusOK {
+		t.Fatalf("expected the new session to work, status = %d", protected.Code)
+	}
+}
+
+func TestEinladungAnnehmenMitUnbekanntemTokenSchlaegtFehl(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+
+	resp := postForm(t, s, nil, "/einladung/unbekanntes-token", url.Values{
+		"email": {"neu@example.com"}, "password": {"ein-langes-passwort"},
+	})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "ungültig") {
+		t.Errorf("expected an invalid-link message, got: %s", resp.Body.String())
+	}
+	if len(fs.users) != 0 {
+		t.Error("expected no user to be created for an invalid token")
+	}
+}
+
+func TestAdminSiehtEinladungslink(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := getWithCookie(t, s, adminCookie, "/verwaltung/einladung")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "/einladung/") {
+		t.Errorf("expected the Einladungslink on the page, got: %s", resp.Body.String())
+	}
+}
+
+func TestAdminKannEinladungslinkErneuern(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	admin, err := fs.GetUserByEmail(context.Background(), "admin@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	altesToken := fs.accounts[admin.AccountID].EinladungToken
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/einladung/erneuern", url.Values{})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	neuesToken := fs.accounts[admin.AccountID].EinladungToken
+	if neuesToken == altesToken {
+		t.Fatal("expected the token to change")
+	}
+
+	oldLinkResp := getWithCookie(t, s, nil, "/einladung/"+altesToken)
+	if !strings.Contains(oldLinkResp.Body.String(), "ungültig") {
+		t.Errorf("expected the old link to be invalid, got: %s", oldLinkResp.Body.String())
+	}
+	newLinkResp := getWithCookie(t, s, nil, "/einladung/"+neuesToken)
+	if newLinkResp.Code != http.StatusOK || strings.Contains(newLinkResp.Body.String(), "ungültig") {
+		t.Errorf("expected the new link to work, status=%d body: %s", newLinkResp.Code, newLinkResp.Body.String())
+	}
+}
+
+func TestMitarbeiterCannotAccessEinladungsverwaltung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/einladung")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter", resp.Code)
+	}
+}

internal/web/fachebene_handlers.go

@@ -0,0 +1,273 @@
+// Ebene 3 (Fachebene) — Posteingang offener Anträge und Entscheiden.
+// Rollen "verantwortlicher" (Entscheidungsrecht) und "pruefer"
+// (identische Sicht, kein Entscheidungsrecht) sehen dieselben Seiten;
+// siehe requireFachebene in middleware.go und CLAUDE.md, Fünf Ebenen.
+package web
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+type fallListItem struct {
+	ID          string
+	Titel       string
+	Haeufigkeit string
+	CreatedAt   string
+}
+
+type fallListData struct {
+	Title  string
+	Nav    navData
+	Faelle []fallListItem
+}
+
+// handleFaelleListe zeigt den Posteingang: alle noch offenen (Status
+// "eingereicht") Anträge des ganzen Mandanten — im Unterschied zu
+// GET /antraege, das nur die eigenen Anträge eines Nutzers zeigt.
+func (s *Server) handleFaelleListe(w http.ResponseWriter, r *http.Request) {
+	antraege, err := s.store.ListAntraegeForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Anträge konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := fallListData{Title: "Posteingang", Nav: navFor(r)}
+	for _, a := range antraege {
+		if a.Status != "eingereicht" {
+			continue
+		}
+		data.Faelle = append(data.Faelle, fallListItem{
+			ID: a.ID, Titel: a.Titel, Haeufigkeit: a.Haeufigkeit,
+			CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "faelle-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+type entscheidungView struct {
+	Entscheidung string
+	Begruendung  string
+	WerkzeugName string
+	GueltigBis   string
+	CreatedAt    string
+}
+
+type werkzeugOption struct {
+	ID   string
+	Name string
+}
+
+type fallDetailData struct {
+	Title            string
+	Nav              navData
+	ID               string
+	Titel            string
+	Beschreibung     string
+	Ergebnis         string
+	Haeufigkeit      string
+	Status           string
+	CreatedAt        string
+	Bewertung        *bewertungView
+	Entscheidung     *entscheidungView
+	CanEntscheiden   bool
+	WerkzeugOptionen []werkzeugOption
+	Error            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.
+func hatEntscheidungsrecht(role string) bool {
+	return role == "verantwortlicher" || role == "admin"
+}
+
+// vorschlagFuer leitet aus einer Bewertung ab, welche Entscheidung das
+// System vorschlagen würde — nicht gespeichert, nur zur Bestimmung, ob
+// eine tatsächliche Entscheidung davon abweicht (dann ist die
+// Begründung Pflicht, siehe CLAUDE.md, Grundregel).
+func vorschlagFuer(b store.Bewertung) string {
+	if b.Verboten {
+		return "abgelehnt"
+	}
+	if len(b.ZulaessigeWerkzeuge) > 0 {
+		return "genehmigt"
+	}
+	return "rueckfrage"
+}
+
+// handleFallDetail zeigt einen Antrag mit Bewertung für die Fachebene
+// — anders als GET /antraege/{id} (nur der eigene Antrag) ist hier
+// jeder Antrag des Mandanten sichtbar, unabhängig vom Ersteller.
+func (s *Server) handleFallDetail(w http.ResponseWriter, r *http.Request) {
+	antrag, err := s.store.GetAntrag(r.Context(), r.PathValue("id"))
+	if err != nil || antrag.AccountID != currentUser(r).AccountID {
+		http.Error(w, "Antrag nicht gefunden", http.StatusNotFound)
+		return
+	}
+
+	data := fallDetailData{
+		Title: "Fall", Nav: navFor(r), ID: antrag.ID, Titel: antrag.Titel,
+		Beschreibung: antrag.Beschreibung, Ergebnis: antrag.Ergebnis, Haeufigkeit: antrag.Haeufigkeit,
+		Status: antrag.Status, CreatedAt: antrag.CreatedAt.Format("02.01.2006 15:04"),
+	}
+
+	bewertung, err := s.store.GetLatestBewertungForAntrag(r.Context(), antrag.ID)
+	if err == nil {
+		data.Bewertung = s.toBewertungView(r.Context(), bewertung)
+		for _, id := range bewertung.ZulaessigeWerkzeuge {
+			data.WerkzeugOptionen = append(data.WerkzeugOptionen, werkzeugOption{ID: id, Name: s.werkzeugName(r.Context(), id)})
+		}
+	}
+	data.CanEntscheiden = hatEntscheidungsrecht(currentUser(r).Role) && antrag.Status == "eingereicht" && data.Bewertung != nil
+
+	entscheidung, err := s.store.GetLatestEntscheidungForAntrag(r.Context(), antrag.ID)
+	if err == nil {
+		v := &entscheidungView{
+			Entscheidung: entscheidung.Entscheidung, Begruendung: entscheidung.Begruendung,
+			CreatedAt: entscheidung.CreatedAt.Format("02.01.2006 15:04"),
+		}
+		if entscheidung.WerkzeugSnapshot != nil {
+			v.WerkzeugName = entscheidung.WerkzeugSnapshot.Name
+		}
+		if entscheidung.GueltigBis != nil {
+			v.GueltigBis = entscheidung.GueltigBis.Format("02.01.2006")
+		}
+		data.Entscheidung = v
+	}
+
+	if err := s.templates.ExecuteTemplate(w, "fall-detail", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// gueltigkeitFuer liefert das Ablaufdatum einer Genehmigung — 12 Monate,
+// bei hochrisiko 6 (siehe CLAUDE.md, Entscheidung/Register/Wiedervorlage).
+func gueltigkeitFuer(einstufung string) time.Time {
+	if einstufung == "hochrisiko" {
+		return time.Now().AddDate(0, 6, 0)
+	}
+	return time.Now().AddDate(1, 0, 0)
+}
+
+// handleFallEntscheiden speichert die Entscheidung eines/einer
+// Verantwortlichen (oder admin, siehe hatEntscheidungsrecht). Prüfer
+// haben dieselbe Sicht, aber kein Entscheidungsrecht — anders als bei
+// requireFachebene (404, weil die Seite für sie gar nicht existieren
+// soll) ist das hier ein 403: ein Prüfer darf wissen, dass der Fall
+// existiert, nur nicht entscheiden.
+func (s *Server) handleFallEntscheiden(w http.ResponseWriter, r *http.Request) {
+	user := currentUser(r)
+	if !hatEntscheidungsrecht(user.Role) {
+		http.Error(w, "kein Entscheidungsrecht", http.StatusForbidden)
+		return
+	}
+
+	antrag, err := s.store.GetAntrag(r.Context(), r.PathValue("id"))
+	if err != nil || antrag.AccountID != user.AccountID {
+		http.Error(w, "Antrag nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if antrag.Status != "eingereicht" {
+		http.Error(w, "Antrag ist bereits entschieden", http.StatusBadRequest)
+		return
+	}
+	bewertung, err := s.store.GetLatestBewertungForAntrag(r.Context(), antrag.ID)
+	if err != nil {
+		http.Error(w, "Bewertung nicht gefunden", http.StatusNotFound)
+		return
+	}
+
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	entscheidungTyp := r.FormValue("entscheidung")
+	begruendung := r.FormValue("begruendung")
+	werkzeugID := r.FormValue("werkzeug_id")
+
+	switch entscheidungTyp {
+	case "genehmigt", "genehmigt_mit_auflagen", "abgelehnt", "rueckfrage":
+	default:
+		http.Error(w, "ungültige Entscheidung", http.StatusBadRequest)
+		return
+	}
+	if vorschlagFuer(bewertung) != entscheidungTyp && begruendung == "" {
+		http.Error(w, "Begründung erforderlich, wenn die Entscheidung vom Vorschlag abweicht", http.StatusBadRequest)
+		return
+	}
+
+	istGenehmigung := entscheidungTyp == "genehmigt" || entscheidungTyp == "genehmigt_mit_auflagen"
+	in := store.EntscheidungInput{
+		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 {
+			if id == werkzeugID {
+				zulaessig = true
+				break
+			}
+		}
+		if werkzeugID == "" || !zulaessig {
+			http.Error(w, "bei Genehmigung muss ein zulässiges Werkzeug gewählt werden", http.StatusBadRequest)
+			return
+		}
+		werkzeug, err := s.store.GetWerkzeug(r.Context(), werkzeugID)
+		if err != nil {
+			http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+			return
+		}
+		werkzeugName = werkzeug.Name
+		in.WerkzeugID = &werkzeugID
+		in.WerkzeugSnapshot = &werkzeug
+		gueltigBis := gueltigkeitFuer(bewertung.Einstufung)
+		in.GueltigBis = &gueltigBis
+	}
+
+	entscheidung, err := s.store.CreateEntscheidung(r.Context(), in)
+	if err != nil {
+		http.Error(w, "Entscheidung konnte nicht gespeichert werden: "+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
+	}
+	if _, err := s.store.CreateAuditEntry(r.Context(), user.ID, "antrag_entschieden", "antrag", antrag.ID, entscheidungTyp); err != nil {
+		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 {
+			http.Error(w, "Registereintrag konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	http.Redirect(w, r, "/faelle/"+antrag.ID, http.StatusSeeOther)
+}

internal/web/fachebene_handlers_test.go

@@ -0,0 +1,216 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+	"github.com/netcell-it/deklarix/internal/web"
+)
+
+// seedFallImAccount legt einen Mandanten mit einem Mitarbeiter an, der
+// einen Antrag einreicht (mit personenbezogener Datenklasse, Einstufung
+// minimal — siehe fullAntragForm), und liefert dessen ID sowie eine
+// zweite Cookie für einen weiteren Nutzer der Rolle role im selben
+// Mandanten (verantwortlicher/pruefer).
+func seedFallImAccount(t *testing.T, fs *fakeStore, s *web.Server, role string) (antragID string, fachebeneCookie *http.Cookie) {
+	t.Helper()
+	ctx := context.Background()
+	acc, err := fs.CreateAccount(ctx, "Fachebene-Mandant")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	mitarbeiterCookie := seedUserInAccount(t, fs, acc.ID, "mitarbeiter@example.com", "mitarbeiter")
+	resp := postForm(t, s, mitarbeiterCookie, "/antraege", fullAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("Antrag anlegen: status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	for id := range fs.antraege {
+		if fs.antraege[id].AccountID == acc.ID {
+			antragID = id
+		}
+	}
+	fachebeneCookie = seedUserInAccount(t, fs, acc.ID, role+"@example.com", role)
+	return antragID, fachebeneCookie
+}
+
+func TestMitarbeiterCannotAccessFaelle(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccount(t, fs, "Test-Mandant", "mitarbeiter@example.com")
+
+	resp := getWithCookie(t, s, cookie, "/faelle")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter on /faelle", resp.Code)
+	}
+}
+
+func TestFaelleListeShowsOpenAntraegeForAccount(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	_, verantwortlicherCookie := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	resp := getWithCookie(t, s, verantwortlicherCookie, "/faelle")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected the open antrag in the Posteingang, got: %s", resp.Body.String())
+	}
+
+	// Ein Verantwortlicher eines anderen Mandanten darf ihn nicht sehen.
+	otherAcc, err := fs.CreateAccount(context.Background(), "Anderer Mandant")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	otherCookie := seedUserInAccount(t, fs, otherAcc.ID, "other-verantwortlicher@example.com", "verantwortlicher")
+	otherResp := getWithCookie(t, s, otherCookie, "/faelle")
+	if strings.Contains(otherResp.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected no cross-tenant antrag in the Posteingang, got: %s", otherResp.Body.String())
+	}
+}
+
+func TestFallDetailShowsDecideFormOnlyForVerantwortlicher(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, verantwortlicherCookie := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	resp := getWithCookie(t, s, verantwortlicherCookie, "/faelle/"+antragID)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), `name="entscheidung"`) {
+		t.Errorf("expected the Entscheiden form for verantwortlicher, got: %s", resp.Body.String())
+	}
+}
+
+func TestFallDetailHidesDecideFormForPruefer(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, prueferCookie := seedFallImAccount(t, fs, s, "pruefer")
+
+	resp := getWithCookie(t, s, prueferCookie, "/faelle/"+antragID)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if strings.Contains(resp.Body.String(), `name="entscheidung"`) {
+		t.Errorf("expected no Entscheiden form for pruefer, got: %s", resp.Body.String())
+	}
+}
+
+func TestFallEntscheidenRejectsPruefer(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, prueferCookie := seedFallImAccount(t, fs, s, "pruefer")
+
+	resp := postForm(t, s, prueferCookie, "/faelle/"+antragID+"/entscheiden", url.Values{"entscheidung": {"rueckfrage"}})
+	if resp.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 for pruefer", resp.Code)
+	}
+}
+
+// TestFallEntscheidenRequiresBegruendungOnAbweichung: fullAntragForm
+// liefert keine passenden Werkzeuge im (leeren) Katalog, der Vorschlag
+// ist also "rueckfrage" (siehe vorschlagFuer). "abgelehnt" weicht davon
+// ab und braucht eine Begründung.
+func TestFallEntscheidenRequiresBegruendungOnAbweichung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, verantwortlicherCookie := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{"entscheidung": {"abgelehnt"}})
+	if resp.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 ohne Begründung bei Abweichung, body: %s", resp.Code, resp.Body.String())
+	}
+
+	resp = postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"abgelehnt"}, "begruendung": {"Kein Werkzeug im Katalog verfügbar, trotzdem vertretbar"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303 mit Begründung, body: %s", resp.Code, resp.Body.String())
+	}
+}
+
+func TestFallEntscheidenRueckfrageOhneAbweichungBrauchtKeineBegruendung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, verantwortlicherCookie := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{"entscheidung": {"rueckfrage"}})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303 (rueckfrage entspricht dem Vorschlag bei leerem Katalog), body: %s", resp.Code, resp.Body.String())
+	}
+
+	detail := getWithCookie(t, s, verantwortlicherCookie, "/faelle/"+antragID)
+	if !strings.Contains(detail.Body.String(), "rueckfrage") {
+		t.Errorf("expected the Entscheidung on the fall-detail page, got: %s", detail.Body.String())
+	}
+}
+
+func TestFallEntscheidenGenehmigtBrauchtZulaessigesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	acc, err := fs.CreateAccount(context.Background(), "Mit Katalog")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	mitarbeiterCookie := seedUserInAccount(t, fs, acc.ID, "mitarbeiter@example.com", "mitarbeiter")
+	fs.werkzeuge["werkzeug-ok"] = store.Werkzeug{ID: "werkzeug-ok", Name: "ChatGPT Enterprise", AVVVerfuegbar: true, TrainingStandard: true}
+	s := newServer(t, fs)
+	createResp := postForm(t, s, mitarbeiterCookie, "/antraege", fullAntragForm())
+	if createResp.Code != http.StatusSeeOther {
+		t.Fatalf("Antrag anlegen: status = %d, body: %s", createResp.Code, createResp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		if fs.antraege[id].AccountID == acc.ID {
+			antragID = id
+		}
+	}
+	verantwortlicherCookie := seedUserInAccount(t, fs, acc.ID, "verantwortlicher@example.com", "verantwortlicher")
+
+	// Ohne werkzeug_id: abgelehnt.
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{"entscheidung": {"genehmigt"}})
+	if resp.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 ohne Werkzeug bei Genehmigung", resp.Code)
+	}
+
+	// Mit zulässigem Werkzeug: erfolgreich, Antrag wird "entschieden".
+	resp = postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {"werkzeug-ok"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	antrag, err := fs.GetAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetAntrag: %v", err)
+	}
+	if antrag.Status != "entschieden" {
+		t.Errorf("Status = %q, want entschieden", antrag.Status)
+	}
+
+	detail := getWithCookie(t, s, verantwortlicherCookie, "/faelle/"+antragID)
+	if !strings.Contains(detail.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the chosen werkzeug name on the fall-detail page, got: %s", detail.Body.String())
+	}
+}
+
+func TestFallDetailRejectsForeignAccount(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, _ := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	otherAcc, err := fs.CreateAccount(context.Background(), "Fremder Mandant")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	otherCookie := seedUserInAccount(t, fs, otherAcc.ID, "fremd@example.com", "verantwortlicher")
+
+	resp := getWithCookie(t, s, otherCookie, "/faelle/"+antragID)
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a foreign account's fall", resp.Code)
+	}
+}

internal/web/mandant_eigenes_werkzeug_test.go

@@ -0,0 +1,103 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func TestAdminCanCreateEditAndDeleteEigenesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/werkzeuge", werkzeugForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("create status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	var id string
+	admin, err := fs.GetUserByEmail(context.Background(), "admin@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	for wid, w := range fs.werkzeuge {
+		if w.AccountID != nil && *w.AccountID == admin.AccountID {
+			id = wid
+		}
+	}
+	if id == "" {
+		t.Fatal("expected an eigenes werkzeug to exist")
+	}
+
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge")
+	if !strings.Contains(list.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the eigenes werkzeug in the list, got: %s", list.Body.String())
+	}
+
+	editForm := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge/"+id)
+	if editForm.Code != http.StatusOK || !strings.Contains(editForm.Body.String(), "ChatGPT Enterprise") {
+		t.Fatalf("edit form status = %d, body: %s", editForm.Code, editForm.Body.String())
+	}
+
+	updateForm := werkzeugForm()
+	updateForm.Set("name", "ChatGPT Enterprise (eigene Version)")
+	updateResp := postForm(t, s, adminCookie, "/verwaltung/werkzeuge/"+id, updateForm)
+	if updateResp.Code != http.StatusSeeOther {
+		t.Fatalf("update status = %d, body: %s", updateResp.Code, updateResp.Body.String())
+	}
+	if fs.werkzeuge[id].Name != "ChatGPT Enterprise (eigene Version)" {
+		t.Errorf("Name = %q nach Update, unerwartet", fs.werkzeuge[id].Name)
+	}
+
+	deleteResp := postForm(t, s, adminCookie, "/verwaltung/werkzeuge/"+id+"/loeschen", url.Values{})
+	if deleteResp.Code != http.StatusSeeOther {
+		t.Fatalf("delete status = %d, body: %s", deleteResp.Code, deleteResp.Body.String())
+	}
+	if _, ok := fs.werkzeuge[id]; ok {
+		t.Error("expected the eigenes werkzeug to be deleted")
+	}
+}
+
+func TestAdminCannotEditZentralesWerkzeugUeberMandantenRoute(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	fs.werkzeuge["werkzeug-central"] = store.Werkzeug{ID: "werkzeug-central", Name: "ChatGPT Enterprise", Anbieter: "OpenAI"}
+
+	resp := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge/werkzeug-central")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a central werkzeug via the tenant route", resp.Code)
+	}
+}
+
+func TestAdminCannotEditFremdesEigenesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminA := seedAccountWithRole(t, fs, "Mandant A", "admin-a@example.com", "admin")
+	postForm(t, s, adminA, "/verwaltung/werkzeuge", werkzeugForm())
+	adminAUser, err := fs.GetUserByEmail(context.Background(), "admin-a@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	var id string
+	for wid, w := range fs.werkzeuge {
+		if w.AccountID != nil && *w.AccountID == adminAUser.AccountID {
+			id = wid
+		}
+	}
+
+	adminB := seedAccountWithRole(t, fs, "Mandant B", "admin-b@example.com", "admin")
+	resp := getWithCookie(t, s, adminB, "/verwaltung/werkzeuge/"+id)
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a foreign account's eigenes werkzeug", resp.Code)
+	}
+	deleteResp := postForm(t, s, adminB, "/verwaltung/werkzeuge/"+id+"/loeschen", url.Values{})
+	if deleteResp.Code != http.StatusNotFound {
+		t.Fatalf("delete status = %d, want 404 for a foreign account's eigenes werkzeug", deleteResp.Code)
+	}
+}

internal/web/mandant_werkzeug_handlers.go

@@ -0,0 +1,209 @@
+// Ebene 4 — "eigene Werkzeug-Freigaben/-Sperrungen" (siehe CLAUDE.md,
+// Fünf Ebenen): ein Mandant kann einen zentralen Katalogeintrag für
+// sich sperren, ohne den zentralen Katalog selbst zu verändern (das
+// bleibt Sache der Plattform, siehe betreiber_werkzeug_handlers.go),
+// UND eigene, mandantenspezifische Katalogeinträge pflegen
+// (`werkzeug.account_id` = der eigene Account) — dieselbe
+// Formular-Vorlage wie der Betreiber nutzt (werkzeugFormData,
+// betreiber-werkzeug-form.html, ActionBase unterscheidet die Ziel-URL).
+package web
+
+import (
+	"net/http"
+	"strings"
+)
+
+type mandantWerkzeugItem struct {
+	ID       string
+	Name     string
+	Anbieter string
+	Gesperrt bool
+}
+
+type eigenesWerkzeugItem struct {
+	ID       string
+	Name     string
+	Anbieter string
+}
+
+type mandantWerkzeugListeData struct {
+	Title           string
+	Nav             navData
+	Werkzeuge       []mandantWerkzeugItem
+	EigeneWerkzeuge []eigenesWerkzeugItem
+}
+
+// handleMandantWerkzeugListe zeigt den zentralen Katalog aus Sicht des
+// eigenen Mandanten mit Sperren/Entsperren-Aktion je Eintrag, sowie
+// die eigenen (mandantenspezifischen) Katalogeinträge mit Bearbeiten/
+// Löschen.
+func (s *Server) handleMandantWerkzeugListe(w http.ResponseWriter, r *http.Request) {
+	accountID := currentUser(r).AccountID
+	zentral, err := s.store.ListZentraleWerkzeuge(r.Context())
+	if err != nil {
+		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	sperren, err := s.store.ListWerkzeugSperrenForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Sperrungen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	eigene, err := s.store.ListWerkzeugeForAccount(r.Context(), accountID)
+	if err != nil {
+		http.Error(w, "Werkzeuge konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	gesperrt := make(map[string]bool, len(sperren))
+	for _, sp := range sperren {
+		gesperrt[sp.WerkzeugID] = true
+	}
+
+	data := mandantWerkzeugListeData{Title: "Werkzeugkatalog", Nav: navFor(r)}
+	for _, wz := range zentral {
+		data.Werkzeuge = append(data.Werkzeuge, mandantWerkzeugItem{
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Gesperrt: gesperrt[wz.ID],
+		})
+	}
+	for _, wz := range eigene {
+		if wz.AccountID == nil {
+			continue // zentral, oben schon gelistet
+		}
+		data.EigeneWerkzeuge = append(data.EigeneWerkzeuge, eigenesWerkzeugItem{ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter})
+	}
+	if err := s.templates.ExecuteTemplate(w, "mandant-werkzeuge", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+func (s *Server) handleMandantWerkzeugNeuForm(w http.ResponseWriter, r *http.Request) {
+	data := werkzeugFormData{Title: "Eigenes Werkzeug anlegen", Nav: navFor(r), ActionBase: "/verwaltung/werkzeuge", Verarbeitungsorte: gueltigeVerarbeitungsorte}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleMandantWerkzeugCreate legt einen mandantenspezifischen
+// Katalogeintrag an (`werkzeug.account_id` = eigener Account) — sichtbar
+// nur für diesen Mandanten, verändert den zentralen Katalog nicht.
+func (s *Server) handleMandantWerkzeugCreate(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
+	in, errMsg := werkzeugInputFromForm(r, &accountID)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Eigenes Werkzeug anlegen", "/verwaltung/werkzeuge", "", errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.CreateWerkzeug(r.Context(), in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Eigenes Werkzeug anlegen", "/verwaltung/werkzeuge", "", "Werkzeug konnte nicht angelegt werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/werkzeuge", http.StatusSeeOther)
+}
+
+// handleMandantWerkzeugEditForm zeigt einen eigenen Katalogeintrag zum
+// Bearbeiten. Ein zentraler oder fremder Eintrag ist hier nicht
+// erreichbar (404) — das bleibt Sache der Plattform bzw. des jeweils
+// anderen Mandanten.
+func (s *Server) handleMandantWerkzeugEditForm(w http.ResponseWriter, r *http.Request) {
+	wz, err := s.store.GetWerkzeug(r.Context(), r.PathValue("id"))
+	accountID := currentUser(r).AccountID
+	if err != nil || wz.AccountID == nil || *wz.AccountID != accountID {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	data := werkzeugFormData{
+		Title: "Eigenes Werkzeug bearbeiten", Nav: navFor(r), ActionBase: "/verwaltung/werkzeuge", ID: wz.ID, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+		AVVVerfuegbar: wz.AVVVerfuegbar, AVVURL: wz.AVVURL,
+		TrainingOptOut: wz.TrainingOptOut, TrainingStandard: wz.TrainingStandard, AufbewahrungTage: wz.AufbewahrungTage,
+		Zertifizierungen: strings.Join(wz.Zertifizierungen, ", "), GeeigneteZwecke: strings.Join(wz.GeeigneteZwecke, ", "),
+		Einschraenkungen: strings.Join(wz.Einschraenkungen, ", "), LetztePruefung: wz.LetztePruefung.Format("2006-01-02"),
+		Quelle: wz.Quelle,
+	}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleMandantWerkzeugUpdate speichert Änderungen an einem eigenen
+// Katalogeintrag.
+func (s *Server) handleMandantWerkzeugUpdate(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	accountID := currentUser(r).AccountID
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID == nil || *wz.AccountID != accountID {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	in, errMsg := werkzeugInputFromForm(r, &accountID)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Eigenes Werkzeug bearbeiten", "/verwaltung/werkzeuge", id, errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.UpdateWerkzeug(r.Context(), id, in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Eigenes Werkzeug bearbeiten", "/verwaltung/werkzeuge", id, "Werkzeug konnte nicht gespeichert werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/werkzeuge", http.StatusSeeOther)
+}
+
+// handleMandantWerkzeugDelete entfernt einen eigenen Katalogeintrag.
+func (s *Server) handleMandantWerkzeugDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	accountID := currentUser(r).AccountID
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID == nil || *wz.AccountID != accountID {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteWerkzeug(r.Context(), id); err != nil {
+		http.Error(w, "Werkzeug konnte nicht gelöscht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/werkzeuge", http.StatusSeeOther)
+}
+
+// handleMandantWerkzeugSperren sperrt einen zentralen Katalogeintrag
+// für den eigenen Mandanten — der zentrale Eintrag selbst bleibt
+// unverändert, er verschwindet nur aus ListWerkzeugeForAccount für
+// diesen einen Mandanten.
+func (s *Server) handleMandantWerkzeugSperren(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	grund := r.FormValue("grund")
+	if _, err := s.store.CreateWerkzeugSperre(r.Context(), currentUser(r).AccountID, r.PathValue("id"), grund); err != nil {
+		http.Error(w, "Werkzeug konnte nicht gesperrt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/werkzeuge", http.StatusSeeOther)
+}
+
+func (s *Server) handleMandantWerkzeugEntsperren(w http.ResponseWriter, r *http.Request) {
+	if err := s.store.DeleteWerkzeugSperre(r.Context(), currentUser(r).AccountID, r.PathValue("id")); err != nil {
+		http.Error(w, "Sperrung konnte nicht aufgehoben werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/verwaltung/werkzeuge", http.StatusSeeOther)
+}

internal/web/mandant_werkzeug_handlers_test.go

@@ -0,0 +1,66 @@
+package web_test
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func TestAdminCanSperrenUndEntsperrenZentralesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	fs.werkzeuge["werkzeug-central"] = store.Werkzeug{ID: "werkzeug-central", Name: "ChatGPT Enterprise", Anbieter: "OpenAI"}
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge")
+	if !strings.Contains(list.Body.String(), "ChatGPT Enterprise") {
+		t.Fatalf("expected the zentrale werkzeug in the list, got: %s", list.Body.String())
+	}
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/werkzeuge/werkzeug-central/sperren", url.Values{"grund": {"zu teuer"}})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("sperren status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	afterSperren := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge")
+	if !strings.Contains(afterSperren.Body.String(), `<span class="status">gesperrt</span>`) {
+		t.Errorf("expected the werkzeug to show as gesperrt, got: %s", afterSperren.Body.String())
+	}
+
+	resp = postForm(t, s, adminCookie, "/verwaltung/werkzeuge/werkzeug-central/entsperren", url.Values{})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("entsperren status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	afterEntsperren := getWithCookie(t, s, adminCookie, "/verwaltung/werkzeuge")
+	if strings.Contains(afterEntsperren.Body.String(), `<span class="status">gesperrt</span>`) {
+		t.Errorf("expected the werkzeug to no longer show as gesperrt, got: %s", afterEntsperren.Body.String())
+	}
+}
+
+func TestSperreIstProMandantIsoliert(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	fs.werkzeuge["werkzeug-central"] = store.Werkzeug{ID: "werkzeug-central", Name: "ChatGPT Enterprise", Anbieter: "OpenAI"}
+	adminA := seedAccountWithRole(t, fs, "Mandant A", "admin-a@example.com", "admin")
+	adminB := seedAccountWithRole(t, fs, "Mandant B", "admin-b@example.com", "admin")
+
+	postForm(t, s, adminA, "/verwaltung/werkzeuge/werkzeug-central/sperren", url.Values{})
+
+	respB := getWithCookie(t, s, adminB, "/verwaltung/werkzeuge")
+	if strings.Contains(respB.Body.String(), `<span class="status">gesperrt</span>`) {
+		t.Errorf("expected Mandant B to see the werkzeug as unsperrt, got: %s", respB.Body.String())
+	}
+}
+
+func TestMitarbeiterCannotAccessWerkzeugverwaltung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/werkzeuge")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter", resp.Code)
+	}
+}

internal/web/middleware.go

@@ -34,7 +34,7 @@ func (s *Server) authenticate(r *http.Request) (store.User, bool) {
 	}
 
 	user, err := s.store.GetUser(r.Context(), sess.UserID)
-	if err != nil {
+	if err != nil || !user.Active {
 		return store.User{}, false
 	}
 	return user, true
@@ -89,19 +89,75 @@ func (s *Server) requireBetreiber(next http.HandlerFunc) http.HandlerFunc {
 	}
 }
 
+// requireFachebene schützt die Fachebene (Ebene 3 — Posteingang und
+// Entscheiden, Rollen "verantwortlicher" und "pruefer", siehe
+// CLAUDE.md). "admin" ist hier bewusst mit zugelassen: die Spezifikation
+// will, dass der erste Nutzer einer neuen Firma gleichzeitig admin UND
+// verantwortlicher ist ("Admin und KI-Verantwortlicher" — siehe CLAUDE.md,
+// Offene Punkte), app_user.role kennt aber nur einen Wert. Statt eines
+// Datenmodell-Umbaus (roles-Array oder zwei app_user-Zeilen pro Person)
+// bekommt admin hier pragmatisch dieselben Fachebene-Rechte wie
+// verantwortlicher (inkl. Entscheidungsrecht, siehe handleFallEntscheiden)
+// — ohne das könnte eine frisch registrierte Firma mit nur einem
+// admin-Login keinen einzigen eingereichten Antrag sehen oder
+// bearbeiten. pruefer bleibt unverändert nur lesend. Wie bei
+// requireBetreiber: 404 statt 403 bei falscher Rolle, damit ein
+// angemeldeter, aber unprivilegierter Nutzer (z. B. "mitarbeiter")
+// nicht erfährt, dass es die Seite überhaupt gibt.
+func (s *Server) requireFachebene(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user, ok := s.authenticate(r)
+		if !ok {
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+		if user.Role != "verantwortlicher" && user.Role != "pruefer" && user.Role != "admin" {
+			http.Error(w, "nicht gefunden", http.StatusNotFound)
+			return
+		}
+		next(w, r.WithContext(context.WithValue(r.Context(), userContextKey, user)))
+	}
+}
+
+// requireAdmin schützt die Mandanten-Verwaltung (Ebene 4 — Nutzer/
+// Rollen für GENAU EINEN Mandanten, siehe CLAUDE.md). Wie bei
+// requireBetreiber/requireFachebene: 404 statt 403 bei falscher Rolle.
+func (s *Server) requireAdmin(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user, ok := s.authenticate(r)
+		if !ok {
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+		if user.Role != "admin" {
+			http.Error(w, "nicht gefunden", http.StatusNotFound)
+			return
+		}
+		next(w, r.WithContext(context.WithValue(r.Context(), userContextKey, user)))
+	}
+}
+
 // navData steuert die gemeinsame Navigation (layout.html, "nav"-Block).
 // Eigenes, kleines Struct statt jeder Seite Zugriff auf den vollen
 // currentUser zu geben — die Navigation braucht nur, ob ein
 // Plattform-Link gezeigt werden soll.
 type navData struct {
 	IsBetreiber bool
+	IsFachebene bool
+	IsAdmin     bool
 }
 
 // navFor liefert die Nav-Daten für den angemeldeten Nutzer der Anfrage.
 // Nur für Seiten hinter requirePage/requireBetreiber aufrufbar (braucht
 // currentUser).
 func navFor(r *http.Request) navData {
-	return navData{IsBetreiber: currentUser(r).Role == "betreiber"}
+	role := currentUser(r).Role
+	return navData{
+		IsBetreiber: role == "betreiber",
+		// admin sieht die Fachebene mit, siehe requireFachebene.
+		IsFachebene: role == "verantwortlicher" || role == "pruefer" || role == "admin",
+		IsAdmin:     role == "admin",
+	}
 }
 
 // currentUser liest den Nutzer, den requirePage/requireAPI in den

internal/web/nutzer_aktivierung_test.go

@@ -0,0 +1,102 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestAdminKannNutzerDeaktivierenUndReaktivieren(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"weg@example.com"}, "password": {"ein-langes-passwort"}, "role": {"mitarbeiter"},
+	})
+	target, err := fs.GetUserByEmail(context.Background(), "weg@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer/"+target.ID+"/deaktivieren", url.Values{})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("deaktivieren status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	deaktiviert, err := fs.GetUser(context.Background(), target.ID)
+	if err != nil || deaktiviert.Active {
+		t.Fatalf("expected user to be inactive, got %+v (err %v)", deaktiviert, err)
+	}
+
+	loginResp := postForm(t, s, nil, "/login", url.Values{"email": {"weg@example.com"}, "password": {"ein-langes-passwort"}})
+	if !strings.Contains(loginResp.Body.String(), "deaktiviert") {
+		t.Errorf("expected a deactivation message on login, got: %s", loginResp.Body.String())
+	}
+
+	reaktivierenResp := postForm(t, s, adminCookie, "/verwaltung/nutzer/"+target.ID+"/aktivieren", url.Values{})
+	if reaktivierenResp.Code != http.StatusSeeOther {
+		t.Fatalf("aktivieren status = %d, body: %s", reaktivierenResp.Code, reaktivierenResp.Body.String())
+	}
+	reaktiviert, err := fs.GetUser(context.Background(), target.ID)
+	if err != nil || !reaktiviert.Active {
+		t.Fatalf("expected user to be active again, got %+v (err %v)", reaktiviert, err)
+	}
+}
+
+func TestAdminKannSichNichtSelbstDeaktivieren(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	self, err := fs.GetUserByEmail(context.Background(), "admin@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer/"+self.ID+"/deaktivieren", url.Values{})
+	if resp.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 for self-deactivation", resp.Code)
+	}
+}
+
+func TestDeaktivierterNutzerVerliertLaufendeSitzungSofort(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+	admin, err := fs.GetUserByEmail(context.Background(), "admin@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	mitarbeiterCookie := seedUserInAccount(t, fs, admin.AccountID, "mitarbeiter@example.com", "mitarbeiter")
+
+	if resp := getWithCookie(t, s, mitarbeiterCookie, "/antraege"); resp.Code != http.StatusOK {
+		t.Fatalf("expected active session to work, status = %d", resp.Code)
+	}
+
+	target, err := fs.GetUserByEmail(context.Background(), "mitarbeiter@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	postForm(t, s, adminCookie, "/verwaltung/nutzer/"+target.ID+"/deaktivieren", url.Values{})
+
+	resp := getWithCookie(t, s, mitarbeiterCookie, "/antraege")
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("expected the deactivated user's session to be rejected, status = %d", resp.Code)
+	}
+}
+
+func TestAdminCannotDeactivateForeignAccountUser(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminA := seedAccountWithRole(t, fs, "Mandant A", "admin-a@example.com", "admin")
+	seedAccountWithRole(t, fs, "Mandant B", "admin-b@example.com", "admin")
+	targetB, err := fs.GetUserByEmail(context.Background(), "admin-b@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+
+	resp := postForm(t, s, adminA, "/verwaltung/nutzer/"+targetB.ID+"/deaktivieren", url.Values{})
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a foreign account's user", resp.Code)
+	}
+}

internal/web/register_handlers.go

@@ -0,0 +1,133 @@
+// Ebene 3 — Register und Export (Schritt 6 der Baureihenfolge, siehe
+// CLAUDE.md). Jede Genehmigung erzeugt automatisch einen Registereintrag
+// (siehe handleFallEntscheiden); diese Seiten zeigen und exportieren
+// sie. Reuse des bereits vorhandenen (bisher ungenutzten) go-pdf/fpdf-
+// Dependency statt einer neuen Bibliothek für den PDF-Export.
+package web
+
+import (
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/go-pdf/fpdf"
+)
+
+type registerEintragView struct {
+	Zweck            string
+	Abteilung        string
+	Werkzeug         string
+	Datenklasse      string
+	Einstufung       string
+	Auflagen         string
+	Verantwortlicher string
+	EntschiedenAm    string
+	GueltigBis       string
+}
+
+type registerListeData struct {
+	Title     string
+	Nav       navData
+	Eintraege []registerEintragView
+}
+
+func (s *Server) registerEintraegeFuerAccount(r *http.Request) ([]registerEintragView, error) {
+	eintraege, err := s.store.ListRegistereintraegeForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		return nil, err
+	}
+	views := make([]registerEintragView, len(eintraege))
+	for i, e := range eintraege {
+		gueltigBis := ""
+		if e.GueltigBis != nil {
+			gueltigBis = e.GueltigBis.Format("02.01.2006")
+		}
+		views[i] = registerEintragView{
+			Zweck: e.Zweck, Abteilung: e.Abteilung, Werkzeug: e.Werkzeug,
+			Datenklasse: e.Datenklasse, Einstufung: e.Einstufung, Auflagen: strings.Join(e.Auflagen, "; "),
+			Verantwortlicher: e.Verantwortlicher, EntschiedenAm: e.EntschiedenAm.Format("02.01.2006 15:04"), GueltigBis: gueltigBis,
+		}
+	}
+	return views, nil
+}
+
+// handleRegisterListe zeigt das Register (alle Genehmigungen des
+// Mandanten) — Ebene 3, für verantwortlicher und pruefer gleichermaßen
+// lesbar.
+func (s *Server) handleRegisterListe(w http.ResponseWriter, r *http.Request) {
+	views, err := s.registerEintraegeFuerAccount(r)
+	if err != nil {
+		http.Error(w, "Register konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := registerListeData{Title: "Register", Nav: navFor(r), Eintraege: views}
+	if err := s.templates.ExecuteTemplate(w, "register-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+var registerCSVHeader = []string{"Zweck", "Abteilung", "Werkzeug", "Datenklasse", "Einstufung", "Auflagen", "Verantwortliche/r", "Entschieden am", "Gültig bis"}
+
+func registerCSVRow(e registerEintragView) []string {
+	return []string{e.Zweck, e.Abteilung, e.Werkzeug, e.Datenklasse, e.Einstufung, e.Auflagen, e.Verantwortlicher, e.EntschiedenAm, e.GueltigBis}
+}
+
+// handleRegisterExportCSV exportiert das Register als CSV.
+func (s *Server) handleRegisterExportCSV(w http.ResponseWriter, r *http.Request) {
+	views, err := s.registerEintraegeFuerAccount(r)
+	if err != nil {
+		http.Error(w, "Register konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "text/csv; charset=utf-8")
+	w.Header().Set("Content-Disposition", `attachment; filename="register.csv"`)
+	cw := csv.NewWriter(w)
+	_ = cw.Write(registerCSVHeader)
+	for _, e := range views {
+		_ = cw.Write(registerCSVRow(e))
+	}
+	cw.Flush()
+}
+
+// handleRegisterExportPDF exportiert das Register als PDF — eine
+// einfache Tabelle, keine Gestaltung über den Design-System-Anspruch
+// des restlichen Produkts hinaus.
+func (s *Server) handleRegisterExportPDF(w http.ResponseWriter, r *http.Request) {
+	views, err := s.registerEintraegeFuerAccount(r)
+	if err != nil {
+		http.Error(w, "Register konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	pdf := fpdf.New("L", "mm", "A4", "")
+	// cp1252 deckt deutsche Umlaute/ß ab — die eingebauten Helvetica-
+	// Fonts von fpdf können sonst kein UTF-8 darstellen.
+	tr := pdf.UnicodeTranslatorFromDescriptor("")
+	pdf.AddPage()
+	pdf.SetFont("Helvetica", "B", 14)
+	pdf.CellFormat(0, 10, tr("Register"), "", 1, "L", false, 0, "")
+	pdf.Ln(2)
+
+	colWidths := []float64{45, 25, 35, 30, 30, 55, 40, 30, 25}
+	pdf.SetFont("Helvetica", "B", 8)
+	for i, h := range registerCSVHeader {
+		pdf.CellFormat(colWidths[i], 8, tr(h), "1", 0, "L", false, 0, "")
+	}
+	pdf.Ln(-1)
+
+	pdf.SetFont("Helvetica", "", 8)
+	for _, e := range views {
+		row := registerCSVRow(e)
+		for i, cell := range row {
+			pdf.CellFormat(colWidths[i], 8, tr(cell), "1", 0, "L", false, 0, "")
+		}
+		pdf.Ln(-1)
+	}
+
+	w.Header().Set("Content-Type", "application/pdf")
+	w.Header().Set("Content-Disposition", `attachment; filename="register.pdf"`)
+	if err := pdf.Output(w); err != nil {
+		http.Error(w, fmt.Sprintf("PDF konnte nicht erzeugt werden: %v", err), http.StatusInternalServerError)
+	}
+}

internal/web/register_handlers_test.go

@@ -0,0 +1,142 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+	"github.com/netcell-it/deklarix/internal/web"
+)
+
+// genehmigeFall reicht einen Antrag ein und genehmigt ihn mit einem
+// echten, zulässigen Werkzeug — Vorbereitung für Register-Tests, die
+// einen tatsächlichen Registereintrag brauchen.
+func genehmigeFall(t *testing.T, fs *fakeStore, s *web.Server) (accountID string) {
+	t.Helper()
+	acc, err := fs.CreateAccount(context.Background(), "Register-Mandant")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	fs.werkzeuge["werkzeug-ok"] = store.Werkzeug{ID: "werkzeug-ok", Name: "ChatGPT Enterprise", AVVVerfuegbar: true, TrainingStandard: true}
+	mitarbeiterCookie := seedUserInAccount(t, fs, acc.ID, "mitarbeiter@example.com", "mitarbeiter")
+	createResp := postForm(t, s, mitarbeiterCookie, "/antraege", fullAntragForm())
+	if createResp.Code != http.StatusSeeOther {
+		t.Fatalf("Antrag anlegen: status = %d, body: %s", createResp.Code, createResp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		if fs.antraege[id].AccountID == acc.ID {
+			antragID = id
+		}
+	}
+	verantwortlicherCookie := seedUserInAccount(t, fs, acc.ID, "verantwortlicher@example.com", "verantwortlicher")
+	entscheidenResp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"genehmigt"}, "werkzeug_id": {"werkzeug-ok"},
+	})
+	if entscheidenResp.Code != http.StatusSeeOther {
+		t.Fatalf("Entscheiden: status = %d, body: %s", entscheidenResp.Code, entscheidenResp.Body.String())
+	}
+	return acc.ID
+}
+
+func TestGenehmigungErzeugtRegistereintrag(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+
+	list := fs.registereintraege[accountID]
+	if len(list) != 1 {
+		t.Fatalf("registereintraege = %+v, want exactly one entry", list)
+	}
+	e := list[0]
+	if e.Werkzeug != "ChatGPT Enterprise" || e.Zweck != "Angebotstexte generieren" || e.Datenklasse != "personenbezogen" {
+		t.Errorf("Registereintrag = %+v, unerwartete Werte", e)
+	}
+	if e.Verantwortlicher != "verantwortlicher@example.com" {
+		t.Errorf("Verantwortlicher = %q, want verantwortlicher@example.com", e.Verantwortlicher)
+	}
+}
+
+func TestAbgelehnteEntscheidungErzeugtKeinenRegistereintrag(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	antragID, verantwortlicherCookie := seedFallImAccount(t, fs, s, "verantwortlicher")
+
+	resp := postForm(t, s, verantwortlicherCookie, "/faelle/"+antragID+"/entscheiden", url.Values{
+		"entscheidung": {"abgelehnt"}, "begruendung": {"Kein Werkzeug verfügbar"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	for _, list := range fs.registereintraege {
+		if len(list) != 0 {
+			t.Fatalf("expected no registereintrag for an abgelehnt Entscheidung, got %+v", list)
+		}
+	}
+}
+
+func TestRegisterListeZeigtGenehmigung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+	verantwortlicherCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+
+	resp := getWithCookie(t, s, verantwortlicherCookie, "/registereintraege")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the genehmigtes werkzeug in the register, got: %s", resp.Body.String())
+	}
+}
+
+func TestRegisterExportCSVEnthaeltEintrag(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+	verantwortlicherCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+
+	resp := getWithCookie(t, s, verantwortlicherCookie, "/registereintraege/export.csv")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if ct := resp.Header().Get("Content-Type"); !strings.Contains(ct, "text/csv") {
+		t.Errorf("Content-Type = %q, want text/csv", ct)
+	}
+	if !strings.Contains(resp.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the werkzeug in the CSV export, got: %s", resp.Body.String())
+	}
+}
+
+func TestRegisterExportPDFReturnsPDF(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+	verantwortlicherCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+
+	resp := getWithCookie(t, s, verantwortlicherCookie, "/registereintraege/export.pdf")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if ct := resp.Header().Get("Content-Type"); ct != "application/pdf" {
+		t.Errorf("Content-Type = %q, want application/pdf", ct)
+	}
+	if !strings.HasPrefix(resp.Body.String(), "%PDF") {
+		t.Error("expected the response body to start with the PDF magic bytes")
+	}
+}
+
+func TestMitarbeiterCannotAccessRegister(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/registereintraege")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter on /registereintraege", resp.Code)
+	}
+}

internal/web/server.go

@@ -30,11 +30,14 @@ var staticFS embed.FS
 type Store interface {
 	CreateAccount(ctx context.Context, name string) (store.Account, error)
 	GetAccount(ctx context.Context, id string) (store.Account, error)
+	GetAccountByEinladungToken(ctx context.Context, token string) (store.Account, error)
+	RegenerateEinladungToken(ctx context.Context, accountID, newToken string) error
 	ListAccounts(ctx context.Context) ([]store.Account, error)
 	CreateUser(ctx context.Context, accountID, email, passwordHash, role string) (store.User, error)
 	GetUserByEmail(ctx context.Context, email string) (store.User, error)
 	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
 	CreateSession(ctx context.Context, token, userID string, expiresAt time.Time) (store.Session, error)
 	GetSession(ctx context.Context, token string) (store.Session, error)
 	DeleteSession(ctx context.Context, token string) error
@@ -42,17 +45,35 @@ type Store interface {
 	ListAuditLog(ctx context.Context, limit int) ([]store.AuditEntry, error)
 
 	ListAbteilungenForAccount(ctx context.Context, accountID string) ([]store.Abteilung, error)
+	CreateAbteilung(ctx context.Context, accountID, name string) (store.Abteilung, error)
+	DeleteAbteilung(ctx context.Context, id string) error
 	CreateAntrag(ctx context.Context, accountID, erstellerUserID string, abteilungID *string, titel string) (store.Antrag, error)
 	GetAntrag(ctx context.Context, id string) (store.Antrag, error)
 	UpdateAntragFelder(ctx context.Context, id, titel, beschreibung, ergebnis, haeufigkeit string, antworten []byte) (store.Antrag, error)
 	SetAntragStatus(ctx context.Context, id, status string) error
 	ListAntraegeForUser(ctx context.Context, erstellerUserID string) ([]store.Antrag, error)
+	ListAntraegeForAccount(ctx context.Context, accountID string) ([]store.Antrag, error)
 
 	ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error)
+	ListZentraleWerkzeuge(ctx context.Context) ([]store.Werkzeug, error)
+	CreateWerkzeugSperre(ctx context.Context, accountID, werkzeugID, grund string) (store.WerkzeugSperre, error)
+	DeleteWerkzeugSperre(ctx context.Context, accountID, werkzeugID string) error
+	ListWerkzeugSperrenForAccount(ctx context.Context, accountID string) ([]store.WerkzeugSperre, error)
 	GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error)
+	CreateWerkzeug(ctx context.Context, in store.WerkzeugInput) (store.Werkzeug, error)
+	UpdateWerkzeug(ctx context.Context, id string, in store.WerkzeugInput) (store.Werkzeug, error)
+	DeleteWerkzeug(ctx context.Context, id string) error
 	CurrentKatalogVersion(ctx context.Context) (string, error)
 	CreateBewertung(ctx context.Context, in store.BewertungInput) (store.Bewertung, error)
 	GetLatestBewertungForAntrag(ctx context.Context, antragID string) (store.Bewertung, error)
+
+	CreateEntscheidung(ctx context.Context, in store.EntscheidungInput) (store.Entscheidung, error)
+	GetLatestEntscheidungForAntrag(ctx context.Context, antragID string) (store.Entscheidung, error)
+	ListAktiveGenehmigungenForAccount(ctx context.Context, accountID string) ([]store.Entscheidung, error)
+
+	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)
 }
 
 // Regelwerk bündelt die drei geladenen Regelwerk-Dateien, die die
@@ -91,6 +112,8 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	mux.HandleFunc("GET /health", s.handleHealth)
 	mux.HandleFunc("GET /register", s.handleRegisterForm)
 	mux.HandleFunc("POST /register", s.handleRegister)
+	mux.HandleFunc("GET /einladung/{token}", s.handleEinladungForm)
+	mux.HandleFunc("POST /einladung/{token}", s.handleEinladungAnnehmen)
 	mux.HandleFunc("GET /login", s.handleLoginForm)
 	mux.HandleFunc("POST /login", s.handleLogin)
 	mux.HandleFunc("POST /logout", s.handleLogout)
@@ -99,10 +122,43 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	mux.HandleFunc("GET /antraege/neu", s.requirePage(s.handleAntragNewForm))
 	mux.HandleFunc("POST /antraege", s.requirePage(s.handleAntragCreate))
 	mux.HandleFunc("GET /antraege/{id}", s.requirePage(s.handleAntragDetail))
+	mux.HandleFunc("GET /faelle", s.requireFachebene(s.handleFaelleListe))
+	mux.HandleFunc("GET /faelle/{id}", s.requireFachebene(s.handleFallDetail))
+	mux.HandleFunc("POST /faelle/{id}/entscheiden", s.requireFachebene(s.handleFallEntscheiden))
+	mux.HandleFunc("GET /registereintraege", s.requireFachebene(s.handleRegisterListe))
+	mux.HandleFunc("GET /registereintraege/export.csv", s.requireFachebene(s.handleRegisterExportCSV))
+	mux.HandleFunc("GET /registereintraege/export.pdf", s.requireFachebene(s.handleRegisterExportPDF))
+	mux.HandleFunc("GET /wiedervorlage", s.requireFachebene(s.handleWiedervorlageListe))
+	mux.HandleFunc("GET /verwaltung/nutzer", s.requireAdmin(s.handleNutzerListe))
+	mux.HandleFunc("GET /verwaltung/nutzer/neu", s.requireAdmin(s.handleNutzerNeuForm))
+	mux.HandleFunc("POST /verwaltung/nutzer", s.requireAdmin(s.handleNutzerCreate))
+	mux.HandleFunc("POST /verwaltung/nutzer/{id}/deaktivieren", s.requireAdmin(s.handleNutzerDeaktivieren))
+	mux.HandleFunc("POST /verwaltung/nutzer/{id}/aktivieren", s.requireAdmin(s.handleNutzerAktivieren))
+	mux.HandleFunc("GET /verwaltung/nutzer/import", s.requireAdmin(s.handleNutzerCSVImportForm))
+	mux.HandleFunc("POST /verwaltung/nutzer/import", s.requireAdmin(s.handleNutzerCSVImportUpload))
+	mux.HandleFunc("GET /verwaltung/einladung", s.requireAdmin(s.handleEinladungVerwaltung))
+	mux.HandleFunc("POST /verwaltung/einladung/erneuern", s.requireAdmin(s.handleEinladungErneuern))
+	mux.HandleFunc("GET /verwaltung/abteilungen", s.requireAdmin(s.handleAbteilungListe))
+	mux.HandleFunc("POST /verwaltung/abteilungen", s.requireAdmin(s.handleAbteilungCreate))
+	mux.HandleFunc("POST /verwaltung/abteilungen/{id}/loeschen", s.requireAdmin(s.handleAbteilungDelete))
+	mux.HandleFunc("GET /verwaltung/werkzeuge", s.requireAdmin(s.handleMandantWerkzeugListe))
+	mux.HandleFunc("POST /verwaltung/werkzeuge/{id}/sperren", s.requireAdmin(s.handleMandantWerkzeugSperren))
+	mux.HandleFunc("POST /verwaltung/werkzeuge/{id}/entsperren", s.requireAdmin(s.handleMandantWerkzeugEntsperren))
+	mux.HandleFunc("GET /verwaltung/werkzeuge/neu", s.requireAdmin(s.handleMandantWerkzeugNeuForm))
+	mux.HandleFunc("POST /verwaltung/werkzeuge", s.requireAdmin(s.handleMandantWerkzeugCreate))
+	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 /betreiber", s.requireBetreiber(s.handleBetreiberDashboard))
 	mux.HandleFunc("GET /betreiber/accounts", s.requireBetreiber(s.handleBetreiberAccountList))
 	mux.HandleFunc("GET /betreiber/accounts/{id}", s.requireBetreiber(s.handleBetreiberAccountDetail))
 	mux.HandleFunc("GET /betreiber/audit-log", s.requireBetreiber(s.handleBetreiberAuditLog))
+	mux.HandleFunc("GET /betreiber/werkzeuge", s.requireBetreiber(s.handleBetreiberWerkzeugListe))
+	mux.HandleFunc("GET /betreiber/werkzeuge/neu", s.requireBetreiber(s.handleBetreiberWerkzeugNeuForm))
+	mux.HandleFunc("POST /betreiber/werkzeuge", s.requireBetreiber(s.handleBetreiberWerkzeugCreate))
+	mux.HandleFunc("GET /betreiber/werkzeuge/{id}", s.requireBetreiber(s.handleBetreiberWerkzeugEditForm))
+	mux.HandleFunc("POST /betreiber/werkzeuge/{id}", s.requireBetreiber(s.handleBetreiberWerkzeugUpdate))
+	mux.HandleFunc("POST /betreiber/werkzeuge/{id}/loeschen", s.requireBetreiber(s.handleBetreiberWerkzeugDelete))
 	mux.Handle("GET /static/", http.FileServerFS(staticFS))
 	s.mux = mux
 

internal/web/server_test.go

@@ -35,6 +35,9 @@ type fakeStore struct {
 	antraege          map[string]store.Antrag
 	werkzeuge         map[string]store.Werkzeug
 	bewertungen       map[string][]store.Bewertung       // antragID -> Bewertungen, älteste zuerst
+	entscheidungen    map[string][]store.Entscheidung    // antragID -> Entscheidungen, älteste zuerst
+	registereintraege map[string][]store.Registereintrag // accountID -> Registereintraege
+	werkzeugSperren   map[string][]store.WerkzeugSperre  // accountID -> Sperrungen
 }
 
 func newFakeStore() *fakeStore {
@@ -47,6 +50,9 @@ func newFakeStore() *fakeStore {
 		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{},
 	}
 }
 
@@ -58,11 +64,35 @@ func (f *fakeStore) newID() string {
 func (f *fakeStore) CreateAccount(ctx context.Context, name string) (store.Account, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
-	acc := store.Account{ID: f.newID(), Name: name, CreatedAt: time.Now()}
+	id := f.newID()
+	acc := store.Account{ID: id, Name: name, EinladungToken: "einladung-token-" + id, CreatedAt: time.Now()}
 	f.accounts[acc.ID] = acc
 	return acc, nil
 }
 
+func (f *fakeStore) GetAccountByEinladungToken(ctx context.Context, token string) (store.Account, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for _, acc := range f.accounts {
+		if acc.EinladungToken == token {
+			return acc, nil
+		}
+	}
+	return store.Account{}, store.ErrNotFound
+}
+
+func (f *fakeStore) RegenerateEinladungToken(ctx context.Context, accountID, newToken string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	acc, ok := f.accounts[accountID]
+	if !ok {
+		return store.ErrNotFound
+	}
+	acc.EinladungToken = newToken
+	f.accounts[accountID] = acc
+	return nil
+}
+
 func (f *fakeStore) GetAccount(ctx context.Context, id string) (store.Account, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -91,7 +121,7 @@ func (f *fakeStore) CreateUser(ctx context.Context, accountID, email, passwordHa
 	}
 	u := store.User{
 		ID: f.newID(), AccountID: accountID, Email: email, PasswordHash: passwordHash,
-		Role: role, CreatedAt: time.Now(),
+		Role: role, Active: true, CreatedAt: time.Now(),
 	}
 	f.users[u.ID] = u
 	f.usersByEmail[email] = u.ID
@@ -118,6 +148,18 @@ func (f *fakeStore) GetUser(ctx context.Context, id string) (store.User, error)
 	return u, nil
 }
 
+func (f *fakeStore) SetUserActive(ctx context.Context, id string, active bool) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	u, ok := f.users[id]
+	if !ok {
+		return store.ErrNotFound
+	}
+	u.Active = active
+	f.users[id] = u
+	return nil
+}
+
 func (f *fakeStore) ListUsersForAccount(ctx context.Context, accountID string) ([]store.User, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -185,6 +227,41 @@ func (f *fakeStore) ListAbteilungenForAccount(ctx context.Context, accountID str
 	return f.abteilungen[accountID], nil
 }
 
+func (f *fakeStore) GetAbteilung(ctx context.Context, id string) (store.Abteilung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for _, list := range f.abteilungen {
+		for _, a := range list {
+			if a.ID == id {
+				return a, nil
+			}
+		}
+	}
+	return store.Abteilung{}, store.ErrNotFound
+}
+
+func (f *fakeStore) CreateAbteilung(ctx context.Context, accountID, name string) (store.Abteilung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	a := store.Abteilung{ID: f.newID(), AccountID: accountID, Name: name, CreatedAt: time.Now()}
+	f.abteilungen[accountID] = append(f.abteilungen[accountID], a)
+	return a, nil
+}
+
+func (f *fakeStore) DeleteAbteilung(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	for accID, list := range f.abteilungen {
+		for i, a := range list {
+			if a.ID == id {
+				f.abteilungen[accID] = append(list[:i], list[i+1:]...)
+				return nil
+			}
+		}
+	}
+	return store.ErrNotFound
+}
+
 func (f *fakeStore) CreateAntrag(ctx context.Context, accountID, erstellerUserID string, abteilungID *string, titel string) (store.Antrag, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -243,6 +320,18 @@ func (f *fakeStore) ListAntraegeForUser(ctx context.Context, erstellerUserID str
 	return out, nil
 }
 
+func (f *fakeStore) ListAntraegeForAccount(ctx context.Context, accountID string) ([]store.Antrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Antrag
+	for _, a := range f.antraege {
+		if a.AccountID == accountID {
+			out = append(out, a)
+		}
+	}
+	return out, nil
+}
+
 func (f *fakeStore) ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -255,6 +344,85 @@ func (f *fakeStore) ListWerkzeugeForAccount(ctx context.Context, accountID strin
 	return out, nil
 }
 
+func (f *fakeStore) ListZentraleWerkzeuge(ctx context.Context) ([]store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Werkzeug
+	for _, w := range f.werkzeuge {
+		if w.AccountID == nil {
+			out = append(out, w)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) CreateWerkzeugSperre(ctx context.Context, accountID, werkzeugID, grund string) (store.WerkzeugSperre, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	sp := store.WerkzeugSperre{ID: f.newID(), AccountID: accountID, WerkzeugID: werkzeugID, Grund: grund, GesperrtAm: time.Now()}
+	f.werkzeugSperren[accountID] = append(f.werkzeugSperren[accountID], sp)
+	return sp, nil
+}
+
+func (f *fakeStore) DeleteWerkzeugSperre(ctx context.Context, accountID, werkzeugID string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	list := f.werkzeugSperren[accountID]
+	for i, sp := range list {
+		if sp.WerkzeugID == werkzeugID {
+			f.werkzeugSperren[accountID] = append(list[:i], list[i+1:]...)
+			return nil
+		}
+	}
+	return store.ErrNotFound
+}
+
+func (f *fakeStore) ListWerkzeugSperrenForAccount(ctx context.Context, accountID string) ([]store.WerkzeugSperre, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.werkzeugSperren[accountID], nil
+}
+
+func (f *fakeStore) CreateWerkzeug(ctx context.Context, in store.WerkzeugInput) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w := store.Werkzeug{
+		ID: f.newID(), AccountID: in.AccountID, Name: in.Name, Anbieter: in.Anbieter,
+		Verarbeitungsort: in.Verarbeitungsort, AVVVerfuegbar: in.AVVVerfuegbar, AVVURL: in.AVVURL,
+		TrainingOptOut: in.TrainingOptOut, TrainingStandard: in.TrainingStandard, AufbewahrungTage: in.AufbewahrungTage,
+		Zertifizierungen: in.Zertifizierungen, GeeigneteZwecke: in.GeeigneteZwecke, Einschraenkungen: in.Einschraenkungen,
+		LetztePruefung: in.LetztePruefung, Quelle: in.Quelle, CreatedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	f.werkzeuge[w.ID] = w
+	return w, nil
+}
+
+func (f *fakeStore) UpdateWerkzeug(ctx context.Context, id string, in store.WerkzeugInput) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w, ok := f.werkzeuge[id]
+	if !ok {
+		return store.Werkzeug{}, store.ErrNotFound
+	}
+	w.Name, w.Anbieter, w.Verarbeitungsort = in.Name, in.Anbieter, in.Verarbeitungsort
+	w.AVVVerfuegbar, w.AVVURL = in.AVVVerfuegbar, in.AVVURL
+	w.TrainingOptOut, w.TrainingStandard, w.AufbewahrungTage = in.TrainingOptOut, in.TrainingStandard, in.AufbewahrungTage
+	w.Zertifizierungen, w.GeeigneteZwecke, w.Einschraenkungen = in.Zertifizierungen, in.GeeigneteZwecke, in.Einschraenkungen
+	w.LetztePruefung, w.Quelle, w.UpdatedAt = in.LetztePruefung, in.Quelle, time.Now()
+	f.werkzeuge[id] = w
+	return w, nil
+}
+
+func (f *fakeStore) DeleteWerkzeug(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.werkzeuge[id]; !ok {
+		return store.ErrNotFound
+	}
+	delete(f.werkzeuge, id)
+	return nil
+}
+
 func (f *fakeStore) GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -297,6 +465,68 @@ func (f *fakeStore) GetLatestBewertungForAntrag(ctx context.Context, antragID st
 	return bs[len(bs)-1], nil
 }
 
+func (f *fakeStore) CreateEntscheidung(ctx context.Context, in store.EntscheidungInput) (store.Entscheidung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	e := store.Entscheidung{
+		ID: f.newID(), AntragID: in.AntragID, BewertungID: in.BewertungID, EntscheiderUserID: in.EntscheiderUserID,
+		Entscheidung: in.Entscheidung, WerkzeugID: in.WerkzeugID, WerkzeugSnapshot: in.WerkzeugSnapshot,
+		Begruendung: in.Begruendung, GueltigBis: in.GueltigBis, CreatedAt: time.Now(),
+	}
+	f.entscheidungen[in.AntragID] = append(f.entscheidungen[in.AntragID], e)
+	return e, nil
+}
+
+func (f *fakeStore) GetLatestEntscheidungForAntrag(ctx context.Context, antragID string) (store.Entscheidung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	es := f.entscheidungen[antragID]
+	if len(es) == 0 {
+		return store.Entscheidung{}, store.ErrNotFound
+	}
+	return es[len(es)-1], nil
+}
+
+func (f *fakeStore) ListAktiveGenehmigungenForAccount(ctx context.Context, accountID string) ([]store.Entscheidung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Entscheidung
+	for antragID, a := range f.antraege {
+		if a.AccountID != accountID {
+			continue
+		}
+		es := f.entscheidungen[antragID]
+		if len(es) == 0 {
+			continue
+		}
+		latest := es[len(es)-1]
+		if latest.Entscheidung == "genehmigt" || latest.Entscheidung == "genehmigt_mit_auflagen" {
+			out = append(out, latest)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) CreateRegistereintrag(ctx context.Context, in store.RegistereintragInput) (store.Registereintrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	e := store.Registereintrag{
+		ID: f.newID(), AccountID: in.AccountID, AntragID: in.AntragID, EntscheidungID: in.EntscheidungID,
+		Zweck: in.Zweck, Abteilung: in.Abteilung, Werkzeug: in.Werkzeug,
+		Datenklasse: in.Datenklasse, Einstufung: in.Einstufung, Auflagen: in.Auflagen,
+		Verantwortlicher: in.Verantwortlicher, EntschiedenAm: in.EntschiedenAm, GueltigBis: in.GueltigBis,
+		CreatedAt: time.Now(),
+	}
+	f.registereintraege[in.AccountID] = append(f.registereintraege[in.AccountID], e)
+	return e, nil
+}
+
+func (f *fakeStore) ListRegistereintraegeForAccount(ctx context.Context, accountID string) ([]store.Registereintrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.registereintraege[accountID], nil
+}
+
 // ─── Test-Setup ───────────────────────────────────────────────────────
 
 // loadTestRegelwerk lädt die echten rules/*.yaml-Dateien — dieselben,
@@ -358,6 +588,31 @@ func seedAccountWithRole(t *testing.T, fs *fakeStore, accountName, email, role s
 	return &http.Cookie{Name: testSessionCookie, Value: token}
 }
 
+// seedUserInAccount legt einen weiteren Nutzer in einem bereits
+// existierenden Account an — für Tests, die mehrere Rollen im selben
+// Mandanten brauchen (z. B. mitarbeiter stellt einen Antrag,
+// verantwortlicher entscheidet darüber).
+func seedUserInAccount(t *testing.T, fs *fakeStore, accountID, email, role string) *http.Cookie {
+	t.Helper()
+	ctx := context.Background()
+	hash, err := auth.HashPassword("test-passwort-123")
+	if err != nil {
+		t.Fatalf("HashPassword: %v", err)
+	}
+	user, err := fs.CreateUser(ctx, accountID, email, hash, role)
+	if err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	token, err := auth.NewSessionToken()
+	if err != nil {
+		t.Fatalf("NewSessionToken: %v", err)
+	}
+	if _, err := fs.CreateSession(ctx, token, user.ID, time.Now().Add(time.Hour)); err != nil {
+		t.Fatalf("CreateSession: %v", err)
+	}
+	return &http.Cookie{Name: testSessionCookie, Value: token}
+}
+
 func seedAccount(t *testing.T, fs *fakeStore, accountName, email string) *http.Cookie {
 	t.Helper()
 	return seedAccountWithRole(t, fs, accountName, email, "mitarbeiter")
@@ -605,7 +860,7 @@ func TestHandleIndexRendersForMitarbeiter(t *testing.T) {
 func TestBetreiberRoutesRejectNonBetreiberWith404(t *testing.T) {
 	s, _, cookie := newAuthedTestServer(t)
 
-	for _, path := range []string{"/betreiber", "/betreiber/accounts", "/betreiber/audit-log"} {
+	for _, path := range []string{"/betreiber", "/betreiber/accounts", "/betreiber/audit-log", "/betreiber/werkzeuge"} {
 		resp := getWithCookie(t, s, cookie, path)
 		if resp.Code != http.StatusNotFound {
 			t.Errorf("GET %s status = %d, want 404 for a non-betreiber user", path, resp.Code)

internal/web/static/app.css

@@ -1,9 +1,10 @@
 /* Deklarix — eigenes, schlankes Stylesheet auf Basis der Design-Tokens
    aus dem enconf Enterprise Light Theme (design/enterprise.css): gleiche
-   Marke (Primärblau #1677ff, Inter, Radius-Skala), aber ohne dessen
+   Marke (Primärblau #1677ff, Inter, Radius-Skala). Mobile-first:
-   Ant-Design-/Desktop-Sidebar-Layout, das für Deklarix nicht passt.
+   Basis-Stile gelten fürs Telefon (Nav als aufklappbares <details>-Menü
-   Mobile-first: Basis-Stile gelten fürs Telefon, @media (min-width)
+   ohne JavaScript), @media (min-width: 960px) verwandelt dieselbe
-   erweitert für größere Bildschirme. */
+   Nav-Markup-Struktur per CSS in eine feste Seitenleiste (siehe
+   .topbar/.app-nav) — kein separates Desktop-Template nötig. */
 
 @import url('/static/inter.css');
 
@@ -14,6 +15,7 @@
   --radius-lg: 10px;
   --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
   --shadow: 0 1px 3px rgba(0, 0, 0, 0.06), 0 1px 2px rgba(0, 0, 0, 0.04);
+  --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.08);
 
   --color-bg: #f8fafc;
   --color-text: #334155;
@@ -27,6 +29,12 @@
   --color-mittel-bg: #fffbeb;
   --color-niedrig: #166534;
   --color-niedrig-bg: #f0fdf4;
+
+  --sidebar-width: 220px;
+  --sidebar-bg: linear-gradient(180deg, #0b1426 0%, #101d33 50%, #0d1829 100%);
+  --sidebar-text: #b6c2d9;
+  --sidebar-text-hover: #ffffff;
+  --sidebar-hover-bg: rgba(255, 255, 255, 0.08);
 }
 
 * {
@@ -74,23 +82,109 @@ a {
   margin: 0 auto;
 }
 
-nav {
+/* ── Navigation ──────────────────────────────────────────────────────
+   Mobil: .topbar ist eine schmale, fixierte Kopfleiste mit einem
+   aufklappbaren <details>-Menü (siehe layout.html) — kein JavaScript,
+   das <details>-Element liefert Auf-/Zuklappen nativ. Ab Desktop-Breite
+   (siehe Media Query unten) wird dieselbe Markup-Struktur per CSS in
+   eine permanent sichtbare, dunkle Seitenleiste verwandelt. */
+.topbar {
+  position: sticky;
+  top: 0;
+  z-index: 10;
   display: flex;
   align-items: center;
-  justify-content: flex-end;
+  justify-content: space-between;
-  gap: 16px;
   padding: 12px 16px;
+  background: #fff;
+  border-bottom: 1px solid var(--color-border);
 }
 
-nav a {
+.brand {
-  color: var(--color-muted);
+  font-weight: 600;
+  color: var(--color-heading);
+  text-decoration: none;
+  letter-spacing: -0.01em;
+}
+
+/* Checkbox-Hack: eine unsichtbare Checkbox plus ein <label for=...>
+   als Klick-/Tap-Ziel steuern per CSS-Geschwister-Selektor, ob .app-nav
+   sichtbar ist — funktioniert ohne JavaScript und ohne die Falle von
+   <details> (siehe Kommentar in layout.html). */
+.nav-toggle {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+}
+
+.nav-toggle-label {
+  cursor: pointer;
+  padding: 8px 14px;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius);
   font-size: 0.875rem;
   font-weight: 500;
+  color: var(--color-text);
+}
+
+.nav-toggle:focus-visible ~ .nav-toggle-label {
+  outline: 2px solid var(--branding-primary);
+  outline-offset: 1px;
+}
+
+.nav-toggle:checked ~ .nav-toggle-label {
+  border-color: var(--branding-primary);
+  color: var(--branding-primary);
+}
+
+.app-nav {
+  display: none;
+  position: absolute;
+  top: calc(100% + 6px);
+  right: 16px;
+  z-index: 20;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 220px;
+  padding: 8px;
+  background: #fff;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  box-shadow: var(--shadow-md);
+}
+
+.nav-toggle:checked ~ .app-nav {
+  display: flex;
+}
+
+.app-nav a {
+  padding: 10px 12px;
+  border-radius: var(--radius);
+  color: var(--color-text);
+  font-size: 0.9375rem;
+  font-weight: 500;
   text-decoration: none;
 }
 
-nav a:hover {
+.app-nav a:hover {
-  color: var(--color-text);
+  background: var(--color-bg);
+  color: var(--branding-primary);
+}
+
+.app-nav form {
+  margin: 4px 0 0;
+}
+
+.app-nav button {
+  width: 100%;
+  margin-top: 0;
+  background: transparent;
+  color: var(--color-hoch);
+  border: 1px solid var(--color-hoch-bg);
+  box-shadow: none;
 }
 
 /* Formulare: großzügige Touch-Ziele (min. 44px Höhe), volle Breite auf
@@ -275,7 +369,12 @@ nav button {
   gap: 8px;
 }
 
-.beitraege-liste li a {
+.beitraege-liste li a,
+/* Einträge ohne umschließenden Link (Zeilen mit Badge/Aktions-Buttons
+   statt Navigation, z. B. Nutzer-/Abteilungsliste) bekommen dieselbe
+   Karte direkt auf dem <li> — :has() unterscheidet beide Fälle, damit
+   ein verlinkter Eintrag nicht doppelt (li UND a) gerahmt wird. */
+.beitraege-liste > li:not(:has(> a)) {
   display: flex;
   flex-wrap: wrap;
   align-items: center;
@@ -288,6 +387,15 @@ nav button {
   text-decoration: none;
 }
 
+.beitraege-liste > li:not(:has(> a)) form {
+  margin: 0;
+  flex: 0 0 auto;
+}
+
+.beitraege-liste > li:not(:has(> a)) button {
+  margin-top: 0;
+}
+
 .beteiligte {
   list-style: none;
   margin: 0 0 16px;
@@ -424,7 +532,45 @@ button.entfernen {
   display: block;
 }
 
-/* Ab hier mehr Platz (Tablet/Desktop) — der Container bekommt spürbaren
+/* Tabellen (z. B. Register-Export-Ansicht) — bewusst horizontal
+   scrollbar in einem eigenen Wrapper statt schrumpfender Spalten: bei
+   neun Spalten wie im Register würde Schrumpfen nur unlesbaren Text
+   erzeugen, siehe .table-scroll in register_liste.html. */
+table {
+  width: 100%;
+  border-collapse: collapse;
+  background: #fff;
+  border-radius: var(--radius-md);
+  overflow: hidden;
+  font-size: 0.875rem;
+}
+
+th, td {
+  padding: 10px 12px;
+  text-align: left;
+  border-bottom: 1px solid var(--color-border);
+  white-space: nowrap;
+}
+
+th {
+  background: var(--color-bg);
+  color: var(--color-heading);
+  font-weight: 600;
+  font-size: 0.8125rem;
+}
+
+tbody tr:hover {
+  background: var(--color-bg);
+}
+
+.table-scroll {
+  overflow-x: auto;
+  box-shadow: var(--shadow);
+  border-radius: var(--radius-md);
+  margin-bottom: 16px;
+}
+
+/* Ab hier mehr Platz (Tablet) — der Container bekommt spürbaren
    Rand statt volle Breite, sonst bleibt alles identisch. */
 @media (min-width: 640px) {
   .page {
@@ -435,3 +581,74 @@ button.entfernen {
     font-size: 1.75rem;
   }
 }
+
+/* Ab Desktop-Breite: dieselbe .topbar/.app-nav-Markup wird zu einer
+   permanent sichtbaren, dunklen Seitenleiste — kein separates
+   Desktop-Template, nur CSS. Der `details`/`summary`-Aufklapp-
+   Mechanismus wird hier überschrieben (Inhalt immer sichtbar,
+   summary versteckt), das Handy-Verhalten bleibt darunter unverändert. */
+@media (min-width: 960px) {
+  .topbar {
+    position: fixed;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    width: var(--sidebar-width);
+    flex-direction: column;
+    align-items: stretch;
+    justify-content: flex-start;
+    gap: 8px;
+    padding: 20px 16px;
+    background: var(--sidebar-bg);
+    border-bottom: none;
+    border-right: 1px solid rgba(255, 255, 255, 0.08);
+    z-index: 10;
+  }
+
+  .brand {
+    color: #fff;
+    font-size: 1.125rem;
+    margin-bottom: 12px;
+  }
+
+  .nav-toggle-label {
+    display: none;
+  }
+
+  .app-nav {
+    display: flex;
+    position: static;
+    min-width: 0;
+    padding: 0;
+    background: transparent;
+    border: none;
+    box-shadow: none;
+  }
+
+  .app-nav a {
+    color: var(--sidebar-text);
+  }
+
+  .app-nav a:hover {
+    background: var(--sidebar-hover-bg);
+    color: var(--sidebar-text-hover);
+  }
+
+  .app-nav button {
+    color: var(--sidebar-text);
+    border-color: rgba(255, 255, 255, 0.15);
+  }
+
+  .app-nav button:hover {
+    background: var(--sidebar-hover-bg);
+    color: var(--sidebar-text-hover);
+    filter: none;
+  }
+
+  .page {
+    margin-left: var(--sidebar-width);
+    max-width: 1100px;
+    padding: 32px 40px;
+    width: 100%;
+  }
+}

internal/web/templates/abteilung_liste.html

@@ -0,0 +1,32 @@
+{{define "abteilung-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Abteilungen</h1>
+<p class="hinweis">Stammdaten für den Fragebogen (Feld "Abteilung").</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+{{if not .Abteilungen}}
+<p class="hinweis">Noch keine Abteilungen.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Abteilungen}}
+  <li>
+    {{.Name}}
+    <form method="post" action="/verwaltung/abteilungen/{{.ID}}/loeschen" style="display:inline" onsubmit="return confirm('Abteilung wirklich löschen?')">
+      <button type="submit" class="entfernen">Löschen</button>
+    </form>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+<form method="post" action="/verwaltung/abteilungen">
+  <label for="name">Neue Abteilung</label>
+  <input type="text" id="name" name="name" required>
+  <button type="submit">Anlegen</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/antrag_detail.html

@@ -14,60 +14,7 @@
 <p><strong>Häufigkeit:</strong> {{.Haeufigkeit}}</p>
 
 {{if .Bewertung}}
-<h2>Bewertung</h2>
+{{template "bewertung-block" .Bewertung}}
-
-{{if .Bewertung.Verboten}}
-<p class="fehler"><strong>Verboten.</strong> Diese Nutzung fällt laut Einstufung unter ein verbotenes KI-Praktiken-Muster der KI-VO ({{.Bewertung.Einstufung}}). {{.Bewertung.EinstufungHerleitung}}</p>
-{{end}}
-
-<p><strong>Datenklasse:</strong> {{.Bewertung.Datenklasse}}<br>
-<span class="hinweis">{{.Bewertung.DatenklasseHerleitung}}</span></p>
-
-<p><strong>KI-VO-Einstufung:</strong> {{.Bewertung.Einstufung}}<br>
-<span class="hinweis">{{.Bewertung.EinstufungHerleitung}}</span></p>
-
-{{if .Bewertung.Anforderungen}}
-<h3>Anforderungen</h3>
-<ul class="findings">
-  {{range .Bewertung.Anforderungen}}
-  <li class="finding finding-mittel">
-    <strong>{{.Beschreibung}}</strong>
-    <p>{{.Herleitung}}</p>
-  </li>
-  {{end}}
-</ul>
-{{end}}
-
-{{if not .Bewertung.Verboten}}
-<h3>Zulässige Werkzeuge</h3>
-{{if .Bewertung.ZulaessigeWerkzeuge}}
-<ul>
-  {{range .Bewertung.ZulaessigeWerkzeuge}}<li>{{.}}</li>{{end}}
-</ul>
-{{else}}
-<p class="rueckfrage">Kein Werkzeug im Katalog erfüllt aktuell alle Anforderungen dieses Antrags.</p>
-{{end}}
-
-{{if .Bewertung.AusgeschlosseneWerkzeuge}}
-<h3>Ausgeschlossene Werkzeuge</h3>
-<ul class="findings">
-  {{range .Bewertung.AusgeschlosseneWerkzeuge}}
-  <li class="finding finding-niedrig">
-    <strong>{{.Name}}</strong>
-    <p>Nicht erfüllt: {{range $i, $a := .NichtErfuellt}}{{if $i}}, {{end}}{{$a}}{{end}}</p>
-  </li>
-  {{end}}
-</ul>
-{{end}}
-{{end}}
-
-<p class="disclaimer">
-  Das System entscheidet nicht. Es bereitet vor. Diese Einstufung ist ein
-  Vorschlag zur Herleitung von Datenklasse, KI-VO-Einstufung und
-  Anforderungen (Regelwerk {{.Bewertung.RegelwerkVersion}}, Katalog
-  {{.Bewertung.KatalogVersion}}, berechnet am {{.Bewertung.CreatedAt}}) —
-  die Entscheidung trifft ein Mensch.
-</p>
 {{else}}
 <p class="hinweis">Die Bewertung wird berechnet, sobald der Antrag eingereicht ist.</p>
 {{end}}

internal/web/templates/betreiber_dashboard.html

@@ -7,6 +7,7 @@
 <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>
 </div>

internal/web/templates/betreiber_werkzeug_form.html

@@ -0,0 +1,65 @@
+{{define "betreiber-werkzeug-form"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="{{.ActionBase}}">&larr; Werkzeugkatalog</a></p>
+<h1>{{.Title}}</h1>
+<p class="hinweis">
+  Jede Zusicherung hier (AVV, Verarbeitungsort, Training-Opt-out,
+  Zertifizierungen) muss belegbar sein — Quelle und letzte Prüfung sind
+  Pflicht.
+</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="{{if .ID}}{{.ActionBase}}/{{.ID}}{{else}}{{.ActionBase}}{{end}}">
+  <label for="name">Name</label>
+  <input type="text" id="name" name="name" value="{{.Name}}" required>
+
+  <label for="anbieter">Anbieter</label>
+  <input type="text" id="anbieter" name="anbieter" value="{{.Anbieter}}" required>
+
+  <fieldset>
+    <legend>Verarbeitungsort</legend>
+    {{$gewaehlt := .Verarbeitungsort}}
+    {{range .Verarbeitungsorte}}
+    <label><input type="radio" name="verarbeitungsort" value="{{.}}" {{if eq . $gewaehlt}}checked{{end}} required> {{.}}</label>
+    {{end}}
+  </fieldset>
+
+  <label><input type="checkbox" name="avv_verfuegbar" {{if .AVVVerfuegbar}}checked{{end}}> AVV verfügbar</label>
+  <label for="avv_url">AVV-URL</label>
+  <input type="text" id="avv_url" name="avv_url" value="{{.AVVURL}}">
+
+  <label><input type="checkbox" name="training_opt_out" {{if .TrainingOptOut}}checked{{end}}> Training-Opt-out möglich</label>
+  <label><input type="checkbox" name="training_standard" {{if .TrainingStandard}}checked{{end}}> Training standardmäßig aus</label>
+
+  <label for="aufbewahrung_tage">Aufbewahrung (Tage)</label>
+  <input type="number" id="aufbewahrung_tage" name="aufbewahrung_tage" min="0" value="{{.AufbewahrungTage}}">
+
+  <label for="zertifizierungen">Zertifizierungen (kommagetrennt)</label>
+  <input type="text" id="zertifizierungen" name="zertifizierungen" value="{{.Zertifizierungen}}">
+
+  <label for="geeignete_zwecke">Geeignete Zwecke (kommagetrennt)</label>
+  <input type="text" id="geeignete_zwecke" name="geeignete_zwecke" value="{{.GeeigneteZwecke}}">
+
+  <label for="einschraenkungen">Einschränkungen (kommagetrennt)</label>
+  <input type="text" id="einschraenkungen" name="einschraenkungen" value="{{.Einschraenkungen}}">
+
+  <label for="letzte_pruefung">Letzte Prüfung</label>
+  <input type="date" id="letzte_pruefung" name="letzte_pruefung" value="{{.LetztePruefung}}" required>
+
+  <label for="quelle">Quelle (Beleg)</label>
+  <input type="text" id="quelle" name="quelle" value="{{.Quelle}}" required>
+
+  <button type="submit">Speichern</button>
+</form>
+{{if .ID}}
+<form method="post" action="/betreiber/werkzeuge/{{.ID}}/loeschen" onsubmit="return confirm('Werkzeug wirklich löschen?')">
+  <button type="submit" class="entfernen">Werkzeug löschen</button>
+</form>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/betreiber_werkzeuge.html

@@ -0,0 +1,26 @@
+{{define "betreiber-werkzeuge"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/betreiber">&larr; Plattform</a></p>
+<h1>Werkzeugkatalog</h1>
+{{if not .Werkzeuge}}
+<p class="hinweis">Noch keine zentralen Katalogeinträge.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Werkzeuge}}
+  <li>
+    <a href="/betreiber/werkzeuge/{{.ID}}">
+      <strong>{{.Name}}</strong> · {{.Anbieter}} · {{.Verarbeitungsort}} · zuletzt geprüft {{.LetztePruefung}}
+    </a>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+<p><a href="/betreiber/werkzeuge/neu">Werkzeug anlegen</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/einladung.html

@@ -0,0 +1,22 @@
+{{define "einladung"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+<div class="page">
+<h1>Einladung annehmen</h1>
+<p class="hinweis">Sie treten dem Konto von <strong>{{.Firmenname}}</strong> bei.</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post">
+  <label for="email">E-Mail</label>
+  <input type="email" id="email" name="email" required>
+
+  <label for="password">Passwort (mind. 8 Zeichen)</label>
+  <input type="password" id="password" name="password" minlength="8" required>
+
+  <button type="submit">Konto anlegen</button>
+</form>
+<p><a href="/login">Schon ein Konto? Anmelden</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/einladung_ungueltig.html

@@ -0,0 +1,12 @@
+{{define "einladung-ungueltig"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+<div class="page">
+<h1>Einladung</h1>
+<p class="fehler">Dieser Einladungslink ist ungültig oder wurde erneuert. Bitte einen aktuellen Link anfragen.</p>
+<p><a href="/login">Zur Anmeldung</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/einladung_verwaltung.html

@@ -0,0 +1,20 @@
+{{define "einladung-verwaltung"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Einladungslink</h1>
+<p class="hinweis">
+  Ein Sammellink für alle Mitarbeitenden — jede Person, die den Link
+  öffnet, kann sich selbst mit eigenem Passwort anmelden (Rolle
+  "mitarbeiter"). Kein Ablaufdatum, aber jederzeit erneuerbar.
+</p>
+<p><input type="text" readonly value="{{.Link}}" onclick="this.select()"></p>
+<form method="post" action="/verwaltung/einladung/erneuern" onsubmit="return confirm('Neuen Link erzeugen? Der alte Link wird dann sofort ungültig.')">
+  <button type="submit" class="entfernen">Link erneuern</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/faelle_liste.html

@@ -0,0 +1,24 @@
+{{define "faelle-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<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>
+  {{end}}
+</ul>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/fall_detail.html

@@ -0,0 +1,60 @@
+{{define "fall-detail"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/faelle">&larr; Posteingang</a></p>
+<h1>{{.Titel}}</h1>
+<p class="hinweis">Eingereicht am {{.CreatedAt}} — Status: <span class="status status-{{.Status}}">{{.Status}}</span></p>
+
+<h2>Vorhaben</h2>
+<p><strong>Was soll die KI tun?</strong><br>{{.Beschreibung}}</p>
+<p><strong>Was soll herauskommen?</strong><br>{{.Ergebnis}}</p>
+<p><strong>Häufigkeit:</strong> {{.Haeufigkeit}}</p>
+
+{{if .Bewertung}}
+{{template "bewertung-block" .Bewertung}}
+{{else}}
+<p class="hinweis">Für diesen Antrag liegt noch keine Bewertung vor.</p>
+{{end}}
+
+{{if .Entscheidung}}
+<h2>Entscheidung</h2>
+<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}}
+{{else if .CanEntscheiden}}
+<h2>Entscheiden</h2>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="/faelle/{{.ID}}/entscheiden">
+  <fieldset>
+    <legend>Entscheidung</legend>
+    <label><input type="radio" name="entscheidung" value="genehmigt" required> Genehmigt</label>
+    <label><input type="radio" name="entscheidung" value="genehmigt_mit_auflagen"> Genehmigt mit Auflagen</label>
+    <label><input type="radio" name="entscheidung" value="abgelehnt"> Abgelehnt</label>
+    <label><input type="radio" name="entscheidung" value="rueckfrage"> Rückfrage</label>
+  </fieldset>
+
+  {{if .WerkzeugOptionen}}
+  <label>Werkzeug (bei Genehmigung erforderlich)
+    <select name="werkzeug_id">
+      <option value="">— auswählen —</option>
+      {{range .WerkzeugOptionen}}<option value="{{.ID}}">{{.Name}}</option>{{end}}
+    </select>
+  </label>
+  {{end}}
+
+  <label>Begründung (Pflicht bei Abweichung vom Vorschlag)
+    <textarea name="begruendung" rows="3"></textarea>
+  </label>
+
+  <button type="submit">Entscheidung speichern</button>
+</form>
+{{else}}
+<p class="hinweis">Noch keine Entscheidung getroffen. Nur die Rolle "Verantwortlicher" kann entscheiden.</p>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/layout.html

@@ -6,13 +6,97 @@
 <script src="/static/htmx.min.js"></script>
 {{end}}
 
+{{/* Eine einzige Nav-Definition für alle Seiten (siehe navData in
+     middleware.go) — auf dem Handy ein aufklappbares Menü (Checkbox-
+     Hack, kein JavaScript: das <details>-Element scheitert daran, dass
+     aktuelle Chromium-Versionen dessen Auf-/Zuklapp-Zustand über eine
+     interne, nicht per CSS überschreibbare Animation steuern), ab
+     Desktop-Breite per CSS in eine permanent sichtbare Seitenleiste
+     verwandelt. Dieselbe Markup-Struktur bedient beide Layouts, siehe
+     app.css .app-nav. Die Checkbox ist bei jedem Seitenaufruf frisch
+     unchecked (serverseitig gerendert, kein Zustand über Navigation
+     hinweg nötig). */}}
 {{define "nav"}}
-<nav>
+<header class="topbar">
+  <a class="brand" href="/">Deklarix</a>
+  <input type="checkbox" id="nav-toggle" class="nav-toggle">
+  <label for="nav-toggle" class="nav-toggle-label" aria-label="Menü öffnen">Menü</label>
+  <nav class="app-nav">
     <a href="/">Start</a>
     {{if not .IsBetreiber}}<a href="/antraege">Meine Anträge</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}}
+    {{if .IsAdmin}}<a href="/verwaltung/nutzer">Nutzerverwaltung</a>{{end}}
+    {{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 .IsBetreiber}}<a href="/betreiber">Plattform</a>{{end}}
-  <form method="post" action="/logout" style="display:inline">
+    <form method="post" action="/logout">
       <button type="submit">Abmelden</button>
     </form>
-</nav>
+  </nav>
+</header>
+{{end}}
+
+{{/* bewertung-block rendert eine Bewertung (Datenklasse, KI-VO-
+     Einstufung, Anforderungen, Werkzeuge, Pflicht-Disclaimer) — gemeinsam
+     genutzt von antrag_detail.html (Ebene 2, nur Ansicht) und
+     fall_detail.html (Ebene 3, mit Entscheiden-Formular). Erwartet eine
+     *bewertungView als . */}}
+{{define "bewertung-block"}}
+<h2>Bewertung</h2>
+
+{{if .Verboten}}
+<p class="fehler"><strong>Verboten.</strong> Diese Nutzung fällt laut Einstufung unter ein verbotenes KI-Praktiken-Muster der KI-VO ({{.Einstufung}}). {{.EinstufungHerleitung}}</p>
+{{end}}
+
+<p><strong>Datenklasse:</strong> {{.Datenklasse}}<br>
+<span class="hinweis">{{.DatenklasseHerleitung}}</span></p>
+
+<p><strong>KI-VO-Einstufung:</strong> {{.Einstufung}}<br>
+<span class="hinweis">{{.EinstufungHerleitung}}</span></p>
+
+{{if .Anforderungen}}
+<h3>Anforderungen</h3>
+<ul class="findings">
+  {{range .Anforderungen}}
+  <li class="finding finding-mittel">
+    <strong>{{.Beschreibung}}</strong>
+    <p>{{.Herleitung}}</p>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+
+{{if not .Verboten}}
+<h3>Zulässige Werkzeuge</h3>
+{{if .ZulaessigeWerkzeuge}}
+<ul>
+  {{range .ZulaessigeWerkzeuge}}<li>{{.}}</li>{{end}}
+</ul>
+{{else}}
+<p class="rueckfrage">Kein Werkzeug im Katalog erfüllt aktuell alle Anforderungen dieses Antrags.</p>
+{{end}}
+
+{{if .AusgeschlosseneWerkzeuge}}
+<h3>Ausgeschlossene Werkzeuge</h3>
+<ul class="findings">
+  {{range .AusgeschlosseneWerkzeuge}}
+  <li class="finding finding-niedrig">
+    <strong>{{.Name}}</strong>
+    <p>Nicht erfüllt: {{range $i, $a := .NichtErfuellt}}{{if $i}}, {{end}}{{$a}}{{end}}</p>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+{{end}}
+
+<p class="disclaimer">
+  Das System entscheidet nicht. Es bereitet vor. Diese Einstufung ist ein
+  Vorschlag zur Herleitung von Datenklasse, KI-VO-Einstufung und
+  Anforderungen (Regelwerk {{.RegelwerkVersion}}, Katalog
+  {{.KatalogVersion}}, berechnet am {{.CreatedAt}}) —
+  die Entscheidung trifft ein Mensch.
+</p>
 {{end}}

internal/web/templates/mandant_werkzeuge.html

@@ -0,0 +1,58 @@
+{{define "mandant-werkzeuge"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Werkzeugkatalog</h1>
+
+<h2>Zentraler Katalog</h2>
+<p class="hinweis">
+  Wird von der Plattform gepflegt. Ein gesperrtes Werkzeug bleibt im
+  zentralen Katalog unverändert — es wird nur für diesen Mandanten aus
+  der Werkzeugsuche ausgeblendet.
+</p>
+{{if not .Werkzeuge}}
+<p class="hinweis">Der zentrale Katalog ist noch leer.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Werkzeuge}}
+  <li>
+    {{.Name}} · {{.Anbieter}}
+    {{if .Gesperrt}}
+    <span class="status">gesperrt</span>
+    <form method="post" action="/verwaltung/werkzeuge/{{.ID}}/entsperren" style="display:inline">
+      <button type="submit">Entsperren</button>
+    </form>
+    {{else}}
+    <form method="post" action="/verwaltung/werkzeuge/{{.ID}}/sperren" style="display:inline">
+      <input type="text" name="grund" placeholder="Grund (optional)">
+      <button type="submit">Sperren</button>
+    </form>
+    {{end}}
+  </li>
+  {{end}}
+</ul>
+{{end}}
+
+<h2>Eigene Werkzeuge</h2>
+<p class="hinweis">
+  Zusätzliche Katalogeinträge nur für diesen Mandanten — sichtbar nur
+  hier, nicht im zentralen Katalog der Plattform.
+</p>
+{{if not .EigeneWerkzeuge}}
+<p class="hinweis">Noch keine eigenen Werkzeuge.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .EigeneWerkzeuge}}
+  <li>
+    <a href="/verwaltung/werkzeuge/{{.ID}}">{{.Name}} · {{.Anbieter}}</a>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+<p><a href="/verwaltung/werkzeuge/neu">Eigenes Werkzeug anlegen</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/nutzer_import.html

@@ -0,0 +1,27 @@
+{{define "nutzer-import"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/verwaltung/nutzer">&larr; Nutzerverwaltung</a></p>
+<h1>Mitarbeiter per CSV importieren</h1>
+<p class="hinweis">
+  CSV mit Kopfzeile, Pflichtspalte "email", optionale Spalte "role"
+  (mitarbeiter/verantwortlicher/pruefer/admin — Standard: mitarbeiter).
+  Es gibt keine Einladungsmail: nach dem Import wird pro Zeile ein
+  Einmalpasswort angezeigt, das nur DIESES EINE MAL sichtbar ist — bitte
+  auf dieser Seite kopieren und sicher weitergeben, bevor sie
+  geschlossen wird.
+</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="/verwaltung/nutzer/import" enctype="multipart/form-data">
+  <label for="csv">CSV-Datei</label>
+  <input type="file" id="csv" name="csv" accept=".csv,text/csv" required>
+
+  <button type="submit">Importieren</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/nutzer_import_ergebnis.html

@@ -0,0 +1,33 @@
+{{define "nutzer-import-ergebnis"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Import-Ergebnis</h1>
+<p class="fehler">
+  Die Einmalpasswörter unten werden nach dieser Seite nirgendwo mehr
+  angezeigt — jetzt kopieren und sicher weitergeben.
+</p>
+<div class="table-scroll">
+<table>
+  <thead>
+    <tr><th>Zeile</th><th>E-Mail</th><th>Rolle</th><th>Ergebnis</th></tr>
+  </thead>
+  <tbody>
+    {{range .Ergebnisse}}
+    <tr>
+      <td>{{.Zeile}}</td>
+      <td>{{.Email}}</td>
+      <td>{{if .Fehler}}—{{else}}{{.Role}}{{end}}</td>
+      <td>{{if .Fehler}}<span class="fehler">{{.Fehler}}</span>{{else}}<code>{{.Passwort}}</code>{{end}}</td>
+    </tr>
+    {{end}}
+  </tbody>
+</table>
+</div>
+<p><a href="/verwaltung/nutzer">Zur Nutzerverwaltung</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/nutzer_liste.html

@@ -0,0 +1,32 @@
+{{define "nutzer-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Nutzerverwaltung</h1>
+<ul class="beitraege-liste">
+  {{range .Nutzer}}
+  <li>
+    {{.Email}} <span class="status">{{.Role}}</span>
+    {{if .Active}}
+    <span class="status status-published">aktiv</span>
+    {{if not .IstSelbst}}
+    <form method="post" action="/verwaltung/nutzer/{{.ID}}/deaktivieren" style="display:inline">
+      <button type="submit" class="entfernen">Deaktivieren</button>
+    </form>
+    {{end}}
+    {{else}}
+    <span class="status">deaktiviert</span>
+    <form method="post" action="/verwaltung/nutzer/{{.ID}}/aktivieren" style="display:inline">
+      <button type="submit">Aktivieren</button>
+    </form>
+    {{end}}
+  </li>
+  {{end}}
+</ul>
+<p><a href="/verwaltung/nutzer/neu">Nutzer anlegen</a> · <a href="/verwaltung/nutzer/import">Per CSV importieren</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/nutzer_neu.html

@@ -0,0 +1,33 @@
+{{define "nutzer-neu"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/verwaltung/nutzer">&larr; Nutzerverwaltung</a></p>
+<h1>Nutzer anlegen</h1>
+<p class="hinweis">
+  Es gibt noch keine Einladungsmail — das hier gesetzte Passwort muss
+  auf einem anderen Weg an die neue Person weitergegeben werden.
+</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="/verwaltung/nutzer">
+  <label for="email">E-Mail</label>
+  <input type="email" id="email" name="email" required>
+
+  <label for="password">Initialpasswort (mind. 8 Zeichen)</label>
+  <input type="password" id="password" name="password" minlength="8" required>
+
+  <fieldset>
+    <legend>Rolle</legend>
+    {{range .Rollen}}
+    <label><input type="radio" name="role" value="{{.}}" required> {{.}}</label>
+    {{end}}
+  </fieldset>
+
+  <button type="submit">Nutzer anlegen</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/register_liste.html

@@ -0,0 +1,40 @@
+{{define "register-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<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>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/wiedervorlage_liste.html

@@ -0,0 +1,29 @@
+{{define "wiedervorlage-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<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>
+{{if not .Eintraege}}
+<p class="keine-findings">Nichts zur Wiedervorlage.</p>
+{{else}}
+<ul class="findings">
+  {{range .Eintraege}}
+  <li class="finding finding-mittel">
+    <strong><a href="/faelle/{{.AntragID}}">{{.Titel}}</a></strong>{{if .Werkzeug}} — {{.Werkzeug}}{{end}}
+    <ul>
+      {{range .Gruende}}<li>{{.}}</li>{{end}}
+    </ul>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/wiedervorlage_handlers.go

@@ -0,0 +1,104 @@
+// Ebene 3 — Wiedervorlage (Schritt 7 der Baureihenfolge, siehe
+// CLAUDE.md). Eine aktive Genehmigung muss erneut geprüft werden, wenn
+// entweder ihr Ablaufdatum erreicht/nah ist, oder sich im Katalog eine
+// Eigenschaft geändert hat, auf der sie beruhte. Es gibt keine E-Mail-
+// Infrastruktur — "Benachrichtigung" ist v1 eine In-App-Liste, kein
+// Versand.
+package web
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+// wiedervorlageSchwelle: eine Genehmigung erscheint schon vor ihrem
+// Ablauf in der Wiedervorlage, damit der/die Verantwortliche Zeit zum
+// Reagieren hat.
+const wiedervorlageSchwelle = 30 * 24 * time.Hour
+
+// werkzeugDiff vergleicht den zum Entscheidungszeitpunkt eingefrorenen
+// Werkzeug-Snapshot mit dem aktuellen Katalogstand und benennt jede für
+// die Bewertung relevante Eigenschaft, die sich seitdem geändert hat.
+func werkzeugDiff(snapshot, current store.Werkzeug) []string {
+	var diffs []string
+	if snapshot.AVVVerfuegbar != current.AVVVerfuegbar {
+		diffs = append(diffs, fmt.Sprintf("AVV verfügbar: %v → %v", snapshot.AVVVerfuegbar, current.AVVVerfuegbar))
+	}
+	if snapshot.TrainingStandard != current.TrainingStandard {
+		diffs = append(diffs, fmt.Sprintf("Training standardmäßig aus: %v → %v", snapshot.TrainingStandard, current.TrainingStandard))
+	}
+	if snapshot.Verarbeitungsort != current.Verarbeitungsort {
+		diffs = append(diffs, fmt.Sprintf("Verarbeitungsort: %s → %s", snapshot.Verarbeitungsort, current.Verarbeitungsort))
+	}
+	return diffs
+}
+
+type wiedervorlageItem struct {
+	AntragID string
+	Titel    string
+	Werkzeug string
+	Gruende  []string
+}
+
+type wiedervorlageListeData struct {
+	Title     string
+	Nav       navData
+	Eintraege []wiedervorlageItem
+}
+
+// handleWiedervorlageListe zeigt alle aktiven Genehmigungen des
+// Mandanten, die erneut geprüft werden sollten — abgelaufen/bald
+// ablaufend oder mit einem seither im Katalog geänderten Werkzeug.
+// Genehmigungen ohne Grund zur Wiedervorlage werden nicht gezeigt.
+func (s *Server) handleWiedervorlageListe(w http.ResponseWriter, r *http.Request) {
+	entscheidungen, err := s.store.ListAktiveGenehmigungenForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Genehmigungen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var data wiedervorlageListeData
+	data.Title, data.Nav = "Wiedervorlage", navFor(r)
+	for _, e := range entscheidungen {
+		var gruende []string
+
+		if e.GueltigBis != nil {
+			if time.Now().After(*e.GueltigBis) {
+				gruende = append(gruende, "Genehmigung ist abgelaufen (seit "+e.GueltigBis.Format("02.01.2006")+")")
+			} else if time.Until(*e.GueltigBis) < wiedervorlageSchwelle {
+				gruende = append(gruende, "Genehmigung läuft am "+e.GueltigBis.Format("02.01.2006")+" ab")
+			}
+		}
+
+		werkzeugName := ""
+		if e.WerkzeugID != nil {
+			current, err := s.store.GetWerkzeug(r.Context(), *e.WerkzeugID)
+			if err != nil {
+				gruende = append(gruende, "Werkzeug wurde aus dem Katalog entfernt")
+			} else {
+				werkzeugName = current.Name
+				if e.WerkzeugSnapshot != nil {
+					gruende = append(gruende, werkzeugDiff(*e.WerkzeugSnapshot, current)...)
+				}
+			}
+		}
+
+		if len(gruende) == 0 {
+			continue
+		}
+		antrag, err := s.store.GetAntrag(r.Context(), e.AntragID)
+		if err != nil {
+			continue
+		}
+		data.Eintraege = append(data.Eintraege, wiedervorlageItem{
+			AntragID: antrag.ID, Titel: antrag.Titel, Werkzeug: werkzeugName, Gruende: gruende,
+		})
+	}
+
+	if err := s.templates.ExecuteTemplate(w, "wiedervorlage-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}

internal/web/wiedervorlage_handlers_test.go

@@ -0,0 +1,95 @@
+package web_test
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestWiedervorlageZeigtAbgelaufeneGenehmigung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+
+	var antragID string
+	for id, a := range fs.antraege {
+		if a.AccountID == accountID {
+			antragID = id
+		}
+	}
+	es := fs.entscheidungen[antragID]
+	abgelaufen := time.Now().Add(-24 * time.Hour)
+	es[len(es)-1].GueltigBis = &abgelaufen
+	fs.entscheidungen[antragID] = es
+
+	prueferCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+	resp := getWithCookie(t, s, prueferCookie, "/wiedervorlage")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "abgelaufen") {
+		t.Errorf("expected the abgelaufene Genehmigung to appear, got: %s", resp.Body.String())
+	}
+}
+
+func TestWiedervorlageZeigtGeaenderteWerkzeugeigenschaft(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+
+	wz := fs.werkzeuge["werkzeug-ok"]
+	wz.AVVVerfuegbar = false // Katalog hat sich seit der Genehmigung geändert
+	fs.werkzeuge["werkzeug-ok"] = wz
+
+	prueferCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+	resp := getWithCookie(t, s, prueferCookie, "/wiedervorlage")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "AVV verfügbar") {
+		t.Errorf("expected the changed AVV property to be flagged, got: %s", resp.Body.String())
+	}
+}
+
+func TestWiedervorlageZeigtEntferntesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+	delete(fs.werkzeuge, "werkzeug-ok")
+
+	prueferCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+	resp := getWithCookie(t, s, prueferCookie, "/wiedervorlage")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "aus dem Katalog entfernt") {
+		t.Errorf("expected the removed werkzeug to be flagged, got: %s", resp.Body.String())
+	}
+}
+
+func TestWiedervorlageIstLeerOhneAenderung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	accountID := genehmigeFall(t, fs, s)
+
+	prueferCookie := seedUserInAccount(t, fs, accountID, "reviewer@example.com", "pruefer")
+	resp := getWithCookie(t, s, prueferCookie, "/wiedervorlage")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Nichts zur Wiedervorlage") {
+		t.Errorf("expected no entries when nothing changed, got: %s", resp.Body.String())
+	}
+}
+
+func TestMitarbeiterCannotAccessWiedervorlage(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/wiedervorlage")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter", resp.Code)
+	}
+}