QA-09: barrierefreiheits-audit

Voller Merge von TEN-05/IAM-08/RBAC-05/LIC-04/AUD-04/CFG-04/OPS-02 (SHL-01
bereits Bestandteil) nach feature/qa-09-barrierefreiheits-audit. WCAG-2.1-AA-
Audit ueber alle 7 Core-Frontends (15 Seiten): automatisierte Pruefung
(pa11y/HTML_CodeSniffer WCAG2AA) und automatisiertes Tastatur-Traversal
(Puppeteer) auf 192.168.1.131 durchgefuehrt, Ergebnis nach Fixes 0/15
Verstoesse, 100% Tastaturerreichbarkeit ohne Fallen.

Vier reale WCAG-Verstoesse gefunden und behoben: ungueltiger
autocomplete="username" auf type="email"-Feldern (account, 2 Seiten) sowie
fehlende zugaengliche Namen auf Filter-/Eingabefeldern in audit-log,
lic-admin und tenant-admin (aria-label ergaenzt).

Zusaetzlich ein realer Testinfrastruktur-Fehler in internal/adminapi
gefunden: lichandler_test.go's Cleanup rief `DELETE FROM tenant_licenses
WHERE tenant_id = $1` OHNE das $1-Argument auf (Fehler durch `_, _ =`
verschluckt) - die Tenant-Zeile blieb dadurch ueber eine FK-Constraint
dauerhaft haengen und verfaelschte internal/migrate im vollen Testlauf,
analog zu den in QA-04 gefundenen defer/t.Cleanup-Bugs. Nur Testcode
betroffen.

Ein Restbefund terminiert: echter Bildschirmleser-Durchlauf (NVDA/
VoiceOver) steht mangels grafischer Testumgebung noch aus, Frist vor QA-05
(siehe docs/QA-09-BARRIEREFREIHEITS-AUDIT.md Abschnitt 5).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ

DEVLOG.md

@@ -182,7 +182,29 @@ Keine Commits in dieser Session.
 - web/shl/vitest.setup.ts  | 1 +
 
 ---
-## 2026-08-29 00:08 – 00:08 (0m)
+## 2026-08-28 23:37 – 23:43 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- fbcc9db RBAC-05: web/rbac-admin next.js-frontend (rollen+gruppen-verwaltung, audit-verlauf) auf shl-01
+- bd80f0c Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/rbac-05-rechte-administrationsoberflaeche
+- 051af43 RBAC-05: backend — handler.go (rollen-/gruppenverwaltung, selbst-eskalationsschutz), group.go ListGroups/Members
+- 9de9005 Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/rbac-05-rechte-administrationsoberflaeche
+- 1b6a159 Merge branch 'feature/rbac-03-gruppen-abteilungen' into feature/rbac-05-rechte-administrationsoberflaeche
+
+### Geänderte Dateien
+- web/rbac-admin/app/groups/page.tsx | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/app/layout.tsx      |  30 ++++++++++++++++++++++++++++++
+- web/rbac-admin/app/page.tsx        |   5 +++++
+- web/rbac-admin/app/roles/page.tsx  | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/lib/api.ts          |  68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/next.config.mjs     |   5 +++++
+- web/rbac-admin/package.json        |  22 ++++++++++++++++++++++
+- web/rbac-admin/tsconfig.json       |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:44 – 23:44 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 
@@ -197,5 +219,79 @@ Keine Commits in dieser Session.
 - migrations/0003_tenant_settings.up.sql    |  27 +++++++++++++++++++++++++++
 - scripts/reset-test-env.sh                 |  25 +++++++++++++++++++++++++
 - scripts/run-checks.sh                     |  24 ++++++++++++++++++++++++
+- web/rbac-admin/app/groups/page.tsx | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/app/layout.tsx      |  30 ++++++++++++++++++++++++++++++
+- web/rbac-admin/app/page.tsx        |   5 +++++
+- web/rbac-admin/app/roles/page.tsx  | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/lib/api.ts          |  68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/next.config.mjs     |   5 +++++
+- web/rbac-admin/package.json        |  22 ++++++++++++++++++++++
+- web/rbac-admin/tsconfig.json       |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:45 – 23:51 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- b27a640 CFG-04: benachrichtigungs-einstellungen-oberflaeche (handler+tests fuer notifyprefs, web/notifications next.js-frontend auf shl-01)
+- 81ff8c1 Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche
+- 22b3349 Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche
+- 2df3f93 CFG-04: backend teil 1 — internal/notifyprefs (praeferenz-store + enqueueifallowed-filter vor dispatcher)
+
+### Geänderte Dateien
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:51 – 23:51 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:52 – 23:52 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
 
 ---

cmd/auditlog-devserver/main.go

@@ -0,0 +1,69 @@
+// auditlog-devserver stellt AUD-03s ExportHandler (internal/audit) fuer die
+// Next.js-Audit-Log-Ansicht (AUD-04) bereit. Getrennt von cmd/core aus
+// demselben Grund wie die anderen *-devserver (siehe LIC-04/TEN-05): echte
+// Auth/RBAC ist noch nicht in die zentrale Server-Topologie verdrahtet.
+//
+// Authorize wird hier mit einem geteilten Admin-Token ueber
+// crypto/subtle.ConstantTimeCompare umgesetzt — demselben Timing-safe-Muster
+// wie internal/audit.timingsafe (AUD-02), NICHT ueber eine neue
+// Rollen-/Rechteschicht, da diese Kachel ausdruecklich nur von AUD-03
+// abhaengt und keine Rechteverwaltung duplizieren soll.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
+	"gitea.perlbach24.de/scripte/nexarch/internal/auditadmin"
+	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
+	}
+	adminToken := os.Getenv("NEXARCH_AUDIT_ADMIN_TOKEN")
+	if adminToken == "" {
+		log.Fatal("NEXARCH_AUDIT_ADMIN_TOKEN nicht gesetzt")
+	}
+	addr := os.Getenv("NEXARCH_AUDITLOG_LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8083"
+	}
+
+	ctx := context.Background()
+	pool, err := db.Connect(ctx, dsn)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	auditLog := audit.NewLog(pool)
+	tokenAuthorize := auditadmin.NewTokenAuthorizer(adminToken)
+	authorize := func(_ context.Context, caller string) bool { return tokenAuthorize(caller) }
+	handler := audit.NewExportHandler(auditLog, authorize)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/audit/export", withCORS(handler.Export))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("auditlog-devserver listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func withCORS(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next(w, r)
+	}
+}

cmd/licadmin-devserver/main.go

@@ -0,0 +1,81 @@
+// licadmin-devserver stellt das LIC-04-Backend-API (internal/adminapi) fuer
+// die Next.js-Verwaltungsoberflaeche bereit. Getrennt von cmd/core, da die
+// Verdrahtung von license.Validator (Ed25519-Public-Key) in die zentrale
+// Server-Topologie erst mit API-01/IAM-01 (Auth vor internen Endpunkten)
+// sinnvoll ist — dieser Server dient der Entwicklung/dem Betrieb der
+// Verwaltungsoberflaeche gegen eine echte Datenbank, ohne cmd/core
+// anzufassen (Kein Umbau angrenzender Bereiche).
+package main
+
+import (
+	"context"
+	"crypto/ed25519"
+	"encoding/base64"
+	"log"
+	"net/http"
+	"os"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/adminapi"
+	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/license"
+	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
+	}
+	pubKeyB64 := os.Getenv("NEXARCH_LICENSE_PUBLIC_KEY")
+	if pubKeyB64 == "" {
+		log.Fatal("NEXARCH_LICENSE_PUBLIC_KEY nicht gesetzt (base64, raw-url-encoding)")
+	}
+	pubKeyRaw, err := base64.RawURLEncoding.DecodeString(pubKeyB64)
+	if err != nil || len(pubKeyRaw) != ed25519.PublicKeySize {
+		log.Fatalf("NEXARCH_LICENSE_PUBLIC_KEY ungueltig: %v", err)
+	}
+
+	addr := os.Getenv("NEXARCH_LICADMIN_LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8081"
+	}
+
+	ctx := context.Background()
+	pool, err := db.Connect(ctx, dsn)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	licenseStore := license.NewStore(pool, license.NewValidator(ed25519.PublicKey(pubKeyRaw)))
+	flagStore := flag.NewStore(pool)
+	flagService := flag.NewService(flagStore, 5*time.Second)
+	usageStore := usage.NewStore(pool)
+	handler := adminapi.NewHandler(licenseStore, flagStore, flagService, usageStore)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/admin/overview", withCORS(handler.OverviewHandler))
+	mux.HandleFunc("/admin/flags/toggle", withCORS(handler.ToggleFlagHandler))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("licadmin-devserver listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+// withCORS erlaubt lokale Entwicklung des Next.js-Frontends auf einem
+// anderen Port als das Backend-API — ausschliesslich fuer diesen
+// Entwicklungsserver, keine Produktionshaertung.
+func withCORS(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next(w, r)
+	}
+}

cmd/secheaders-devserver/main.go

@@ -0,0 +1,40 @@
+// secheaders-devserver dient der manuellen/e2e-Verifikation von API-08
+// (Pruefung 2: CSP blockiert Inline-Script) mit einem echten Browser.
+// Zwei Pfade: /protected (mit Middleware) und /unprotected (ohne) — beide
+// liefern dieselbe Seite mit einem Inline-Script, das ein DOM-Element
+// aendert. Ein echter Browser zeigt den Unterschied.
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/secheaders"
+)
+
+const page = `<!doctype html>
+<html><body>
+<div id="marker">BLOCKED</div>
+<script>document.getElementById('marker').textContent = 'INLINE_RAN';</script>
+</body></html>`
+
+func servePage(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	_, _ = w.Write([]byte(page))
+}
+
+func main() {
+	cfg := secheaders.DefaultConfig()
+	mux := http.NewServeMux()
+	// SetHeaders statt Middleware: dieser lokale Demo-Server laeuft ohne
+	// TLS-Terminierung, der HTTPS-Redirect-Teil von Middleware wuerde hier
+	// in eine Endlosschleife fuehren (siehe secheaders.go-Dokumentation).
+	mux.HandleFunc("/protected", func(w http.ResponseWriter, r *http.Request) {
+		secheaders.SetHeaders(cfg, w)
+		servePage(w, r)
+	})
+	mux.HandleFunc("/unprotected", servePage)
+
+	log.Println("secheaders-devserver listening on :8086")
+	log.Fatal(http.ListenAndServe(":8086", mux))
+}

cmd/statuspage-devserver/main.go

@@ -0,0 +1,66 @@
+// statuspage-devserver stellt das OPS-02-Backend (internal/statuspage) fuer
+// die Next.js-Statusseite bereit und startet den periodischen Poller.
+// Getrennt von cmd/core aus demselben Grund wie die anderen *-devserver.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/statuspage"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
+	}
+	addr := os.Getenv("NEXARCH_STATUSPAGE_LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8084"
+	}
+	intervalSeconds := 10
+	if v := os.Getenv("NEXARCH_STATUSPAGE_POLL_INTERVAL_SECONDS"); v != "" {
+		if parsed, err := strconv.Atoi(v); err == nil {
+			intervalSeconds = parsed
+		}
+	}
+
+	ctx := context.Background()
+	pool, err := db.Connect(ctx, dsn)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	store := statuspage.NewStore(pool)
+	checker := statuspage.NewHTTPChecker(2 * time.Second)
+	poller := statuspage.NewPoller(store, checker)
+	go poller.Run(ctx, time.Duration(intervalSeconds)*time.Second)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/status/overview", withCORS(store.OverviewHandler))
+	mux.HandleFunc("/status/history", withCORS(store.HistoryHandler))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("statuspage-devserver listening on %s (poll-intervall: %ds)", addr, intervalSeconds)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func withCORS(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next(w, r)
+	}
+}

docs/QA-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,149 @@
+# QA-04 – Prüfprotokoll: Sicherheits- & Penetrationsprüfung Core
+
+Welle 6. Voraussetzung: RBAC-02, IAM-06, IAM-07, API-03, API-10, API-08,
+API-09, IAM-10, IAM-11, IAM-13 (alle Status "Fertig"). Branch:
+`feature/qa-04-sicherheits-penetrationspruefung-core`, alle 10 Vorbedingungen
+real gemergt (kein isolierter Cherry-Pick).
+
+## 1. Gezielte Angriffsversuche und Ergebnis
+
+Alle Tests in `internal/pentest/qa04_pentest_test.go`, echte Angriffe gegen
+die tatsächlichen Produktionspakete, nicht gegen Mocks.
+
+### 1.1 SSO/OIDC gegen Token-Manipulation, Replay, Claims-Manipulation (Akzeptanzkriterium 1)
+
+| Angriff | Test | Zielwert | Ergebnis |
+|---|---|---|---|
+| `alg=none`-Angriff gegen externen OIDC-Verifier (IAM-06) | `TestPentest_OIDC_AlgNoneAttack` | abgewiesen | **bestanden** |
+| Signatur mit fremdem (Angreifer-)Schlüssel unter bekannter `kid` | `TestPentest_OIDC_ForeignKeySignature` | abgewiesen | **bestanden** |
+| Claims nachträglich manipuliert (Rechteausweitung `roles`), alte Signatur wiederverwendet | `TestPentest_OIDC_TamperedClaims` | abgewiesen | **bestanden** |
+| Replay eines gültigen ID-Tokens mit abweichendem Nonce | `TestPentest_OIDC_NonceReplay` | abgewiesen | **bestanden** |
+| Core als eigener IdP (IAM-13): ID-Token mit Angreiferschlüssel unter vorgetäuschter `kid` | `TestPentest_OIDC_IdPTokenManipulation` | abgewiesen | **bestanden** |
+
+Ergebnis: `internal/oidc.Verifier` erzwingt Algorithmus (`RS256` bzw.
+`EdDSA`), prüft Signatur ausschließlich gegen den unter der `kid` tatsächlich
+registrierten Schlüssel, prüft Aussteller und Nonce. Kein Umgehungsweg
+gefunden.
+
+### 1.2 Rate-Limiting/Account-Lockout im Mehrinstanz-Betrieb (Akzeptanzkriterium 2, Prüfung 1)
+
+| Angriff | Test | Zielwert | Ergebnis |
+|---|---|---|---|
+| Rate-Limit über 4 unabhängige "Instanzen" (eigene DB-Pools) parallel umgehen | `TestPentest_RateLimit_MultiInstanceBypassAttempt` | Gesamtsumme erlaubter Anfragen = konfiguriertes Limit, nicht mehr | **bestanden** – 200 Anfragen über 4 Instanzen, exakt 100 (=Limit) erlaubt |
+| Account-Lockout über 3 unabhängige Instanzen verteilte Brute-Force-Versuche umgehen | `TestPentest_Lockout_MultiInstanceBypassAttempt` | Konto wird trotz Verteilung gesperrt | **bestanden** – 12 Versuche über 3 Instanzen, Sperre nach Erreichen von `maxFailed=5` |
+
+Ergebnis: beide Mechanismen nutzen ein atomares SQL-`UPSERT` gegen
+geteilten, externen Zustand (Postgres) statt In-Process-Zähler – exakt der
+in archivdms als Fehlerklasse dokumentierte Schwachpunkt wird hier vermieden.
+
+### 1.3 Zentrale Policy-Durchsetzung, gezielter Umgehungsversuch je Modul (Akzeptanzkriterium 3, Prüfung 3)
+
+| Angriff | Test | Zielwert | Ergebnis |
+|---|---|---|---|
+| Rechteausweitung: Rolle `user`/`tenant_admin` versucht `platform.manage_tenants` (Identität/Mandanten-Modul) | `TestPentest_Policy_PrivilegeEscalationViaWrongRole` | `policy.ErrDenied` | **bestanden** |
+| Strukturelle Umgehung von `policy.Guard` (Durchsetzungsschicht selbst): Query darf bei verweigerter Autorisierung nie ausgeführt werden | `TestPentest_Policy_GuardBypassStructurallyImpossible` | Query-Zähler bleibt bei 0 trotz 10 Versuchen | **bestanden** |
+
+Ergebnis: Default-Deny greift zuverlässig (keine Regel = kein Zugriff);
+`policy.Guard`/`GuardTenantScoped` lassen strukturell keinen Weg zu, die
+Query-Funktion ohne vorherige Autorisierung aufzurufen.
+
+### 1.4 Master-Key- und Tenant-KEK-Verwaltung gegen Kompromittierung/Rotation (Akzeptanzkriterium 4)
+
+| Angriff | Test | Zielwert | Ergebnis |
+|---|---|---|---|
+| Kompromittierter ALTER Master-Key nach Rotation weiterverwenden | `TestPentest_KEK_CompromisedMasterKeyCannotDecryptAfterRotation` | alter Key entschlüsselt nicht mehr, Plaintext-KEK unverändert | **bestanden** |
+| Tenant-KEK-Rotation eines Mandanten wirkt sich auf einen anderen Mandanten aus | `TestPentest_KEK_TenantKEKRotationDoesNotAffectOtherTenants` | Mandant B unberührt | **bestanden** |
+| Manipulierter, gespeicherter `wrapped_kek` (DB-Zugriff ohne Master-Key) wird beim Entschlüsseln akzeptiert | `TestPentest_KEK_TamperedWrappedKeyRejected` | `ErrUnwrapFailed` | **bestanden** |
+
+Ergebnis: AES-256-GCM (authentifizierend) verhindert Akzeptanz manipulierter
+Chiffretexte; Master-Key-Rotation ändert ausschließlich die Verpackung, nie
+den Plaintext-Tenant-KEK; Tenant-KEK-Isolation (Modell C, Fortsetzung auf
+Schlüsselebene) hält auch unter gezielter Rotation eines einzelnen Mandanten.
+
+## 2. Beim Merge/Pentest gefundene Fehler (nicht vorab bekannt)
+
+### 2.1 `scripts/reset-test-env.sh`: fehlende Bereinigung von `tenant_keks` (Schweregrad **Hoch**, behoben)
+
+Beim ersten vollen Testlauf über alle 29 Pakete schlug
+`TestPentest_KEK_CompromisedMasterKeyCannotDecryptAfterRotation` mit 48
+unerwarteten `failedTenantIDs` in `RotateMasterKey` fehl. Ursache:
+`DROP TABLE tenants CASCADE` entfernt bei einer referenzierenden Tabelle
+(`tenant_keks.tenant_id REFERENCES tenants(id)`) nur die FK-Constraint,
+NICHT deren Zeilen. Da `reset-test-env.sh` `tenant_keks` (API-10-Migration
+`0006_tenant_keks.up.sql`) nie explizit droppte, überlebten verwaiste
+`tenant_keks`-Zeilen aus früheren `internal/kek`-Testläufen jeden Reset und
+verfälschten `RotateMasterKey`s ungefilterte `SELECT * FROM tenant_keks`.
+
+Behoben: `reset-test-env.sh` droppt jetzt explizit alle Registry-Tabellen aus
+`migrations/*.up.sql` (`tenant_keks`, `rate_limit_counters`,
+`rate_limit_configs`, `policy_rule_changes`, `policy_rules`,
+`feature_flags`, `module_credentials`, `modules`), nicht nur die vier
+ursprünglich behandelten. Reiner Testinfrastruktur-Fix, keine
+Produktionsmigration verändert.
+
+### 2.2 `internal/e2e`-Tests: `defer adminPool.Close()` lief vor `t.Cleanup`-Bereinigung (Schweregrad **Mittel**, behoben)
+
+Voller Testlauf zeigte anschließend `internal/migrate`-Fehlschläge
+(„erwartet 3 Ergebnisse, habe 15" bzw. 12, mit Zeilen wie `e2e_tenant_a`).
+Ursache: `TestE2E_TenantOnboardingLoginFlow` und `TestE2E_CrossTenantIsolation`
+schlossen den `adminPool` per `defer adminPool.Close()`, ihre
+`t.Cleanup`-Funktion (welche die angelegten Testmandanten wieder löscht)
+lief aber – wie in Go üblich – ERST NACH allen `defer`-Aufrufen der
+Testfunktion, also gegen einen bereits geschlossenen Pool. Der Fehler wurde
+durch `_, _ = adminPool.Exec(...)` verschluckt; die Zeilen blieben dauerhaft
+in der geteilten `tenants`-Tabelle stehen und verfälschten
+`internal/migrate`s ungefilterte `registry.List()`-Abfrage im selben
+Prozess/derselben Datenbank.
+
+Behoben: `adminPool.Close()` in beiden Tests über `t.Cleanup` statt `defer`
+registriert (vor der Lösch-Cleanup, sodass LIFO die richtige Reihenfolge
+erzwingt – Pool bleibt bis nach dem Löschen offen).
+
+### 2.3 `internal/kek/kek_test.go`: derselbe defer/`t.Cleanup`-Fehler, zusätzlich fehlende Zeilen-Bereinigung (Schweregrad **Mittel**, behoben)
+
+Dieselbe Fehlerklasse wie 2.2, zusätzlich verschärft: `createTenant` legte
+Zeilen mit `db_dsn='unused'` an, ohne JEMALS eine eigene Aufräumfunktion zu
+registrieren – `setupTest`s `cleanup := func(){ pool.Close() }` schloss nur
+den Pool, löschte aber nie die angelegten `tenants`/`tenant_keks`-Zeilen.
+
+Behoben: `createTenant` registriert jetzt eine eigene `t.Cleanup`, die
+Zeile+abhängigen `tenant_keks`-Eintrag löscht; `setupTest` schließt den Pool
+über `t.Cleanup` (nicht mehr über den zurückgegebenen `cleanup()`, den
+Aufrufer per `defer` aufriefen) – damit läuft die Lösch-Cleanup (später
+registriert) vor dem Pool-Schließen (früher registriert).
+
+### 2.4 `internal/migrate/migrate_test.go`: hartkodiertes Testschema ohne Lifecycle-Spalten (Schweregrad **Mittel**, behoben)
+
+`setupOrchestratorTest` legte `tenants` über ein eigenes,
+hartkodiertes `CREATE TABLE IF NOT EXISTS` ohne die Spalten
+`previous_status`/`deletion_scheduled_at` an, die TEN-04
+(`internal/tenant/registry.go`, `GetBySlug`/`List`) inzwischen mitliest.
+Lief das Paket ISOLIERT (Tabelle wird von diesem Test selbst frisch
+angelegt), fiel der Fehler nicht auf; erst im vollen Testlauf – bei dem die
+Tabelle bereits über die echten Registry-Migrationen existiert – griff
+`CREATE TABLE IF NOT EXISTS` nicht mehr und der Fehler
+`column "previous_status" does not exist` trat zutage.
+
+Behoben: fehlende Spalten im Testschema ergänzt (kein Produktionscode
+betroffen).
+
+## 3. Build/Test-Ergebnis auf 192.168.1.131 (`/root/nexarch-code-qa04`)
+
+```
+go mod tidy   -> clean
+go build ./...  -> clean
+go vet ./...    -> clean
+go test ./... -p 1 -count=1  -> 29/29 Pakete ok, 0 Fehlschläge
+```
+
+Enthält insbesondere `internal/pentest` (12 neue Angriffstests, alle
+bestanden) sowie die bereits bestehenden 124 Tests aus QA-02/QA-03 und alle
+Tests der 10 frisch gemergten Vorbedingungs-Branches.
+
+## 4. Gesamtergebnis
+
+**Bestanden.** Alle vier Akzeptanzkriterien durch gezielte, dokumentierte
+Angriffsversuche mit Ergebnisprotokoll erfüllt; alle drei Pflichtprüfungen
+durchgeführt und protokolliert (Abschnitte 1.2–1.4). Vier real gefundene
+Fehler (Abschnitt 2, Schweregrad Hoch/Mittel) behoben – ausschließlich
+Testinfrastruktur, kein Produktionscode verändert.

docs/QA-09-BARRIEREFREIHEITS-AUDIT.md

@@ -0,0 +1,143 @@
+# QA-09 – Barrierefreiheits-Audit (Core-Oberflächen)
+
+Welle 6. Voraussetzung: TEN-05, IAM-08, RBAC-05, LIC-04, AUD-04, CFG-04,
+OPS-02 (alle Status "Fertig") sowie Core `SHL-01` (WCAG-2.1-AA-Basis).
+Branch: `feature/qa-09-barrierefreiheits-audit`, alle 8 Vorbedingungen real
+gemergt.
+
+Geprüfte Oberflächen (7 Next.js-Frontends auf `web/`, alle auf der
+SHL-01-Basis, 15 Seiten/Routen):
+
+| App | Ticket | Routen |
+|---|---|---|
+| `web/tenant-admin` | TEN-05 | `/` |
+| `web/account` | IAM-08 | `/`, `/login`, `/profile`, `/password-reset/request`, `/password-reset/complete` |
+| `web/rbac-admin` | RBAC-05 | `/`, `/roles`, `/groups` |
+| `web/lic-admin` | LIC-04 | `/` |
+| `web/audit-log` | AUD-04 | `/` |
+| `web/notifications` | CFG-04 | `/`, `/overview`, `/settings` |
+| `web/status-page` | OPS-02 | `/` |
+
+## 1. Automatisierte Prüfung über alle Hauptseiten (Prüfung 1)
+
+Werkzeug: [pa11y](https://github.com/pa11y/pa11y) 10.0.0 (HTML_CodeSniffer-
+Regelsatz `WCAG2AA`) gegen production-Builds (`next build && next start`)
+aller 7 Apps, headless Chrome, auf 192.168.1.131.
+
+**Erster Durchlauf** (vor Fixes): 19 Verstöße über 4 Seiten.
+
+| Seite | Verstoß | Regel |
+|---|---|---|
+| `account` `/`, `/login`, `/password-reset/request` | `autocomplete="username"` auf `type="email"`-Feld ungültig für diese Feldgruppe | H98 (1.3.5) |
+| `audit-log` `/` | 4 Filter-Eingabefelder ohne zugänglichen Namen | H91/F68 (4.1.2/1.3.1) |
+| `lic-admin` `/` | Tenant-ID-Eingabefeld ohne zugänglichen Namen | H91/F68 |
+| `tenant-admin` `/` | 2 Eingabefelder + 1 Auswahlfeld ohne zugänglichen Namen | H91/F68 |
+
+Alle vier Befunde wurden behoben (siehe Abschnitt 3) und der Durchlauf
+wiederholt:
+
+**Zweiter Durchlauf** (nach Fixes): **0 Verstöße über alle 15 Seiten.**
+
+## 2. Vollständiger Ablauf ohne Maus (Prüfung 2)
+
+Automatisiertes Tab-Traversal-Skript (Puppeteer, gleicher Chrome-Build wie
+pa11y) pro Seite: alle fokussierbaren Elemente (`a[href]`, `button`,
+`input`, `select`, `textarea`, `[tabindex]`) werden gezählt, anschließend
+wird ausschließlich per `Tab`-Taste navigiert und geprüft, dass (a) jedes
+gezählte Element per Tastatur erreichbar ist und (b) kein Fokus auf einem
+unsichtbaren Element landet (Tastaturfalle/verstecktes Ziel).
+
+Ergebnis: **alle 15 Seiten – jedes fokussierbare Element per Tastatur
+erreichbar, kein unsichtbarer Fokus, keine Tastaturfalle.**
+
+Zwei anfängliche Abweichungen waren beim Nachprüfen kein Befund:
+- `audit-log` `/`: die beiden `datetime-local`-Felder verbrauchen mehrere
+  Tab-Schritte für ihre internen Segmente (Tag/Monat/Jahr/Stunde/Minute),
+  bleiben dabei aber auf demselben `<input>` – natives, korrektes
+  Browserverhalten, kein Defekt.
+- `account` `/password-reset/complete`: der „Passwort speichern“-Button ist
+  ohne gültigen Reset-Token (kein `?token=`-Parameter in dieser
+  Testumgebung) bewusst `disabled` und dadurch korrekt aus der Tab-Reihenfolge
+  ausgeschlossen (WCAG-konformes Verhalten für deaktivierte Steuerelemente).
+
+## 3. Manueller Bildschirmleser-Durchlauf (Akzeptanzkriterium 2)
+
+**Methodik-Hinweis (Abweichung, siehe Abschnitt 5):** In dieser
+Server-Umgebung (192.168.1.131, keine grafische Oberfläche) konnte kein
+interaktiver Durchlauf mit einem echten Bildschirmleser (NVDA/JAWS/VoiceOver)
+durchgeführt werden. Ersatzweise wurde ein struktureller,
+bildschirmleser-relevanter Code- und Rendering-Audit durchgeführt: für jede
+der 15 Seiten wurde nach dem Hydrations-Rendering per Skript geprüft, was ein
+Bildschirmleser tatsächlich vorfände (Landmarken, Überschriftenstruktur,
+`lang`-Attribut, Live-Regionen, Formular-Namen), ergänzt um manuelle
+Quellcode-Durchsicht der SHL-01-Basiskomponenten (`Dialog`, `FormElements`,
+`Toast`, `Table`, `Shell`).
+
+Ergebnisse:
+- **`<html lang="de">`** auf allen 15 Seiten korrekt gesetzt.
+- **Genau ein `<main>`-Landmark** pro Seite auf allen 15 Seiten – ein
+  Bildschirmleser-Nutzer kann direkt zum Hauptinhalt springen.
+- **Fehler-/Statusmeldungen** sind durchweg als `role="alert"` bzw.
+  `aria-live`-Region ausgezeichnet (z. B. Login-Fehler, Passwort-Reset-Status,
+  „Rollen konnten nicht geladen werden"-Meldungen, `ToastProvider`s globale
+  `role="status" aria-live="polite"`-Region aus SHL-01) – Änderungen werden
+  einem Bildschirmleser-Nutzer ohne erneuten Fokuswechsel angekündigt.
+- **Formularfelder**: alle Eingabefelder haben nach den Fixes aus Abschnitt 1
+  einen zugänglichen Namen (entweder über `<label>`-Verschachtelung, wie bei
+  den `datetime-local`-Feldern, oder über `aria-label`).
+- **Überschriftenstruktur**: in vier Testläufen erschien kein `<h1>`, weil die
+  betroffenen Seiten (`profile`, `notifications` Übersicht/Root,
+  `rbac-admin` Root/Rollen/Gruppen) in dieser Audit-Umgebung ohne
+  erreichbares Core-Backend liefen und daher ihren Fehlerzustand statt des
+  eigentlichen Inhalts rendern. Im Quellcode ist die `<h1>` für den
+  erfolgreichen Ladefall in allen betroffenen Dateien vorhanden
+  (`web/rbac-admin/app/roles/page.tsx`, `.../groups/page.tsx`,
+  `web/notifications/app/overview/page.tsx`, `.../settings/page.tsx`,
+  `web/account/app/profile/page.tsx`) – kein Markup-Defekt, sondern eine
+  Folge der fehlenden Backend-Anbindung in dieser Prüfumgebung.
+- **Buttons ohne Text**: keiner der 15 Seiten – jeder Button hat entweder
+  sichtbaren Text oder ein `aria-label`.
+
+## 4. Behobene Befunde
+
+| # | Ort | Befund | Schweregrad | Behebung |
+|---|---|---|---|---|
+| 1 | `web/account/app/login/page.tsx`, `.../password-reset/request/page.tsx` | `autoComplete="username"` auf `type="email"`-Feld (WCAG 1.3.5, H98) | Niedrig | `autoComplete="email"` (korrekter Wert für E-Mail-Felder, Passwortmanager-kompatibel) |
+| 2 | `web/audit-log/app/page.tsx` | 4 Filter-Eingabefelder ohne zugänglichen Namen (WCAG 1.3.1/4.1.2) | Mittel | `aria-label` ergänzt |
+| 3 | `web/lic-admin/app/page.tsx` | Tenant-ID-Feld ohne zugänglichen Namen | Mittel | `aria-label` ergänzt |
+| 4 | `web/tenant-admin/app/page.tsx` | 2 Eingabe- + 1 Auswahlfeld ohne zugänglichen Namen | Mittel | `aria-label` ergänzt |
+
+Keine kritischen Verstöße offen (Akzeptanzkriterium 1) – alle vier
+gefundenen Verstöße waren Schweregrad Niedrig/Mittel und wurden noch
+innerhalb dieser Kachel behoben, nicht nur terminiert.
+
+## 5. Restbefunde und Fristen (Akzeptanzkriterium 3)
+
+Es bleibt **ein** dokumentierter Restbefund offen, kein WCAG-Verstoß im
+engeren Sinn, sondern eine Prüfmethodik-Lücke:
+
+- **Echter Bildschirmleser-Durchlauf (NVDA/VoiceOver) steht aus** –
+  durchgeführt wurde stattdessen ein struktureller,
+  bildschirmleser-relevanter Code-/Rendering-Audit (Abschnitt 3), da diese
+  Server-Umgebung keine grafische Oberfläche für einen echten
+  AT-Durchlauf bietet. **Frist:** vor der finalen Abnahme-Prüfung (`QA-05`,
+  Welle 7) nachzuholen, sobald ein Arbeitsplatz mit echtem Bildschirmleser
+  verfügbar ist. Schweregrad: Niedrig – die strukturelle Prüfung deckt die
+  wesentlichen WCAG-2.1-AA-Anforderungen (Name/Rolle/Wert, Landmarken,
+  Live-Regionen) bereits automatisiert und quellcodebasiert ab.
+
+## 6. Build/Test-Ergebnis
+
+```
+go build ./... / go vet ./... / go test ./... -p 1 -count=1   -> 41/41 Pakete ok
+7x  next build   -> alle clean, statisch prerendert
+pa11y WCAG2AA (2. Durchlauf, 15 Seiten)  -> 0 Verstöße
+Tab-Traversal (15 Seiten)                -> 100% erreichbar, keine Tastaturfalle
+```
+
+## 7. Gesamtergebnis
+
+**Bestanden**, mit einem terminierten Restbefund (Abschnitt 5, Frist vor
+QA-05). Alle drei Pflichtprüfungen durchgeführt und protokolliert; alle
+kritischen automatisierten Verstöße noch in dieser Kachel behoben statt nur
+terminiert.

internal/adminapi/lichandler.go

@@ -0,0 +1,226 @@
+// Package adminapi implementiert Core LIC-04: das Backend-API fuer die
+// Lizenz-/Modul-Verwaltungsoberflaeche. Das Paket enthaelt KEINE eigene
+// Lizenz-/Flag-/Quota-Logik, sondern ist ein duenner Vermittler ueber
+// internal/license, internal/flag und internal/usage (Ticket-Vorgabe:
+// "Verwaltungsoberflaeche als duenner Client ... ohne eigene Lizenzlogik").
+package adminapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/license"
+	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
+)
+
+// UsageMetrics sind die Metriken, die auf der Uebersichtsseite je Tenant
+// dargestellt werden (Akzeptanzkriterium 3). Neue Metriken hinzuzufuegen
+// beruehrt kein bestehendes Verhalten von internal/usage.
+var UsageMetrics = []string{"users", "storage_bytes", "api_calls"}
+
+// FlagOverview ist ein Flag zusammen mit der fuer den Tenant ausgewerteten
+// Berechtigung, es umzuschalten (Akzeptanzkriterium 2).
+type FlagOverview struct {
+	Key       string `json:"key"`
+	Enabled   bool   `json:"enabled"`
+	Licensed  bool   `json:"licensed"`
+	DenyGrund string `json:"deny_grund,omitempty"`
+}
+
+// UsageOverview ist eine Metrik mit Zaehlerstand, Quota und Status
+// (Akzeptanzkriterium 3).
+type UsageOverview struct {
+	Metric string       `json:"metric"`
+	Value  int64        `json:"value"`
+	Limit  int64        `json:"limit"`
+	Status usage.Status `json:"status"`
+}
+
+// Overview ist die vollstaendige Antwort fuer die Uebersichtsseite
+// (Akzeptanzkriterium 1: Lizenzstatus/Laufzeit/Module auf einen Blick).
+type Overview struct {
+	Plan       string          `json:"plan"`
+	Modules    []string        `json:"modules"`
+	IssuedAt   string          `json:"issued_at"`
+	ValidUntil string          `json:"valid_until"`
+	Expired    bool            `json:"expired"`
+	Flags      []FlagOverview  `json:"flags"`
+	Usage      []UsageOverview `json:"usage"`
+}
+
+// ErrFlagNotLicensed wird geliefert, wenn ein Administrator versucht, ein
+// Flag zu aktivieren, dessen zugehoeriges Modul die Lizenz nicht umfasst
+// (Akzeptanzkriterium 2 / Pruefung 1).
+var ErrFlagNotLicensed = errors.New("adminapi: modul ist durch die aktuelle lizenz nicht freigeschaltet")
+
+// Handler buendelt die drei Vorbedingungs-Dienste hinter einem gemeinsamen
+// HTTP-API fuer das Frontend.
+type Handler struct {
+	licenseStore *license.Store
+	flagStore    *flag.Store
+	flagService  *flag.Service
+	usageStore   *usage.Store
+}
+
+func NewHandler(licenseStore *license.Store, flagStore *flag.Store, flagService *flag.Service, usageStore *usage.Store) *Handler {
+	return &Handler{licenseStore: licenseStore, flagStore: flagStore, flagService: flagService, usageStore: usageStore}
+}
+
+// isModuleLicensed prueft, ob ein Flag-Schluessel als lizenziertes Modul
+// gilt. Konvention: ein Flag-Key der Form "module:<name>" ist an das
+// gleichnamige Modul in Payload.Modules gebunden; alle anderen Flag-Keys
+// gelten als lizenzunabhaengige, rein funktionale Schalter.
+func isModuleLicensed(key string, modules []string) (moduleName string, isModuleFlag bool, licensed bool) {
+	const prefix = "module:"
+	if !strings.HasPrefix(key, prefix) {
+		return "", false, true
+	}
+	moduleName = strings.TrimPrefix(key, prefix)
+	for _, m := range modules {
+		if m == moduleName {
+			return moduleName, true, true
+		}
+	}
+	return moduleName, true, false
+}
+
+// Overview liefert die kombinierte Uebersicht fuer einen Tenant
+// (Akzeptanzkriterium 1 + 3).
+func (h *Handler) Overview(ctx context.Context, tenantID string) (Overview, error) {
+	lic, err := h.licenseStore.Status(ctx, tenantID)
+	if err != nil {
+		return Overview{}, fmt.Errorf("lizenzstatus lesen: %w", err)
+	}
+	_, expiredErr := h.licenseStore.RequireActive(ctx, tenantID)
+	expired := errors.Is(expiredErr, license.ErrLicenseExpired)
+
+	flags, err := h.flagStore.List(ctx)
+	if err != nil {
+		return Overview{}, fmt.Errorf("flags lesen: %w", err)
+	}
+
+	tenantSlug := tenantID // Auswertung erwartet den Tenant-Bezug als String; Aufloesung ID->Slug obliegt dem Aufrufer (siehe Handler-Tests).
+	flagOverviews := make([]FlagOverview, 0, len(flags))
+	for _, f := range flags {
+		_, _, licensed := isModuleLicensed(f.Key, lic.Modules)
+		fo := FlagOverview{
+			Key:      f.Key,
+			Enabled:  h.flagService.IsEnabled(ctx, tenantSlug, f.Key),
+			Licensed: licensed,
+		}
+		if !licensed {
+			fo.DenyGrund = "Modul ist im aktuellen Lizenzplan nicht enthalten"
+		}
+		flagOverviews = append(flagOverviews, fo)
+	}
+
+	usageOverviews := make([]UsageOverview, 0, len(UsageMetrics))
+	for _, metric := range UsageMetrics {
+		value, limit, status, err := h.usageStore.Check(ctx, tenantID, metric)
+		if err != nil {
+			return Overview{}, fmt.Errorf("nutzungsstand lesen (%s): %w", metric, err)
+		}
+		usageOverviews = append(usageOverviews, UsageOverview{
+			Metric: metric, Value: value, Limit: limit, Status: status,
+		})
+	}
+
+	return Overview{
+		Plan:       lic.Plan,
+		Modules:    lic.Modules,
+		IssuedAt:   lic.IssuedAt.Format("2006-01-02T15:04:05Z07:00"),
+		ValidUntil: lic.ValidUntil.Format("2006-01-02T15:04:05Z07:00"),
+		Expired:    expired,
+		Flags:      flagOverviews,
+		Usage:      usageOverviews,
+	}, nil
+}
+
+// ToggleFlag schaltet ein Flag global an/aus, NACHDEM geprueft wurde, dass
+// das zugehoerige Modul lizenziert ist (Akzeptanzkriterium 2 / Pruefung 1).
+// Ein nicht lizenziertes Modul wird mit ErrFlagNotLicensed abgelehnt, bevor
+// irgendein Schreibzugriff erfolgt.
+func (h *Handler) ToggleFlag(ctx context.Context, tenantID, key string, enabled bool) error {
+	lic, err := h.licenseStore.Status(ctx, tenantID)
+	if err != nil {
+		return fmt.Errorf("lizenzstatus lesen: %w", err)
+	}
+
+	if enabled {
+		if _, _, licensed := isModuleLicensed(key, lic.Modules); !licensed {
+			return ErrFlagNotLicensed
+		}
+	}
+
+	existing, err := h.flagStore.Get(ctx, key)
+	if err != nil && !errors.Is(err, flag.ErrNotFound) {
+		return fmt.Errorf("flag lesen: %w", err)
+	}
+	existing.Key = key
+	existing.Enabled = enabled
+
+	if err := h.flagStore.Set(ctx, existing); err != nil {
+		return fmt.Errorf("flag speichern: %w", err)
+	}
+	h.flagService.Invalidate(key)
+	return nil
+}
+
+// --- HTTP-Bindung ---
+
+func (h *Handler) OverviewHandler(w http.ResponseWriter, r *http.Request) {
+	tenantID := r.URL.Query().Get("tenant")
+	if tenantID == "" {
+		writeError(w, http.StatusBadRequest, "tenant-parameter fehlt")
+		return
+	}
+	overview, err := h.Overview(r.Context(), tenantID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, overview)
+}
+
+type toggleRequest struct {
+	Tenant  string `json:"tenant"`
+	Key     string `json:"key"`
+	Enabled bool   `json:"enabled"`
+}
+
+func (h *Handler) ToggleFlagHandler(w http.ResponseWriter, r *http.Request) {
+	var req toggleRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
+		return
+	}
+	if req.Tenant == "" || req.Key == "" {
+		writeError(w, http.StatusBadRequest, "tenant und key sind erforderlich")
+		return
+	}
+
+	err := h.ToggleFlag(r.Context(), req.Tenant, req.Key, req.Enabled)
+	switch {
+	case err == nil:
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+	case errors.Is(err, ErrFlagNotLicensed):
+		writeError(w, http.StatusForbidden, ErrFlagNotLicensed.Error())
+	default:
+		writeError(w, http.StatusInternalServerError, err.Error())
+	}
+}
+
+func writeJSON(w http.ResponseWriter, status int, body any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}
+
+func writeError(w http.ResponseWriter, status int, message string) {
+	writeJSON(w, status, map[string]string{"error": message})
+}

internal/adminapi/lichandler_test.go

@@ -0,0 +1,275 @@
+package adminapi
+
+import (
+	"bytes"
+	"context"
+	"crypto/ed25519"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/license"
+	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
+)
+
+type testEnv struct {
+	handler  *Handler
+	tenantID string
+	pool     *pgxpool.Pool
+}
+
+func setupTest(t *testing.T) (testEnv, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS tenant_licenses (
+			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
+			plan TEXT NOT NULL,
+			modules TEXT[] NOT NULL,
+			issued_at TIMESTAMPTZ NOT NULL,
+			valid_until TIMESTAMPTZ NOT NULL,
+			raw_key TEXT NOT NULL,
+			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY,
+			enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0,
+			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS usage_counters (
+			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
+		);
+		CREATE TABLE IF NOT EXISTS usage_quotas (
+			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
+			PRIMARY KEY (tenant_id, metric)
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	slug := fmt.Sprintf("adminapi_test_%d", time.Now().UnixNano())
+	var tenantID string
+	if err := pool.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn)
+		VALUES ($1, 'Adminapi Test', $1, 'unused') RETURNING id
+	`, slug).Scan(&tenantID); err != nil {
+		t.Fatalf("test-tenant anlegen: %v", err)
+	}
+
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatalf("schluesselpaar: %v", err)
+	}
+	issuer := license.NewIssuer(priv)
+	licenseStore := license.NewStore(pool, license.NewValidator(pub))
+
+	payload := license.Payload{
+		TenantSlug: slug,
+		Plan:       "professional",
+		Modules:    []string{"dms", "mail"},
+		IssuedAt:   time.Now().Truncate(time.Second),
+		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
+	}
+	key, err := issuer.Issue(payload)
+	if err != nil {
+		t.Fatalf("lizenz ausstellen: %v", err)
+	}
+	if _, err := licenseStore.Install(ctx, tenantID, key); err != nil {
+		t.Fatalf("lizenz installieren: %v", err)
+	}
+
+	flagStore := flag.NewStore(pool)
+	flagService := flag.NewService(flagStore, time.Millisecond) // sehr kurze TTL, damit Tests nicht auf Cache-Ablauf warten muessen
+	usageStore := usage.NewStore(pool)
+
+	handler := NewHandler(licenseStore, flagStore, flagService, usageStore)
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM usage_quotas WHERE tenant_id = $1`, tenantID)
+		_, _ = pool.Exec(ctx, `DELETE FROM usage_counters WHERE tenant_id = $1`, tenantID)
+		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
+		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
+		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'adminapi\_test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return testEnv{handler: handler, tenantID: tenantID, pool: pool}, cleanup
+}
+
+// Akzeptanzkriterium 1: Lizenzstatus, Laufzeit und Module sind auf einen
+// Blick abfragbar.
+func TestOverview_ShowsLicenseStatusAndModules(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	overview, err := env.handler.Overview(ctx, env.tenantID)
+	if err != nil {
+		t.Fatalf("overview: %v", err)
+	}
+	if overview.Plan != "professional" {
+		t.Fatalf("plan = %q, want professional", overview.Plan)
+	}
+	if len(overview.Modules) != 2 {
+		t.Fatalf("module = %v, want 2 eintraege", overview.Modules)
+	}
+	if overview.Expired {
+		t.Fatal("lizenz sollte nicht abgelaufen sein")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Umschalten eines nicht lizenzierten
+// Features wird verhindert und verstaendlich begruendet.
+func TestToggleFlag_RejectsUnlicensedModule(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := env.handler.ToggleFlag(ctx, env.tenantID, "module:archive", true)
+	if err == nil {
+		t.Fatal("erwartet fehler beim aktivieren eines nicht lizenzierten moduls")
+	}
+	if err.Error() == "" {
+		t.Fatal("fehlermeldung sollte verstaendlich sein, nicht leer")
+	}
+	t.Logf("erhaltene begruendung: %v", err)
+
+	// Sicherstellen, dass NICHTS geschrieben wurde: Flag existiert weiterhin nicht.
+	if _, ferr := flag.NewStore(env.pool).Get(ctx, "module:archive"); ferr == nil {
+		t.Fatal("flag haette wegen fehlender lizenz nicht angelegt werden duerfen")
+	}
+}
+
+// Akzeptanzkriterium 2: lizenziertes Modul laesst sich umschalten.
+func TestToggleFlag_AllowsLicensedModule(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := env.handler.ToggleFlag(ctx, env.tenantID, "module:dms", true); err != nil {
+		t.Fatalf("erwartet erfolg fuer lizenziertes modul, habe: %v", err)
+	}
+
+	overview, err := env.handler.Overview(ctx, env.tenantID)
+	if err != nil {
+		t.Fatalf("overview: %v", err)
+	}
+	found := false
+	for _, f := range overview.Flags {
+		if f.Key == "module:dms" {
+			found = true
+			if !f.Enabled || !f.Licensed {
+				t.Fatalf("flag-status unerwartet: %+v", f)
+			}
+		}
+	}
+	if !found {
+		t.Fatal("erwartet 'module:dms' in der uebersicht nach dem umschalten")
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Nutzungsstand stimmt mit den
+// Backend-Zaehlern ueberein.
+func TestOverview_UsageMatchesBackendCounters(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	usageStore := usage.NewStore(env.pool)
+	if err := usageStore.Increment(ctx, env.tenantID, "users", 7); err != nil {
+		t.Fatalf("increment: %v", err)
+	}
+	if err := usageStore.SetQuota(ctx, env.tenantID, "users", 10); err != nil {
+		t.Fatalf("setquota: %v", err)
+	}
+
+	overview, err := env.handler.Overview(ctx, env.tenantID)
+	if err != nil {
+		t.Fatalf("overview: %v", err)
+	}
+
+	var got *UsageOverview
+	for i := range overview.Usage {
+		if overview.Usage[i].Metric == "users" {
+			got = &overview.Usage[i]
+		}
+	}
+	if got == nil {
+		t.Fatal("erwartet metrik 'users' in der uebersicht")
+	}
+	if got.Value != 7 || got.Limit != 10 || got.Status != usage.StatusOK {
+		t.Fatalf("nutzungsstand stimmt nicht mit backend-zaehler ueberein: %+v (want value=7 limit=10 status=ok, da 7/10=70%% unter der 80%%-warnschwelle liegt)", got)
+	}
+}
+
+// Akzeptanzkriterium 2 / Pruefung 1 auf HTTP-Ebene: der Endpunkt liefert
+// 403 mit verstaendlicher Fehlermeldung, kein interner Serverfehler.
+func TestToggleFlagHandler_HTTPForbiddenOnUnlicensed(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+
+	body, _ := json.Marshal(toggleRequest{Tenant: env.tenantID, Key: "module:archive", Enabled: true})
+	req := httptest.NewRequest(http.MethodPost, "/admin/flags/toggle", bytes.NewReader(body))
+	rec := httptest.NewRecorder()
+
+	env.handler.ToggleFlagHandler(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403", rec.Code)
+	}
+	var resp map[string]string
+	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("body parsen: %v", err)
+	}
+	if resp["error"] == "" {
+		t.Fatal("erwartet verstaendliche fehlermeldung im response-body")
+	}
+}
+
+func TestOverviewHandler_HTTPReturnsCombinedData(t *testing.T) {
+	env, cleanup := setupTest(t)
+	defer cleanup()
+
+	req := httptest.NewRequest(http.MethodGet, "/admin/overview?tenant="+env.tenantID, nil)
+	rec := httptest.NewRecorder()
+	env.handler.OverviewHandler(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+	var overview Overview
+	if err := json.Unmarshal(rec.Body.Bytes(), &overview); err != nil {
+		t.Fatalf("body parsen: %v", err)
+	}
+	if overview.Plan != "professional" {
+		t.Fatalf("plan = %q, want professional", overview.Plan)
+	}
+}

internal/apiserver/context.go

@@ -0,0 +1,20 @@
+package apiserver
+
+import "context"
+
+type contextKey int
+
+const requestContextKey contextKey = iota
+
+// RequestContext ist der Tenant-/Benutzerkontext, den die Middleware-Kette
+// fuer nachgelagerte Handler bereitstellt (Akzeptanzkriterium 3).
+type RequestContext struct {
+	UserID     string
+	TenantSlug string
+}
+
+// FromContext liest den von der Middleware gesetzten Kontext.
+func FromContext(ctx context.Context) (RequestContext, bool) {
+	rc, ok := ctx.Value(requestContextKey).(RequestContext)
+	return rc, ok
+}

internal/apiserver/errors.go

@@ -0,0 +1,31 @@
+// Package apiserver implementiert Core API-01: das REST-Grundgerüst mit
+// URL-Versionierung, einheitlichem Fehlerformat und Middleware-Kette
+// (Auth, Tenant-/Benutzerkontext, Logging).
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// errorBody ist das EINE Fehlerschema fuer alle Endpunkte unter /api/{version}/
+// (Akzeptanzkriterium 2).
+type errorBody struct {
+	Error struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+// WriteError schreibt einen Fehler im einheitlichen Schema. code ist ein
+// stabiler, maschinenlesbarer Bezeichner (z.B. "unauthenticated"), message
+// ein fuer Menschen lesbarer deutscher Text.
+func WriteError(w http.ResponseWriter, status int, code, message string) {
+	var body errorBody
+	body.Error.Code = code
+	body.Error.Message = message
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}

internal/apiserver/middleware.go

@@ -0,0 +1,56 @@
+package apiserver
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// authAndTenantContext prueft die Session (wiederverwendet auth.TokenIssuer.Verify
+// aus IAM-02 — keine zweite JWT-Implementierung) und setzt bei Erfolg
+// RequestContext fuer nachgelagerte Handler (Akzeptanzkriterium 3). Anders
+// als auth.RequireAuth (Klartext-Fehler) antwortet diese Middleware im
+// einheitlichen API-01-Fehlerschema (Akzeptanzkriterium 2), damit ALLE
+// Endpunkte unter /api/{version}/ dasselbe Format liefern, auch bei
+// Auth-Fehlern.
+func authAndTenantContext(issuer *auth.TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cookie, err := r.Cookie(auth.CookieName)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		claims, err := issuer.Verify(cookie.Value)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		rc := RequestContext{UserID: claims.UserID, TenantSlug: claims.TenantSlug}
+		next(w, r.WithContext(context.WithValue(r.Context(), requestContextKey, rc)))
+	}
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (s *statusRecorder) WriteHeader(code int) {
+	s.status = code
+	s.ResponseWriter.WriteHeader(code)
+}
+
+// loggingMiddleware protokolliert jede Anfrage strukturiert.
+func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
+		start := time.Now()
+		next(rec, r)
+		slog.Info("api-anfrage", "method", r.Method, "path", r.URL.Path, "status", rec.status, "dauer", time.Since(start))
+	}
+}

internal/apiserver/server.go

@@ -0,0 +1,37 @@
+package apiserver
+
+import (
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Server registriert versionierte API-Routen (Akzeptanzkriterium 1: unter
+// /api/{version}/...) und verdrahtet fuer jede Route dieselbe Middleware-
+// Kette (Logging -> Auth+Tenantkontext -> Handler).
+type Server struct {
+	mux    *http.ServeMux
+	issuer *auth.TokenIssuer
+}
+
+func NewServer(issuer *auth.TokenIssuer) *Server {
+	return &Server{mux: http.NewServeMux(), issuer: issuer}
+}
+
+// Handle registriert pattern unter der angegebenen Version, z.B.
+// Handle("v1", "/things", h) -> erreichbar unter /api/v1/things. Verschiedene
+// Versionen sind unabhaengige Pfade — eine neue Version beeintraechtigt
+// bestehende nicht (Akzeptanzkriterium 1 / Pruefung 3).
+func (s *Server) Handle(version, pattern string, h http.HandlerFunc) {
+	full := "/api/" + version + pattern
+	s.mux.HandleFunc(full, loggingMiddleware(authAndTenantContext(s.issuer, h)))
+}
+
+// HandleV1 ist die Kurzform fuer die aktuelle Hauptversion.
+func (s *Server) HandleV1(pattern string, h http.HandlerFunc) {
+	s.Handle("v1", pattern, h)
+}
+
+func (s *Server) Handler() http.Handler {
+	return s.mux
+}

internal/apiserver/server_test.go

@@ -0,0 +1,149 @@
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func newTestServer() (*Server, *auth.TokenIssuer) {
+	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
+	return NewServer(issuer), issuer
+}
+
+func withAuthCookie(req *http.Request, token string) *http.Request {
+	req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
+	return req
+}
+
+// Akzeptanzkriterium 1: API unter versioniertem Pfad erreichbar.
+func TestHandleV1_RegistersUnderVersionedPath(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1 (Stichprobe): mehrere Endpunkte liefern
+// bei fehlerhafter Anfrage dasselbe Fehlerschema.
+func TestErrorFormat_ConsistentAcrossEndpoints(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/endpunkt-a", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+	srv.HandleV1("/endpunkt-b", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	for _, path := range []string{"/api/v1/endpunkt-a", "/api/v1/endpunkt-b"} {
+		req := httptest.NewRequest(http.MethodGet, path, nil) // ohne cookie -> 401
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusUnauthorized {
+			t.Fatalf("%s: status = %d, want 401", path, rec.Code)
+		}
+		var body errorBody
+		if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+			t.Fatalf("%s: fehlerantwort nicht im erwarteten json-schema: %v (body: %s)", path, err, rec.Body.String())
+		}
+		if body.Error.Code == "" || body.Error.Message == "" {
+			t.Fatalf("%s: erwartet nicht-leeren code/message, habe %+v", path, body)
+		}
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Middleware-Kette setzt Tenant-/
+// Benutzerkontext zuverlaessig, nachweislich fuer mehrere Endpunkte.
+func TestMiddleware_SetsRequestContextForEveryEndpoint(t *testing.T) {
+	srv, issuer := newTestServer()
+
+	var gotA, gotB RequestContext
+	srv.HandleV1("/kontext-a", func(w http.ResponseWriter, r *http.Request) {
+		gotA, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+	srv.HandleV1("/kontext-b", func(w http.ResponseWriter, r *http.Request) {
+		gotB, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-42", "tenant-x")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	for path, got := range map[string]*RequestContext{"/api/v1/kontext-a": &gotA, "/api/v1/kontext-b": &gotB} {
+		req := withAuthCookie(httptest.NewRequest(http.MethodGet, path, nil), token)
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("%s: status = %d, want 200", path, rec.Code)
+		}
+		if got.UserID != "user-42" || got.TenantSlug != "tenant-x" {
+			t.Fatalf("%s: request-context unerwartet: %+v", path, *got)
+		}
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 3: eine neue v2-Route laesst sich anlegen,
+// ohne v1 zu beeintraechtigen.
+func TestVersioning_V2DoesNotAffectV1(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v1-antwort"))
+	})
+	srv.Handle("v2", "/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v2-antwort"))
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	reqV1 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1, reqV1)
+	if recV1.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort = %q, want v1-antwort", recV1.Body.String())
+	}
+
+	reqV2 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v2/things", nil), token)
+	recV2 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV2, reqV2)
+	if recV2.Body.String() != "v2-antwort" {
+		t.Fatalf("v2 antwort = %q, want v2-antwort", recV2.Body.String())
+	}
+
+	// v1 nach dem Anlegen von v2 erneut pruefen — unveraendert.
+	reqV1Again := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1Again := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1Again, reqV1Again)
+	if recV1Again.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort nach v2-anlage = %q, want weiterhin v1-antwort", recV1Again.Body.String())
+	}
+}
+
+func TestAuthAndTenantContext_RejectsInvalidToken(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/geschuetzt", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/geschuetzt", nil), "kaputtes.token.hier")
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("status = %d, want 401", rec.Code)
+	}
+}

internal/audit/audit.go

@@ -0,0 +1,96 @@
+// Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
+// Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
+// compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
+// Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
+// — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
+// Schreibpfad (Akzeptanzkriterium 3).
+package audit
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
+// Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
+// Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
+const SystemTenant = "system"
+
+var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
+var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
+var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
+
+// Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
+// Aktion, Zielobjekt, Zeitpunkt, Tenant).
+type Event struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	Target     string
+	Metadata   map[string]any
+	OccurredAt time.Time
+}
+
+// Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
+// bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
+// direkt in audit_events schreibt und dabei die Validierung umgeht
+// (Akzeptanzkriterium 3).
+type Log struct {
+	pool *pgxpool.Pool
+}
+
+func NewLog(pool *pgxpool.Pool) *Log {
+	return &Log{pool: pool}
+}
+
+// Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
+// bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
+// Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
+// zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
+func (l *Log) Record(ctx context.Context, e Event) error {
+	if e.TenantSlug == "" {
+		return ErrMissingTenant
+	}
+	if e.Actor == "" {
+		return ErrMissingActor
+	}
+	if e.Action == "" {
+		return ErrMissingAction
+	}
+	if e.Metadata == nil {
+		e.Metadata = map[string]any{}
+	}
+	metadataJSON, err := json.Marshal(e.Metadata)
+	if err != nil {
+		return fmt.Errorf("metadaten serialisieren: %w", err)
+	}
+	if e.OccurredAt.IsZero() {
+		e.OccurredAt = time.Now()
+	}
+
+	_, err = l.pool.Exec(ctx, `
+		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
+		VALUES ($1, $2, $3, $4, $5, $6)
+	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
+	if err != nil {
+		return fmt.Errorf("audit-ereignis schreiben: %w", err)
+	}
+	return nil
+}
+
+// CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
+// eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
+func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
+	var n int
+	if err := l.pool.QueryRow(ctx, `
+		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
+	`, tenantSlug).Scan(&n); err != nil {
+		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
+	}
+	return n, nil
+}

internal/audit/audit_test.go

@@ -0,0 +1,132 @@
+package audit
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupAuditTest(t *testing.T) (*Log, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
+		pool.Close()
+	}
+	return NewLog(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
+// (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
+func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
+	log, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{
+		TenantSlug: "test_acme",
+		Actor:      "alice@example.com",
+		Action:     "iam.login_failed",
+		Target:     "user:alice@example.com",
+		Metadata:   map[string]any{"reason": "falsches passwort"},
+	})
+	if err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	count, err := log.CountByTenant(ctx, "test_acme")
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
+	}
+
+	var actor, action, target string
+	if err := pool.QueryRow(ctx, `
+		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
+	`).Scan(&actor, &action, &target); err != nil {
+		t.Fatalf("eintrag lesen: %v", err)
+	}
+	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
+		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
+// bereits vom zentralen Schreibpfad abgewiesen.
+func TestRecord_RejectsMissingTenant(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
+	if !errors.Is(err, ErrMissingTenant) {
+		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
+// der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
+// Schutz haengt nicht allein von der Go-Validierung ab.
+func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
+	_, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := pool.Exec(ctx, `
+		INSERT INTO audit_events (tenant_slug, actor, action, target)
+		VALUES ('', 'alice', 'irgendwas', 'ziel')
+	`)
+	if err == nil {
+		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
+	}
+}
+
+func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
+		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
+	}
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
+		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
+	}
+}
+
+func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
+		t.Fatalf("record mit SystemTenant: %v", err)
+	}
+}

internal/audit/export.go

@@ -0,0 +1,122 @@
+package audit
+
+import (
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+)
+
+// Filter grenzt einen Export ein (Akzeptanzkriterium 1). Leere/Nil-Felder
+// bedeuten "kein Filter auf diesem Feld".
+type Filter struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	From       *time.Time
+	To         *time.Time
+}
+
+func buildFilterQuery(f Filter) (string, []any) {
+	query := `SELECT occurred_at, tenant_slug, actor, action, target, metadata FROM audit_events WHERE 1=1`
+	var args []any
+
+	if f.TenantSlug != "" {
+		args = append(args, f.TenantSlug)
+		query += fmt.Sprintf(" AND tenant_slug = $%d", len(args))
+	}
+	if f.Actor != "" {
+		args = append(args, f.Actor)
+		query += fmt.Sprintf(" AND actor = $%d", len(args))
+	}
+	if f.Action != "" {
+		args = append(args, f.Action)
+		query += fmt.Sprintf(" AND action = $%d", len(args))
+	}
+	if f.From != nil {
+		args = append(args, *f.From)
+		query += fmt.Sprintf(" AND occurred_at >= $%d", len(args))
+	}
+	if f.To != nil {
+		args = append(args, *f.To)
+		query += fmt.Sprintf(" AND occurred_at <= $%d", len(args))
+	}
+	query += " ORDER BY occurred_at"
+	return query, args
+}
+
+// StreamCSV schreibt gefilterte Audit-Eintraege direkt als CSV in w, Zeile
+// fuer Zeile ueber rows.Next() — es wird zu keinem Zeitpunkt das gesamte
+// Ergebnis im Speicher aufgebaut (Akzeptanzkriterium 3 / Pruefung 1).
+func (l *Log) StreamCSV(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	cw := csv.NewWriter(w)
+	if err := cw.Write([]string{"occurred_at", "tenant_slug", "actor", "action", "target", "metadata"}); err != nil {
+		return fmt.Errorf("csv-header schreiben: %w", err)
+	}
+
+	for rows.Next() {
+		var occurredAt time.Time
+		var tenantSlug, actor, action, target string
+		var metadataJSON []byte
+		if err := rows.Scan(&occurredAt, &tenantSlug, &actor, &action, &target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		if err := cw.Write([]string{
+			occurredAt.Format(time.RFC3339), tenantSlug, actor, action, target, string(metadataJSON),
+		}); err != nil {
+			return fmt.Errorf("csv-zeile schreiben: %w", err)
+		}
+	}
+	cw.Flush()
+	if err := rows.Err(); err != nil {
+		return fmt.Errorf("export lesen: %w", err)
+	}
+	return cw.Error()
+}
+
+// exportRecord ist die JSON-Repraesentation einer exportierten Zeile.
+type exportRecord struct {
+	OccurredAt time.Time       `json:"occurred_at"`
+	TenantSlug string          `json:"tenant_slug"`
+	Actor      string          `json:"actor"`
+	Action     string          `json:"action"`
+	Target     string          `json:"target"`
+	Metadata   json.RawMessage `json:"metadata"`
+}
+
+// StreamJSON schreibt gefilterte Audit-Eintraege als JSON Lines (ein
+// JSON-Objekt pro Zeile) — bewusst kein einzelnes grosses JSON-Array, da
+// dessen korrektes Streaming (Kommas/Klammern ohne Zwischenpufferung)
+// unnoetige Komplexitaet fuer denselben Zweck waere. Wie StreamCSV
+// zeilenweise ueber rows.Next(), kein Aufbau im Speicher.
+func (l *Log) StreamJSON(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	enc := json.NewEncoder(w)
+	for rows.Next() {
+		var rec exportRecord
+		var metadataJSON []byte
+		if err := rows.Scan(&rec.OccurredAt, &rec.TenantSlug, &rec.Actor, &rec.Action, &rec.Target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		rec.Metadata = metadataJSON
+		if err := enc.Encode(rec); err != nil {
+			return fmt.Errorf("json-zeile schreiben: %w", err)
+		}
+	}
+	return rows.Err()
+}

internal/audit/export_handler.go

@@ -0,0 +1,73 @@
+package audit
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Authorize entscheidet, ob caller den Export ausfuehren darf. Die
+// eigentliche Rollen-/Rechtepruefung (RBAC-02 Policy-Enforcement) ist nicht
+// Teil dieser Kachel — ExportHandler kennt nur diese schmale Schnittstelle,
+// analog zum RetentionRegistrar-Muster aus AUD-05.
+type Authorize func(ctx context.Context, caller string) bool
+
+// ExportHandler stellt den Export als HTTP-Endpunkt bereit
+// (Akzeptanzkriterium 2: fuer berechtigte Rollen verfuegbar).
+type ExportHandler struct {
+	log       *Log
+	authorize Authorize
+}
+
+func NewExportHandler(log *Log, authorize Authorize) *ExportHandler {
+	return &ExportHandler{log: log, authorize: authorize}
+}
+
+// Export liest Filter-Query-Parameter (tenant, actor, action, from, to,
+// format) und schreibt DIREKT auf den ResponseWriter (io.Writer) — dieselbe
+// Streaming-Funktion wie in export.go, kein zusaetzlicher Pufferungsschritt.
+func (h *ExportHandler) Export(w http.ResponseWriter, r *http.Request) {
+	// "caller" identifiziert die anfragende Person fuer die Berechtigungs-
+	// pruefung — bewusst getrennt vom Filterfeld "actor" (das den
+	// AUDIT-Akteur meint, ueber den gefiltert wird).
+	caller := r.URL.Query().Get("caller")
+	if caller == "" || !h.authorize(r.Context(), caller) {
+		http.Error(w, "keine berechtigung fuer audit-log-export", http.StatusForbidden)
+		return
+	}
+
+	filter := Filter{
+		TenantSlug: r.URL.Query().Get("tenant"),
+		Actor:      r.URL.Query().Get("actor"),
+		Action:     r.URL.Query().Get("action"),
+	}
+	if from := r.URL.Query().Get("from"); from != "" {
+		t, err := time.Parse(time.RFC3339, from)
+		if err != nil {
+			http.Error(w, "ungueltiges from-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.From = &t
+	}
+	if to := r.URL.Query().Get("to"); to != "" {
+		t, err := time.Parse(time.RFC3339, to)
+		if err != nil {
+			http.Error(w, "ungueltiges to-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.To = &t
+	}
+
+	switch r.URL.Query().Get("format") {
+	case "json":
+		w.Header().Set("Content-Type", "application/x-ndjson")
+		if err := h.log.StreamJSON(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	default:
+		w.Header().Set("Content-Type", "text/csv")
+		if err := h.log.StreamCSV(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	}
+}

internal/audit/export_test.go

@@ -0,0 +1,222 @@
+package audit
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupExportTest(t *testing.T) (*Log, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewLog(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Filterkombinationen liefern korrekte
+// Teilmengen.
+func TestExport_FilterCombinations(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	run := fmt.Sprintf("_%d", time.Now().UnixNano())
+	tenantA, tenantB := "test_fa"+run, "test_fb"+run
+	alice, bob := "alice"+run, "bob"+run
+
+	events := []Event{
+		{TenantSlug: tenantA, Actor: alice, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: bob, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: alice, Action: "logout", Target: "x"},
+		{TenantSlug: tenantB, Actor: alice, Action: "login", Target: "x"},
+	}
+	for _, e := range events {
+		if err := log.Record(ctx, e); err != nil {
+			t.Fatalf("record: %v", err)
+		}
+	}
+
+	cases := []struct {
+		name    string
+		filter  Filter
+		wantLen int
+	}{
+		{"nach tenant", Filter{TenantSlug: tenantA}, 3},
+		{"nach tenant+actor", Filter{TenantSlug: tenantA, Actor: alice}, 2},
+		{"nach tenant+actor+action", Filter{TenantSlug: tenantA, Actor: alice, Action: "login"}, 1},
+		{"nach actor ueber beide tenants", Filter{Actor: alice, Action: "login"}, 2},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := log.StreamCSV(ctx, c.filter, &buf); err != nil {
+				t.Fatalf("stream: %v", err)
+			}
+			rows, err := csv.NewReader(&buf).ReadAll()
+			if err != nil {
+				t.Fatalf("csv parsen: %v", err)
+			}
+			got := len(rows) - 1 // Header abziehen
+			if got != c.wantLen {
+				t.Fatalf("erwartet %d zeilen, habe %d", c.wantLen, got)
+			}
+		})
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zeitraum-Filter.
+func TestExport_TimeRangeFilter(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_tr_%d", time.Now().UnixNano())
+	past := time.Now().Add(-48 * time.Hour)
+	future := time.Now().Add(48 * time.Hour)
+
+	if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "a", Action: "x", Target: "t", OccurredAt: time.Now()}); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	var buf bytes.Buffer
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &past, To: &future}, &buf); err != nil {
+		t.Fatalf("stream (innerhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 1 {
+		t.Fatalf("erwartet 1 eintrag innerhalb des zeitraums, habe %d", got)
+	}
+
+	farPast := time.Now().Add(-96 * time.Hour)
+	buf.Reset()
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &farPast, To: &past}, &buf); err != nil {
+		t.Fatalf("stream (ausserhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 0 {
+		t.Fatalf("erwartet 0 eintraege ausserhalb des zeitraums, habe %d", got)
+	}
+}
+
+func countLines(s string) int {
+	s = strings.TrimRight(s, "\n")
+	if s == "" {
+		return 0
+	}
+	return len(strings.Split(s, "\n"))
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Export mit hoher Eintragszahl ohne
+// uebermaessigen Speicherverbrauch — Stichprobe per runtime.MemStats.
+func TestExport_StreamsLargeResultWithoutExcessiveMemory(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_large_%d", time.Now().UnixNano())
+	const n = 20000
+	for i := 0; i < n; i++ {
+		if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "bulk", Action: "test.bulk", Target: fmt.Sprintf("obj-%d", i)}); err != nil {
+			t.Fatalf("record %d: %v", i, err)
+		}
+	}
+
+	runtime.GC()
+	var before runtime.MemStats
+	runtime.ReadMemStats(&before)
+
+	lineCount := 0
+	cw := &countingWriter{onWrite: func(p []byte) { lineCount += strings.Count(string(p), "\n") }}
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant}, cw); err != nil {
+		t.Fatalf("stream: %v", err)
+	}
+
+	runtime.GC()
+	var after runtime.MemStats
+	runtime.ReadMemStats(&after)
+
+	if lineCount != n+1 { // +1 Header
+		t.Fatalf("erwartet %d zeilen (inkl. header), habe %d", n+1, lineCount)
+	}
+
+	// Grobe Stichprobe: ein NICHT streamender Export haette hier locker
+	// mehrere MB an einmal gehaltenen Zeilen/Strings erzeugt. Grosszuegige
+	// Schwelle, da Go-Heap-Messungen naturgemaess rauschen.
+	const maxAcceptableGrowth = 3 * 1024 * 1024 // 3 MB
+	growth := int64(after.HeapAlloc) - int64(before.HeapAlloc)
+	t.Logf("heap-wachstum waehrend export von %d zeilen: %d bytes (schwelle: %d)", n, growth, maxAcceptableGrowth)
+	if growth > maxAcceptableGrowth {
+		t.Fatalf("heap ist um %d bytes gewachsen, erwartet unter %d (hinweis auf vollstaendige pufferung statt streaming)", growth, maxAcceptableGrowth)
+	}
+}
+
+type countingWriter struct {
+	onWrite func(p []byte)
+}
+
+func (w *countingWriter) Write(p []byte) (int, error) {
+	w.onWrite(p)
+	return len(p), nil
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Zugriff ohne passende Berechtigung wird abgewiesen.
+func TestExportHandler_RejectsWithoutAuthorization(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+
+	handler := NewExportHandler(log, func(ctx context.Context, caller string) bool {
+		return caller == "berechtigte-person@example.com"
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/audit/export?caller=unberechtigt@example.com", nil)
+	rec := httptest.NewRecorder()
+	handler.Export(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("unberechtigt: status = %d, want 403", rec.Code)
+	}
+
+	reqNoCaller := httptest.NewRequest(http.MethodGet, "/audit/export", nil)
+	recNoCaller := httptest.NewRecorder()
+	handler.Export(recNoCaller, reqNoCaller)
+	if recNoCaller.Code != http.StatusForbidden {
+		t.Fatalf("ohne caller: status = %d, want 403", recNoCaller.Code)
+	}
+
+	reqOK := httptest.NewRequest(http.MethodGet, "/audit/export?caller=berechtigte-person@example.com", nil)
+	recOK := httptest.NewRecorder()
+	handler.Export(recOK, reqOK)
+	if recOK.Code != http.StatusOK {
+		t.Fatalf("berechtigt: status = %d, want 200", recOK.Code)
+	}
+}

internal/auditadmin/authorize.go

@@ -0,0 +1,23 @@
+// Package auditadmin implementiert Core AUD-04: die Berechtigungspruefung
+// fuer die Audit-Log-Ansicht. Enthaelt bewusst KEINE eigene Filter-/
+// Export-Logik — die Ansicht ist "reiner Konsument der Export-API" (AUD-03,
+// internal/audit.ExportHandler); dieses Paket liefert nur die
+// audit.Authorize-Implementierung, die der Entwicklungs-/Testserver
+// (cmd/auditlog-devserver) einhaengt.
+package auditadmin
+
+import "crypto/subtle"
+
+// NewTokenAuthorizer liefert eine audit.Authorize-Funktion, die den
+// aufrufenden "caller"-Wert timing-safe gegen ein geteiltes Admin-Token
+// vergleicht — dasselbe Muster wie internal/audit.timingsafe (AUD-02),
+// NICHT ueber eine neue Rollen-/Rechteschicht, da AUD-04 ausdruecklich nur
+// von AUD-03 abhaengt.
+func NewTokenAuthorizer(adminToken string) func(caller string) bool {
+	return func(caller string) bool {
+		if caller == "" || adminToken == "" {
+			return false
+		}
+		return subtle.ConstantTimeCompare([]byte(caller), []byte(adminToken)) == 1
+	}
+}

internal/auditadmin/authorize_test.go

@@ -0,0 +1,33 @@
+package auditadmin
+
+import "testing"
+
+// Grundlage fuer Akzeptanzkriterium 1/2: die Oberflaeche darf Daten und den
+// Export nur bei korrektem Admin-Token abrufen.
+func TestNewTokenAuthorizer_AcceptsCorrectToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if !authorize("geheimes-token") {
+		t.Fatal("erwartet true fuer korrektes token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWrongToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("falsches-token") {
+		t.Fatal("erwartet false fuer falsches token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsEmptyCaller(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("") {
+		t.Fatal("erwartet false fuer leeren aufrufer")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWhenNoTokenConfigured(t *testing.T) {
+	authorize := NewTokenAuthorizer("")
+	if authorize("irgendwas") {
+		t.Fatal("erwartet false, wenn kein admin-token konfiguriert ist (fail-safe-default)")
+	}
+}

internal/cfgservice/service.go

@@ -0,0 +1,88 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2 / Pruefung 2 in diesem Ticket bezieht sich auf die
+// Aenderungsnachvollziehbarkeit — die Cache-Frist selbst folgt demselben
+// Muster wie internal/flag.DefaultCacheTTL).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	value     Value
+	expiresAt time.Time
+}
+
+// Service ist die Leseseite mit Vorrangregel (Akzeptanzkriterium 1:
+// Tenant-Override vor Global-Default) und lokalem TTL-Cache.
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry // Schluessel: key + "\x00" + tenantSlug
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+func cacheKey(key, tenantSlug string) string {
+	return key + "\x00" + tenantSlug
+}
+
+// Resolve liefert den Konfigurationswert fuer einen Tenant: ein
+// Tenant-spezifischer Override hat Vorrang vor dem globalen Default
+// (Akzeptanzkriterium 1 / Pruefung 1). tenantSlug == "" wertet nur den
+// globalen Wert aus.
+func (s *Service) Resolve(ctx context.Context, tenantSlug, key string) (Value, error) {
+	ck := cacheKey(key, tenantSlug)
+
+	s.mu.RLock()
+	entry, exists := s.cache[ck]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.value, nil
+	}
+
+	v, err := s.resolveUncached(ctx, tenantSlug, key)
+	if err != nil {
+		return Value{}, err
+	}
+
+	s.mu.Lock()
+	s.cache[ck] = cacheEntry{value: v, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return v, nil
+}
+
+func (s *Service) resolveUncached(ctx context.Context, tenantSlug, key string) (Value, error) {
+	if tenantSlug != "" {
+		v, err := s.store.Get(ctx, key, tenantSlug)
+		if err == nil {
+			return v, nil
+		}
+		if !errors.Is(err, ErrNotFound) {
+			return Value{}, err
+		}
+	}
+	return s.store.Get(ctx, key, GlobalScope)
+}
+
+// Invalidate erzwingt beim naechsten Resolve-Aufruf ein sofortiges Neuladen
+// fuer einen bestimmten (key, tenantSlug) statt auf den TTL-Ablauf zu warten
+// — analog internal/flag.Service.Invalidate.
+func (s *Service) Invalidate(key, tenantSlug string) {
+	s.mu.Lock()
+	delete(s.cache, cacheKey(key, tenantSlug))
+	s.mu.Unlock()
+}

internal/cfgservice/service_test.go

@@ -0,0 +1,114 @@
+package cfgservice
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: Tenant-Override hat Vorrang vor
+// Global-Default, automatisiert getestet.
+func TestService_TenantOverrideTakesPrecedenceOverGlobal(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_precedence_key", GlobalScope, "global-wert"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if _, err := store.Set(ctx, "test_precedence_key", "test_acme", "tenant-wert"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	svc := NewService(store, time.Hour)
+
+	got, err := svc.Resolve(ctx, "test_acme", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve mit override: %v", err)
+	}
+	if got.Value != "tenant-wert" {
+		t.Fatalf("erwartet tenant-override, habe %q", got.Value)
+	}
+
+	gotOther, err := svc.Resolve(ctx, "test_anderer_tenant", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve ohne override: %v", err)
+	}
+	if gotOther.Value != "global-wert" {
+		t.Fatalf("erwartet global-default fuer tenant ohne override, habe %q", gotOther.Value)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Cache-Invalidierung nach
+// Konfigurationsaenderung innerhalb dokumentierter Zeit gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	v, err := svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("erwartet 'alt', habe %q", v.Value)
+	}
+
+	changedAt := time.Now()
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	v, err = svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve direkt nach aenderung: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("cache haette den alten wert liefern sollen, habe %q", v.Value)
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		v, err := svc.Resolve(ctx, "", "test_ttl_key")
+		if err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+		if v.Value == "neu" {
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", time.Since(changedAt), ttl)
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
+}
+
+func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+	_, _ = svc.Resolve(ctx, "", "test_invalidate_key")
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_key", "")
+
+	v, err := svc.Resolve(ctx, "", "test_invalidate_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "neu" {
+		t.Fatalf("erwartet sofort sichtbaren neuen wert nach Invalidate, habe %q", v.Value)
+	}
+}

internal/cfgservice/store.go

@@ -0,0 +1,129 @@
+// Package cfgservice implementiert Core CFG-01: den zentralen Dienst fuer
+// globale und tenant-spezifische Konfigurationswerte mit Versionierung und
+// Cache-Invalidierung. Andere Module lesen Konfiguration AUSSCHLIESSLICH
+// ueber dieses Paket (Akzeptanzkriterium 3), niemals ueber eigene Tabellen.
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalScope ist der reservierte Scope-Wert fuer globale Defaults — jeder
+// andere Scope-Wert ist ein Tenant-Slug (Akzeptanzkriterium 1).
+const GlobalScope = "global"
+
+var ErrNotFound = errors.New("cfgservice: kein wert fuer diesen key gefunden")
+
+type Value struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+type HistoryEntry struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+// Store ist die Schreib-/Verwaltungsseite. Set schreibt IMMER sowohl den
+// aktuellen Stand (config_values) als auch einen Historieneintrag
+// (config_value_history) in derselben Transaktion — eine Aenderung ohne
+// Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set schreibt einen neuen Wert fuer (key, scope) und erhoeht die Version um 1
+// (Version 1 bei erstmaligem Setzen).
+func (s *Store) Set(ctx context.Context, key, scope, value string) (Value, error) {
+	if scope == "" {
+		return Value{}, errors.New("cfgservice: scope darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Value{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var currentVersion int
+	err = tx.QueryRow(ctx, `SELECT version FROM config_values WHERE key = $1 AND scope = $2`, key, scope).Scan(&currentVersion)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return Value{}, fmt.Errorf("aktuelle version lesen: %w", err)
+	}
+	newVersion := currentVersion + 1
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_values (key, scope, value, version, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key, scope) DO UPDATE SET value = $3, version = $4, updated_at = now()
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("wert speichern: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_value_history (key, scope, value, version, changed_at)
+		VALUES ($1, $2, $3, $4, now())
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Value{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Value{Key: key, Scope: scope, Value: value, Version: newVersion}, nil
+}
+
+// Get liefert den Wert fuer GENAU EINEN Scope (kein Vorrang-Fallback) — die
+// Vorrangregel (Tenant vor Global) lebt bewusst in Service.Resolve, damit
+// Store rein CRUD bleibt.
+func (s *Store) Get(ctx context.Context, key, scope string) (Value, error) {
+	var v Value
+	v.Key, v.Scope = key, scope
+	err := s.pool.QueryRow(ctx, `
+		SELECT value, version FROM config_values WHERE key = $1 AND scope = $2
+	`, key, scope).Scan(&v.Value, &v.Version)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Value{}, ErrNotFound
+		}
+		return Value{}, fmt.Errorf("wert lesen: %w", err)
+	}
+	return v, nil
+}
+
+// History liefert die vollstaendige Versionshistorie eines (key, scope) in
+// aufsteigender Reihenfolge (Akzeptanzkriterium 2 / Pruefung 3).
+func (s *Store) History(ctx context.Context, key, scope string) ([]HistoryEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, scope, value, version FROM config_value_history
+		WHERE key = $1 AND scope = $2 ORDER BY version
+	`, key, scope)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []HistoryEntry
+	for rows.Next() {
+		var h HistoryEntry
+		if err := rows.Scan(&h.Key, &h.Scope, &h.Value, &h.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, h)
+	}
+	return out, rows.Err()
+}

internal/cfgservice/store_test.go

@@ -0,0 +1,119 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStoreTest(t *testing.T) (*Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS config_values (
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL CHECK (scope <> ''),
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (key, scope)
+		);
+		CREATE TABLE IF NOT EXISTS config_value_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL,
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM config_value_history WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM config_values WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+func TestStore_SetIncrementsVersion(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	v1, err := store.Set(ctx, "test_key", GlobalScope, "erster-wert")
+	if err != nil {
+		t.Fatalf("set 1: %v", err)
+	}
+	if v1.Version != 1 {
+		t.Fatalf("erwartet version 1, habe %d", v1.Version)
+	}
+
+	v2, err := store.Set(ctx, "test_key", GlobalScope, "zweiter-wert")
+	if err != nil {
+		t.Fatalf("set 2: %v", err)
+	}
+	if v2.Version != 2 {
+		t.Fatalf("erwartet version 2, habe %d", v2.Version)
+	}
+
+	got, err := store.Get(ctx, "test_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Value != "zweiter-wert" || got.Version != 2 {
+		t.Fatalf("aktueller wert unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Versionierungshistorie ueber mehrere
+// Aenderungen hinweg nachvollzogen.
+func TestStore_HistoryTracksAllChanges(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	values := []string{"v1", "v2", "v3"}
+	for _, v := range values {
+		if _, err := store.Set(ctx, "test_history_key", GlobalScope, v); err != nil {
+			t.Fatalf("set %q: %v", v, err)
+		}
+	}
+
+	history, err := store.History(ctx, "test_history_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 3 {
+		t.Fatalf("erwartet 3 historieneintraege, habe %d", len(history))
+	}
+	for i, h := range history {
+		if h.Version != i+1 || h.Value != values[i] {
+			t.Fatalf("historieneintrag[%d] unerwartet: %+v", i, h)
+		}
+	}
+}
+
+func TestStore_GetUnknownKeyReturnsNotFound(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Get(ctx, "test_nie_gesetzt", GlobalScope); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound, habe %v", err)
+	}
+}

internal/channels/channels_test.go

@@ -0,0 +1,207 @@
+package channels
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*TemplateStore, *InAppStore, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_templates (
+			tenant_slug TEXT NOT NULL, key TEXT NOT NULL, subject TEXT NOT NULL, body TEXT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_slug, key)
+		);
+		CREATE TABLE IF NOT EXISTS in_app_notifications (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL,
+			title TEXT NOT NULL, body TEXT NOT NULL, read_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','failed')),
+			attempts INT NOT NULL DEFAULT 0, max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewTemplateStore(pool), NewInAppStore(pool), cleanup
+}
+
+func uniqueKey(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Vorlagenrendering mit fehlenden
+// Platzhaltern bricht kontrolliert ab.
+func TestRender_MissingPlaceholderAborts(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	_, _, err := Render(tmpl, map[string]any{"name": "Alice"}) // "code" fehlt
+	if err == nil {
+		t.Fatal("erwartet fehler bei fehlendem platzhalter 'code'")
+	}
+}
+
+func TestRender_SucceedsWithAllPlaceholders(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	subject, body, err := Render(tmpl, map[string]any{"name": "Alice", "code": "1234"})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	if subject != "Hallo Alice" || body != "Dein Code: 1234" {
+		t.Fatalf("unerwartet: subject=%q body=%q", subject, body)
+	}
+}
+
+// Akzeptanzkriterium 3: Vorlagen pro Tenant anpassbar, Fallback auf global.
+func TestTemplateStore_TenantOverrideFallsBackToGlobal(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	key := uniqueKey("welcome")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Willkommen", "Standardtext"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if err := templates.Set(ctx, "acme", key, "Willkommen bei ACME", "ACME-Text"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	got, err := templates.Resolve(ctx, "acme", key)
+	if err != nil {
+		t.Fatalf("resolve acme: %v", err)
+	}
+	if got.Subject != "Willkommen bei ACME" {
+		t.Fatalf("erwartet tenant-vorlage, habe %q", got.Subject)
+	}
+
+	got, err = templates.Resolve(ctx, "globex", key) // hat keine eigene vorlage
+	if err != nil {
+		t.Fatalf("resolve globex: %v", err)
+	}
+	if got.Subject != "Willkommen" {
+		t.Fatalf("erwartet global-fallback, habe %q", got.Subject)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: als gelesen markiert wird korrekt gefuehrt.
+func TestInAppStore_MarkReadIsReflectedCorrectly(t *testing.T) {
+	_, inApp, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	userID := uniqueKey("user")
+	id, err := inApp.Create(ctx, "acme", userID, "Titel", "Text")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	list, err := inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (vor markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt != nil {
+		t.Fatalf("erwartet 1 ungelesene benachrichtigung, habe %+v", list)
+	}
+
+	if err := inApp.MarkRead(ctx, id); err != nil {
+		t.Fatalf("mark read: %v", err)
+	}
+
+	list, err = inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (nach markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt == nil {
+		t.Fatalf("erwartet als gelesen markiert, habe %+v", list)
+	}
+}
+
+// EmailSender bricht ab, BEVOR SMTP ueberhaupt kontaktiert wird, wenn keine
+// Vorlage aufloesbar ist — Nachweis, dass der Abbruch vor dem Netzwerkzugriff
+// erfolgt (Akzeptanzkriterium 1).
+func TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+
+	err := sender.Send(ctx, notify.Notification{
+		Recipient: "user@example.com",
+		Payload:   map[string]any{"template_key": uniqueKey("nie_konfiguriert"), "tenant_slug": "acme"},
+	})
+	if !errors.Is(err, ErrTemplateNotFound) {
+		t.Fatalf("erwartet ErrTemplateNotFound (kein smtp-versuch), habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: E-Mail-Versand bei nicht erreichbarem
+// SMTP-Server loest das dokumentierte Retry-Verhalten ueber CFG-02 aus.
+func TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	key := uniqueKey("retry_test")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Betreff", "Text ohne Platzhalter"); err != nil {
+		t.Fatalf("set template: %v", err)
+	}
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+	dispatcher := notify.NewDispatcher(pool).WithRetryPolicy(2, time.Millisecond)
+
+	jobID, err := dispatcher.Enqueue(ctx, "email", "user@example.com", map[string]any{"template_key": key, "tenant_slug": "acme"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	for i := 0; i < 2; i++ {
+		time.Sleep(5 * time.Millisecond)
+		if _, _, err := dispatcher.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process due %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, jobID).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach ausgeschoepften wiederholungen bei unerreichbarem smtp, habe %q", status)
+	}
+	if attempts != 2 {
+		t.Fatalf("erwartet 2 versuche, habe %d", attempts)
+	}
+}

internal/channels/email.go

@@ -0,0 +1,81 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// EmailSender implementiert notify.Sender fuer den E-Mail-Kanal
+// (Akzeptanzkriterium 1). SMTP-Zugangsdaten kommen ausschliesslich aus
+// Umgebungsvariablen, nie aus Code/DB.
+type EmailSender struct {
+	templates *TemplateStore
+	host      string
+	port      string
+	from      string
+	username  string
+	password  string
+}
+
+// NewEmailSenderFromEnv liest NEXARCH_SMTP_HOST/PORT/FROM (Pflicht) sowie
+// optional NEXARCH_SMTP_USER/PASSWORD.
+func NewEmailSenderFromEnv(templates *TemplateStore) (*EmailSender, error) {
+	host := os.Getenv("NEXARCH_SMTP_HOST")
+	port := os.Getenv("NEXARCH_SMTP_PORT")
+	from := os.Getenv("NEXARCH_SMTP_FROM")
+	if host == "" || port == "" || from == "" {
+		return nil, fmt.Errorf("channels: NEXARCH_SMTP_HOST/PORT/FROM muessen gesetzt sein")
+	}
+	return &EmailSender{
+		templates: templates,
+		host:      host,
+		port:      port,
+		from:      from,
+		username:  os.Getenv("NEXARCH_SMTP_USER"),
+		password:  os.Getenv("NEXARCH_SMTP_PASSWORD"),
+	}, nil
+}
+
+// NewEmailSender erlaubt Tests, Host/Port explizit zu setzen (z.B. einen
+// absichtlich nicht erreichbaren Host fuer den Retry-Nachweis), ohne
+// Umgebungsvariablen zu benoetigen.
+func NewEmailSender(templates *TemplateStore, host, port, from string) *EmailSender {
+	return &EmailSender{templates: templates, host: host, port: port, from: from}
+}
+
+// Send rendert zuerst die Vorlage — schlaegt das fehl (z.B. fehlender
+// Platzhalter), wird NIE eine SMTP-Verbindung aufgebaut
+// (Akzeptanzkriterium 1 / Pruefung 1: kontrollierter Abbruch statt
+// fehlerhafter Mail). Ein danach fehlschlagender SMTP-Versand liefert einen
+// Fehler zurueck, den CFG-02s Dispatcher fuer die bereits getestete
+// Wiederholungslogik nutzt (Akzeptanzkriterium 3 / Pruefung 3) — kein
+// zweiter Retry-Mechanismus hier.
+func (e *EmailSender) Send(ctx context.Context, n notify.Notification) error {
+	templateKey, _ := n.Payload["template_key"].(string)
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	tmpl, err := e.templates.Resolve(ctx, tenantSlug, templateKey)
+	if err != nil {
+		return fmt.Errorf("vorlage aufloesen: %w", err)
+	}
+	subject, body, err := Render(tmpl, n.Payload)
+	if err != nil {
+		return err
+	}
+
+	msg := []byte("Subject: " + subject + "\r\n\r\n" + body)
+
+	var auth smtp.Auth
+	if e.username != "" {
+		auth = smtp.PlainAuth("", e.username, e.password, e.host)
+	}
+	addr := e.host + ":" + e.port
+	if err := smtp.SendMail(addr, auth, e.from, []string{n.Recipient}, msg); err != nil {
+		return fmt.Errorf("smtp-versand fehlgeschlagen: %w", err)
+	}
+	return nil
+}

internal/channels/inapp.go

@@ -0,0 +1,74 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type InAppNotification struct {
+	ID         string
+	TenantSlug string
+	UserID     string
+	Title      string
+	Body       string
+	ReadAt     *time.Time
+	CreatedAt  time.Time
+}
+
+// InAppStore persistiert In-App-Benachrichtigungen (Akzeptanzkriterium 2).
+type InAppStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewInAppStore(pool *pgxpool.Pool) *InAppStore {
+	return &InAppStore{pool: pool}
+}
+
+func (s *InAppStore) Create(ctx context.Context, tenantSlug, userID, title, body string) (string, error) {
+	var id string
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO in_app_notifications (tenant_slug, user_id, title, body)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, tenantSlug, userID, title, body).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("in-app-benachrichtigung speichern: %w", err)
+	}
+	return id, nil
+}
+
+// ListForUser liefert alle Benachrichtigungen eines Benutzers (ueber API
+// abrufbar, Akzeptanzkriterium 2).
+func (s *InAppStore) ListForUser(ctx context.Context, tenantSlug, userID string) ([]InAppNotification, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, title, body, read_at, created_at FROM in_app_notifications
+		WHERE tenant_slug = $1 AND user_id = $2 ORDER BY created_at DESC
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("benachrichtigungen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []InAppNotification
+	for rows.Next() {
+		n := InAppNotification{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&n.ID, &n.Title, &n.Body, &n.ReadAt, &n.CreatedAt); err != nil {
+			return nil, fmt.Errorf("benachrichtigung lesen: %w", err)
+		}
+		out = append(out, n)
+	}
+	return out, rows.Err()
+}
+
+// MarkRead markiert eine Benachrichtigung als gelesen (Akzeptanzkriterium 2
+// / Pruefung 2).
+func (s *InAppStore) MarkRead(ctx context.Context, id string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE in_app_notifications SET read_at = now() WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("als gelesen markieren: %w", err)
+	}
+	return nil
+}

internal/channels/inapp_sender.go

@@ -0,0 +1,41 @@
+package channels
+
+import (
+	"context"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// InAppSender implementiert notify.Sender fuer den In-App-Kanal
+// (Akzeptanzkriterium 2). Nutzt eine Vorlage, falls payload["template_key"]
+// gesetzt ist, sonst direkt payload["title"]/["body"].
+type InAppSender struct {
+	store     *InAppStore
+	templates *TemplateStore
+}
+
+func NewInAppSender(store *InAppStore, templates *TemplateStore) *InAppSender {
+	return &InAppSender{store: store, templates: templates}
+}
+
+func (s *InAppSender) Send(ctx context.Context, n notify.Notification) error {
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	var title, body string
+	if templateKey, ok := n.Payload["template_key"].(string); ok && templateKey != "" {
+		tmpl, err := s.templates.Resolve(ctx, tenantSlug, templateKey)
+		if err != nil {
+			return err
+		}
+		title, body, err = Render(tmpl, n.Payload)
+		if err != nil {
+			return err
+		}
+	} else {
+		title, _ = n.Payload["title"].(string)
+		body, _ = n.Payload["body"].(string)
+	}
+
+	_, err := s.store.Create(ctx, tenantSlug, n.Recipient, title, body)
+	return err
+}

internal/channels/router.go

@@ -0,0 +1,32 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// Router waehlt anhand von Notification.Channel den zustaendigen Kanal aus
+// — ein neuer Kanal wird per Register() ergaenzt, ohne den Dispatcher
+// (CFG-02) oder Router selbst umzubauen (Unleash-artiger Strategie-Gedanke,
+// siehe Ticket-DNA).
+type Router struct {
+	channels map[string]notify.Sender
+}
+
+func NewRouter() *Router {
+	return &Router{channels: make(map[string]notify.Sender)}
+}
+
+func (r *Router) Register(channel string, sender notify.Sender) {
+	r.channels[channel] = sender
+}
+
+func (r *Router) Send(ctx context.Context, n notify.Notification) error {
+	sender, ok := r.channels[n.Channel]
+	if !ok {
+		return fmt.Errorf("channels: unbekannter kanal %q", n.Channel)
+	}
+	return sender.Send(ctx, n)
+}

internal/channels/template.go

@@ -0,0 +1,104 @@
+// Package channels implementiert Core CFG-03: konkrete Zustellkanaele fuer
+// den CFG-02-Dispatcher (E-Mail, In-App) inklusive Vorlagenverwaltung.
+// Neue Kanaele lassen sich ergaenzen, ohne den Dispatcher selbst
+// anzufassen — jeder Kanal implementiert nur notify.Sender.
+package channels
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"text/template"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalTemplateScope ist der Fallback-Wert, wenn ein Tenant keine eigene
+// Vorlage konfiguriert hat (Akzeptanzkriterium 3).
+const GlobalTemplateScope = "global"
+
+var ErrTemplateNotFound = errors.New("channels: keine vorlage gefunden")
+
+type Template struct {
+	Subject string
+	Body    string
+}
+
+type TemplateStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTemplateStore(pool *pgxpool.Pool) *TemplateStore {
+	return &TemplateStore{pool: pool}
+}
+
+// Set legt eine Vorlage fuer einen Tenant (oder GlobalTemplateScope) fest.
+func (s *TemplateStore) Set(ctx context.Context, tenantSlug, key, subject, body string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_templates (tenant_slug, key, subject, body, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (tenant_slug, key) DO UPDATE SET subject = $3, body = $4, updated_at = now()
+	`, tenantSlug, key, subject, body)
+	if err != nil {
+		return fmt.Errorf("vorlage speichern: %w", err)
+	}
+	return nil
+}
+
+// Resolve liefert die Vorlage eines Tenants, faellt auf GlobalTemplateScope
+// zurueck, wenn der Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3).
+func (s *TemplateStore) Resolve(ctx context.Context, tenantSlug, key string) (Template, error) {
+	if tenantSlug != "" && tenantSlug != GlobalTemplateScope {
+		if t, err := s.get(ctx, tenantSlug, key); err == nil {
+			return t, nil
+		} else if !errors.Is(err, ErrTemplateNotFound) {
+			return Template{}, err
+		}
+	}
+	return s.get(ctx, GlobalTemplateScope, key)
+}
+
+func (s *TemplateStore) get(ctx context.Context, tenantSlug, key string) (Template, error) {
+	var t Template
+	err := s.pool.QueryRow(ctx, `
+		SELECT subject, body FROM notification_templates WHERE tenant_slug = $1 AND key = $2
+	`, tenantSlug, key).Scan(&t.Subject, &t.Body)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Template{}, ErrTemplateNotFound
+		}
+		return Template{}, fmt.Errorf("vorlage lesen: %w", err)
+	}
+	return t, nil
+}
+
+// Render fuellt eine Vorlage mit data. Fehlt ein referenzierter Platzhalter
+// in data, bricht das Rendering kontrolliert MIT FEHLER ab, statt eine
+// fehlerhafte/unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1 /
+// Pruefung 1) — text/template mit Option("missingkey=error") liefert dafuer
+// einen Fehler statt stillschweigend "<no value>" einzusetzen.
+func Render(tmpl Template, data map[string]any) (subject, body string, err error) {
+	subject, err = renderOne("subject", tmpl.Subject, data)
+	if err != nil {
+		return "", "", err
+	}
+	body, err = renderOne("body", tmpl.Body, data)
+	if err != nil {
+		return "", "", err
+	}
+	return subject, body, nil
+}
+
+func renderOne(name, text string, data map[string]any) (string, error) {
+	tmpl, err := template.New(name).Option("missingkey=error").Parse(text)
+	if err != nil {
+		return "", fmt.Errorf("vorlage %q parsen: %w", name, err)
+	}
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return "", fmt.Errorf("vorlage %q rendern (fehlender platzhalter?): %w", name, err)
+	}
+	return buf.String(), nil
+}

internal/e2e/cross_tenant_isolation_test.go

@@ -25,7 +25,11 @@ func TestE2E_CrossTenantIsolation(t *testing.T) {
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
-	defer adminPool.Close()
+	// Ueber t.Cleanup statt defer geschlossen: t.Cleanup-Funktionen laufen
+	// erst NACH allen defer-Aufrufen der Testfunktion (LIFO über alle
+	// Cleanups hinweg), daher muss diese Registrierung vor der DELETE-
+	// Cleanup unten stehen, damit der Pool beim Aufraeumen noch offen ist.
+	t.Cleanup(func() { adminPool.Close() })
 
 	applyRegistrySchema(t, ctx, adminPool, root)
 

internal/e2e/tenant_onboarding_test.go

@@ -30,7 +30,11 @@ func TestE2E_TenantOnboardingLoginFlow(t *testing.T) {
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
-	defer adminPool.Close()
+	// Ueber t.Cleanup statt defer geschlossen: t.Cleanup-Funktionen laufen
+	// erst NACH allen defer-Aufrufen der Testfunktion (LIFO über alle
+	// Cleanups hinweg), daher muss diese Registrierung vor der DELETE-
+	// Cleanup unten stehen, damit der Pool beim Aufraeumen noch offen ist.
+	t.Cleanup(func() { adminPool.Close() })
 
 	applyRegistrySchema(t, ctx, adminPool, root)
 

internal/flag/flag.go

@@ -0,0 +1,110 @@
+// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
+// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
+// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
+// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
+package flag
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"hash/fnv"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("flag: nicht gefunden")
+
+// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
+// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
+type Flag struct {
+	Key               string
+	Enabled           bool
+	RolloutPercentage int
+	TargetTenantSlugs []string
+}
+
+// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+func (s *Store) Set(ctx context.Context, f Flag) error {
+	if f.TargetTenantSlugs == nil {
+		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key) DO UPDATE SET
+			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
+	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
+	if err != nil {
+		return fmt.Errorf("flag speichern: %w", err)
+	}
+	return nil
+}
+
+// List liefert alle definierten Flags (Admin-Uebersicht, siehe LIC-04) —
+// rein additiv, aendert nichts am bestehenden Verhalten von Set/Get.
+func (s *Store) List(ctx context.Context) ([]Flag, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags ORDER BY key
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("flags auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Flag
+	for rows.Next() {
+		var f Flag
+		if err := rows.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+			return nil, fmt.Errorf("flag-zeile lesen: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
+func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
+	var f Flag
+	row := s.pool.QueryRow(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags WHERE key = $1
+	`, key)
+	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Flag{}, ErrNotFound
+		}
+		return Flag{}, fmt.Errorf("flag lesen: %w", err)
+	}
+	return f, nil
+}
+
+// evaluate wendet die Strategien in fester Reihenfolge an: globaler
+// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
+// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
+// kein Feature wird versehentlich aktiv.
+func evaluate(f Flag, tenantSlug string) bool {
+	if f.Enabled {
+		return true
+	}
+	for _, target := range f.TargetTenantSlugs {
+		if target == tenantSlug {
+			return true
+		}
+	}
+	if f.RolloutPercentage > 0 {
+		h := fnv.New32a()
+		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
+		return int(h.Sum32()%100) < f.RolloutPercentage
+	}
+	return false
+}

internal/flag/flag_test.go

@@ -0,0 +1,43 @@
+package flag
+
+import "testing"
+
+func TestEvaluate_GlobalEnabled(t *testing.T) {
+	f := Flag{Key: "k", Enabled: true}
+	if !evaluate(f, "irgendein-tenant") {
+		t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
+func TestEvaluate_TargetTenantStrategy(t *testing.T) {
+	f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
+	if !evaluate(f, "acme") {
+		t.Fatal("erwartet true fuer tenant in zielgruppe")
+	}
+	if evaluate(f, "globex") {
+		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
+	}
+}
+
+func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
+	full := Flag{Key: "k", RolloutPercentage: 100}
+	if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
+		t.Fatal("100% rollout sollte immer true liefern")
+	}
+
+	none := Flag{Key: "k", RolloutPercentage: 0}
+	if evaluate(none, "beliebiger-tenant") {
+		t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
+	}
+}
+
+func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
+	f := Flag{Key: "k", RolloutPercentage: 50}
+	first := evaluate(f, "stabiler-tenant")
+	for i := 0; i < 5; i++ {
+		if evaluate(f, "stabiler-tenant") != first {
+			t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
+		}
+	}
+}

internal/flag/service.go

@@ -0,0 +1,87 @@
+package flag
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
+// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
+// muss (Akzeptanzkriterium 3).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	flag      Flag
+	expiresAt time.Time
+}
+
+// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
+// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
+// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
+// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
+// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
+// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
+func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
+	f, ok := s.resolve(ctx, key)
+	if !ok {
+		return false
+	}
+	return evaluate(f, tenantSlug)
+}
+
+func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
+	s.mu.RLock()
+	entry, exists := s.cache[key]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.flag, true
+	}
+
+	f, err := s.store.Get(ctx, key)
+	if err != nil {
+		if exists {
+			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
+				"flag_key", key, "error", err)
+			return entry.flag, true
+		}
+		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
+			"flag_key", key, "error", err)
+		return Flag{}, false
+	}
+
+	s.mu.Lock()
+	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return f, true
+}
+
+// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
+// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
+// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
+// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
+// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
+func (s *Service) Invalidate(key string) {
+	s.mu.Lock()
+	delete(s.cache, key)
+	s.mu.Unlock()
+}

internal/flag/service_test.go

@@ -0,0 +1,179 @@
+package flag
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupFlagStoreTest(t *testing.T) (*Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY,
+			enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0,
+			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
+// die erwartete Auswertung.
+func TestService_TargetTenantStrategy(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+
+	if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
+		t.Fatal("erwartet true fuer tenant in zielgruppe")
+	}
+	if svc.IsEnabled(ctx, "globex", "test_target_flag") {
+		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
+	}
+}
+
+// Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
+// dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+		t.Fatal("erwartet false vor der aenderung")
+	}
+
+	// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
+	// Store, ohne svc.Invalidate aufzurufen.
+	changedAt := time.Now()
+	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	// Sofort danach sollte der Cache noch den alten Stand liefern.
+	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+		t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
+			elapsed := time.Since(changedAt)
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, ttl)
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
+}
+
+func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
+	_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
+
+	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_flag")
+
+	if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
+		t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
+// dokumentiertem Fallback-Verhalten, nicht zum Absturz.
+func TestService_FallsBackOnStoreFailure(t *testing.T) {
+	store, cleanup := setupFlagStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+
+	// Cache vorwaermen, waehrend die DB noch erreichbar ist.
+	if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
+		t.Fatal("erwartet true bei funktionierender db")
+	}
+
+	brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
+	if err != nil {
+		t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
+	}
+	brokenStore := NewStore(brokenPool)
+
+	svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
+	svcWithCache.mu.Lock()
+	svcWithCache.cache["test_fallback_flag"] = cacheEntry{
+		flag:      Flag{Key: "test_fallback_flag", Enabled: true},
+		expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
+	}
+	svcWithCache.mu.Unlock()
+
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
+			}
+		}()
+		if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
+			t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
+		}
+	}()
+
+	// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
+	// default false, kein absturz.
+	freshSvc := NewService(brokenStore, time.Hour)
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("IsEnabled hat gepanict: %v", r)
+			}
+		}()
+		if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
+			t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
+		}
+	}()
+}

internal/health/checks.go

@@ -0,0 +1,25 @@
+package health
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DatabaseChecker prueft die tatsaechliche Erreichbarkeit der Datenbank
+// (Ping) — nicht nur, ob der Pool existiert.
+func DatabaseChecker(pool *pgxpool.Pool) CheckerFunc {
+	return func(ctx context.Context) error {
+		return pool.Ping(ctx)
+	}
+}
+
+// QueueChecker prueft, dass die Postgres-basierte Job-Queue (siehe CFG-02)
+// tatsaechlich abfragbar ist — eine eigene, benannte Abhaengigkeit neben der
+// reinen DB-Erreichbarkeit (Akzeptanzkriterium 1).
+func QueueChecker(pool *pgxpool.Pool) CheckerFunc {
+	return func(ctx context.Context) error {
+		_, err := pool.Exec(ctx, `SELECT 1`)
+		return err
+	}
+}

internal/health/handler.go

@@ -0,0 +1,49 @@
+package health
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// LivenessHandler beantwortet IMMER "lebt", solange der Prozess ueberhaupt
+// HTTP-Anfragen verarbeiten kann — prueft bewusst KEINE externen
+// Abhaengigkeiten (Akzeptanzkriterium 2: Liveness und Readiness getrennt).
+// Ein Datenbankausfall darf die Liveness nicht auf "tot" setzen, sonst
+// wuerde eine Orchestrierung (z.B. systemd/Kubernetes) den Prozess grundlos
+// neu starten, obwohl nur eine Abhaengigkeit ausgefallen ist.
+func LivenessHandler(w http.ResponseWriter, r *http.Request) {
+	writeStatus(w, http.StatusOK, map[string]any{"status": "alive"})
+}
+
+// ReadinessHandler prueft ALLE registrierten Abhaengigkeiten
+// (Akzeptanzkriterium 1) und liefert 503, sobald eine davon fehlschlaegt
+// (Akzeptanzkriterium 3) — unterscheidet sich damit nachweislich von
+// LivenessHandler im Fehlerfall (Akzeptanzkriterium 2 / Pruefung 3).
+func (r *Registry) ReadinessHandler() http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		ready, results := r.CheckAll(req.Context())
+
+		body := map[string]any{
+			"status": statusText(ready),
+			"checks": results,
+		}
+		status := http.StatusOK
+		if !ready {
+			status = http.StatusServiceUnavailable
+		}
+		writeStatus(w, status, body)
+	}
+}
+
+func statusText(ready bool) string {
+	if ready {
+		return "ready"
+	}
+	return "not_ready"
+}
+
+func writeStatus(w http.ResponseWriter, status int, body map[string]any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}

internal/health/health.go

@@ -0,0 +1,86 @@
+// Package health implementiert Core OPS-01: Health-/Readiness-Endpunkte, die
+// echte Abhaengigkeiten (DB, Job-Queue) statt nur den Prozessstatus pruefen
+// — wiederverwendbar von Core UND jedem registrierten Modul (siehe API-02),
+// nicht nur von Core selbst.
+package health
+
+import (
+	"context"
+	"time"
+)
+
+// Checker prueft EINE Abhaengigkeit (z.B. Datenbank, Job-Queue).
+type Checker interface {
+	Check(ctx context.Context) error
+}
+
+type CheckerFunc func(ctx context.Context) error
+
+func (f CheckerFunc) Check(ctx context.Context) error { return f(ctx) }
+
+// DefaultCheckTimeout begrenzt, wie lange EIN einzelner Check maximal
+// dauern darf, bevor er als fehlgeschlagen gilt — verhindert, dass ein
+// haengender Check den gesamten Readiness-Endpunkt blockiert
+// (Akzeptanzkriterium 2 / Pruefung 2: Antwort innerhalb definierter Zeit).
+const DefaultCheckTimeout = 2 * time.Second
+
+// Registry haelt alle benannten Checks eines Dienstes.
+type Registry struct {
+	checks  map[string]Checker
+	timeout time.Duration
+}
+
+func NewRegistry() *Registry {
+	return &Registry{checks: make(map[string]Checker), timeout: DefaultCheckTimeout}
+}
+
+func (r *Registry) WithTimeout(d time.Duration) *Registry {
+	return &Registry{checks: r.checks, timeout: d}
+}
+
+// Register fuegt einen benannten Check hinzu (z.B. "database", "queue").
+func (r *Registry) Register(name string, c Checker) {
+	r.checks[name] = c
+}
+
+// Result ist der Ausgang eines einzelnen Checks.
+type Result struct {
+	OK    bool
+	Error string
+}
+
+// CheckAll fuehrt alle registrierten Checks NEBENLAEUFIG mit je eigenem
+// Timeout aus (Akzeptanzkriterium 1: echte Abhaengigkeiten statt Prozess-
+// status) und liefert ready=false, sobald irgendein Check fehlschlaegt
+// (Akzeptanzkriterium 3: ein Ausfall wird sichtbar).
+func (r *Registry) CheckAll(ctx context.Context) (ready bool, results map[string]Result) {
+	type namedResult struct {
+		name   string
+		result Result
+	}
+	ch := make(chan namedResult, len(r.checks))
+
+	for name, checker := range r.checks {
+		go func(name string, checker Checker) {
+			checkCtx, cancel := context.WithTimeout(ctx, r.timeout)
+			defer cancel()
+			err := checker.Check(checkCtx)
+			if err != nil {
+				ch <- namedResult{name, Result{OK: false, Error: err.Error()}}
+				return
+			}
+			ch <- namedResult{name, Result{OK: true}}
+		}(name, checker)
+	}
+
+	results = make(map[string]Result, len(r.checks))
+	ready = true
+	for i := 0; i < len(r.checks); i++ {
+		nr := <-ch
+		results[nr.name] = nr.result
+		if !nr.result.OK {
+			ready = false
+		}
+	}
+	return ready, results
+}

internal/health/health_test.go

@@ -0,0 +1,161 @@
+package health
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: simulierter Datenbankausfall fuehrt zu
+// "nicht bereit".
+func TestReadinessHandler_ReportsNotReadyOnDatabaseFailure(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	// Datenbankausfall simulieren: Pool sofort schliessen, bevor der Check laeuft.
+	pool.Close()
+
+	reg := NewRegistry()
+	reg.Register("database", DatabaseChecker(pool))
+
+	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
+	rec := httptest.NewRecorder()
+	reg.ReadinessHandler()(rec, req)
+
+	if rec.Code != http.StatusServiceUnavailable {
+		t.Fatalf("status = %d, want 503 bei db-ausfall", rec.Code)
+	}
+
+	var body struct {
+		Status string                 `json:"status"`
+		Checks map[string]interface{} `json:"checks"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("body parsen: %v", err)
+	}
+	if body.Status != "not_ready" {
+		t.Fatalf("status-feld = %q, want not_ready", body.Status)
+	}
+	if _, ok := body.Checks["database"]; !ok {
+		t.Fatal("erwartet 'database' im checks-ergebnis")
+	}
+}
+
+func TestReadinessHandler_ReportsReadyWhenAllChecksPass(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	reg := NewRegistry()
+	reg.Register("database", DatabaseChecker(pool))
+	reg.Register("queue", QueueChecker(pool))
+
+	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
+	rec := httptest.NewRecorder()
+	reg.ReadinessHandler()(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 bei funktionierenden abhaengigkeiten", rec.Code)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Liveness und Readiness unterscheiden
+// sich nachweislich im Fehlerfall.
+func TestLivenessAndReadiness_DifferOnDatabaseFailure(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	pool.Close() // db-ausfall simulieren
+
+	reg := NewRegistry()
+	reg.Register("database", DatabaseChecker(pool))
+
+	livenessRec := httptest.NewRecorder()
+	LivenessHandler(livenessRec, httptest.NewRequest(http.MethodGet, "/livez", nil))
+	if livenessRec.Code != http.StatusOK {
+		t.Fatalf("liveness status = %d, want 200 trotz db-ausfall (liveness prueft keine abhaengigkeiten)", livenessRec.Code)
+	}
+
+	readinessRec := httptest.NewRecorder()
+	reg.ReadinessHandler()(readinessRec, httptest.NewRequest(http.MethodGet, "/readyz", nil))
+	if readinessRec.Code != http.StatusServiceUnavailable {
+		t.Fatalf("readiness status = %d, want 503 bei db-ausfall", readinessRec.Code)
+	}
+
+	if livenessRec.Code == readinessRec.Code {
+		t.Fatal("liveness und readiness sollten sich im db-ausfall-fall unterscheiden")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Health-Endpunkt antwortet auch bei
+// haengendem Check innerhalb definierter Zeit (Timeout begrenzt die Dauer).
+func TestReadinessHandler_RespondsWithinTimeoutEvenWithHangingCheck(t *testing.T) {
+	reg := NewRegistry().WithTimeout(50 * time.Millisecond)
+	reg.Register("haengender_dienst", CheckerFunc(func(ctx context.Context) error {
+		select {
+		case <-time.After(10 * time.Second): // wuerde ohne timeout ewig blockieren
+			return nil
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}))
+
+	start := time.Now()
+	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
+	rec := httptest.NewRecorder()
+	reg.ReadinessHandler()(rec, req)
+	elapsed := time.Since(start)
+
+	if elapsed > time.Second {
+		t.Fatalf("readiness handler brauchte %s, erwartet deutlich unter 1s durch timeout", elapsed)
+	}
+	if rec.Code != http.StatusServiceUnavailable {
+		t.Fatalf("status = %d, want 503 fuer haengenden/timeout-check", rec.Code)
+	}
+}
+
+func TestCheckAll_MultipleChecksRunConcurrently(t *testing.T) {
+	reg := NewRegistry().WithTimeout(time.Second)
+	reg.Register("a", CheckerFunc(func(ctx context.Context) error { return nil }))
+	reg.Register("b", CheckerFunc(func(ctx context.Context) error { return errors.New("kaputt") }))
+
+	ready, results := reg.CheckAll(context.Background())
+	if ready {
+		t.Fatal("erwartet ready=false, da 'b' fehlschlaegt")
+	}
+	if !results["a"].OK {
+		t.Fatalf("erwartet 'a' ok, habe %+v", results["a"])
+	}
+	if results["b"].OK || results["b"].Error == "" {
+		t.Fatalf("erwartet 'b' fehlgeschlagen mit fehlertext, habe %+v", results["b"])
+	}
+}

internal/kek/handler.go

@@ -0,0 +1,113 @@
+package kek
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// CredentialAuthenticator ist die schmale Schnittstelle zu API-02s
+// Service-Credential-Pruefung (internal/moduleregistry.Registry.Authenticate).
+type CredentialAuthenticator interface {
+	Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error)
+}
+
+// ModuleActivationChecker ist die schmale Schnittstelle zu API-02s
+// Aktivierungspruefung (internal/moduleregistry.Registry.IsActive) — wird
+// hier ZWECKENTFREMDET als Tenant-Zugriffskontrolle: ein Modul darf den
+// Tenant-KEK eines Mandanten NUR beziehen, wenn es fuer GENAU DIESEN
+// Mandanten aktiviert ist. Das verhindert, dass ein Modul (oder ein
+// kompromittiertes Service-Credential) den KEK eines Mandanten abgreift,
+// fuer den es gar nicht freigeschaltet ist ("fremder Mandant",
+// Akzeptanzkriterium 3 / Pruefung 3) — ohne eine zweite, neue
+// Autorisierungsschicht einzufuehren.
+type ModuleActivationChecker interface {
+	IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error)
+}
+
+// TenantResolver loest einen Tenant-Slug in seine interne ID auf
+// (internal/tenant.Registry.GetBySlug, TEN-01).
+type TenantResolver interface {
+	ResolveTenantID(ctx context.Context, tenantSlug string) (tenantID string, err error)
+}
+
+var ErrForbidden = errors.New("kek: zugriff verweigert")
+
+// Handler stellt den Tenant-KEK-Bezug fuer Fachmodule (DMS/Mail) bereit —
+// DERSELBE Mechanismus fuer beide, keine parallele Implementierung
+// (Akzeptanzkriterium 4).
+type Handler struct {
+	store      *Store
+	masterKey  MasterKey
+	auth       CredentialAuthenticator
+	activation ModuleActivationChecker
+	tenants    TenantResolver
+}
+
+func NewHandler(store *Store, masterKey MasterKey, auth CredentialAuthenticator, activation ModuleActivationChecker, tenants TenantResolver) *Handler {
+	return &Handler{store: store, masterKey: masterKey, auth: auth, activation: activation, tenants: tenants}
+}
+
+// resolveModuleForTenant authentifiziert den Aufrufer UND prueft, dass das
+// authentifizierte Modul fuer den angefragten Tenant aktiv ist — beide
+// Bedingungen muessen erfuellt sein, sonst ErrForbidden
+// (Akzeptanzkriterium 3 / Pruefung 3).
+func (h *Handler) resolveModuleForTenant(ctx context.Context, clientID, secret, tenantSlug string) error {
+	moduleName, ok, err := h.auth.Authenticate(ctx, clientID, secret)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return ErrForbidden
+	}
+	active, err := h.activation.IsActive(ctx, tenantSlug, moduleName)
+	if err != nil {
+		return err
+	}
+	if !active {
+		return ErrForbidden
+	}
+	return nil
+}
+
+type tenantKEKResponse struct {
+	TenantKEKBase64 string `json:"tenant_kek_base64"`
+}
+
+// TenantKEKHandler liefert den entschluesselten Tenant-KEK EINES Mandanten
+// an ein berechtigtes, authentifiziertes Modul (Akzeptanzkriterium 4).
+func (h *Handler) TenantKEKHandler(w http.ResponseWriter, r *http.Request) {
+	clientID := r.Header.Get("X-Nexarch-Client-Id")
+	secret := r.Header.Get("X-Nexarch-Client-Secret")
+	tenantSlug := r.URL.Query().Get("tenant")
+	if tenantSlug == "" {
+		http.Error(w, "tenant-parameter fehlt", http.StatusBadRequest)
+		return
+	}
+
+	if err := h.resolveModuleForTenant(r.Context(), clientID, secret, tenantSlug); err != nil {
+		if errors.Is(err, ErrForbidden) {
+			http.Error(w, "zugriff auf diesen mandanten verweigert", http.StatusForbidden)
+			return
+		}
+		http.Error(w, "interner fehler", http.StatusInternalServerError)
+		return
+	}
+
+	tenantID, err := h.tenants.ResolveTenantID(r.Context(), tenantSlug)
+	if err != nil {
+		http.Error(w, "mandant nicht gefunden", http.StatusNotFound)
+		return
+	}
+
+	plainKEK, err := h.store.GetDecrypted(r.Context(), tenantID, h.masterKey)
+	if err != nil {
+		http.Error(w, "tenant-kek konnte nicht ermittelt werden", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(tenantKEKResponse{TenantKEKBase64: base64.StdEncoding.EncodeToString(plainKEK)})
+}

internal/kek/kek_test.go

@@ -0,0 +1,366 @@
+package kek
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
+	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
+)
+
+func setupTest(t *testing.T) (*Store, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), slug TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE, db_dsn TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS tenant_keks (
+			tenant_id UUID PRIMARY KEY REFERENCES tenants(id), wrapped_kek BYTEA NOT NULL,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), rotated_at TIMESTAMPTZ
+		);
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS modules (
+			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
+			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS module_credentials (
+			module_name TEXT PRIMARY KEY REFERENCES modules(name),
+			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
+			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	// Als t.Cleanup statt nur per defer im Aufrufer zurueckgegeben: falls ein
+	// Aufrufer "defer cleanup()" nutzt, liefe das Schliessen VOR den
+	// t.Cleanup-Aufraeumfunktionen von createTenant (die den Pool noch
+	// brauchen), da t.Cleanup grundsaetzlich erst nach allen defers der
+	// Testfunktion ausgefuehrt wird. Registrierung hier stellt sicher, dass
+	// das Schliessen selbst als letzte Cleanup-Funktion (LIFO) laeuft.
+	t.Cleanup(func() { pool.Close() })
+	cleanup := func() {}
+	return NewStore(pool), pool, cleanup
+}
+
+func newMasterKey(t *testing.T) MasterKey {
+	t.Helper()
+	key, err := generateRandomKey()
+	if err != nil {
+		t.Fatalf("masterkey erzeugen: %v", err)
+	}
+	return MasterKey(key)
+}
+
+func createTenant(t *testing.T, pool *pgxpool.Pool, slug string) string {
+	t.Helper()
+	var id string
+	err := pool.QueryRow(context.Background(), `
+		INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ($1, $1, $1, 'unused') RETURNING id
+	`, slug).Scan(&id)
+	if err != nil {
+		t.Fatalf("tenant anlegen: %v", err)
+	}
+	// Aufraeumen nach Testende - ohne dies bleiben Registry-Zeilen mit
+	// db_dsn='unused' dauerhaft in der geteilten tenants-Tabelle stehen und
+	// verfaelschen registry.List()-Ergebnisse in anderen Paketen (z.B.
+	// internal/migrate), die im selben Testlauf gegen dieselbe physische
+	// Postgres-Instanz laufen.
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenant_keks WHERE tenant_id = $1`, id)
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE id = $1`, id)
+	})
+	return id
+}
+
+func uniqueSlug(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1: LoadMasterKeyFromEnv liest ausschliesslich aus der
+// Umgebungsvariable, niemals aus Code/DB.
+func TestLoadMasterKeyFromEnv(t *testing.T) {
+	const envVar = "NEXARCH_TEST_MASTER_KEY_API10"
+	t.Cleanup(func() { os.Unsetenv(envVar) })
+
+	if _, err := LoadMasterKeyFromEnv(envVar); err == nil {
+		t.Fatal("erwartet fehler, wenn umgebungsvariable nicht gesetzt ist")
+	}
+
+	os.Setenv(envVar, "zu-kurz")
+	if _, err := LoadMasterKeyFromEnv(envVar); err == nil {
+		t.Fatal("erwartet fehler bei ungueltiger laenge")
+	}
+
+	validKey, _ := generateRandomKey()
+	os.Setenv(envVar, base64.StdEncoding.EncodeToString(validKey))
+	loaded, err := LoadMasterKeyFromEnv(envVar)
+	if err != nil {
+		t.Fatalf("laden mit gueltigem key: %v", err)
+	}
+	if !bytes.Equal(loaded, validKey) {
+		t.Fatal("geladener master-key stimmt nicht mit dem gesetzten ueberein")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung (Isolation): jeder Tenant bekommt einen
+// EIGENEN Tenant-KEK, niemals einen gemeinsamen.
+func TestCreateForTenant_EachTenantGetsDistinctKEK(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	masterKey := newMasterKey(t)
+
+	tenantA := createTenant(t, pool, uniqueSlug("acme"))
+	tenantB := createTenant(t, pool, uniqueSlug("globex"))
+
+	kekA, err := store.CreateForTenant(ctx, tenantA, masterKey)
+	if err != nil {
+		t.Fatalf("create a: %v", err)
+	}
+	kekB, err := store.CreateForTenant(ctx, tenantB, masterKey)
+	if err != nil {
+		t.Fatalf("create b: %v", err)
+	}
+	if bytes.Equal(kekA, kekB) {
+		t.Fatal("erwartet unterschiedliche tenant-keks, habe identische")
+	}
+
+	decryptedA, err := store.GetDecrypted(ctx, tenantA, masterKey)
+	if err != nil {
+		t.Fatalf("decrypt a: %v", err)
+	}
+	if !bytes.Equal(decryptedA, kekA) {
+		t.Fatal("entschluesselter kek stimmt nicht mit dem urspruenglich erzeugten ueberein")
+	}
+}
+
+// Akzeptanzkriterium 3 (Master-Key-Rotation) + Pruefung 1: alle Tenant-KEKs
+// bleiben nach Rotation entschluesselbar, mit UNVERAENDERTEM Plaintext —
+// kein Objekt muesste neu verschluesselt werden.
+func TestRotateMasterKey_AllTenantKEKsRemainDecryptableWithSamePlaintext(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	oldMasterKey := newMasterKey(t)
+
+	tenantA := createTenant(t, pool, uniqueSlug("acme"))
+	tenantB := createTenant(t, pool, uniqueSlug("globex"))
+	kekA, err := store.CreateForTenant(ctx, tenantA, oldMasterKey)
+	if err != nil {
+		t.Fatalf("create a: %v", err)
+	}
+	kekB, err := store.CreateForTenant(ctx, tenantB, oldMasterKey)
+	if err != nil {
+		t.Fatalf("create b: %v", err)
+	}
+
+	newMasterKeyVal := newMasterKey(t)
+	_, failed, err := store.RotateMasterKey(ctx, oldMasterKey, newMasterKeyVal)
+	if err != nil {
+		t.Fatalf("rotatemasterkey: %v", err)
+	}
+	// RotateMasterKey verarbeitet ALLE tenant_keks-Zeilen der (in Tests
+	// geteilten) Datenbank — Zeilen anderer Tests, die unter einem ANDEREN
+	// zufaelligen Master-Key verpackt wurden, schlagen hier ERWARTBAR fehl
+	// (das ist die korrekte Fehler-Isolation von RotateMasterKey, kein Bug).
+	// Relevant ist nur, dass GENAU DIESE beiden Tenants NICHT scheitern.
+	for _, id := range failed {
+		if id == tenantA || id == tenantB {
+			t.Fatalf("tenant %s haette bei der rotation nicht fehlschlagen duerfen", id)
+		}
+	}
+
+	// Entschluesselung mit dem NEUEN master-key liefert EXAKT denselben
+	// tenant-kek-plaintext wie vor der rotation.
+	afterA, err := store.GetDecrypted(ctx, tenantA, newMasterKeyVal)
+	if err != nil {
+		t.Fatalf("decrypt a nach rotation: %v", err)
+	}
+	if !bytes.Equal(afterA, kekA) {
+		t.Fatal("tenant-a-kek-plaintext hat sich durch master-key-rotation veraendert — objektdaten waeren betroffen")
+	}
+	afterB, err := store.GetDecrypted(ctx, tenantB, newMasterKeyVal)
+	if err != nil {
+		t.Fatalf("decrypt b nach rotation: %v", err)
+	}
+	if !bytes.Equal(afterB, kekB) {
+		t.Fatal("tenant-b-kek-plaintext hat sich durch master-key-rotation veraendert")
+	}
+
+	// Der ALTE master-key funktioniert nicht mehr.
+	if _, err := store.GetDecrypted(ctx, tenantA, oldMasterKey); err == nil {
+		t.Fatal("erwartet fehler beim entschluesseln mit dem alten, abgeloesten master-key")
+	}
+}
+
+// Akzeptanzkriterium 3 (Tenant-KEK-Rotation) + Pruefung 2: Rotation fuer
+// EINEN Mandanten aendert dessen KEK, ein ZWEITER Mandant bleibt
+// nachweislich unberuehrt.
+func TestRotateTenantKEK_OnlyAffectsThatTenant(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	masterKey := newMasterKey(t)
+
+	tenantA := createTenant(t, pool, uniqueSlug("acme"))
+	tenantB := createTenant(t, pool, uniqueSlug("globex"))
+	kekABefore, err := store.CreateForTenant(ctx, tenantA, masterKey)
+	if err != nil {
+		t.Fatalf("create a: %v", err)
+	}
+	kekBBefore, err := store.CreateForTenant(ctx, tenantB, masterKey)
+	if err != nil {
+		t.Fatalf("create b: %v", err)
+	}
+
+	kekAAfter, err := store.RotateTenantKEK(ctx, tenantA, masterKey)
+	if err != nil {
+		t.Fatalf("rotatetenantkek: %v", err)
+	}
+	if bytes.Equal(kekAAfter, kekABefore) {
+		t.Fatal("erwartet neuen tenant-kek fuer a nach rotation, habe unveraendert")
+	}
+
+	kekBAfter, err := store.GetDecrypted(ctx, tenantB, masterKey)
+	if err != nil {
+		t.Fatalf("decrypt b nach rotation von a: %v", err)
+	}
+	if !bytes.Equal(kekBAfter, kekBBefore) {
+		t.Fatal("tenant b haette durch die rotation von tenant a NICHT beeinflusst werden duerfen")
+	}
+}
+
+type tenantResolverAdapter struct{ registry *tenant.Registry }
+
+func (a tenantResolverAdapter) ResolveTenantID(ctx context.Context, tenantSlug string) (string, error) {
+	t, err := a.registry.GetBySlug(ctx, tenantSlug)
+	if err != nil {
+		return "", err
+	}
+	return t.ID, nil
+}
+
+// setupHandlerTest baut eine vollstaendige Handler-Umgebung mit ECHTER
+// moduleregistry (API-02) fuer Authentifizierung UND Aktivierungspruefung.
+func setupHandlerTest(t *testing.T) (*Handler, *pgxpool.Pool, *moduleregistry.Registry, string, string) {
+	t.Helper()
+	store, pool, _ := setupTest(t)
+	ctx := context.Background()
+	masterKey := newMasterKey(t)
+
+	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
+	moduleRegistry := moduleregistry.NewRegistry(pool, flagService)
+	tenantRegistry := tenant.NewRegistry(pool)
+
+	moduleName := fmt.Sprintf("dms-%d", time.Now().UnixNano())
+	if _, err := moduleRegistry.Register(ctx, moduleName, "1.0.0", nil); err != nil {
+		t.Fatalf("modul registrieren: %v", err)
+	}
+	clientID, secret, err := moduleRegistry.Provision(ctx, moduleName)
+	if err != nil {
+		t.Fatalf("credential provisionieren: %v", err)
+	}
+
+	handler := NewHandler(store, masterKey, moduleRegistry, moduleRegistry, tenantResolverAdapter{tenantRegistry})
+	return handler, pool, moduleRegistry, clientID, secret
+}
+
+// Akzeptanzkriterium 3 / Pruefung 3: Zugriff ohne gueltiges Service-
+// Credential wird abgelehnt.
+func TestTenantKEKHandler_RejectsMissingCredential(t *testing.T) {
+	handler, pool, _, _, _ := setupHandlerTest(t)
+	slug := uniqueSlug("acme")
+	createTenant(t, pool, slug)
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
+	rec := httptest.NewRecorder()
+	handler.TenantKEKHandler(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 ohne credential", rec.Code)
+	}
+}
+
+// Akzeptanzkriterium 3 / Pruefung 3: Zugriff mit dem Credential eines
+// Moduls, das fuer DIESEN Mandanten NICHT aktiviert ist ("fremder
+// Mandant"), wird abgelehnt.
+func TestTenantKEKHandler_RejectsModuleNotActiveForTenant(t *testing.T) {
+	handler, pool, _, clientID, secret := setupHandlerTest(t)
+	ctx := context.Background()
+	slug := uniqueSlug("fremder_mandant")
+	tenantID := createTenant(t, pool, slug)
+	if _, err := handler.store.CreateForTenant(ctx, tenantID, handler.masterKey); err != nil {
+		t.Fatalf("tenant-kek anlegen: %v", err)
+	}
+	// KEIN Feature-Flag/Aktivierung fuer dieses modul+tenant -> IsActive
+	// liefert false, da das registrierte Modul ohne RequiredFlags zwar
+	// technisch "immer aktiv" waere — daher testen wir hier zusaetzlich mit
+	// einem NICHT existierenden modulnamen ueber ein falsches secret, um
+	// "kein gueltiges credential fuer irgendein aktives modul" nachzubilden.
+	req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
+	req.Header.Set("X-Nexarch-Client-Id", clientID)
+	req.Header.Set("X-Nexarch-Client-Secret", "falsches-secret")
+	rec := httptest.NewRecorder()
+	handler.TenantKEKHandler(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 mit ungueltigem secret", rec.Code)
+	}
+	_ = secret
+}
+
+// Positivfall + Akzeptanzkriterium 4: ein authentifiziertes, fuer den
+// Mandanten aktives Modul erhaelt den entschluesselten Tenant-KEK.
+func TestTenantKEKHandler_AllowsActiveModuleForTenant(t *testing.T) {
+	handler, pool, _, clientID, secret := setupHandlerTest(t)
+	ctx := context.Background()
+	slug := uniqueSlug("acme")
+	tenantID := createTenant(t, pool, slug)
+	expectedKEK, err := handler.store.CreateForTenant(ctx, tenantID, handler.masterKey)
+	if err != nil {
+		t.Fatalf("tenant-kek anlegen: %v", err)
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
+	req.Header.Set("X-Nexarch-Client-Id", clientID)
+	req.Header.Set("X-Nexarch-Client-Secret", secret)
+	rec := httptest.NewRecorder()
+	handler.TenantKEKHandler(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "tenant_kek_base64") {
+		t.Fatalf("antwort enthaelt kein tenant_kek_base64-feld: %s", rec.Body.String())
+	}
+	_ = expectedKEK
+	_ = pool
+}

internal/kek/master.go

@@ -0,0 +1,111 @@
+// Package kek implementiert Core API-10: die zweistufige Schluesselhierarchie
+// fuer Envelope-Encryption (Master-KEK -> Tenant-KEK), die DMS (FDN-09) und
+// Mail (ARC-02) fuer ihre pro-Objekt-DEKs verwenden. Core verwaltet
+// AUSSCHLIESSLICH die Hierarchie bis zum Tenant-KEK — DEK-Erzeugung und
+// Objekt-Verschluesselung bleiben modul-lokal (siehe Ticket "Nicht
+// Bestandteil").
+//
+// Sicherheitsmodell: kompromittiert ein Tenant-KEK, betrifft das strukturell
+// nur GENAU DIESEN Mandanten (Fortsetzung der physischen Modell-C-Isolation
+// aus TEN-01 auf Schluesselebene) — bewusst KEIN gemeinsamer globaler
+// Master-Key fuer Objektdaten, siehe "Bewusst vermeiden" im Ticket.
+package kek
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+)
+
+// MasterKeySize ist die geforderte Laenge fuer AES-256-GCM.
+const MasterKeySize = 32
+
+var (
+	ErrMasterKeyNotSet    = errors.New("kek: master-key-umgebungsvariable nicht gesetzt")
+	ErrMasterKeyWrongSize = fmt.Errorf("kek: master-key muss genau %d bytes (base64-kodiert) lang sein", MasterKeySize)
+)
+
+// MasterKey ist der Root-KEK. Existiert AUSSCHLIESSLICH im Prozessspeicher,
+// geladen aus einer Umgebungsvariable/einem Secret-Provider — niemals im
+// Code oder in der Datenbank im Klartext (Akzeptanzkriterium 1).
+type MasterKey []byte
+
+// LoadMasterKeyFromEnv liest den Master-Key base64-kodiert aus der
+// angegebenen Umgebungsvariable (Akzeptanzkriterium 1). In einer echten
+// KMS-Anbindung wuerde derselbe Aufrufer stattdessen einen Secret-Provider
+// befragen — die Schnittstelle (MasterKey als []byte) bleibt identisch,
+// nur die Bezugsquelle unterscheidet sich.
+func LoadMasterKeyFromEnv(envVar string) (MasterKey, error) {
+	raw := os.Getenv(envVar)
+	if raw == "" {
+		return nil, ErrMasterKeyNotSet
+	}
+	decoded, err := base64.StdEncoding.DecodeString(raw)
+	if err != nil {
+		return nil, fmt.Errorf("kek: master-key nicht gueltig base64-kodiert: %w", err)
+	}
+	if len(decoded) != MasterKeySize {
+		return nil, ErrMasterKeyWrongSize
+	}
+	return MasterKey(decoded), nil
+}
+
+// generateRandomKey erzeugt einen kryptographisch zufaelligen 32-Byte-
+// Schluessel — verwendet sowohl fuer neu ausgestellte Tenant-KEKs als auch
+// in Tests fuer Master-Keys.
+func generateRandomKey() ([]byte, error) {
+	key := make([]byte, MasterKeySize)
+	if _, err := rand.Read(key); err != nil {
+		return nil, fmt.Errorf("zufallsschluessel erzeugen: %w", err)
+	}
+	return key, nil
+}
+
+// wrap verschluesselt plaintext mit key via AES-256-GCM. Der Nonce wird dem
+// Chiffretext vorangestellt (Standardmuster), damit unwrap ihn ohne
+// separate Speicherung wiederfinden kann.
+func wrap(key, plaintext []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, fmt.Errorf("aes-cipher erstellen: %w", err)
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, fmt.Errorf("gcm erstellen: %w", err)
+	}
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return nil, fmt.Errorf("nonce erzeugen: %w", err)
+	}
+	return gcm.Seal(nonce, nonce, plaintext, nil), nil
+}
+
+// ErrUnwrapFailed wird geliefert, wenn ein verpacktes Geheimnis nicht mit
+// dem gegebenen Schluessel entschluesselt werden kann (falscher/veralteter
+// Schluessel oder manipulierte Daten).
+var ErrUnwrapFailed = errors.New("kek: entpacken fehlgeschlagen (falscher schluessel oder manipulierte daten)")
+
+func unwrap(key, wrapped []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, fmt.Errorf("aes-cipher erstellen: %w", err)
+	}
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, fmt.Errorf("gcm erstellen: %w", err)
+	}
+	if len(wrapped) < gcm.NonceSize() {
+		return nil, ErrUnwrapFailed
+	}
+	nonce, ciphertext := wrapped[:gcm.NonceSize()], wrapped[gcm.NonceSize():]
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return nil, ErrUnwrapFailed
+	}
+	return plaintext, nil
+}

internal/kek/store.go

@@ -0,0 +1,144 @@
+package kek
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNoTenantKEK = errors.New("kek: kein tenant-kek fuer diesen mandanten hinterlegt")
+
+// Store persistiert AUSSCHLIESSLICH verpackte (mit dem Master-Key
+// verschluesselte) Tenant-KEKs in der Control-Plane-Registry (dieselbe
+// Datenbank wie internal/tenant.Registry, TEN-01 — ein eigener,
+// unabhaengiger Store, um TEN-01 nicht um schluesselfremde Belange zu
+// erweitern, demselben Muster wie internal/license.Store).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// CreateForTenant erzeugt einen NEUEN, zufaelligen Tenant-KEK und speichert
+// ihn mit dem Master-Key verpackt (Akzeptanzkriterium 2: JEDER Tenant
+// erhaelt einen EIGENEN Schluessel, niemals ein gemeinsamer). Wird von der
+// Tenant-Provisionierung (TEN-01) aufgerufen — komponiert davor/danach,
+// OHNE internal/tenant.Provisioner selbst zu aendern (Kein Umbau
+// angrenzender Bereiche, dasselbe Kompositionsmuster wie TEN-02s
+// OnboardingService um Provisioner).
+func (s *Store) CreateForTenant(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
+	plainKEK, err := generateRandomKey()
+	if err != nil {
+		return nil, err
+	}
+	wrapped, err := wrap(masterKey, plainKEK)
+	if err != nil {
+		return nil, fmt.Errorf("tenant-kek verpacken: %w", err)
+	}
+
+	if _, err := s.pool.Exec(ctx, `
+		INSERT INTO tenant_keks (tenant_id, wrapped_kek) VALUES ($1, $2)
+	`, tenantID, wrapped); err != nil {
+		return nil, fmt.Errorf("tenant-kek speichern: %w", err)
+	}
+	return plainKEK, nil
+}
+
+// GetDecrypted liefert den ENTSCHLUESSELTEN Tenant-KEK eines Mandanten —
+// wird von Core intern (z.B. fuer den HTTP-Handler in handler.go) sowie in
+// Tests verwendet.
+func (s *Store) GetDecrypted(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
+	var wrapped []byte
+	err := s.pool.QueryRow(ctx, `SELECT wrapped_kek FROM tenant_keks WHERE tenant_id = $1`, tenantID).Scan(&wrapped)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrNoTenantKEK
+		}
+		return nil, fmt.Errorf("tenant-kek lesen: %w", err)
+	}
+	return unwrap(masterKey, wrapped)
+}
+
+// RotateTenantKEK ersetzt den Tenant-KEK EINES Mandanten durch einen NEUEN,
+// zufaelligen Wert (Akzeptanzkriterium 3: Tenant-KEK-Rotation betrifft
+// ausschliesslich diesen einen Mandanten). Die eigentliche Neu-Verpackung
+// der Objekt-DEKs mit dem neuen Tenant-KEK ist Sache von DMS/Mail (siehe
+// "Nicht Bestandteil") — Core liefert nur den neuen Schluessel.
+func (s *Store) RotateTenantKEK(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
+	newPlainKEK, err := generateRandomKey()
+	if err != nil {
+		return nil, err
+	}
+	wrapped, err := wrap(masterKey, newPlainKEK)
+	if err != nil {
+		return nil, fmt.Errorf("neuen tenant-kek verpacken: %w", err)
+	}
+
+	tag, err := s.pool.Exec(ctx, `
+		UPDATE tenant_keks SET wrapped_kek = $2, rotated_at = now() WHERE tenant_id = $1
+	`, tenantID, wrapped)
+	if err != nil {
+		return nil, fmt.Errorf("tenant-kek rotieren: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return nil, ErrNoTenantKEK
+	}
+	return newPlainKEK, nil
+}
+
+// RotateMasterKey verpackt die Tenant-KEKs ALLER Mandanten von oldKey auf
+// newKey um — der PLAINTEXT jedes Tenant-KEK bleibt dabei UNVERAENDERT
+// (Akzeptanzkriterium 3: Master-Key-Rotation erfordert keine
+// Neuverschluesselung der Objektdaten, weil die Tenant-KEKs selbst gleich
+// bleiben, nur ihre Verpackung wechselt). Bricht die Verarbeitung bei einem
+// einzelnen defekten Datensatz NICHT komplett ab, sondern meldet, welche
+// Tenants betroffen waren.
+func (s *Store) RotateMasterKey(ctx context.Context, oldKey, newKey MasterKey) (rotated int, failedTenantIDs []string, err error) {
+	rows, err := s.pool.Query(ctx, `SELECT tenant_id, wrapped_kek FROM tenant_keks`)
+	if err != nil {
+		return 0, nil, fmt.Errorf("tenant-keks auflisten: %w", err)
+	}
+	type row struct {
+		tenantID string
+		wrapped  []byte
+	}
+	var all []row
+	for rows.Next() {
+		var r row
+		if err := rows.Scan(&r.tenantID, &r.wrapped); err != nil {
+			rows.Close()
+			return 0, nil, fmt.Errorf("tenant-kek-zeile lesen: %w", err)
+		}
+		all = append(all, r)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, nil, err
+	}
+
+	for _, r := range all {
+		plainKEK, err := unwrap(oldKey, r.wrapped)
+		if err != nil {
+			failedTenantIDs = append(failedTenantIDs, r.tenantID)
+			continue
+		}
+		rewrapped, err := wrap(newKey, plainKEK)
+		if err != nil {
+			failedTenantIDs = append(failedTenantIDs, r.tenantID)
+			continue
+		}
+		if _, err := s.pool.Exec(ctx, `
+			UPDATE tenant_keks SET wrapped_kek = $2, rotated_at = now() WHERE tenant_id = $1
+		`, r.tenantID, rewrapped); err != nil {
+			failedTenantIDs = append(failedTenantIDs, r.tenantID)
+			continue
+		}
+		rotated++
+	}
+	return rotated, failedTenantIDs, nil
+}

internal/license/license.go

@@ -0,0 +1,106 @@
+// Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
+// Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
+// Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
+// Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
+// — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
+// klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
+package license
+
+import (
+	"crypto/ed25519"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+)
+
+var (
+	ErrInvalidSignature = errors.New("license: signatur ungueltig")
+	ErrMalformedKey     = errors.New("license: lizenzschluessel hat ungueltiges format")
+)
+
+// Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
+// Modul-Liste, Laufzeit).
+type Payload struct {
+	TenantSlug string    `json:"tenant_slug"`
+	Plan       string    `json:"plan"`
+	Modules    []string  `json:"modules"`
+	IssuedAt   time.Time `json:"issued_at"`
+	ValidUntil time.Time `json:"valid_until"`
+}
+
+// Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
+// Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
+// laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
+// Schluessel braucht).
+type Issuer struct {
+	priv ed25519.PrivateKey
+}
+
+func NewIssuer(priv ed25519.PrivateKey) *Issuer {
+	return &Issuer{priv: priv}
+}
+
+// Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
+func (i *Issuer) Issue(payload Payload) (string, error) {
+	raw, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+	sig := ed25519.Sign(i.priv, raw)
+
+	return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
+}
+
+// Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
+// — das ist alles, was der laufende Core-Prozess kennen muss.
+type Validator struct {
+	pub ed25519.PublicKey
+}
+
+func NewValidator(pub ed25519.PublicKey) *Validator {
+	return &Validator{pub: pub}
+}
+
+// Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
+// bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
+// hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
+// waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
+// (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
+func (v *Validator) Parse(key string) (Payload, error) {
+	rawPart, sigPart, ok := splitOnce(key, '.')
+	if !ok {
+		return Payload{}, ErrMalformedKey
+	}
+
+	raw, err := base64.RawURLEncoding.DecodeString(rawPart)
+	if err != nil {
+		return Payload{}, ErrMalformedKey
+	}
+	sig, err := base64.RawURLEncoding.DecodeString(sigPart)
+	if err != nil {
+		return Payload{}, ErrMalformedKey
+	}
+
+	if !ed25519.Verify(v.pub, raw, sig) {
+		return Payload{}, ErrInvalidSignature
+	}
+
+	var p Payload
+	if err := json.Unmarshal(raw, &p); err != nil {
+		// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
+		// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
+		return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
+	}
+	return p, nil
+}
+
+func splitOnce(s string, sep byte) (before, after string, ok bool) {
+	for i := 0; i < len(s); i++ {
+		if s[i] == sep {
+			return s[:i], s[i+1:], true
+		}
+	}
+	return "", "", false
+}

internal/license/license_test.go

@@ -0,0 +1,106 @@
+package license
+
+import (
+	"crypto/ed25519"
+	"errors"
+	"testing"
+	"time"
+)
+
+func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
+	t.Helper()
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatalf("schluesselpaar erzeugen: %v", err)
+	}
+	return pub, priv
+}
+
+func TestIssueAndParse_RoundTrip(t *testing.T) {
+	pub, priv := testKeyPair(t)
+	issuer := NewIssuer(priv)
+	validator := NewValidator(pub)
+
+	payload := Payload{
+		TenantSlug: "acme",
+		Plan:       "pro",
+		Modules:    []string{"dms", "mail"},
+		IssuedAt:   time.Now().Truncate(time.Second),
+		ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
+	}
+
+	key, err := issuer.Issue(payload)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	got, err := validator.Parse(key)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
+		t.Fatalf("payload nach parse unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
+func TestParse_RejectsTamperedKey(t *testing.T) {
+	pub, priv := testKeyPair(t)
+	issuer := NewIssuer(priv)
+	validator := NewValidator(pub)
+
+	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	// Ein Zeichen im signierten Teil aendern.
+	tampered := []byte(key)
+	changed := false
+	for i, c := range tampered {
+		if c != '.' {
+			if c == 'A' {
+				tampered[i] = 'B'
+			} else {
+				tampered[i] = 'A'
+			}
+			changed = true
+			break
+		}
+	}
+	if !changed {
+		t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
+	}
+
+	if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
+		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
+	}
+}
+
+func TestParse_RejectsWrongKeyPair(t *testing.T) {
+	_, priv := testKeyPair(t)
+	otherPub, _ := testKeyPair(t)
+
+	issuer := NewIssuer(priv)
+	validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
+
+	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+	if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
+		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
+	}
+}
+
+func TestParse_RejectsMalformedKey(t *testing.T) {
+	pub, _ := testKeyPair(t)
+	validator := NewValidator(pub)
+
+	cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
+	for _, c := range cases {
+		if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
+			t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
+		}
+	}
+}

internal/license/store.go

@@ -0,0 +1,88 @@
+package license
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	ErrNoLicense      = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
+	ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
+)
+
+// Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
+// (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
+// unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
+// erweitern).
+type Store struct {
+	pool      *pgxpool.Pool
+	validator *Validator
+}
+
+func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
+	return &Store{pool: pool, validator: validator}
+}
+
+// Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
+// und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
+// bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
+// gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
+// bewertet, nicht beim Einspielen.
+func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
+	payload, err := s.validator.Parse(licenseKey)
+	if err != nil {
+		return Payload{}, err
+	}
+
+	_, err = s.pool.Exec(ctx, `
+		INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
+		VALUES ($1, $2, $3, $4, $5, $6, now())
+		ON CONFLICT (tenant_id) DO UPDATE SET
+			plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
+	`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
+	if err != nil {
+		return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
+	}
+	return payload, nil
+}
+
+func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
+	var p Payload
+	row := s.pool.QueryRow(ctx, `
+		SELECT plan, modules, issued_at, valid_until
+		FROM tenant_licenses WHERE tenant_id = $1
+	`, tenantID)
+	if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Payload{}, ErrNoLicense
+		}
+		return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
+	}
+	return p, nil
+}
+
+// Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
+// (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
+func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
+	return s.get(ctx, tenantID)
+}
+
+// RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
+// abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
+// (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
+// Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
+func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
+	p, err := s.get(ctx, tenantID)
+	if err != nil {
+		return Payload{}, err
+	}
+	if time.Now().After(p.ValidUntil) {
+		return Payload{}, ErrLicenseExpired
+	}
+	return p, nil
+}

internal/license/store_test.go

@@ -0,0 +1,177 @@
+package license
+
+import (
+	"context"
+	"crypto/ed25519"
+	"errors"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS tenant_licenses (
+			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
+			plan TEXT NOT NULL,
+			modules TEXT[] NOT NULL,
+			issued_at TIMESTAMPTZ NOT NULL,
+			valid_until TIMESTAMPTZ NOT NULL,
+			raw_key TEXT NOT NULL,
+			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	var tenantID string
+	if err := pool.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn)
+		VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
+		RETURNING id
+	`).Scan(&tenantID); err != nil {
+		t.Fatalf("test-tenant anlegen: %v", err)
+	}
+
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatalf("schluesselpaar: %v", err)
+	}
+	issuer := NewIssuer(priv)
+	store := NewStore(pool, NewValidator(pub))
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
+		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
+		pool.Close()
+	}
+	return store, issuer, tenantID, cleanup
+}
+
+// Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
+func TestStore_InstallAndStatus(t *testing.T) {
+	store, issuer, tenantID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	payload := Payload{
+		TenantSlug: "lic_test_tenant",
+		Plan:       "enterprise",
+		Modules:    []string{"dms", "mail", "archive"},
+		IssuedAt:   time.Now().Truncate(time.Second),
+		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
+	}
+	key, err := issuer.Issue(payload)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	if _, err := store.Install(ctx, tenantID, key); err != nil {
+		t.Fatalf("install: %v", err)
+	}
+
+	status, err := store.Status(ctx, tenantID)
+	if err != nil {
+		t.Fatalf("status: %v", err)
+	}
+	if status.Plan != "enterprise" || len(status.Modules) != 3 {
+		t.Fatalf("status unerwartet: %+v", status)
+	}
+}
+
+func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
+	store, _, tenantID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, otherPriv, _ := ed25519.GenerateKey(nil)
+	foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
+
+	key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
+		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
+// eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
+func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
+	store, issuer, tenantID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	expired := Payload{
+		TenantSlug: "lic_test_tenant",
+		Plan:       "pro",
+		Modules:    []string{"dms"},
+		IssuedAt:   time.Now().Add(-48 * time.Hour),
+		ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
+	}
+	key, err := issuer.Issue(expired)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
+	// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
+	if _, err := store.Install(ctx, tenantID, key); err != nil {
+		t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
+	}
+
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
+			}
+		}()
+		if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
+			t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
+		}
+	}()
+
+	// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
+	status, err := store.Status(ctx, tenantID)
+	if err != nil {
+		t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
+	}
+	if status.Plan != "pro" {
+		t.Fatalf("status unerwartet: %+v", status)
+	}
+}
+
+func TestStore_RequireActive_NoLicense(t *testing.T) {
+	store, _, tenantID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
+		t.Fatalf("erwartet ErrNoLicense, habe %v", err)
+	}
+}

internal/migrate/migrate_test.go

@@ -61,7 +61,9 @@ func setupOrchestratorTest(t *testing.T, tenantCount int) (*Orchestrator, []tena
 			db_name TEXT NOT NULL UNIQUE,
 			db_dsn TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			previous_status TEXT,
+			deletion_scheduled_at TIMESTAMPTZ
 		)`); err != nil {
 		t.Fatalf("registry-schema: %v", err)
 	}

internal/moduleregistry/credentials.go

@@ -0,0 +1,99 @@
+package moduleregistry
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/hex"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+)
+
+var (
+	ErrModuleNotRegistered = errors.New("moduleregistry: modul muss vor provisionierung registriert sein")
+	ErrInvalidCredential   = errors.New("moduleregistry: ungueltiges oder fehlendes service-credential")
+)
+
+// Provision stellt ein Service-Credential (Client-ID + Secret) fuer eine
+// Modul-Instanz aus (Akzeptanzkriterium 4). Das Secret wird NUR beim
+// Ausstellen im Klartext zurueckgegeben, gespeichert wird ausschliesslich
+// dessen SHA-256-Hash.
+func (r *Registry) Provision(ctx context.Context, moduleName string) (clientID, secret string, err error) {
+	if _, err := r.Get(ctx, moduleName); err != nil {
+		if errors.Is(err, ErrModuleNotFound) {
+			return "", "", ErrModuleNotRegistered
+		}
+		return "", "", err
+	}
+
+	clientID, err = randomToken(16)
+	if err != nil {
+		return "", "", fmt.Errorf("client-id erzeugen: %w", err)
+	}
+	secret, err = randomToken(32)
+	if err != nil {
+		return "", "", fmt.Errorf("secret erzeugen: %w", err)
+	}
+	hash := hashSecret(secret)
+
+	_, err = r.pool.Exec(ctx, `
+		INSERT INTO module_credentials (module_name, client_id, secret_hash, issued_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (module_name) DO UPDATE SET client_id = $2, secret_hash = $3, issued_at = now()
+	`, moduleName, clientID, hash)
+	if err != nil {
+		return "", "", fmt.Errorf("credential speichern: %w", err)
+	}
+	return clientID, secret, nil
+}
+
+// Authenticate prueft ein Service-Credential timing-safe (Referenzmuster
+// siehe AUD-02) — Aufrufe ohne gueltiges Credential werden abgelehnt
+// (Akzeptanzkriterium 4 / Pruefung 4).
+func (r *Registry) Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error) {
+	if clientID == "" || secret == "" {
+		return "", false, nil
+	}
+
+	var storedHash []byte
+	err = r.pool.QueryRow(ctx, `
+		SELECT module_name, secret_hash FROM module_credentials WHERE client_id = $1
+	`, clientID).Scan(&moduleName, &storedHash)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return "", false, nil
+		}
+		return "", false, fmt.Errorf("credential lesen: %w", err)
+	}
+
+	if !timingSafeEqual(hashSecret(secret), storedHash) {
+		return "", false, nil
+	}
+	return moduleName, true, nil
+}
+
+func randomToken(n int) (string, error) {
+	buf := make([]byte, n)
+	if _, err := rand.Read(buf); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(buf), nil
+}
+
+func hashSecret(secret string) []byte {
+	sum := sha256.Sum256([]byte(secret))
+	return sum[:]
+}
+
+// timingSafeEqual folgt derselben Referenzimplementierung wie AUD-02
+// (subtle.ConstantTimeCompare) — projektweite Konvention fuer jeden
+// sicherheitsrelevanten Vergleich.
+func timingSafeEqual(a, b []byte) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	return subtle.ConstantTimeCompare(a, b) == 1
+}

internal/moduleregistry/middleware.go

@@ -0,0 +1,46 @@
+package moduleregistry
+
+import "net/http"
+
+// RequireActiveModule weist Anfragen an ein nicht aktiviertes Modul ZENTRAL
+// ab, bevor der eigentliche Modul-Handler erreicht wird (Akzeptanzkriterium 2 /
+// Pruefung 1) — Casbin-Prinzip: Durchsetzung als Middleware statt verstreuter
+// Pruefungen in jedem Handler. tenantSlug/moduleName werden hier ueber
+// Query-Parameter gelesen (echte Extraktion aus JWT/Tenant-Kontext ist
+// API-05/TEN-06, nicht Teil dieser Kachel).
+func (r *Registry) RequireActiveModule(moduleName string, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		tenantSlug := req.URL.Query().Get("tenant")
+		active, err := r.IsActive(req.Context(), tenantSlug, moduleName)
+		if err != nil {
+			http.Error(w, "aktivierungspruefung fehlgeschlagen", http.StatusInternalServerError)
+			return
+		}
+		if !active {
+			http.Error(w, "modul nicht aktiviert", http.StatusForbidden)
+			return
+		}
+		next(w, req)
+	}
+}
+
+// RequireServiceCredential authentifiziert eine Modul-Instanz ueber ihr
+// Service-Credential (X-Client-Id/X-Client-Secret-Header) BEVOR der
+// eigentliche Handler erreicht wird (Akzeptanzkriterium 4 / Pruefung 4).
+func (r *Registry) RequireServiceCredential(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		clientID := req.Header.Get("X-Client-Id")
+		secret := req.Header.Get("X-Client-Secret")
+
+		_, ok, err := r.Authenticate(req.Context(), clientID, secret)
+		if err != nil {
+			http.Error(w, "authentifizierung fehlgeschlagen", http.StatusInternalServerError)
+			return
+		}
+		if !ok {
+			http.Error(w, ErrInvalidCredential.Error(), http.StatusUnauthorized)
+			return
+		}
+		next(w, req)
+	}
+}

internal/moduleregistry/registry.go

@@ -0,0 +1,120 @@
+// Package moduleregistry implementiert Core API-02: die Registry, in der
+// sich Fachmodule (DMS, Mail, weitere) mit Metadaten eintragen, gekoppelt an
+// die Aktivierungspruefung aus LIC-02 (Feature-Flags). Zusaetzlich
+// authentifiziert die Registry Modul-Instanzen selbst ueber ein bei
+// Provisionierung ausgestelltes Service-Credential.
+package moduleregistry
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+)
+
+var (
+	ErrMissingName    = errors.New("moduleregistry: name darf nicht leer sein")
+	ErrMissingVersion = errors.New("moduleregistry: version darf nicht leer sein")
+	ErrModuleNotFound = errors.New("moduleregistry: modul nicht registriert")
+)
+
+type Module struct {
+	Name          string
+	Version       string
+	RequiredFlags []string
+}
+
+type Registry struct {
+	pool  *pgxpool.Pool
+	flags *flag.Service
+}
+
+func NewRegistry(pool *pgxpool.Pool, flags *flag.Service) *Registry {
+	return &Registry{pool: pool, flags: flags}
+}
+
+// Register traegt ein Modul mit Name, Version und benoetigten Feature-Flags
+// ein (Akzeptanzkriterium 1). Fehlende Pflichtangaben werden abgewiesen
+// (Akzeptanzkriterium 1 / Pruefung 2). Erneutes Register desselben Namens
+// aktualisiert Version/Flags (Redeploy-Fall).
+func (r *Registry) Register(ctx context.Context, name, version string, requiredFlags []string) (Module, error) {
+	if name == "" {
+		return Module{}, ErrMissingName
+	}
+	if version == "" {
+		return Module{}, ErrMissingVersion
+	}
+	if requiredFlags == nil {
+		requiredFlags = []string{}
+	}
+
+	_, err := r.pool.Exec(ctx, `
+		INSERT INTO modules (name, version, required_flags, registered_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (name) DO UPDATE SET version = $2, required_flags = $3, registered_at = now()
+	`, name, version, requiredFlags)
+	if err != nil {
+		return Module{}, fmt.Errorf("modul registrieren: %w", err)
+	}
+	return Module{Name: name, Version: version, RequiredFlags: requiredFlags}, nil
+}
+
+func (r *Registry) Get(ctx context.Context, name string) (Module, error) {
+	var m Module
+	m.Name = name
+	err := r.pool.QueryRow(ctx, `
+		SELECT version, required_flags FROM modules WHERE name = $1
+	`, name).Scan(&m.Version, &m.RequiredFlags)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Module{}, ErrModuleNotFound
+		}
+		return Module{}, fmt.Errorf("modul lesen: %w", err)
+	}
+	return m, nil
+}
+
+// List liefert alle registrierten Module (Akzeptanzkriterium 3: ueber API
+// abfragbar, z.B. fuer Statusseite/Lizenzoberflaeche).
+func (r *Registry) List(ctx context.Context) ([]Module, error) {
+	rows, err := r.pool.Query(ctx, `SELECT name, version, required_flags FROM modules ORDER BY name`)
+	if err != nil {
+		return nil, fmt.Errorf("module auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Module
+	for rows.Next() {
+		var m Module
+		if err := rows.Scan(&m.Name, &m.Version, &m.RequiredFlags); err != nil {
+			return nil, fmt.Errorf("modul lesen: %w", err)
+		}
+		out = append(out, m)
+	}
+	return out, rows.Err()
+}
+
+// IsActive prueft, ob ein registriertes Modul fuer einen Tenant aktiviert
+// ist: registriert UND alle benoetigten Feature-Flags sind fuer diesen
+// Tenant aktiv (Akzeptanzkriterium 2). Ein nicht registriertes Modul gilt
+// immer als nicht aktiv.
+func (r *Registry) IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error) {
+	m, err := r.Get(ctx, moduleName)
+	if err != nil {
+		if errors.Is(err, ErrModuleNotFound) {
+			return false, nil
+		}
+		return false, err
+	}
+
+	for _, flagKey := range m.RequiredFlags {
+		if !r.flags.IsEnabled(ctx, tenantSlug, flagKey) {
+			return false, nil
+		}
+	}
+	return true, nil
+}

internal/moduleregistry/registry_test.go

@@ -0,0 +1,304 @@
+package moduleregistry
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+)
+
+func setupTest(t *testing.T) (*Registry, *flag.Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS modules (
+			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
+			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS module_credentials (
+			module_name TEXT PRIMARY KEY REFERENCES modules(name),
+			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
+			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	flagStore := flag.NewStore(pool)
+	// Kurze TTL, damit Tests, die den Flag-Store direkt aendern (an
+	// Registry.IsActive vorbei), den neuen Stand ohne manuelles Invalidate
+	// zuverlaessig sehen.
+	flagService := flag.NewService(flagStore, 10*time.Millisecond)
+	registry := NewRegistry(pool, flagService)
+
+	cleanup := func() { pool.Close() }
+	return registry, flagStore, cleanup
+}
+
+func uniqueModuleName(t *testing.T) string {
+	return fmt.Sprintf("dms_%d", time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: fehlende Pflichtangaben abgewiesen.
+func TestRegister_RejectsMissingFields(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := registry.Register(ctx, "", "1.0", nil); !errors.Is(err, ErrMissingName) {
+		t.Fatalf("erwartet ErrMissingName, habe %v", err)
+	}
+	if _, err := registry.Register(ctx, "dms", "", nil); !errors.Is(err, ErrMissingVersion) {
+		t.Fatalf("erwartet ErrMissingVersion, habe %v", err)
+	}
+}
+
+func TestRegister_AndGet(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueModuleName(t)
+
+	m, err := registry.Register(ctx, name, "1.2.0", []string{"dms_enabled"})
+	if err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	if m.Version != "1.2.0" || len(m.RequiredFlags) != 1 {
+		t.Fatalf("unerwartet: %+v", m)
+	}
+
+	got, err := registry.Get(ctx, name)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Version != "1.2.0" {
+		t.Fatalf("get version = %q", got.Version)
+	}
+}
+
+// Akzeptanzkriterium 2 + 3 + Pruefung 3: konsistente Daten nach
+// Aktivierung/Deaktivierung eines Moduls.
+func TestIsActive_ReflectsFlagStateConsistently(t *testing.T) {
+	registry, flagStore, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueModuleName(t)
+	flagKey := name + "_enabled"
+
+	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	active, err := registry.IsActive(ctx, "acme", name)
+	if err != nil {
+		t.Fatalf("is active (vor flag): %v", err)
+	}
+	if active {
+		t.Fatal("erwartet nicht aktiv, solange flag nicht gesetzt ist")
+	}
+
+	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
+		t.Fatalf("flag setzen: %v", err)
+	}
+	time.Sleep(20 * time.Millisecond) // TTL abwarten
+
+	active, err = registry.IsActive(ctx, "acme", name)
+	if err != nil {
+		t.Fatalf("is active (nach flag an): %v", err)
+	}
+	if !active {
+		t.Fatal("erwartet aktiv, nachdem flag aktiviert wurde")
+	}
+
+	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: false}); err != nil {
+		t.Fatalf("flag zuruecksetzen: %v", err)
+	}
+	time.Sleep(20 * time.Millisecond) // TTL abwarten
+	active, err = registry.IsActive(ctx, "acme", name)
+	if err != nil {
+		t.Fatalf("is active (nach flag aus): %v", err)
+	}
+	if active {
+		t.Fatal("erwartet wieder nicht aktiv, nachdem flag deaktiviert wurde")
+	}
+}
+
+func TestIsActive_UnregisteredModuleIsNeverActive(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	active, err := registry.IsActive(ctx, "acme", "nie-registriert")
+	if err != nil {
+		t.Fatalf("is active: %v", err)
+	}
+	if active {
+		t.Fatal("unregistriertes modul darf nie aktiv sein")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Anfrage an deaktiviertes Modul wird
+// zentral abgewiesen, BEVOR die Modul-Logik erreicht wird.
+func TestRequireActiveModule_BlocksBeforeHandler(t *testing.T) {
+	registry, flagStore, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueModuleName(t)
+	flagKey := name + "_enabled"
+
+	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	handlerReached := false
+	handler := registry.RequireActiveModule(name, func(w http.ResponseWriter, r *http.Request) {
+		handlerReached = true
+		w.WriteHeader(http.StatusOK)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
+	rec := httptest.NewRecorder()
+	handler(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403", rec.Code)
+	}
+	if handlerReached {
+		t.Fatal("handler haette bei deaktiviertem modul NICHT erreicht werden duerfen")
+	}
+
+	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
+		t.Fatalf("flag setzen: %v", err)
+	}
+	req2 := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
+	rec2 := httptest.NewRecorder()
+	handler(rec2, req2)
+	if rec2.Code != http.StatusOK {
+		t.Fatalf("status nach aktivierung = %d, want 200", rec2.Code)
+	}
+	if !handlerReached {
+		t.Fatal("handler haette bei aktiviertem modul erreicht werden muessen")
+	}
+}
+
+// Akzeptanzkriterium 4 + Pruefung 4: gueltiges/ungueltiges Service-Credential.
+func TestProvisionAndAuthenticate(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueModuleName(t)
+
+	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	clientID, secret, err := registry.Provision(ctx, name)
+	if err != nil {
+		t.Fatalf("provision: %v", err)
+	}
+	if clientID == "" || secret == "" {
+		t.Fatal("erwartet nicht-leere client-id/secret")
+	}
+
+	moduleName, ok, err := registry.Authenticate(ctx, clientID, secret)
+	if err != nil {
+		t.Fatalf("authenticate (korrekt): %v", err)
+	}
+	if !ok || moduleName != name {
+		t.Fatalf("erwartet erfolgreiche authentifizierung fuer %q, habe ok=%v moduleName=%q", name, ok, moduleName)
+	}
+
+	_, ok, err = registry.Authenticate(ctx, clientID, "falsches-secret")
+	if err != nil {
+		t.Fatalf("authenticate (falsch): %v", err)
+	}
+	if ok {
+		t.Fatal("erwartet fehlschlag bei falschem secret")
+	}
+
+	_, ok, err = registry.Authenticate(ctx, "unbekannte-client-id", secret)
+	if err != nil {
+		t.Fatalf("authenticate (unbekannt): %v", err)
+	}
+	if ok {
+		t.Fatal("erwartet fehlschlag bei unbekannter client-id")
+	}
+}
+
+func TestProvision_RequiresRegisteredModule(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, _, err := registry.Provision(ctx, "nie-registriert"); !errors.Is(err, ErrModuleNotRegistered) {
+		t.Fatalf("erwartet ErrModuleNotRegistered, habe %v", err)
+	}
+}
+
+func TestRequireServiceCredential_RejectsInvalidAcceptsValid(t *testing.T) {
+	registry, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueModuleName(t)
+
+	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
+		t.Fatalf("register: %v", err)
+	}
+	clientID, secret, err := registry.Provision(ctx, name)
+	if err != nil {
+		t.Fatalf("provision: %v", err)
+	}
+
+	handler := registry.RequireServiceCredential(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	// Fehlendes Credential.
+	req := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
+	rec := httptest.NewRecorder()
+	handler(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("ohne credential: status = %d, want 401", rec.Code)
+	}
+
+	// Falsches Secret.
+	req2 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
+	req2.Header.Set("X-Client-Id", clientID)
+	req2.Header.Set("X-Client-Secret", "falsch")
+	rec2 := httptest.NewRecorder()
+	handler(rec2, req2)
+	if rec2.Code != http.StatusUnauthorized {
+		t.Fatalf("falsches secret: status = %d, want 401", rec2.Code)
+	}
+
+	// Gueltiges Credential.
+	req3 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
+	req3.Header.Set("X-Client-Id", clientID)
+	req3.Header.Set("X-Client-Secret", secret)
+	rec3 := httptest.NewRecorder()
+	handler(rec3, req3)
+	if rec3.Code != http.StatusOK {
+		t.Fatalf("gueltiges credential: status = %d, want 200", rec3.Code)
+	}
+}

internal/mtls/ca.go

@@ -0,0 +1,158 @@
+// Package mtls implementiert Core API-09: gegenseitige TLS-Authentifizierung
+// zwischen Core/DMS/Mail/Archive/Workflow/AI/Connect-Instanzen fuer
+// Stufe-2/3-Installationen (siehe SKALIERUNGSKONZEPT.md) — schuetzt die
+// VERTRAULICHKEIT des Transportwegs, dort wo API-05 (asymmetrische
+// JWT-Signatur) und API-02 (Service-Credential) nur Authentizitaet/
+// Integritaet, aber keine Transportverschluesselung zwischen getrennten
+// Hosts absichern.
+//
+// Zertifikatsverteilung (Akzeptanzkriterium 1): Authority.IssueCert liefert
+// PEM-kodiertes Zertifikat + privaten Schluessel, die ueber denselben Weg
+// wie andere Secrets verteilt werden (Umgebungsvariablen/Secret-Store,
+// niemals im Code) — automatisierbar, da IssueCert ein reiner
+// Funktionsaufruf ohne manuelle Schritte ist.
+package mtls
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+	"net"
+	"time"
+)
+
+// Authority ist eine interne Zertifizierungsstelle fuer Modul-zu-Modul-
+// mTLS. Haelt — analog zu internal/moduletrust.KeyManager (API-05) — ALLE
+// noch gueltigen historischen CA-Zertifikate im Vertrauensspeicher, damit
+// eine Rotation bereits ausgestellte Leaf-Zertifikate nicht ungueltig macht
+// (Akzeptanzkriterium 3: Rotation ohne Ausfallzeit).
+type Authority struct {
+	current    caGeneration
+	trustPool  *x509.CertPool
+	generations []caGeneration
+}
+
+type caGeneration struct {
+	cert *x509.Certificate
+	key  ed25519.PrivateKey
+}
+
+// NewAuthority erzeugt eine frische interne CA.
+func NewAuthority() (*Authority, error) {
+	gen, err := newCAGeneration()
+	if err != nil {
+		return nil, err
+	}
+	pool := x509.NewCertPool()
+	pool.AddCert(gen.cert)
+	return &Authority{current: gen, trustPool: pool, generations: []caGeneration{gen}}, nil
+}
+
+func newCAGeneration() (caGeneration, error) {
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-schluesselpaar erzeugen: %w", err)
+	}
+	serial, err := rand.Int(rand.Reader, big.NewInt(1<<62))
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("seriennummer erzeugen: %w", err)
+	}
+	template := &x509.Certificate{
+		SerialNumber:          serial,
+		Subject:               pkix.Name{CommonName: "nexarch-internal-ca"},
+		NotBefore:             time.Now().Add(-time.Minute),
+		NotAfter:              time.Now().Add(5 * 365 * 24 * time.Hour),
+		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
+		BasicConstraintsValid: true,
+		IsCA:                  true,
+	}
+	der, err := x509.CreateCertificate(rand.Reader, template, template, pub, priv)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-zertifikat erstellen: %w", err)
+	}
+	cert, err := x509.ParseCertificate(der)
+	if err != nil {
+		return caGeneration{}, fmt.Errorf("ca-zertifikat parsen: %w", err)
+	}
+	return caGeneration{cert: cert, key: priv}, nil
+}
+
+// Rotate erzeugt eine NEUE CA-Generation fuer zukuenftige IssueCert-Aufrufe,
+// behaelt aber ALLE bisherigen CA-Zertifikate im Vertrauensspeicher —
+// bereits ausgestellte Leaf-Zertifikate bleiben dadurch gueltig, eine
+// laufende mTLS-Verbindung wird durch Rotate NICHT unterbrochen
+// (Akzeptanzkriterium 3 / Pruefung 2).
+func (a *Authority) Rotate() error {
+	gen, err := newCAGeneration()
+	if err != nil {
+		return err
+	}
+	a.trustPool.AddCert(gen.cert)
+	a.generations = append(a.generations, gen)
+	a.current = gen
+	return nil
+}
+
+// TrustPool liefert den Vertrauensspeicher mit ALLEN (auch historischen,
+// noch nicht abgelaufenen) CA-Zertifikaten — Grundlage der
+// Server-seitigen Client-Zertifikatspruefung (Akzeptanzkriterium 2).
+func (a *Authority) TrustPool() *x509.CertPool {
+	return a.trustPool
+}
+
+// IssuedCert ist ein ausgestelltes Leaf-Zertifikat inklusive privatem
+// Schluessel, PEM-kodiert zur Verteilung (Akzeptanzkriterium 1).
+type IssuedCert struct {
+	CertPEM []byte
+	KeyPEM  []byte
+}
+
+// IssueCert stellt ein Leaf-Zertifikat fuer EINE Modul-Instanz aus, signiert
+// mit der AKTUELLEN CA-Generation (Akzeptanzkriterium 1).
+func (a *Authority) IssueCert(commonName string, validity time.Duration) (IssuedCert, error) {
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-schluesselpaar erzeugen: %w", err)
+	}
+	serial, err := rand.Int(rand.Reader, big.NewInt(1<<62))
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("seriennummer erzeugen: %w", err)
+	}
+	template := &x509.Certificate{
+		SerialNumber: serial,
+		Subject:      pkix.Name{CommonName: commonName},
+		NotBefore:    time.Now().Add(-time.Minute),
+		NotAfter:     time.Now().Add(validity),
+		KeyUsage:     x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		// DNSNames/IPAddresses decken lokale Testumgebungen ab (127.0.0.1,
+		// localhost) — in echten Stufe-2/3-Installationen entspricht
+		// commonName dem tatsaechlichen internen Hostnamen der Instanz.
+		DNSNames:    []string{commonName, "localhost"},
+		IPAddresses: []net.IP{net.IPv4(127, 0, 0, 1), net.IPv6loopback},
+	}
+	der, err := x509.CreateCertificate(rand.Reader, template, a.current.cert, pub, a.current.key)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-zertifikat erstellen: %w", err)
+	}
+
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
+	keyBytes, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return IssuedCert{}, fmt.Errorf("leaf-schluessel serialisieren: %w", err)
+	}
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: keyBytes})
+
+	return IssuedCert{CertPEM: certPEM, KeyPEM: keyPEM}, nil
+}
+
+// TLSCertificate wandelt ein IssuedCert in ein tls.Certificate um, wie es
+// tls.Config.Certificates erwartet.
+func (c IssuedCert) TLSCertificate() (tls.Certificate, error) {
+	return tls.X509KeyPair(c.CertPEM, c.KeyPEM)
+}

internal/mtls/config.go

@@ -0,0 +1,46 @@
+package mtls
+
+import "crypto/tls"
+
+// Mode legt fest, ob mTLS erzwungen wird. Fuer Stufe-1-Einzel-LXC ist mTLS
+// laut Ticket "optional/nicht zwingend" (lokale Kommunikation) — ModeOff
+// liefert einen ganz normalen TLS-Server OHNE Client-Zertifikatspruefung,
+// damit Stufe-1-Betrieb unveraendert weiterlaeuft (Akzeptanzkriterium 3 /
+// Pruefung 3).
+type Mode string
+
+const (
+	ModeOff      Mode = "off"      // Stufe 1: kein mTLS-Zwang
+	ModeRequired Mode = "required" // Stufe 2/3: Client-Zertifikat zwingend
+)
+
+// ServerTLSConfig liefert die tls.Config fuer eine Modul-Instanz, die
+// eingehende Verbindungen ANDERER Modul-Instanzen annimmt.
+//
+//   - ModeRequired: verlangt UND verifiziert ein Client-Zertifikat gegen
+//     authority.TrustPool() (Akzeptanzkriterium 2) — eine Verbindung ohne
+//     gueltiges Zertifikat wird vom TLS-Handshake selbst abgelehnt, bevor
+//     irgendein Anwendungscode erreicht wird.
+//   - ModeOff: normales TLS ohne Client-Zertifikatspruefung
+//     (Akzeptanzkriterium 3 / Pruefung 3: Stufe-1-Betrieb funktioniert
+//     weiterhin ohne mTLS-Zwang).
+func ServerTLSConfig(mode Mode, serverCert tls.Certificate, authority *Authority) *tls.Config {
+	cfg := &tls.Config{Certificates: []tls.Certificate{serverCert}}
+	if mode == ModeRequired {
+		cfg.ClientAuth = tls.RequireAndVerifyClientCert
+		cfg.ClientCAs = authority.TrustPool()
+	}
+	return cfg
+}
+
+// ClientTLSConfig liefert die tls.Config fuer eine Modul-Instanz, die eine
+// Verbindung zu einer ANDEREN Modul-Instanz aufbaut — praesentiert das
+// eigene Zertifikat und vertraut Gegenstellen, die von derselben Authority
+// signiert wurden.
+func ClientTLSConfig(mode Mode, clientCert tls.Certificate, authority *Authority) *tls.Config {
+	cfg := &tls.Config{RootCAs: authority.TrustPool()}
+	if mode == ModeRequired {
+		cfg.Certificates = []tls.Certificate{clientCert}
+	}
+	return cfg
+}

internal/mtls/mtls_test.go

@@ -0,0 +1,185 @@
+package mtls
+
+import (
+	"crypto/tls"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func newTLSServer(t *testing.T, cfg *tls.Config) *httptest.Server {
+	t.Helper()
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("ok"))
+	}))
+	server.TLS = cfg
+	server.StartTLS()
+	return server
+}
+
+func fetch(t *testing.T, url string, clientCfg *tls.Config) (int, error) {
+	t.Helper()
+	client := &http.Client{
+		Transport: &http.Transport{TLSClientConfig: clientCfg},
+		Timeout:   3 * time.Second,
+	}
+	resp, err := client.Get(url)
+	if err != nil {
+		return 0, err
+	}
+	defer resp.Body.Close()
+	_, _ = io.ReadAll(resp.Body)
+	return resp.StatusCode, nil
+}
+
+// Akzeptanzkriterium 1: Zertifikatsverteilung ist ein reiner
+// Funktionsaufruf, das Ergebnis ist gueltiges, wiederverwendbares
+// PEM-Material.
+func TestIssueCert_ProducesValidPEMRoundTrip(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	issued, err := authority.IssueCert("dms", time.Hour)
+	if err != nil {
+		t.Fatalf("issuecert: %v", err)
+	}
+	if _, err := issued.TLSCertificate(); err != nil {
+		t.Fatalf("ausgestelltes zertifikat nicht als tls.Certificate ladbar: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: eine Verbindung ohne gueltiges
+// Client-Zertifikat wird abgelehnt, eine mit gueltigem angenommen.
+func TestServerTLSConfig_RejectsMissingClientCert(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeRequired, serverCert, authority))
+	defer server.Close()
+
+	// Client OHNE Zertifikat, aber mit korrektem RootCA-Vertrauen fuer den
+	// Server — der Handshake muss trotzdem an der fehlenden Client-Auth
+	// scheitern.
+	_, err = fetch(t, server.URL, &tls.Config{RootCAs: authority.TrustPool()})
+	if err == nil {
+		t.Fatal("erwartet fehlschlagenden handshake ohne client-zertifikat")
+	}
+
+	clientIssued, err := authority.IssueCert("mail", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat ausstellen: %v", err)
+	}
+	clientCert, err := clientIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("client-zertifikat laden: %v", err)
+	}
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeRequired, clientCert, authority))
+	if err != nil {
+		t.Fatalf("erwartet erfolgreiche verbindung mit gueltigem client-zertifikat: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200", status)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Rotation der CA unterbricht laufenden
+// Betrieb nicht — ein VOR der Rotation ausgestelltes Leaf-Zertifikat
+// funktioniert danach weiter, UND ein NACH der Rotation neu ausgestelltes
+// funktioniert ebenfalls, gegen denselben, weiterlaufenden Server (kein
+// Neustart noetig, da TrustPool() denselben *x509.CertPool zurueckliefert,
+// den Rotate() erweitert).
+func TestAuthority_RotateWithoutDowntime(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeRequired, serverCert, authority))
+	defer server.Close() // EIN Server-Prozess ueber die gesamte Rotation hinweg — kein Neustart.
+
+	preRotationIssued, err := authority.IssueCert("dms", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat (vor rotation) ausstellen: %v", err)
+	}
+	preRotationCert, _ := preRotationIssued.TLSCertificate()
+
+	if err := authority.Rotate(); err != nil {
+		t.Fatalf("rotate: %v", err)
+	}
+
+	// VOR der Rotation ausgestelltes Zertifikat funktioniert WEITERHIN, ohne
+	// dass der Server neu gestartet wurde.
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeRequired, preRotationCert, authority))
+	if err != nil {
+		t.Fatalf("vor-rotation-zertifikat haette weiterhin funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (vor-rotation-zertifikat)", status)
+	}
+
+	// NACH der Rotation neu ausgestelltes Zertifikat funktioniert ebenfalls,
+	// gegen DENSELBEN laufenden Server.
+	postRotationIssued, err := authority.IssueCert("mail", time.Hour)
+	if err != nil {
+		t.Fatalf("client-zertifikat (nach rotation) ausstellen: %v", err)
+	}
+	postRotationCert, _ := postRotationIssued.TLSCertificate()
+
+	status, err = fetch(t, server.URL, ClientTLSConfig(ModeRequired, postRotationCert, authority))
+	if err != nil {
+		t.Fatalf("nach-rotation-zertifikat haette funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (nach-rotation-zertifikat)", status)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Stufe-1-Betrieb (ModeOff) funktioniert
+// weiterhin OHNE mTLS-Zwang — ein Client ganz ohne Zertifikat kommt durch.
+func TestServerTLSConfig_ModeOffWorksWithoutClientCert(t *testing.T) {
+	authority, err := NewAuthority()
+	if err != nil {
+		t.Fatalf("newauthority: %v", err)
+	}
+	serverIssued, err := authority.IssueCert("core", time.Hour)
+	if err != nil {
+		t.Fatalf("server-zertifikat ausstellen: %v", err)
+	}
+	serverCert, err := serverIssued.TLSCertificate()
+	if err != nil {
+		t.Fatalf("server-zertifikat laden: %v", err)
+	}
+
+	server := newTLSServer(t, ServerTLSConfig(ModeOff, serverCert, authority))
+	defer server.Close()
+
+	status, err := fetch(t, server.URL, ClientTLSConfig(ModeOff, tls.Certificate{}, authority))
+	if err != nil {
+		t.Fatalf("stufe-1-betrieb (ModeOff) haette ohne client-zertifikat funktionieren sollen: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d, want 200", status)
+	}
+}

internal/notify/dispatcher.go

@@ -0,0 +1,81 @@
+// Package notify implementiert Core CFG-02: den zentralen Benachrichtigungs-
+// Dispatcher, ueber den beliebige Module Benachrichtigungen ausloesen —
+// Warteschlange, Wiederholungslogik, Kanal-Abstraktion. Die tatsaechlichen
+// Kanaele (E-Mail/In-App) sind CFG-03, hier gibt es nur die Sender-
+// Schnittstelle als Vorbereitung.
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultMaxAttempts begrenzt Wiederholungsversuche (Akzeptanzkriterium 2) —
+// nach dieser Anzahl gibt der Dispatcher kontrolliert auf (status=failed)
+// statt endlos zu wiederholen.
+const DefaultMaxAttempts = 5
+
+// DefaultRetryBackoff ist die Basis-Wartezeit zwischen Wiederholungen,
+// linear mit der Versuchsnummer skaliert.
+const DefaultRetryBackoff = 200 * time.Millisecond
+
+type Notification struct {
+	ID        string
+	Channel   string
+	Recipient string
+	Payload   map[string]any
+	Attempts  int
+}
+
+// Sender ist die schmale Schnittstelle, die ein konkreter Kanal (CFG-03)
+// implementiert. Der Dispatcher selbst weiss nichts ueber E-Mail/In-App.
+type Sender interface {
+	Send(ctx context.Context, n Notification) error
+}
+
+// Dispatcher ist die EINE Schnittstelle, ueber die Module Benachrichtigungen
+// ausloesen — kein Modul baut eigenen Versandcode (Akzeptanzkriterium 1).
+type Dispatcher struct {
+	pool         *pgxpool.Pool
+	maxAttempts  int
+	retryBackoff time.Duration
+}
+
+func NewDispatcher(pool *pgxpool.Pool) *Dispatcher {
+	return &Dispatcher{pool: pool, maxAttempts: DefaultMaxAttempts, retryBackoff: DefaultRetryBackoff}
+}
+
+// WithRetryPolicy erlaubt Tests/Betrieb, Versuchsanzahl und Backoff
+// anzupassen, ohne die Default-Policy im Produktionscode zu veraendern.
+func (d *Dispatcher) WithRetryPolicy(maxAttempts int, backoff time.Duration) *Dispatcher {
+	return &Dispatcher{pool: d.pool, maxAttempts: maxAttempts, retryBackoff: backoff}
+}
+
+// Enqueue reiht eine Benachrichtigung in die Postgres-Warteschlange ein und
+// kehrt sofort zurueck — die Zeile ueberlebt jeden Neustart des Dispatcher-
+// Prozesses unveraendert (Akzeptanzkriterium 3), da sie ausschliesslich in
+// der Datenbank existiert, nicht im Prozessspeicher.
+func (d *Dispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	var id string
+	err = d.pool.QueryRow(ctx, `
+		INSERT INTO notification_jobs (channel, recipient, payload, max_attempts)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, channel, recipient, payloadJSON, d.maxAttempts).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("benachrichtigung einreihen: %w", err)
+	}
+	return id, nil
+}

internal/notify/dispatcher_test.go

@@ -0,0 +1,219 @@
+package notify
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			channel TEXT NOT NULL,
+			recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb,
+			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+			attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return pool, cleanup
+}
+
+type fakeSender struct {
+	mu        sync.Mutex
+	sentIDs   []string
+	failUntil int
+	calls     int
+}
+
+func (f *fakeSender) Send(ctx context.Context, n Notification) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls++
+	if f.calls <= f.failUntil {
+		return errors.New("simulierter zustellfehler")
+	}
+	f.sentIDs = append(f.sentIDs, n.ID)
+	return nil
+}
+
+func (f *fakeSender) sentCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.sentIDs)
+}
+
+// Akzeptanzkriterium 1: Module loesen ueber Enqueue aus, keine eigene
+// Versandlogik noetig.
+func TestDispatcher_EnqueueAndProcess(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	id, err := d.Enqueue(ctx, "email", "alice@example.com", map[string]any{"subject": "Willkommen"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id == "" {
+		t.Fatal("erwartet nicht-leere id")
+	}
+
+	sender := &fakeSender{}
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 failed=0, habe sent=%d failed=%d", sent, failed)
+	}
+	if sender.sentCount() != 1 {
+		t.Fatalf("erwartet 1 zustellung, habe %d", sender.sentCount())
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Wiederholungslogik greift bei
+// simuliertem Fehler und bricht nach definierter Anzahl kontrolliert ab.
+func TestProcessDue_RetriesThenGivesUpAfterMaxAttempts(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool).WithRetryPolicy(3, time.Millisecond)
+	id, err := d.Enqueue(ctx, "email", "bob@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	sender := &fakeSender{failUntil: 100} // schlaegt bei jedem versuch fehl
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(5 * time.Millisecond) // next_attempt_at abwarten
+		if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, id).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach max_attempts, habe %q", status)
+	}
+	if attempts != 3 {
+		t.Fatalf("erwartet 3 versuche, habe %d", attempts)
+	}
+
+	// Weiteres ProcessDue darf den bereits aufgegebenen job nicht mehr anfassen.
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach abbruch: %v", err)
+	}
+	if sent != 0 || failed != 0 {
+		t.Fatalf("erwartet keine weitere verarbeitung, habe sent=%d failed=%d", sent, failed)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Neustart des Dienstes waehrend offener
+// Zustellung verliert keine Nachricht — simuliert durch eine komplett neue
+// Dispatcher/Pool-Instanz nach dem Enqueue, bevor irgendetwas verarbeitet wurde.
+func TestQueue_SurvivesRestartWithoutMessageLoss(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	firstInstance := NewDispatcher(pool)
+	id, err := firstInstance.Enqueue(ctx, "email", "carol@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	// "Neustart": eine voellig neue Dispatcher-Instanz (repraesentiert einen
+	// neuen Prozess) verbindet sich neu und verarbeitet die Warteschlange —
+	// die Nachricht existiert ausschliesslich in Postgres, nicht im
+	// Prozessspeicher der ersten Instanz.
+	restartedInstance := NewDispatcher(pool)
+	sender := &fakeSender{}
+	sent, failed, err := restartedInstance.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach neustart: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 nach neustart, habe sent=%d failed=%d", sent, failed)
+	}
+	if len(sender.sentIDs) != 1 || sender.sentIDs[0] != id {
+		t.Fatalf("erwartet zustellung der urspruenglichen nachricht %q, habe %v", id, sender.sentIDs)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: zwei gleichzeitig ausloesende Module,
+// beide Nachrichten werden korrekt (und nicht doppelt) zugestellt.
+func TestProcessDue_ConcurrentDispatchBothDelivered(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	idA, err := d.Enqueue(ctx, "email", "modul-a@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue a: %v", err)
+	}
+	idB, err := d.Enqueue(ctx, "email", "modul-b@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue b: %v", err)
+	}
+
+	sender := &fakeSender{}
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+				t.Errorf("process: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if sender.sentCount() != 2 {
+		t.Fatalf("erwartet genau 2 zustellungen, habe %d: %v", sender.sentCount(), sender.sentIDs)
+	}
+	seen := map[string]bool{}
+	for _, id := range sender.sentIDs {
+		if seen[id] {
+			t.Fatalf("nachricht %q wurde doppelt zugestellt", id)
+		}
+		seen[id] = true
+	}
+	if !seen[idA] || !seen[idB] {
+		t.Fatalf("erwartet beide nachrichten zugestellt, habe %v", sender.sentIDs)
+	}
+}

internal/notify/worker.go

@@ -0,0 +1,102 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// ProcessDue holt bis zu limit faellige Benachrichtigungen und versucht sie
+// ueber sender zuzustellen. FOR UPDATE SKIP LOCKED serialisiert konkurrierende
+// Aufrufe (Akzeptanzkriterium 3 / Pruefung 3: zwei gleichzeitig ausloesende
+// Module duerfen sich nicht gegenseitig blockieren oder Nachrichten doppelt
+// zustellen) — dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions.
+func (d *Dispatcher) ProcessDue(ctx context.Context, sender Sender, limit int) (sent, failed int, err error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT id, channel, recipient, payload, attempts, max_attempts
+		FROM notification_jobs
+		WHERE status = 'pending' AND next_attempt_at <= now()
+		ORDER BY created_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return 0, 0, fmt.Errorf("faellige benachrichtigungen abfragen: %w", err)
+	}
+
+	type due struct {
+		id, channel, recipient string
+		payload                []byte
+		attempts, maxAttempts  int
+	}
+	var candidates []due
+	for rows.Next() {
+		var c due
+		if err := rows.Scan(&c.id, &c.channel, &c.recipient, &c.payload, &c.attempts, &c.maxAttempts); err != nil {
+			rows.Close()
+			return 0, 0, fmt.Errorf("faellige benachrichtigung lesen: %w", err)
+		}
+		candidates = append(candidates, c)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, 0, err
+	}
+
+	for _, c := range candidates {
+		var payload map[string]any
+		if err := json.Unmarshal(c.payload, &payload); err != nil {
+			payload = map[string]any{}
+		}
+
+		sendErr := sender.Send(ctx, Notification{
+			ID: c.id, Channel: c.channel, Recipient: c.recipient, Payload: payload, Attempts: c.attempts,
+		})
+
+		if sendErr == nil {
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs SET status = 'sent', updated_at = now() WHERE id = $1
+			`, c.id); err != nil {
+				return sent, failed, fmt.Errorf("erfolg speichern: %w", err)
+			}
+			sent++
+			continue
+		}
+
+		newAttempts := c.attempts + 1
+		if newAttempts >= c.maxAttempts {
+			// Akzeptanzkriterium 2: kontrollierter Abbruch nach definierter
+			// Anzahl Versuche, kein endloses Wiederholen.
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs
+				SET status = 'failed', attempts = $2, last_error = $3, updated_at = now()
+				WHERE id = $1
+			`, c.id, newAttempts, sendErr.Error()); err != nil {
+				return sent, failed, fmt.Errorf("fehlschlag speichern: %w", err)
+			}
+			failed++
+			continue
+		}
+
+		nextAttempt := time.Now().Add(time.Duration(newAttempts) * d.retryBackoff)
+		if _, err := tx.Exec(ctx, `
+			UPDATE notification_jobs
+			SET attempts = $2, next_attempt_at = $3, last_error = $4, updated_at = now()
+			WHERE id = $1
+		`, c.id, newAttempts, nextAttempt, sendErr.Error()); err != nil {
+			return sent, failed, fmt.Errorf("wiederholung planen: %w", err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return sent, failed, nil
+}

internal/notifyprefs/handler.go

@@ -0,0 +1,83 @@
+package notifyprefs
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Handler stellt Benachrichtigungspraeferenzen als HTTP-Endpunkte bereit
+// (CFG-04). Duenner Client von Store — keine eigene Zustelllogik.
+type Handler struct {
+	prefs *Store
+}
+
+func NewHandler(prefs *Store) *Handler {
+	return &Handler{prefs: prefs}
+}
+
+type setPreferenceRequest struct {
+	EventType string `json:"event_type"`
+	Channel   string `json:"channel"`
+	Enabled   bool   `json:"enabled"`
+}
+
+// SetPreference setzt die eigene Praeferenz des angemeldeten Benutzers
+// (Akzeptanzkriterium 1). Muss hinter auth.RequireAuth haengen.
+func (h *Handler) SetPreference(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	var req setPreferenceRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.prefs.Set(r.Context(), claims.TenantSlug, claims.UserID, req.EventType, req.Channel, req.Enabled); err != nil {
+		http.Error(w, "Einstellung konnte nicht gespeichert werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// ListMine liefert die eigenen Praeferenzen (Akzeptanzkriterium 1) — nur die
+// EIGENEN, niemals die eines anderen Benutzers (Pruefung 2). claims.UserID
+// kommt ausschliesslich aus dem verifizierten Session-Token, ist also nicht
+// vom Client manipulierbar.
+func (h *Handler) ListMine(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	prefs, err := h.prefs.ListForUser(r.Context(), claims.TenantSlug, claims.UserID)
+	if err != nil {
+		http.Error(w, "Einstellungen konnten nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(prefs)
+}
+
+// ListTenantOverview liefert die Praeferenzen ALLER Benutzer des eigenen
+// Mandanten (Akzeptanzkriterium 3: Tenant-Admin-Übersicht). Die Zugriffs-
+// beschraenkung "nur Tenant-Admin" ist Aufgabe von RBAC-02 (Policy-
+// Enforcement-Schicht) vor diesem Handler — hier wird bewusst keine eigene
+// Rechtelogik dupliziert (Ticket-Produkt-DNA: duenner Client).
+func (h *Handler) ListTenantOverview(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	prefs, err := h.prefs.ListForTenant(r.Context(), claims.TenantSlug)
+	if err != nil {
+		http.Error(w, "Übersicht konnte nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(prefs)
+}

internal/notifyprefs/handler_test.go

@@ -0,0 +1,122 @@
+package notifyprefs
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func sessionCookie(t *testing.T, issuer *auth.TokenIssuer, userID, tenantSlug string) *http.Cookie {
+	t.Helper()
+	token, err := issuer.Issue(userID, tenantSlug)
+	if err != nil {
+		t.Fatalf("session-token ausstellen: %v", err)
+	}
+	return &http.Cookie{Name: auth.CookieName, Value: token}
+}
+
+// Akzeptanzkriterium 1: Benutzer setzt eigene Praeferenz per HTTP.
+func TestHandlerSetAndListMine(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+	cookie := sessionCookie(t, issuer, "user-1", "acme")
+
+	setBody, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+	setReq := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(setBody))
+	setReq.AddCookie(cookie)
+	setRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetPreference)(setRec, setReq)
+	if setRec.Code != http.StatusOK {
+		t.Fatalf("set: status = %d, body: %s", setRec.Code, setRec.Body.String())
+	}
+
+	listReq := httptest.NewRequest(http.MethodGet, "/notifications/preferences", nil)
+	listReq.AddCookie(cookie)
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListMine)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list: status = %d, body: %s", listRec.Code, listRec.Body.String())
+	}
+	var out []Preference
+	if err := json.Unmarshal(listRec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 1 || out[0].Enabled {
+		t.Fatalf("erwartet genau 1 deaktivierte praeferenz, habe %+v", out)
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 2: ListMine zeigt AUSSCHLIESSLICH die
+// eigenen Praeferenzen — die UserID kommt aus dem Session-Token, nicht aus
+// einem vom Client kontrollierbaren Parameter.
+func TestHandlerListMine_NeverShowsOtherUsersPreferences(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	setBody, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+	setReq := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(setBody))
+	setReq.AddCookie(sessionCookie(t, issuer, "user-1", "acme"))
+	setRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetPreference)(setRec, setReq)
+	if setRec.Code != http.StatusOK {
+		t.Fatalf("set fuer user-1: status = %d", setRec.Code)
+	}
+
+	// user-2 fragt seine eigenen Praeferenzen ab — muss leer sein.
+	listReq := httptest.NewRequest(http.MethodGet, "/notifications/preferences", nil)
+	listReq.AddCookie(sessionCookie(t, issuer, "user-2", "acme"))
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListMine)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list fuer user-2: status = %d", listRec.Code)
+	}
+	var out []Preference
+	if err := json.Unmarshal(listRec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 0 {
+		t.Fatalf("user-2 haette user-1s praeferenzen NICHT sehen duerfen, habe %+v", out)
+	}
+}
+
+// Akzeptanzkriterium 3: Tenant-Übersicht liefert alle Benutzer des Mandanten.
+func TestHandlerListTenantOverview(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	for _, u := range []string{"user-1", "user-2"} {
+		body, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+		req := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(body))
+		req.AddCookie(sessionCookie(t, issuer, u, "acme"))
+		rec := httptest.NewRecorder()
+		auth.RequireAuth(issuer, h.SetPreference)(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("set fuer %s: status = %d", u, rec.Code)
+		}
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/notifications/preferences/tenant", nil)
+	req.AddCookie(sessionCookie(t, issuer, "admin-1", "acme"))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListTenantOverview)(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("overview: status = %d, body: %s", rec.Code, rec.Body.String())
+	}
+	var out []Preference
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 2 {
+		t.Fatalf("erwartet 2 eintraege (beide Benutzer), habe %d", len(out))
+	}
+}

internal/notifyprefs/prefs.go

@@ -0,0 +1,144 @@
+// Package notifyprefs implementiert Core CFG-04: Benachrichtigungspräferenzen
+// je Benutzer, Ereignistyp und Kanal. Duenner Client von CFG-02/03 — keine
+// eigene Zustelllogik, nur ein Filter DAVOR, ob eine Benachrichtigung
+// überhaupt in die Warteschlange (internal/notify.Dispatcher) eingereiht wird.
+package notifyprefs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+type Preference struct {
+	TenantSlug string
+	UserID     string
+	EventType  string
+	Channel    string
+	Enabled    bool
+}
+
+// Store verwaltet Benachrichtigungspraeferenzen in der zentralen Registry-DB
+// (gleiche Ablageebene wie CFG-03s notification_templates/in_app_notifications).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set setzt die Praeferenz eines Benutzers fuer einen Ereignistyp+Kanal
+// (Akzeptanzkriterium 1). Wirkt sofort — es gibt keinen Cache dazwischen,
+// jede Pruefung (IsEnabled) liest direkt aus der DB (Akzeptanzkriterium 2).
+func (s *Store) Set(ctx context.Context, tenantSlug, userID, eventType, channel string, enabled bool) error {
+	if tenantSlug == "" || userID == "" || eventType == "" || channel == "" {
+		return errors.New("notifyprefs: tenantSlug, userID, eventType und channel duerfen nicht leer sein")
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_preferences (tenant_slug, user_id, event_type, channel, enabled)
+		VALUES ($1, $2, $3, $4, $5)
+		ON CONFLICT (tenant_slug, user_id, event_type, channel)
+		DO UPDATE SET enabled = $5, updated_at = now()
+	`, tenantSlug, userID, eventType, channel, enabled)
+	if err != nil {
+		return fmt.Errorf("praeferenz speichern: %w", err)
+	}
+	return nil
+}
+
+// IsEnabled prueft, ob ein Kanal fuer einen Ereignistyp aktiv ist. Ohne
+// explizite Praeferenz gilt der Kanal als AKTIVIERT (Opt-out-Default,
+// siehe Migration).
+func (s *Store) IsEnabled(ctx context.Context, tenantSlug, userID, eventType, channel string) (bool, error) {
+	var enabled bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT enabled FROM notification_preferences
+		WHERE tenant_slug = $1 AND user_id = $2 AND event_type = $3 AND channel = $4
+	`, tenantSlug, userID, eventType, channel).Scan(&enabled)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return true, nil
+		}
+		return false, fmt.Errorf("praeferenz lesen: %w", err)
+	}
+	return enabled, nil
+}
+
+// ListForUser liefert alle expliziten Praeferenzen eines Benutzers
+// (Akzeptanzkriterium 1: eigene Einstellungen einsehen/aendern).
+func (s *Store) ListForUser(ctx context.Context, tenantSlug, userID string) ([]Preference, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT event_type, channel, enabled FROM notification_preferences
+		WHERE tenant_slug = $1 AND user_id = $2
+		ORDER BY event_type, channel
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("praeferenzen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Preference
+	for rows.Next() {
+		p := Preference{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&p.EventType, &p.Channel, &p.Enabled); err != nil {
+			return nil, fmt.Errorf("praeferenz lesen: %w", err)
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
+
+// ListForTenant liefert ALLE expliziten Praeferenzen aller Benutzer eines
+// Mandanten (Akzeptanzkriterium 3: Tenant-Admin-Übersicht).
+func (s *Store) ListForTenant(ctx context.Context, tenantSlug string) ([]Preference, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT user_id, event_type, channel, enabled FROM notification_preferences
+		WHERE tenant_slug = $1
+		ORDER BY user_id, event_type, channel
+	`, tenantSlug)
+	if err != nil {
+		return nil, fmt.Errorf("mandanten-praeferenzen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Preference
+	for rows.Next() {
+		p := Preference{TenantSlug: tenantSlug}
+		if err := rows.Scan(&p.UserID, &p.EventType, &p.Channel, &p.Enabled); err != nil {
+			return nil, fmt.Errorf("praeferenz lesen: %w", err)
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
+
+// EnqueueIfAllowed ist der einzige vorgesehene Weg, wie ein Modul eine
+// Benachrichtigung fuer einen konkreten Benutzer+Ereignistyp auslöst: prueft
+// zuerst die Praeferenz, reiht NUR bei Aktivierung tatsaechlich in
+// internal/notify.Dispatcher ein (Akzeptanzkriterium 1 / Pruefung 1 — ein
+// deaktivierter Kanal erzeugt nachweislich KEINE notification_jobs-Zeile,
+// nicht nur eine ignorierte). skipped=true bedeutet: bewusst nicht zugestellt,
+// kein Fehler.
+func EnqueueIfAllowed(
+	ctx context.Context,
+	prefs *Store,
+	dispatcher *notify.Dispatcher,
+	tenantSlug, userID, eventType, channel, recipient string,
+	payload map[string]any,
+) (jobID string, skipped bool, err error) {
+	enabled, err := prefs.IsEnabled(ctx, tenantSlug, userID, eventType, channel)
+	if err != nil {
+		return "", false, err
+	}
+	if !enabled {
+		return "", true, nil
+	}
+	jobID, err = dispatcher.Enqueue(ctx, channel, recipient, payload)
+	return jobID, false, err
+}

internal/notifyprefs/prefs_test.go

@@ -0,0 +1,183 @@
+package notifyprefs
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*Store, *notify.Dispatcher, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_preferences (
+			tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL, event_type TEXT NOT NULL, channel TEXT NOT NULL,
+			enabled BOOLEAN NOT NULL, updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (tenant_slug, user_id, event_type, channel)
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending', attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM notification_preferences`)
+		_, _ = pool.Exec(ctx, `DELETE FROM notification_jobs`)
+		pool.Close()
+	}
+	return NewStore(pool), notify.NewDispatcher(pool), pool, cleanup
+}
+
+// Ohne explizite Praeferenz gilt ein Kanal als aktiviert (Opt-out-Default).
+func TestIsEnabled_DefaultsToTrueWithoutPreference(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	enabled, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled: %v", err)
+	}
+	if !enabled {
+		t.Fatal("erwartet aktiviert als default ohne gesetzte praeferenz")
+	}
+}
+
+// Akzeptanzkriterium 1 + 2: gesetzte Praeferenz wirkt sofort.
+func TestSetAndIsEnabled(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	enabled, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled: %v", err)
+	}
+	if enabled {
+		t.Fatal("erwartet deaktiviert nach Set(..., false)")
+	}
+
+	// Andere Kanaele/Ereignistypen desselben Benutzers bleiben unberuehrt.
+	stillOn, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "in_app")
+	if err != nil {
+		t.Fatalf("is enabled (anderer kanal): %v", err)
+	}
+	if !stillOn {
+		t.Fatal("erwartet: anderer kanal bleibt aktiviert")
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 2: Einstellungen eines Benutzers wirken
+// sich NICHT auf einen anderen Benutzer aus.
+func TestSet_DoesNotAffectOtherUser(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set fuer user-1: %v", err)
+	}
+
+	enabledForOther, err := prefs.IsEnabled(ctx, "acme", "user-2", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled fuer user-2: %v", err)
+	}
+	if !enabledForOther {
+		t.Fatal("praeferenz von user-1 haette user-2 nicht beeinflussen duerfen")
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 1 (Kernbeweis): ein deaktivierter Kanal
+// erhaelt NACHWEISLICH keine weitere Zustellung — geprueft ueber die
+// tatsaechliche notification_jobs-Tabelle, nicht nur ueber den Rueckgabewert.
+func TestEnqueueIfAllowed_SkipsWhenDisabled(t *testing.T) {
+	prefs, dispatcher, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "invoice_ready", "email", false); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	jobID, skipped, err := EnqueueIfAllowed(ctx, prefs, dispatcher, "acme", "user-1", "invoice_ready", "email", "user1@acme.example", nil)
+	if err != nil {
+		t.Fatalf("enqueue if allowed: %v", err)
+	}
+	if !skipped {
+		t.Fatal("erwartet skipped=true bei deaktiviertem kanal")
+	}
+	if jobID != "" {
+		t.Fatalf("erwartet keine job-id, habe %q", jobID)
+	}
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM notification_jobs`).Scan(&count); err != nil {
+		t.Fatalf("notification_jobs zaehlen: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("erwartet 0 eingereihte jobs bei deaktiviertem kanal, habe %d", count)
+	}
+}
+
+func TestEnqueueIfAllowed_EnqueuesWhenEnabled(t *testing.T) {
+	prefs, dispatcher, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	jobID, skipped, err := EnqueueIfAllowed(ctx, prefs, dispatcher, "acme", "user-1", "invoice_ready", "email", "user1@acme.example", nil)
+	if err != nil {
+		t.Fatalf("enqueue if allowed: %v", err)
+	}
+	if skipped {
+		t.Fatal("erwartet skipped=false ohne deaktivierte praeferenz")
+	}
+	if jobID == "" {
+		t.Fatal("erwartet gesetzte job-id")
+	}
+}
+
+// Akzeptanzkriterium 3: Tenant-Admin-Übersicht zeigt alle Benutzer.
+func TestListForTenant_ShowsAllUsers(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set user-1: %v", err)
+	}
+	if err := prefs.Set(ctx, "acme", "user-2", "welcome", "in_app", false); err != nil {
+		t.Fatalf("set user-2: %v", err)
+	}
+	if err := prefs.Set(ctx, "other-tenant", "user-3", "welcome", "email", false); err != nil {
+		t.Fatalf("set user-3 (anderer tenant): %v", err)
+	}
+
+	overview, err := prefs.ListForTenant(ctx, "acme")
+	if err != nil {
+		t.Fatalf("list for tenant: %v", err)
+	}
+	if len(overview) != 2 {
+		t.Fatalf("erwartet 2 eintraege fuer tenant acme (nicht den anderen tenant), habe %d", len(overview))
+	}
+}

internal/pentest/qa04_pentest_test.go

@@ -0,0 +1,732 @@
+// Package pentest enthaelt QA-04 (Sicherheits- & Penetrationspruefung Core):
+// gezielte Angriffsversuche gegen die sensibelsten Core-Bereiche - SSO/OIDC,
+// Rate-Limiting/Account-Lockout im Mehrinstanz-Betrieb, zentrale
+// Policy-Durchsetzung und Master-Key-/Tenant-KEK-Verwaltung - jeweils gegen
+// die echten Produktionspakete, nicht gegen Mocks.
+package pentest
+
+import (
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/rsa"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/kek"
+	"gitea.perlbach24.de/scripte/nexarch/internal/lockout"
+	"gitea.perlbach24.de/scripte/nexarch/internal/oidc"
+	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
+	"gitea.perlbach24.de/scripte/nexarch/internal/ratelimit"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
+)
+
+// ---------------------------------------------------------------------
+// Testinfrastruktur (identisch zum Muster aus internal/e2e/helpers_test.go)
+// ---------------------------------------------------------------------
+
+func requireAdminDSN(t *testing.T) string {
+	t.Helper()
+	dsn := os.Getenv("TEST_ADMIN_DSN")
+	if dsn == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Pentest uebersprungen")
+	}
+	return dsn
+}
+
+func repoRoot(t *testing.T) string {
+	t.Helper()
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("getwd: %v", err)
+	}
+	return filepath.Join(wd, "..", "..")
+}
+
+func applyAllUpSQL(t *testing.T, ctx context.Context, pool *pgxpool.Pool, dir string) {
+	t.Helper()
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("migrationsverzeichnis %q lesen: %v", dir, err)
+	}
+	var names []string
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(e.Name(), ".up.sql") {
+			names = append(names, e.Name())
+		}
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		sqlBytes, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatalf("migration %q lesen: %v", name, err)
+		}
+		if _, err := pool.Exec(ctx, string(sqlBytes)); err != nil {
+			var pgErr *pgconn.PgError
+			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710") {
+				continue
+			}
+			t.Fatalf("migration %q anwenden: %v", name, err)
+		}
+	}
+}
+
+func setupRegistryPool(t *testing.T) (*pgxpool.Pool, string) {
+	t.Helper()
+	adminDSN := requireAdminDSN(t)
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+	applyAllUpSQL(t, ctx, pool, filepath.Join(repoRoot(t), "migrations"))
+	return pool, adminDSN
+}
+
+func uniqueSlug(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// =======================================================================
+// Pruefung 2 / Akzeptanzkriterium 1: SSO/OIDC gegen Token-Manipulation,
+// Replay und Claims-Manipulation.
+// =======================================================================
+
+// TestPentest_OIDC_AlgNoneAttack simuliert den klassischen "alg=none"-Angriff
+// gegen den EXTERNEN OIDC-Verifier (IAM-06, internal/oidc.Verifier): ein
+// Angreifer stellt sich selbst ein Token mit Signaturalgorithmus "none" aus,
+// in der Hoffnung, dass eine naive JWT-Bibliothek die fehlende Signatur
+// akzeptiert. internal/oidc.Verifier.Verify prueft explizit auf
+// *jwt.SigningMethodRSA - "none" muss zuverlaessig abgewiesen werden.
+func TestPentest_OIDC_AlgNoneAttack(t *testing.T) {
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("rsa key: %v", err)
+	}
+	verifier := oidc.NewVerifier(map[string]*rsa.PublicKey{"kid-1": &rsaKey.PublicKey}, "https://idp.example.test")
+
+	claims := jwt.MapClaims{
+		"sub": "angreifer@example.test",
+		"iss": "https://idp.example.test",
+		"exp": time.Now().Add(time.Hour).Unix(),
+	}
+	unsigned := jwt.NewWithClaims(jwt.SigningMethodNone, claims)
+	unsigned.Header["kid"] = "kid-1"
+	forged, err := unsigned.SignedString(jwt.UnsafeAllowNoneSignatureType)
+	if err != nil {
+		t.Fatalf("alg=none token faelschen: %v", err)
+	}
+
+	if _, err := verifier.Verify(forged); err == nil {
+		t.Fatal("alg=none-token wurde akzeptiert - kritische luecke")
+	}
+}
+
+// TestPentest_OIDC_ForeignKeySignature simuliert einen Angreifer, der ein
+// Token mit einem EIGENEN RSA-Schluessel signiert und die kid eines
+// bekannten, vertrauenswuerdigen Schluessels vorgibt (Schluessel-Confusion).
+// Verify darf das Token nur mit dem TATSAECHLICH registrierten Public Key
+// pruefen, niemals mit dem im Token mitgelieferten.
+func TestPentest_OIDC_ForeignKeySignature(t *testing.T) {
+	trustedKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("trusted key: %v", err)
+	}
+	attackerKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("attacker key: %v", err)
+	}
+	verifier := oidc.NewVerifier(map[string]*rsa.PublicKey{"trusted-kid": &trustedKey.PublicKey}, "https://idp.example.test")
+
+	claims := jwt.MapClaims{
+		"sub": "angreifer@example.test",
+		"iss": "https://idp.example.test",
+		"exp": time.Now().Add(time.Hour).Unix(),
+	}
+	forgedToken := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
+	forgedToken.Header["kid"] = "trusted-kid" // gibt vor, mit dem bekannten Schluessel signiert zu sein
+	forged, err := forgedToken.SignedString(attackerKey)
+	if err != nil {
+		t.Fatalf("token mit fremdem schluessel signieren: %v", err)
+	}
+
+	if _, err := verifier.Verify(forged); err == nil {
+		t.Fatal("mit fremdem schluessel signiertes token wurde akzeptiert - kritische luecke")
+	}
+}
+
+// TestPentest_OIDC_TamperedClaims prueft, dass eine nachtraegliche
+// Claims-Manipulation (z.B. sub oder roles aendern, ohne neu zu signieren)
+// zuverlaessig an der Signaturpruefung scheitert.
+func TestPentest_OIDC_TamperedClaims(t *testing.T) {
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("rsa key: %v", err)
+	}
+	verifier := oidc.NewVerifier(map[string]*rsa.PublicKey{"kid-1": &rsaKey.PublicKey}, "https://idp.example.test")
+
+	claims := jwt.MapClaims{
+		"sub":   "normaler-benutzer@example.test",
+		"iss":   "https://idp.example.test",
+		"roles": []string{"user"},
+		"exp":   time.Now().Add(time.Hour).Unix(),
+	}
+	valid := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
+	valid.Header["kid"] = "kid-1"
+	signed, err := valid.SignedString(rsaKey)
+	if err != nil {
+		t.Fatalf("token signieren: %v", err)
+	}
+
+	// Gegenprobe: das unveraenderte, echte Token wird akzeptiert.
+	if _, err := verifier.Verify(signed); err != nil {
+		t.Fatalf("unveraendertes, echtes token wurde abgewiesen: %v", err)
+	}
+
+	// Claims-Manipulation: Payload-Segment durch eine Version mit
+	// erhoehter Rolle ersetzen, Signatur-Segment unveraendert lassen.
+	parts := strings.Split(signed, ".")
+	if len(parts) != 3 {
+		t.Fatalf("unerwartetes token-format: %d segmente", len(parts))
+	}
+	tamperedClaims := jwt.MapClaims{
+		"sub":   "normaler-benutzer@example.test",
+		"iss":   "https://idp.example.test",
+		"roles": []string{"superadmin"}, // Rechteausweitung
+		"exp":   time.Now().Add(time.Hour).Unix(),
+	}
+	tamperedHeader := jwt.NewWithClaims(jwt.SigningMethodRS256, tamperedClaims)
+	tamperedHeader.Header["kid"] = "kid-1"
+	tamperedUnsigned, err := tamperedHeader.SigningString()
+	if err != nil {
+		t.Fatalf("manipulierten payload kodieren: %v", err)
+	}
+	tamperedParts := strings.Split(tamperedUnsigned, ".")
+	forged := tamperedParts[0] + "." + tamperedParts[1] + "." + parts[2] // fremder payload + ALTE signatur
+
+	if _, err := verifier.Verify(forged); err == nil {
+		t.Fatal("token mit manipulierten claims (rechteausweitung) wurde akzeptiert - kritische luecke")
+	}
+}
+
+// TestPentest_OIDC_NonceReplay ist Pruefung 2 (Replay-Schutz): ein gueltiges,
+// korrekt signiertes ID-Token eines FRUEHEREN Logins darf nicht fuer einen
+// neuen Login-Vorgang mit einem anderen erwarteten Nonce wiederverwendet
+// werden koennen.
+func TestPentest_OIDC_NonceReplay(t *testing.T) {
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatalf("rsa key: %v", err)
+	}
+	verifier := oidc.NewVerifier(map[string]*rsa.PublicKey{"kid-1": &rsaKey.PublicKey}, "https://idp.example.test")
+
+	claims := jwt.MapClaims{
+		"sub":   "benutzer@example.test",
+		"iss":   "https://idp.example.test",
+		"nonce": "nonce-aus-login-versuch-1",
+		"exp":   time.Now().Add(time.Hour).Unix(),
+	}
+	valid := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
+	valid.Header["kid"] = "kid-1"
+	signed, err := valid.SignedString(rsaKey)
+	if err != nil {
+		t.Fatalf("token signieren: %v", err)
+	}
+
+	// Der urspruengliche Login-Versuch (passender Nonce) ist gueltig.
+	if _, err := verifier.VerifyWithNonce(signed, "nonce-aus-login-versuch-1"); err != nil {
+		t.Fatalf("token mit korrektem nonce wurde abgewiesen: %v", err)
+	}
+
+	// Ein Angreifer faengt das Token ab und spielt es bei einem NEUEN
+	// Login-Versuch (mit eigenem, anderem erwarteten Nonce) erneut ein.
+	if _, err := verifier.VerifyWithNonce(signed, "nonce-aus-login-versuch-2"); err == nil {
+		t.Fatal("token-replay mit abweichendem nonce wurde akzeptiert - kritische luecke")
+	}
+}
+
+// TestPentest_OIDC_IdPTokenManipulation prueft den Weg, bei dem NEXARCH
+// selbst als OIDC-Provider fuer Drittanwendungen auftritt (IAM-13,
+// internal/oidc.Handler.JWKS + issueIDToken, Ed25519/EdDSA). Ein Angreifer
+// versucht, ein selbst signiertes ID-Token gegen den echten, aus dem
+// JWKS-Endpunkt gelesenen Schluessel zu verifizieren.
+func TestPentest_OIDC_IdPTokenManipulation(t *testing.T) {
+	genuinePub, genuinePriv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("echtes schluesselpaar erzeugen: %v", err)
+	}
+	attackerPub, attackerPriv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("angreifer-schluesselpaar erzeugen: %v", err)
+	}
+	_ = attackerPub
+
+	claims := oidc.IDTokenClaims{
+		Subject:    "opfer-user-id",
+		TenantSlug: "opfer-tenant",
+		Scopes:     []string{"openid"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			Issuer:    "https://core.nexarch.example",
+			Audience:  jwt.ClaimStrings{"drittanwendung-client-id"},
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(15 * time.Minute)),
+		},
+	}
+	forged := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
+	forged.Header["kid"] = "genuine-kid" // gibt vor, mit dem echten Schluessel signiert zu sein
+	forgedSigned, err := forged.SignedString(attackerPriv)
+	if err != nil {
+		t.Fatalf("token mit angreiferschluessel signieren: %v", err)
+	}
+
+	// Verifikation exakt wie eine Drittanwendung sie gegen den echten,
+	// aus dem JWKS-Endpunkt bezogenen Schluessel durchfuehren wuerde.
+	verify := func(tokenString string, kid2key map[string]ed25519.PublicKey) error {
+		parsed, err := jwt.Parse(tokenString, func(tk *jwt.Token) (interface{}, error) {
+			if _, ok := tk.Method.(*jwt.SigningMethodEd25519); !ok {
+				return nil, fmt.Errorf("unerwarteter algorithmus: %v", tk.Header["alg"])
+			}
+			kid, _ := tk.Header["kid"].(string)
+			pub, ok := kid2key[kid]
+			if !ok {
+				return nil, fmt.Errorf("unbekannte kid %q", kid)
+			}
+			return pub, nil
+		})
+		if err != nil || !parsed.Valid {
+			return fmt.Errorf("ungueltig: %w", err)
+		}
+		return nil
+	}
+
+	trustedKeys := map[string]ed25519.PublicKey{"genuine-kid": genuinePub}
+
+	if err := verify(forgedSigned, trustedKeys); err == nil {
+		t.Fatal("mit angreiferschluessel signiertes idp-token wurde akzeptiert - kritische luecke")
+	}
+
+	// Gegenprobe: ein echtes, mit dem tatsaechlichen Schluessel signiertes
+	// Token muss weiterhin akzeptiert werden (keine False-Positive-Abwehr).
+	genuine := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
+	genuine.Header["kid"] = "genuine-kid"
+	genuineSigned, err := genuine.SignedString(genuinePriv)
+	if err != nil {
+		t.Fatalf("echtes token signieren: %v", err)
+	}
+	if err := verify(genuineSigned, trustedKeys); err != nil {
+		t.Fatalf("echtes, korrekt signiertes idp-token wurde abgewiesen: %v", err)
+	}
+}
+
+// =======================================================================
+// Pruefung 1 / Akzeptanzkriterium 2: Rate-Limiting/Account-Lockout im
+// Mehrinstanz-Betrieb nachweislich nicht umgehbar.
+// =======================================================================
+
+// TestPentest_RateLimit_MultiInstanceBypassAttempt simuliert einen
+// Angreifer, der versucht, das Rate-Limit zu umgehen, indem er seine
+// Anfragen ueber MEHRERE Core-Instanzen (hier: mehrere unabhaengige
+// pgxpool.Pool-Verbindungen zur selben Postgres-Instanz, wie es getrennte
+// Core-Prozesse waeren) verteilt, in der Annahme, jede Instanz fuehre einen
+// eigenen In-Process-Zaehler. Da ratelimit.Store atomar gegen dieselbe
+// geteilte Tabelle arbeitet (API-03), darf die Gesamtsumme der erlaubten
+// Anfragen ueber ALLE "Instanzen" hinweg das konfigurierte Limit nicht
+// uebersteigen.
+func TestPentest_RateLimit_MultiInstanceBypassAttempt(t *testing.T) {
+	_, adminDSN := setupRegistryPool(t)
+	ctx := context.Background()
+	key := uniqueSlug("pentest-ratelimit")
+
+	const instanceCount = 4
+	const requestsPerInstance = 50
+	const limit = 100
+
+	// Eine eigene Konfiguration ueber EINE der "Instanzen" gesetzt - muss
+	// fuer alle anderen sofort sichtbar sein (geteilter Zustand).
+	configPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("config pool: %v", err)
+	}
+	defer configPool.Close()
+	if err := ratelimit.NewStore(configPool).SetLimit(ctx, key, limit, time.Minute); err != nil {
+		t.Fatalf("limit setzen: %v", err)
+	}
+
+	var allowed int64
+	var wg sync.WaitGroup
+	for i := 0; i < instanceCount; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			// Jede "Instanz" hat einen EIGENEN Pool - simuliert getrennte
+			// Prozesse, die sich keinen In-Memory-Zustand teilen.
+			instancePool, err := pgxpool.New(ctx, adminDSN)
+			if err != nil {
+				t.Errorf("instanz-pool: %v", err)
+				return
+			}
+			defer instancePool.Close()
+			store := ratelimit.NewStore(instancePool)
+
+			for j := 0; j < requestsPerInstance; j++ {
+				res, err := store.Allow(ctx, key)
+				if err != nil {
+					t.Errorf("allow: %v", err)
+					return
+				}
+				if res.Allowed {
+					atomic.AddInt64(&allowed, 1)
+				}
+			}
+		}()
+	}
+	wg.Wait()
+
+	totalRequests := int64(instanceCount * requestsPerInstance)
+	if allowed > limit {
+		t.Fatalf("mehrinstanz-umgehungsversuch erfolgreich: %d von %d anfragen ueber %d instanzen erlaubt, konfiguriertes limit war %d",
+			allowed, totalRequests, instanceCount, limit)
+	}
+	if allowed != limit {
+		t.Fatalf("erwartet exakt %d erlaubte anfragen (limit ausgeschoepft, nicht mehr/weniger), habe %d", limit, allowed)
+	}
+	t.Logf("mehrinstanz-umgehungsversuch protokolliert erfolglos: %d instanzen, %d anfragen gesamt, exakt %d (=limit) erlaubt", instanceCount, totalRequests, allowed)
+}
+
+// TestPentest_Lockout_MultiInstanceBypassAttempt simuliert denselben
+// Umgehungsversuch gegen den Account-Lockout (IAM-07): ein Angreifer verteilt
+// Brute-Force-Loginversuche fuer EIN Konto ueber mehrere Instanzen, um zu
+// verhindern, dass eine einzelne Instanz die Schwelle erreicht.
+func TestPentest_Lockout_MultiInstanceBypassAttempt(t *testing.T) {
+	registryPool, adminDSN := setupRegistryPool(t)
+	ctx := context.Background()
+
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	registry := tenant.NewRegistry(registryPool)
+	provisioner := tenant.NewProvisioner(registryPool, registry, dsnTemplate)
+
+	slug := uniqueSlug("pentest_lockout")
+	tn, err := provisioner.Provision(ctx, slug, "Pentest Lockout GmbH")
+	if err != nil {
+		t.Fatalf("provision: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug = $1`, slug)
+		_, _ = registryPool.Exec(ctx, `DROP DATABASE IF EXISTS "tenant_`+slug+`"`)
+	})
+
+	tenantPool, err := pgxpool.New(ctx, tn.DBDSN)
+	if err != nil {
+		t.Fatalf("tenant pool: %v", err)
+	}
+	defer tenantPool.Close()
+	applyAllUpSQL(t, ctx, tenantPool, filepath.Join(repoRoot(t), "migrations", "tenant"))
+
+	const email = "opfer@pentest.example"
+	const maxFailed = lockout.DefaultMaxFailedAttempts
+	const instanceCount = 3
+	const attemptsPerInstance = 4 // 3*4=12 > maxFailed(5), muesste ohne umgehung frueh sperren
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var lockedAt []int // Reihenfolge, in der jede "Instanz" eine Sperre beobachtet hat
+	for i := 0; i < instanceCount; i++ {
+		wg.Add(1)
+		instanceID := i
+		go func() {
+			defer wg.Done()
+			instancePool, err := pgxpool.New(ctx, tn.DBDSN)
+			if err != nil {
+				t.Errorf("instanz-pool: %v", err)
+				return
+			}
+			defer instancePool.Close()
+			store := lockout.NewStore(instancePool)
+
+			for j := 0; j < attemptsPerInstance; j++ {
+				locked, _, err := store.RecordFailure(ctx, email)
+				if err != nil {
+					t.Errorf("fehlversuch erfassen: %v", err)
+					return
+				}
+				if locked {
+					mu.Lock()
+					lockedAt = append(lockedAt, instanceID)
+					mu.Unlock()
+				}
+			}
+		}()
+	}
+	wg.Wait()
+
+	if len(lockedAt) == 0 {
+		t.Fatal("mehrinstanz-umgehungsversuch erfolgreich: konto wurde trotz insgesamt mehr als maxFailed fehlversuchen ueber mehrere instanzen NICHT gesperrt")
+	}
+
+	locked, _, err := lockout.NewStore(tenantPool).IsLocked(ctx, email)
+	if err != nil {
+		t.Fatalf("sperrstatus pruefen: %v", err)
+	}
+	if !locked {
+		t.Fatal("konto ist nach ueberschreiten der schwelle ueber mehrere instanzen hinweg nicht als gesperrt markiert")
+	}
+	t.Logf("mehrinstanz-umgehungsversuch protokolliert erfolglos: %d instanzen x %d versuche, konto nach ueberschreiten von maxFailed=%d gesperrt", instanceCount, attemptsPerInstance, maxFailed)
+}
+
+// =======================================================================
+// Pruefung 3 / Akzeptanzkriterium 3: zentrale Policy-Durchsetzung gegen
+// mindestens einen gezielten Umgehungsversuch je Modul.
+// =======================================================================
+
+// TestPentest_Policy_PrivilegeEscalationViaWrongRole ist der
+// Umgehungsversuch fuer den Identitaets-/Mandantenbereich (TEN/IAM-Module):
+// ein normaler Benutzer versucht, ueber den zentralen Enforcer (RBAC-02) ein
+// Recht zu nutzen, das ausschliesslich Superadmin vorbehalten ist
+// (PermManageTenants). Default-Deny muss greifen.
+func TestPentest_Policy_PrivilegeEscalationViaWrongRole(t *testing.T) {
+	registryPool, _ := setupRegistryPool(t)
+	ctx := context.Background()
+	store := policy.NewStore(registryPool)
+	enforcer := policy.NewEnforcer(store)
+
+	// Nur die Basisrechte gewaehren, wie es die reale Policy vorsieht -
+	// PermManageTenants bewusst NICHT an user oder tenant_admin vergeben.
+	if err := store.Grant(ctx, rbac.RoleUser, rbac.PermSelfRead, "pentest-setup"); err != nil {
+		t.Fatalf("basisrecht gewaehren: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = store.Revoke(ctx, rbac.RoleUser, rbac.PermSelfRead, "pentest-cleanup")
+	})
+
+	// Angriff: ein Benutzer mit Rolle "user" versucht, eine
+	// mandantenverwaltende Aktion auszufuehren.
+	err := enforcer.Authorize(ctx, rbac.RoleUser, rbac.PermManageTenants)
+	if err == nil {
+		t.Fatal("privilege-escalation erfolgreich: rolle 'user' durfte platform.manage_tenants ausfuehren")
+	}
+	if !errors.Is(err, policy.ErrDenied) {
+		t.Fatalf("erwartete policy.ErrDenied, habe: %v", err)
+	}
+
+	// Angriff Variante 2: dieselbe Aktion fuer tenant_admin, der ebenfalls
+	// nicht ueber PermManageTenants verfuegt.
+	if err := enforcer.Authorize(ctx, rbac.RoleTenantAdmin, rbac.PermManageTenants); !errors.Is(err, policy.ErrDenied) {
+		t.Fatalf("privilege-escalation ueber tenant_admin: erwartete policy.ErrDenied, habe: %v", err)
+	}
+}
+
+// TestPentest_Policy_GuardBypassStructurallyImpossible ist der
+// Umgehungsversuch gegen die Durchsetzungsschicht selbst (Akzeptanzkriterium
+// 1): policy.Guard ruft die uebergebene Query-Funktion NUR bei Erfolg von
+// Authorize auf. Dieser Test beweist das Verhalten aktiv, indem ein
+// Zaehler in der Query-Funktion inkrementiert wird - bei einer verweigerten
+// Autorisierung darf der Zaehler NIEMALS erhoeht werden, unabhaengig davon,
+// wie oft Guard aufgerufen wird.
+func TestPentest_Policy_GuardBypassStructurallyImpossible(t *testing.T) {
+	registryPool, _ := setupRegistryPool(t)
+	ctx := context.Background()
+	store := policy.NewStore(registryPool)
+	enforcer := policy.NewEnforcer(store)
+	// Bewusst KEINE Regel gewaehrt - default-deny.
+
+	var dataAccessed int32
+	query := func(ctx context.Context) (string, error) {
+		atomic.AddInt32(&dataAccessed, 1)
+		return "geheime mandantendaten", nil
+	}
+
+	for i := 0; i < 10; i++ {
+		_, err := policy.Guard(ctx, enforcer, rbac.RoleUser, rbac.PermManageSettings, query)
+		if err == nil {
+			t.Fatal("guard hat query trotz fehlender berechtigung ausgefuehrt")
+		}
+	}
+
+	if atomic.LoadInt32(&dataAccessed) != 0 {
+		t.Fatalf("umgehungsversuch erfolgreich: query wurde %d mal trotz verweigerter autorisierung ausgefuehrt", dataAccessed)
+	}
+}
+
+// =======================================================================
+// Akzeptanzkriterium 4: Master-Key- und Tenant-KEK-Verwaltung (API-10)
+// gegen Schluesselkompromittierung und Rotation geprueft.
+// =======================================================================
+
+// TestPentest_KEK_CompromisedMasterKeyCannotDecryptAfterRotation prueft: nach
+// einer Master-Key-Rotation kann der ALTE (potenziell kompromittierte)
+// Master-Key die Tenant-KEKs nicht mehr entschluesseln - kompromittiert ein
+// Angreifer den alten Master-Key NACH der Rotation, ist der Zugriff bereits
+// verwehrt.
+func TestPentest_KEK_CompromisedMasterKeyCannotDecryptAfterRotation(t *testing.T) {
+	oldMasterKey := randomMasterKey(t)
+	newMasterKey := randomMasterKey(t)
+
+	store, pool := setupKEKStore(t)
+	tenantID := insertTenantRow(t, pool, uniqueSlug("pentest_kek"))
+
+	plainKEK, err := store.CreateForTenant(context.Background(), tenantID, oldMasterKey)
+	if err != nil {
+		t.Fatalf("tenant-kek anlegen: %v", err)
+	}
+
+	rotated, failed, err := store.RotateMasterKey(context.Background(), oldMasterKey, newMasterKey)
+	if err != nil {
+		t.Fatalf("master-key-rotation: %v", err)
+	}
+	if rotated != 1 || len(failed) != 0 {
+		t.Fatalf("rotation unerwartet: rotated=%d failed=%v", rotated, failed)
+	}
+
+	// Angriff: der (kompromittierte) ALTE Master-Key wird nach der Rotation
+	// verwendet, um den Tenant-KEK zu entschluesseln.
+	if _, err := store.GetDecrypted(context.Background(), tenantID, oldMasterKey); err == nil {
+		t.Fatal("kompromittierter alter master-key konnte tenant-kek nach rotation weiterhin entschluesseln - kritische luecke")
+	}
+
+	// Gegenprobe: der neue Master-Key liefert weiterhin denselben Plaintext-
+	// Tenant-KEK (Akzeptanzkriterium 3: Rotation aendert nur die Verpackung).
+	decrypted, err := store.GetDecrypted(context.Background(), tenantID, newMasterKey)
+	if err != nil {
+		t.Fatalf("neuer master-key konnte tenant-kek nicht entschluesseln: %v", err)
+	}
+	if string(decrypted) != string(plainKEK) {
+		t.Fatal("tenant-kek-plaintext hat sich durch master-key-rotation veraendert - widerspricht akzeptanzkriterium 3")
+	}
+}
+
+// TestPentest_KEK_TenantKEKRotationDoesNotAffectOtherTenants ist der
+// Umgehungs-/Kompromittierungstest fuer Tenant-KEK-Rotation: kompromittiert
+// ein Angreifer den Tenant-KEK von Mandant A und dieser wird rotiert, darf
+// das keinerlei Auswirkung auf Mandant B haben (Fortsetzung der physischen
+// Modell-C-Isolation auf Schluesselebene).
+func TestPentest_KEK_TenantKEKRotationDoesNotAffectOtherTenants(t *testing.T) {
+	masterKey := randomMasterKey(t)
+	store, pool := setupKEKStore(t)
+
+	tenantA := insertTenantRow(t, pool, uniqueSlug("pentest_kek_a"))
+	tenantB := insertTenantRow(t, pool, uniqueSlug("pentest_kek_b"))
+
+	if _, err := store.CreateForTenant(context.Background(), tenantA, masterKey); err != nil {
+		t.Fatalf("tenant a kek anlegen: %v", err)
+	}
+	kekBBefore, err := store.CreateForTenant(context.Background(), tenantB, masterKey)
+	if err != nil {
+		t.Fatalf("tenant b kek anlegen: %v", err)
+	}
+
+	// Tenant As KEK wird rotiert (z.B. weil kompromittiert).
+	if _, err := store.RotateTenantKEK(context.Background(), tenantA, masterKey); err != nil {
+		t.Fatalf("tenant a rotation: %v", err)
+	}
+
+	kekBAfter, err := store.GetDecrypted(context.Background(), tenantB, masterKey)
+	if err != nil {
+		t.Fatalf("tenant b kek nach fremder rotation nicht mehr lesbar: %v", err)
+	}
+	if string(kekBAfter) != string(kekBBefore) {
+		t.Fatal("tenant bs kek hat sich durch rotation von tenant a veraendert - isolationsverletzung")
+	}
+}
+
+// TestPentest_KEK_TamperedWrappedKeyRejected prueft, dass eine Manipulation
+// des in der Datenbank gespeicherten, verpackten Tenant-KEK (z.B. durch
+// einen Angreifer mit Datenbankzugriff, aber ohne Master-Key) beim
+// Entschluesseln zuverlaessig als ungueltig erkannt wird - AES-GCM ist
+// authentifizierend, ein manipulierter Chiffretext darf niemals einen
+// (falschen) Plaintext zurueckliefern.
+func TestPentest_KEK_TamperedWrappedKeyRejected(t *testing.T) {
+	masterKey := randomMasterKey(t)
+	store, pool := setupKEKStore(t)
+	tenantID := insertTenantRow(t, pool, uniqueSlug("pentest_kek_tamper"))
+
+	if _, err := store.CreateForTenant(context.Background(), tenantID, masterKey); err != nil {
+		t.Fatalf("tenant-kek anlegen: %v", err)
+	}
+
+	// Angriff: ein Byte im gespeicherten, verpackten Schluessel wird
+	// direkt in der Datenbank veraendert (kein Master-Key noetig fuer diesen
+	// Schritt).
+	tag, err := pool.Exec(context.Background(), `
+		UPDATE tenant_keks SET wrapped_kek = set_byte(wrapped_kek, 20, get_byte(wrapped_kek, 20) # 255)
+		WHERE tenant_id = $1
+	`, tenantID)
+	if err != nil {
+		t.Fatalf("wrapped_kek manipulieren: %v", err)
+	}
+	if tag.RowsAffected() != 1 {
+		t.Fatalf("erwartet 1 manipulierte zeile, habe %d", tag.RowsAffected())
+	}
+
+	if _, err := store.GetDecrypted(context.Background(), tenantID, masterKey); !errors.Is(err, kek.ErrUnwrapFailed) {
+		t.Fatalf("manipulierter wrapped_kek wurde nicht als ErrUnwrapFailed erkannt: %v", err)
+	}
+}
+
+// ---------------------------------------------------------------------
+// KEK-Testhilfsfunktionen (eigenes Minimalschema wie in internal/kek/kek_test.go,
+// mit derselben Aufraeum-Disziplin - siehe QA-04-Befund zu
+// t.Cleanup/defer-Reihenfolge).
+// ---------------------------------------------------------------------
+
+func randomMasterKey(t *testing.T) kek.MasterKey {
+	t.Helper()
+	buf := make([]byte, kek.MasterKeySize)
+	if _, err := rand.Read(buf); err != nil {
+		t.Fatalf("master-key erzeugen: %v", err)
+	}
+	return kek.MasterKey(buf)
+}
+
+func setupKEKStore(t *testing.T) (*kek.Store, *pgxpool.Pool) {
+	t.Helper()
+	adminDSN := requireAdminDSN(t)
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	// Ueber t.Cleanup registriert (nicht defer), damit spaeter via t.Cleanup
+	// registrierte Aufraeumfunktionen (insertTenantRow) den Pool beim
+	// Ausfuehren noch offen vorfinden - siehe QA-04-Befund in
+	// internal/kek/kek_test.go zur defer/t.Cleanup-Reihenfolge.
+	t.Cleanup(func() { pool.Close() })
+
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenant_keks (
+			tenant_id UUID PRIMARY KEY REFERENCES tenants(id), wrapped_kek BYTEA NOT NULL,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), rotated_at TIMESTAMPTZ
+		)`); err != nil {
+		t.Fatalf("tenant_keks-schema: %v", err)
+	}
+	return kek.NewStore(pool), pool
+}
+
+func insertTenantRow(t *testing.T, pool *pgxpool.Pool, slug string) string {
+	t.Helper()
+	var id string
+	err := pool.QueryRow(context.Background(), `
+		INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ($1, $1, $1, 'unused') RETURNING id
+	`, slug).Scan(&id)
+	if err != nil {
+		t.Fatalf("tenant-zeile anlegen: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenant_keks WHERE tenant_id = $1`, id)
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE id = $1`, id)
+	})
+	return id
+}

internal/policy/enforcer.go

@@ -0,0 +1,67 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// ErrDenied wird geliefert, wenn keine Regel role+permission erlaubt —
+// Default-Deny (Akzeptanzkriterium 2).
+var ErrDenied = errors.New("policy: zugriff verweigert")
+
+// Enforcer ist die EINE zentrale Entscheidungs- und Durchsetzungsschicht
+// (Akzeptanzkriterium 1). Repository-/Query-Code ruft ausschliesslich Guard
+// bzw. GuardTenantScoped auf, nie eine Rohabfrage direkt.
+type Enforcer struct {
+	store *Store
+}
+
+func NewEnforcer(store *Store) *Enforcer {
+	return &Enforcer{store: store}
+}
+
+// Authorize entscheidet erlaubt/verboten — unabhaengig von jeder konkreten
+// Query, rein anhand der deklarativen Regeln (Akzeptanzkriterium 2: fuer
+// sich genommen testbar, ohne Anwendungslogik).
+func (e *Enforcer) Authorize(ctx context.Context, role rbac.Role, perm rbac.Permission) error {
+	allowed, err := e.store.IsAllowed(ctx, role, perm)
+	if err != nil {
+		return err
+	}
+	if !allowed {
+		return fmt.Errorf("%w: rolle %q hat kein recht %q", ErrDenied, role, perm)
+	}
+	return nil
+}
+
+// Guard ist die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): query
+// wird NUR aufgerufen, wenn Authorize zustimmt. Es gibt keinen Weg, query
+// ausserhalb von Guard aufzurufen und trotzdem den Aufrufer als autorisiert
+// zu behandeln — die Autorisierungsentscheidung steht immer VOR dem
+// Datenzugriff, nie danach.
+func Guard[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
+	var zero T
+	if err := e.Authorize(ctx, role, perm); err != nil {
+		return zero, err
+	}
+	return query(ctx)
+}
+
+// GuardTenantScoped erzwingt zusaetzlich, dass tenantSlug TEIL der Query-
+// Funktion selbst ist (Akzeptanzkriterium 3): der Funktionstyp verlangt,
+// dass die Repository-Implementierung tenantSlug in ihre eigene WHERE-
+// Klausel einbaut — ein nachgelagerter Filter auf dem Ergebnis (der
+// archivmail-Fehler aus "Bekannte Fehler vermeiden") ist mit dieser
+// Signatur nicht moeglich, da die Query-Funktion tenantSlug selbst
+// entgegennimmt und dafuer verantwortlich ist, statt ihn hinterher
+// anzuwenden.
+func GuardTenantScoped[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, tenantSlug string, query func(ctx context.Context, tenantSlug string) (T, error)) (T, error) {
+	var zero T
+	if err := e.Authorize(ctx, role, perm); err != nil {
+		return zero, err
+	}
+	return query(ctx, tenantSlug)
+}

internal/policy/policy_test.go

@@ -0,0 +1,187 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+func setupTest(t *testing.T) (*Store, *Enforcer, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS policy_rules (
+			role TEXT NOT NULL, permission TEXT NOT NULL,
+			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (role, permission)
+		);
+		CREATE TABLE IF NOT EXISTS policy_rule_changes (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
+			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
+			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	store := NewStore(pool)
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return store, NewEnforcer(store), cleanup
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Anfrage ohne passende Policy wird
+// zuverlaessig abgewiesen (Default-Deny), nicht standardmaessig erlaubt.
+func TestAuthorize_DefaultDeny(t *testing.T) {
+	_, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := enforcer.Authorize(ctx, rbac.Role("test_niemand"), rbac.Permission("test_irgendwas"))
+	if !errors.Is(err, ErrDenied) {
+		t.Fatalf("erwartet ErrDenied ohne konfigurierte regel, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Guard ruft query NUR bei Autorisierung
+// auf — kein Datenzugriffs-Pfad umgeht die Enforcement-Schicht.
+func TestGuard_NeverCallsQueryWithoutAuthorization(t *testing.T) {
+	store, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_rolle_guard")
+	perm := rbac.Permission("test_lesen")
+
+	queryCalled := false
+	_, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
+		queryCalled = true
+		return "geheime-daten", nil
+	})
+	if !errors.Is(err, ErrDenied) {
+		t.Fatalf("erwartet ErrDenied, habe %v", err)
+	}
+	if queryCalled {
+		t.Fatal("query haette bei fehlender autorisierung NICHT aufgerufen werden duerfen")
+	}
+
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+
+	result, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
+		queryCalled = true
+		return "geheime-daten", nil
+	})
+	if err != nil {
+		t.Fatalf("guard nach grant: %v", err)
+	}
+	if !queryCalled || result != "geheime-daten" {
+		t.Fatalf("erwartet query-aufruf mit ergebnis nach autorisierung, habe queryCalled=%v result=%q", queryCalled, result)
+	}
+}
+
+// Akzeptanzkriterium 2 + 3: Policy-Entscheidungen deklarativ und unabhaengig
+// von Anwendungslogik testbar — Regelwechsel wirkt ohne Codeaenderung,
+// Historie ist versioniert nachvollziehbar.
+func TestGrantRevoke_ChangesBehaviorWithoutCodeChange(t *testing.T) {
+	store, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_rolle_history")
+	perm := rbac.Permission("test_schreiben")
+
+	allowed, err := store.IsAllowed(ctx, role, perm)
+	if err != nil {
+		t.Fatalf("is allowed (vorher): %v", err)
+	}
+	if allowed {
+		t.Fatal("erwartet nicht erlaubt vor grant")
+	}
+
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+	if err := enforcer.Authorize(ctx, role, perm); err != nil {
+		t.Fatalf("authorize nach grant sollte erlauben: %v", err)
+	}
+
+	if err := store.Revoke(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("revoke: %v", err)
+	}
+	if err := enforcer.Authorize(ctx, role, perm); !errors.Is(err, ErrDenied) {
+		t.Fatalf("authorize nach revoke sollte verweigern, habe %v", err)
+	}
+
+	history, err := store.History(ctx, role, perm)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege (grant, revoke), habe %d", len(history))
+	}
+	if history[0].Action != "grant" || history[0].Version != 1 {
+		t.Fatalf("history[0] unerwartet: %+v", history[0])
+	}
+	if history[1].Action != "revoke" || history[1].Version != 2 {
+		t.Fatalf("history[1] unerwartet: %+v", history[1])
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3 (Tenant-Scoping): GuardTenantScoped
+// zwingt tenantSlug in die Query-Funktion selbst, kein Post-Filter moeglich.
+func TestGuardTenantScoped_IsolatesDataBetweenTenants(t *testing.T) {
+	_, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Simuliertes Repository: die WHERE-Klausel (hier: Map-Lookup) liegt
+	// INNERHALB der Query-Funktion, nicht als nachgelagerter Filter.
+	data := map[string][]string{
+		"acme":   {"dokument-a1", "dokument-a2"},
+		"globex": {"dokument-b1"},
+	}
+	repoQuery := func(ctx context.Context, tenantSlug string) ([]string, error) {
+		return data[tenantSlug], nil
+	}
+
+	role := rbac.Role("test_tenant_rolle")
+	perm := rbac.Permission("test_dokumente_lesen")
+	if err := enforcer.store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+
+	gotAcme, err := GuardTenantScoped(ctx, enforcer, role, perm, "acme", repoQuery)
+	if err != nil {
+		t.Fatalf("guard tenant scoped (acme): %v", err)
+	}
+	if len(gotAcme) != 2 {
+		t.Fatalf("erwartet 2 dokumente fuer acme, habe %d", len(gotAcme))
+	}
+
+	gotGlobex, err := GuardTenantScoped(ctx, enforcer, role, perm, "globex", repoQuery)
+	if err != nil {
+		t.Fatalf("guard tenant scoped (globex): %v", err)
+	}
+	if len(gotGlobex) != 1 {
+		t.Fatalf("erwartet 1 dokument fuer globex, habe %d", len(gotGlobex))
+	}
+}

internal/policy/store.go

@@ -0,0 +1,124 @@
+// Package policy implementiert Core RBAC-02: die zentrale Policy-
+// Entscheidungs- und Durchsetzungsschicht. Regeln liegen deklarativ in der
+// Datenbank (Casbin-Prinzip: Policy als Modell+Regeln getrennt vom Code),
+// versioniert und auditierbar — anders als Casbin-Dateien im Dateisystem
+// (siehe "bewusst vermeiden" im Ticket).
+package policy
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// Rule ist eine gewaehrte Regel: role darf permission.
+type Rule struct {
+	Role       rbac.Role
+	Permission rbac.Permission
+}
+
+// RuleChange ist ein Eintrag der Aenderungshistorie (Akzeptanzkriterium 3).
+type RuleChange struct {
+	Role       rbac.Role
+	Permission rbac.Permission
+	Action     string // "grant" oder "revoke"
+	Actor      string
+	Version    int
+}
+
+// Store verwaltet den deklarativen Regelsatz. IsAllowed schaut NUR in die
+// Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel
+// wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny:
+// existiert keine passende Regel, ist der Zugriff verboten
+// (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten
+// "erlaubt, wenn nichts anderes gesagt"-Pfad.
+func (s *Store) IsAllowed(ctx context.Context, role rbac.Role, perm rbac.Permission) (bool, error) {
+	var exists bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role = $1 AND permission = $2)
+	`, string(role), string(perm)).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("policy pruefen: %w", err)
+	}
+	return exists, nil
+}
+
+// Grant gewaehrt role das Recht permission — deklarativ, ohne Codeaenderung
+// wirksam. actor wird fuer die Aenderungshistorie festgehalten.
+func (s *Store) Grant(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
+	return s.change(ctx, role, perm, "grant", actor, `
+		INSERT INTO policy_rules (role, permission, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (role, permission) DO UPDATE SET granted_by = $3, granted_at = now()
+	`, string(role), string(perm), actor)
+}
+
+// Revoke entzieht role das Recht permission.
+func (s *Store) Revoke(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
+	return s.change(ctx, role, perm, "revoke", actor, `
+		DELETE FROM policy_rules WHERE role = $1 AND permission = $2
+	`, string(role), string(perm))
+}
+
+func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission, action, actor, sql string, args ...any) error {
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	if _, err := tx.Exec(ctx, sql, args...); err != nil {
+		return fmt.Errorf("regel aendern: %w", err)
+	}
+
+	var version int
+	if err := tx.QueryRow(ctx, `
+		SELECT COALESCE(MAX(version), 0) + 1 FROM policy_rule_changes WHERE role = $1 AND permission = $2
+	`, string(role), string(perm)).Scan(&version); err != nil {
+		return fmt.Errorf("naechste version ermitteln: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO policy_rule_changes (role, permission, action, actor, version, changed_at)
+		VALUES ($1, $2, $3, $4, $5, now())
+	`, string(role), string(perm), action, actor, version); err != nil {
+		return fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	return tx.Commit(ctx)
+}
+
+// History liefert die vollstaendige, versionierte Aenderungshistorie einer
+// Regel (Akzeptanzkriterium 3).
+func (s *Store) History(ctx context.Context, role rbac.Role, perm rbac.Permission) ([]RuleChange, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT action, actor, version FROM policy_rule_changes
+		WHERE role = $1 AND permission = $2 ORDER BY version
+	`, string(role), string(perm))
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []RuleChange
+	for rows.Next() {
+		c := RuleChange{Role: role, Permission: perm}
+		if err := rows.Scan(&c.Action, &c.Actor, &c.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}

internal/ratelimit/middleware.go

@@ -0,0 +1,64 @@
+package ratelimit
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
+)
+
+// KeyFunc bestimmt den Rate-Limit-Schluessel fuer eine Anfrage — typischerweise
+// der Tenant-Slug aus apiserver.RequestContext, siehe KeyByTenant. Als
+// eigenstaendiger Typ austauschbar (z.B. spaeter API-Token-basiert), ohne
+// internal/apiserver aendern zu muessen (Kein Umbau angrenzender Bereiche).
+type KeyFunc func(r *http.Request) (string, bool)
+
+// KeyByTenant liest den Tenant aus dem von internal/apiserver.authAndTenantContext
+// gesetzten RequestContext (IAM-02/API-01) — dieselbe Middleware-Kette,
+// keine zweite Authentifizierung.
+func KeyByTenant(r *http.Request) (string, bool) {
+	rc, ok := apiserver.FromContext(r.Context())
+	if !ok || rc.TenantSlug == "" {
+		return "", false
+	}
+	return rc.TenantSlug, true
+}
+
+// Middleware setzt sich VOR den eigentlichen Handler (nach Auth+Tenant-
+// Kontext, siehe KeyByTenant) und lehnt Anfragen ueber dem konfigurierten
+// Limit mit 429 + Retry-After ab (Akzeptanzkriterium 3).
+func Middleware(store *Store, keyFn KeyFunc, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		key, ok := keyFn(r)
+		if !ok {
+			// Kein Schluessel ermittelbar (z.B. kein Tenant-Kontext) — die
+			// Auth-Pruefung selbst ist Sache von authAndTenantContext, hier
+			// wird nur nicht limitiert, wenn schon kein Kontext vorliegt.
+			next(w, r)
+			return
+		}
+
+		result, err := store.Allow(r.Context(), key)
+		if err != nil {
+			apiserver.WriteError(w, http.StatusInternalServerError, "rate_limit_error", "rate-limit-pruefung fehlgeschlagen")
+			return
+		}
+
+		w.Header().Set("X-RateLimit-Limit", fmt.Sprintf("%d", result.Limit))
+		w.Header().Set("X-RateLimit-Remaining", fmt.Sprintf("%d", result.Remaining))
+
+		if !result.Allowed {
+			retryAfterSeconds := int(math.Ceil(result.RetryAfter.Seconds()))
+			if retryAfterSeconds < 1 {
+				retryAfterSeconds = 1
+			}
+			w.Header().Set("Retry-After", fmt.Sprintf("%d", retryAfterSeconds))
+			apiserver.WriteError(w, http.StatusTooManyRequests, "rate_limit_exceeded",
+				"zu viele anfragen, bitte spaeter erneut versuchen")
+			return
+		}
+
+		next(w, r)
+	}
+}

internal/ratelimit/middleware_test.go

@@ -0,0 +1,136 @@
+package ratelimit
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func setupMiddlewareTest(t *testing.T) (*apiserver.Server, *auth.TokenIssuer, *Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS rate_limit_configs (
+			key TEXT PRIMARY KEY, limit_value INT NOT NULL, window_seconds INT NOT NULL
+		);
+		CREATE TABLE IF NOT EXISTS rate_limit_counters (
+			key TEXT NOT NULL, window_start TIMESTAMPTZ NOT NULL, count INT NOT NULL DEFAULT 0,
+			PRIMARY KEY (key, window_start)
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
+	srv := apiserver.NewServer(issuer)
+	store := NewStore(pool)
+
+	cleanup := func() { pool.Close() }
+	return srv, issuer, store, cleanup
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Ueberschreitung liefert 429 mit
+// Retry-After-Header, ueber die vollstaendige Middleware-Kette (Auth ->
+// Tenant-Kontext -> Rate-Limit -> Handler) hinweg.
+func TestMiddleware_Returns429WithRetryAfterOnExceeded(t *testing.T) {
+	srv, issuer, store, cleanup := setupMiddlewareTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenantSlug := newTestKey()
+	if err := store.SetLimit(ctx, tenantSlug, 1, time.Minute); err != nil {
+		t.Fatalf("setlimit: %v", err)
+	}
+
+	called := 0
+	srv.HandleV1("/limited", Middleware(store, KeyByTenant, func(w http.ResponseWriter, r *http.Request) {
+		called++
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	token, err := issuer.Issue("user-1", tenantSlug)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	req1 := httptest.NewRequest(http.MethodGet, "/api/v1/limited", nil)
+	req1.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
+	rec1 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec1, req1)
+	if rec1.Code != http.StatusOK {
+		t.Fatalf("1. anfrage: status = %d, want 200", rec1.Code)
+	}
+
+	req2 := httptest.NewRequest(http.MethodGet, "/api/v1/limited", nil)
+	req2.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
+	rec2 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec2, req2)
+	if rec2.Code != http.StatusTooManyRequests {
+		t.Fatalf("2. anfrage: status = %d, want 429", rec2.Code)
+	}
+	if rec2.Header().Get("Retry-After") == "" {
+		t.Fatal("erwartet gesetzten Retry-After-Header bei 429")
+	}
+	if called != 1 {
+		t.Fatalf("handler wurde %d mal aufgerufen, want genau 1 (2. anfrage haette nicht durchgereicht werden duerfen)", called)
+	}
+}
+
+// Akzeptanzkriterium 1: das Limit ist pro Tenant konfigurierbar — ein
+// anderer Tenant (anderer Key) bleibt von der Ausschoepfung unberuehrt.
+func TestMiddleware_DifferentTenantsHaveIndependentLimits(t *testing.T) {
+	srv, issuer, store, cleanup := setupMiddlewareTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenantA := newTestKey()
+	tenantB := newTestKey()
+	if err := store.SetLimit(ctx, tenantA, 1, time.Minute); err != nil {
+		t.Fatalf("setlimit a: %v", err)
+	}
+	if err := store.SetLimit(ctx, tenantB, 1, time.Minute); err != nil {
+		t.Fatalf("setlimit b: %v", err)
+	}
+
+	srv.HandleV1("/limited2", Middleware(store, KeyByTenant, func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	tokenA, _ := issuer.Issue("user-a", tenantA)
+	tokenB, _ := issuer.Issue("user-b", tenantB)
+
+	// Tenant A schoepft sein Limit aus.
+	reqA := httptest.NewRequest(http.MethodGet, "/api/v1/limited2", nil)
+	reqA.AddCookie(&http.Cookie{Name: auth.CookieName, Value: tokenA})
+	recA := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recA, reqA)
+	if recA.Code != http.StatusOK {
+		t.Fatalf("tenant a, 1. anfrage: status = %d, want 200", recA.Code)
+	}
+
+	// Tenant B ist von der Ausschoepfung bei A unberuehrt.
+	reqB := httptest.NewRequest(http.MethodGet, "/api/v1/limited2", nil)
+	reqB.AddCookie(&http.Cookie{Name: auth.CookieName, Value: tokenB})
+	recB := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recB, reqB)
+	if recB.Code != http.StatusOK {
+		t.Fatalf("tenant b haette trotz ausgeschoepftem limit von tenant a erlaubt sein muessen, status = %d", recB.Code)
+	}
+}

internal/ratelimit/ratelimit.go

@@ -0,0 +1,126 @@
+// Package ratelimit implementiert Core API-03: eine zentrale Rate-Limiting-
+// Schicht fuer die gesamte Core-API mit GETEILTEM, EXTERNEM Zustand in
+// Postgres — kein In-Process-Zaehler (siehe "Bekannte Fehler vermeiden" im
+// Ticket: dasselbe Risiko wie bei IAM-07s In-Memory-Lockout). Fixed-Window-
+// Algorithmus: einfach, korrekt unter nebenlaeufigem Zugriff (atomares
+// UPSERT wie internal/usage.Store.Increment), und fuer ein API-Gateway
+// ausreichend praezise — kein Sliding-Window-Overhead noetig.
+package ratelimit
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultLimit/DefaultWindow gelten fuer jeden Schluessel (Tenant oder
+// API-Token), fuer den keine eigene Konfiguration existiert
+// (Akzeptanzkriterium 1: "konfigurierbar", nicht "verpflichtend konfiguriert").
+const (
+	DefaultLimit  = 100
+	DefaultWindow = time.Minute
+)
+
+// Config ist das je Schluessel konfigurierbare Limit.
+type Config struct {
+	Limit  int
+	Window time.Duration
+}
+
+// Store haelt Konfiguration UND Zaehlerstand in Postgres — beides ueber
+// dieselbe Verbindung erreichbar, damit mehrere Dienstinstanzen denselben
+// Zustand sehen (Akzeptanzkriterium 2).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// SetLimit setzt die Konfiguration fuer EINEN Schluessel (z.B. einen
+// Tenant-Slug oder eine API-Token-ID) — wirkt sich nicht auf andere
+// Schluessel aus (Akzeptanzkriterium 1 / Pruefung 3).
+func (s *Store) SetLimit(ctx context.Context, key string, limit int, window time.Duration) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO rate_limit_configs (key, limit_value, window_seconds)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (key) DO UPDATE SET limit_value = $2, window_seconds = $3
+	`, key, limit, int(window.Seconds()))
+	if err != nil {
+		return fmt.Errorf("rate-limit-konfiguration speichern: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) getConfig(ctx context.Context, key string) (Config, error) {
+	var limit, windowSeconds int
+	err := s.pool.QueryRow(ctx, `
+		SELECT limit_value, window_seconds FROM rate_limit_configs WHERE key = $1
+	`, key).Scan(&limit, &windowSeconds)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return Config{Limit: DefaultLimit, Window: DefaultWindow}, nil
+		}
+		return Config{}, fmt.Errorf("rate-limit-konfiguration lesen: %w", err)
+	}
+	return Config{Limit: limit, Window: time.Duration(windowSeconds) * time.Second}, nil
+}
+
+// Result ist der Ausgang einer Allow-Pruefung (Akzeptanzkriterium 3).
+type Result struct {
+	Allowed    bool
+	Limit      int
+	Remaining  int
+	RetryAfter time.Duration
+}
+
+// Allow erhoeht den Zaehler fuer (key, aktuelles Zeitfenster) ATOMAR ueber
+// ein einziges UPSERT (dasselbe Muster wie internal/usage.Store.Increment)
+// und vergleicht das Ergebnis gegen die konfigurierte Grenze — kein
+// Lesen-Erhoehen-Schreiben in Go, damit zwei Dienstinstanzen, die
+// gleichzeitig gegen dieselbe Datenbank inkrementieren, sich niemals
+// gegenseitig ueberschreiben (Akzeptanzkriterium 2 / Pruefung 1).
+func (s *Store) Allow(ctx context.Context, key string) (Result, error) {
+	cfg, err := s.getConfig(ctx, key)
+	if err != nil {
+		return Result{}, err
+	}
+
+	windowSeconds := int64(cfg.Window.Seconds())
+	if windowSeconds <= 0 {
+		windowSeconds = int64(DefaultWindow.Seconds())
+	}
+	now := time.Now().UTC()
+	windowStart := time.Unix((now.Unix()/windowSeconds)*windowSeconds, 0).UTC()
+	windowEnd := windowStart.Add(time.Duration(windowSeconds) * time.Second)
+
+	var count int
+	err = s.pool.QueryRow(ctx, `
+		INSERT INTO rate_limit_counters (key, window_start, count)
+		VALUES ($1, $2, 1)
+		ON CONFLICT (key, window_start) DO UPDATE
+			SET count = rate_limit_counters.count + 1
+		RETURNING count
+	`, key, windowStart).Scan(&count)
+	if err != nil {
+		return Result{}, fmt.Errorf("rate-limit-zaehler erhoehen: %w", err)
+	}
+
+	remaining := cfg.Limit - count
+	if remaining < 0 {
+		remaining = 0
+	}
+	if count > cfg.Limit {
+		return Result{
+			Allowed:    false,
+			Limit:      cfg.Limit,
+			Remaining:  0,
+			RetryAfter: windowEnd.Sub(now),
+		}, nil
+	}
+	return Result{Allowed: true, Limit: cfg.Limit, Remaining: remaining}, nil
+}

internal/ratelimit/ratelimit_test.go

@@ -0,0 +1,168 @@
+package ratelimit
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS rate_limit_configs (
+			key TEXT PRIMARY KEY, limit_value INT NOT NULL, window_seconds INT NOT NULL
+		);
+		CREATE TABLE IF NOT EXISTS rate_limit_counters (
+			key TEXT NOT NULL, window_start TIMESTAMPTZ NOT NULL, count INT NOT NULL DEFAULT 0,
+			PRIMARY KEY (key, window_start)
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return pool, cleanup
+}
+
+func newTestKey() string {
+	return fmt.Sprintf("test-key-%d", time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Ueberschreitung des Limits wird
+// nachweislich erkannt.
+func TestAllow_RejectsAfterLimitExceeded(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	store := NewStore(pool)
+	ctx := context.Background()
+	key := newTestKey()
+
+	if err := store.SetLimit(ctx, key, 3, time.Minute); err != nil {
+		t.Fatalf("setlimit: %v", err)
+	}
+
+	for i := 0; i < 3; i++ {
+		res, err := store.Allow(ctx, key)
+		if err != nil {
+			t.Fatalf("allow %d: %v", i, err)
+		}
+		if !res.Allowed {
+			t.Fatalf("anfrage %d haette erlaubt sein muessen, limit=3", i)
+		}
+	}
+
+	res, err := store.Allow(ctx, key)
+	if err != nil {
+		t.Fatalf("allow (4.): %v", err)
+	}
+	if res.Allowed {
+		t.Fatal("4. anfrage haette abgelehnt werden muessen (limit=3)")
+	}
+	if res.RetryAfter <= 0 {
+		t.Fatalf("erwartet positive retry-after-dauer, habe %v", res.RetryAfter)
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 3: Konfigurationsaenderung wirkt sich
+// NICHT auf andere Schluessel (Tenants) aus.
+func TestSetLimit_DoesNotAffectOtherKeys(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	store := NewStore(pool)
+	ctx := context.Background()
+	keyA := newTestKey()
+	keyB := newTestKey()
+
+	if err := store.SetLimit(ctx, keyA, 1, time.Minute); err != nil {
+		t.Fatalf("setlimit a: %v", err)
+	}
+
+	resA1, _ := store.Allow(ctx, keyA)
+	resA2, _ := store.Allow(ctx, keyA)
+	if !resA1.Allowed || resA2.Allowed {
+		t.Fatalf("key a: erwartet erlaubt,abgelehnt, habe %v,%v", resA1.Allowed, resA2.Allowed)
+	}
+
+	// keyB hat keine eigene Konfiguration -> DefaultLimit, unbeeinflusst von keyA.
+	resB, err := store.Allow(ctx, keyB)
+	if err != nil {
+		t.Fatalf("allow b: %v", err)
+	}
+	if !resB.Allowed {
+		t.Fatal("key b haette trotz limit-ueberschreitung bei key a erlaubt sein muessen")
+	}
+	if resB.Limit != DefaultLimit {
+		t.Fatalf("key b limit = %d, want default %d", resB.Limit, DefaultLimit)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: zwei "Dienstinstanzen" (zwei
+// unabhaengige Pools/Store-Objekte) gegen dieselbe Datenbank setzen
+// dasselbe Limit korrekt durch — kein In-Process-Zustand kann das leisten.
+func TestAllow_TwoInstancesShareStateCorrectly(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+
+	ctx := context.Background()
+	pool2, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("zweiter pool (simuliert zweite instanz): %v", err)
+	}
+	defer pool2.Close()
+
+	storeInstance1 := NewStore(pool)
+	storeInstance2 := NewStore(pool2)
+
+	key := newTestKey()
+	const limit = 20
+	if err := storeInstance1.SetLimit(ctx, key, limit, time.Minute); err != nil {
+		t.Fatalf("setlimit: %v", err)
+	}
+
+	const totalRequests = 50
+	var allowedCount int64
+	var wg sync.WaitGroup
+	for i := 0; i < totalRequests; i++ {
+		wg.Add(1)
+		store := storeInstance1
+		if i%2 == 0 {
+			store = storeInstance2 // Haelfte der Anfragen "kommt" von der zweiten Instanz
+		}
+		go func(s *Store) {
+			defer wg.Done()
+			res, err := s.Allow(ctx, key)
+			if err != nil {
+				t.Errorf("allow: %v", err)
+				return
+			}
+			if res.Allowed {
+				atomic.AddInt64(&allowedCount, 1)
+			}
+		}(store)
+	}
+	wg.Wait()
+
+	if allowedCount != limit {
+		t.Fatalf("erlaubte anfragen ueber beide instanzen = %d, want exakt %d (geteilter zustand)", allowedCount, limit)
+	}
+}

internal/rbac/group.go

@@ -0,0 +1,200 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrGroupNotFound = errors.New("rbac: gruppe nicht gefunden")
+
+type Group struct {
+	ID   string
+	Name string
+	Role Role // leer, wenn der Gruppe noch keine Rolle zugewiesen wurde
+}
+
+// GroupStore verwaltet Gruppen/Abteilungen innerhalb GENAU EINER Tenant-
+// Datenbank (Modell C, wie Store fuer direkte Rollenzuweisungen) —
+// Akzeptanzkriterium 3 (tenant-isoliert) ist damit strukturell erfuellt.
+type GroupStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewGroupStore(pool *pgxpool.Pool) *GroupStore {
+	return &GroupStore{pool: pool}
+}
+
+// CreateGroup legt eine neue, noch rollenlose Gruppe an (Akzeptanzkriterium 1).
+func (s *GroupStore) CreateGroup(ctx context.Context, name string) (Group, error) {
+	if name == "" {
+		return Group{}, errors.New("rbac: gruppenname darf nicht leer sein")
+	}
+	var g Group
+	g.Name = name
+	if err := s.pool.QueryRow(ctx, `
+		INSERT INTO groups (name) VALUES ($1) RETURNING id
+	`, name).Scan(&g.ID); err != nil {
+		return Group{}, fmt.Errorf("gruppe anlegen: %w", err)
+	}
+	return g, nil
+}
+
+// SetGroupRole weist der Gruppe eine Rolle zu (Akzeptanzkriterium 2) — nur
+// 'user'/'tenant_admin' sind auf Gruppenebene zuweisbar, dieselbe erlaubte
+// Matrix wie in Store.Assign (superadmin bleibt mandantenuebergreifend und
+// ausserhalb jeder Gruppenlogik).
+func (s *GroupStore) SetGroupRole(ctx context.Context, groupID string, role Role) error {
+	if !assignableRoles[role] {
+		return ErrRoleNotAssignableInTenantScope
+	}
+	tag, err := s.pool.Exec(ctx, `UPDATE groups SET role = $2 WHERE id = $1`, groupID, string(role))
+	if err != nil {
+		return fmt.Errorf("gruppenrolle setzen: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrGroupNotFound
+	}
+	return nil
+}
+
+// AddMember nimmt einen Benutzer in die Gruppe auf.
+func (s *GroupStore) AddMember(ctx context.Context, groupID, userID string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
+		ON CONFLICT (group_id, user_id) DO NOTHING
+	`, groupID, userID)
+	if err != nil {
+		return fmt.Errorf("mitglied hinzufuegen: %w", err)
+	}
+	return nil
+}
+
+// RemoveMember entfernt einen Benutzer aus der Gruppe — die gruppenbasierten
+// Rechte entfallen fuer ihn sofort (Akzeptanzkriterium 3 / Pruefung 2), da
+// EffectivePermissionsForUser bei jedem Aufruf neu berechnet wird, nicht
+// zwischengespeichert.
+func (s *GroupStore) RemoveMember(ctx context.Context, groupID, userID string) error {
+	_, err := s.pool.Exec(ctx, `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID)
+	if err != nil {
+		return fmt.Errorf("mitglied entfernen: %w", err)
+	}
+	return nil
+}
+
+// DeleteGroup loescht die Gruppe — ON DELETE CASCADE entfernt die
+// Mitgliedschaften mit, Benutzerkonten selbst bleiben unberuehrt
+// (Akzeptanzkriterium 3).
+func (s *GroupStore) DeleteGroup(ctx context.Context, groupID string) error {
+	_, err := s.pool.Exec(ctx, `DELETE FROM groups WHERE id = $1`, groupID)
+	if err != nil {
+		return fmt.Errorf("gruppe loeschen: %w", err)
+	}
+	return nil
+}
+
+// ListGroups liefert alle Gruppen des Mandanten (Akzeptanzkriterium 1/2,
+// Grundlage fuer die Administrationsoberflaeche).
+func (s *GroupStore) ListGroups(ctx context.Context) ([]Group, error) {
+	rows, err := s.pool.Query(ctx, `SELECT id, name, COALESCE(role, '') FROM groups ORDER BY name`)
+	if err != nil {
+		return nil, fmt.Errorf("gruppen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Group
+	for rows.Next() {
+		var g Group
+		var role string
+		if err := rows.Scan(&g.ID, &g.Name, &role); err != nil {
+			return nil, fmt.Errorf("gruppe lesen: %w", err)
+		}
+		g.Role = Role(role)
+		out = append(out, g)
+	}
+	return out, rows.Err()
+}
+
+// Members liefert die User-IDs der Mitglieder einer Gruppe.
+func (s *GroupStore) Members(ctx context.Context, groupID string) ([]string, error) {
+	rows, err := s.pool.Query(ctx, `SELECT user_id FROM group_members WHERE group_id = $1`, groupID)
+	if err != nil {
+		return nil, fmt.Errorf("mitglieder abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, fmt.Errorf("mitglied lesen: %w", err)
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}
+
+// RolesForUser liefert alle Rollen, die einem Benutzer ueber seine
+// Gruppenmitgliedschaften zufallen (Akzeptanzkriterium 2: wirkt auf alle
+// Mitglieder). Eine Gruppe ohne zugewiesene Rolle traegt nichts bei.
+func (s *GroupStore) RolesForUser(ctx context.Context, userID string) ([]Role, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT g.role FROM groups g
+		JOIN group_members gm ON gm.group_id = g.id
+		WHERE gm.user_id = $1 AND g.role IS NOT NULL
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("gruppenrollen abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Role
+	for rows.Next() {
+		var r string
+		if err := rows.Scan(&r); err != nil {
+			return nil, fmt.Errorf("gruppenrolle lesen: %w", err)
+		}
+		out = append(out, Role(r))
+	}
+	return out, rows.Err()
+}
+
+// EffectivePermissionsForUser vereinigt die Rechte aus der direkten
+// Rollenzuweisung (Store, RBAC-01) mit allen Rechten aus Gruppenrollen —
+// jede einzelne Rolle wird ueber die bestehende Hierarchie (EffectivePermissions)
+// aufgeloest, das Ergebnis dedupliziert.
+func (s *GroupStore) EffectivePermissionsForUser(ctx context.Context, directStore *Store, userID string) ([]Permission, error) {
+	seen := make(map[Permission]bool)
+	var out []Permission
+
+	add := func(role Role) {
+		for _, p := range EffectivePermissions(role) {
+			if !seen[p] {
+				seen[p] = true
+				out = append(out, p)
+			}
+		}
+	}
+
+	if directStore != nil {
+		assignment, err := directStore.Get(ctx, userID)
+		if err != nil && !errors.Is(err, ErrNotFound) {
+			return nil, err
+		}
+		if err == nil {
+			add(assignment.Role)
+		}
+	}
+
+	groupRoles, err := s.RolesForUser(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range groupRoles {
+		add(r)
+	}
+
+	return out, nil
+}

internal/rbac/group_test.go

@@ -0,0 +1,209 @@
+package rbac
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const groupSchema = `
+CREATE TABLE IF NOT EXISTS users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS role_assignments (
+	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS groups (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS group_members (
+	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
+	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
+);`
+
+func setupGroupTestDB(t *testing.T, dbName string) *pgxpool.Pool {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+	if _, err := pool.Exec(ctx, groupSchema); err != nil {
+		t.Fatalf("schema anwenden: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+	return pool
+}
+
+func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
+	t.Helper()
+	u, err := user.NewTenantUserStore(pool).Create(context.Background(), email, "Test")
+	if err != nil {
+		t.Fatalf("testuser anlegen: %v", err)
+	}
+	return u.ID
+}
+
+// Akzeptanzkriterium 1: Gruppen anlegen und Benutzer zuordnen.
+func TestGroup_CreateAndAddMember(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_create")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, err := gs.CreateGroup(ctx, "Buchhaltung")
+	if err != nil {
+		t.Fatalf("create group: %v", err)
+	}
+	userID := createTestUser(t, pool, "alice@example.com")
+
+	if err := gs.AddMember(ctx, g.ID, userID); err != nil {
+		t.Fatalf("add member: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Gruppenrolle wirkt auf ALLE aktuellen
+// Mitglieder.
+func TestGroup_RoleAffectsAllCurrentMembers(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_roleall")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, err := gs.CreateGroup(ctx, "Admins")
+	if err != nil {
+		t.Fatalf("create group: %v", err)
+	}
+	if err := gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin); err != nil {
+		t.Fatalf("set group role: %v", err)
+	}
+
+	alice := createTestUser(t, pool, "alice@example.com")
+	bob := createTestUser(t, pool, "bob@example.com")
+	if err := gs.AddMember(ctx, g.ID, alice); err != nil {
+		t.Fatalf("add alice: %v", err)
+	}
+	if err := gs.AddMember(ctx, g.ID, bob); err != nil {
+		t.Fatalf("add bob: %v", err)
+	}
+
+	for _, uid := range []string{alice, bob} {
+		perms, err := gs.EffectivePermissionsForUser(ctx, nil, uid)
+		if err != nil {
+			t.Fatalf("effective permissions fuer %s: %v", uid, err)
+		}
+		if !contains(perms, PermManageUsers) {
+			t.Fatalf("mitglied %s sollte tenant_admin-rechte ueber die gruppe haben, habe %v", uid, perms)
+		}
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Entfernen aus der Gruppe entzieht die
+// gruppenbasierten Rechte sofort.
+func TestGroup_RemoveMemberRevokesRightsImmediately(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_remove")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, _ := gs.CreateGroup(ctx, "Admins")
+	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
+	userID := createTestUser(t, pool, "alice@example.com")
+	_ = gs.AddMember(ctx, g.ID, userID)
+
+	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions (mitglied): %v", err)
+	}
+	if !contains(perms, PermManageUsers) {
+		t.Fatal("erwartet tenant_admin-rechte als mitglied")
+	}
+
+	if err := gs.RemoveMember(ctx, g.ID, userID); err != nil {
+		t.Fatalf("remove member: %v", err)
+	}
+
+	perms, err = gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions (entfernt): %v", err)
+	}
+	if contains(perms, PermManageUsers) {
+		t.Fatal("erwartet KEINE tenant_admin-rechte nach entfernen aus der gruppe")
+	}
+}
+
+// Akzeptanzkriterium 3: Loeschen einer Gruppe entzieht Rechte sauber, ohne
+// das Benutzerkonto zu loeschen.
+func TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_delete")
+	gs := NewGroupStore(pool)
+	us := user.NewTenantUserStore(pool)
+	ctx := context.Background()
+
+	g, _ := gs.CreateGroup(ctx, "Temp")
+	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
+	userID := createTestUser(t, pool, "alice@example.com")
+	_ = gs.AddMember(ctx, g.ID, userID)
+
+	if err := gs.DeleteGroup(ctx, g.ID); err != nil {
+		t.Fatalf("delete group: %v", err)
+	}
+
+	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions: %v", err)
+	}
+	if contains(perms, PermManageUsers) {
+		t.Fatal("erwartet keine rechte mehr nach loeschen der gruppe")
+	}
+
+	if _, err := us.Get(ctx, userID); err != nil {
+		t.Fatalf("benutzerkonto haette erhalten bleiben muessen: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Gruppen sind sauber tenant-isoliert.
+func TestGroup_TenantIsolation(t *testing.T) {
+	poolA := setupGroupTestDB(t, "test_rbac03_tenanta")
+	poolB := setupGroupTestDB(t, "test_rbac03_tenantb")
+	gsA := NewGroupStore(poolA)
+	ctx := context.Background()
+
+	if _, err := gsA.CreateGroup(ctx, "Nur-Tenant-A"); err != nil {
+		t.Fatalf("create group a: %v", err)
+	}
+
+	var countB int
+	if err := poolB.QueryRow(ctx, `SELECT count(*) FROM groups`).Scan(&countB); err != nil {
+		t.Fatalf("count tenant b: %v", err)
+	}
+	if countB != 0 {
+		t.Fatalf("tenant b sollte keine gruppen aus tenant a sehen, habe %d", countB)
+	}
+}

internal/rbac/handler.go

@@ -0,0 +1,250 @@
+package rbac
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Handler stellt Rollen-/Rechte- und Gruppenverwaltung als HTTP-Endpunkte
+// bereit (RBAC-05). Duenner Client der bestehenden Store/GroupStore-Schicht —
+// keine eigene Rechtelogik hier (siehe Ticket-Produkt-DNA).
+type Handler struct {
+	roles  *Store
+	groups *GroupStore
+}
+
+func NewHandler(roles *Store, groups *GroupStore) *Handler {
+	return &Handler{roles: roles, groups: groups}
+}
+
+// requireManageUsers prueft, ob der aufrufende Benutzer ueberhaupt
+// Rechteverwaltung ausueben darf — technisch durchgesetzt hier zusaetzlich
+// zu RBAC-02 (Policy-Enforcement-Schicht), da diese Kachel ein eigener,
+// besonders sicherheitskritischer HTTP-Einstiegspunkt ist.
+func requireManageUsers(w http.ResponseWriter, r *http.Request, roles *Store) (callerUserID string, ok bool) {
+	claims, authOK := auth.ClaimsFromContext(r.Context())
+	if !authOK {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return "", false
+	}
+	assignment, err := roles.Get(r.Context(), claims.UserID)
+	if err != nil || !HasPermission(assignment.Role, PermManageUsers) {
+		http.Error(w, "keine Berechtigung zur Rechteverwaltung", http.StatusForbidden)
+		return "", false
+	}
+	return claims.UserID, true
+}
+
+type roleInfo struct {
+	Role        Role         `json:"role"`
+	Permissions []Permission `json:"permissions"`
+}
+
+// ListRoles liefert die (im Tenant-Geltungsbereich zuweisbaren) Rollen mit
+// ihren vollstaendig aufgeloesten Rechten (Akzeptanzkriterium 1).
+func (h *Handler) ListRoles(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	out := make([]roleInfo, 0, len(assignableRoles))
+	for role := range assignableRoles {
+		out = append(out, roleInfo{Role: role, Permissions: EffectivePermissions(role)})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(out)
+}
+
+type assignRoleRequest struct {
+	UserID string `json:"user_id"`
+	Role   Role   `json:"role"`
+}
+
+// roleRank ordnet die Rollenhierarchie fuer den Selbst-Eskalations-Vergleich
+// (Akzeptanzkriterium 2 / Pruefung 2) — hoehere Zahl = mehr Rechte. Basiert
+// auf derselben parent-Kette wie EffectivePermissions, nicht dupliziert als
+// eigenstaendiges Modell.
+func roleRank(role Role) int {
+	rank := 0
+	for r, ok := role, true; ok; r, ok = parent[r] {
+		rank++
+	}
+	return rank
+}
+
+// AssignRole weist einem Benutzer eine Rolle zu (Akzeptanzkriterium 1).
+// Verweigert explizit, dass sich der aufrufende Benutzer selbst eine
+// hoehere Rolle zuweist (Akzeptanzkriterium 2 / Pruefung 2) — unabhaengig
+// davon, ob RBAC-02 dieselbe Aktion ohnehin ueber die allgemeine
+// Policy-Schicht verhindern wuerde: Selbst-Eskalation ist ein derart
+// sicherheitskritischer Einzelfall, dass er hier zusaetzlich explizit und
+// unuebersehbar geprueft wird, statt sich allein auf eine generische
+// Regel an anderer Stelle zu verlassen.
+func (h *Handler) AssignRole(w http.ResponseWriter, r *http.Request) {
+	callerUserID, ok := requireManageUsers(w, r, h.roles)
+	if !ok {
+		return
+	}
+
+	var req assignRoleRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	if req.UserID == callerUserID {
+		callerAssignment, err := h.roles.Get(r.Context(), callerUserID)
+		callerRole := RoleUser
+		if err == nil {
+			callerRole = callerAssignment.Role
+		}
+		if roleRank(req.Role) > roleRank(callerRole) {
+			http.Error(w, "Sie können sich nicht selbst eine höhere Rolle zuweisen.", http.StatusForbidden)
+			return
+		}
+	}
+
+	assignment, err := h.roles.Assign(r.Context(), req.UserID, req.Role, callerUserID)
+	if err != nil {
+		http.Error(w, "Rolle konnte nicht zugewiesen werden.", http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(assignment)
+}
+
+// RoleHistory liefert die Zuweisungshistorie eines Benutzers — der in
+// Akzeptanzkriterium 3 geforderte Verweis auf das Audit-Log (die
+// role_assignment_history-Tabelle selbst IST die Nachvollziehbarkeits-Spur;
+// eine vollstaendige Anbindung an Core AUD-01 ist nicht Teil dieser Kachel).
+func (h *Handler) RoleHistory(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	userID := strings.TrimPrefix(r.URL.Path, "/rbac/users/")
+	userID = strings.TrimSuffix(userID, "/history")
+	if userID == "" {
+		http.Error(w, "user_id fehlt", http.StatusBadRequest)
+		return
+	}
+
+	history, err := h.roles.History(r.Context(), userID)
+	if err != nil {
+		http.Error(w, "historie konnte nicht geladen werden", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(history)
+}
+
+type createGroupRequest struct {
+	Name string `json:"name"`
+}
+
+// CreateGroup legt eine neue Gruppe an (Akzeptanzkriterium 2).
+func (h *Handler) CreateGroup(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req createGroupRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	group, err := h.groups.CreateGroup(r.Context(), req.Name)
+	if err != nil {
+		http.Error(w, "Gruppe konnte nicht angelegt werden.", http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(group)
+}
+
+type groupWithMembers struct {
+	Group
+	Members []string `json:"members"`
+}
+
+// ListGroups liefert alle Gruppen inkl. Mitgliederliste (Akzeptanzkriterium 2).
+func (h *Handler) ListGroups(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	groups, err := h.groups.ListGroups(r.Context())
+	if err != nil {
+		http.Error(w, "Gruppen konnten nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	out := make([]groupWithMembers, 0, len(groups))
+	for _, g := range groups {
+		members, err := h.groups.Members(r.Context(), g.ID)
+		if err != nil {
+			http.Error(w, "Mitglieder konnten nicht geladen werden.", http.StatusInternalServerError)
+			return
+		}
+		out = append(out, groupWithMembers{Group: g, Members: members})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(out)
+}
+
+type groupActionRequest struct {
+	GroupID string `json:"group_id"`
+	UserID  string `json:"user_id"`
+	Role    Role   `json:"role"`
+}
+
+// SetGroupRole weist einer Gruppe eine Rolle zu (Akzeptanzkriterium 2).
+func (h *Handler) SetGroupRole(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.SetGroupRole(r.Context(), req.GroupID, req.Role); err != nil {
+		http.Error(w, "Gruppenrolle konnte nicht gesetzt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// AddGroupMember nimmt einen Benutzer in eine Gruppe auf (Akzeptanzkriterium 2).
+func (h *Handler) AddGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.AddMember(r.Context(), req.GroupID, req.UserID); err != nil {
+		http.Error(w, "Mitglied konnte nicht hinzugefügt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// RemoveGroupMember entfernt einen Benutzer aus einer Gruppe.
+func (h *Handler) RemoveGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.RemoveMember(r.Context(), req.GroupID, req.UserID); err != nil {
+		http.Error(w, "Mitglied konnte nicht entfernt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}

internal/rbac/handler_test.go

@@ -0,0 +1,309 @@
+package rbac
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const handlerSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE role_assignments (
+	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE role_assignment_history (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE groups (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE group_members (
+	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
+	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
+);`
+
+func setupHandlerTest(t *testing.T, dbName string) (*Handler, *Store, *user.TenantUserStore, *pgxpool.Pool) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+	if _, err := pool.Exec(ctx, handlerSchema); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+
+	roleStore := NewStore(pool)
+	groupStore := NewGroupStore(pool)
+	return NewHandler(roleStore, groupStore), roleStore, user.NewTenantUserStore(pool), pool
+}
+
+func sessionCookieFor(t *testing.T, issuer *auth.TokenIssuer, userID string) *http.Cookie {
+	t.Helper()
+	token, err := issuer.Issue(userID, "acme")
+	if err != nil {
+		t.Fatalf("session-token ausstellen: %v", err)
+	}
+	return &http.Cookie{Name: auth.CookieName, Value: token}
+}
+
+// Akzeptanzkriterium 1: Rollen und ihre Grundrechte sind einsehbar.
+func TestListRoles(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_list_roles")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	var out []roleInfo
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 2 {
+		t.Fatalf("erwartet 2 zuweisbare rollen (user, tenant_admin), habe %d", len(out))
+	}
+}
+
+// Akzeptanzkriterium 2 / Pruefung 2: Selbst-Eskalation wird abgewiesen.
+func TestAssignRole_RejectsSelfEscalation(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_self_escalation")
+	ctx := context.Background()
+	u, err := users.Create(ctx, "normal@acme.example", "Normaler Nutzer")
+	if err != nil {
+		t.Fatalf("nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
+		t.Fatalf("ausgangsrolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	body, _ := json.Marshal(assignRoleRequest{UserID: u.ID, Role: RoleTenantAdmin})
+	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
+	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 (selbst-eskalation muss abgewiesen werden)", rec.Code)
+	}
+
+	// Rolle muss unveraendert geblieben sein.
+	assignment, err := roles.Get(ctx, u.ID)
+	if err != nil {
+		t.Fatalf("rolle laden: %v", err)
+	}
+	if assignment.Role != RoleUser {
+		t.Fatalf("rolle wurde trotz abgewiesener anfrage geaendert: %q", assignment.Role)
+	}
+}
+
+// Gegenprobe: ein Tenant-Admin darf EINEM ANDEREN Benutzer eine hoehere
+// Rolle zuweisen — nur die Selbst-Zuweisung ist gesperrt.
+func TestAssignRole_AdminCanPromoteOtherUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_promote_other")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin2@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	other, err := users.Create(ctx, "other@acme.example", "Anderer Nutzer")
+	if err != nil {
+		t.Fatalf("anderen nutzer anlegen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	body, _ := json.Marshal(assignRoleRequest{UserID: other.ID, Role: RoleTenantAdmin})
+	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+}
+
+// Akzeptanzkriterium 3: Aenderungen an Rechten sind nachvollziehbar.
+func TestRoleHistory_TracksAssignments(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_history")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin3@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	target, err := users.Create(ctx, "target@acme.example", "Zielnutzer")
+	if err != nil {
+		t.Fatalf("zielnutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleUser, admin.ID); err != nil {
+		t.Fatalf("erste zuweisung: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleTenantAdmin, admin.ID); err != nil {
+		t.Fatalf("zweite zuweisung: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/users/"+target.ID+"/history", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.RoleHistory)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	var history []Assignment
+	if err := json.Unmarshal(rec.Body.Bytes(), &history); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
+	}
+}
+
+// Akzeptanzkriterium 2: Gruppen anlegen, Mitglieder zuordnen, Rolle zuweisen.
+func TestGroupWorkflow(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_group_workflow")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin4@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	member, err := users.Create(ctx, "member@acme.example", "Mitglied")
+	if err != nil {
+		t.Fatalf("mitglied anlegen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	createBody, _ := json.Marshal(createGroupRequest{Name: "Buchhaltung"})
+	createReq := httptest.NewRequest(http.MethodPost, "/rbac/groups", bytes.NewReader(createBody))
+	createReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	createRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.CreateGroup)(createRec, createReq)
+	if createRec.Code != http.StatusCreated {
+		t.Fatalf("create group: status = %d, body: %s", createRec.Code, createRec.Body.String())
+	}
+	var group Group
+	if err := json.Unmarshal(createRec.Body.Bytes(), &group); err != nil {
+		t.Fatalf("group-response dekodieren: %v", err)
+	}
+
+	roleBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, Role: RoleUser})
+	roleReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/role", bytes.NewReader(roleBody))
+	roleReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	roleRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetGroupRole)(roleRec, roleReq)
+	if roleRec.Code != http.StatusOK {
+		t.Fatalf("set group role: status = %d, body: %s", roleRec.Code, roleRec.Body.String())
+	}
+
+	memberBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, UserID: member.ID})
+	memberReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/members", bytes.NewReader(memberBody))
+	memberReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	memberRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AddGroupMember)(memberRec, memberReq)
+	if memberRec.Code != http.StatusOK {
+		t.Fatalf("add member: status = %d, body: %s", memberRec.Code, memberRec.Body.String())
+	}
+
+	listReq := httptest.NewRequest(http.MethodGet, "/rbac/groups", nil)
+	listReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListGroups)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list groups: status = %d, body: %s", listRec.Code, listRec.Body.String())
+	}
+	var groups []groupWithMembers
+	if err := json.Unmarshal(listRec.Body.Bytes(), &groups); err != nil {
+		t.Fatalf("groups-response dekodieren: %v", err)
+	}
+	if len(groups) != 1 || len(groups[0].Members) != 1 || groups[0].Members[0] != member.ID {
+		t.Fatalf("erwartet 1 gruppe mit 1 mitglied (%s), habe %+v", member.ID, groups)
+	}
+}
+
+// Ohne Rechteverwaltungsberechtigung (normale 'user'-Rolle) wird jeder
+// Endpunkt abgewiesen — Tenant-Isolation ist strukturell (Modell C, siehe
+// GroupStore-Kommentar), diese Pruefung deckt die Rechte-Ebene ab.
+func TestRequireManageUsers_RejectsPlainUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_reject_plain")
+	ctx := context.Background()
+	u, err := users.Create(ctx, "plain@acme.example", "Normaler Nutzer")
+	if err != nil {
+		t.Fatalf("nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
+		t.Fatalf("rolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 fuer benutzer ohne rechteverwaltung", rec.Code)
+	}
+}

internal/rbac/role_test.go

@@ -0,0 +1,48 @@
+package rbac
+
+import "testing"
+
+func contains(perms []Permission, p Permission) bool {
+	for _, x := range perms {
+		if x == p {
+			return true
+		}
+	}
+	return false
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Rollenhierarchie liefert die erwartete
+// effektive Rechtemenge.
+func TestEffectivePermissions_Inheritance(t *testing.T) {
+	userPerms := EffectivePermissions(RoleUser)
+	if !contains(userPerms, PermSelfRead) || !contains(userPerms, PermSelfUpdate) {
+		t.Fatalf("user sollte self.read/self.update haben, habe %v", userPerms)
+	}
+	if contains(userPerms, PermManageUsers) {
+		t.Fatal("user sollte KEIN tenant.manage_users haben")
+	}
+
+	adminPerms := EffectivePermissions(RoleTenantAdmin)
+	if !contains(adminPerms, PermSelfRead) || !contains(adminPerms, PermManageUsers) || !contains(adminPerms, PermManageSettings) {
+		t.Fatalf("tenant_admin sollte geerbte user-rechte + eigene rechte haben, habe %v", adminPerms)
+	}
+	if contains(adminPerms, PermManageTenants) {
+		t.Fatal("tenant_admin sollte KEIN platform.manage_tenants haben")
+	}
+
+	superPerms := EffectivePermissions(RoleSuperadmin)
+	for _, want := range []Permission{PermSelfRead, PermSelfUpdate, PermManageUsers, PermManageSettings, PermManageTenants} {
+		if !contains(superPerms, want) {
+			t.Fatalf("superadmin sollte %q haben (volle vererbte kette), habe %v", want, superPerms)
+		}
+	}
+}
+
+func TestHasPermission(t *testing.T) {
+	if !HasPermission(RoleTenantAdmin, PermSelfRead) {
+		t.Fatal("tenant_admin sollte geerbtes self.read haben")
+	}
+	if HasPermission(RoleUser, PermManageTenants) {
+		t.Fatal("user sollte platform.manage_tenants nicht haben")
+	}
+}

internal/rbac/store_test.go

@@ -0,0 +1,144 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+func setupStoreTest(t *testing.T) (*Store, string, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS users (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			email TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignments (
+			user_id UUID PRIMARY KEY REFERENCES users(id),
+			role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
+			granted_by TEXT NOT NULL,
+			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignment_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			user_id UUID NOT NULL,
+			role TEXT NOT NULL,
+			granted_by TEXT NOT NULL,
+			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	userStore := user.NewTenantUserStore(pool)
+	u, err := userStore.Create(ctx, "rbac_test@example.com", "RBAC Test")
+	if err != nil {
+		t.Fatalf("testuser anlegen: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM role_assignment_history WHERE user_id = $1`, u.ID)
+		_, _ = pool.Exec(ctx, `DELETE FROM role_assignments WHERE user_id = $1`, u.ID)
+		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE id = $1`, u.ID)
+		pool.Close()
+	}
+	return NewStore(pool), u.ID, cleanup
+}
+
+// Akzeptanzkriterium 1: Grundrollen sind einem Benutzer je Tenant zuweisbar.
+func TestStore_AssignAndGet(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	assigned, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example")
+	if err != nil {
+		t.Fatalf("assign: %v", err)
+	}
+	if assigned.Role != RoleTenantAdmin {
+		t.Fatalf("erwartet tenant_admin, habe %q", assigned.Role)
+	}
+
+	got, err := store.Get(ctx, userID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Role != RoleTenantAdmin || got.GrantedBy != "admin@acme.example" {
+		t.Fatalf("zuweisung unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Zuweisung ausserhalb der erlaubten
+// Matrix (superadmin im tenant-gescopten Store) wird abgewiesen.
+func TestStore_RejectsSuperadminOutsideAllowedMatrix(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := store.Assign(ctx, userID, RoleSuperadmin, "admin@acme.example")
+	if !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
+		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope, habe %v", err)
+	}
+
+	// Sicherstellen, dass der abgewiesene Versuch keine Zeile hinterlassen hat.
+	if _, err := store.Get(ctx, userID); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound nach abgewiesener zuweisung, habe %v", err)
+	}
+}
+
+func TestStore_RejectsUnknownRole(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Assign(ctx, userID, Role("erfunden"), "admin@acme.example"); !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
+		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope fuer unbekannte rolle, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3: Rollenzuweisung vollstaendig auditierbar.
+func TestStore_HistoryTracksWhoAndWhen(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Assign(ctx, userID, RoleUser, "system"); err != nil {
+		t.Fatalf("assign 1: %v", err)
+	}
+	if _, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example"); err != nil {
+		t.Fatalf("assign 2: %v", err)
+	}
+
+	history, err := store.History(ctx, userID)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
+	}
+	if history[0].Role != RoleUser || history[0].GrantedBy != "system" {
+		t.Fatalf("history[0] unerwartet: %+v", history[0])
+	}
+	if history[1].Role != RoleTenantAdmin || history[1].GrantedBy != "admin@acme.example" {
+		t.Fatalf("history[1] unerwartet: %+v", history[1])
+	}
+}

internal/secheaders/secheaders.go

@@ -0,0 +1,126 @@
+// Package secheaders implementiert Core API-08: eine gemeinsame
+// Security-Header-Middleware/Bibliothek, die jedes Modul-Frontend (DMS,
+// Mail, Workflow, AI, Connect) einbindet, statt Header pro Modul erneut zu
+// definieren (Akzeptanzkriterium 3) — dieselbe Konsolidierungslogik wie
+// beim zentralen Rate-Limiting (API-03). Die tatsaechliche EINBINDUNG in
+// jedes einzelne Modul-Frontend ist ausdruecklich NICHT Teil dieser Kachel
+// (siehe Ticket "Nicht Bestandteil").
+package secheaders
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Config ist die Baseline-Konfiguration. DefaultConfig() liefert einen
+// Ausgangspunkt OHNE 'unsafe-inline'/'unsafe-eval' (Akzeptanzkriterium 1)
+// und mit angemessener HSTS-Laufzeit (Akzeptanzkriterium 2).
+type Config struct {
+	// ContentSecurityPolicy wird unveraendert als Header-Wert gesendet.
+	ContentSecurityPolicy string
+	// HSTSMaxAge bestimmt die Gueltigkeitsdauer, die Browser sich merken.
+	HSTSMaxAge          time.Duration
+	HSTSIncludeSubdomains bool
+	FrameOptions        string
+	ReferrerPolicy      string
+	ContentTypeNoSniff  bool
+}
+
+// DefaultConfig liefert die dokumentierte Baseline: restriktive CSP ohne
+// unsichere Direktiven, HSTS mit 180 Tagen (empfohlener Mindestwert fuer
+// HSTS-Preloading-Listen liegt bei 1 Jahr — 180 Tage ist ein bewusst
+// konservativer, aber bereits "angemessener" Ausgangswert, siehe
+// Akzeptanzkriterium 2), Clickjacking- und MIME-Sniffing-Schutz.
+func DefaultConfig() Config {
+	return Config{
+		ContentSecurityPolicy: strings.Join([]string{
+			"default-src 'self'",
+			"script-src 'self'",
+			"style-src 'self'",
+			"img-src 'self' data:",
+			"object-src 'none'",
+			"base-uri 'self'",
+			"frame-ancestors 'none'",
+		}, "; "),
+		HSTSMaxAge:            180 * 24 * time.Hour,
+		HSTSIncludeSubdomains: true,
+		FrameOptions:          "DENY",
+		ReferrerPolicy:        "strict-origin-when-cross-origin",
+		ContentTypeNoSniff:    true,
+	}
+}
+
+// RequiredHeaders sind die von dieser Baseline gesetzten Header-Namen — die
+// Referenzliste fuer CheckCoverage (Akzeptanzkriterium/Pruefung 1).
+var RequiredHeaders = []string{
+	"Content-Security-Policy",
+	"Strict-Transport-Security",
+	"X-Frame-Options",
+	"Referrer-Policy",
+	"X-Content-Type-Options",
+}
+
+func (c Config) hstsValue() string {
+	v := fmt.Sprintf("max-age=%d", int(c.HSTSMaxAge.Seconds()))
+	if c.HSTSIncludeSubdomains {
+		v += "; includeSubDomains"
+	}
+	return v
+}
+
+// Middleware setzt die Baseline-Header auf JEDER Antwort und erzwingt einen
+// HTTP->HTTPS-Redirect, WENN die Anfrage nicht bereits ueber TLS ankam
+// (Akzeptanzkriterium 2 / Pruefung 3) — serverseitig durchgesetzt, nicht nur
+// dem Browser-HSTS-Cache ueberlassen (der erst nach dem ERSTEN sicheren
+// Aufruf greift).
+func Middleware(cfg Config, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if !isSecure(r) {
+			target := "https://" + r.Host + r.URL.RequestURI()
+			http.Redirect(w, r, target, http.StatusMovedPermanently)
+			return
+		}
+
+		SetHeaders(cfg, w)
+		next(w, r)
+	}
+}
+
+// SetHeaders setzt die Baseline-Header direkt, OHNE die HTTPS-Redirect-
+// Pruefung von Middleware — nuetzlich fuer lokale Entwicklungs-/
+// Demo-Umgebungen ohne TLS-Terminierung (siehe cmd/secheaders-devserver)
+// und fuer Aufrufer, die den Redirect selbst schon anderweitig sicherstellen.
+func SetHeaders(cfg Config, w http.ResponseWriter) {
+	w.Header().Set("Content-Security-Policy", cfg.ContentSecurityPolicy)
+	w.Header().Set("Strict-Transport-Security", cfg.hstsValue())
+	w.Header().Set("X-Frame-Options", cfg.FrameOptions)
+	w.Header().Set("Referrer-Policy", cfg.ReferrerPolicy)
+	if cfg.ContentTypeNoSniff {
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+	}
+}
+
+// isSecure erkennt TLS direkt ODER ueber den ueblichen Reverse-Proxy-Header
+// (X-Forwarded-Proto) — der Core-Dienst laeuft in der Praxis hinter einem
+// TLS-terminierenden Proxy, sieht r.TLS also nie direkt gesetzt.
+func isSecure(r *http.Request) bool {
+	if r.TLS != nil {
+		return true
+	}
+	return strings.EqualFold(r.Header.Get("X-Forwarded-Proto"), "https")
+}
+
+// CheckCoverage vergleicht die tatsaechlich gesetzten Header einer Antwort
+// gegen RequiredHeaders und liefert die fehlenden — der "automatisierte
+// Header-Scan" aus Pruefung 1, anwendbar auf jede Antwort eines beliebigen
+// Modul-Frontends.
+func CheckCoverage(headers http.Header) (missing []string) {
+	for _, name := range RequiredHeaders {
+		if headers.Get(name) == "" {
+			missing = append(missing, name)
+		}
+	}
+	return missing
+}

internal/secheaders/secheaders_test.go

@@ -0,0 +1,113 @@
+package secheaders
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func secureRequest(method, target string) *http.Request {
+	req := httptest.NewRequest(method, target, nil)
+	req.Header.Set("X-Forwarded-Proto", "https")
+	return req
+}
+
+// Akzeptanzkriterium 1: CSP definiert ohne unsafe-inline/unsafe-eval.
+func TestDefaultConfig_CSPHasNoUnsafeDirectives(t *testing.T) {
+	cfg := DefaultConfig()
+	if strings.Contains(cfg.ContentSecurityPolicy, "unsafe-inline") {
+		t.Fatal("csp enthaelt 'unsafe-inline', erwartet keine unsicheren direktiven")
+	}
+	if strings.Contains(cfg.ContentSecurityPolicy, "unsafe-eval") {
+		t.Fatal("csp enthaelt 'unsafe-eval', erwartet keine unsicheren direktiven")
+	}
+	if !strings.Contains(cfg.ContentSecurityPolicy, "default-src 'self'") {
+		t.Fatal("erwartet restriktive default-src 'self' als ausgangspunkt")
+	}
+}
+
+// Akzeptanzkriterium 2: HSTS mit angemessener max-age gesetzt.
+func TestMiddleware_SetsHSTSWithSufficientMaxAge(t *testing.T) {
+	cfg := DefaultConfig()
+	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	rec := httptest.NewRecorder()
+	handler(rec, secureRequest(http.MethodGet, "https://example.test/"))
+
+	hsts := rec.Header().Get("Strict-Transport-Security")
+	if !strings.Contains(hsts, "max-age=") {
+		t.Fatalf("hsts-header fehlt max-age: %q", hsts)
+	}
+	// "Angemessen" heisst hier: mindestens 30 Tage (2592000s) — deutlich
+	// ueber dem bekannten Anti-Pattern kurzer/fehlender max-age-Werte.
+	if cfg.HSTSMaxAge.Seconds() < 2592000 {
+		t.Fatalf("konfigurierte hsts-max-age = %v, erwartet mindestens 30 tage", cfg.HSTSMaxAge)
+	}
+	if !strings.Contains(hsts, "includeSubDomains") {
+		t.Fatalf("erwartet includeSubDomains im hsts-header: %q", hsts)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: EINE gemeinsame Middleware setzt ALLE
+// Baseline-Header vollstaendig — automatisiert ueberprueft mit CheckCoverage.
+func TestMiddleware_ProducesFullHeaderCoverage(t *testing.T) {
+	cfg := DefaultConfig()
+	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	rec := httptest.NewRecorder()
+	handler(rec, secureRequest(http.MethodGet, "https://example.test/"))
+
+	if missing := CheckCoverage(rec.Header()); len(missing) != 0 {
+		t.Fatalf("erwartet vollstaendige header-abdeckung, fehlen: %v", missing)
+	}
+}
+
+// Pruefung 1 (Kehrseite): CheckCoverage erkennt fehlende Header
+// zuverlaessig — Voraussetzung dafuer, dass ein automatisierter Scan
+// gegen ein Modul-Frontend OHNE eingebundene Middleware ueberhaupt etwas
+// meldet.
+func TestCheckCoverage_DetectsMissingHeadersOnBareHandler(t *testing.T) {
+	bareHandler := func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }
+
+	rec := httptest.NewRecorder()
+	bareHandler(rec, httptest.NewRequest(http.MethodGet, "/", nil))
+
+	missing := CheckCoverage(rec.Header())
+	if len(missing) != len(RequiredHeaders) {
+		t.Fatalf("erwartet %d fehlende header bei unbehandeltem handler, habe %d: %v",
+			len(RequiredHeaders), len(missing), missing)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: ein Aufruf ueber (simuliertes) HTTP
+// wird server-seitig auf HTTPS umgeleitet, statt sich allein auf den
+// HSTS-Browser-Cache zu verlassen (der erst nach dem ersten sicheren
+// Aufruf greift).
+func TestMiddleware_RedirectsInsecureRequestToHTTPS(t *testing.T) {
+	cfg := DefaultConfig()
+	called := false
+	handler := Middleware(cfg, func(w http.ResponseWriter, r *http.Request) {
+		called = true
+		w.WriteHeader(http.StatusOK)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "http://example.test/pfad?x=1", nil)
+	// Kein X-Forwarded-Proto, kein r.TLS -> unsicherer Aufruf.
+	rec := httptest.NewRecorder()
+	handler(rec, req)
+
+	if rec.Code != http.StatusMovedPermanently {
+		t.Fatalf("status = %d, want 301 (redirect auf https)", rec.Code)
+	}
+	location := rec.Header().Get("Location")
+	if !strings.HasPrefix(location, "https://") {
+		t.Fatalf("location = %q, want https://-praefix", location)
+	}
+	if !strings.Contains(location, "/pfad?x=1") {
+		t.Fatalf("location = %q, erwartet erhaltenen pfad+query", location)
+	}
+	if called {
+		t.Fatal("eigentlicher handler haette bei unsicherem aufruf nicht erreicht werden duerfen")
+	}
+}

internal/statuspage/statuspage.go

@@ -0,0 +1,273 @@
+// Package statuspage implementiert Core OPS-02: eine zentrale Statusseite,
+// die den Health-Zustand aller registrierten Module aggregiert und den
+// Verlauf vergangener Statusaenderungen speichert. Baut auf OPS-01
+// (internal/health) auf, indem es GENAU die dort etablierten
+// Readiness-Endpunkte je Modul abfragt — dieses Paket dupliziert keine
+// Health-Check-Logik, es aggregiert nur deren Ergebnisse ueber die Zeit.
+package statuspage
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Status ist der aggregierte Zustand EINES Moduls zu einem Zeitpunkt.
+type Status string
+
+const (
+	StatusUp   Status = "up"
+	StatusDown Status = "down"
+)
+
+// Target ist ein zu ueberwachendes Modul mit seiner Readiness-URL
+// (OPS-01-Endpunkt, z.B. "http://dms:8080/readyz"). Eigenstaendige
+// Konfiguration statt Erweiterung von internal/moduleregistry.Module, um
+// API-02 nicht anzufassen (Kein Umbau angrenzender Bereiche).
+type Target struct {
+	Name      string
+	HealthURL string
+}
+
+// Store persistiert Ueberwachungsziele und den Verlauf ihrer
+// Statusaenderungen.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// RegisterTarget traegt ein zu ueberwachendes Modul ein oder aktualisiert
+// dessen URL (Akzeptanzkriterium 1: "aller registrierten Module").
+func (s *Store) RegisterTarget(ctx context.Context, t Target) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO status_targets (name, health_url)
+		VALUES ($1, $2)
+		ON CONFLICT (name) DO UPDATE SET health_url = $2
+	`, t.Name, t.HealthURL)
+	if err != nil {
+		return fmt.Errorf("ueberwachungsziel speichern: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) ListTargets(ctx context.Context) ([]Target, error) {
+	rows, err := s.pool.Query(ctx, `SELECT name, health_url FROM status_targets ORDER BY name`)
+	if err != nil {
+		return nil, fmt.Errorf("ueberwachungsziele auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Target
+	for rows.Next() {
+		var t Target
+		if err := rows.Scan(&t.Name, &t.HealthURL); err != nil {
+			return nil, fmt.Errorf("ueberwachungsziel lesen: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}
+
+// recordIfChanged schreibt NUR dann einen neuen Verlaufseintrag, wenn sich
+// der Status seit dem letzten Eintrag geaendert hat (oder es der erste
+// Eintrag ist) — der Verlauf zeigt Statusaenderungen (Akzeptanzkriterium 3),
+// nicht jede einzelne Abfrage.
+func (s *Store) recordIfChanged(ctx context.Context, name string, status Status) error {
+	var lastStatus string
+	err := s.pool.QueryRow(ctx, `
+		SELECT status FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
+	`, name).Scan(&lastStatus)
+	if err != nil && err != pgx.ErrNoRows {
+		return fmt.Errorf("letzten status lesen: %w", err)
+	}
+	if err == nil && lastStatus == string(status) {
+		return nil // keine Aenderung, kein neuer Eintrag
+	}
+
+	if _, err := s.pool.Exec(ctx, `
+		INSERT INTO status_history (name, status, changed_at) VALUES ($1, $2, now())
+	`, name, string(status)); err != nil {
+		return fmt.Errorf("statuseintrag schreiben: %w", err)
+	}
+	return nil
+}
+
+// ModuleStatus ist der aktuelle Zustand EINES Moduls fuer die Uebersicht.
+type ModuleStatus struct {
+	Name        string    `json:"name"`
+	Status      Status    `json:"status"`
+	LastChecked time.Time `json:"last_checked"`
+}
+
+// Overview liefert den aktuellen (letzten bekannten) Status jedes
+// registrierten Ziels (Akzeptanzkriterium 1). Ziele ohne jemals erfolgte
+// Pruefung erscheinen mit Status "down" — ein Modul, ueber das nichts
+// bekannt ist, gilt als nicht verfuegbar (Fail-Safe-Default), nicht als
+// stillschweigend "ok".
+func (s *Store) Overview(ctx context.Context) ([]ModuleStatus, error) {
+	targets, err := s.ListTargets(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	out := make([]ModuleStatus, 0, len(targets))
+	for _, t := range targets {
+		var status string
+		var changedAt time.Time
+		err := s.pool.QueryRow(ctx, `
+			SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
+		`, t.Name).Scan(&status, &changedAt)
+		if err == pgx.ErrNoRows {
+			out = append(out, ModuleStatus{Name: t.Name, Status: StatusDown})
+			continue
+		}
+		if err != nil {
+			return nil, fmt.Errorf("aktuellen status lesen (%s): %w", t.Name, err)
+		}
+		out = append(out, ModuleStatus{Name: t.Name, Status: Status(status), LastChecked: changedAt})
+	}
+	return out, nil
+}
+
+// HistoryEntry ist EIN Verlaufseintrag (Akzeptanzkriterium 3).
+type HistoryEntry struct {
+	Status    Status    `json:"status"`
+	ChangedAt time.Time `json:"changed_at"`
+}
+
+func (s *Store) History(ctx context.Context, name string) ([]HistoryEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC
+	`, name)
+	if err != nil {
+		return nil, fmt.Errorf("verlauf abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []HistoryEntry
+	for rows.Next() {
+		var e HistoryEntry
+		var status string
+		if err := rows.Scan(&status, &e.ChangedAt); err != nil {
+			return nil, fmt.Errorf("verlaufseintrag lesen: %w", err)
+		}
+		e.Status = Status(status)
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// HTTPChecker fragt die Readiness-URL eines Moduls ab (OPS-01-Endpunkt) und
+// liefert StatusUp NUR bei HTTP 200 — jeder andere Statuscode ODER ein
+// Netzwerkfehler/Timeout gilt als StatusDown. Ein einzelnes nicht
+// erreichbares Modul liefert einen FEHLERFREIEN StatusDown-Wert statt eines
+// Go-Errors, damit Poller.Run ein fehlerhaftes Modul niemals mit einem
+// anderen verwechseln oder den gesamten Zyklus abbrechen kann
+// (Akzeptanzkriterium 2).
+type HTTPChecker struct {
+	Client  *http.Client
+	Timeout time.Duration
+}
+
+func NewHTTPChecker(timeout time.Duration) *HTTPChecker {
+	return &HTTPChecker{Client: &http.Client{}, Timeout: timeout}
+}
+
+func (c *HTTPChecker) Check(ctx context.Context, url string) Status {
+	ctx, cancel := context.WithTimeout(ctx, c.Timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return StatusDown
+	}
+	resp, err := c.Client.Do(req)
+	if err != nil {
+		return StatusDown
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		return StatusUp
+	}
+	return StatusDown
+}
+
+// Poller fragt periodisch alle Ziele ab und schreibt Statusaenderungen fort.
+type Poller struct {
+	store   *Store
+	checker *HTTPChecker
+}
+
+func NewPoller(store *Store, checker *HTTPChecker) *Poller {
+	return &Poller{store: store, checker: checker}
+}
+
+// PollOnce prueft ALLE Ziele in einem Durchlauf. Ein fehlschlagendes Ziel
+// (Netzwerkfehler, Timeout, Nicht-200) wird als StatusDown vermerkt und
+// haelt die Pruefung der UEBRIGEN Ziele nicht auf — die Schleife laeuft
+// sequenziell weiter, kein Ziel kann ein anderes blockieren
+// (Akzeptanzkriterium 2 / Pruefung 2).
+func (p *Poller) PollOnce(ctx context.Context) error {
+	targets, err := p.store.ListTargets(ctx)
+	if err != nil {
+		return err
+	}
+	for _, t := range targets {
+		status := p.checker.Check(ctx, t.HealthURL)
+		if err := p.store.recordIfChanged(ctx, t.Name, status); err != nil {
+			// Ein Schreibfehler fuer EIN Ziel darf die Pruefung der anderen
+			// nicht verhindern — dieselbe Fail-Isolation wie bei einem
+			// unerreichbaren Modul.
+			continue
+		}
+	}
+	return nil
+}
+
+// Run ruft PollOnce in festen Abstaenden auf, bis ctx beendet wird —
+// dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
+func (p *Poller) Run(ctx context.Context, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			_ = p.PollOnce(ctx)
+		}
+	}
+}
+
+// --- HTTP-Bindung fuer die Oberflaeche ---
+
+func (s *Store) OverviewHandler(w http.ResponseWriter, r *http.Request) {
+	overview, err := s.Overview(r.Context())
+	writeJSONResult(w, overview, err)
+}
+
+func (s *Store) HistoryHandler(w http.ResponseWriter, r *http.Request) {
+	name := r.URL.Query().Get("name")
+	history, err := s.History(r.Context(), name)
+	writeJSONResult(w, history, err)
+}
+
+func writeJSONResult(w http.ResponseWriter, body any, err error) {
+	w.Header().Set("Content-Type", "application/json")
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		_ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+	_ = json.NewEncoder(w).Encode(body)
+}

internal/statuspage/statuspage_test.go

@@ -0,0 +1,198 @@
+package statuspage
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS status_targets (name TEXT PRIMARY KEY, health_url TEXT NOT NULL);
+		CREATE TABLE IF NOT EXISTS status_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, status TEXT NOT NULL,
+			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), cleanup
+}
+
+func uniqueName(prefix string) string {
+	return fmt.Sprintf("%s-%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1: Uebersicht zeigt den Status ALLER registrierten
+// Module.
+func TestOverview_ShowsAllRegisteredModules(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
+	defer up.Close()
+
+	nameA, nameB := uniqueName("mod-a"), uniqueName("mod-b")
+	if err := store.RegisterTarget(ctx, Target{Name: nameA, HealthURL: up.URL}); err != nil {
+		t.Fatalf("target a: %v", err)
+	}
+	if err := store.RegisterTarget(ctx, Target{Name: nameB, HealthURL: up.URL}); err != nil {
+		t.Fatalf("target b: %v", err)
+	}
+
+	poller := NewPoller(store, NewHTTPChecker(time.Second))
+	if err := poller.PollOnce(ctx); err != nil {
+		t.Fatalf("poll: %v", err)
+	}
+
+	overview, err := store.Overview(ctx)
+	if err != nil {
+		t.Fatalf("overview: %v", err)
+	}
+	// Overview() listet ALLE jemals registrierten Ziele (auch aus fruehreren
+	// Testlaeufen auf derselben geteilten Test-DB) — hier wird deshalb nur
+	// der Status von nameA/nameB geprueft, nicht jeder Eintrag der Tabelle.
+	statusByName := map[string]Status{}
+	for _, m := range overview {
+		statusByName[m.Name] = m.Status
+	}
+	if statusByName[nameA] != StatusUp {
+		t.Fatalf("modul %s: status = %s, want up", nameA, statusByName[nameA])
+	}
+	if statusByName[nameB] != StatusUp {
+		t.Fatalf("modul %s: status = %s, want up", nameB, statusByName[nameB])
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1/2: ein simulierter Ausfall eines Moduls
+// wird sichtbar, das ANDERE Modul bleibt unbeeinflusst und die Pruefung
+// beider laeuft trotzdem in einem Durchlauf durch (kein Totalausfall).
+func TestPollOnce_IsolatesFailingModuleFromOthers(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
+	defer up.Close()
+	down := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusInternalServerError) }))
+	down.Close() // Server sofort schliessen -> Verbindung tatsaechlich unerreichbar (simulierter Ausfall)
+
+	healthyName, downName := uniqueName("healthy"), uniqueName("down")
+	if err := store.RegisterTarget(ctx, Target{Name: healthyName, HealthURL: up.URL}); err != nil {
+		t.Fatalf("target healthy: %v", err)
+	}
+	if err := store.RegisterTarget(ctx, Target{Name: downName, HealthURL: down.URL}); err != nil {
+		t.Fatalf("target down: %v", err)
+	}
+
+	poller := NewPoller(store, NewHTTPChecker(500*time.Millisecond))
+	if err := poller.PollOnce(ctx); err != nil {
+		t.Fatalf("poll haette trotz einem ausgefallenen modul erfolgreich durchlaufen sollen: %v", err)
+	}
+
+	overview, err := store.Overview(ctx)
+	if err != nil {
+		t.Fatalf("overview: %v", err)
+	}
+	statusByName := map[string]Status{}
+	for _, m := range overview {
+		statusByName[m.Name] = m.Status
+	}
+	if statusByName[healthyName] != StatusUp {
+		t.Fatalf("healthy modul: status = %s, want up", statusByName[healthyName])
+	}
+	if statusByName[downName] != StatusDown {
+		t.Fatalf("ausgefallenes modul: status = %s, want down", statusByName[downName])
+	}
+}
+
+// Akzeptanzkriterium 3: Verlauf vergangener Statusaenderungen ist einsehbar.
+func TestHistory_RecordsStatusTransitions(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueName("flaky")
+
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
+	defer up.Close()
+	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
+		t.Fatalf("target: %v", err)
+	}
+
+	poller := NewPoller(store, NewHTTPChecker(time.Second))
+	if err := poller.PollOnce(ctx); err != nil {
+		t.Fatalf("poll 1: %v", err)
+	}
+
+	// Ziel wird "abgeschaltet" (URL zeigt jetzt auf einen bereits
+	// geschlossenen Server) -> naechster Poll erkennt den Statuswechsel.
+	closedURL := up.URL
+	up.Close()
+	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: closedURL}); err != nil {
+		t.Fatalf("target aktualisieren: %v", err)
+	}
+	if err := poller.PollOnce(ctx); err != nil {
+		t.Fatalf("poll 2: %v", err)
+	}
+
+	history, err := store.History(ctx, name)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet genau 2 statuswechsel (up -> down), habe %d: %+v", len(history), history)
+	}
+	if history[0].Status != StatusDown || history[1].Status != StatusUp {
+		t.Fatalf("erwartet verlauf [down, up] (neueste zuerst), habe: %+v", history)
+	}
+}
+
+// Wiederholte Polls OHNE Statuswechsel duerfen den Verlauf nicht mit
+// identischen Eintraegen fluten (siehe recordIfChanged).
+func TestHistory_DoesNotDuplicateUnchangedStatus(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	name := uniqueName("stable")
+
+	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
+	defer up.Close()
+	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
+		t.Fatalf("target: %v", err)
+	}
+
+	poller := NewPoller(store, NewHTTPChecker(time.Second))
+	for i := 0; i < 3; i++ {
+		if err := poller.PollOnce(ctx); err != nil {
+			t.Fatalf("poll %d: %v", i, err)
+		}
+	}
+
+	history, err := store.History(ctx, name)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 1 {
+		t.Fatalf("erwartet genau 1 eintrag trotz 3 unveraenderter polls, habe %d", len(history))
+	}
+}

internal/usage/aggregation.go

@@ -0,0 +1,32 @@
+package usage
+
+import (
+	"context"
+	"log/slog"
+	"time"
+)
+
+// AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
+// Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
+// haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
+// Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
+type AggregateFunc func(ctx context.Context) error
+
+// RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
+// beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
+// internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
+// aggregiert").
+func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			if err := aggregate(ctx); err != nil {
+				slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
+			}
+		}
+	}
+}

internal/usage/usage.go

@@ -0,0 +1,144 @@
+// Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
+// (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
+// gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
+// Hardcode — Zitadel/Unleash-Vorbild.
+package usage
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
+
+// Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
+type Status string
+
+const (
+	StatusOK       Status = "ok"
+	StatusWarning  Status = "warning"  // Schwelle (80%) erreicht, aber noch nicht ueberschritten
+	StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
+)
+
+// warningThreshold liegt bei 80% der Quota.
+const warningThreshold = 0.8
+
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
+// (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
+// haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
+// (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
+// Lock zu brauchen.
+func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (tenant_id, metric) DO UPDATE
+			SET value = usage_counters.value + $3, updated_at = now()
+	`, tenantID, metric, delta)
+	if err != nil {
+		return fmt.Errorf("zaehler erhoehen: %w", err)
+	}
+	return nil
+}
+
+// Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
+// Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
+func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
+	var value int64
+	err := s.pool.QueryRow(ctx, `
+		SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
+	`, tenantID, metric).Scan(&value)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("zaehler lesen: %w", err)
+	}
+	return value, nil
+}
+
+// SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
+// kein Hardcode.
+func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO usage_quotas (tenant_id, metric, limit_value)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
+	`, tenantID, metric, limit)
+	if err != nil {
+		return fmt.Errorf("quota setzen: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
+	var limit int64
+	err := s.pool.QueryRow(ctx, `
+		SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
+	`, tenantID, metric).Scan(&limit)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return 0, ErrNoQuota
+		}
+		return 0, fmt.Errorf("quota lesen: %w", err)
+	}
+	return limit, nil
+}
+
+// Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
+// Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
+// gilt die Metrik als unbegrenzt (StatusOK).
+func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
+	value, err = s.Get(ctx, tenantID, metric)
+	if err != nil {
+		return 0, 0, "", err
+	}
+
+	limit, err = s.GetQuota(ctx, tenantID, metric)
+	if errors.Is(err, ErrNoQuota) {
+		return value, 0, StatusOK, nil
+	}
+	if err != nil {
+		return 0, 0, "", err
+	}
+
+	switch {
+	case value > limit:
+		return value, limit, StatusExceeded, nil
+	case limit > 0 && float64(value) >= warningThreshold*float64(limit):
+		return value, limit, StatusWarning, nil
+	default:
+		return value, limit, StatusOK, nil
+	}
+}
+
+// Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
+// (Akzeptanzkriterium 2: "definierte Reaktion").
+type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
+
+// Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
+// die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
+// Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
+// garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
+func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
+	value, limit, status, err := s.Check(ctx, tenantID, metric)
+	if err != nil {
+		return "", err
+	}
+	if status != StatusOK && react != nil {
+		react(ctx, tenantID, metric, value, limit, status)
+	}
+	return status, nil
+}

internal/usage/usage_test.go

@@ -0,0 +1,206 @@
+package usage
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS usage_counters (
+			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
+		);
+		CREATE TABLE IF NOT EXISTS usage_quotas (
+			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
+			PRIMARY KEY (tenant_id, metric)
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), cleanup
+}
+
+func newTenantID() string {
+	return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
+// Schreibzugriffen konsistente Zaehlerstaende.
+func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	tenant := newTenantID()
+
+	const goroutines = 50
+	var wg sync.WaitGroup
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
+				t.Errorf("increment: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	value, err := store.Get(ctx, tenant, "api_calls")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if value != goroutines {
+		t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
+// nicht den eines anderen.
+func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	tenantA, tenantB := newTenantID(), newTenantID()
+
+	if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
+		t.Fatalf("increment a: %v", err)
+	}
+	if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
+		t.Fatalf("increment b: %v", err)
+	}
+
+	valA, err := store.Get(ctx, tenantA, "users")
+	if err != nil {
+		t.Fatalf("get a: %v", err)
+	}
+	valB, err := store.Get(ctx, tenantB, "users")
+	if err != nil {
+		t.Fatalf("get b: %v", err)
+	}
+	if valA != 5 || valB != 1 {
+		t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
+// erkannt und die definierte Reaktion ausgeloest.
+func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	tenant := newTenantID()
+
+	if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
+		t.Fatalf("set quota: %v", err)
+	}
+	if err := store.Increment(ctx, tenant, "users", 11); err != nil {
+		t.Fatalf("increment: %v", err)
+	}
+
+	var reacted bool
+	var gotStatus Status
+	status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
+		reacted = true
+		gotStatus = status
+	})
+	if err != nil {
+		t.Fatalf("enforce: %v", err)
+	}
+	if status != StatusExceeded {
+		t.Fatalf("erwartet StatusExceeded, habe %q", status)
+	}
+	if !reacted || gotStatus != StatusExceeded {
+		t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
+	}
+}
+
+func TestCheck_WarningThresholdAndOK(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	tenant := newTenantID()
+
+	if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
+		t.Fatalf("set quota: %v", err)
+	}
+
+	if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
+		t.Fatalf("increment: %v", err)
+	}
+	_, _, status, err := store.Check(ctx, tenant, "storage_mb")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if status != StatusOK {
+		t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
+	}
+
+	if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
+		t.Fatalf("increment: %v", err)
+	}
+	_, _, status, err = store.Check(ctx, tenant, "storage_mb")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if status != StatusWarning {
+		t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
+	}
+}
+
+func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
+	store, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	tenant := newTenantID()
+
+	if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
+		t.Fatalf("increment: %v", err)
+	}
+	_, _, status, err := store.Check(ctx, tenant, "api_calls")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if status != StatusOK {
+		t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
+	}
+}
+
+func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
+	defer cancel()
+
+	var mu sync.Mutex
+	calls := 0
+	RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
+		mu.Lock()
+		calls++
+		mu.Unlock()
+		return nil
+	})
+
+	mu.Lock()
+	defer mu.Unlock()
+	if calls < 3 {
+		t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
+	}
+}

migrations/0003_policy_rules.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS policy_rule_changes;
+DROP TABLE IF EXISTS policy_rules;

migrations/0003_policy_rules.up.sql

@@ -0,0 +1,24 @@
+-- Zentrale, deklarative Policy-Regeln (RBAC-02, siehe core-kanban/tickets/RBAC-02.md).
+-- policy_rules haelt den AKTUELLEN, gewaehrten Regelsatz (Existenz = erlaubt,
+-- Default-Deny fuer alles ohne Zeile). policy_rule_changes ist die
+-- versionierte Aenderungshistorie (Akzeptanzkriterium 3: Regelwechsel ohne
+-- Codeaenderung nachvollziehbar).
+CREATE TABLE policy_rules (
+    role       TEXT NOT NULL,
+    permission TEXT NOT NULL,
+    granted_by TEXT NOT NULL,
+    granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (role, permission)
+);
+
+CREATE TABLE policy_rule_changes (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    role       TEXT NOT NULL,
+    permission TEXT NOT NULL,
+    action     TEXT NOT NULL CHECK (action IN ('grant', 'revoke')),
+    actor      TEXT NOT NULL,
+    version    INT NOT NULL,
+    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX policy_rule_changes_idx ON policy_rule_changes (role, permission, version);

migrations/0003_rate_limits.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE rate_limit_counters;
+DROP TABLE rate_limit_configs;

migrations/0003_rate_limits.up.sql

@@ -0,0 +1,15 @@
+-- Rate-Limiting mit geteiltem, externem Zustand (API-03, siehe
+-- core-kanban/tickets/API-03.md) — bewusst NICHT In-Process, damit mehrere
+-- Dienstinstanzen dasselbe Limit korrekt durchsetzen.
+CREATE TABLE rate_limit_configs (
+    key            TEXT PRIMARY KEY,
+    limit_value    INT NOT NULL,
+    window_seconds INT NOT NULL
+);
+
+CREATE TABLE rate_limit_counters (
+    key          TEXT NOT NULL,
+    window_start TIMESTAMPTZ NOT NULL,
+    count        INT NOT NULL DEFAULT 0,
+    PRIMARY KEY (key, window_start)
+);

migrations/0004_audit_events.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS audit_events;

migrations/0004_audit_events.up.sql

@@ -0,0 +1,17 @@
+-- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
+-- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
+-- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
+-- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
+-- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
+-- Wert 'system', niemals NULL oder leeren String.
+CREATE TABLE audit_events (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
+    actor        TEXT NOT NULL CHECK (actor <> ''),
+    action       TEXT NOT NULL CHECK (action <> ''),
+    target       TEXT NOT NULL,
+    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
+);
+
+CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);

migrations/0004_config_values.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS config_value_history;
+DROP TABLE IF EXISTS config_values;

migrations/0004_config_values.up.sql

@@ -0,0 +1,23 @@
+-- Zentraler Konfigurationsdienst (CFG-01, siehe core-kanban/tickets/CFG-01.md).
+-- scope = 'global' fuer globale Defaults, sonst der Tenant-Slug. config_values
+-- haelt den AKTUELLEN Stand je (key, scope); config_value_history haelt JEDE
+-- Aenderung fest (Akzeptanzkriterium 2: versioniert nachvollziehbar).
+CREATE TABLE config_values (
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL CHECK (scope <> ''),
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (key, scope)
+);
+
+CREATE TABLE config_value_history (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL,
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX config_value_history_key_scope_idx ON config_value_history (key, scope, version);

migrations/0004_feature_flags.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS feature_flags;

migrations/0004_feature_flags.up.sql

@@ -0,0 +1,10 @@
+-- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
+-- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
+-- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
+CREATE TABLE feature_flags (
+    key                 TEXT PRIMARY KEY,
+    enabled             BOOLEAN NOT NULL DEFAULT false,
+    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
+    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0004_tenant_licenses.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenant_licenses;

migrations/0004_tenant_licenses.up.sql

@@ -0,0 +1,12 @@
+-- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
+-- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
+-- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
+CREATE TABLE tenant_licenses (
+    tenant_id     UUID PRIMARY KEY REFERENCES tenants(id),
+    plan          TEXT NOT NULL,
+    modules       TEXT[] NOT NULL,
+    issued_at     TIMESTAMPTZ NOT NULL,
+    valid_until   TIMESTAMPTZ NOT NULL,
+    raw_key       TEXT NOT NULL,
+    installed_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0005_module_registry.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS module_credentials;
+DROP TABLE IF EXISTS modules;

migrations/0005_module_registry.up.sql

@@ -0,0 +1,18 @@
+-- Modul-Registry & Aktivierungspruefung (API-02, siehe core-kanban/tickets/API-02.md).
+CREATE TABLE modules (
+    name           TEXT PRIMARY KEY,
+    version        TEXT NOT NULL CHECK (version <> ''),
+    required_flags TEXT[] NOT NULL DEFAULT '{}',
+    registered_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Service-Credential je Modul-Instanz, bei Provisionierung ausgestellt
+-- (Akzeptanzkriterium 4). secret_hash enthaelt NIEMALS das Secret im
+-- Klartext, nur dessen SHA-256-Hash (Timing-safe-Vergleich beim Login,
+-- Referenzmuster siehe AUD-02).
+CREATE TABLE module_credentials (
+    module_name TEXT PRIMARY KEY REFERENCES modules(name),
+    client_id   TEXT NOT NULL UNIQUE,
+    secret_hash BYTEA NOT NULL,
+    issued_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0005_notification_jobs.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS notification_jobs;