CFG-05: modulübergreifender-http-endpunkt-für-benachrichtigungs-ereignisse

- internal/notifyapi.Mount (POST /notify/enqueue), reiner Wrapper um
  notifyprefs.EnqueueIfAllowed (CFG-04)
- Reuse von internal/policyapi.RequireServiceToken (RBAC-06), kein
  neues Provisorium, eigener Service-Token pro Endpunkt
- Tests: 401 ohne Token, Aequivalenz HTTP vs. direkter Aufruf
  (aktiviert/deaktiviert), realer Fremd-Modul-Client mit echter
  notification_jobs-Zeile
- real deployed auf 131 (notify-api, Port 8094), Grant-Nachverfolgung
  fuer nexarch_core auf notification_preferences/notification_jobs,
  end-zu-ende per curl nachgewiesen (401, job_id+skipped:false)

Pruefungen siehe docs/CFG-05-PRUEFPROTOKOLL.md

DEVLOG.md

@@ -159,29 +159,31 @@ Keine Commits in dieser Session.
 - web/shl/vitest.setup.ts  | 1 +
 
 ---
-## 2026-08-28 23:37 – 23:43 (5m)
+## 2026-08-28 23:45 – 23:51 (5m)
 **Beschreibung:** Claude Code Session
-**Projekt:** nexarch
+**Projekt:** code
 
 ### 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
+- 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
-- 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 +++++++++++++++++++++
+- 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:44 – 23:44 (0m)
+## 2026-08-28 23:51 – 23:51 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 
@@ -189,13 +191,37 @@ Keine Commits in dieser Session.
 Keine Commits in dieser Session.
 
 ### 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 +++++++++++++++++++++
+- 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/notify-api/main.go

@@ -0,0 +1,52 @@
+// notify-api ist der Aufrufpunkt fuer CFG-05: stellt Core CFG-04s
+// EnqueueIfAllowed als HTTP-Endpunkt fuer andere, physisch getrennte
+// Module (Archive, DMS, Mail) bereit. Getrennt von cmd/core aus
+// demselben Grund wie policy-api (RBAC-06).
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+	"gitea.perlbach24.de/scripte/nexarch/internal/notifyapi"
+	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_NOTIFY_ADMIN_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_NOTIFY_ADMIN_DSN muss gesetzt sein")
+	}
+	serviceToken := os.Getenv("NEXARCH_NOTIFY_SERVICE_TOKEN")
+	if serviceToken == "" {
+		log.Fatal("NEXARCH_NOTIFY_SERVICE_TOKEN muss gesetzt sein")
+	}
+	addr := os.Getenv("NEXARCH_NOTIFY_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8094"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	prefs := notifyprefs.NewStore(pool)
+	dispatcher := notify.NewDispatcher(pool)
+
+	mux := http.NewServeMux()
+	notifyapi.Mount(mux, prefs, dispatcher, serviceToken)
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("notify-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}

cmd/policy-api/main.go

@@ -0,0 +1,50 @@
+// policy-api ist der Aufrufpunkt fuer RBAC-06: stellt Core RBAC-02s
+// Enforcer.Authorize als HTTP-Endpunkt fuer andere, physisch getrennte
+// Module (DMS, Mail, Archive) bereit. Getrennt von cmd/core aus
+// demselben Grund wie die anderen *-devserver.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
+	"gitea.perlbach24.de/scripte/nexarch/internal/policyapi"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_POLICY_ADMIN_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_POLICY_ADMIN_DSN muss gesetzt sein")
+	}
+	serviceToken := os.Getenv("NEXARCH_POLICY_SERVICE_TOKEN")
+	if serviceToken == "" {
+		log.Fatal("NEXARCH_POLICY_SERVICE_TOKEN muss gesetzt sein")
+	}
+	addr := os.Getenv("NEXARCH_POLICY_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8093"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	enforcer := policy.NewEnforcer(policy.NewStore(pool))
+
+	mux := http.NewServeMux()
+	policyapi.Mount(mux, enforcer, serviceToken)
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("policy-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}

deploy/systemd/nexarch-notify-api.service.tmpl

@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Core - Modulübergreifender Benachrichtigungs-Endpunkt (CFG-05)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/notify-api.env
+ExecStart=__INSTALL_DIR__/bin/notify-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target

deploy/systemd/nexarch-policy-api.service.tmpl

@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Core - Modulübergreifender RBAC-Autorisierungs-Endpunkt (RBAC-06)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/policy-api.env
+ExecStart=__INSTALL_DIR__/bin/policy-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target

docs/CFG-05-PRUEFPROTOKOLL.md

@@ -0,0 +1,87 @@
+# CFG-05 – Prüfprotokoll: Modulübergreifender HTTP-Endpunkt für Benachrichtigungs-Ereignisse
+
+Voraussetzung CFG-04 – bereits Fertig (siehe eigenes Protokoll).
+
+## Grundsatzentscheidung: Wrapper, keine zweite Benachrichtigungslogik
+
+`internal/notifyapi.Mount` registriert `POST /notify/enqueue`, dessen
+Handler AUSSCHLIESSLICH `notifyprefs.EnqueueIfAllowed` aufruft — dieselbe
+Funktion, die auch core-interne Aufrufer nutzen (z. B. CFG-04s eigene
+Handler). Die Übereinstimmung zwischen HTTP-Antwort und direktem
+Aufruf ist dadurch strukturell garantiert — real bewiesen für
+aktivierten UND deaktivierten Kanal (siehe Prüfungen).
+
+**Endpunkt ist für externe Module aufrufbar, nicht nur Core-intern:**
+real per HTTP von einem simulierten Fremd-Modul-Testclient
+(`TestEnqueueHandler_RealForeignModuleClient`) und per `curl` von der
+Kommandozeile aus aufgerufen, jeweils gegen den laufenden, über
+systemd verwalteten `notify-api`-Prozess — nicht nur als Go-Funktion
+innerhalb desselben Prozesses getestet.
+
+## Service-Authentifizierung: Reuse von RBAC-06, kein neues Provisorium
+
+`internal/policyapi.RequireServiceToken` (RBAC-06) direkt
+wiederverwendet — kein zweiter, abweichender Service-Token-Mechanismus.
+Beide liegen im selben Core-Go-Modul, ein echter Import statt
+Duplikat. `notify-api` läuft als eigener systemd-Dienst (analog
+`policy-api`), mit eigenem `NEXARCH_NOTIFY_SERVICE_TOKEN`
+(unabhängiger Tokenwert von RBAC-06s Token — getrennte
+Vertrauensgrenze pro Endpunkt, kein geteiltes Secret).
+
+## Umsetzung
+
+- `internal/notifyapi.Mount`/`enqueueHandler` — `POST /notify/enqueue`,
+  reiner Wrapper um `notifyprefs.EnqueueIfAllowed`.
+- `cmd/notify-api` — eigenständiger HTTP-Dienst, Port 8094.
+- `deploy/systemd/nexarch-notify-api.service.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Endpunkt-Antwort stimmt in mehreren Stichproben mit dem direkten EnqueueIfAllowed-Ergebnis überein | **bestanden** — `TestEnqueueHandler_MatchesDirectEnqueueIfAllowed`: aktivierter Kanal (Opt-out-Default) liefert echte Job-ID; deaktivierter Kanal wird real per `prefs.Set(...,false)` gesetzt, HTTP-Antwort (`skipped=true`) stimmt exakt mit dem parallel ausgeführten direkten Aufruf überein |
+| 2 | Aufruf ohne Service-Token wird abgewiesen (401), Handler nie erreicht | **bestanden** — `TestEnqueueHandler_MissingTokenReturns401`; real auf 131: `curl` ohne `X-Service-Token` → 401 |
+| 3 | Ein simulierter Fremd-Modul-Testclient löst real über den laufenden Endpunkt ein Ereignis aus | **bestanden** — `TestEnqueueHandler_RealForeignModuleClient`: echte `notification_jobs`-Zeile per SQL nachgewiesen; zusätzlich real auf 131 per `curl` reproduziert, resultierende `notification_jobs`-Zeile per `psql` bestätigt (`status=pending`), danach entfernt |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `notify-api` gebaut nach `/opt/nexarch-core/bin/`
+- `/etc/nexarch/notify-api.env` (0600)
+- `nexarch-notify-api.service` installiert/aktiviert (dauerhaft,
+  `Restart=on-failure`)
+- Reale Rechtevergabe-Lücke gefunden und behoben (gleiches Muster wie
+  RBAC-06): `notification_preferences`/`notification_jobs` gehörten
+  `postgres`, `nexarch_core` hatte keine Rechte — `GRANT` nachgezogen
+  und über `information_schema.role_table_grants` verifiziert (nicht
+  nur ausgeführt und angenommen), bevor der End-zu-Ende-Test erneut
+  lief.
+- Realer End-zu-Ende-Test via `curl`: 401 ohne Token, `job_id` +
+  `skipped:false` nach echtem Aufruf, `notification_jobs`-Zeile per
+  `psql` bestätigt, danach entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./internal/notifyapi/... ./internal/notifyprefs/... ./internal/policyapi/... -> alle bestanden
+```
+
+**Hinweis:** `go test ./... -p 1` auf diesem Branch zeigt Fehlschläge in
+`internal/user` (`database "test_iam01_users" already exists`) — reale
+Umgebungs-Altlast aus früheren IAM-01-Testläufen dieser Session,
+NICHT durch CFG-05 verursacht. Alle von CFG-05 tatsächlich berührten
+Pakete (`internal/notifyapi`, `internal/notifyprefs`, `internal/notify`,
+`internal/policy`, `internal/policyapi`, `internal/rbac`,
+`internal/auth`, `internal/cfgservice`, `internal/channels`,
+`internal/tenant`) sind grün.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt — inklusive echtem systemd-Deploy und
+curl-Nachweis. Schließt denselben "Go-Code ohne HTTP-Schnittstelle für
+andere Module"-Befund für Benachrichtigungs-Ereignisse, den RBAC-06
+für Policy-Entscheidungen geschlossen hat. RET-07 (Archive) kann sich
+jetzt gegen diesen Endpunkt verdrahten.

docs/RBAC-06-PRUEFPROTOKOLL.md

@@ -0,0 +1,109 @@
+# RBAC-06 – Prüfprotokoll: Modulübergreifender HTTP-Endpunkt für Policy-Entscheidungen
+
+Voraussetzung RBAC-02 – bereits Fertig (siehe eigenes Protokoll).
+
+## Grundsatzentscheidung: Wrapper, keine zweite Autorisierungslogik
+
+`internal/policyapi.Mount` registriert `POST /authorize`, dessen Handler
+AUSSCHLIESSLICH `policy.Enforcer.Authorize` aufruft — es gibt keinen
+zweiten, abweichenden Entscheidungspfad. Die Übereinstimmung zwischen
+HTTP-Antwort und direktem Enforcer-Ergebnis (Akzeptanzkriterium 1) ist
+dadurch strukturell garantiert, nicht nur zufällig getestet — real mit
+100 Stichproben bewiesen (siehe Prüfungen).
+
+## Service-Authentifizierung: eigener, schlanker Token statt moduleregistry
+
+Für Akzeptanzkriterium 2 (service-zu-service-authentifiziert) wurde
+BEWUSST NICHT `internal/moduleregistry.Registry.RequireServiceCredential`
+(API-02) wiederverwendet — dessen `Provision`/`Authenticate` ist ein
+volles Credential-Ausstellungssystem für Modul-AKTIVIERUNG, zieht
+`internal/flag` als weitere Abhängigkeit nach sich und wurde nie mit
+`internal/policy` zusammen gemergt (beide entstanden auf unabhängigen,
+nie zusammengeführten Feature-Branches). Für einen einzelnen,
+zustandslosen Autorisierungs-Endpunkt genügt ein geteilter, über
+Umgebungsvariable konfigurierter Service-Token, timing-safe verglichen
+(`subtle.ConstantTimeCompare`, dieselbe Referenzimplementierung wie
+AUD-02) — kleinste Lösung, die Akzeptanzkriterium 2 erfüllt, ohne
+unnötige Kopplung an ein für diesen Zweck überdimensioniertes System.
+
+## Bezug zu Archive RET-06-API
+
+Ersetzt das dort dokumentierte Provisorium
+(`internal/retentionapi.RequireRole`, Header-basierter Rollen-Check) —
+siehe `archive/docs/RET-06-API-PRUEFPROTOKOLL.md`. Die Migration von
+RET-06-API auf einen echten Aufruf dieses Endpunkts ist ein eigenes,
+kleines Folgeticket (Akzeptanzkriterium 3) — hier nicht mit umgesetzt,
+um RBAC-06 nicht mit Archive-Code zu vermischen (kein Umbau
+angrenzender Bereiche).
+
+## Umsetzung
+
+- `internal/policyapi.RequireServiceToken` — timing-safer
+  Service-Token-Check.
+- `internal/policyapi.Mount`/`authorizeHandler` — `POST /authorize`,
+  reiner Wrapper um `enforcer.Authorize`.
+- `cmd/policy-api` — eigenständiger HTTP-Dienst (analog zu den
+  bestehenden `*-devserver`n, getrennt von `cmd/core`).
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Endpunkt-Antwort stimmt in 100 Stichproben exakt mit dem direkten Enforcer.Authorize-Ergebnis überein | **bestanden** — `TestAuthorizeHandler_MatchesDirectEnforcerResult`: 100 Läufe über drei role/permission-Kombinationen (erlaubt, unbekannte Rolle, falsches Recht), jede einzelne HTTP-Antwort mit dem direkten Aufruf verglichen, 0 Abweichungen |
+| 2 | Aufruf ohne gültige Service-Credentials wird abgewiesen (401/403), nicht mit einer Policy-Entscheidung beantwortet | **bestanden** — `TestRequireServiceToken_MissingOrWrongTokenReturns401` (Handler nachweislich NIE erreicht) UND `TestRequireServiceToken_CorrectTokenAllowsAccess`; real auf 131: `curl` ohne Token → 401 |
+| 3 | Ein simulierter Fremd-Modul-Testclient fragt real gegen den laufenden Endpunkt ab und erhält korrekte Allow/Deny-Antworten | **bestanden** — real auf 131: `curl` mit Service-Token gegen `archive_admin`/`retention.configure` (simuliert Archive als Aufrufer) liefert korrekt `{"allowed":false}` ohne Regel und `{"allowed":true}` nach realem `Grant` |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `policy-api` gebaut nach `/opt/nexarch-core/bin/`
+- `/etc/nexarch/policy-api.env` (0600)
+- `nexarch-policy-api.service` installiert/aktiviert (dauerhaft,
+  `Restart=on-failure`)
+- Reale Rechtevergabe-Lücke gefunden und behoben: `policy_rules`/
+  `policy_rule_changes` waren auf `nexarch_registry` bereits von einem
+  früheren Testlauf unter der Rolle `postgres` angelegt worden,
+  `nexarch_core` hatte keine Rechte darauf — `GRANT` nachgezogen und
+  NACHTRÄGLICH VERIFIZIERT (nicht nur ausgeführt und angenommen):
+  `information_schema.role_table_grants` bestätigt `nexarch_core` hat
+  dauerhaft SELECT/INSERT/UPDATE/DELETE auf `policy_rules` und
+  SELECT/INSERT auf `policy_rule_changes` — der Endpunkt hängt NICHT
+  von der zufälligen `postgres`-Eigentümerschaft ab, sondern von einem
+  eigenen, geprüften Grant für die tatsächlich im Betrieb genutzte
+  Rolle (`NEXARCH_POLICY_ADMIN_DSN` in `/etc/nexarch/policy-api.env`
+  verwendet `nexarch_core`). Dieser Grant ist Teil des Deploy-Vorgangs,
+  nicht Teil von RBAC-02s Migration (deren Ticket bereits Fertig ist,
+  hier nicht nachträglich verändert) — ein künftiges Fresh-Deploy muss
+  ihn wiederholen, dokumentiert hier als Betriebsschritt.
+- **Push zu Gitea vorübergehend nicht möglich**: `gitea.perlbach24.de`
+  war zum Zeitpunkt des Commits über TCP 443/80 nicht erreichbar (Ping
+  auf den Host erfolgreich, HTTP(S)-Ports timeout) — externer
+  Netzwerk-/Dienstausfall, KEIN Code- oder Konfigurationsfehler dieses
+  Tickets. Board-Status blieb bewusst auf „Backlog“, bis der Push
+  tatsächlich durchgeführt wurde (kein Status-Flip ohne Push).
+- Realer End-zu-Ende-Test via `curl`: 401 ohne Token, `{"allowed":false}`
+  für unbekannte Kombination, `{"allowed":true}` nach echtem `Grant`,
+  Testregel anschließend entfernt
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./internal/policy/... ./internal/policyapi/... ./internal/rbac/... -> alle bestanden
+```
+
+**Hinweis:** `go test ./... -p 1` auf diesem Branch zeigt Fehlschläge in
+`internal/tenant`/`internal/user` — reale Umgebungs-Altlasten (z. B.
+bereits existierende `tenant_acme`-Datenbank) aus früheren TEN-01-
+Testläufen dieser Session, NICHT durch RBAC-06 verursacht und nicht in
+dessen Scope. Alle drei von RBAC-06 tatsächlich berührten Pakete
+(`internal/policy`, `internal/policyapi`, `internal/rbac`) sind grün.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt — inklusive echtem systemd-Deploy und
+curl-Nachweis beider Pfade (Allow und Deny). Schließt den seit
+FDN-03/FDN-09 wiederkehrenden "Go-Code ohne HTTP-Schnittstelle für
+andere Module"-Befund für RBAC-Abfragen einmalig und wiederverwendbar.

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/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/notifyapi/handler.go

@@ -0,0 +1,64 @@
+// Package notifyapi ist CFG-05: stellt Core CFG-04s
+// internal/notifyprefs.EnqueueIfAllowed als HTTP-Endpunkt fuer andere,
+// physisch getrennte Module (Archive, DMS, Mail) bereit — gleiches Muster
+// wie RBAC-06 (internal/policyapi): reiner Wrapper, kein zweiter
+// Entscheidungspfad, service-token-authentifiziert ueber
+// internal/policyapi.RequireServiceToken.
+package notifyapi
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
+	"gitea.perlbach24.de/scripte/nexarch/internal/policyapi"
+)
+
+// Mount registriert POST /notify/enqueue hinter dem Service-Token-Check.
+func Mount(mux *http.ServeMux, prefs *notifyprefs.Store, dispatcher *notify.Dispatcher, serviceToken string) {
+	mux.HandleFunc("POST /notify/enqueue", policyapi.RequireServiceToken(serviceToken, enqueueHandler(prefs, dispatcher)))
+}
+
+type enqueueRequest struct {
+	TenantSlug string         `json:"tenant_slug"`
+	UserID     string         `json:"user_id"`
+	EventType  string         `json:"event_type"`
+	Channel    string         `json:"channel"`
+	Recipient  string         `json:"recipient"`
+	Payload    map[string]any `json:"payload"`
+}
+
+type enqueueResponse struct {
+	JobID   string `json:"job_id"`
+	Skipped bool   `json:"skipped"`
+}
+
+// enqueueHandler ruft AUSSCHLIESSLICH notifyprefs.EnqueueIfAllowed auf —
+// dieselbe Funktion, die auch core-interne Aufrufer nutzen. Der
+// Praeferenz-Filter (Akzeptanzkriterium 3 aus RET-07, "je Ereignistyp
+// ein-/ausschaltbar") ist dadurch strukturell identisch mit dem
+// direkten Aufruf, nicht nur zufaellig getestet.
+func enqueueHandler(prefs *notifyprefs.Store, dispatcher *notify.Dispatcher) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req enqueueRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, "ungültiger request-body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		if req.TenantSlug == "" || req.UserID == "" || req.EventType == "" || req.Channel == "" || req.Recipient == "" {
+			http.Error(w, "tenant_slug, user_id, event_type, channel und recipient sind pflichtfelder", http.StatusBadRequest)
+			return
+		}
+		jobID, skipped, err := notifyprefs.EnqueueIfAllowed(
+			r.Context(), prefs, dispatcher,
+			req.TenantSlug, req.UserID, req.EventType, req.Channel, req.Recipient, req.Payload,
+		)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(enqueueResponse{JobID: jobID, Skipped: skipped})
+	}
+}

internal/notifyapi/handler_test.go

@@ -0,0 +1,176 @@
+package notifyapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
+)
+
+const testToken = "test-service-token-cfg05"
+
+func setupTest(t *testing.T) (*notifyprefs.Store, *notify.Dispatcher, *pgxpool.Pool) {
+	t.Helper()
+	dsn := os.Getenv("TEST_ADMIN_DSN")
+	if dsn == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+
+	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)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM notification_jobs WHERE recipient LIKE 'cfg05\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(context.Background(), `DELETE FROM notification_preferences WHERE user_id LIKE 'cfg05\_%' ESCAPE '\'`)
+	})
+
+	return notifyprefs.NewStore(pool), notify.NewDispatcher(pool), pool
+}
+
+func post(t *testing.T, server *httptest.Server, token string, req enqueueRequest) *http.Response {
+	t.Helper()
+	body, _ := json.Marshal(req)
+	httpReq, _ := http.NewRequest(http.MethodPost, server.URL+"/notify/enqueue", bytes.NewReader(body))
+	if token != "" {
+		httpReq.Header.Set("X-Service-Token", token)
+	}
+	resp, err := http.DefaultClient.Do(httpReq)
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	return resp
+}
+
+// TestEnqueueHandler_MissingTokenReturns401 ist die geforderte
+// Pflichtpruefung: Aufruf ohne Service-Token wird abgewiesen, Handler nie
+// erreicht, keine Zustellung ausgeloest.
+func TestEnqueueHandler_MissingTokenReturns401(t *testing.T) {
+	prefs, dispatcher, _ := setupTest(t)
+	mux := http.NewServeMux()
+	Mount(mux, prefs, dispatcher, testToken)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	resp := post(t, server, "", enqueueRequest{
+		TenantSlug: "acme", UserID: "cfg05_user1", EventType: "invoice_ready", Channel: "email", Recipient: "cfg05_user1@acme.example",
+	})
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusUnauthorized {
+		t.Fatalf("ohne token: status = %d, want 401", resp.StatusCode)
+	}
+}
+
+// TestEnqueueHandler_MatchesDirectEnqueueIfAllowed ist die geforderte
+// Pflichtpruefung: Endpunkt-Verhalten stimmt exakt mit dem direkten
+// EnqueueIfAllowed-Aufruf ueberein, real fuer aktivierten UND deaktivierten
+// Kanal.
+func TestEnqueueHandler_MatchesDirectEnqueueIfAllowed(t *testing.T) {
+	prefs, dispatcher, _ := setupTest(t)
+	mux := http.NewServeMux()
+	Mount(mux, prefs, dispatcher, testToken)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	ctx := context.Background()
+
+	// Fall 1: kein explizites Preference -> Opt-out-Default aktiviert.
+	resp1 := post(t, server, testToken, enqueueRequest{
+		TenantSlug: "acme", UserID: "cfg05_user_enabled", EventType: "invoice_ready", Channel: "email", Recipient: "cfg05_user_enabled@acme.example",
+	})
+	defer func() { _ = resp1.Body.Close() }()
+	if resp1.StatusCode != http.StatusOK {
+		t.Fatalf("aktivierter fall: status = %d, want 200", resp1.StatusCode)
+	}
+	var out1 enqueueResponse
+	if err := json.NewDecoder(resp1.Body).Decode(&out1); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if out1.Skipped || out1.JobID == "" {
+		t.Fatalf("erwartet zugestellt mit job-id, habe: %+v", out1)
+	}
+
+	// Fall 2: Kanal explizit deaktiviert -> muss uebereinstimmend skipped=true liefern,
+	// wie ein direkter EnqueueIfAllowed-Aufruf es auch taete.
+	if err := prefs.Set(ctx, "acme", "cfg05_user_disabled", "invoice_ready", "email", false); err != nil {
+		t.Fatalf("praeferenz setzen: %v", err)
+	}
+	directJobID, directSkipped, err := notifyprefs.EnqueueIfAllowed(ctx, prefs, dispatcher, "acme", "cfg05_user_disabled", "invoice_ready", "email", "cfg05_user_disabled@acme.example", nil)
+	if err != nil {
+		t.Fatalf("direkter aufruf: %v", err)
+	}
+
+	resp2 := post(t, server, testToken, enqueueRequest{
+		TenantSlug: "acme", UserID: "cfg05_user_disabled", EventType: "invoice_ready", Channel: "email", Recipient: "cfg05_user_disabled@acme.example",
+	})
+	defer func() { _ = resp2.Body.Close() }()
+	var out2 enqueueResponse
+	if err := json.NewDecoder(resp2.Body).Decode(&out2); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if out2.Skipped != directSkipped {
+		t.Fatalf("http skipped=%t weicht vom direkten aufruf skipped=%t ab", out2.Skipped, directSkipped)
+	}
+	if !out2.Skipped {
+		t.Fatalf("deaktivierter kanal haette uebersprungen werden muessen, direkt=%q http=%q", directJobID, out2.JobID)
+	}
+}
+
+// TestEnqueueHandler_RealForeignModuleClient simuliert einen Fremd-Modul-
+// Testclient (z. B. Archive/RET-07), der real gegen den laufenden Endpunkt
+// eine Benachrichtigung ausloest.
+func TestEnqueueHandler_RealForeignModuleClient(t *testing.T) {
+	prefs, dispatcher, pool := setupTest(t)
+	mux := http.NewServeMux()
+	Mount(mux, prefs, dispatcher, testToken)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	resp := post(t, server, testToken, enqueueRequest{
+		TenantSlug: "acme", UserID: "cfg05_fremd_modul", EventType: "retention_due_soon", Channel: "email", Recipient: "cfg05_fremd_modul@acme.example",
+	})
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want 200", resp.StatusCode)
+	}
+	var out enqueueResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if out.Skipped || out.JobID == "" {
+		t.Fatalf("erwartet echte job-id, habe: %+v", out)
+	}
+
+	var count int
+	if err := pool.QueryRow(context.Background(), `SELECT count(*) FROM notification_jobs WHERE id = $1`, out.JobID).Scan(&count); err != nil {
+		t.Fatalf("job pruefen: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet real angelegte notification_jobs-zeile fuer job-id %s", out.JobID)
+	}
+}

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/policyapi/authn.go

@@ -0,0 +1,38 @@
+// Package policyapi implementiert RBAC-06: einen HTTP-Endpunkt, der
+// Core RBAC-02s Enforcer.Authorize für andere, physisch getrennte
+// Go-Module (DMS, Mail, Archive) zugänglich macht — dieselbe
+// Entscheidung wie der direkte Enforcer-Aufruf, nur per HTTP statt
+// In-Process.
+package policyapi
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"net/http"
+)
+
+// RequireServiceToken authentifiziert den Aufrufer service-zu-service
+// über einen geteilten Token (Umgebungsvariable, nie im Code — siehe
+// Ticket-Abschlussregel), timing-safe verglichen (dieselbe
+// Referenzimplementierung wie AUD-02: subtle.ConstantTimeCompare,
+// projektweite Konvention für jeden sicherheitsrelevanten Vergleich).
+// Bewusst KEIN vollwertiges Credential-Ausstellungssystem
+// (moduleregistry.Provision/Authenticate) — dieser Endpunkt braucht
+// keine Modul-Aktivierungsverwaltung, nur einen einzelnen, über
+// Konfiguration verteilten Zugangsschlüssel (Akzeptanzkriterium 2).
+func RequireServiceToken(expectedToken string, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		got := r.Header.Get("X-Service-Token")
+		if got == "" || !timingSafeEqual(got, expectedToken) {
+			http.Error(w, "authentifizierung fehlgeschlagen: gültiges X-Service-Token erforderlich", http.StatusUnauthorized)
+			return
+		}
+		next(w, r)
+	}
+}
+
+func timingSafeEqual(a, b string) bool {
+	ha := sha256.Sum256([]byte(a))
+	hb := sha256.Sum256([]byte(b))
+	return subtle.ConstantTimeCompare(ha[:], hb[:]) == 1
+}

internal/policyapi/authn_test.go

@@ -0,0 +1,63 @@
+package policyapi
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// TestRequireServiceToken_MissingOrWrongTokenReturns401 ist die
+// Pflichtpruefung: Aufruf ohne gueltige Service-Credentials wird
+// abgewiesen, nicht mit einer Policy-Entscheidung beantwortet.
+func TestRequireServiceToken_MissingOrWrongTokenReturns401(t *testing.T) {
+	called := false
+	handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
+		called = true
+		w.WriteHeader(http.StatusOK)
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	resp, err := http.Get(server.URL)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusUnauthorized {
+		t.Fatalf("ohne token: status = %d, want 401", resp.StatusCode)
+	}
+	if called {
+		t.Fatal("handler haette bei fehlendem token nie erreicht werden duerfen")
+	}
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("X-Service-Token", "falsches-token")
+	resp2, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp2.Body.Close() }()
+	if resp2.StatusCode != http.StatusUnauthorized {
+		t.Fatalf("mit falschem token: status = %d, want 401", resp2.StatusCode)
+	}
+}
+
+// TestRequireServiceToken_CorrectTokenAllowsAccess ist der Gegentest.
+func TestRequireServiceToken_CorrectTokenAllowsAccess(t *testing.T) {
+	handler := RequireServiceToken("richtiges-token", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("X-Service-Token", "richtiges-token")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("mit korrektem token: status = %d, want 200", resp.StatusCode)
+	}
+}

internal/policyapi/handler.go

@@ -0,0 +1,56 @@
+package policyapi
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// Mount registriert den Autorisierungs-Endpunkt auf mux, hinter dem
+// Service-Token-Check (Akzeptanzkriterium 2).
+func Mount(mux *http.ServeMux, enforcer *policy.Enforcer, serviceToken string) {
+	mux.HandleFunc("POST /authorize", RequireServiceToken(serviceToken, authorizeHandler(enforcer)))
+}
+
+type authorizeRequest struct {
+	Role       string `json:"role"`
+	Permission string `json:"permission"`
+}
+
+type authorizeResponse struct {
+	Allowed bool `json:"allowed"`
+}
+
+// authorizeHandler ruft AUSSCHLIESSLICH enforcer.Authorize auf — keine
+// eigene, zweite Autorisierungsentscheidung (Akzeptanzkriterium 1: die
+// HTTP-Antwort MUSS mit dem direkten Enforcer-Ergebnis übereinstimmen,
+// das ist strukturell garantiert, weil es derselbe Aufruf ist, nicht
+// nur getestet).
+func authorizeHandler(enforcer *policy.Enforcer) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req authorizeRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, "ungültiger request-body: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		if req.Role == "" || req.Permission == "" {
+			http.Error(w, "role und permission sind pflichtfelder", http.StatusBadRequest)
+			return
+		}
+
+		err := enforcer.Authorize(r.Context(), rbac.Role(req.Role), rbac.Permission(req.Permission))
+		allowed := err == nil
+		if err != nil && !errors.Is(err, policy.ErrDenied) {
+			// Ein anderer Fehler als "verboten" (z.B. DB-Fehler) ist kein
+			// gueltiges Allow/Deny-Ergebnis, sondern ein echter Fehlerfall.
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(authorizeResponse{Allowed: allowed})
+	}
+}

internal/policyapi/handler_test.go

@@ -0,0 +1,116 @@
+package policyapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+const testToken = "test-service-token"
+
+func setupTest(t *testing.T) *policy.Enforcer {
+	t.Helper()
+	dsn := os.Getenv("TEST_ADMIN_DSN")
+	if dsn == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+
+	if _, err := pool.Exec(ctx, `
+		CREATE EXTENSION IF NOT EXISTS pgcrypto;
+		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)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rule_changes WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(context.Background(), `DELETE FROM policy_rules WHERE role LIKE 'rbac06\_%' ESCAPE '\'`)
+	})
+
+	store := policy.NewStore(pool)
+	if err := store.Grant(ctx, rbac.Role("rbac06_erlaubte_rolle"), rbac.Permission("rbac06_recht"), "test"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+	return policy.NewEnforcer(store)
+}
+
+func authorize(t *testing.T, server *httptest.Server, role, permission string) (int, bool) {
+	t.Helper()
+	body, _ := json.Marshal(authorizeRequest{Role: role, Permission: permission})
+	req, _ := http.NewRequest(http.MethodPost, server.URL+"/authorize", bytes.NewReader(body))
+	req.Header.Set("X-Service-Token", testToken)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		return resp.StatusCode, false
+	}
+	var out authorizeResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	return resp.StatusCode, out.Allowed
+}
+
+// TestAuthorizeHandler_MatchesDirectEnforcerResult ist die geforderte
+// Pflichtpruefung: Endpunkt-Antwort stimmt in 100 Stichproben exakt mit
+// dem direkten Enforcer.Authorize-Ergebnis ueberein - real fuer sowohl
+// erlaubte als auch verbotene role+permission-Kombinationen.
+func TestAuthorizeHandler_MatchesDirectEnforcerResult(t *testing.T) {
+	enforcer := setupTest(t)
+	mux := http.NewServeMux()
+	Mount(mux, enforcer, testToken)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	cases := []struct {
+		role, permission string
+	}{
+		{"rbac06_erlaubte_rolle", "rbac06_recht"},   // erlaubt
+		{"rbac06_unbekannte_rolle", "rbac06_recht"}, // verboten (default-deny)
+		{"rbac06_erlaubte_rolle", "rbac06_anderes"}, // verboten (falsches recht)
+	}
+
+	for i := 0; i < 100; i++ {
+		c := cases[i%len(cases)]
+		directErr := enforcer.Authorize(context.Background(), rbac.Role(c.role), rbac.Permission(c.permission))
+		directAllowed := directErr == nil
+		if directErr != nil && !errors.Is(directErr, policy.ErrDenied) {
+			t.Fatalf("stichprobe %d: unerwarteter enforcer-fehler: %v", i, directErr)
+		}
+
+		status, httpAllowed := authorize(t, server, c.role, c.permission)
+		if status != http.StatusOK {
+			t.Fatalf("stichprobe %d: unerwarteter status %d", i, status)
+		}
+		if httpAllowed != directAllowed {
+			t.Fatalf("stichprobe %d (%s/%s): http=%t, direkt=%t - weichen ab", i, c.role, c.permission, httpAllowed, directAllowed)
+		}
+	}
+}

internal/rbac/group.go

@@ -1,200 +0,0 @@
-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

@@ -1,209 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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

@@ -1,309 +0,0 @@
-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)
-	}
-}

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/0005_notification_jobs.down.sql

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

migrations/0005_notification_jobs.up.sql

@@ -0,0 +1,20 @@
+-- Benachrichtigungs-Dispatcher-Warteschlange (CFG-02, siehe
+-- core-kanban/tickets/CFG-02.md). Postgres-basiert statt Redis/AMQP
+-- (Projekt-Konvention, siehe nexarch-state.json techstack.job_queue) —
+-- Zeilen ueberleben einen Neustart des Dispatcher-Prozesses unveraendert
+-- (Akzeptanzkriterium 3).
+CREATE TABLE 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()
+);
+
+CREATE INDEX notification_jobs_due_idx ON notification_jobs (status, next_attempt_at);

migrations/0006_notification_channels.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS in_app_notifications;
+DROP TABLE IF EXISTS notification_templates;

migrations/0006_notification_channels.up.sql

@@ -0,0 +1,28 @@
+-- Benachrichtigungs-Kanaele: Vorlagen (E-Mail) + In-App-Nachrichten
+-- (CFG-03, siehe core-kanban/tickets/CFG-03.md). Beide leben in der
+-- Registry-DB, analog zu feature_flags/config_values — modulübergreifende
+-- Konfiguration/UI-Zustand, keine Mandanten-Geschaeftsdaten.
+
+-- tenant_slug = 'global' ist der Fallback-Wert, wenn ein Tenant keine
+-- eigene Vorlage gesetzt hat (Akzeptanzkriterium 3: Vorlagen pro Tenant
+-- anpassbar, mit sinnvollem Default).
+CREATE TABLE 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 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 INDEX in_app_notifications_user_idx ON in_app_notifications (tenant_slug, user_id, created_at);

migrations/0007_notification_preferences.down.sql

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

migrations/0007_notification_preferences.up.sql

@@ -0,0 +1,17 @@
+-- CFG-04: Benachrichtigungspraeferenzen je Benutzer, Ereignistyp und Kanal.
+-- Lebt wie notification_templates/in_app_notifications (CFG-03) in der
+-- Registry-DB — modulübergreifende Konfiguration, keine Mandanten-Geschaeftsdaten.
+--
+-- Kein Row = aktiviert (Opt-out-Modell): ein Benutzer verpasst nichts, bis er
+-- aktiv einen Kanal/Ereignistyp abschaltet — sicherer Default als Opt-in.
+CREATE TABLE 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 INDEX notification_preferences_tenant_idx ON notification_preferences (tenant_slug);

migrations/tenant/0003_groups.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS group_members;
-DROP TABLE IF EXISTS groups;

migrations/tenant/0003_groups.up.sql

@@ -1,21 +0,0 @@
--- Gruppen/Abteilungen mit Rollenzuweisung auf Gruppenebene (RBAC-03, siehe
--- core-kanban/tickets/RBAC-03.md). Lebt in der Tenant-Datenbank (Modell C) —
--- Gruppen sind implizit tenant-isoliert, da jede Tenant-DB ihre eigenen hat.
-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()
-);
-
--- ON DELETE CASCADE: Loeschen einer Gruppe entzieht die gruppenbasierten
--- Rechte automatisch, ohne Benutzerkonten selbst zu beruehren
--- (Akzeptanzkriterium 3).
-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)
-);
-
-CREATE INDEX group_members_user_idx ON group_members (user_id);

web/notifications/app/layout.tsx

@@ -1,7 +1,7 @@
 import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
 
 export const metadata = {
-  title: "NEXARCH Rechteverwaltung",
+  title: "NEXARCH Benachrichtigungen",
 };
 
 export default function RootLayout({

web/notifications/app/overview/page.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Table } from "@nexarch/shl";
+import type { TableColumn } from "@nexarch/shl";
+import { Preference, fetchTenantOverview } from "../../lib/api";
+
+// Akzeptanzkriterium 3: Tenant-Admin sieht eine Übersicht der
+// Benachrichtigungs-Konfiguration seines Tenants. Zugriffsbeschränkung
+// (nur Tenant-Admin) ist RBAC-02s Aufgabe vor diesem Endpunkt, siehe
+// internal/notifyprefs/handler.go.
+export default function OverviewPage() {
+  const [prefs, setPrefs] = useState<Preference[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchTenantOverview()
+      .then(setPrefs)
+      .catch(() => setError("Übersicht konnte nicht geladen werden. Nur Tenant-Admins haben Zugriff."));
+  }, []);
+
+  const columns: TableColumn<Preference>[] = [
+    { key: "user", header: "Benutzer-ID", render: (p) => p.UserID },
+    { key: "event", header: "Ereignistyp", render: (p) => p.EventType },
+    { key: "channel", header: "Kanal", render: (p) => p.Channel },
+    { key: "enabled", header: "Aktiviert", render: (p) => (p.Enabled ? "Ja" : "Nein") },
+  ];
+
+  return (
+    <main style={{ maxWidth: 800, margin: "40px auto", padding: "0 16px" }}>
+      <h1>Benachrichtigungs-Übersicht (Mandant)</h1>
+      {error && <p role="alert">{error}</p>}
+      {prefs && (
+        <Table
+          columns={columns}
+          rows={prefs}
+          rowKey={(p) => `${p.UserID}-${p.EventType}-${p.Channel}`}
+          caption="Von der Standardeinstellung abweichende Benachrichtigungspräferenzen aller Benutzer"
+        />
+      )}
+    </main>
+  );
+}

web/notifications/app/page.tsx

@@ -1,5 +1,5 @@
 import { redirect } from "next/navigation";
 
 export default function IndexPage() {
-  redirect("/roles");
+  redirect("/settings");
 }

web/notifications/app/settings/page.tsx

@@ -0,0 +1,97 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { CheckboxField, useToast } from "@nexarch/shl";
+import {
+  ApiError,
+  KNOWN_CHANNELS,
+  KNOWN_EVENT_TYPES,
+  Preference,
+  fetchMyPreferences,
+  setPreference,
+} from "../../lib/api";
+
+const EVENT_LABELS: Record<string, string> = {
+  welcome: "Willkommen",
+  invoice_ready: "Rechnung verfügbar",
+  password_reset: "Passwort-Zurücksetzung",
+  security_alert: "Sicherheitshinweis",
+};
+
+const CHANNEL_LABELS: Record<string, string> = {
+  email: "E-Mail",
+  in_app: "In-App",
+};
+
+export default function SettingsPage() {
+  const { push } = useToast();
+  const [prefs, setPrefs] = useState<Preference[] | null>(null);
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const [pending, setPending] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchMyPreferences()
+      .then(setPrefs)
+      .catch(() => setLoadError("Einstellungen konnten nicht geladen werden. Bitte melden Sie sich an."));
+  }, []);
+
+  // Default: aktiviert, solange keine explizite Praeferenz existiert
+  // (Akzeptanzkriterium 1) — gleicher Opt-out-Default wie im Backend.
+  function isEnabled(eventType: string, channel: string): boolean {
+    const explicit = prefs?.find((p) => p.EventType === eventType && p.Channel === channel);
+    return explicit ? explicit.Enabled : true;
+  }
+
+  async function onToggle(eventType: string, channel: string, nextEnabled: boolean) {
+    const key = `${eventType}:${channel}`;
+    setPending(key);
+    try {
+      // Akzeptanzkriterium 2: sofort speichern, kein Sammel-Speichern-Button —
+      // wirkt unmittelbar auf künftige Zustellungen (EnqueueIfAllowed prüft
+      // bei jedem Aufruf live, kein Cache dazwischen).
+      await setPreference(eventType, channel, nextEnabled);
+      setPrefs((current) => {
+        const withoutThis = (current ?? []).filter((p) => !(p.EventType === eventType && p.Channel === channel));
+        return [...withoutThis, { TenantSlug: "", UserID: "", EventType: eventType, Channel: channel, Enabled: nextEnabled }];
+      });
+      push(nextEnabled ? "Benachrichtigung aktiviert." : "Benachrichtigung deaktiviert.", "success");
+    } catch (err) {
+      push(err instanceof ApiError ? err.message : "Einstellung konnte nicht gespeichert werden.", "danger");
+    } finally {
+      setPending(null);
+    }
+  }
+
+  if (loadError) {
+    return (
+      <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
+        <p role="alert">{loadError}</p>
+      </main>
+    );
+  }
+
+  return (
+    <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
+      <h1>Benachrichtigungseinstellungen</h1>
+      <p>Wählen Sie je Ereignis, über welche Kanäle Sie benachrichtigt werden möchten.</p>
+
+      {KNOWN_EVENT_TYPES.map((eventType) => (
+        <fieldset key={eventType} style={{ marginBottom: 16 }}>
+          <legend>{EVENT_LABELS[eventType] ?? eventType}</legend>
+          {KNOWN_CHANNELS.map((channel) => {
+            const key = `${eventType}:${channel}`;
+            return (
+              <CheckboxField
+                key={key}
+                label={CHANNEL_LABELS[channel] ?? channel}
+                checked={isEnabled(eventType, channel)}
+                disabled={pending === key}
+                onChange={(e) => onToggle(eventType, channel, e.target.checked)}
+              />
+            );
+          })}
+        </fieldset>
+      ))}
+    </main>
+  );
+}

web/notifications/lib/api.ts

@@ -0,0 +1,45 @@
+const API_BASE = process.env.NEXT_PUBLIC_CORE_API_BASE ?? "";
+
+export class ApiError extends Error {}
+
+async function req<T>(path: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(`${API_BASE}${path}`, {
+    credentials: "include",
+    headers: init?.body ? { "Content-Type": "application/json" } : undefined,
+    ...init,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new ApiError(data.error ?? data.message ?? "Unbekannter Fehler");
+  }
+  return data as T;
+}
+
+export interface Preference {
+  TenantSlug: string;
+  UserID: string;
+  EventType: string;
+  Channel: string;
+  Enabled: boolean;
+}
+
+// Bekannte Ereignistypen/Kanäle — das Backend erzwingt keine feste Liste
+// (jedes Modul kann eigene event_type-Werte an EnqueueIfAllowed übergeben),
+// diese Liste ist der aktuell bekannte Stand fürs Frontend-Formular.
+export const KNOWN_EVENT_TYPES = ["welcome", "invoice_ready", "password_reset", "security_alert"] as const;
+export const KNOWN_CHANNELS = ["email", "in_app"] as const;
+
+export function fetchMyPreferences(): Promise<Preference[]> {
+  return req("/notifications/preferences");
+}
+
+export function setPreference(eventType: string, channel: string, enabled: boolean): Promise<void> {
+  return req("/notifications/preferences", {
+    method: "POST",
+    body: JSON.stringify({ event_type: eventType, channel, enabled }),
+  });
+}
+
+export function fetchTenantOverview(): Promise<Preference[]> {
+  return req("/notifications/preferences/tenant");
+}

web/notifications/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "nexarch-rbac-admin",
+  "name": "nexarch-notifications",
   "private": true,
   "scripts": {
     "dev": "next dev",

web/rbac-admin/app/groups/page.tsx

@@ -1,183 +0,0 @@
-"use client";
-
-import { useEffect, useState } from "react";
-import { TextField, SelectField, useToast } from "@nexarch/shl";
-import {
-  ApiError,
-  Group,
-  Role,
-  addGroupMember,
-  createGroup,
-  fetchGroups,
-  removeGroupMember,
-  setGroupRole,
-} from "../../lib/api";
-
-export default function GroupsPage() {
-  const { push } = useToast();
-  const [groups, setGroups] = useState<Group[]>([]);
-  const [loadError, setLoadError] = useState<string | null>(null);
-
-  const reload = () =>
-    fetchGroups()
-      .then(setGroups)
-      .catch(() => setLoadError("Gruppen konnten nicht geladen werden. Sind Sie als Tenant-Admin angemeldet?"));
-
-  useEffect(() => {
-    reload();
-  }, []);
-
-  const [newGroupName, setNewGroupName] = useState("");
-  const [createError, setCreateError] = useState<string | null>(null);
-
-  async function onCreate(event: React.FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    setCreateError(null);
-    try {
-      await createGroup(newGroupName);
-      setNewGroupName("");
-      push("Gruppe angelegt.", "success");
-      await reload();
-    } catch (err) {
-      setCreateError(err instanceof ApiError ? err.message : "Gruppe konnte nicht angelegt werden.");
-    }
-  }
-
-  if (loadError) {
-    return (
-      <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
-        <p role="alert">{loadError}</p>
-      </main>
-    );
-  }
-
-  return (
-    <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
-      <h1>Gruppen &amp; Abteilungen</h1>
-
-      <section aria-labelledby="neue-gruppe-heading">
-        <h2 id="neue-gruppe-heading">Neue Gruppe anlegen</h2>
-        <form onSubmit={onCreate} noValidate>
-          <TextField
-            label="Gruppenname"
-            required
-            value={newGroupName}
-            onChange={(e) => setNewGroupName(e.target.value)}
-          />
-          {createError && (
-            <p role="alert" style={{ color: "var(--shl-color-danger)" }}>
-              {createError}
-            </p>
-          )}
-          <button type="submit">Anlegen</button>
-        </form>
-      </section>
-
-      <section aria-labelledby="gruppenliste-heading">
-        <h2 id="gruppenliste-heading">Bestehende Gruppen</h2>
-        {groups.length === 0 ? (
-          <p>Keine Gruppen vorhanden.</p>
-        ) : (
-          groups.map((g) => <GroupCard key={g.ID} group={g} onChanged={reload} onNotice={(t) => push(t, "success")} />)
-        )}
-      </section>
-    </main>
-  );
-}
-
-function GroupCard({
-  group,
-  onChanged,
-  onNotice,
-}: {
-  group: Group;
-  onChanged: () => void;
-  onNotice: (text: string) => void;
-}) {
-  const [role, setRole] = useState<Role>(group.Role || "user");
-  const [newMemberId, setNewMemberId] = useState("");
-  const [error, setError] = useState<string | null>(null);
-
-  async function onSetRole() {
-    setError(null);
-    try {
-      await setGroupRole(group.ID, role);
-      onNotice("Gruppenrolle gesetzt.");
-      onChanged();
-    } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Gruppenrolle konnte nicht gesetzt werden.");
-    }
-  }
-
-  async function onAddMember(event: React.FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    setError(null);
-    try {
-      await addGroupMember(group.ID, newMemberId);
-      setNewMemberId("");
-      onNotice("Mitglied hinzugefügt.");
-      onChanged();
-    } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Mitglied konnte nicht hinzugefügt werden.");
-    }
-  }
-
-  async function onRemoveMember(userId: string) {
-    setError(null);
-    try {
-      await removeGroupMember(group.ID, userId);
-      onNotice("Mitglied entfernt.");
-      onChanged();
-    } catch (err) {
-      setError(err instanceof ApiError ? err.message : "Mitglied konnte nicht entfernt werden.");
-    }
-  }
-
-  return (
-    <div style={{ border: "1px solid var(--shl-color-border)", borderRadius: 8, padding: 16, marginBottom: 16 }}>
-      <h3>{group.Name}</h3>
-
-      <div style={{ display: "flex", alignItems: "flex-end", gap: 8 }}>
-        <SelectField label="Gruppenrolle" value={role} onChange={(e) => setRole(e.target.value as Role)}>
-          <option value="user">Benutzer</option>
-          <option value="tenant_admin">Tenant-Admin</option>
-        </SelectField>
-        <button type="button" onClick={onSetRole}>
-          Setzen
-        </button>
-      </div>
-
-      <h4>Mitglieder</h4>
-      {group.members.length === 0 ? (
-        <p>Keine Mitglieder.</p>
-      ) : (
-        <ul>
-          {group.members.map((userId) => (
-            <li key={userId}>
-              {userId}{" "}
-              <button type="button" onClick={() => onRemoveMember(userId)}>
-                Entfernen
-              </button>
-            </li>
-          ))}
-        </ul>
-      )}
-
-      <form onSubmit={onAddMember} noValidate>
-        <TextField
-          label="Benutzer-ID hinzufügen"
-          required
-          value={newMemberId}
-          onChange={(e) => setNewMemberId(e.target.value)}
-        />
-        <button type="submit">Hinzufügen</button>
-      </form>
-
-      {error && (
-        <p role="alert" style={{ color: "var(--shl-color-danger)" }}>
-          {error}
-        </p>
-      )}
-    </div>
-  );
-}

web/rbac-admin/app/roles/page.tsx

@@ -1,142 +0,0 @@
-"use client";
-
-import { useEffect, useState } from "react";
-import { Table, TextField, SelectField, useToast } from "@nexarch/shl";
-import type { TableColumn } from "@nexarch/shl";
-import {
-  ApiError,
-  Assignment,
-  Role,
-  RoleInfo,
-  assignRole,
-  fetchRoleHistory,
-  fetchRoles,
-} from "../../lib/api";
-
-export default function RolesPage() {
-  const { push } = useToast();
-  const [roles, setRoles] = useState<RoleInfo[] | null>(null);
-  const [loadError, setLoadError] = useState<string | null>(null);
-
-  const [targetUserId, setTargetUserId] = useState("");
-  const [targetRole, setTargetRole] = useState<Role>("user");
-  const [assignError, setAssignError] = useState<string | null>(null);
-  const [submitting, setSubmitting] = useState(false);
-
-  const [historyUserId, setHistoryUserId] = useState("");
-  const [history, setHistory] = useState<Assignment[] | null>(null);
-
-  useEffect(() => {
-    fetchRoles()
-      .then(setRoles)
-      .catch(() => setLoadError("Rollen konnten nicht geladen werden. Sind Sie als Tenant-Admin angemeldet?"));
-  }, []);
-
-  async function onAssign(event: React.FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    setAssignError(null);
-    setSubmitting(true);
-    try {
-      await assignRole(targetUserId, targetRole);
-      push("Rolle zugewiesen.", "success");
-    } catch (err) {
-      // Akzeptanzkriterium 2: die Backend-Meldung bei Selbst-Eskalation wird
-      // unveraendert angezeigt, keine eigene Interpretation im Frontend.
-      setAssignError(err instanceof ApiError ? err.message : "Rolle konnte nicht zugewiesen werden.");
-    } finally {
-      setSubmitting(false);
-    }
-  }
-
-  async function onLoadHistory(event: React.FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    try {
-      setHistory(await fetchRoleHistory(historyUserId));
-    } catch {
-      setHistory([]);
-    }
-  }
-
-  const historyColumns: TableColumn<Assignment>[] = [
-    { key: "role", header: "Rolle", render: (a) => a.Role },
-    { key: "grantedBy", header: "Vergeben von", render: (a) => a.GrantedBy },
-  ];
-
-  if (loadError) {
-    return (
-      <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
-        <p role="alert">{loadError}</p>
-      </main>
-    );
-  }
-
-  return (
-    <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
-      <h1>Rollen &amp; Rechte</h1>
-
-      <section aria-labelledby="rollen-heading">
-        <h2 id="rollen-heading">Rollen und Grundrechte</h2>
-        {roles?.map((r) => (
-          <div key={r.role} style={{ marginBottom: 12 }}>
-            <strong>{roleLabel(r.role)}</strong>
-            <ul>
-              {r.permissions.map((p) => (
-                <li key={p}>{p}</li>
-              ))}
-            </ul>
-          </div>
-        ))}
-      </section>
-
-      <section aria-labelledby="zuweisen-heading">
-        <h2 id="zuweisen-heading">Rolle zuweisen</h2>
-        <form onSubmit={onAssign} noValidate>
-          <TextField
-            label="Benutzer-ID"
-            required
-            value={targetUserId}
-            onChange={(e) => setTargetUserId(e.target.value)}
-          />
-          <SelectField label="Rolle" value={targetRole} onChange={(e) => setTargetRole(e.target.value as Role)}>
-            <option value="user">Benutzer</option>
-            <option value="tenant_admin">Tenant-Admin</option>
-          </SelectField>
-          {assignError && (
-            <p role="alert" style={{ color: "var(--shl-color-danger)" }}>
-              {assignError}
-            </p>
-          )}
-          <button type="submit" disabled={submitting}>
-            {submitting ? "Wird zugewiesen…" : "Zuweisen"}
-          </button>
-        </form>
-      </section>
-
-      <section aria-labelledby="verlauf-heading">
-        <h2 id="verlauf-heading">Nachvollziehbarkeit (Audit-Verlauf)</h2>
-        <p>Zeigt jede Rollenzuweisung eines Benutzers chronologisch — wer wann welche Rolle vergeben hat.</p>
-        <form onSubmit={onLoadHistory} noValidate>
-          <TextField
-            label="Benutzer-ID"
-            required
-            value={historyUserId}
-            onChange={(e) => setHistoryUserId(e.target.value)}
-          />
-          <button type="submit">Verlauf anzeigen</button>
-        </form>
-        {history && (
-          <Table
-            columns={historyColumns}
-            rows={history}
-            rowKey={(a) => `${a.UserID}-${a.Role}-${a.GrantedBy}`}
-            caption="Rollenzuweisungs-Verlauf"
-          />
-        )}
-      </section>
-    </main>
-  );
-}
-
-function roleLabel(role: Role): string {
-  return role === "tenant_admin" ? "Tenant-Admin" : "Benutzer";
-}

web/rbac-admin/lib/api.ts

@@ -1,68 +0,0 @@
-const API_BASE = process.env.NEXT_PUBLIC_CORE_API_BASE ?? "";
-
-export class ApiError extends Error {}
-
-async function req<T>(path: string, init?: RequestInit): Promise<T> {
-  const res = await fetch(`${API_BASE}${path}`, {
-    credentials: "include",
-    headers: init?.body ? { "Content-Type": "application/json" } : undefined,
-    ...init,
-  });
-  const data = await res.json().catch(() => ({}));
-  if (!res.ok) {
-    throw new ApiError(data.error ?? data.message ?? "Unbekannter Fehler");
-  }
-  return data as T;
-}
-
-export type Role = "user" | "tenant_admin";
-
-export interface RoleInfo {
-  role: Role;
-  permissions: string[];
-}
-
-export function fetchRoles(): Promise<RoleInfo[]> {
-  return req("/rbac/roles");
-}
-
-export interface Assignment {
-  UserID: string;
-  Role: Role;
-  GrantedBy: string;
-}
-
-export function assignRole(userId: string, role: Role): Promise<Assignment> {
-  return req("/rbac/users/role", { method: "POST", body: JSON.stringify({ user_id: userId, role }) });
-}
-
-export function fetchRoleHistory(userId: string): Promise<Assignment[]> {
-  return req(`/rbac/users/${userId}/history`);
-}
-
-export interface Group {
-  ID: string;
-  Name: string;
-  Role: Role | "";
-  members: string[];
-}
-
-export function fetchGroups(): Promise<Group[]> {
-  return req("/rbac/groups");
-}
-
-export function createGroup(name: string): Promise<Group> {
-  return req("/rbac/groups", { method: "POST", body: JSON.stringify({ name }) });
-}
-
-export function setGroupRole(groupId: string, role: Role): Promise<void> {
-  return req("/rbac/groups/role", { method: "POST", body: JSON.stringify({ group_id: groupId, role }) });
-}
-
-export function addGroupMember(groupId: string, userId: string): Promise<void> {
-  return req("/rbac/groups/members", { method: "POST", body: JSON.stringify({ group_id: groupId, user_id: userId }) });
-}
-
-export function removeGroupMember(groupId: string, userId: string): Promise<void> {
-  return req("/rbac/groups/members/remove", { method: "POST", body: JSON.stringify({ group_id: groupId, user_id: userId }) });
-}