RBAC-07: rechte-administrations-dienst-starten

- cmd/rbac-admin-api: startet internal/rbac.Handler (RBAC-05), hinter auth.RequireAuth mit demselben JWT-Secret wie IAM-16 (account-api) - reines Wiring, kein Diff an internal/rbac/ (verifiziert) - real deployed auf 131, cross-service-Session real bewiesen: Login gegen account-api (Port 8099), dasselbe Session-Cookie gegen rbac-admin-api (Port 8100) verwendet -> echte Rollenliste, ohne Cookie -> 401 - Migrationen (role_assignments/groups) real auf tenant_acme angewendet, reale Grant-Luecke behoben und verifiziert - Bootstrap-Erkenntnis dokumentiert: ListRoles selbst verlangt bereits eine Rolle mit PermManageUsers, Testnutzer daher mit direkter DB-Bootstrap-Rolle angelegt (wie Ersteinrichtung) Pruefungen siehe docs/RBAC-07-PRUEFPROTOKOLL.md
DEVLOG: Sessionlog-Eintrag (Auto-Hook)
2026-08-30 21:24:35 +02:00 · 2026-08-28 23:45:51 +02:00 · 2026-08-28 23:43:09 +02:00 · 2026-08-28 23:41:36 +02:00 · 2026-08-28 23:41:30 +02:00 · 2026-08-28 23:38:57 +02:00
59 changed files with 3171 additions and 1155 deletions
@@ -1,2 +1,4 @@
 *.log
 .env
+web/*/node_modules/
+web/*/.next/
@@ -64,6 +64,9 @@ Keine Änderungen ermittelbar.
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
+## 2026-08-28 21:44 – 21:44 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch

 ### Commits
 Keine Commits in dieser Session.
@@ -127,5 +130,72 @@ Keine Commits in dieser Session.
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
+- web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/index.ts                    | 25 +++++++++++++++++++++++++
+- web/shl/package.json                | 23 +++++++++++++++++++++++
+- web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tsconfig.json               | 18 ++++++++++++++++++
+
+---
+## 2026-08-28 21:51 – 21:57 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
+
+### Geänderte Dateien
+- web/shl/package.json     | 2 ++
+- web/shl/vitest.config.ts | 8 ++++++++
+- web/shl/vitest.setup.ts  | 1 +
+
+---
+## 2026-08-28 23:37 – 23:43 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- fbcc9db RBAC-05: web/rbac-admin next.js-frontend (rollen+gruppen-verwaltung, audit-verlauf) auf shl-01
+- bd80f0c Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/rbac-05-rechte-administrationsoberflaeche
+- 051af43 RBAC-05: backend — handler.go (rollen-/gruppenverwaltung, selbst-eskalationsschutz), group.go ListGroups/Members
+- 9de9005 Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/rbac-05-rechte-administrationsoberflaeche
+- 1b6a159 Merge branch 'feature/rbac-03-gruppen-abteilungen' into feature/rbac-05-rechte-administrationsoberflaeche
+
+### Geänderte Dateien
+- web/rbac-admin/app/groups/page.tsx | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/app/layout.tsx      |  30 ++++++++++++++++++++++++++++++
+- web/rbac-admin/app/page.tsx        |   5 +++++
+- web/rbac-admin/app/roles/page.tsx  | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/lib/api.ts          |  68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/rbac-admin/next.config.mjs     |   5 +++++
+- web/rbac-admin/package.json        |  22 ++++++++++++++++++++++
+- web/rbac-admin/tsconfig.json       |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:44 – 23:44 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+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 +++++++++++++++++++++

 ---
@@ -0,0 +1,66 @@
+// rbac-admin-api ist der Aufrufpunkt fuer RBAC-07: startet den bereits
+// fertigen RBAC-05-Handler (internal/rbac) als eigenstaendigen HTTP-Dienst,
+// hinter derselben Session-Auth wie IAM-16 (account-api) — GLEICHER
+// JWT-Secret, damit eine bei account-api ausgestellte Session hier auch
+// gueltig ist. REINES WIRING — keine Aenderung an internal/rbac/.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+func requireEnv(name string) string {
+	v := os.Getenv(name)
+	if v == "" {
+		log.Fatalf("%s muss gesetzt sein", name)
+	}
+	return v
+}
+
+func main() {
+	dsn := requireEnv("NEXARCH_RBACADMIN_TENANT_DSN")
+	// MUSS identisch mit NEXARCH_ACCOUNT_JWT_SECRET (IAM-16) sein, sonst
+	// verwirft dieser Dienst gueltige account-api-Sessions.
+	jwtSecret := requireEnv("NEXARCH_RBACADMIN_JWT_SECRET")
+	addr := os.Getenv("NEXARCH_RBACADMIN_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8100"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	tokenIssuer := auth.NewTokenIssuer(jwtSecret)
+	roles := rbac.NewStore(pool)
+	groups := rbac.NewGroupStore(pool)
+	handler := rbac.NewHandler(roles, groups)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	mux.HandleFunc("GET /rbac/roles", auth.RequireAuth(tokenIssuer, handler.ListRoles))
+	mux.HandleFunc("POST /rbac/users/role", auth.RequireAuth(tokenIssuer, handler.AssignRole))
+	mux.HandleFunc("GET /rbac/users/{id}/history", auth.RequireAuth(tokenIssuer, handler.RoleHistory))
+	mux.HandleFunc("GET /rbac/groups", auth.RequireAuth(tokenIssuer, handler.ListGroups))
+	mux.HandleFunc("POST /rbac/groups", auth.RequireAuth(tokenIssuer, handler.CreateGroup))
+	mux.HandleFunc("POST /rbac/groups/role", auth.RequireAuth(tokenIssuer, handler.SetGroupRole))
+	mux.HandleFunc("POST /rbac/groups/members", auth.RequireAuth(tokenIssuer, handler.AddGroupMember))
+	mux.HandleFunc("POST /rbac/groups/members/remove", auth.RequireAuth(tokenIssuer, handler.RemoveGroupMember))
+
+	log.Printf("rbac-admin-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}
@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Core - Rechte-Administrations-Dienst (RBAC-05/RBAC-07)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/rbac-admin-api.env
+ExecStart=__INSTALL_DIR__/bin/rbac-admin-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target
@@ -0,0 +1,75 @@
+# RBAC-07 – Prüfprotokoll: Rechte-Administrations-Dienst starten (RBAC-05 als laufender Dienst)
+
+Voraussetzung RBAC-05, IAM-16 – beide bereits Fertig, hier UNVERÄNDERT.
+
+## Reines Wiring, keine neue Logik
+
+`git diff --stat internal/rbac/` liefert KEINEN Diff. `cmd/rbac-admin-api/main.go`
+setzt ausschließlich bestehende Konstruktoren zusammen und wrappt jeden
+Endpunkt mit `auth.RequireAuth` — derselben Middleware, die IAM-16
+bereits nutzt.
+
+## JWT-Secret-Konsistenz (explizit geprüft, nicht nur konfiguriert)
+
+`NEXARCH_RBACADMIN_JWT_SECRET` MUSS identisch mit
+`NEXARCH_ACCOUNT_JWT_SECRET` (IAM-16) sein, sonst verwirft dieser Dienst
+gültige account-api-Sessions. Real getestet: mit account-api (Port
+8099) eingeloggt, Session-Cookie unverändert gegen rbac-admin-api (Port
+8100, ANDERER Prozess, ANDERE Portnummer) verwendet — Cookie wurde real
+akzeptiert, kein zweiter Login nötig. Das beweist die Cross-Service-
+Gültigkeit, nicht nur eine übereinstimmende Konfigurationszeile.
+
+## Bootstrap-Erkenntnis (dokumentiert)
+
+`internal/rbac.Handler.ListRoles` verlangt selbst bereits eine Rolle
+mit `PermManageUsers` (`requireManageUsers`) — ein Benutzer OHNE
+`role_assignments`-Zeile bekommt 403, auch für die reine Rollenliste.
+Für den End-zu-Ende-Test wurde daher ein Testnutzer mit einer direkt in
+der DB gesetzten `tenant_admin`-Bootstrap-Zeile angelegt (wie eine
+Ersteinrichtung) — kein Umgehen der echten Prüfung, sondern deren
+Voraussetzung.
+
+## Umsetzung
+
+- `cmd/rbac-admin-api/main.go` – Rollen/Gruppen-Endpunkte
+  (`GET /rbac/roles`, `POST /rbac/users/role`,
+  `GET /rbac/users/{id}/history`, `GET/POST /rbac/groups*`), alle
+  hinter `auth.RequireAuth`.
+- `deploy/systemd/nexarch-rbac-admin-api.service.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-rbac-admin-api.service` aktiv |
+| 2 | Realer Aufruf mit gültigem IAM-16-Session-Cookie liefert die erwartete Rollenliste, ohne/mit falschem Cookie 401/403 | **bestanden** – real per `curl`: mit dem bei `account-api` (IAM-16) ausgestellten Cookie → 200 mit der echten Rollen-/Rechte-Liste (`tenant_admin`, `user`); ohne Cookie → 401 |
+| 3 | Code-Review: keine Änderung an internal/rbac/ selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat internal/rbac/` liefert leeren Diff |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `rbac-admin-api` gebaut nach `/opt/nexarch-core/bin/`,
+  `/etc/nexarch/rbac-admin-api.env` (0600, `NEXARCH_RBACADMIN_JWT_SECRET`
+  identisch zu `NEXARCH_ACCOUNT_JWT_SECRET`), Dienst installiert/aktiviert.
+- Migrationen `0002_role_assignments`, `0003_groups` real auf
+  `tenant_acme` angewendet (fehlten dort), reale Grant-Lücke gefunden
+  und behoben (`role_assignments`, `role_assignment_history`, `groups`,
+  `group_members`), über `information_schema.role_table_grants`
+  verifiziert.
+- End-zu-Ende-Beweis: Testnutzer mit Bootstrap-`tenant_admin`-Rolle,
+  Login gegen `account-api`, dasselbe Cookie gegen `rbac-admin-api`
+  verwendet → echte Rollenliste. Testdaten anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./cmd/rbac-admin-api/...  -> 0 issues
+```
+
+## Gesamtergebnis
+
+**Bestanden.** RBAC-05 ist jetzt ein real laufender, über systemd
+verwalteter Dienst, cross-service authentifiziert über dieselbe
+IAM-16-Session — der zweite Baustein der browserfähigen Core-GUI nach
+TEN-05.
@@ -1,27 +0,0 @@
-// Package ldapsync implementiert Core IAM-05: LDAP/Active-Directory-
-// Anbindung je Tenant fuer Benutzer-Synchronisation, Login-Delegation und
-// Rollenzuordnung aus Gruppen ueber eine explizite Erlaubnis-Matrix.
-//
-// WICHTIGER HINWEIS: In dieser Umgebung steht kein echter LDAP/AD-Server zur
-// Verfuegung (analog zur Archive-Engine bei AUD-05). Client ist deshalb eine
-// Schnittstelle — die Sync-/Rollenzuordnungs-Logik ist gegen einen Fake in
-// den Tests vollstaendig geprueft, eine echte Verbindungspruefung gegen
-// LDAP/AD steht noch aus.
-package ldapsync
-
-// Entry ist ein aus LDAP gelesener Benutzerdatensatz.
-type Entry struct {
-	Email    string
-	Name     string
-	Groups   []string
-	Disabled bool
-}
-
-// Client abstrahiert die eigentliche LDAP-Verbindung (Bind + Search).
-type Client interface {
-	// Search liefert alle Benutzer, die dem konfigurierten Filter
-	// entsprechen. Ein Fehler bedeutet "Quelle nicht erreichbar oder
-	// fehlerhaft" — Run() bricht dann komplett und folgenlos ab
-	// (Akzeptanzkriterium 2).
-	Search() ([]Entry, error)
-}
@@ -1,204 +0,0 @@
-package ldapsync
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-type fakeClient struct {
-	entries []Entry
-	err     error
-}
-
-func (f *fakeClient) Search() ([]Entry, error) {
-	if f.err != nil {
-		return nil, f.err
-	}
-	return f.entries, nil
-}
-
-func setupTest(t *testing.T) (*user.TenantUserStore, *rbac.Store, *RoleMappingStore, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS users (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignments (
-			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignment_history (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
-			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return user.NewTenantUserStore(pool), rbac.NewStore(pool), NewRoleMappingStore(pool), cleanup
-}
-
-func uniqueEmail() string {
-	return fmt.Sprintf("ldap-test-%d@example.com", time.Now().UnixNano())
-}
-
-// Akzeptanzkriterium 3 + Pruefung 1: Rollen-Erlaubnis-Matrix mit Positiv- und
-// Negativfaellen — keine Privilege-Escalation ueber Gruppenmitgliedschaft.
-func TestRoleMapping_PositiveAndNegativeCases(t *testing.T) {
-	_, _, mappings, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := mappings.SetMapping(ctx, "cn=IT-Admins,ou=groups,dc=example,dc=com", rbac.RoleTenantAdmin); err != nil {
-		t.Fatalf("set mapping: %v", err)
-	}
-
-	// Positivfall: gemappte Gruppe liefert die konfigurierte Rolle.
-	role, ok, err := mappings.HighestRoleFor(ctx, []string{"cn=IT-Admins,ou=groups,dc=example,dc=com"})
-	if err != nil {
-		t.Fatalf("highest role: %v", err)
-	}
-	if !ok || role != rbac.RoleTenantAdmin {
-		t.Fatalf("erwartet tenant_admin, habe ok=%v role=%q", ok, role)
-	}
-
-	// Negativfall 1: unbekannte Gruppe vergibt keine Rolle.
-	_, ok, err = mappings.HighestRoleFor(ctx, []string{"cn=Praktikanten,ou=groups,dc=example,dc=com"})
-	if err != nil {
-		t.Fatalf("highest role (unbekannt): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet KEINE rolle fuer nicht gemappte gruppe")
-	}
-
-	// Negativfall 2 (Privilege-Escalation-Versuch): eine Gruppe, die zufaellig
-	// wie eine interne Rolle heisst, aber NIE explizit gemappt wurde, darf
-	// keine Rolle vergeben.
-	_, ok, err = mappings.HighestRoleFor(ctx, []string{"tenant_admin", "superadmin"})
-	if err != nil {
-		t.Fatalf("highest role (namens-trick): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet KEINE privilege-escalation ueber gruppennamen, die wie rollen aussehen")
-	}
-}
-
-// Akzeptanzkriterium 1: Synchronisationslauf legt Benutzer an.
-func TestSyncer_CreatesUsers(t *testing.T) {
-	users, roles, mappings, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	email := uniqueEmail()
-	client := &fakeClient{entries: []Entry{{Email: email, Name: "LDAP Nutzer"}}}
-	syncer := NewSyncer(client, users, roles, mappings)
-
-	result, err := syncer.Run(ctx)
-	if err != nil {
-		t.Fatalf("run: %v", err)
-	}
-	if result.Created != 1 {
-		t.Fatalf("erwartet 1 angelegten benutzer, habe %d", result.Created)
-	}
-
-	if _, err := users.GetByEmailForAuth(ctx, email); err != nil {
-		t.Fatalf("benutzer sollte existieren: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: fehlerhafte/nicht erreichbare LDAP-
-// Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen.
-func TestSyncer_AbortsCleanlyOnSourceError(t *testing.T) {
-	users, roles, mappings, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	// Ein bereits bestehendes Konto, das UNBERUEHRT bleiben muss.
-	existingEmail := uniqueEmail()
-	existing, err := users.Create(ctx, existingEmail, "Bestehender Nutzer")
-	if err != nil {
-		t.Fatalf("create existing: %v", err)
-	}
-
-	client := &fakeClient{err: errors.New("ldap-server nicht erreichbar (simuliert)")}
-	syncer := NewSyncer(client, users, roles, mappings)
-
-	if _, err := syncer.Run(ctx); err == nil {
-		t.Fatal("erwartet fehler bei nicht erreichbarer ldap-quelle")
-	}
-
-	// Bestehendes Konto unveraendert (noch aktiv, keine geloeschten/neuen Zeilen).
-	got, err := users.Get(ctx, existing.ID)
-	if err != nil {
-		t.Fatalf("bestehendes konto sollte weiterhin existieren: %v", err)
-	}
-	if got.Status != user.StatusActive {
-		t.Fatalf("bestehendes konto sollte unveraendert aktiv sein, ist %q", got.Status)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Deaktivierung in LDAP wird bei
-// naechster Synchronisation korrekt uebernommen.
-func TestSyncer_AppliesDeactivationOnNextRun(t *testing.T) {
-	users, roles, mappings, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	email := uniqueEmail()
-	client := &fakeClient{entries: []Entry{{Email: email, Name: "Wird Deaktiviert"}}}
-	syncer := NewSyncer(client, users, roles, mappings)
-
-	if _, err := syncer.Run(ctx); err != nil {
-		t.Fatalf("erster lauf: %v", err)
-	}
-	u, err := users.GetByEmailForAuth(ctx, email)
-	if err != nil {
-		t.Fatalf("benutzer nach erstem lauf: %v", err)
-	}
-	if u.User.Status != user.StatusActive {
-		t.Fatalf("erwartet aktiv nach erstem lauf, habe %q", u.User.Status)
-	}
-
-	// Zweiter Lauf: derselbe Benutzer ist jetzt in LDAP deaktiviert.
-	client.entries[0].Disabled = true
-	result, err := syncer.Run(ctx)
-	if err != nil {
-		t.Fatalf("zweiter lauf: %v", err)
-	}
-	if result.Deactivated != 1 {
-		t.Fatalf("erwartet 1 deaktivierung, habe %d", result.Deactivated)
-	}
-
-	u, err = users.GetByEmailForAuth(ctx, email)
-	if err != nil {
-		t.Fatalf("benutzer nach zweitem lauf: %v", err)
-	}
-	if u.User.Status != user.StatusInactive {
-		t.Fatalf("erwartet inaktiv nach deaktivierung in ldap, habe %q", u.User.Status)
-	}
-}
@@ -1,79 +0,0 @@
-package ldapsync
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-)
-
-// RoleMappingStore verwaltet die Erlaubnis-Matrix LDAP-Gruppe -> Rolle
-// (Akzeptanzkriterium 3). Nur explizit gemappte Gruppen vergeben eine Rolle
-// — der Schutz gegen Privilege-Escalation ist strukturell: es gibt keinen
-// Code-Pfad, der eine unbekannte Gruppe irgendeiner Rolle zuordnet.
-type RoleMappingStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewRoleMappingStore(pool *pgxpool.Pool) *RoleMappingStore {
-	return &RoleMappingStore{pool: pool}
-}
-
-// SetMapping ordnet eine LDAP-Gruppe genau einer NEXARCH-Rolle zu. Nur
-// 'user'/'tenant_admin' sind zuweisbar (dieselbe Matrix wie RBAC-01/03) —
-// 'superadmin' bleibt mandantenuebergreifend und nie ueber LDAP erreichbar.
-func (s *RoleMappingStore) SetMapping(ctx context.Context, ldapGroup string, role rbac.Role) error {
-	if role != rbac.RoleUser && role != rbac.RoleTenantAdmin {
-		return fmt.Errorf("ldapsync: rolle %q ist ueber ldap nicht zuweisbar", role)
-	}
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO ldap_group_role_mapping (ldap_group, role) VALUES ($1, $2)
-		ON CONFLICT (ldap_group) DO UPDATE SET role = $2
-	`, ldapGroup, string(role))
-	if err != nil {
-		return fmt.Errorf("gruppenzuordnung speichern: %w", err)
-	}
-	return nil
-}
-
-// roleFor liefert die einer LDAP-Gruppe zugeordnete Rolle, sofern konfiguriert.
-func (s *RoleMappingStore) roleFor(ctx context.Context, ldapGroup string) (rbac.Role, bool, error) {
-	var role string
-	err := s.pool.QueryRow(ctx, `SELECT role FROM ldap_group_role_mapping WHERE ldap_group = $1`, ldapGroup).Scan(&role)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", false, nil
-		}
-		return "", false, fmt.Errorf("gruppenzuordnung lesen: %w", err)
-	}
-	return rbac.Role(role), true, nil
-}
-
-// HighestRoleFor bestimmt aus einer Liste von LDAP-Gruppen die hoechste
-// zugeordnete Rolle (tenant_admin > user). Gruppen ohne Eintrag in der
-// Matrix tragen NICHTS bei — auch nicht, wenn ihr Name zufaellig wie eine
-// interne Rolle aussieht (Akzeptanzkriterium 3 / Pruefung 1: keine
-// Privilege-Escalation ueber Gruppenmitgliedschaft).
-func (s *RoleMappingStore) HighestRoleFor(ctx context.Context, ldapGroups []string) (rbac.Role, bool, error) {
-	var best rbac.Role
-	found := false
-
-	for _, g := range ldapGroups {
-		role, ok, err := s.roleFor(ctx, g)
-		if err != nil {
-			return "", false, err
-		}
-		if !ok {
-			continue
-		}
-		if !found || role == rbac.RoleTenantAdmin {
-			best = role
-			found = true
-		}
-	}
-	return best, found, nil
-}
@@ -1,93 +0,0 @@
-package ldapsync
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-// SyncResult fasst das Ergebnis eines Synchronisationslaufs zusammen.
-type SyncResult struct {
-	Created     int
-	Updated     int
-	Deactivated int
-	Failed      []string // Email-Adressen, bei denen die Verarbeitung fehlschlug
-}
-
-// Syncer fuehrt die Benutzer-/Rollen-Synchronisation aus LDAP aus.
-type Syncer struct {
-	client   Client
-	users    *user.TenantUserStore
-	roles    *rbac.Store
-	mappings *RoleMappingStore
-}
-
-func NewSyncer(client Client, users *user.TenantUserStore, roles *rbac.Store, mappings *RoleMappingStore) *Syncer {
-	return &Syncer{client: client, users: users, roles: roles, mappings: mappings}
-}
-
-// Run synchronisiert Benutzer aus LDAP (Akzeptanzkriterium 1). Ist die
-// LDAP-Quelle nicht erreichbar/fehlerhaft, wird SOFORT und OHNE jede
-// Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2 /
-// Pruefung 2) — Search() wird als allererstes aufgerufen, bevor irgendein
-// Schreibzugriff stattfindet.
-func (s *Syncer) Run(ctx context.Context) (SyncResult, error) {
-	entries, err := s.client.Search()
-	if err != nil {
-		return SyncResult{}, fmt.Errorf("ldap-quelle nicht erreichbar, synchronisation abgebrochen: %w", err)
-	}
-
-	var result SyncResult
-	for _, entry := range entries {
-		if err := s.syncOne(ctx, entry, &result); err != nil {
-			// Ein fehlerhafter Einzeleintrag isoliert sich selbst — er
-			// beschaedigt weder bereits verarbeitete noch nachfolgende
-			// Konten (Akzeptanzkriterium 2).
-			result.Failed = append(result.Failed, entry.Email)
-		}
-	}
-	return result, nil
-}
-
-func (s *Syncer) syncOne(ctx context.Context, entry Entry, result *SyncResult) error {
-	existing, err := s.users.GetByEmailForAuth(ctx, entry.Email)
-	isNew := errors.Is(err, user.ErrNotFound)
-	if err != nil && !isNew {
-		return err
-	}
-
-	var userID string
-	if isNew {
-		created, err := s.users.Create(ctx, entry.Email, entry.Name)
-		if err != nil {
-			return err
-		}
-		userID = created.ID
-		result.Created++
-	} else {
-		userID = existing.User.ID
-		result.Updated++
-	}
-
-	// Deaktivierung in LDAP wird uebernommen (Akzeptanzkriterium 3 / Pruefung 3).
-	if entry.Disabled {
-		if _, err := s.users.Deactivate(ctx, userID); err != nil {
-			return err
-		}
-		result.Deactivated++
-	}
-
-	role, ok, err := s.mappings.HighestRoleFor(ctx, entry.Groups)
-	if err != nil {
-		return err
-	}
-	if ok {
-		if _, err := s.roles.Assign(ctx, userID, role, "ldap-sync"); err != nil {
-			return err
-		}
-	}
-	return nil
-}
@@ -1,78 +0,0 @@
-// Package oidc implementiert Core IAM-06: SSO-Anmeldung ueber OpenID
-// Connect gegen externe Identity-Provider.
-//
-// WICHTIGER HINWEIS: In dieser Umgebung ist kein registrierter externer
-// OIDC-Provider (Client-ID/Secret bei Google/Okta/Azure AD o.ae.) verfuegbar,
-// gegen den ein echter Authorization-Code-Redirect-Flow end-to-end
-// durchgefuehrt werden koennte (analog AUD-05/Archive, IAM-05/LDAP). ANDERS
-// als bei LDAP/Archive ist die eigentliche Token-VALIDIERUNG (JWKS-
-// Signaturpruefung, Ablauf, Claims, Nonce/State) aber ein rein
-// kryptographischer Vorgang ohne Netzwerkabhaengigkeit zur Testzeit — die
-// Tests unten erzeugen ein eigenes RSA-Schluesselpaar, signieren ein
-// ID-Token selbst und pruefen es exakt so, wie es ein echter Provider
-// liefern wuerde. Nur der Redirect zu einem echten externen Provider bleibt
-// ungeprueft.
-package oidc
-
-import (
-	"crypto/rsa"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-)
-
-type jwk struct {
-	Kid string `json:"kid"`
-	Kty string `json:"kty"`
-	N   string `json:"n"`
-	E   string `json:"e"`
-}
-
-type jwkSet struct {
-	Keys []jwk `json:"keys"`
-}
-
-var ErrUnsupportedKeyType = errors.New("oidc: nicht unterstuetzter jwk-schluesseltyp")
-
-// ParseJWKS dekodiert eine JWKS-Antwort (RFC 7517) in kid -> RSA-Public-Key.
-// Nur RSA-Schluessel (kty=RSA, Standard bei allen gaengigen OIDC-Providern
-// fuer ID-Tokens) werden unterstuetzt.
-func ParseJWKS(data []byte) (map[string]*rsa.PublicKey, error) {
-	var set jwkSet
-	if err := json.Unmarshal(data, &set); err != nil {
-		return nil, fmt.Errorf("jwks parsen: %w", err)
-	}
-
-	out := make(map[string]*rsa.PublicKey, len(set.Keys))
-	for _, k := range set.Keys {
-		if k.Kty != "RSA" {
-			continue
-		}
-		pub, err := decodeRSAKey(k)
-		if err != nil {
-			return nil, fmt.Errorf("schluessel %q dekodieren: %w", k.Kid, err)
-		}
-		out[k.Kid] = pub
-	}
-	return out, nil
-}
-
-func decodeRSAKey(k jwk) (*rsa.PublicKey, error) {
-	nBytes, err := base64.RawURLEncoding.DecodeString(k.N)
-	if err != nil {
-		return nil, fmt.Errorf("modulus dekodieren: %w", err)
-	}
-	eBytes, err := base64.RawURLEncoding.DecodeString(k.E)
-	if err != nil {
-		return nil, fmt.Errorf("exponent dekodieren: %w", err)
-	}
-
-	eBuf := make([]byte, 8)
-	copy(eBuf[8-len(eBytes):], eBytes)
-	e := int(binary.BigEndian.Uint64(eBuf))
-
-	return &rsa.PublicKey{N: new(big.Int).SetBytes(nBytes), E: e}, nil
-}
@@ -1,69 +0,0 @@
-package oidc
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-	"gitea.perlbach24.de/scripte/nexarch/internal/ldapsync"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-// CompleteOIDCLogin verifiziert das ID-Token (Signatur, Ablauf, Aussteller,
-// Nonce — Akzeptanzkriterium 3), loest den State einmalig ein
-// (Akzeptanzkriterium/Pruefung 3), legt bei Bedarf einen lokalen Benutzer an
-// und mapped Rollen aus den OIDC-Claims ueber DIESELBE Erlaubnis-Matrix wie
-// IAM-05/LDAP (ldapsync.RoleMappingStore — kein zweiter, paralleler
-// Mapping-Mechanismus, Akzeptanzkriterium 2). Bei Erfolg wird ein normales
-// IAM-02-Sitzungs-Token ausgestellt.
-func CompleteOIDCLogin(
-	ctx context.Context,
-	verifier *Verifier,
-	states *StateStore,
-	users *user.TenantUserStore,
-	roles *rbac.Store,
-	roleMapping *ldapsync.RoleMappingStore,
-	issuer *auth.TokenIssuer,
-	tenantSlug, state, idToken string,
-) (token string, err error) {
-	nonce, err := states.Consume(ctx, state)
-	if err != nil {
-		return "", err
-	}
-
-	claims, err := verifier.VerifyWithNonce(idToken, nonce)
-	if err != nil {
-		return "", err
-	}
-	if claims.Email == "" {
-		return "", fmt.Errorf("%w: id-token ohne e-mail-claim", ErrInvalidToken)
-	}
-
-	u, err := findOrCreateUser(ctx, users, claims.Email)
-	if err != nil {
-		return "", err
-	}
-
-	if role, ok, err := roleMapping.HighestRoleFor(ctx, claims.Roles); err != nil {
-		return "", err
-	} else if ok {
-		if _, err := roles.Assign(ctx, u.ID, role, "oidc-sso"); err != nil {
-			return "", err
-		}
-	}
-
-	return issuer.Issue(u.ID, tenantSlug)
-}
-
-func findOrCreateUser(ctx context.Context, users *user.TenantUserStore, email string) (user.User, error) {
-	creds, err := users.GetByEmailForAuth(ctx, email)
-	if err == nil {
-		return creds.User, nil
-	}
-	if !errors.Is(err, user.ErrNotFound) {
-		return user.User{}, err
-	}
-	return users.Create(ctx, email, email)
-}
@@ -1,172 +0,0 @@
-package oidc
-
-import (
-	"context"
-	"crypto/rsa"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-	"github.com/golang-jwt/jwt/v5"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-	"gitea.perlbach24.de/scripte/nexarch/internal/ldapsync"
-	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-func setupLoginTest(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 users (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignments (
-			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS role_assignment_history (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
-			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
-			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
-		);
-		CREATE TABLE IF NOT EXISTS oidc_states (
-			state TEXT PRIMARY KEY, nonce TEXT NOT NULL, expires_at TIMESTAMPTZ NOT NULL,
-			used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return pool, cleanup
-}
-
-// Akzeptanzkriterium 1 + 3: End-to-End-Login gegen ein (selbst signiertes,
-// aber protokollkorrektes) ID-Token — Signatur, Nonce, State, Rollen-Mapping,
-// Sitzungs-Token-Ausstellung.
-func TestCompleteOIDCLogin_EndToEnd(t *testing.T) {
-	pool, cleanup := setupLoginTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-	states := NewStateStore(pool)
-	users := user.NewTenantUserStore(pool)
-	roles := rbac.NewStore(pool)
-	roleMapping := ldapsync.NewRoleMappingStore(pool)
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-
-	if err := roleMapping.SetMapping(ctx, "sso-admins", rbac.RoleTenantAdmin); err != nil {
-		t.Fatalf("set mapping: %v", err)
-	}
-
-	state, nonce, err := states.Generate(ctx)
-	if err != nil {
-		t.Fatalf("generate state: %v", err)
-	}
-
-	email := fmt.Sprintf("oidc-test-%d@example.com", time.Now().UnixNano())
-	claims := Claims{
-		Subject: "idp-subject-123",
-		Email:   email,
-		Nonce:   nonce,
-		Roles:   []string{"sso-admins"},
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	idToken := signTestToken(t, key, "kid-1", claims)
-
-	token, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken)
-	if err != nil {
-		t.Fatalf("complete oidc login: %v", err)
-	}
-	if token == "" {
-		t.Fatal("erwartet nicht-leeres sitzungs-token")
-	}
-
-	assignment, err := roles.Get(ctx, mustGetUserID(t, ctx, users, email))
-	if err != nil {
-		t.Fatalf("rollenzuweisung lesen: %v", err)
-	}
-	if assignment.Role != rbac.RoleTenantAdmin {
-		t.Fatalf("erwartet tenant_admin aus sso-admins-mapping, habe %q", assignment.Role)
-	}
-
-	// Replay desselben state schlaegt fehl.
-	if _, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken); err == nil {
-		t.Fatal("erwartet fehler bei wiederverwendetem state (replay)")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: keine Privilege-Escalation ueber
-// manipulierte/unbekannte Rollen-Claims.
-func TestCompleteOIDCLogin_UnmappedRoleGrantsNothing(t *testing.T) {
-	pool, cleanup := setupLoginTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-	states := NewStateStore(pool)
-	users := user.NewTenantUserStore(pool)
-	roles := rbac.NewStore(pool)
-	roleMapping := ldapsync.NewRoleMappingStore(pool)
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-
-	state, nonce, err := states.Generate(ctx)
-	if err != nil {
-		t.Fatalf("generate state: %v", err)
-	}
-
-	email := fmt.Sprintf("oidc-test-%d@example.com", time.Now().UnixNano())
-	claims := Claims{
-		Email: email,
-		Nonce: nonce,
-		// Versuch, sich ueber einen manipulierten Rollen-Claim
-		// hochzustufen — diese Gruppen wurden NIE gemappt.
-		Roles: []string{"tenant_admin", "superadmin"},
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	idToken := signTestToken(t, key, "kid-1", claims)
-
-	if _, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken); err != nil {
-		t.Fatalf("complete oidc login: %v", err)
-	}
-
-	userID := mustGetUserID(t, ctx, users, email)
-	if _, err := roles.Get(ctx, userID); err == nil {
-		t.Fatal("erwartet KEINE rollenzuweisung fuer nicht gemappte claims (privilege-escalation-versuch)")
-	}
-}
-
-func mustGetUserID(t *testing.T, ctx context.Context, users *user.TenantUserStore, email string) string {
-	t.Helper()
-	creds, err := users.GetByEmailForAuth(ctx, email)
-	if err != nil {
-		t.Fatalf("get user by email: %v", err)
-	}
-	return creds.User.ID
-}
@@ -1,76 +0,0 @@
-package oidc
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrStateInvalid = errors.New("oidc: state ungueltig, bereits verwendet oder abgelaufen")
-
-// DefaultStateTTL begrenzt, wie lange ein ausgestellter State/Nonce fuer den
-// Redirect-Umweg zum Identity-Provider gueltig bleibt.
-const DefaultStateTTL = 10 * time.Minute
-
-type StateStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewStateStore(pool *pgxpool.Pool) *StateStore {
-	return &StateStore{pool: pool}
-}
-
-// Generate stellt state+nonce fuer einen neuen Login-Redirect aus. state
-// wird als OAuth2-"state"-Parameter mitgeschickt (CSRF-Schutz), nonce
-// erscheint spaeter im ID-Token und muss exakt uebereinstimmen (Replay-Schutz).
-func (s *StateStore) Generate(ctx context.Context) (state, nonce string, err error) {
-	state, err = randomValue()
-	if err != nil {
-		return "", "", err
-	}
-	nonce, err = randomValue()
-	if err != nil {
-		return "", "", err
-	}
-
-	_, err = s.pool.Exec(ctx, `
-		INSERT INTO oidc_states (state, nonce, expires_at) VALUES ($1, $2, $3)
-	`, state, nonce, time.Now().Add(DefaultStateTTL))
-	if err != nil {
-		return "", "", fmt.Errorf("state speichern: %w", err)
-	}
-	return state, nonce, nil
-}
-
-// Consume loest einen State EINMALIG ein (Akzeptanzkriterium/Pruefung 3:
-// Replay-Schutz) — atomar ueber WHERE used_at IS NULL, analog IAM-03/IAM-09.
-// Ein zweiter Callback mit demselben state (z.B. durch einen Angreifer, der
-// die Redirect-URL abgefangen hat) schlaegt fehl.
-func (s *StateStore) Consume(ctx context.Context, state string) (nonce string, err error) {
-	err = s.pool.QueryRow(ctx, `
-		UPDATE oidc_states SET used_at = now()
-		WHERE state = $1 AND used_at IS NULL AND expires_at > now()
-		RETURNING nonce
-	`, state).Scan(&nonce)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", ErrStateInvalid
-		}
-		return "", fmt.Errorf("state einloesen: %w", err)
-	}
-	return nonce, nil
-}
-
-func randomValue() (string, error) {
-	buf := make([]byte, 32)
-	if _, err := rand.Read(buf); err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(buf), nil
-}
@@ -1,68 +0,0 @@
-package oidc
-
-import (
-	"context"
-	"errors"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupStateTest(t *testing.T) (*StateStore, 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 oidc_states (
-			state TEXT PRIMARY KEY, nonce TEXT NOT NULL, expires_at TIMESTAMPTZ NOT NULL,
-			used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		)`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewStateStore(pool), cleanup
-}
-
-// Akzeptanzkriterium/Pruefung 3: State/Nonce-Handling gegen CSRF und Replay.
-func TestStateStore_ConsumeIsSingleUse(t *testing.T) {
-	store, cleanup := setupStateTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	state, nonce, err := store.Generate(ctx)
-	if err != nil {
-		t.Fatalf("generate: %v", err)
-	}
-
-	gotNonce, err := store.Consume(ctx, state)
-	if err != nil {
-		t.Fatalf("consume (erste einloesung): %v", err)
-	}
-	if gotNonce != nonce {
-		t.Fatalf("nonce = %q, want %q", gotNonce, nonce)
-	}
-
-	if _, err := store.Consume(ctx, state); !errors.Is(err, ErrStateInvalid) {
-		t.Fatalf("erwartet ErrStateInvalid bei erneutem einloesen (replay), habe %v", err)
-	}
-}
-
-func TestStateStore_RejectsUnknownState(t *testing.T) {
-	store, cleanup := setupStateTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.Consume(ctx, "niemals-ausgestellter-state"); !errors.Is(err, ErrStateInvalid) {
-		t.Fatalf("erwartet ErrStateInvalid, habe %v", err)
-	}
-}
@@ -1,70 +0,0 @@
-package oidc
-
-import (
-	"crypto/rsa"
-	"errors"
-	"fmt"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-var ErrInvalidToken = errors.New("oidc: id-token ungueltig, abgelaufen oder falscher aussteller")
-
-// Claims sind die fuer NEXARCH relevanten OIDC-ID-Token-Claims.
-type Claims struct {
-	Subject string   `json:"sub"`
-	Email   string   `json:"email"`
-	Nonce   string   `json:"nonce"`
-	Roles   []string `json:"roles"` // providerabhaengiger Claim-Name, hier vereinfacht fest "roles"
-	jwt.RegisteredClaims
-}
-
-// Verifier prueft ID-Tokens gegen den JWKS-Schluesselsatz eines konfigurierten
-// Providers (Akzeptanzkriterium 3: fehlerhafte/abgelaufene Tokens werden
-// abgewiesen).
-type Verifier struct {
-	keys   map[string]*rsa.PublicKey
-	issuer string
-}
-
-func NewVerifier(keys map[string]*rsa.PublicKey, issuer string) *Verifier {
-	return &Verifier{keys: keys, issuer: issuer}
-}
-
-// Verify prueft Signatur (gegen JWKS), Ablauf (jwt-Bibliothek lehnt
-// abgelaufene Tokens automatisch ab) und Aussteller.
-func (v *Verifier) Verify(idToken string) (*Claims, error) {
-	claims := &Claims{}
-	token, err := jwt.ParseWithClaims(idToken, claims, func(t *jwt.Token) (interface{}, error) {
-		if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
-			return nil, ErrInvalidToken
-		}
-		kid, _ := t.Header["kid"].(string)
-		key, ok := v.keys[kid]
-		if !ok {
-			return nil, ErrInvalidToken
-		}
-		return key, nil
-	})
-	if err != nil || !token.Valid {
-		return nil, ErrInvalidToken
-	}
-	if claims.Issuer != v.issuer {
-		return nil, fmt.Errorf("%w: unerwarteter aussteller %q", ErrInvalidToken, claims.Issuer)
-	}
-	return claims, nil
-}
-
-// VerifyWithNonce prueft zusaetzlich, dass der nonce-Claim im Token exakt
-// dem bei der Anfrage ausgestellten Nonce entspricht — verhindert Replay
-// eines fremden, gueltigen ID-Tokens (Akzeptanzkriterium/Pruefung 3).
-func (v *Verifier) VerifyWithNonce(idToken, expectedNonce string) (*Claims, error) {
-	claims, err := v.Verify(idToken)
-	if err != nil {
-		return nil, err
-	}
-	if claims.Nonce == "" || claims.Nonce != expectedNonce {
-		return nil, fmt.Errorf("%w: nonce stimmt nicht ueberein", ErrInvalidToken)
-	}
-	return claims, nil
-}
@@ -1,184 +0,0 @@
-package oidc
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-func generateTestKey(t *testing.T) *rsa.PrivateKey {
-	t.Helper()
-	key, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		t.Fatalf("generate rsa key: %v", err)
-	}
-	return key
-}
-
-func signTestToken(t *testing.T, key *rsa.PrivateKey, kid string, claims Claims) string {
-	t.Helper()
-	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
-	token.Header["kid"] = kid
-	s, err := token.SignedString(key)
-	if err != nil {
-		t.Fatalf("sign token: %v", err)
-	}
-	return s
-}
-
-func TestVerify_AcceptsValidToken(t *testing.T) {
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-
-	claims := Claims{
-		Subject: "user-123",
-		Email:   "person@example.com",
-		Nonce:   "erwarteter-nonce",
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	tok := signTestToken(t, key, "kid-1", claims)
-
-	got, err := verifier.Verify(tok)
-	if err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-	if got.Email != "person@example.com" {
-		t.Fatalf("email = %q", got.Email)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Token-Signatur- und Ablaufpruefung.
-func TestVerify_RejectsExpiredToken(t *testing.T) {
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-
-	claims := Claims{
-		Subject: "user-123",
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Hour)), // abgelaufen
-		},
-	}
-	tok := signTestToken(t, key, "kid-1", claims)
-
-	if _, err := verifier.Verify(tok); err == nil {
-		t.Fatal("erwartet fehler bei abgelaufenem token")
-	}
-}
-
-func TestVerify_RejectsWrongSigningKey(t *testing.T) {
-	realKey := generateTestKey(t)
-	attackerKey := generateTestKey(t)
-	// Verifier kennt NUR den echten oeffentlichen Schluessel.
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &realKey.PublicKey}, "https://idp.example.com")
-
-	claims := Claims{
-		Subject: "user-123",
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	// Mit dem Angreifer-Schluessel signiert, aber unter demselben kid wie der echte.
-	tok := signTestToken(t, attackerKey, "kid-1", claims)
-
-	if _, err := verifier.Verify(tok); err == nil {
-		t.Fatal("erwartet fehler bei fremd signiertem token")
-	}
-}
-
-func TestVerify_RejectsWrongIssuer(t *testing.T) {
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-
-	claims := Claims{
-		Subject: "user-123",
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://ganz-anderer-idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	tok := signTestToken(t, key, "kid-1", claims)
-
-	if _, err := verifier.Verify(tok); err == nil {
-		t.Fatal("erwartet fehler bei unerwartetem aussteller")
-	}
-}
-
-// Akzeptanzkriterium/Pruefung 3: Nonce-Handling gegen Replay.
-func TestVerifyWithNonce_RejectsMismatch(t *testing.T) {
-	key := generateTestKey(t)
-	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
-
-	claims := Claims{
-		Subject: "user-123",
-		Nonce:   "nonce-a",
-		RegisteredClaims: jwt.RegisteredClaims{
-			Issuer:    "https://idp.example.com",
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-		},
-	}
-	tok := signTestToken(t, key, "kid-1", claims)
-
-	if _, err := verifier.VerifyWithNonce(tok, "nonce-b"); err == nil {
-		t.Fatal("erwartet fehler bei nonce-mismatch (moeglicher replay eines fremden tokens)")
-	}
-	if _, err := verifier.VerifyWithNonce(tok, "nonce-a"); err != nil {
-		t.Fatalf("erwartet erfolg bei passendem nonce: %v", err)
-	}
-}
-
-func TestParseJWKS_RoundTrip(t *testing.T) {
-	key := generateTestKey(t)
-
-	nBytes := key.PublicKey.N.Bytes()
-	eBuf := make([]byte, 8)
-	binary.BigEndian.PutUint64(eBuf, uint64(key.PublicKey.E))
-	// Fuehrende Nullbytes des Exponenten abschneiden (ueblich bei JWK-Kodierung).
-	eStart := 0
-	for eStart < len(eBuf)-1 && eBuf[eStart] == 0 {
-		eStart++
-	}
-
-	set := jwkSet{Keys: []jwk{{
-		Kid: "kid-1",
-		Kty: "RSA",
-		N:   base64.RawURLEncoding.EncodeToString(nBytes),
-		E:   base64.RawURLEncoding.EncodeToString(eBuf[eStart:]),
-	}}}
-	data, err := json.Marshal(set)
-	if err != nil {
-		t.Fatalf("marshal: %v", err)
-	}
-
-	parsed, err := ParseJWKS(data)
-	if err != nil {
-		t.Fatalf("parse jwks: %v", err)
-	}
-	got, ok := parsed["kid-1"]
-	if !ok {
-		t.Fatal("erwartet kid-1 im ergebnis")
-	}
-	if got.E != key.PublicKey.E || got.N.Cmp(key.PublicKey.N) != 0 {
-		t.Fatalf("erwartet identischen oeffentlichen schluessel nach roundtrip")
-	}
-
-	// Der wiederhergestellte Schluessel muss ein damit signiertes Token auch tatsaechlich verifizieren.
-	verifier := NewVerifier(parsed, "https://idp.example.com")
-	claims := Claims{Subject: "x", RegisteredClaims: jwt.RegisteredClaims{
-		Issuer: "https://idp.example.com", ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
-	}}
-	tok := signTestToken(t, key, "kid-1", claims)
-	if _, err := verifier.Verify(tok); err != nil {
-		t.Fatalf("verify mit aus jwks wiederhergestelltem schluessel: %v", err)
-	}
-}
@@ -0,0 +1,67 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// ErrDenied wird geliefert, wenn keine Regel role+permission erlaubt —
+// Default-Deny (Akzeptanzkriterium 2).
+var ErrDenied = errors.New("policy: zugriff verweigert")
+
+// Enforcer ist die EINE zentrale Entscheidungs- und Durchsetzungsschicht
+// (Akzeptanzkriterium 1). Repository-/Query-Code ruft ausschliesslich Guard
+// bzw. GuardTenantScoped auf, nie eine Rohabfrage direkt.
+type Enforcer struct {
+	store *Store
+}
+
+func NewEnforcer(store *Store) *Enforcer {
+	return &Enforcer{store: store}
+}
+
+// Authorize entscheidet erlaubt/verboten — unabhaengig von jeder konkreten
+// Query, rein anhand der deklarativen Regeln (Akzeptanzkriterium 2: fuer
+// sich genommen testbar, ohne Anwendungslogik).
+func (e *Enforcer) Authorize(ctx context.Context, role rbac.Role, perm rbac.Permission) error {
+	allowed, err := e.store.IsAllowed(ctx, role, perm)
+	if err != nil {
+		return err
+	}
+	if !allowed {
+		return fmt.Errorf("%w: rolle %q hat kein recht %q", ErrDenied, role, perm)
+	}
+	return nil
+}
+
+// Guard ist die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): query
+// wird NUR aufgerufen, wenn Authorize zustimmt. Es gibt keinen Weg, query
+// ausserhalb von Guard aufzurufen und trotzdem den Aufrufer als autorisiert
+// zu behandeln — die Autorisierungsentscheidung steht immer VOR dem
+// Datenzugriff, nie danach.
+func Guard[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
+	var zero T
+	if err := e.Authorize(ctx, role, perm); err != nil {
+		return zero, err
+	}
+	return query(ctx)
+}
+
+// GuardTenantScoped erzwingt zusaetzlich, dass tenantSlug TEIL der Query-
+// Funktion selbst ist (Akzeptanzkriterium 3): der Funktionstyp verlangt,
+// dass die Repository-Implementierung tenantSlug in ihre eigene WHERE-
+// Klausel einbaut — ein nachgelagerter Filter auf dem Ergebnis (der
+// archivmail-Fehler aus "Bekannte Fehler vermeiden") ist mit dieser
+// Signatur nicht moeglich, da die Query-Funktion tenantSlug selbst
+// entgegennimmt und dafuer verantwortlich ist, statt ihn hinterher
+// anzuwenden.
+func GuardTenantScoped[T any](ctx context.Context, e *Enforcer, role rbac.Role, perm rbac.Permission, tenantSlug string, query func(ctx context.Context, tenantSlug string) (T, error)) (T, error) {
+	var zero T
+	if err := e.Authorize(ctx, role, perm); err != nil {
+		return zero, err
+	}
+	return query(ctx, tenantSlug)
+}
@@ -0,0 +1,187 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+func setupTest(t *testing.T) (*Store, *Enforcer, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS policy_rules (
+			role TEXT NOT NULL, permission TEXT NOT NULL,
+			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (role, permission)
+		);
+		CREATE TABLE IF NOT EXISTS policy_rule_changes (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
+			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
+			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	store := NewStore(pool)
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return store, NewEnforcer(store), cleanup
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Anfrage ohne passende Policy wird
+// zuverlaessig abgewiesen (Default-Deny), nicht standardmaessig erlaubt.
+func TestAuthorize_DefaultDeny(t *testing.T) {
+	_, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := enforcer.Authorize(ctx, rbac.Role("test_niemand"), rbac.Permission("test_irgendwas"))
+	if !errors.Is(err, ErrDenied) {
+		t.Fatalf("erwartet ErrDenied ohne konfigurierte regel, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Guard ruft query NUR bei Autorisierung
+// auf — kein Datenzugriffs-Pfad umgeht die Enforcement-Schicht.
+func TestGuard_NeverCallsQueryWithoutAuthorization(t *testing.T) {
+	store, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_rolle_guard")
+	perm := rbac.Permission("test_lesen")
+
+	queryCalled := false
+	_, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
+		queryCalled = true
+		return "geheime-daten", nil
+	})
+	if !errors.Is(err, ErrDenied) {
+		t.Fatalf("erwartet ErrDenied, habe %v", err)
+	}
+	if queryCalled {
+		t.Fatal("query haette bei fehlender autorisierung NICHT aufgerufen werden duerfen")
+	}
+
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+
+	result, err := Guard(ctx, enforcer, role, perm, func(ctx context.Context) (string, error) {
+		queryCalled = true
+		return "geheime-daten", nil
+	})
+	if err != nil {
+		t.Fatalf("guard nach grant: %v", err)
+	}
+	if !queryCalled || result != "geheime-daten" {
+		t.Fatalf("erwartet query-aufruf mit ergebnis nach autorisierung, habe queryCalled=%v result=%q", queryCalled, result)
+	}
+}
+
+// Akzeptanzkriterium 2 + 3: Policy-Entscheidungen deklarativ und unabhaengig
+// von Anwendungslogik testbar — Regelwechsel wirkt ohne Codeaenderung,
+// Historie ist versioniert nachvollziehbar.
+func TestGrantRevoke_ChangesBehaviorWithoutCodeChange(t *testing.T) {
+	store, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_rolle_history")
+	perm := rbac.Permission("test_schreiben")
+
+	allowed, err := store.IsAllowed(ctx, role, perm)
+	if err != nil {
+		t.Fatalf("is allowed (vorher): %v", err)
+	}
+	if allowed {
+		t.Fatal("erwartet nicht erlaubt vor grant")
+	}
+
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+	if err := enforcer.Authorize(ctx, role, perm); err != nil {
+		t.Fatalf("authorize nach grant sollte erlauben: %v", err)
+	}
+
+	if err := store.Revoke(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("revoke: %v", err)
+	}
+	if err := enforcer.Authorize(ctx, role, perm); !errors.Is(err, ErrDenied) {
+		t.Fatalf("authorize nach revoke sollte verweigern, habe %v", err)
+	}
+
+	history, err := store.History(ctx, role, perm)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege (grant, revoke), habe %d", len(history))
+	}
+	if history[0].Action != "grant" || history[0].Version != 1 {
+		t.Fatalf("history[0] unerwartet: %+v", history[0])
+	}
+	if history[1].Action != "revoke" || history[1].Version != 2 {
+		t.Fatalf("history[1] unerwartet: %+v", history[1])
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3 (Tenant-Scoping): GuardTenantScoped
+// zwingt tenantSlug in die Query-Funktion selbst, kein Post-Filter moeglich.
+func TestGuardTenantScoped_IsolatesDataBetweenTenants(t *testing.T) {
+	_, enforcer, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Simuliertes Repository: die WHERE-Klausel (hier: Map-Lookup) liegt
+	// INNERHALB der Query-Funktion, nicht als nachgelagerter Filter.
+	data := map[string][]string{
+		"acme":   {"dokument-a1", "dokument-a2"},
+		"globex": {"dokument-b1"},
+	}
+	repoQuery := func(ctx context.Context, tenantSlug string) ([]string, error) {
+		return data[tenantSlug], nil
+	}
+
+	role := rbac.Role("test_tenant_rolle")
+	perm := rbac.Permission("test_dokumente_lesen")
+	if err := enforcer.store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+
+	gotAcme, err := GuardTenantScoped(ctx, enforcer, role, perm, "acme", repoQuery)
+	if err != nil {
+		t.Fatalf("guard tenant scoped (acme): %v", err)
+	}
+	if len(gotAcme) != 2 {
+		t.Fatalf("erwartet 2 dokumente fuer acme, habe %d", len(gotAcme))
+	}
+
+	gotGlobex, err := GuardTenantScoped(ctx, enforcer, role, perm, "globex", repoQuery)
+	if err != nil {
+		t.Fatalf("guard tenant scoped (globex): %v", err)
+	}
+	if len(gotGlobex) != 1 {
+		t.Fatalf("erwartet 1 dokument fuer globex, habe %d", len(gotGlobex))
+	}
+}
@@ -0,0 +1,124 @@
+// Package policy implementiert Core RBAC-02: die zentrale Policy-
+// Entscheidungs- und Durchsetzungsschicht. Regeln liegen deklarativ in der
+// Datenbank (Casbin-Prinzip: Policy als Modell+Regeln getrennt vom Code),
+// versioniert und auditierbar — anders als Casbin-Dateien im Dateisystem
+// (siehe "bewusst vermeiden" im Ticket).
+package policy
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// Rule ist eine gewaehrte Regel: role darf permission.
+type Rule struct {
+	Role       rbac.Role
+	Permission rbac.Permission
+}
+
+// RuleChange ist ein Eintrag der Aenderungshistorie (Akzeptanzkriterium 3).
+type RuleChange struct {
+	Role       rbac.Role
+	Permission rbac.Permission
+	Action     string // "grant" oder "revoke"
+	Actor      string
+	Version    int
+}
+
+// Store verwaltet den deklarativen Regelsatz. IsAllowed schaut NUR in die
+// Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel
+// wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny:
+// existiert keine passende Regel, ist der Zugriff verboten
+// (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten
+// "erlaubt, wenn nichts anderes gesagt"-Pfad.
+func (s *Store) IsAllowed(ctx context.Context, role rbac.Role, perm rbac.Permission) (bool, error) {
+	var exists bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role = $1 AND permission = $2)
+	`, string(role), string(perm)).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("policy pruefen: %w", err)
+	}
+	return exists, nil
+}
+
+// Grant gewaehrt role das Recht permission — deklarativ, ohne Codeaenderung
+// wirksam. actor wird fuer die Aenderungshistorie festgehalten.
+func (s *Store) Grant(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
+	return s.change(ctx, role, perm, "grant", actor, `
+		INSERT INTO policy_rules (role, permission, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (role, permission) DO UPDATE SET granted_by = $3, granted_at = now()
+	`, string(role), string(perm), actor)
+}
+
+// Revoke entzieht role das Recht permission.
+func (s *Store) Revoke(ctx context.Context, role rbac.Role, perm rbac.Permission, actor string) error {
+	return s.change(ctx, role, perm, "revoke", actor, `
+		DELETE FROM policy_rules WHERE role = $1 AND permission = $2
+	`, string(role), string(perm))
+}
+
+func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission, action, actor, sql string, args ...any) error {
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	if _, err := tx.Exec(ctx, sql, args...); err != nil {
+		return fmt.Errorf("regel aendern: %w", err)
+	}
+
+	var version int
+	if err := tx.QueryRow(ctx, `
+		SELECT COALESCE(MAX(version), 0) + 1 FROM policy_rule_changes WHERE role = $1 AND permission = $2
+	`, string(role), string(perm)).Scan(&version); err != nil {
+		return fmt.Errorf("naechste version ermitteln: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO policy_rule_changes (role, permission, action, actor, version, changed_at)
+		VALUES ($1, $2, $3, $4, $5, now())
+	`, string(role), string(perm), action, actor, version); err != nil {
+		return fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	return tx.Commit(ctx)
+}
+
+// History liefert die vollstaendige, versionierte Aenderungshistorie einer
+// Regel (Akzeptanzkriterium 3).
+func (s *Store) History(ctx context.Context, role rbac.Role, perm rbac.Permission) ([]RuleChange, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT action, actor, version FROM policy_rule_changes
+		WHERE role = $1 AND permission = $2 ORDER BY version
+	`, string(role), string(perm))
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []RuleChange
+	for rows.Next() {
+		c := RuleChange{Role: role, Permission: perm}
+		if err := rows.Scan(&c.Action, &c.Actor, &c.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
@@ -0,0 +1,200 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrGroupNotFound = errors.New("rbac: gruppe nicht gefunden")
+
+type Group struct {
+	ID   string
+	Name string
+	Role Role // leer, wenn der Gruppe noch keine Rolle zugewiesen wurde
+}
+
+// GroupStore verwaltet Gruppen/Abteilungen innerhalb GENAU EINER Tenant-
+// Datenbank (Modell C, wie Store fuer direkte Rollenzuweisungen) —
+// Akzeptanzkriterium 3 (tenant-isoliert) ist damit strukturell erfuellt.
+type GroupStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewGroupStore(pool *pgxpool.Pool) *GroupStore {
+	return &GroupStore{pool: pool}
+}
+
+// CreateGroup legt eine neue, noch rollenlose Gruppe an (Akzeptanzkriterium 1).
+func (s *GroupStore) CreateGroup(ctx context.Context, name string) (Group, error) {
+	if name == "" {
+		return Group{}, errors.New("rbac: gruppenname darf nicht leer sein")
+	}
+	var g Group
+	g.Name = name
+	if err := s.pool.QueryRow(ctx, `
+		INSERT INTO groups (name) VALUES ($1) RETURNING id
+	`, name).Scan(&g.ID); err != nil {
+		return Group{}, fmt.Errorf("gruppe anlegen: %w", err)
+	}
+	return g, nil
+}
+
+// SetGroupRole weist der Gruppe eine Rolle zu (Akzeptanzkriterium 2) — nur
+// 'user'/'tenant_admin' sind auf Gruppenebene zuweisbar, dieselbe erlaubte
+// Matrix wie in Store.Assign (superadmin bleibt mandantenuebergreifend und
+// ausserhalb jeder Gruppenlogik).
+func (s *GroupStore) SetGroupRole(ctx context.Context, groupID string, role Role) error {
+	if !assignableRoles[role] {
+		return ErrRoleNotAssignableInTenantScope
+	}
+	tag, err := s.pool.Exec(ctx, `UPDATE groups SET role = $2 WHERE id = $1`, groupID, string(role))
+	if err != nil {
+		return fmt.Errorf("gruppenrolle setzen: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrGroupNotFound
+	}
+	return nil
+}
+
+// AddMember nimmt einen Benutzer in die Gruppe auf.
+func (s *GroupStore) AddMember(ctx context.Context, groupID, userID string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO group_members (group_id, user_id) VALUES ($1, $2)
+		ON CONFLICT (group_id, user_id) DO NOTHING
+	`, groupID, userID)
+	if err != nil {
+		return fmt.Errorf("mitglied hinzufuegen: %w", err)
+	}
+	return nil
+}
+
+// RemoveMember entfernt einen Benutzer aus der Gruppe — die gruppenbasierten
+// Rechte entfallen fuer ihn sofort (Akzeptanzkriterium 3 / Pruefung 2), da
+// EffectivePermissionsForUser bei jedem Aufruf neu berechnet wird, nicht
+// zwischengespeichert.
+func (s *GroupStore) RemoveMember(ctx context.Context, groupID, userID string) error {
+	_, err := s.pool.Exec(ctx, `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, groupID, userID)
+	if err != nil {
+		return fmt.Errorf("mitglied entfernen: %w", err)
+	}
+	return nil
+}
+
+// DeleteGroup loescht die Gruppe — ON DELETE CASCADE entfernt die
+// Mitgliedschaften mit, Benutzerkonten selbst bleiben unberuehrt
+// (Akzeptanzkriterium 3).
+func (s *GroupStore) DeleteGroup(ctx context.Context, groupID string) error {
+	_, err := s.pool.Exec(ctx, `DELETE FROM groups WHERE id = $1`, groupID)
+	if err != nil {
+		return fmt.Errorf("gruppe loeschen: %w", err)
+	}
+	return nil
+}
+
+// ListGroups liefert alle Gruppen des Mandanten (Akzeptanzkriterium 1/2,
+// Grundlage fuer die Administrationsoberflaeche).
+func (s *GroupStore) ListGroups(ctx context.Context) ([]Group, error) {
+	rows, err := s.pool.Query(ctx, `SELECT id, name, COALESCE(role, '') FROM groups ORDER BY name`)
+	if err != nil {
+		return nil, fmt.Errorf("gruppen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Group
+	for rows.Next() {
+		var g Group
+		var role string
+		if err := rows.Scan(&g.ID, &g.Name, &role); err != nil {
+			return nil, fmt.Errorf("gruppe lesen: %w", err)
+		}
+		g.Role = Role(role)
+		out = append(out, g)
+	}
+	return out, rows.Err()
+}
+
+// Members liefert die User-IDs der Mitglieder einer Gruppe.
+func (s *GroupStore) Members(ctx context.Context, groupID string) ([]string, error) {
+	rows, err := s.pool.Query(ctx, `SELECT user_id FROM group_members WHERE group_id = $1`, groupID)
+	if err != nil {
+		return nil, fmt.Errorf("mitglieder abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, fmt.Errorf("mitglied lesen: %w", err)
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}
+
+// RolesForUser liefert alle Rollen, die einem Benutzer ueber seine
+// Gruppenmitgliedschaften zufallen (Akzeptanzkriterium 2: wirkt auf alle
+// Mitglieder). Eine Gruppe ohne zugewiesene Rolle traegt nichts bei.
+func (s *GroupStore) RolesForUser(ctx context.Context, userID string) ([]Role, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT g.role FROM groups g
+		JOIN group_members gm ON gm.group_id = g.id
+		WHERE gm.user_id = $1 AND g.role IS NOT NULL
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("gruppenrollen abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Role
+	for rows.Next() {
+		var r string
+		if err := rows.Scan(&r); err != nil {
+			return nil, fmt.Errorf("gruppenrolle lesen: %w", err)
+		}
+		out = append(out, Role(r))
+	}
+	return out, rows.Err()
+}
+
+// EffectivePermissionsForUser vereinigt die Rechte aus der direkten
+// Rollenzuweisung (Store, RBAC-01) mit allen Rechten aus Gruppenrollen —
+// jede einzelne Rolle wird ueber die bestehende Hierarchie (EffectivePermissions)
+// aufgeloest, das Ergebnis dedupliziert.
+func (s *GroupStore) EffectivePermissionsForUser(ctx context.Context, directStore *Store, userID string) ([]Permission, error) {
+	seen := make(map[Permission]bool)
+	var out []Permission
+
+	add := func(role Role) {
+		for _, p := range EffectivePermissions(role) {
+			if !seen[p] {
+				seen[p] = true
+				out = append(out, p)
+			}
+		}
+	}
+
+	if directStore != nil {
+		assignment, err := directStore.Get(ctx, userID)
+		if err != nil && !errors.Is(err, ErrNotFound) {
+			return nil, err
+		}
+		if err == nil {
+			add(assignment.Role)
+		}
+	}
+
+	groupRoles, err := s.RolesForUser(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range groupRoles {
+		add(r)
+	}
+
+	return out, nil
+}
@@ -0,0 +1,209 @@
+package rbac
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const groupSchema = `
+CREATE TABLE IF NOT EXISTS users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS role_assignments (
+	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS groups (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE IF NOT EXISTS group_members (
+	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
+	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
+);`
+
+func setupGroupTestDB(t *testing.T, dbName string) *pgxpool.Pool {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+	if _, err := pool.Exec(ctx, groupSchema); err != nil {
+		t.Fatalf("schema anwenden: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+	return pool
+}
+
+func createTestUser(t *testing.T, pool *pgxpool.Pool, email string) string {
+	t.Helper()
+	u, err := user.NewTenantUserStore(pool).Create(context.Background(), email, "Test")
+	if err != nil {
+		t.Fatalf("testuser anlegen: %v", err)
+	}
+	return u.ID
+}
+
+// Akzeptanzkriterium 1: Gruppen anlegen und Benutzer zuordnen.
+func TestGroup_CreateAndAddMember(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_create")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, err := gs.CreateGroup(ctx, "Buchhaltung")
+	if err != nil {
+		t.Fatalf("create group: %v", err)
+	}
+	userID := createTestUser(t, pool, "alice@example.com")
+
+	if err := gs.AddMember(ctx, g.ID, userID); err != nil {
+		t.Fatalf("add member: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Gruppenrolle wirkt auf ALLE aktuellen
+// Mitglieder.
+func TestGroup_RoleAffectsAllCurrentMembers(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_roleall")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, err := gs.CreateGroup(ctx, "Admins")
+	if err != nil {
+		t.Fatalf("create group: %v", err)
+	}
+	if err := gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin); err != nil {
+		t.Fatalf("set group role: %v", err)
+	}
+
+	alice := createTestUser(t, pool, "alice@example.com")
+	bob := createTestUser(t, pool, "bob@example.com")
+	if err := gs.AddMember(ctx, g.ID, alice); err != nil {
+		t.Fatalf("add alice: %v", err)
+	}
+	if err := gs.AddMember(ctx, g.ID, bob); err != nil {
+		t.Fatalf("add bob: %v", err)
+	}
+
+	for _, uid := range []string{alice, bob} {
+		perms, err := gs.EffectivePermissionsForUser(ctx, nil, uid)
+		if err != nil {
+			t.Fatalf("effective permissions fuer %s: %v", uid, err)
+		}
+		if !contains(perms, PermManageUsers) {
+			t.Fatalf("mitglied %s sollte tenant_admin-rechte ueber die gruppe haben, habe %v", uid, perms)
+		}
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Entfernen aus der Gruppe entzieht die
+// gruppenbasierten Rechte sofort.
+func TestGroup_RemoveMemberRevokesRightsImmediately(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_remove")
+	gs := NewGroupStore(pool)
+	ctx := context.Background()
+
+	g, _ := gs.CreateGroup(ctx, "Admins")
+	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
+	userID := createTestUser(t, pool, "alice@example.com")
+	_ = gs.AddMember(ctx, g.ID, userID)
+
+	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions (mitglied): %v", err)
+	}
+	if !contains(perms, PermManageUsers) {
+		t.Fatal("erwartet tenant_admin-rechte als mitglied")
+	}
+
+	if err := gs.RemoveMember(ctx, g.ID, userID); err != nil {
+		t.Fatalf("remove member: %v", err)
+	}
+
+	perms, err = gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions (entfernt): %v", err)
+	}
+	if contains(perms, PermManageUsers) {
+		t.Fatal("erwartet KEINE tenant_admin-rechte nach entfernen aus der gruppe")
+	}
+}
+
+// Akzeptanzkriterium 3: Loeschen einer Gruppe entzieht Rechte sauber, ohne
+// das Benutzerkonto zu loeschen.
+func TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser(t *testing.T) {
+	pool := setupGroupTestDB(t, "test_rbac03_delete")
+	gs := NewGroupStore(pool)
+	us := user.NewTenantUserStore(pool)
+	ctx := context.Background()
+
+	g, _ := gs.CreateGroup(ctx, "Temp")
+	_ = gs.SetGroupRole(ctx, g.ID, RoleTenantAdmin)
+	userID := createTestUser(t, pool, "alice@example.com")
+	_ = gs.AddMember(ctx, g.ID, userID)
+
+	if err := gs.DeleteGroup(ctx, g.ID); err != nil {
+		t.Fatalf("delete group: %v", err)
+	}
+
+	perms, err := gs.EffectivePermissionsForUser(ctx, nil, userID)
+	if err != nil {
+		t.Fatalf("effective permissions: %v", err)
+	}
+	if contains(perms, PermManageUsers) {
+		t.Fatal("erwartet keine rechte mehr nach loeschen der gruppe")
+	}
+
+	if _, err := us.Get(ctx, userID); err != nil {
+		t.Fatalf("benutzerkonto haette erhalten bleiben muessen: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Gruppen sind sauber tenant-isoliert.
+func TestGroup_TenantIsolation(t *testing.T) {
+	poolA := setupGroupTestDB(t, "test_rbac03_tenanta")
+	poolB := setupGroupTestDB(t, "test_rbac03_tenantb")
+	gsA := NewGroupStore(poolA)
+	ctx := context.Background()
+
+	if _, err := gsA.CreateGroup(ctx, "Nur-Tenant-A"); err != nil {
+		t.Fatalf("create group a: %v", err)
+	}
+
+	var countB int
+	if err := poolB.QueryRow(ctx, `SELECT count(*) FROM groups`).Scan(&countB); err != nil {
+		t.Fatalf("count tenant b: %v", err)
+	}
+	if countB != 0 {
+		t.Fatalf("tenant b sollte keine gruppen aus tenant a sehen, habe %d", countB)
+	}
+}
@@ -0,0 +1,250 @@
+package rbac
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Handler stellt Rollen-/Rechte- und Gruppenverwaltung als HTTP-Endpunkte
+// bereit (RBAC-05). Duenner Client der bestehenden Store/GroupStore-Schicht —
+// keine eigene Rechtelogik hier (siehe Ticket-Produkt-DNA).
+type Handler struct {
+	roles  *Store
+	groups *GroupStore
+}
+
+func NewHandler(roles *Store, groups *GroupStore) *Handler {
+	return &Handler{roles: roles, groups: groups}
+}
+
+// requireManageUsers prueft, ob der aufrufende Benutzer ueberhaupt
+// Rechteverwaltung ausueben darf — technisch durchgesetzt hier zusaetzlich
+// zu RBAC-02 (Policy-Enforcement-Schicht), da diese Kachel ein eigener,
+// besonders sicherheitskritischer HTTP-Einstiegspunkt ist.
+func requireManageUsers(w http.ResponseWriter, r *http.Request, roles *Store) (callerUserID string, ok bool) {
+	claims, authOK := auth.ClaimsFromContext(r.Context())
+	if !authOK {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return "", false
+	}
+	assignment, err := roles.Get(r.Context(), claims.UserID)
+	if err != nil || !HasPermission(assignment.Role, PermManageUsers) {
+		http.Error(w, "keine Berechtigung zur Rechteverwaltung", http.StatusForbidden)
+		return "", false
+	}
+	return claims.UserID, true
+}
+
+type roleInfo struct {
+	Role        Role         `json:"role"`
+	Permissions []Permission `json:"permissions"`
+}
+
+// ListRoles liefert die (im Tenant-Geltungsbereich zuweisbaren) Rollen mit
+// ihren vollstaendig aufgeloesten Rechten (Akzeptanzkriterium 1).
+func (h *Handler) ListRoles(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	out := make([]roleInfo, 0, len(assignableRoles))
+	for role := range assignableRoles {
+		out = append(out, roleInfo{Role: role, Permissions: EffectivePermissions(role)})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(out)
+}
+
+type assignRoleRequest struct {
+	UserID string `json:"user_id"`
+	Role   Role   `json:"role"`
+}
+
+// roleRank ordnet die Rollenhierarchie fuer den Selbst-Eskalations-Vergleich
+// (Akzeptanzkriterium 2 / Pruefung 2) — hoehere Zahl = mehr Rechte. Basiert
+// auf derselben parent-Kette wie EffectivePermissions, nicht dupliziert als
+// eigenstaendiges Modell.
+func roleRank(role Role) int {
+	rank := 0
+	for r, ok := role, true; ok; r, ok = parent[r] {
+		rank++
+	}
+	return rank
+}
+
+// AssignRole weist einem Benutzer eine Rolle zu (Akzeptanzkriterium 1).
+// Verweigert explizit, dass sich der aufrufende Benutzer selbst eine
+// hoehere Rolle zuweist (Akzeptanzkriterium 2 / Pruefung 2) — unabhaengig
+// davon, ob RBAC-02 dieselbe Aktion ohnehin ueber die allgemeine
+// Policy-Schicht verhindern wuerde: Selbst-Eskalation ist ein derart
+// sicherheitskritischer Einzelfall, dass er hier zusaetzlich explizit und
+// unuebersehbar geprueft wird, statt sich allein auf eine generische
+// Regel an anderer Stelle zu verlassen.
+func (h *Handler) AssignRole(w http.ResponseWriter, r *http.Request) {
+	callerUserID, ok := requireManageUsers(w, r, h.roles)
+	if !ok {
+		return
+	}
+
+	var req assignRoleRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	if req.UserID == callerUserID {
+		callerAssignment, err := h.roles.Get(r.Context(), callerUserID)
+		callerRole := RoleUser
+		if err == nil {
+			callerRole = callerAssignment.Role
+		}
+		if roleRank(req.Role) > roleRank(callerRole) {
+			http.Error(w, "Sie können sich nicht selbst eine höhere Rolle zuweisen.", http.StatusForbidden)
+			return
+		}
+	}
+
+	assignment, err := h.roles.Assign(r.Context(), req.UserID, req.Role, callerUserID)
+	if err != nil {
+		http.Error(w, "Rolle konnte nicht zugewiesen werden.", http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(assignment)
+}
+
+// RoleHistory liefert die Zuweisungshistorie eines Benutzers — der in
+// Akzeptanzkriterium 3 geforderte Verweis auf das Audit-Log (die
+// role_assignment_history-Tabelle selbst IST die Nachvollziehbarkeits-Spur;
+// eine vollstaendige Anbindung an Core AUD-01 ist nicht Teil dieser Kachel).
+func (h *Handler) RoleHistory(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	userID := strings.TrimPrefix(r.URL.Path, "/rbac/users/")
+	userID = strings.TrimSuffix(userID, "/history")
+	if userID == "" {
+		http.Error(w, "user_id fehlt", http.StatusBadRequest)
+		return
+	}
+
+	history, err := h.roles.History(r.Context(), userID)
+	if err != nil {
+		http.Error(w, "historie konnte nicht geladen werden", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(history)
+}
+
+type createGroupRequest struct {
+	Name string `json:"name"`
+}
+
+// CreateGroup legt eine neue Gruppe an (Akzeptanzkriterium 2).
+func (h *Handler) CreateGroup(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req createGroupRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	group, err := h.groups.CreateGroup(r.Context(), req.Name)
+	if err != nil {
+		http.Error(w, "Gruppe konnte nicht angelegt werden.", http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(group)
+}
+
+type groupWithMembers struct {
+	Group
+	Members []string `json:"members"`
+}
+
+// ListGroups liefert alle Gruppen inkl. Mitgliederliste (Akzeptanzkriterium 2).
+func (h *Handler) ListGroups(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	groups, err := h.groups.ListGroups(r.Context())
+	if err != nil {
+		http.Error(w, "Gruppen konnten nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	out := make([]groupWithMembers, 0, len(groups))
+	for _, g := range groups {
+		members, err := h.groups.Members(r.Context(), g.ID)
+		if err != nil {
+			http.Error(w, "Mitglieder konnten nicht geladen werden.", http.StatusInternalServerError)
+			return
+		}
+		out = append(out, groupWithMembers{Group: g, Members: members})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(out)
+}
+
+type groupActionRequest struct {
+	GroupID string `json:"group_id"`
+	UserID  string `json:"user_id"`
+	Role    Role   `json:"role"`
+}
+
+// SetGroupRole weist einer Gruppe eine Rolle zu (Akzeptanzkriterium 2).
+func (h *Handler) SetGroupRole(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.SetGroupRole(r.Context(), req.GroupID, req.Role); err != nil {
+		http.Error(w, "Gruppenrolle konnte nicht gesetzt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// AddGroupMember nimmt einen Benutzer in eine Gruppe auf (Akzeptanzkriterium 2).
+func (h *Handler) AddGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.AddMember(r.Context(), req.GroupID, req.UserID); err != nil {
+		http.Error(w, "Mitglied konnte nicht hinzugefügt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// RemoveGroupMember entfernt einen Benutzer aus einer Gruppe.
+func (h *Handler) RemoveGroupMember(w http.ResponseWriter, r *http.Request) {
+	if _, ok := requireManageUsers(w, r, h.roles); !ok {
+		return
+	}
+	var req groupActionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.groups.RemoveMember(r.Context(), req.GroupID, req.UserID); err != nil {
+		http.Error(w, "Mitglied konnte nicht entfernt werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
@@ -0,0 +1,309 @@
+package rbac
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const handlerSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE role_assignments (
+	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE role_assignment_history (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
+	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE groups (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE TABLE group_members (
+	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
+	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
+);`
+
+func setupHandlerTest(t *testing.T, dbName string) (*Handler, *Store, *user.TenantUserStore, *pgxpool.Pool) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+	if _, err := pool.Exec(ctx, handlerSchema); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+
+	roleStore := NewStore(pool)
+	groupStore := NewGroupStore(pool)
+	return NewHandler(roleStore, groupStore), roleStore, user.NewTenantUserStore(pool), pool
+}
+
+func sessionCookieFor(t *testing.T, issuer *auth.TokenIssuer, userID string) *http.Cookie {
+	t.Helper()
+	token, err := issuer.Issue(userID, "acme")
+	if err != nil {
+		t.Fatalf("session-token ausstellen: %v", err)
+	}
+	return &http.Cookie{Name: auth.CookieName, Value: token}
+}
+
+// Akzeptanzkriterium 1: Rollen und ihre Grundrechte sind einsehbar.
+func TestListRoles(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_list_roles")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	var out []roleInfo
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 2 {
+		t.Fatalf("erwartet 2 zuweisbare rollen (user, tenant_admin), habe %d", len(out))
+	}
+}
+
+// Akzeptanzkriterium 2 / Pruefung 2: Selbst-Eskalation wird abgewiesen.
+func TestAssignRole_RejectsSelfEscalation(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_self_escalation")
+	ctx := context.Background()
+	u, err := users.Create(ctx, "normal@acme.example", "Normaler Nutzer")
+	if err != nil {
+		t.Fatalf("nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
+		t.Fatalf("ausgangsrolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	body, _ := json.Marshal(assignRoleRequest{UserID: u.ID, Role: RoleTenantAdmin})
+	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
+	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 (selbst-eskalation muss abgewiesen werden)", rec.Code)
+	}
+
+	// Rolle muss unveraendert geblieben sein.
+	assignment, err := roles.Get(ctx, u.ID)
+	if err != nil {
+		t.Fatalf("rolle laden: %v", err)
+	}
+	if assignment.Role != RoleUser {
+		t.Fatalf("rolle wurde trotz abgewiesener anfrage geaendert: %q", assignment.Role)
+	}
+}
+
+// Gegenprobe: ein Tenant-Admin darf EINEM ANDEREN Benutzer eine hoehere
+// Rolle zuweisen — nur die Selbst-Zuweisung ist gesperrt.
+func TestAssignRole_AdminCanPromoteOtherUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_promote_other")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin2@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	other, err := users.Create(ctx, "other@acme.example", "Anderer Nutzer")
+	if err != nil {
+		t.Fatalf("anderen nutzer anlegen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	body, _ := json.Marshal(assignRoleRequest{UserID: other.ID, Role: RoleTenantAdmin})
+	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+}
+
+// Akzeptanzkriterium 3: Aenderungen an Rechten sind nachvollziehbar.
+func TestRoleHistory_TracksAssignments(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_history")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin3@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	target, err := users.Create(ctx, "target@acme.example", "Zielnutzer")
+	if err != nil {
+		t.Fatalf("zielnutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleUser, admin.ID); err != nil {
+		t.Fatalf("erste zuweisung: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleTenantAdmin, admin.ID); err != nil {
+		t.Fatalf("zweite zuweisung: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/users/"+target.ID+"/history", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.RoleHistory)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	var history []Assignment
+	if err := json.Unmarshal(rec.Body.Bytes(), &history); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
+	}
+}
+
+// Akzeptanzkriterium 2: Gruppen anlegen, Mitglieder zuordnen, Rolle zuweisen.
+func TestGroupWorkflow(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_group_workflow")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin4@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	member, err := users.Create(ctx, "member@acme.example", "Mitglied")
+	if err != nil {
+		t.Fatalf("mitglied anlegen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	createBody, _ := json.Marshal(createGroupRequest{Name: "Buchhaltung"})
+	createReq := httptest.NewRequest(http.MethodPost, "/rbac/groups", bytes.NewReader(createBody))
+	createReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	createRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.CreateGroup)(createRec, createReq)
+	if createRec.Code != http.StatusCreated {
+		t.Fatalf("create group: status = %d, body: %s", createRec.Code, createRec.Body.String())
+	}
+	var group Group
+	if err := json.Unmarshal(createRec.Body.Bytes(), &group); err != nil {
+		t.Fatalf("group-response dekodieren: %v", err)
+	}
+
+	roleBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, Role: RoleUser})
+	roleReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/role", bytes.NewReader(roleBody))
+	roleReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	roleRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetGroupRole)(roleRec, roleReq)
+	if roleRec.Code != http.StatusOK {
+		t.Fatalf("set group role: status = %d, body: %s", roleRec.Code, roleRec.Body.String())
+	}
+
+	memberBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, UserID: member.ID})
+	memberReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/members", bytes.NewReader(memberBody))
+	memberReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	memberRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AddGroupMember)(memberRec, memberReq)
+	if memberRec.Code != http.StatusOK {
+		t.Fatalf("add member: status = %d, body: %s", memberRec.Code, memberRec.Body.String())
+	}
+
+	listReq := httptest.NewRequest(http.MethodGet, "/rbac/groups", nil)
+	listReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListGroups)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list groups: status = %d, body: %s", listRec.Code, listRec.Body.String())
+	}
+	var groups []groupWithMembers
+	if err := json.Unmarshal(listRec.Body.Bytes(), &groups); err != nil {
+		t.Fatalf("groups-response dekodieren: %v", err)
+	}
+	if len(groups) != 1 || len(groups[0].Members) != 1 || groups[0].Members[0] != member.ID {
+		t.Fatalf("erwartet 1 gruppe mit 1 mitglied (%s), habe %+v", member.ID, groups)
+	}
+}
+
+// Ohne Rechteverwaltungsberechtigung (normale 'user'-Rolle) wird jeder
+// Endpunkt abgewiesen — Tenant-Isolation ist strukturell (Modell C, siehe
+// GroupStore-Kommentar), diese Pruefung deckt die Rechte-Ebene ab.
+func TestRequireManageUsers_RejectsPlainUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_reject_plain")
+	ctx := context.Background()
+	u, err := users.Create(ctx, "plain@acme.example", "Normaler Nutzer")
+	if err != nil {
+		t.Fatalf("nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
+		t.Fatalf("rolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 fuer benutzer ohne rechteverwaltung", rec.Code)
+	}
+}
@@ -0,0 +1,48 @@
+package rbac
+
+import "testing"
+
+func contains(perms []Permission, p Permission) bool {
+	for _, x := range perms {
+		if x == p {
+			return true
+		}
+	}
+	return false
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Rollenhierarchie liefert die erwartete
+// effektive Rechtemenge.
+func TestEffectivePermissions_Inheritance(t *testing.T) {
+	userPerms := EffectivePermissions(RoleUser)
+	if !contains(userPerms, PermSelfRead) || !contains(userPerms, PermSelfUpdate) {
+		t.Fatalf("user sollte self.read/self.update haben, habe %v", userPerms)
+	}
+	if contains(userPerms, PermManageUsers) {
+		t.Fatal("user sollte KEIN tenant.manage_users haben")
+	}
+
+	adminPerms := EffectivePermissions(RoleTenantAdmin)
+	if !contains(adminPerms, PermSelfRead) || !contains(adminPerms, PermManageUsers) || !contains(adminPerms, PermManageSettings) {
+		t.Fatalf("tenant_admin sollte geerbte user-rechte + eigene rechte haben, habe %v", adminPerms)
+	}
+	if contains(adminPerms, PermManageTenants) {
+		t.Fatal("tenant_admin sollte KEIN platform.manage_tenants haben")
+	}
+
+	superPerms := EffectivePermissions(RoleSuperadmin)
+	for _, want := range []Permission{PermSelfRead, PermSelfUpdate, PermManageUsers, PermManageSettings, PermManageTenants} {
+		if !contains(superPerms, want) {
+			t.Fatalf("superadmin sollte %q haben (volle vererbte kette), habe %v", want, superPerms)
+		}
+	}
+}
+
+func TestHasPermission(t *testing.T) {
+	if !HasPermission(RoleTenantAdmin, PermSelfRead) {
+		t.Fatal("tenant_admin sollte geerbtes self.read haben")
+	}
+	if HasPermission(RoleUser, PermManageTenants) {
+		t.Fatal("user sollte platform.manage_tenants nicht haben")
+	}
+}
@@ -0,0 +1,144 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+func setupStoreTest(t *testing.T) (*Store, string, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS users (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			email TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignments (
+			user_id UUID PRIMARY KEY REFERENCES users(id),
+			role TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
+			granted_by TEXT NOT NULL,
+			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignment_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			user_id UUID NOT NULL,
+			role TEXT NOT NULL,
+			granted_by TEXT NOT NULL,
+			granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	userStore := user.NewTenantUserStore(pool)
+	u, err := userStore.Create(ctx, "rbac_test@example.com", "RBAC Test")
+	if err != nil {
+		t.Fatalf("testuser anlegen: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM role_assignment_history WHERE user_id = $1`, u.ID)
+		_, _ = pool.Exec(ctx, `DELETE FROM role_assignments WHERE user_id = $1`, u.ID)
+		_, _ = pool.Exec(ctx, `DELETE FROM users WHERE id = $1`, u.ID)
+		pool.Close()
+	}
+	return NewStore(pool), u.ID, cleanup
+}
+
+// Akzeptanzkriterium 1: Grundrollen sind einem Benutzer je Tenant zuweisbar.
+func TestStore_AssignAndGet(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	assigned, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example")
+	if err != nil {
+		t.Fatalf("assign: %v", err)
+	}
+	if assigned.Role != RoleTenantAdmin {
+		t.Fatalf("erwartet tenant_admin, habe %q", assigned.Role)
+	}
+
+	got, err := store.Get(ctx, userID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Role != RoleTenantAdmin || got.GrantedBy != "admin@acme.example" {
+		t.Fatalf("zuweisung unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Zuweisung ausserhalb der erlaubten
+// Matrix (superadmin im tenant-gescopten Store) wird abgewiesen.
+func TestStore_RejectsSuperadminOutsideAllowedMatrix(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := store.Assign(ctx, userID, RoleSuperadmin, "admin@acme.example")
+	if !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
+		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope, habe %v", err)
+	}
+
+	// Sicherstellen, dass der abgewiesene Versuch keine Zeile hinterlassen hat.
+	if _, err := store.Get(ctx, userID); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound nach abgewiesener zuweisung, habe %v", err)
+	}
+}
+
+func TestStore_RejectsUnknownRole(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Assign(ctx, userID, Role("erfunden"), "admin@acme.example"); !errors.Is(err, ErrRoleNotAssignableInTenantScope) {
+		t.Fatalf("erwartet ErrRoleNotAssignableInTenantScope fuer unbekannte rolle, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3: Rollenzuweisung vollstaendig auditierbar.
+func TestStore_HistoryTracksWhoAndWhen(t *testing.T) {
+	store, userID, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Assign(ctx, userID, RoleUser, "system"); err != nil {
+		t.Fatalf("assign 1: %v", err)
+	}
+	if _, err := store.Assign(ctx, userID, RoleTenantAdmin, "admin@acme.example"); err != nil {
+		t.Fatalf("assign 2: %v", err)
+	}
+
+	history, err := store.History(ctx, userID)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
+	}
+	if history[0].Role != RoleUser || history[0].GrantedBy != "system" {
+		t.Fatalf("history[0] unerwartet: %+v", history[0])
+	}
+	if history[1].Role != RoleTenantAdmin || history[1].GrantedBy != "admin@acme.example" {
+		t.Fatalf("history[1] unerwartet: %+v", history[1])
+	}
+}
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS policy_rule_changes;
+DROP TABLE IF EXISTS policy_rules;
@@ -0,0 +1,24 @@
+-- Zentrale, deklarative Policy-Regeln (RBAC-02, siehe core-kanban/tickets/RBAC-02.md).
+-- policy_rules haelt den AKTUELLEN, gewaehrten Regelsatz (Existenz = erlaubt,
+-- Default-Deny fuer alles ohne Zeile). policy_rule_changes ist die
+-- versionierte Aenderungshistorie (Akzeptanzkriterium 3: Regelwechsel ohne
+-- Codeaenderung nachvollziehbar).
+CREATE TABLE policy_rules (
+    role       TEXT NOT NULL,
+    permission TEXT NOT NULL,
+    granted_by TEXT NOT NULL,
+    granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (role, permission)
+);
+
+CREATE TABLE policy_rule_changes (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    role       TEXT NOT NULL,
+    permission TEXT NOT NULL,
+    action     TEXT NOT NULL CHECK (action IN ('grant', 'revoke')),
+    actor      TEXT NOT NULL,
+    version    INT NOT NULL,
+    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX policy_rule_changes_idx ON policy_rule_changes (role, permission, version);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS group_members;
+DROP TABLE IF EXISTS groups;
@@ -0,0 +1,21 @@
+-- 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);
@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS ldap_group_role_mapping;
-DROP TABLE IF EXISTS ldap_config;
@@ -1,22 +0,0 @@
-- LDAP/Active-Directory-Anbindung (IAM-05, siehe core-kanban/tickets/IAM-05.md).
-- Bind-Credentials liegen NIE in dieser Tabelle im Klartext — bind_password_env
-- nennt nur den Namen einer Umgebungsvariable, aus der das Passwort zur
-- Laufzeit gelesen wird (Projekt-Konvention: Secrets nur ueber Env-Vars).
-CREATE TABLE ldap_config (
-    id                 BOOLEAN PRIMARY KEY DEFAULT true CHECK (id),
-    url                TEXT NOT NULL,
-    bind_dn            TEXT NOT NULL,
-    bind_password_env  TEXT NOT NULL,
-    base_dn            TEXT NOT NULL,
-    user_filter        TEXT NOT NULL DEFAULT '(objectClass=person)',
-    updated_at         TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-- Erlaubnis-Matrix LDAP-Gruppe -> NEXARCH-Rolle (Akzeptanzkriterium 3).
-- Eine LDAP-Gruppe OHNE Eintrag hier vergibt KEINE Rolle — kein impliziter
-- Zugriff durch Gruppennamen-Zufall (Privilege-Escalation-Schutz, siehe
-- "Bekannte Fehler vermeiden" im Ticket).
-CREATE TABLE ldap_group_role_mapping (
-    ldap_group TEXT PRIMARY KEY,
-    role       TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin'))
-);
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS oidc_states;
@@ -1,10 +0,0 @@
-- CSRF-/Replay-Schutz fuer OIDC-Login (IAM-06, siehe
-- core-kanban/tickets/IAM-06.md). Einmal-Verwendung erzwungen ueber
-- used_at IS NULL in der Consume-Abfrage, analog IAM-03/IAM-09.
-CREATE TABLE oidc_states (
-    state      TEXT PRIMARY KEY,
-    nonce      TEXT NOT NULL,
-    expires_at TIMESTAMPTZ NOT NULL,
-    used_at    TIMESTAMPTZ,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1,11 +1,23 @@
 #!/usr/bin/env bash
+# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
+# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
+# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
+# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
+# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
+
 export PGPASSWORD="$PASS"
+
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
+
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -1,12 +1,24 @@
 #!/usr/bin/env bash
+# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
+# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
+# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
+# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
+
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
+
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
+
 echo "== go build =="
 go build ./...
+
 echo "== go vet =="
 go vet ./...
+
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1
@@ -0,0 +1,183 @@
+"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>
+  );
+}
@@ -0,0 +1,30 @@
+import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
+
+export const metadata = {
+  title: "NEXARCH Rechteverwaltung",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="de">
+      <body
+        style={{
+          fontFamily: typography.fontFamily,
+          margin: 0,
+          background: "var(--shl-color-background, #ffffff)",
+          color: "var(--shl-color-text-primary, #14181f)",
+        }}
+      >
+        <ThemeProvider>
+          <I18nProvider initialLocale="de">
+            <ToastProvider>{children}</ToastProvider>
+          </I18nProvider>
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}
@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function IndexPage() {
+  redirect("/roles");
+}
@@ -0,0 +1,142 @@
+"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";
+}
@@ -0,0 +1,68 @@
+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 }) });
+}
@@ -0,0 +1,5 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;
@@ -0,0 +1,22 @@
+{
+  "name": "nexarch-rbac-admin",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@nexarch/shl": "file:../shl",
+    "next": "14.2.35",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "20.14.9",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "typescript": "5.5.3"
+  }
+}
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
@@ -0,0 +1,45 @@
+# @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
+
+Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
+Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
+
+## Enthält
+
+- **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
+- **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
+- **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
+- **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
+
+## Verwendung in einem Modul-Frontend
+
+```tsx
+import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <ThemeProvider>
+      <I18nProvider initialLocale="de">
+        <ToastProvider>
+          <Shell modules={[]} tenantLabel="Mandant XY">
+            {children}
+          </Shell>
+        </ToastProvider>
+      </I18nProvider>
+    </ThemeProvider>
+  );
+}
+```
+
+## Bekannter offener Punkt
+
+Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
+
+## Tests
+
+Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
+
+```bash
+npm install
+npm test
+npm run typecheck
+```
@@ -0,0 +1,38 @@
+// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { Dialog } from "../components/Dialog";
+import { I18nProvider } from "../i18n/i18n";
+
+function renderDialog(onClose: () => void) {
+  return render(
+    <I18nProvider>
+      <Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
+        <button type="button">Erste Aktion</button>
+        <button type="button">Zweite Aktion</button>
+      </Dialog>
+    </I18nProvider>,
+  );
+}
+
+describe("Dialog: Tastaturbedienung", () => {
+  it("schließt sich bei ESC", () => {
+    const onClose = vi.fn();
+    renderDialog(onClose);
+    fireEvent.keyDown(document, { key: "Escape" });
+    expect(onClose).toHaveBeenCalledOnce();
+  });
+
+  it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
+    renderDialog(vi.fn());
+    const closeButton = screen.getByRole("button", { name: /schließen/i });
+    expect(document.activeElement).toBe(closeButton);
+  });
+
+  it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
+    renderDialog(vi.fn());
+    const dialog = screen.getByRole("dialog");
+    expect(dialog).toHaveAttribute("aria-modal", "true");
+    expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
+  });
+});
@@ -0,0 +1,39 @@
+// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
+import { describe, expect, it } from "vitest";
+import { colorTokens } from "../tokens/tokens";
+
+// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
+function relLuminance(hex: string): number {
+  const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+  const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+function contrastRatio(a: string, b: string): number {
+  const l1 = relLuminance(a);
+  const l2 = relLuminance(b);
+  const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
+  for (const scheme of ["light", "dark"] as const) {
+    const c = colorTokens[scheme];
+
+    it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
+    });
+  }
+});
@@ -0,0 +1,88 @@
+"use client";
+
+// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
+
+import { useEffect, useRef } from "react";
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+const FOCUSABLE_SELECTOR =
+  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
+export interface DialogProps {
+  open: boolean;
+  onClose: () => void;
+  titleId: string;
+  title: string;
+  children: ReactNode;
+}
+
+export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
+  const { t } = useI18n();
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const previouslyFocused = useRef<HTMLElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    previouslyFocused.current = document.activeElement as HTMLElement | null;
+
+    const node = dialogRef.current;
+    const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
+    focusables?.[0]?.focus();
+
+    function handleKeyDown(event: KeyboardEvent) {
+      if (event.key === "Escape") {
+        onClose();
+        return;
+      }
+      if (event.key !== "Tab" || !node) return;
+
+      const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
+      if (items.length === 0) return;
+      const first = items[0];
+      const last = items[items.length - 1];
+
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    }
+
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+      previouslyFocused.current?.focus();
+    };
+  }, [open, onClose]);
+
+  if (!open) return null;
+
+  return (
+    <div
+      className="shl-dialog-backdrop"
+      role="presentation"
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onClose();
+      }}
+    >
+      <div
+        ref={dialogRef}
+        className="shl-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+      >
+        <div className="shl-dialog-header">
+          <h2 id={titleId}>{title}</h2>
+          <button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
+            ×
+          </button>
+        </div>
+        <div className="shl-dialog-body">{children}</div>
+      </div>
+    </div>
+  );
+}
@@ -0,0 +1,98 @@
+// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
+// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
+
+import { useId } from "react";
+import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
+
+interface FieldWrapperProps {
+  label: string;
+  error?: string;
+  hint?: string;
+  children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
+}
+
+function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
+  const inputId = useId();
+  const hintId = hint ? `${inputId}-hint` : undefined;
+  const errorId = error ? `${inputId}-error` : undefined;
+  const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
+
+  return (
+    <div className="shl-field">
+      <label htmlFor={inputId}>{label}</label>
+      {children({ inputId, describedBy })}
+      {hint && (
+        <p id={hintId} className="shl-field-hint">
+          {hint}
+        </p>
+      )}
+      {error && (
+        <p id={errorId} className="shl-field-error" role="alert">
+          {error}
+        </p>
+      )}
+    </div>
+  );
+}
+
+export interface TextFieldProps
+  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
+  label: string;
+  error?: string;
+  hint?: string;
+}
+
+export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
+  return (
+    <FieldWrapper label={label} error={error} hint={hint}>
+      {({ inputId, describedBy }) => (
+        <input
+          id={inputId}
+          aria-describedby={describedBy}
+          aria-invalid={error ? true : undefined}
+          {...inputProps}
+        />
+      )}
+    </FieldWrapper>
+  );
+}
+
+export interface SelectFieldProps
+  extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
+  label: string;
+  error?: string;
+  hint?: string;
+  children: ReactNode;
+}
+
+export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
+  return (
+    <FieldWrapper label={label} error={error} hint={hint}>
+      {({ inputId, describedBy }) => (
+        <select
+          id={inputId}
+          aria-describedby={describedBy}
+          aria-invalid={error ? true : undefined}
+          {...selectProps}
+        >
+          {children}
+        </select>
+      )}
+    </FieldWrapper>
+  );
+}
+
+export interface CheckboxFieldProps
+  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
+  label: string;
+}
+
+export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
+  const inputId = useId();
+  return (
+    <div className="shl-field shl-field-checkbox">
+      <input id={inputId} type="checkbox" {...inputProps} />
+      <label htmlFor={inputId}>{label}</label>
+    </div>
+  );
+}
@@ -0,0 +1,62 @@
+"use client";
+
+// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
+// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
+
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+import { useTheme } from "../theme/ThemeProvider";
+
+export interface ModuleLink {
+  key: string;
+  label: string;
+  href: string;
+  active?: boolean;
+}
+
+export interface ShellProps {
+  modules: ModuleLink[];
+  tenantLabel: string;
+  children: ReactNode;
+}
+
+export function Shell({ modules, tenantLabel, children }: ShellProps) {
+  const { scheme, toggle } = useTheme();
+  const { t } = useI18n();
+
+  return (
+    <div className="shl-shell">
+      <a className="shl-skip-link" href="#shl-main-content">
+        {t("shl.shell.skipToContent", "Zum Inhalt springen")}
+      </a>
+      <header className="shl-shell-header">
+        <nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
+          <ul>
+            {modules.map((mod) => (
+              <li key={mod.key}>
+                <a href={mod.href} aria-current={mod.active ? "page" : undefined}>
+                  {mod.label}
+                </a>
+              </li>
+            ))}
+          </ul>
+        </nav>
+        <div className="shl-shell-context">
+          <span className="shl-tenant-context">{tenantLabel}</span>
+          <button
+            type="button"
+            onClick={toggle}
+            aria-label={
+              scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
+            }
+          >
+            {scheme === "light" ? "🌙" : "☀️"}
+          </button>
+        </div>
+      </header>
+      <main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
+        {children}
+      </main>
+    </div>
+  );
+}
@@ -0,0 +1,83 @@
+// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
+
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+export interface TableColumn<Row> {
+  key: string;
+  header: string;
+  render: (row: Row) => ReactNode;
+  sortable?: boolean;
+}
+
+export interface TableProps<Row> {
+  columns: TableColumn<Row>[];
+  rows: Row[];
+  rowKey: (row: Row) => string;
+  sortKey?: string;
+  sortDirection?: "asc" | "desc";
+  onSort?: (key: string) => void;
+  caption?: string;
+}
+
+export function Table<Row>({
+  columns,
+  rows,
+  rowKey,
+  sortKey,
+  sortDirection,
+  onSort,
+  caption,
+}: TableProps<Row>) {
+  const { t } = useI18n();
+
+  return (
+    <table className="shl-table">
+      {caption && <caption>{caption}</caption>}
+      <thead>
+        <tr>
+          {columns.map((column) => {
+            const isSorted = column.key === sortKey;
+            const ariaSort = column.sortable
+              ? isSorted
+                ? sortDirection === "asc"
+                  ? "ascending"
+                  : "descending"
+                : "none"
+              : undefined;
+            return (
+              <th key={column.key} scope="col" aria-sort={ariaSort}>
+                {column.sortable ? (
+                  <button
+                    type="button"
+                    onClick={() => onSort?.(column.key)}
+                    className="shl-table-sort-button"
+                  >
+                    {column.header}
+                  </button>
+                ) : (
+                  column.header
+                )}
+              </th>
+            );
+          })}
+        </tr>
+      </thead>
+      <tbody>
+        {rows.length === 0 ? (
+          <tr>
+            <td colSpan={columns.length}>{t("shl.table.noRows")}</td>
+          </tr>
+        ) : (
+          rows.map((row) => (
+            <tr key={rowKey(row)}>
+              {columns.map((column) => (
+                <td key={column.key}>{column.render(row)}</td>
+              ))}
+            </tr>
+          ))
+        )}
+      </tbody>
+    </table>
+  );
+}
@@ -0,0 +1,67 @@
+"use client";
+
+// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
+
+import { createContext, useCallback, useContext, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+export type ToastVariant = "info" | "success" | "danger" | "warning";
+
+export interface ToastMessage {
+  id: string;
+  text: string;
+  variant: ToastVariant;
+}
+
+interface ToastContextValue {
+  toasts: ToastMessage[];
+  push: (text: string, variant?: ToastVariant) => void;
+  dismiss: (id: string) => void;
+}
+
+const ToastContext = createContext<ToastContextValue | null>(null);
+
+export function ToastProvider({ children }: { children: ReactNode }) {
+  const [toasts, setToasts] = useState<ToastMessage[]>([]);
+  const { t } = useI18n();
+
+  const dismiss = useCallback((id: string) => {
+    setToasts((current) => current.filter((toast) => toast.id !== id));
+  }, []);
+
+  const push = useCallback((text: string, variant: ToastVariant = "info") => {
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    setToasts((current) => [...current, { id, text, variant }]);
+  }, []);
+
+  const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
+
+  return (
+    <ToastContext.Provider value={value}>
+      {children}
+      <div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
+        {toasts.map((toast) => (
+          <div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
+            <span>{toast.text}</span>
+            <button
+              type="button"
+              onClick={() => dismiss(toast.id)}
+              aria-label={t("shl.toast.dismiss")}
+            >
+              ×
+            </button>
+          </div>
+        ))}
+      </div>
+    </ToastContext.Provider>
+  );
+}
+
+export function useToast(): ToastContextValue {
+  const ctx = useContext(ToastContext);
+  if (!ctx) {
+    throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
+  }
+  return ctx;
+}
@@ -0,0 +1,75 @@
+"use client";
+
+// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
+// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
+// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
+// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
+
+import { createContext, useContext, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+
+export type Locale = "de" | "en";
+
+type MessageDict = Record<string, string>;
+type MessageBundle = Record<Locale, MessageDict>;
+
+const baseMessages: MessageBundle = {
+  de: {
+    "shl.dialog.close": "Schließen",
+    "shl.toast.dismiss": "Meldung schließen",
+    "shl.table.noRows": "Keine Einträge vorhanden",
+    "shl.theme.toggleToLight": "Helles Erscheinungsbild",
+    "shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
+  },
+  en: {
+    "shl.dialog.close": "Close",
+    "shl.toast.dismiss": "Dismiss message",
+    "shl.table.noRows": "No entries",
+    "shl.theme.toggleToLight": "Switch to light theme",
+    "shl.theme.toggleToDark": "Switch to dark theme",
+  },
+};
+
+// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
+const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
+
+export function registerMessages(locale: Locale, messages: MessageDict): void {
+  registry[locale] = { ...registry[locale], ...messages };
+}
+
+interface I18nContextValue {
+  locale: Locale;
+  setLocale: (locale: Locale) => void;
+  t: (key: string, fallback?: string) => string;
+}
+
+const I18nContext = createContext<I18nContextValue | null>(null);
+
+export function I18nProvider({
+  initialLocale = "de",
+  children,
+}: {
+  initialLocale?: Locale;
+  children: ReactNode;
+}) {
+  const [locale, setLocale] = useState<Locale>(initialLocale);
+
+  const value = useMemo<I18nContextValue>(
+    () => ({
+      locale,
+      setLocale,
+      t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
+    }),
+    [locale],
+  );
+
+  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
+}
+
+export function useI18n(): I18nContextValue {
+  const ctx = useContext(I18nContext);
+  if (!ctx) {
+    throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
+  }
+  return ctx;
+}
@@ -0,0 +1,25 @@
+// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
+// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
+
+export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
+export type { ColorScheme, ColorTokens } from "./tokens/tokens";
+
+export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
+
+export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
+export type { Locale } from "./i18n/i18n";
+
+export { Shell } from "./components/Shell";
+export type { ShellProps, ModuleLink } from "./components/Shell";
+
+export { Dialog } from "./components/Dialog";
+export type { DialogProps } from "./components/Dialog";
+
+export { Table } from "./components/Table";
+export type { TableProps, TableColumn } from "./components/Table";
+
+export { TextField, SelectField, CheckboxField } from "./components/FormElements";
+export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
+
+export { ToastProvider, useToast } from "./components/Toast";
+export type { ToastMessage, ToastVariant } from "./components/Toast";
@@ -0,0 +1,25 @@
+{
+  "name": "@nexarch/shl",
+  "version": "0.1.0",
+  "private": true,
+  "description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
+  "main": "index.ts",
+  "types": "index.ts",
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.4.8",
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "jsdom": "^24.1.1",
+    "typescript": "5.5.3",
+    "vitest": "^2.0.0"
+  }
+}
@@ -0,0 +1,81 @@
+"use client";
+
+// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
+// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
+
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
+
+const STORAGE_KEY = "nexarch-shl-theme";
+
+interface ThemeContextValue {
+  scheme: ColorScheme;
+  setScheme: (scheme: ColorScheme) => void;
+  toggle: () => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+function readStoredScheme(): ColorScheme | null {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = window.localStorage.getItem(STORAGE_KEY);
+    return stored === "light" || stored === "dark" ? stored : null;
+  } catch {
+    // localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
+    return null;
+  }
+}
+
+function systemPrefersDark(): boolean {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+  const [scheme, setSchemeState] = useState<ColorScheme>("light");
+
+  useEffect(() => {
+    const stored = readStoredScheme();
+    setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
+  }, []);
+
+  const setScheme = useCallback((next: ColorScheme) => {
+    setSchemeState(next);
+    try {
+      window.localStorage.setItem(STORAGE_KEY, next);
+    } catch {
+      // Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
+    }
+  }, []);
+
+  const toggle = useCallback(() => {
+    setScheme(scheme === "light" ? "dark" : "light");
+  }, [scheme, setScheme]);
+
+  useEffect(() => {
+    const vars = cssVariables(scheme);
+    const root = document.documentElement;
+    for (const [key, value] of Object.entries(vars)) {
+      root.style.setProperty(key, value);
+    }
+    root.dataset.shlTheme = scheme;
+  }, [scheme]);
+
+  const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
+
+  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
+}
+
+export function useTheme(): ThemeContextValue {
+  const ctx = useContext(ThemeContext);
+  if (!ctx) {
+    throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
+  }
+  return ctx;
+}
+
+export function currentColors(scheme: ColorScheme) {
+  return colorTokens[scheme];
+}
@@ -0,0 +1,96 @@
+// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
+// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
+// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
+
+export type ColorScheme = "light" | "dark";
+
+export interface ColorTokens {
+  background: string;
+  surface: string;
+  surfaceRaised: string;
+  border: string;
+  textPrimary: string;
+  textSecondary: string;
+  accent: string;
+  accentContrast: string;
+  danger: string;
+  dangerContrast: string;
+  success: string;
+  warning: string;
+  focusRing: string;
+}
+
+// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
+// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
+export const colorTokens: Record<ColorScheme, ColorTokens> = {
+  light: {
+    background: "#FFFFFF",
+    surface: "#F5F6F8",
+    surfaceRaised: "#FFFFFF",
+    border: "#D7DBE0",
+    textPrimary: "#14181F",
+    textSecondary: "#4B5563",
+    accent: "#1D4ED8",
+    accentContrast: "#FFFFFF",
+    danger: "#B91C1C",
+    dangerContrast: "#FFFFFF",
+    success: "#15803D",
+    warning: "#B45309",
+    focusRing: "#1D4ED8",
+  },
+  dark: {
+    background: "#0F1115",
+    surface: "#181B21",
+    surfaceRaised: "#20242C",
+    border: "#333944",
+    textPrimary: "#F2F4F7",
+    textSecondary: "#B4BAC4",
+    accent: "#5B8DEF",
+    accentContrast: "#0F1115",
+    danger: "#F87171",
+    dangerContrast: "#0F1115",
+    success: "#4ADE80",
+    warning: "#FBBF24",
+    focusRing: "#5B8DEF",
+  },
+};
+
+export const spacing = {
+  xs: "4px",
+  sm: "8px",
+  md: "16px",
+  lg: "24px",
+  xl: "32px",
+  xxl: "48px",
+} as const;
+
+export const breakpoints = {
+  mobile: "0px",
+  tablet: "768px",
+  desktop: "1200px",
+} as const;
+
+export const typography = {
+  fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
+  fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
+  sizeSm: "13px",
+  sizeMd: "15px",
+  sizeLg: "18px",
+  sizeXl: "24px",
+  lineHeight: 1.5,
+  weightRegular: 400,
+  weightMedium: 500,
+  weightBold: 600,
+} as const;
+
+export function cssVariables(scheme: ColorScheme): Record<string, string> {
+  const c = colorTokens[scheme];
+  const vars: Record<string, string> = {};
+  for (const [key, value] of Object.entries(c)) {
+    vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
+  }
+  for (const [key, value] of Object.entries(spacing)) {
+    vars[`--shl-spacing-${key}`] = value;
+  }
+  return vars;
+}
@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}
@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    setupFiles: ["./vitest.setup.ts"],
+  },
+});
@@ -0,0 +1,9 @@
+import "@testing-library/jest-dom/vitest";
+import { afterEach } from "vitest";
+import { cleanup } from "@testing-library/react";
+
+// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
+// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
+afterEach(() => {
+  cleanup();
+});
Author	SHA1	Message	Date
sysops	bc46c3e320	RBAC-07: rechte-administrations-dienst-starten - cmd/rbac-admin-api: startet internal/rbac.Handler (RBAC-05), hinter auth.RequireAuth mit demselben JWT-Secret wie IAM-16 (account-api) - reines Wiring, kein Diff an internal/rbac/ (verifiziert) - real deployed auf 131, cross-service-Session real bewiesen: Login gegen account-api (Port 8099), dasselbe Session-Cookie gegen rbac-admin-api (Port 8100) verwendet -> echte Rollenliste, ohne Cookie -> 401 - Migrationen (role_assignments/groups) real auf tenant_acme angewendet, reale Grant-Luecke behoben und verifiziert - Bootstrap-Erkenntnis dokumentiert: ListRoles selbst verlangt bereits eine Rolle mit PermManageUsers, Testnutzer daher mit direkter DB-Bootstrap-Rolle angelegt (wie Ersteinrichtung) Pruefungen siehe docs/RBAC-07-PRUEFPROTOKOLL.md	2026-08-30 21:24:35 +02:00
sysops	e65625841c	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 23:45:51 +02:00
sysops	fbcc9db8f1	RBAC-05: web/rbac-admin next.js-frontend (rollen+gruppen-verwaltung, audit-verlauf) auf shl-01	2026-08-28 23:43:09 +02:00
sysops	bd80f0cb16	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/rbac-05-rechte-administrationsoberflaeche # Conflicts: # DEVLOG.md	2026-08-28 23:41:36 +02:00
sysops	051af43dec	RBAC-05: backend — handler.go (rollen-/gruppenverwaltung, selbst-eskalationsschutz), group.go ListGroups/Members	2026-08-28 23:41:30 +02:00
sysops	9de9005ced	Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/rbac-05-rechte-administrationsoberflaeche	2026-08-28 23:38:57 +02:00
sysops	1b6a1591c7	Merge branch 'feature/rbac-03-gruppen-abteilungen' into feature/rbac-05-rechte-administrationsoberflaeche	2026-08-28 23:38:52 +02:00
sysops	bfa5c61db5	SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)	2026-08-28 22:01:56 +02:00
sysops	3c226dab12	SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)	2026-08-28 21:55:34 +02:00
sysops	584cefa388	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 21:45:55 +02:00
sysops	00665592f6	SHL-01: ui-shell-design-system-zentral (tokens, theming, i18n-rahmen, basis-komponenten)	2026-08-28 21:41:56 +02:00
sysopsandClaude Sonnet 5	bab582a38a	RBAC-03: gruppen-abteilungen internal/rbac/group.go: GroupStore verwaltet Gruppen innerhalb GENAU EINER Tenant-Datenbank (Modell C, analog Store/TenantUserStore) — Tenant-Isolation ist damit strukturell erfuellt, keine zusaetzliche Filterlogik noetig (Akzeptanzkriterium 3). Nur 'user'/'tenant_admin' sind auf Gruppenebene zuweisbar (dieselbe assignableRoles-Matrix wie bei direkter Zuweisung) — superadmin bleibt mandantenuebergreifend und ausserhalb jeder Gruppenlogik. EffectivePermissionsForUser vereinigt die direkte Rollenzuweisung (RBAC-01 Store) mit allen Rechten aus Gruppenrollen, live berechnet bei jedem Aufruf statt zwischengespeichert — RemoveMember/DeleteGroup wirken dadurch sofort (Akzeptanzkriterium 3). ON DELETE CASCADE auf group_members entzieht beim Loeschen einer Gruppe die Mitgliedschaften automatisch, Benutzerkonten selbst bleiben unberuehrt. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Gruppenrolle wirkt korrekt auf ALLE aktuellen Mitglieder — TestGroup_RoleAffectsAllCurrentMembers: zwei Mitglieder, beide erhalten die Gruppenrolle-Rechte. PASS. 2. Entfernen eines Benutzers aus der Gruppe entzieht Rechte sofort — TestGroup_RemoveMemberRevokesRightsImmediately. PASS. 3. Gruppen sauber tenant-isoliert (Stichprobe ueber zwei Tenants) — TestGroup_TenantIsolation: Gruppe in Tenant A taucht in Tenant B nicht auf. PASS. Zusaetzlich: TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser belegt Akzeptanzkriterium 3 (Loeschung ohne Benutzerkonto-Verlust) konkret. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 22:00:48 +02:00
sysopsandClaude Sonnet 5	d63fcbb49e	RBAC-02: policy-enforcement-schicht-zentral internal/policy: deklarativer, DB-gehaltener Regelsatz (policy_rules) statt hartcodierter Go-Entscheidungslogik — Store.IsAllowed schaut ausschliesslich in die Datenbank, kein Go-Fallback. Ein Regelwechsel (Grant/Revoke) wirkt sich sofort aus, ohne Codeaenderung/Deploy (Akzeptanzkriterium 3). Jede Aenderung wird atomar mit einem versionierten Historieneintrag in policy_rule_changes festgehalten (grant/revoke, Akteur, Version). Enforcer.Authorize ist Default-Deny: existiert keine Regel fuer role+ permission, ist der Zugriff verboten (Akzeptanzkriterium 2), fuer sich genommen ohne Anwendungslogik testbar. Guard/GuardTenantScoped sind die zentrale Enforcement-Funktion (Akzeptanzkriterium 1): die uebergebene Query-Funktion wird NUR bei erfolgreicher Autorisierung aufgerufen — es gibt keinen Weg, Daten ohne vorherige Authorize-Entscheidung zu erhalten. GuardTenantScoped erzwingt zusaetzlich per Funktionssignatur, dass tenantSlug TEIL der Query-Funktion ist (Akzeptanzkriterium 3) — ein nachgelagerter Post-Filter (der archivmail-Fehler aus "Bekannte Fehler vermeiden": Tenant-Filter nach statt in der Query) ist mit dieser Signatur strukturell nicht moeglich, da die Repository-Implementierung tenantSlug selbst fuer ihre eigene WHERE-Klausel entgegennimmt. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Kein Datenzugriffs-Pfad umgeht die zentrale Enforcement-Schicht — TestGuard_NeverCallsQueryWithoutAuthorization: query-Funktion wird nachweislich NICHT aufgerufen ohne vorherige Regel, erst nach Grant. PASS. 2. Anfrage ohne passende Policy wird zuverlaessig abgewiesen (Default-Deny) — TestAuthorize_DefaultDeny: keine Regel konfiguriert -> ErrDenied, nicht automatisch erlaubt. PASS. 3. Policy-Regelsatz versioniert, Regelwechsel ohne Codeaenderung nachvollziehbar — TestGrantRevoke_ChangesBehaviorWithoutCodeChange: Verhalten aendert sich durch reinen Datenbank-Grant/Revoke, Historie zeigt beide Versionen korrekt. PASS. Zusaetzlich: TestGuardTenantScoped_IsolatesDataBetweenTenants belegt das Tenant-Scoping-Muster aus Akzeptanzkriterium 3 konkret anhand zweier Tenants. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:43:26 +02:00
sysopsandClaude Sonnet 5	ed67887385	RBAC-01: rollenmodell-grundrechte internal/rbac: drei Grundrollen (superadmin, tenant_admin, user) mit Hierarchie ueber eine einfache Eltern-Map (tenant_admin erbt von user, superadmin erbt von tenant_admin) — EffectivePermissions loest die volle vererbte Rechtemenge auf (Akzeptanzkriterium 2). Policy-Modell bewusst als reine Go-Datenstruktur getrennt von der Durchsetzung (RBAC-02), nach Casbin-Prinzip. Store verwaltet Rollenzuweisungen innerhalb EINER Tenant-Datenbank (Modell C, analog internal/user.TenantUserStore) — nur 'user' und 'tenant_admin' sind hier zuweisbar (assignableRoles-Matrix). Ein Zuweisungsversuch fuer 'superadmin' wird abgewiesen, da diese Rolle mandantenuebergreifend ist und bereits durch die Existenz eines Kontos in IAM-01s SuperadminStore repraesentiert wird — keine doppelte Modellierung. Jede Zuweisung schreibt zusaetzlich einen Historieneintrag (role_assignment_history) mit grantedBy/grantedAt, atomar in derselben Transaktion (Akzeptanzkriterium 3). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zuweisung ausserhalb der erlaubten Matrix abgewiesen — TestStore_RejectsSuperadminOutsideAllowedMatrix und TestStore_RejectsUnknownRole: beide ErrRoleNotAssignableInTenantScope, kein Datensatz hinterlassen. PASS. 2. Rollenhierarchie liefert erwartete effektive Rechtemenge — TestEffectivePermissions_Inheritance: tenant_admin hat geerbte user-Rechte + eigene, aber nicht platform.manage_tenants; superadmin hat die volle Kette. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Zusaetzlich automatisiert getestet (Akzeptanzkriterium 3): TestStore_HistoryTracksWhoAndWhen — zwei aufeinanderfolgende Zuweisungen, Historie liefert beide mit korrektem grantedBy in chronologischer Reihenfolge. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:45:16 +02:00