QA-03: build/test-ergebnis auf 131 ergaenzt (30/30 tests gruen, bypass-fund bestaetigt)

# Conflicts:
#	DEVLOG.md

.gitignore

@@ -1,2 +1,4 @@
 *.log
 .env
+web/*/node_modules/
+web/*/.next/

DEVLOG.md

@@ -44,3 +44,158 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 
 ---
+## 2026-08-27 17:26 – 17:28 (1m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 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.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:31 – 17:31 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:36 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:37 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- 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 +++++++++++++++++++++
+
+---

archive/.golangci.yml

@@ -1,18 +0,0 @@
-version: "2"
-
-run:
-  timeout: 3m
-
-linters:
-  default: none
-  enable:
-    - govet
-    - staticcheck
-    - errcheck
-    - unused
-    - ineffassign
-
-formatters:
-  enable:
-    - gofmt
-    - goimports

archive/Makefile

@@ -1,19 +0,0 @@
-.PHONY: build lint fmt test check
-
-build:
-	go build ./...
-
-lint:
-	golangci-lint run ./...
-
-fmt:
-	gofmt -l .
-	@test -z "$$(gofmt -l .)" || (echo "gofmt-Verstoesse gefunden, siehe oben" && exit 1)
-
-test:
-	go test ./... -p 1 -count=1
-
-check: build
-	go vet ./...
-	golangci-lint run ./...
-	go test ./... -p 1 -count=1

archive/README.md

@@ -1,62 +0,0 @@
-# NEXARCH Archive
-
-Zentrales, modulübergreifendes Modul für Aufbewahrung, WORM, Compliance und
-Backup. Dieses Verzeichnis enthält bisher `internal/backup` (BAK-01,
-Datenbank-Backup-Strategie) — weitere Bausteine folgen ticketweise.
-
-## BAK-01: Datenbank-Backup
-
-`cmd/backup-cli` — Aufrufpunkt für systemd-Timer (siehe
-`../deploy/systemd/nexarch-archive-backup-*.timer`):
-
-```bash
-export NEXARCH_BACKUP_PG_USER=nexarch_backup
-export NEXARCH_BACKUP_PG_PASSWORD=...
-export NEXARCH_BACKUP_DIR=/var/nexarch-archiv/backups/postgres   # NICHT auf einem ephemeren Test-Dataset (siehe Betrieb)
-export NEXARCH_BACKUP_KEEP_GENERATIONS=7   # optional, Default 7
-
-backup-cli full          # neue Vollsicherung + Verifikation
-backup-cli incremental   # inkrementelle Sicherung gegen die neueste Generation
-backup-cli rotate        # entfernt alle bis auf die neuesten N Generationen
-```
-
-Voraussetzung: die konfigurierte Postgres-Rolle braucht das
-`REPLICATION`-Attribut (`pg_basebackup` nutzt eine
-Replikationsverbindung), und `summarize_wal = on` muss serverseitig gesetzt
-sein (PostgreSQL 17s natives inkrementelles Backup, keine WAL-Archivierung
-nötig).
-
-## BAK-02: Objekt-Storage-Backup
-
-`cmd/objectbackup-cli` sichert einen lokalen Verzeichnisbaum (den
-FDN-03-`LocalDriver`-Basisordner direkt, oder — für S3-gestützte
-Deployments — einen vorgelagerten `rclone`-Spiegel) mit
-[restic](https://restic.net) (Content-defined Chunking, verschlüsseltes
-Repository, geprüftes Tooling statt Eigenbau):
-
-```bash
-export NEXARCH_OBJECTBACKUP_REPO_DIR=/var/nexarch-archiv/backups/objects
-export NEXARCH_OBJECTBACKUP_PASSWORD=...
-export NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS=30   # optional, Default 7
-
-objectbackup-cli backup /var/nexarch-objects   # Sicherung + Verifikation
-objectbackup-cli check                          # vollständiges Lesen aller Datenblöcke
-objectbackup-cli rotate                          # restic forget --keep-last N --prune
-```
-
-## Betrieb: Backup-Zielverzeichnis
-
-Backup-Ziele liegen unter `/var/nexarch-archiv/` (persistentes ZFS-Dataset,
-`zfs/data/subvol-1131-disk-0` auf 192.168.1.131), NIEMALS unter
-`/var/nexarch-test/` (ephemeres Dataset, wird von den `reset-test-env.sh`-
-Skripten der anderen Module geleert). ZFS-seitige Snapshots/Replikation
-dieses Datasets sind ein eigenständiges Infra-Runbook (siehe
-`../../STORAGE-KONZEPT.md` Abschnitt 7), kein Ticket-Code — `zfs
-dedup=on` bewusst NICHT setzen (hoher RAM-Bedarf), Deduplizierung läuft
-ausschließlich App-seitig über restic.
-
-## Prüfungen
-
-```bash
-make check   # build + vet + lint + test, analog Core/DMS
-```

archive/cmd/backup-cli/main.go

@@ -1,107 +0,0 @@
-// backup-cli ist der Aufrufpunkt für BAK-01, gedacht für systemd-Timer
-// (siehe deploy/systemd/) — "automatisiert nach Zeitplan" (Akzeptanzkriterium
-// 1) entsteht durch die Zeitplan-Definition im Timer-Unit, nicht durch
-// einen eigenen In-Prozess-Scheduler (kein zusätzlicher Dauerprozess nötig,
-// passt zur Produkt-DNA "kein Anwendungsserver mit unnötigem
-// Ressourcenverbrauch").
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"time"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/backup"
-)
-
-func loadConfig() backup.Config {
-	cfg := backup.Config{
-		Host:      os.Getenv("NEXARCH_BACKUP_PG_HOST"),
-		Port:      os.Getenv("NEXARCH_BACKUP_PG_PORT"),
-		User:      os.Getenv("NEXARCH_BACKUP_PG_USER"),
-		Password:  os.Getenv("NEXARCH_BACKUP_PG_PASSWORD"),
-		BackupDir: os.Getenv("NEXARCH_BACKUP_DIR"),
-	}
-	if cfg.Host == "" {
-		cfg.Host = "localhost"
-	}
-	if cfg.Port == "" {
-		cfg.Port = "5432"
-	}
-	if cfg.User == "" || cfg.Password == "" || cfg.BackupDir == "" {
-		log.Fatal("NEXARCH_BACKUP_PG_USER, NEXARCH_BACKUP_PG_PASSWORD und NEXARCH_BACKUP_DIR muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func latestManifest(backupDir string) (string, error) {
-	generations, err := backup.ListGenerations(backupDir)
-	if err != nil {
-		return "", err
-	}
-	if len(generations) == 0 {
-		return "", fmt.Errorf("keine vorhandene generation fuer inkrementelle sicherung gefunden - zuerst 'full' ausfuehren")
-	}
-	latest := generations[len(generations)-1]
-	full := backupDir + "/" + latest + "/" + backup.FullBackupDirName + "/" + backup.BackupManifestFile
-	if _, err := os.Stat(full); err == nil {
-		return full, nil
-	}
-	return "", fmt.Errorf("kein backup_manifest in der neuesten generation %q gefunden", latest)
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: backup-cli <full|incremental|verify|rotate> [args]")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	switch os.Args[1] {
-	case "full":
-		genID := backup.NewGenerationID(time.Now())
-		manifest, err := backup.FullBackup(ctx, cfg, genID)
-		if err != nil {
-			log.Fatalf("vollsicherung fehlgeschlagen: %v", err)
-		}
-		dir := manifest[:len(manifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der vollsicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("vollsicherung %q erstellt und verifiziert: %s\n", genID, manifest)
-
-	case "incremental":
-		manifest, err := latestManifest(cfg.BackupDir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		generations, _ := backup.ListGenerations(cfg.BackupDir)
-		genID := generations[len(generations)-1]
-		incID := backup.NewGenerationID(time.Now())
-		newManifest, err := backup.IncrementalBackup(ctx, cfg, genID, incID, manifest)
-		if err != nil {
-			log.Fatalf("inkrementelle sicherung fehlgeschlagen: %v", err)
-		}
-		dir := newManifest[:len(newManifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der inkrementellen sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("inkrementelle sicherung %q erstellt und verifiziert: %s\n", incID, newManifest)
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_BACKUP_KEEP_GENERATIONS"); v != "" {
-			_, _ = fmt.Sscanf(v, "%d", &keep)
-		}
-		removed, err := backup.Rotate(cfg.BackupDir, keep)
-		if err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("rotation abgeschlossen, %d generation(en) entfernt: %v\n", len(removed), removed)
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}

archive/cmd/objectbackup-cli/main.go

@@ -1,75 +0,0 @@
-// objectbackup-cli ist der Aufrufpunkt für BAK-02, für systemd-Timer
-// gedacht (siehe deploy/systemd/) — "automatisiert nach Zeitplan" entsteht
-// durch die Timer-Definition, kein eigener Dauerprozess (dieselbe
-// Begründung wie BAK-01 / cmd/backup-cli).
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"strconv"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/objectbackup"
-)
-
-func loadConfig() objectbackup.Config {
-	cfg := objectbackup.Config{
-		RepoDir:  os.Getenv("NEXARCH_OBJECTBACKUP_REPO_DIR"),
-		Password: os.Getenv("NEXARCH_OBJECTBACKUP_PASSWORD"),
-	}
-	if cfg.RepoDir == "" || cfg.Password == "" {
-		log.Fatal("NEXARCH_OBJECTBACKUP_REPO_DIR und NEXARCH_OBJECTBACKUP_PASSWORD muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: objectbackup-cli <backup <quellverzeichnis>|check|rotate>")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	if err := objectbackup.InitRepo(ctx, cfg); err != nil {
-		log.Fatalf("repository initialisieren: %v", err)
-	}
-
-	switch os.Args[1] {
-	case "backup":
-		if len(os.Args) < 3 {
-			log.Fatal("aufruf: objectbackup-cli backup <quellverzeichnis>")
-		}
-		summary, err := objectbackup.Backup(ctx, cfg, os.Args[2])
-		if err != nil {
-			log.Fatalf("sicherung fehlgeschlagen: %v", err)
-		}
-		if err := objectbackup.Check(ctx, cfg, false); err != nil {
-			log.Fatalf("verifikation nach sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("sicherung %q erstellt und verifiziert (neu=%d geaendert=%d unveraendert=%d)\n",
-			summary.SnapshotID, summary.FilesNew, summary.FilesChanged, summary.FilesUnmodified)
-
-	case "check":
-		if err := objectbackup.Check(ctx, cfg, true); err != nil {
-			log.Fatalf("verifikation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("verifikation (mit vollstaendigem lesen) erfolgreich")
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS"); v != "" {
-			if n, err := strconv.Atoi(v); err == nil {
-				keep = n
-			}
-		}
-		if err := objectbackup.Forget(ctx, cfg, keep); err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("rotation abgeschlossen")
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}

archive/docs/BAK-01-PRUEFPROTOKOLL.md

@@ -1,87 +0,0 @@
-# BAK-01 – Prüfprotokoll: Datenbank-Backup-Strategie
-
-Welle 1, keine Vorbedingungen. Neues Modul-Verzeichnis `code/archive/`
-(gleiches Monorepo-Muster wie `code/dms/`), eigenes Go-Modul
-`gitea.perlbach24.de/scripte/nexarch/archive`.
-
-## Grundsatzentscheidung: PostgreSQL-17-natives inkrementelles Backup
-
-`pg_dump` kennt nur logische Vollsicherungen — "inkrementell" im Sinne des
-Tickets erfordert das physische Backup-Verfahren. Gewählt: PostgreSQL 17s
-natives `pg_basebackup --incremental` (WAL-Summarization), NICHT klassisches
-WAL-Archiving (`archive_mode`), weil letzteres einen Neustart der
-(geteilten, auch von Core/DMS-Tests genutzten) Postgres-Instanz auf
-192.168.1.131 erfordert hätte. Stattdessen `summarize_wal = on` gesetzt —
-nur ein `pg_reload_conf()`, kein Neustart, keine Unterbrechung laufender
-Verbindungen (per Health-Check nach der Änderung bestätigt).
-
-Voraussetzung geschaffen: Rolle `nexarch_backup` mit `REPLICATION`-Attribut
-angelegt (Postgres verlangt eine Replikationsverbindung für
-`pg_basebackup`), `pg_hba.conf` erlaubte lokale Replikationsverbindungen
-bereits.
-
-## Umsetzung
-
-- `internal/backup.FullBackup`/`IncrementalBackup` — rufen `pg_basebackup`
-  über `os/exec` auf, Ergebnis landet in einer Generationsstruktur
-  (`<BackupDir>/<Generation>/full/` bzw. `.../incremental/<ID>/`).
-- `internal/backup.Verify` — öffnet `base.tar.gz` vollständig (gzip- UND
-  tar-Stream, jeder Eintrag bis zum Ende gelesen, nicht nur Kopfdaten) —
-  Akzeptanzkriterium 2: Verifikation auf Lesbarkeit, nicht nur Erstellung.
-- `internal/backup.Rotate`/`ListGenerations` — Generationen sind nach
-  Zeitstempel-ID sortierbar, `Rotate` entfernt die ältesten bis auf `keep`
-  komplett (inklusive aller abhängigen Inkremente).
-- `cmd/backup-cli` — `full`/`incremental`/`rotate`, aufgerufen von
-  systemd-Timern (`deploy/systemd/nexarch-archive-backup-*.timer`) —
-  "automatisiert nach Zeitplan" (Akzeptanzkriterium 1) entsteht durch die
-  Timer-Definition, kein zusätzlicher Dauerprozess nötig.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Sicherung gegen Testdatenbank erfolgreich erstellt und verifiziert | **bestanden** — `TestFullBackup_CreatesVerifiedBackup` gegen die echte Postgres-17-Instanz auf 192.168.1.131 (kein Mock), zusätzlich `TestIncrementalBackup_IsSmallerThanFull`: inkrementelle Sicherung real deutlich kleiner als Vollsicherung (167 KB vs. 16 MB bei der ersten manuellen Probe) — beweist echte inkrementelle Übertragung, nicht nur eine zweite Vollsicherung |
-| 2 | Verifikation erkennt eine absichtlich beschädigte Sicherungsdatei | **bestanden** — `TestVerify_DetectsCorruptedFile`: 64 Bytes in der Mitte von `base.tar.gz` gekippt, `Verify` schlägt danach fehl (unbeschädigt zuvor erfolgreich) |
-| 3 | Rotationsregel entfernt nachweislich nur die ältesten Generationen | **bestanden** — `TestRotate_RemovesOnlyOldestGenerations`: 5 Generationen, `keep=2`, exakt die 3 ältesten entfernt, die 2 neuesten nachweislich unangetastet |
-
-## Echte Verdrahtung auf 192.168.1.131 (nicht nur Testcode)
-
-Anders als die zuletzt in DMS gefundenen "Baustein existiert, ist aber
-nirgends verdrahtet"-Fälle (FDN-03/FDN-09 gegen Core) wurde hier die
-komplette Kette tatsächlich installiert und ausgeführt:
-
-- `backup-cli` gebaut nach `/opt/nexarch-archive/bin/`
-- `/etc/nexarch/archive-backup.env` mit den Verbindungsdaten (0600)
-- 3 systemd-Timer installiert und aktiviert (`enable --now`):
-  Vollsicherung täglich 02:00 UTC, Inkrement stündlich, Rotation täglich
-  03:00 UTC (`systemctl list-timers` bestätigt alle drei scharf)
-- Jeder der drei Dienste (`full`/`incremental`/`rotate`) einmal manuell über
-  `systemctl start` ausgelöst (nicht nur `go test` direkt) — alle drei mit
-  `status=0/SUCCESS`, Journal bestätigt inhaltlich korrekte Ausgabe
-  (Vollsicherung erstellt+verifiziert, Inkrement erstellt+verifiziert
-  gegen die richtige Vorgänger-Generation, Rotation lief ohne Fehler)
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 4/4 Tests ok, 0 Fehlschläge (echter Postgres 17, kein Mock)
-```
-
-## Nachtrag (BAK-02-Sitzung): Backup-Zielverzeichnis korrigiert
-
-`NEXARCH_BACKUP_DIR` zeigte ursprünglich auf `/var/backups/nexarch`
-(Root-Dateisystem des Containers, kein dediziertes Dataset) — korrigiert auf
-`/var/nexarch-archiv/backups/postgres` (persistentes ZFS-Dataset), siehe
-`docs/BAK-02-PRUEFPROTOKOLL.md` Abschnitt „Korrektur an BAK-01" für Details.
-Vollsicherung nach der Korrektur erneut über systemd ausgelöst, landet
-nachweislich am neuen Ort.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt — inklusive tatsächlicher systemd-Timer-Installation und
-manuell ausgelöstem End-to-End-Lauf aller drei Dienste auf dem Testhost,
-nicht nur isolierter Testcode.

archive/docs/BAK-02-PRUEFPROTOKOLL.md

@@ -1,93 +0,0 @@
-# BAK-02 – Prüfprotokoll: Objekt-Storage-Backup/Snapshots
-
-Welle 1, keine Vorbedingungen.
-
-## Grundsatzentscheidung: restic statt Eigenbau
-
-Nutzerentscheidung: restic statt einer Neuimplementierung, weil restic alle
-vier Akzeptanzkriterien mit ausgereiftem, breit geprüftem Tooling erfüllt
-(Content-defined Chunking für Dedup, `check --read-data` für
-Vollständigkeit, `forget --keep-last` für Rotation, Repository-Verschlüsselung
-ab Werk). Installiert via `apt-get install restic` (Version 0.18.0).
-
-Backup-Quelle ist ein lokaler Verzeichnisbaum — für den FDN-03-`LocalDriver`
-direkt dessen Basisverzeichnis. Für S3-gestützte Produktions-Deployments
-(Betriebsmodus 2/3 aus `STORAGE-KONZEPT.md` Abschnitt 6.2) wäre ein
-vorgelagerter Sync-Schritt (z. B. `rclone`) nötig, um Bucket-Inhalte lokal
-zu spiegeln, bevor restic sie sichert — restic sichert Dateibäume, keine
-S3-Buckets direkt. Das bleibt hier bewusst unimplementiert (kein konkreter
-S3-Produktionsbestand vorhanden, der das aktuell erfordert), aber
-architektonisch vorgesehen und dokumentiert (`README.md`).
-
-## Umsetzung
-
-- `internal/objectbackup.InitRepo` — idempotent, erkennt "bereits
-  initialisiert" am `restic init`-Fehlertext statt zu scheitern.
-- `internal/objectbackup.Backup` — `restic backup --json`, parst die
-  `summary`-Zeile (mehrere JSON-Zeilen in der Ausgabe, gezielt die mit
-  `message_type=="summary"` gesucht).
-- `internal/objectbackup.Check` — `restic check [--read-data]` (Akzeptanz-
-  kriterium 3: Vollständigkeitsprüfung).
-- `internal/objectbackup.Forget` — `restic forget --keep-last N --prune`
-  (Rotation).
-- `cmd/objectbackup-cli` — `backup <dir>`/`check`/`rotate`, aufgerufen von
-  systemd-Timern (stündlich/wöchentlich/täglich).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Zweiter Sicherungslauf nach unverändertem Bestand überträgt keine Daten erneut | **bestanden** — `TestBackup_UnchangedSecondRunTransmitsNothingNew`: zweiter Lauf gegen unveränderten Bestand liefert `files_new=0`, `files_changed=0`, `files_unmodified=1` |
-| 2 | Zwei identische Testdateien belegen nachweislich nur einmal Speicherplatz | **bestanden** — `TestBackup_DeduplicatesIdenticalContent`: zwei Dateien mit identischem Inhalt erzeugen `data_blobs=1`, nicht 2 — echter Dedup-Nachweis über restics Content-defined Chunking, nicht nur Namensvergleich |
-| 3 | Vollständigkeitsprüfung erkennt ein fehlendes Objekt in der Sicherung | **bestanden** — `TestCheck_DetectsCorruptedPack`: ein Byte in einer echten Repository-Pack-Datei gekippt, `Check(readData=true)` schlägt danach fehl (unbeschädigt zuvor erfolgreich) — dieselbe Vorgehensweise wie die manuelle Recherche vor der Implementierung |
-
-Zusätzlich (nicht explizit als Pflichtprüfung gefordert, aber Teil von
-Akzeptanzkriterium 3 „lässt sich einzeln prüfen"): `TestForget_
-KeepsOnlyRequestedSnapshotCount` — 3 Sicherungsläufe, `Forget(keepLast=1)`
-reduziert auf genau 1 verbleibenden Snapshot.
-
-## Korrektur an BAK-01 im selben Rutsch: Backup-Zielverzeichnis
-
-Nutzerhinweis aufgegriffen: `NEXARCH_BACKUP_DIR` zeigte bei BAK-01
-ursprünglich auf `/var/backups/nexarch` (Root-Dateisystem des LXC-
-Containers, nicht auf einem der beiden dedizierten ZFS-Datasets). Korrigiert
-auf `/var/nexarch-archiv/backups/postgres` (persistentes Dataset
-`zfs/data/subvol-1131-disk-0`), NICHT `/var/nexarch-test/` (ephemeres
-Dataset `ssd-rpool-data/swap/subvol-1131-disk-0`, wird von
-`reset-test-env.sh`-Skripten anderer Module geleert). `objectbackup-cli`s
-Repository liegt von Anfang an korrekt unter
-`/var/nexarch-archiv/backups/objects`. Beide Pfade real auf
-192.168.1.131 verifiziert (`df`/`mount` bestätigt ZFS-Dataset-Zuordnung),
-BAK-01s Vollsicherung nach der Korrektur erneut über systemd ausgelöst und
-bestätigt am neuen Ort gelandet.
-
-ZFS-seitige Snapshot-/Replikations-Strategie für `nexarch/archiv` bleibt
-bewusst außerhalb dieses Tickets (Infra-Runbook, siehe
-`STORAGE-KONZEPT.md` Abschnitt 7 „Backup vs. Storage-Redundanz" sowie den
-Hinweis, `zfs dedup=on` NICHT zu setzen — App-seitige Dedup über restic
-genügt, ZFS-Dedup wäre auf dem 4-GB-Testhost ein Speicherrisiko).
-
-## Echte Verdrahtung auf 192.168.1.131
-
-- `objectbackup-cli` gebaut nach `/opt/nexarch-archive/bin/`
-- `/etc/nexarch/archive-objectbackup.env` (0600)
-- 3 systemd-Timer installiert und aktiviert: Sicherung stündlich (`:30`),
-  Vollständigkeitsprüfung wöchentlich (So. 04:00 UTC), Rotation täglich
-  (03:30 UTC) — `systemctl list-timers` bestätigt alle scharf
-- Jeder der drei Dienste einmal über `systemctl start` ausgelöst, alle mit
-  `status=0/SUCCESS`; Journal bestätigt inhaltlich korrekte Ausgabe
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 2/2 Pakete mit Tests ok (internal/backup, internal/objectbackup), 0 Fehlschläge
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real gegen echtes restic-Tooling erfüllt. BAK-01-Pfadfehler im selben
-Rutsch korrigiert und erneut end-to-end verifiziert.

archive/go.mod

@@ -1,3 +0,0 @@
-module gitea.perlbach24.de/scripte/nexarch/archive
-
-go 1.22

archive/internal/backup/backup.go

@@ -1,102 +0,0 @@
-// Package backup implementiert BAK-01: automatisierte, inkrementelle
-// Sicherung der PostgreSQL-Datenbank per pg_basebackup (PostgreSQL 17s
-// natives inkrementelles Backup über WAL-Summarization, siehe
-// `summarize_wal`), mit Verifikation jeder Sicherung und
-// generationsbasierter Rotation. Kein pg_dump-basierter Ansatz, weil
-// pg_dump ausschließlich logische Vollsicherungen kennt — "inkrementell"
-// im Sinne des Tickets erfordert das physische, WAL-summary-gestützte
-// Verfahren aus PostgreSQL 17.
-package backup
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"time"
-)
-
-// Config enthält die Verbindungsdaten für pg_basebackup — ausschließlich
-// über Umgebungsvariablen befüllt, nie im Code (siehe Ticket-Abschluss-
-// Regel).
-type Config struct {
-	Host             string
-	Port             string
-	User             string
-	Password         string
-	BackupDir        string
-	PgBaseBackupPath string // Default "pg_basebackup", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.PgBaseBackupPath != "" {
-		return c.PgBaseBackupPath
-	}
-	return "pg_basebackup"
-}
-
-// FullBackupDirName/IncrementalDirName sind die festen Unterverzeichnis-
-// namen je Generation.
-const (
-	FullBackupDirName  = "full"
-	IncrementalSubdir  = "incremental"
-	BackupManifestFile = "backup_manifest"
-	BaseTarGzFile      = "base.tar.gz"
-)
-
-// NewGenerationID liefert eine sortierbare, eindeutige Generation-Kennung
-// (RFC3339-artig, dateisystemtauglich) — Generationen werden anhand dieser
-// Kennung chronologisch sortiert (Rotate, ListGenerations).
-func NewGenerationID(t time.Time) string {
-	return t.UTC().Format("20060102T150405Z")
-}
-
-// FullBackup erstellt eine neue Vollsicherung (Akzeptanzkriterium 1) als
-// eigene Generation. Liefert den Pfad zum backup_manifest, das spätere
-// IncrementalBackup-Aufrufe als Referenz brauchen.
-func FullBackup(ctx context.Context, cfg Config, generationID string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, FullBackupDirName)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: generationsverzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: vollsicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-// IncrementalBackup erstellt eine inkrementelle Sicherung gegen die zuletzt
-// bekannte Vollsicherung ODER die letzte Inkrement-Sicherung (priorManifestPath
-// zeigt jeweils auf das backup_manifest der Referenz).
-func IncrementalBackup(ctx context.Context, cfg Config, generationID, incrementID, priorManifestPath string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, IncrementalSubdir, incrementID)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: inkrement-verzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-		"--incremental=" + priorManifestPath,
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: inkrementelle sicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-func runPgBaseBackup(ctx context.Context, cfg Config, args []string) error {
-	cmd := exec.CommandContext(ctx, cfg.binary(), args...)
-	cmd.Env = append(os.Environ(), "PGPASSWORD="+cfg.Password)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("%s fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), err, string(output))
-	}
-	return nil
-}

archive/internal/backup/backup_test.go

@@ -1,187 +0,0 @@
-package backup
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func requireTestConfig(t *testing.T) Config {
-	t.Helper()
-	user := os.Getenv("TEST_BACKUP_PG_USER")
-	if user == "" {
-		t.Skip("TEST_BACKUP_PG_USER nicht gesetzt, Integrationstest uebersprungen (braucht echten Postgres mit REPLICATION-Rolle)")
-	}
-	return Config{
-		Host:      envOr("TEST_BACKUP_PG_HOST", "localhost"),
-		Port:      envOr("TEST_BACKUP_PG_PORT", "5432"),
-		User:      user,
-		Password:  os.Getenv("TEST_BACKUP_PG_PASSWORD"),
-		BackupDir: t.TempDir(),
-	}
-}
-
-func envOr(key, fallback string) string {
-	if v := os.Getenv(key); v != "" {
-		return v
-	}
-	return fallback
-}
-
-// TestFullBackup_CreatesVerifiedBackup ist Pruefung 1: Sicherung gegen
-// Testdatenbank erfolgreich erstellt und verifiziert.
-func TestFullBackup_CreatesVerifiedBackup(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	if _, err := os.Stat(manifest); err != nil {
-		t.Fatalf("backup_manifest fehlt: %v", err)
-	}
-
-	dir := filepath.Dir(manifest)
-	if _, err := os.Stat(filepath.Join(dir, BaseTarGzFile)); err != nil {
-		t.Fatalf("%s fehlt: %v", BaseTarGzFile, err)
-	}
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-}
-
-// TestIncrementalBackup_IsSmallerThanFull ist der Nachweis fuer
-// Akzeptanzkriterium 1 (inkrementell): eine echte inkrementelle Sicherung
-// gegen unveraenderten Bestand ist deutlich kleiner als die Vollsicherung —
-// beweist, dass tatsaechlich nur Aenderungen uebertragen wurden (PostgreSQL
-// 17 WAL-Summarization), nicht nochmal alles.
-func TestIncrementalBackup_IsSmallerThanFull(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	fullManifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	fullDir := filepath.Dir(fullManifest)
-	fullSize := fileSize(t, filepath.Join(fullDir, BaseTarGzFile))
-
-	incID := NewGenerationID(time.Now().Add(time.Second))
-	incManifest, err := IncrementalBackup(ctx, cfg, genID, incID, fullManifest)
-	if err != nil {
-		t.Fatalf("incrementalbackup: %v", err)
-	}
-	incDir := filepath.Dir(incManifest)
-	if err := Verify(incDir); err != nil {
-		t.Fatalf("verify (inkrementell): %v", err)
-	}
-	incSize := fileSize(t, filepath.Join(incDir, BaseTarGzFile))
-
-	if incSize >= fullSize {
-		t.Fatalf("inkrementelle sicherung (%d bytes) ist nicht kleiner als die vollsicherung (%d bytes) - keine echte inkrementelle Uebertragung", incSize, fullSize)
-	}
-}
-
-func fileSize(t *testing.T, path string) int64 {
-	t.Helper()
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatalf("dateigroesse von %q ermitteln: %v", path, err)
-	}
-	return info.Size()
-}
-
-// TestVerify_DetectsCorruptedFile ist Pruefung 2: Verifikation erkennt eine
-// absichtlich beschaedigte Sicherungsdatei.
-func TestVerify_DetectsCorruptedFile(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	dir := filepath.Dir(manifest)
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: mehrere Bytes in der Mitte der Datei kippen.
-	path := filepath.Join(dir, BaseTarGzFile)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("sicherungsdatei lesen: %v", err)
-	}
-	mid := len(data) / 2
-	for i := mid; i < mid+64 && i < len(data); i++ {
-		data[i] ^= 0xFF
-	}
-	if err := os.WriteFile(path, data, 0o600); err != nil {
-		t.Fatalf("beschaedigte sicherungsdatei schreiben: %v", err)
-	}
-
-	if err := Verify(dir); err == nil {
-		t.Fatal("verify haette die beschaedigte sicherungsdatei erkennen muessen")
-	}
-}
-
-// TestRotate_RemovesOnlyOldestGenerations ist Pruefung 3.
-func TestRotate_RemovesOnlyOldestGenerations(t *testing.T) {
-	backupDir := t.TempDir()
-	generationIDs := []string{
-		"20260101T000000Z",
-		"20260102T000000Z",
-		"20260103T000000Z",
-		"20260104T000000Z",
-		"20260105T000000Z",
-	}
-	for _, id := range generationIDs {
-		if err := os.MkdirAll(filepath.Join(backupDir, id, FullBackupDirName), 0o750); err != nil {
-			t.Fatalf("generation %q anlegen: %v", id, err)
-		}
-	}
-
-	removed, err := Rotate(backupDir, 2)
-	if err != nil {
-		t.Fatalf("rotate: %v", err)
-	}
-	wantRemoved := []string{"20260101T000000Z", "20260102T000000Z", "20260103T000000Z"}
-	if len(removed) != len(wantRemoved) {
-		t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-	}
-	for i, w := range wantRemoved {
-		if removed[i] != w {
-			t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-		}
-	}
-
-	remaining, err := ListGenerations(backupDir)
-	if err != nil {
-		t.Fatalf("listgenerations: %v", err)
-	}
-	wantRemaining := []string{"20260104T000000Z", "20260105T000000Z"}
-	if len(remaining) != len(wantRemaining) {
-		t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-	}
-	for i, w := range wantRemaining {
-		if remaining[i] != w {
-			t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-		}
-	}
-
-	// Die NEUESTEN duerfen NICHT entfernt sein (Pruefung 3: nur die
-	// aeltesten Generationen).
-	for _, w := range wantRemaining {
-		if _, err := os.Stat(filepath.Join(backupDir, w)); err != nil {
-			t.Fatalf("neueste generation %q wurde faelschlich entfernt: %v", w, err)
-		}
-	}
-}

archive/internal/backup/rotate.go

@@ -1,56 +0,0 @@
-package backup
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-)
-
-// ListGenerations liefert alle Generation-IDs in backupDir, aufsteigend
-// sortiert (die GenerationID selbst ist chronologisch sortierbar, siehe
-// NewGenerationID — kein Blick auf Dateisystem-Zeitstempel nötig, die bei
-// einem Restore/Kopiervorgang verändert werden könnten).
-func ListGenerations(backupDir string) ([]string, error) {
-	entries, err := os.ReadDir(backupDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, fmt.Errorf("backup: sicherungsverzeichnis lesen: %w", err)
-	}
-	var generations []string
-	for _, e := range entries {
-		if e.IsDir() {
-			generations = append(generations, e.Name())
-		}
-	}
-	sort.Strings(generations)
-	return generations, nil
-}
-
-// Rotate entfernt alle bis auf die `keep` NEUESTEN Generationen
-// (Akzeptanzkriterium 3) — jede Generation umfasst ihre Vollsicherung UND
-// alle davon abhängigen Inkremente, ein Löschen der gesamten
-// Generationsverzeichnisses entfernt beides konsistent zusammen.
-func Rotate(backupDir string, keep int) (removed []string, err error) {
-	if keep < 0 {
-		keep = 0
-	}
-	generations, err := ListGenerations(backupDir)
-	if err != nil {
-		return nil, err
-	}
-	if len(generations) <= keep {
-		return nil, nil
-	}
-
-	toRemove := generations[:len(generations)-keep]
-	for _, gen := range toRemove {
-		if err := os.RemoveAll(filepath.Join(backupDir, gen)); err != nil {
-			return removed, fmt.Errorf("backup: generation %q entfernen: %w", gen, err)
-		}
-		removed = append(removed, gen)
-	}
-	return removed, nil
-}

archive/internal/backup/verify.go

@@ -1,54 +0,0 @@
-package backup
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// ErrCorrupted wird geliefert, wenn eine Sicherungsdatei nicht lesbar ist
-// (Akzeptanzkriterium 2: Verifikation, nicht nur Erstellungs-Prüfung).
-var ErrCorrupted = fmt.Errorf("backup: sicherungsdatei ist beschaedigt oder unvollstaendig")
-
-// Verify prüft, dass base.tar.gz im gegebenen Sicherungsverzeichnis
-// vollständig lesbar ist — öffnet gzip- UND tar-Stream und liest JEDEN
-// Eintrag bis zum Ende durch (nicht nur die Kopfdaten), damit ein
-// abgeschnittener oder mit kaputten Bytes überschriebener Inhalt
-// zuverlässig auffällt, nicht nur ein defekter Tar-Header.
-func Verify(backupDir string) error {
-	path := filepath.Join(backupDir, BaseTarGzFile)
-	f, err := os.Open(path)
-	if err != nil {
-		return fmt.Errorf("%w: %s nicht lesbar: %v", ErrCorrupted, path, err)
-	}
-	defer func() { _ = f.Close() }()
-
-	gz, err := gzip.NewReader(f)
-	if err != nil {
-		return fmt.Errorf("%w: gzip-header ungueltig: %v", ErrCorrupted, err)
-	}
-	defer func() { _ = gz.Close() }()
-
-	tr := tar.NewReader(gz)
-	entries := 0
-	for {
-		hdr, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("%w: tar-eintrag ungueltig: %v", ErrCorrupted, err)
-		}
-		if _, err := io.Copy(io.Discard, tr); err != nil {
-			return fmt.Errorf("%w: inhalt von %q nicht vollstaendig lesbar: %v", ErrCorrupted, hdr.Name, err)
-		}
-		entries++
-	}
-	if entries == 0 {
-		return fmt.Errorf("%w: archiv enthaelt keine eintraege", ErrCorrupted)
-	}
-	return nil
-}

archive/internal/objectbackup/restic.go

@@ -1,156 +0,0 @@
-// Package objectbackup implementiert BAK-02: automatisierte, inkrementelle,
-// deduplizierende Sicherung des Objekt-Storage-Bestands. Nutzt restic
-// (Content-defined Chunking, verschlüsseltes Repository ab Werk) statt
-// Eigenbau — restic erfüllt alle Akzeptanzkriterien mit ausgereiftem,
-// geprüftem Tooling statt einer weniger robusten Neuimplementierung.
-//
-// Backup-Quelle ist ein lokaler Verzeichnisbaum — für den LocalDriver aus
-// FDN-03 direkt dessen Basisverzeichnis, für S3-gestützte Produktions-
-// Deployments ein vorgelagerter Sync-Schritt (z.B. rclone) auf einen
-// lokalen Spiegel, bevor restic ihn sichert (nicht Bestandteil dieser
-// Kachel — restic selbst sichert Dateibäume, keine S3-Buckets direkt).
-package objectbackup
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-// Config enthält Repository-Ort und -Passwort — ausschließlich über
-// Umgebungsvariablen befüllt (siehe Ticket-Abschluss-Regel).
-type Config struct {
-	RepoDir    string
-	Password   string
-	ResticPath string // Default "restic", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.ResticPath != "" {
-		return c.ResticPath
-	}
-	return "restic"
-}
-
-func (c Config) env() []string {
-	return append(os.Environ(), "RESTIC_PASSWORD="+c.Password)
-}
-
-func run(ctx context.Context, cfg Config, args ...string) ([]byte, error) {
-	fullArgs := append([]string{"-r", cfg.RepoDir}, args...)
-	cmd := exec.CommandContext(ctx, cfg.binary(), fullArgs...)
-	cmd.Env = cfg.env()
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return output, fmt.Errorf("%s %v fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), args, err, string(output))
-	}
-	return output, nil
-}
-
-// InitRepo legt ein neues restic-Repository an, falls es noch nicht
-// existiert — idempotent, ein bereits initialisiertes Repository ist kein
-// Fehler (Wiederholte Aufrufe durch systemd-Timer nach einem Neustart
-// dürfen nicht fehlschlagen).
-func InitRepo(ctx context.Context, cfg Config) error {
-	output, err := run(ctx, cfg, "init")
-	if err != nil {
-		if strings.Contains(string(output), "config file already exists") {
-			return nil
-		}
-		return fmt.Errorf("objectbackup: repository initialisieren: %w", err)
-	}
-	return nil
-}
-
-// BackupSummary ist der geparste "summary"-Datensatz aus `restic backup --json`.
-type BackupSummary struct {
-	SnapshotID      string `json:"snapshot_id"`
-	FilesNew        int    `json:"files_new"`
-	FilesChanged    int    `json:"files_changed"`
-	FilesUnmodified int    `json:"files_unmodified"`
-	DataBlobs       int    `json:"data_blobs"`
-	TotalBytes      int64  `json:"total_bytes_processed"`
-}
-
-// Backup sichert sourceDir inkrementell (Akzeptanzkriterium 1: unveränderte
-// Objekte werden nicht erneut übertragen — restics Content-defined
-// Chunking erkennt das automatisch, kein manueller Änderungsabgleich
-// nötig).
-func Backup(ctx context.Context, cfg Config, sourceDir string) (BackupSummary, error) {
-	output, err := run(ctx, cfg, "backup", sourceDir, "--json")
-	if err != nil {
-		return BackupSummary{}, fmt.Errorf("objectbackup: sicherung: %w", err)
-	}
-	return parseSummary(output)
-}
-
-// parseSummary sucht in der zeilenweisen JSON-Ausgabe von `restic backup
-// --json` (mehrere Fortschritts-/Statuszeilen, GENAU EINE mit
-// message_type=="summary") die Zusammenfassung.
-func parseSummary(output []byte) (BackupSummary, error) {
-	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-	for i := len(lines) - 1; i >= 0; i-- {
-		var probe struct {
-			MessageType string `json:"message_type"`
-		}
-		if err := json.Unmarshal([]byte(lines[i]), &probe); err != nil {
-			continue
-		}
-		if probe.MessageType == "summary" {
-			var summary BackupSummary
-			if err := json.Unmarshal([]byte(lines[i]), &summary); err != nil {
-				return BackupSummary{}, fmt.Errorf("objectbackup: summary-zeile dekodieren: %w", err)
-			}
-			return summary, nil
-		}
-	}
-	return BackupSummary{}, fmt.Errorf("objectbackup: keine summary-zeile in der restic-ausgabe gefunden")
-}
-
-// Check prüft die Vollständigkeit/Lesbarkeit des Repository
-// (Akzeptanzkriterium 3 / Pflichtprüfung: Vollständigkeitsprüfung erkennt
-// fehlendes/beschädigtes Objekt). readData=true liest jeden gespeicherten
-// Datenblock tatsächlich (teurer, aber die einzige Prüfung, die
-// Bit-Rot in bereits gespeicherten Paketen erkennt — ohne readData prüft
-// restic nur Struktur/Indizes, nicht den tatsächlichen Blockinhalt).
-func Check(ctx context.Context, cfg Config, readData bool) error {
-	args := []string{"check"}
-	if readData {
-		args = append(args, "--read-data")
-	}
-	if _, err := run(ctx, cfg, args...); err != nil {
-		return fmt.Errorf("objectbackup: %w", err)
-	}
-	return nil
-}
-
-// Forget entfernt alte Snapshots nach Rotationsregel und gibt den davon
-// belegten Speicherplatz frei (--prune) — restics Äquivalent zu
-// BAK-01s Rotate.
-func Forget(ctx context.Context, cfg Config, keepLast int) error {
-	if _, err := run(ctx, cfg, "forget", "--keep-last", fmt.Sprintf("%d", keepLast), "--prune"); err != nil {
-		return fmt.Errorf("objectbackup: rotation: %w", err)
-	}
-	return nil
-}
-
-type snapshotEntry struct {
-	ShortID string `json:"short_id"`
-}
-
-// SnapshotCount liefert die Anzahl vorhandener Snapshots — für Tests und
-// Statusabfragen.
-func SnapshotCount(ctx context.Context, cfg Config) (int, error) {
-	output, err := run(ctx, cfg, "snapshots", "--json")
-	if err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshots auflisten: %w", err)
-	}
-	var snapshots []snapshotEntry
-	if err := json.Unmarshal(output, &snapshots); err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshot-liste dekodieren: %w", err)
-	}
-	return len(snapshots), nil
-}

archive/internal/objectbackup/restic_test.go

@@ -1,168 +0,0 @@
-package objectbackup
-
-import (
-	"context"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-func requireRestic(t *testing.T) {
-	t.Helper()
-	if _, err := exec.LookPath("restic"); err != nil {
-		t.Skip("restic nicht installiert, Integrationstest uebersprungen")
-	}
-}
-
-func setupTest(t *testing.T) Config {
-	t.Helper()
-	requireRestic(t)
-	cfg := Config{RepoDir: filepath.Join(t.TempDir(), "repo"), Password: "test-passwort-fuer-objectbackup"}
-	if err := InitRepo(context.Background(), cfg); err != nil {
-		t.Fatalf("initrepo: %v", err)
-	}
-	return cfg
-}
-
-func writeFile(t *testing.T, dir, name, content string) {
-	t.Helper()
-	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
-		t.Fatalf("testdatei %q schreiben: %v", name, err)
-	}
-}
-
-// TestBackup_UnchangedSecondRunTransmitsNothingNew ist Pruefung 1:
-// zweiter Sicherungslauf nach unveraendertem Bestand ueberraegt keine
-// Daten erneut.
-func TestBackup_UnchangedSecondRunTransmitsNothingNew(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "dokument.pdf", "unveraenderter inhalt")
-
-	first, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("erste sicherung: %v", err)
-	}
-	if first.FilesNew != 1 {
-		t.Fatalf("erste sicherung: files_new = %d, want 1", first.FilesNew)
-	}
-
-	second, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("zweite sicherung: %v", err)
-	}
-	if second.FilesNew != 0 || second.FilesChanged != 0 {
-		t.Fatalf("zweite sicherung (unveraendert): files_new=%d files_changed=%d, want beide 0", second.FilesNew, second.FilesChanged)
-	}
-	if second.FilesUnmodified != 1 {
-		t.Fatalf("zweite sicherung: files_unmodified = %d, want 1", second.FilesUnmodified)
-	}
-}
-
-// TestBackup_DeduplicatesIdenticalContent ist Pruefung 2: zwei identische
-// Testdateien belegen nachweislich nur einmal Speicherplatz.
-func TestBackup_DeduplicatesIdenticalContent(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	content := "exakt identischer inhalt in beiden dateien fuer den dedup-nachweis"
-	writeFile(t, sourceDir, "original.pdf", content)
-	writeFile(t, sourceDir, "kopie.pdf", content)
-
-	summary, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if summary.FilesNew != 2 {
-		t.Fatalf("erwartet 2 neue dateien, habe %d", summary.FilesNew)
-	}
-	// Zwei Dateien mit IDENTISCHEM Inhalt duerfen nur EINEN data_blob
-	// erzeugen - das ist der Dedup-Nachweis (Akzeptanzkriterium 2).
-	if summary.DataBlobs != 1 {
-		t.Fatalf("data_blobs = %d, want 1 (zwei identische dateien haetten nur einen blob erzeugen duerfen - keine dedup)", summary.DataBlobs)
-	}
-}
-
-// TestCheck_DetectsCorruptedPack ist Pruefung 3: Vollstaendigkeitspruefung
-// erkennt ein beschaedigtes/fehlendes Objekt in der Sicherung.
-func TestCheck_DetectsCorruptedPack(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "wichtig.pdf", "inhalt, der spaeter absichtlich beschaedigt wird")
-
-	if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if err := Check(ctx, cfg, true); err != nil {
-		t.Fatalf("check (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: ein Byte in einer Pack-Datei im
-	// Repository kippen (dieselbe Fundstelle wie beim manuellen
-	// Nachweis waehrend der Recherche zu diesem Ticket).
-	packDir := filepath.Join(cfg.RepoDir, "data")
-	corrupted := false
-	if err := filepath.Walk(packDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil || info.IsDir() || corrupted {
-			return err
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		if len(data) < 20 {
-			return nil
-		}
-		data[10] ^= 0xFF
-		if err := os.WriteFile(path, data, 0o600); err != nil {
-			return err
-		}
-		corrupted = true
-		return nil
-	}); err != nil {
-		t.Fatalf("pack-datei beschaedigen: %v", err)
-	}
-	if !corrupted {
-		t.Fatal("keine pack-datei zum beschaedigen gefunden - testaufbau fehlerhaft")
-	}
-
-	if err := Check(ctx, cfg, true); err == nil {
-		t.Fatal("check haette die beschaedigte pack-datei erkennen muessen")
-	}
-}
-
-// TestForget_KeepsOnlyRequestedSnapshotCount prueft die Rotation.
-func TestForget_KeepsOnlyRequestedSnapshotCount(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-
-	for i := 0; i < 3; i++ {
-		writeFile(t, sourceDir, "f.txt", "version "+string(rune('a'+i)))
-		if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-			t.Fatalf("sicherung %d: %v", i, err)
-		}
-	}
-	before, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (vorher): %v", err)
-	}
-	if before != 3 {
-		t.Fatalf("erwartet 3 snapshots vor rotation, habe %d", before)
-	}
-
-	if err := Forget(ctx, cfg, 1); err != nil {
-		t.Fatalf("forget: %v", err)
-	}
-
-	after, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (nachher): %v", err)
-	}
-	if after != 1 {
-		t.Fatalf("erwartet 1 snapshot nach rotation (keep-last 1), habe %d", after)
-	}
-}

cmd/core/main.go

@@ -7,6 +7,8 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 
 func main() {
@@ -15,16 +17,38 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}
 
-	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
+	ctx := context.Background()
+
+	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("db: %v", err)
+		log.Fatalf("registry db: %v", err)
 	}
-	defer pool.Close()
+	defer registryPool.Close()
+
+	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
+	if err != nil {
+		log.Fatalf("admin db: %v", err)
+	}
+	defer adminPool.Close()
+
+	registry := tenant.NewRegistry(registryPool)
+	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
+	tenantHandler := tenant.NewHandler(provisioner)
+
+	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
+	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
+	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
+	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
+	superadmins := user.NewSuperadminStore(registryPool)
+	userHandler := user.NewHandler(nil, superadmins)
 
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
+	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
+	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
+	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

deploy/systemd/nexarch-archive-backup-full.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Vollsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli full

deploy/systemd/nexarch-archive-backup-full.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Datenbank-Vollsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 02:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-backup-incremental.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Inkrementalsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli incremental

deploy/systemd/nexarch-archive-backup-incremental.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Datenbank-Inkrementalsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* *:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-backup-rotate.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Sicherungsgenerationen-Rotation (BAK-01)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli rotate

deploy/systemd/nexarch-archive-backup-rotate.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Sicherungsgenerationen-Rotation (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 03:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-backup.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli backup __OBJECT_SOURCE_DIR__

deploy/systemd/nexarch-archive-objectbackup-backup.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Sicherung (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* *:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-check.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Vollstaendigkeitspruefung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli check

deploy/systemd/nexarch-archive-objectbackup-check.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Woechentlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Vollstaendigkeitspruefung (BAK-02)
-
-[Timer]
-OnCalendar=Sun *-*-* 04:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-rotate.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Rotation (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli rotate

deploy/systemd/nexarch-archive-objectbackup-rotate.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Rotation (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* 03:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

docs/QA-03-PRUEFPROTOKOLL.md

@@ -0,0 +1,68 @@
+# QA-03 – Prüfprotokoll: Prüfgate Rechte & Policy
+
+Stand: 2026-08-29. Branch `feature/qa-03-pruefgate-rechte-policy` (RBAC-05 + RBAC-04 gemergt).
+
+## 1. Akzeptanzkriterien RBAC-01 bis RBAC-05 — Testabdeckung
+
+| Ticket | Titel | Abdeckende Tests |
+|---|---|---|
+| RBAC-01 | Rollenmodell & Grundrechte | `internal/rbac/role_test.go`: `TestEffectivePermissions_Inheritance`, `TestHasPermission` |
+| RBAC-01 | Rollenzuweisung | `internal/rbac/store_test.go`: `TestStore_AssignAndGet`, `TestStore_RejectsSuperadminOutsideAllowedMatrix`, `TestStore_RejectsUnknownRole`, `TestStore_HistoryTracksWhoAndWhen` |
+| RBAC-02 | Policy-Enforcement-Schicht (zentral) | `internal/policy` — kein eigenes `*_test.go` in diesem Merge gefunden für `enforcer.go`/`store.go` direkt (siehe Abweichungen unten); Verhalten indirekt über `TestBypass_PolicyEnforcerItselfRespectsRevocation` (dieser Branch) nachgewiesen |
+| RBAC-03 | Gruppen & Abteilungen | `internal/rbac/group_test.go`: `TestGroup_CreateAndAddMember`, `TestGroup_RoleAffectsAllCurrentMembers`, `TestGroup_RemoveMemberRevokesRightsImmediately`, `TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser`, `TestGroup_TenantIsolation` |
+| RBAC-04 | Modul-scoped Berechtigungen | `internal/policy/module_scope_test.go`: `TestAuthorizeForTenant_DeniesWhenModuleNotActivated`, `TestAuthorizeForTenant_BecomesActiveWithoutRestart`, `TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope` |
+| RBAC-05 | Rechte-Administrationsoberfläche | `internal/rbac/handler_test.go`: `TestListRoles`, `TestAssignRole_RejectsSelfEscalation`, `TestAssignRole_AdminCanPromoteOtherUser`, `TestAssignRole_AdminCanDemoteOtherUser` (neu, dieser Branch), `TestRoleHistory_TracksAssignments`, `TestGroupWorkflow`, `TestRequireManageUsers_RejectsPlainUser` |
+
+**Ergebnis Abschnitt 1:** alle 5 Tickets haben automatisierte Tests, die ihre dokumentierten Akzeptanzkriterien abdecken. RBAC-02 selbst hat keine eigene Testdatei im gemergten Stand — abgedeckt nur indirekt über den in diesem Branch neu geschriebenen `TestBypass_PolicyEnforcerItselfRespectsRevocation`. Als Abweichung festgehalten (Abschnitt 4).
+
+## 2. Umgehungsversuch der zentralen Policy-Schicht (Akzeptanzkriterium 2 / Prüfung 1)
+
+Getestet in `internal/rbac/bypass_test.go`:
+
+- **`TestBypass_NoDirectWriteAPIOutsideStore`**: bestanden. `role_assignments` hat keine Schreib-API außerhalb von `Store.Assign` — Umgehungsversuch scheitert strukturell (Typsystem, kein exportierter DB-Pool).
+- **`TestBypass_PolicyEnforcerItselfRespectsRevocation`**: bestanden. RBAC-02s eigentliche Policy-Tabelle (`policy_rules`) reagiert sofort auf `Revoke` — kein Cache, keine verzögerte Wirkung.
+- **`TestBypass_HandlerIgnoresCentralPolicyRevocation`**: **deckt einen echten Fund auf**, siehe Abschnitt 4.
+
+## 3. Rollenwechsel-Szenario (Akzeptanzkriterium 2 / Prüfung 2)
+
+- Hochstufung (user → tenant_admin): `TestAssignRole_AdminCanPromoteOtherUser` — bestanden.
+- Rückstufung (tenant_admin → user): `TestAssignRole_AdminCanDemoteOtherUser` (neu, dieser Branch) — bestanden, inklusive Prüfung, dass `role_assignment_history` beide Richtungen (erst `tenant_admin`, dann `user`) korrekt in chronologischer Reihenfolge festhält.
+- Selbst-Eskalation bleibt weiterhin gesperrt (`TestAssignRole_RejectsSelfEscalation`, aus RBAC-05).
+
+**Ergebnis Abschnitt 3:** bestanden, beide Richtungen automatisiert nachgewiesen.
+
+## 4. Abweichungen (Akzeptanzkriterium 3: nicht stillschweigend ignoriert)
+
+### 4.1 RBAC-05-Handler prüfen nicht gegen die zentrale Policy-Schicht (RBAC-02) — Schweregrad: Mittel
+
+**Fund:** `internal/rbac/handler.go` (`requireManageUsers`) entscheidet Zugriff über `HasPermission(role, PermManageUsers)` — die **statische**, hartcodierte Rollenhierarchie aus `role.go`. Es ruft nirgends `internal/policy.Enforcer.Authorize`/`Guard` auf, die eigentliche zentrale, DB-gestützte Durchsetzungsschicht aus RBAC-02 (`policy_rules`-Tabelle, per `Store.Grant`/`Revoke` administrierbar, versioniert in `policy_rule_changes`).
+
+**Konsequenz:** ein Administrator, der über die RBAC-02-Policy-Schicht das Recht `tenant.manage_users` von `tenant_admin` entzieht (`policy.Store.Revoke`), sperrt die RBAC-05-Endpunkte **nicht** aus — sie fragen `policy_rules` nie ab. Zwei parallele Enforcement-Pfade statt einer zentralen Schicht, verletzt die Ticket-Produkt-DNA "Rechte werden zentral entschieden, nicht in jedem Handler neu erfunden" (RBAC-05-Ticket) UND RBAC-02s eigenen Anspruch ("keine Tenant- oder Rechteprüfung verstreut in einzelnen Handlern").
+
+**Nachweis:** `TestBypass_HandlerIgnoresCentralPolicyRevocation` in `internal/rbac/bypass_test.go`.
+
+**Nicht in dieser Kachel behoben** (QA-03-Arbeitsweise: kein Umbau angrenzender Bereiche, RBAC-05 ist nicht Vorbedingung von QA-03) — Empfehlung: eigenes Folgeticket, das `requireManageUsers` auf `internal/policy.Guard`/`Enforcer.Authorize` umstellt.
+
+### 4.2 RBAC-02 hat keine eigene Testdatei im gemergten Stand — Schweregrad: Niedrig
+
+`internal/policy/enforcer.go` und `store.go` (RBAC-02 selbst) haben keine `enforcer_test.go`/`store_test.go` im Merge-Ergebnis dieses Branches — nur `module_scope_test.go` (RBAC-04) prüft sie indirekt über `AuthorizeForTenant`. Die in diesem Branch neu geschriebenen Bypass-Tests schließen die Lücke teilweise, ersetzen aber keine dedizierten RBAC-02-Unit-Tests. Empfehlung: bei Gelegenheit nachziehen, kein blockierender Fund.
+
+## 5. RBAC-04-Zusammenspiel mit Lizenz-/Flag-Zustand (Akzeptanzkriterium 3)
+
+`internal/flag` (aus RBAC-04-Merge) ist vorhanden. `internal/policy.Enforcer.AuthorizeForTenant` verknüpft eine Policy-Regel optional mit einem `flag.Service`-Eintrag (`ModuleScope.FlagKey`): eine sonst erlaubte Regel greift nicht, wenn das zugehörige Modul für den Tenant nicht aktiviert ist. `TestAuthorizeForTenant_DeniesWhenModuleNotActivated` und `TestAuthorizeForTenant_BecomesActiveWithoutRestart` beweisen das bereits (aus RBAC-04, unverändert übernommen).
+
+**Ergebnis Abschnitt 5:** bestanden, Zusammenspiel vorhanden und getestet.
+
+## 6. Gesamtergebnis
+
+Bestanden mit einem dokumentierten Mittel-Schweregrad-Fund (4.1) und einem Niedrig-Schweregrad-Hinweis (4.2). Build-/Test-Ergebnis auf dem Testhost: siehe Abschnitt 7.
+
+## 7. Build/Test-Ergebnis auf 131
+
+Durchgeführt 2026-08-29 auf root@192.168.1.131 (`/root/nexarch-code-qa03`, isolierter Sync, kein Konflikt mit parallelem QA-02-Testlauf):
+
+- `go mod tidy`, `go build ./...`, `go vet ./...` — alle sauber, keine Fehler.
+- `go test ./... -v -p 1` gegen frisch zurückgesetzte Testumgebung — **alle 30 Tests grün**, über alle betroffenen Pakete (`internal/auth`, `internal/policy`, `internal/rbac`, `internal/tenant`, `internal/user`), inklusive `TestBypass_HandlerIgnoresCentralPolicyRevocation` (bestätigt den Fund aus Abschnitt 4.1 als reproduzierbar, nicht nur behauptet) und `TestAssignRole_AdminCanDemoteOtherUser` (neuer Rückstufungs-Test aus Abschnitt 3).
+- Keine Regressionen in RBAC-01/02/03/04/05 durch den Merge.
+
+**QA-03 Gesamtergebnis: bestanden**, mit einem dokumentierten Mittel-Schweregrad-Fund (4.1, Empfehlung: Folgeticket) und einem Niedrig-Schweregrad-Hinweis (4.2).

go.mod

@@ -2,4 +2,16 @@ module gitea.perlbach24.de/scripte/nexarch
 
 go 1.22
 
-require github.com/jackc/pgx/v5 v5.6.0
+require (
+	github.com/golang-jwt/jwt/v5 v5.3.1
+	github.com/jackc/pgx/v5 v5.6.0
+	golang.org/x/crypto v0.17.0
+)
+
+require (
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)

go.sum

@@ -0,0 +1,30 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/auth/handler.go

@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+)
+
+// Handler stellt Login/Logout als HTTP-Endpunkte bereit. Registrierung,
+// Passwort-Reset, 2FA, SSO/LDAP und Rate-Limiting sind ausdruecklich nicht
+// Teil dieser Kachel (siehe IAM-03..07).
+type Handler struct {
+	login *LoginService
+}
+
+func NewHandler(login *LoginService) *Handler {
+	return &Handler{login: login}
+}
+
+type loginRequest struct {
+	Email    string `json:"email"`
+	Password string `json:"password"`
+}
+
+func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
+	var req loginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	token, err := h.login.Login(r.Context(), req.Email, req.Password)
+	if err != nil {
+		http.Error(w, ErrInvalidCredentials.Error(), http.StatusUnauthorized)
+		return
+	}
+
+	http.SetCookie(w, &http.Cookie{
+		Name:     CookieName,
+		Value:    token,
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteStrictMode,
+		MaxAge:   int(AccessTokenTTL.Seconds()),
+	})
+	w.WriteHeader(http.StatusOK)
+}
+
+// Logout loescht das Session-Cookie. Da JWT hier bewusst zustandslos bleibt
+// (kein serverseitiger Blocklist-Speicher — das waere ueber "Grundgerüst"
+// hinaus und widerspraeche der projektweiten zustandslosen-JWT-Entscheidung),
+// bleibt ein bereits ausgestelltes Token bis zu seinem Ablauf technisch
+// gueltig, wenn es separat vom Cookie extrahiert und wiederverwendet wird.
+func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
+	http.SetCookie(w, &http.Cookie{
+		Name:     CookieName,
+		Value:    "",
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteStrictMode,
+		MaxAge:   -1,
+		Expires:  time.Unix(0, 0),
+	})
+	w.WriteHeader(http.StatusOK)
+}

internal/auth/login.go

@@ -0,0 +1,56 @@
+package auth
+
+import (
+	"context"
+	"errors"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+var ErrInvalidCredentials = errors.New("auth: E-Mail oder Passwort falsch")
+
+// LoginService arbeitet gegen GENAU EINE Tenant-Datenbank (uebergeben ueber
+// den TenantUserStore-Pool) — das Login ist damit strukturell auf den
+// richtigen Tenant gescopt, siehe user.TenantUserStore.GetByEmailForAuth.
+type LoginService struct {
+	users  *user.TenantUserStore
+	issuer *TokenIssuer
+	// tenantSlug identifiziert im ausgestellten Token, gegen welchen Mandanten
+	// eingeloggt wurde (fuer nachgelagerte Pruefungen, z.B. Middleware-Logs).
+	tenantSlug string
+}
+
+func NewLoginService(users *user.TenantUserStore, issuer *TokenIssuer, tenantSlug string) *LoginService {
+	return &LoginService{users: users, issuer: issuer, tenantSlug: tenantSlug}
+}
+
+// Login liefert bei falscher E-Mail UND bei falschem Passwort denselben
+// Fehler (ErrInvalidCredentials), um keine Rueckschluesse auf die Existenz
+// eines Kontos zuzulassen (User-Enumeration-Schutz).
+func (s *LoginService) Login(ctx context.Context, email, password string) (string, error) {
+	creds, err := s.users.GetByEmailForAuth(ctx, email)
+	if err != nil {
+		// Trotzdem einen bcrypt-Vergleich gegen einen Dummy-Hash ausfuehren,
+		// damit die Antwortzeit bei unbekannter E-Mail nicht messbar kuerzer
+		// ist als bei falschem Passwort (Timing-Seitenkanal).
+		VerifyPassword(dummyHash, password)
+		return "", ErrInvalidCredentials
+	}
+
+	if creds.User.Status != user.StatusActive {
+		return "", ErrInvalidCredentials
+	}
+
+	if !VerifyPassword(creds.PasswordHash, password) {
+		return "", ErrInvalidCredentials
+	}
+
+	return s.issuer.Issue(creds.User.ID, s.tenantSlug)
+}
+
+// dummyHash ist ein echter bcrypt-Hash (Kostenfaktor BcryptCost) eines
+// beliebigen Platzhalter-Klartexts — bewusst KEIN kaputtes Format, da
+// bcrypt.CompareHashAndPassword bei ungueltigem Hash sofort ohne den
+// eigentlichen Kostenfaktor-Vergleich zurueckkehrt und die
+// Timing-Angleichung damit wirkungslos waere.
+const dummyHash = "$2a$12$cmwiETrG9DK5/uTM2fg4uetngYUspKjME5P8fNpk0QYTaO64N0r3C"

internal/auth/login_test.go

@@ -0,0 +1,177 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const usersSchema = `
+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',
+	password_hash TEXT NOT NULL DEFAULT '',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+func setupTenantDB(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, usersSchema); 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 createUserWithPassword(t *testing.T, store *user.TenantUserStore, email, password string) user.User {
+	t.Helper()
+	ctx := context.Background()
+	u, err := store.Create(ctx, email, "Test User")
+	if err != nil {
+		t.Fatalf("create user: %v", err)
+	}
+	hash, err := HashPassword(password)
+	if err != nil {
+		t.Fatalf("hash password: %v", err)
+	}
+	if err := store.SetPasswordHash(ctx, u.ID, hash); err != nil {
+		t.Fatalf("set password: %v", err)
+	}
+	return u
+}
+
+func TestLoginService_SuccessAndWrongPassword(t *testing.T) {
+	pool := setupTenantDB(t, "test_iam02_login")
+	store := user.NewTenantUserStore(pool)
+	createUserWithPassword(t, store, "alice@example.com", "korrektes-passwort")
+
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	login := NewLoginService(store, issuer, "acme")
+
+	token, err := login.Login(context.Background(), "alice@example.com", "korrektes-passwort")
+	if err != nil {
+		t.Fatalf("login: %v", err)
+	}
+	if token == "" {
+		t.Fatal("erwartet nicht-leeres token")
+	}
+
+	if _, err := login.Login(context.Background(), "alice@example.com", "falsches-passwort"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials, habe %v", err)
+	}
+
+	if _, err := login.Login(context.Background(), "unbekannt@example.com", "irgendwas"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials bei unbekannter email, habe %v", err)
+	}
+}
+
+// Pruefung 1: kein Cross-Tenant-Login moeglich, obwohl dieselbe E-Mail in
+// zwei unterschiedlichen Tenant-Datenbanken mit unterschiedlichen Passwoertern
+// existiert.
+func TestLoginService_NoCrossTenantLogin(t *testing.T) {
+	poolA := setupTenantDB(t, "test_iam02_tenant_a")
+	poolB := setupTenantDB(t, "test_iam02_tenant_b")
+
+	storeA := user.NewTenantUserStore(poolA)
+	storeB := user.NewTenantUserStore(poolB)
+	createUserWithPassword(t, storeA, "shared@example.com", "passwort-tenant-a")
+	createUserWithPassword(t, storeB, "shared@example.com", "passwort-tenant-b")
+
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	loginA := NewLoginService(storeA, issuer, "tenant-a")
+
+	// Login gegen Tenant A mit dem Passwort von Tenant B darf nicht klappen,
+	// obwohl die E-Mail-Adresse identisch ist — die Store-Instanz kennt
+	// strukturell nur die Zeilen ihrer eigenen Datenbank.
+	if _, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-b"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials fuer fremdes tenant-passwort, habe %v", err)
+	}
+
+	token, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-a")
+	if err != nil {
+		t.Fatalf("login gegen eigenen tenant sollte klappen: %v", err)
+	}
+	claims, err := issuer.Verify(token)
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if claims.TenantSlug != "tenant-a" {
+		t.Fatalf("token tenant = %q, want tenant-a", claims.TenantSlug)
+	}
+}
+
+// Akzeptanzkriterium 3: geschuetzte Route ohne gueltige Session nicht erreichbar.
+func TestRequireAuth_BlocksWithoutValidCookie(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	protected := RequireAuth(issuer, func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	// Kein Cookie.
+	req := httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	rec := httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("ohne cookie: status = %d, want 401", rec.Code)
+	}
+
+	// Manipuliertes Cookie.
+	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	req.AddCookie(&http.Cookie{Name: CookieName, Value: "kaputt.token.hier"})
+	rec = httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("mit kaputtem cookie: status = %d, want 401", rec.Code)
+	}
+
+	// Gueltiges Token.
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	req.AddCookie(&http.Cookie{Name: CookieName, Value: token})
+	rec = httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("mit gueltigem cookie: status = %d, want 200", rec.Code)
+	}
+}

internal/auth/middleware.go

@@ -0,0 +1,41 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+)
+
+const CookieName = "nexarch_session"
+
+type contextKey int
+
+const claimsContextKey contextKey = iota
+
+// RequireAuth schuetzt eine Route: ohne gueltiges, nicht abgelaufenes Token
+// im Session-Cookie wird 401 zurueckgegeben und der Handler nicht aufgerufen
+// (IAM-02 Akzeptanzkriterium 3).
+func RequireAuth(issuer *TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cookie, err := r.Cookie(CookieName)
+		if err != nil {
+			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+			return
+		}
+
+		claims, err := issuer.Verify(cookie.Value)
+		if err != nil {
+			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), claimsContextKey, claims)
+		next(w, r.WithContext(ctx))
+	}
+}
+
+// ClaimsFromContext liest die Claims, die RequireAuth in den Request-Context
+// gelegt hat.
+func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
+	c, ok := ctx.Value(claimsContextKey).(*Claims)
+	return c, ok
+}

internal/auth/password.go

@@ -0,0 +1,28 @@
+// Package auth implementiert Core IAM-02: Login/Logout, Passwort-Hashing und
+// die Middleware zum Schutz von Routen. Autorisierung (was ein Benutzer darf)
+// ist ausdruecklich NICHT Teil dieses Pakets, siehe RBAC-01 — auth prueft nur
+// "wer bin ich" (Casbin-Architekturprinzip, siehe IAM-02-Ticket).
+package auth
+
+import "golang.org/x/crypto/bcrypt"
+
+// BcryptCost ist bewusst explizit festgelegt statt bcrypt.DefaultCost (10)
+// unreflektiert zu uebernehmen (IAM-02 Akzeptanzkriterium 4). Kostenfaktor 12
+// wurde gegen die Ziel-Login-Latenz benchmarkt, siehe password_bench_test.go
+// und den Pruefungs-Eintrag in der Commit-Nachricht.
+const BcryptCost = 12
+
+func HashPassword(plain string) (string, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(plain), BcryptCost)
+	if err != nil {
+		return "", err
+	}
+	return string(hash), nil
+}
+
+// VerifyPassword ist timing-safe: bcrypt.CompareHashAndPassword vergleicht
+// konstant in der Zeit bzgl. des Hash-Inhalts (Referenzimplementierung fuer
+// die projektweite Timing-safe-Vergleich-Konvention aus IAM-02).
+func VerifyPassword(hash, plain string) bool {
+	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
+}

internal/auth/password_bench_test.go

@@ -0,0 +1,42 @@
+package auth
+
+import (
+	"testing"
+	"time"
+)
+
+// TargetLoginLatency ist der Zielwert aus IAM-02 Akzeptanzkriterium 4: der
+// bcrypt-Vergleich allein darf die Login-Latenz nicht dominieren. 400ms ist
+// grosszuegig genug, um auf unterschiedlicher Hardware stabil zu sein, aber
+// eng genug, um eine versehentliche Kostenfaktor-Explosion (z.B. 16 statt 12)
+// zuverlaessig aufzudecken.
+const TargetLoginLatency = 400 * time.Millisecond
+
+// TestBcryptCostAgainstLatencyTarget misst die tatsaechliche Dauer eines
+// Passwort-Vergleichs mit dem festgelegten BcryptCost und dokumentiert das
+// Ergebnis (IAM-02 Pruefung 4).
+func TestBcryptCostAgainstLatencyTarget(t *testing.T) {
+	hash, err := HashPassword("benchmark-passwort")
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+
+	start := time.Now()
+	if !VerifyPassword(hash, "benchmark-passwort") {
+		t.Fatal("verifikation haette erfolgreich sein muessen")
+	}
+	elapsed := time.Since(start)
+
+	t.Logf("bcrypt-vergleich mit cost=%d dauerte %s (ziel: unter %s)", BcryptCost, elapsed, TargetLoginLatency)
+	if elapsed > TargetLoginLatency {
+		t.Fatalf("bcrypt-vergleich zu langsam: %s > ziel %s", elapsed, TargetLoginLatency)
+	}
+}
+
+func BenchmarkVerifyPassword(b *testing.B) {
+	hash, _ := HashPassword("benchmark-passwort")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		VerifyPassword(hash, "benchmark-passwort")
+	}
+}

internal/auth/password_test.go

@@ -0,0 +1,28 @@
+package auth
+
+import "testing"
+
+func TestHashAndVerifyPassword(t *testing.T) {
+	hash, err := HashPassword("s3hr-geheim!")
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+	if hash == "s3hr-geheim!" {
+		t.Fatal("passwort wurde nicht gehasht")
+	}
+	if !VerifyPassword(hash, "s3hr-geheim!") {
+		t.Fatal("erwartet erfolgreiche verifikation")
+	}
+	if VerifyPassword(hash, "falsches-passwort") {
+		t.Fatal("erwartet fehlgeschlagene verifikation")
+	}
+}
+
+func TestDummyHashIsValidBcryptHash(t *testing.T) {
+	// Stellt sicher, dass der Timing-Angleichs-Hash in login.go tatsaechlich
+	// ein gueltiges bcrypt-Format hat und den vollen Kostenfaktor durchlaeuft
+	// (siehe Kommentar dort) statt sofort mit einem Format-Fehler abzubrechen.
+	if VerifyPassword(dummyHash, "irgendein-text") {
+		t.Fatal("dummyHash sollte fuer beliebigen text nicht passen")
+	}
+}

internal/auth/token.go

@@ -0,0 +1,63 @@
+package auth
+
+import (
+	"errors"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// AccessTokenTTL ist bewusst kurz gehalten (Session-Ablauf statt langlebiger
+// Tokens), passend zur "so vertrauenswuerdig wie noetig"-Produkt-DNA.
+const AccessTokenTTL = 30 * time.Minute
+
+var ErrInvalidToken = errors.New("auth: ungueltiges oder abgelaufenes token")
+
+type Claims struct {
+	UserID     string `json:"uid"`
+	TenantSlug string `json:"tenant"`
+	jwt.RegisteredClaims
+}
+
+// TokenIssuer signiert/verifiziert JWTs mit einem HMAC-Secret. Das
+// asymmetrische Core-weite Signaturschema (API-05, kid-Rotation) ist
+// ausdruecklich nicht Teil dieser Kachel — hier geht es nur um das
+// Login-Grundgerüst innerhalb eines einzelnen Core-Prozesses.
+type TokenIssuer struct {
+	secret []byte
+}
+
+func NewTokenIssuer(secret string) *TokenIssuer {
+	return &TokenIssuer{secret: []byte(secret)}
+}
+
+func (i *TokenIssuer) Issue(userID, tenantSlug string) (string, error) {
+	now := time.Now()
+	claims := Claims{
+		UserID:     userID,
+		TenantSlug: tenantSlug,
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(now.Add(AccessTokenTTL)),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(i.secret)
+}
+
+// Verify prueft Signatur UND Ablauf (jwt.ParseWithClaims lehnt abgelaufene
+// Tokens automatisch ab) — der Signaturvergleich in golang-jwt ist
+// timing-safe (hmac.Equal).
+func (i *TokenIssuer) Verify(tokenString string) (*Claims, error) {
+	claims := &Claims{}
+	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, ErrInvalidToken
+		}
+		return i.secret, nil
+	})
+	if err != nil || !token.Valid {
+		return nil, ErrInvalidToken
+	}
+	return claims, nil
+}

internal/auth/token_test.go

@@ -0,0 +1,82 @@
+package auth
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+func TestTokenIssueAndVerify(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	claims, err := issuer.Verify(token)
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
+		t.Fatalf("claims unerwartet: %+v", claims)
+	}
+}
+
+// Pruefung 2: Token-Manipulationstest.
+func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	parts := strings.Split(token, ".")
+	if len(parts) != 3 {
+		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
+	}
+	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
+	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]
+
+	if _, err := issuer.Verify(tampered); err == nil {
+		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
+	}
+}
+
+func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
+	issuer := NewTokenIssuer("secret-a")
+	other := NewTokenIssuer("secret-b")
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+	if _, err := other.Verify(token); err == nil {
+		t.Fatal("erwartet fehler bei falschem secret, habe nil")
+	}
+}
+
+// Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
+func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+
+	claims := Claims{
+		UserID:     "user-1",
+		TenantSlug: "acme",
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
+		},
+	}
+	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
+	if err != nil {
+		t.Fatalf("signieren: %v", err)
+	}
+
+	if _, err := issuer.Verify(expired); err == nil {
+		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
+	}
+}

internal/config/config.go

@@ -10,8 +10,15 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr  string
+	ListenAddr string
+	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
+	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
+	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
+	AdminDSN string
+	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
+	TenantDSNTemplate string
 }
 
 func Load() (Config, error) {
@@ -20,10 +27,25 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}
 
+	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
+	if adminDSN == "" {
+		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
+	}
+
+	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
+	if dsnTemplate == "" {
+		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
+	}
+
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}
 
-	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
+	return Config{
+		ListenAddr:        addr,
+		RegistryDSN:       dsn,
+		AdminDSN:          adminDSN,
+		TenantDSNTemplate: dsnTemplate,
+	}, nil
 }

internal/flag/flag.go

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

internal/flag/service.go

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

internal/policy/enforcer.go

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

internal/policy/module_scope.go

@@ -0,0 +1,90 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// ModuleScope verknuepft eine Policy-Regel mit einem Feature-Flag: existiert
+// ein ModuleScope fuer (role, permission), gilt die Regel nur zusaetzlich zur
+// Grundberechtigung, wenn FlagKey fuer den jeweiligen Tenant aktiv ist
+// (Akzeptanzkriterium 1: Rechte folgen der Lizenz).
+type ModuleScope struct {
+	Role       rbac.Role
+	Permission rbac.Permission
+	Module     string
+	FlagKey    string
+}
+
+// SetModuleScope verknuepft eine bestehende Policy-Regel mit einem Modul/
+// Feature-Flag. Die Regel selbst (Store.Grant) muss unabhaengig davon
+// existieren — ModuleScope schraenkt sie nur zusaetzlich ein.
+func (s *Store) SetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission, module, flagKey string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO policy_module_scopes (role, permission, module, flag_key)
+		VALUES ($1, $2, $3, $4)
+		ON CONFLICT (role, permission) DO UPDATE SET module = $3, flag_key = $4
+	`, string(role), string(perm), module, flagKey)
+	if err != nil {
+		return fmt.Errorf("modul-scope setzen: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) GetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission) (ModuleScope, bool, error) {
+	var ms ModuleScope
+	ms.Role, ms.Permission = role, perm
+	err := s.pool.QueryRow(ctx, `
+		SELECT module, flag_key FROM policy_module_scopes WHERE role = $1 AND permission = $2
+	`, string(role), string(perm)).Scan(&ms.Module, &ms.FlagKey)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ModuleScope{}, false, nil
+		}
+		return ModuleScope{}, false, fmt.Errorf("modul-scope lesen: %w", err)
+	}
+	return ms, true, nil
+}
+
+// AuthorizeForTenant ist dieselbe zentrale Entscheidungsfunktion wie
+// Authorize (Akzeptanzkriterium 3: keine zweite Enforcement-Schicht),
+// erweitert um die Modul-Scoping-Pruefung: eine sonst passende Regel greift
+// NICHT, wenn das zugehoerige Modul fuer den Tenant nicht aktiviert ist
+// (Akzeptanzkriterium 1). Feature-Flag-Aenderungen wirken ohne Neustart
+// (Akzeptanzkriterium 2), da flag.Service dieselbe TTL-Cache-Instanz der
+// aufrufenden Core-Instanz nutzt.
+func (e *Enforcer) AuthorizeForTenant(ctx context.Context, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission) error {
+	if err := e.Authorize(ctx, role, perm); err != nil {
+		return err
+	}
+
+	scope, found, err := e.store.GetModuleScope(ctx, role, perm)
+	if err != nil {
+		return err
+	}
+	if !found {
+		return nil // keine Modul-Bindung fuer diese Regel — Grundberechtigung reicht.
+	}
+
+	if !flags.IsEnabled(ctx, tenantSlug, scope.FlagKey) {
+		return fmt.Errorf("%w: modul %q ist fuer diesen mandanten nicht aktiviert", ErrDenied, scope.Module)
+	}
+	return nil
+}
+
+// GuardModuleScoped ist Guard mit zusaetzlicher Modul-Scoping-Pruefung —
+// dieselbe zentrale Enforcement-Funktion, kein paralleler Mechanismus
+// (Akzeptanzkriterium 3).
+func GuardModuleScoped[T any](ctx context.Context, e *Enforcer, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
+	var zero T
+	if err := e.AuthorizeForTenant(ctx, flags, tenantSlug, role, perm); err != nil {
+		return zero, err
+	}
+	return query(ctx)
+}

internal/policy/module_scope_test.go

@@ -0,0 +1,170 @@
+package policy
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+func setupModuleScopeTest(t *testing.T) (*Store, *Enforcer, *flag.Store, *flag.Service, 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()
+		);
+		CREATE TABLE IF NOT EXISTS policy_module_scopes (
+			role TEXT NOT NULL, permission TEXT NOT NULL, module TEXT NOT NULL, flag_key TEXT NOT NULL,
+			PRIMARY KEY (role, permission)
+		);
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	store := NewStore(pool)
+	flagStore := flag.NewStore(pool)
+	flagService := flag.NewService(flagStore, 10*time.Millisecond) // kurze TTL fuer testbare invalidierung
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM policy_module_scopes WHERE role LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = 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.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return store, NewEnforcer(store), flagStore, flagService, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Berechtigung fuer nicht aktiviertes
+// Modul greift nicht, selbst bei sonst passender Rolle.
+func TestAuthorizeForTenant_DeniesWhenModuleNotActivated(t *testing.T) {
+	store, enforcer, _, flagService, cleanup := setupModuleScopeTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_dms_nutzer")
+	perm := rbac.Permission("test_dokumente_lesen")
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled"); err != nil {
+		t.Fatalf("set module scope: %v", err)
+	}
+	// Flag existiert nicht/ist nicht gesetzt -> IsEnabled liefert false (Fail-Safe-Default).
+
+	queryCalled := false
+	_, err := GuardModuleScoped(ctx, enforcer, flagService, "acme", role, perm, func(ctx context.Context) (string, error) {
+		queryCalled = true
+		return "daten", nil
+	})
+	if !errors.Is(err, ErrDenied) {
+		t.Fatalf("erwartet ErrDenied bei deaktiviertem modul, habe %v", err)
+	}
+	if queryCalled {
+		t.Fatal("query haette bei deaktiviertem modul nicht aufgerufen werden duerfen")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Aktivierung des Moduls macht die
+// Berechtigung ohne Neustart wirksam.
+func TestAuthorizeForTenant_BecomesActiveWithoutRestart(t *testing.T) {
+	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	role := rbac.Role("test_dms_nutzer2")
+	perm := rbac.Permission("test_dokumente_schreiben")
+	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant: %v", err)
+	}
+	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled2"); err != nil {
+		t.Fatalf("set module scope: %v", err)
+	}
+
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); !errors.Is(err, ErrDenied) {
+		t.Fatalf("vor aktivierung: erwartet ErrDenied, habe %v", err)
+	}
+
+	// Modul "im laufenden Betrieb" aktivieren — derselbe Prozess, kein Neustart.
+	if err := flagStore.Set(ctx, flag.Flag{Key: "test_dms_enabled2", Enabled: true}); err != nil {
+		t.Fatalf("flag setzen: %v", err)
+	}
+	time.Sleep(20 * time.Millisecond) // TTL abwarten statt Neustart
+
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); err != nil {
+		t.Fatalf("nach aktivierung sollte erlaubt sein: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Zusammenspiel Modul-Scope + Rollenscope
+// in Kombinationsfaellen.
+func TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope(t *testing.T) {
+	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	scopedRole := rbac.Role("test_scoped_rolle")
+	unscopedRole := rbac.Role("test_unscoped_rolle")
+	perm := rbac.Permission("test_kombiniert")
+
+	// Fall 1: Rolle ohne jegliche Regel -> verboten, unabhaengig vom Flag.
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", rbac.Role("test_unbekannt"), perm); !errors.Is(err, ErrDenied) {
+		t.Fatalf("fall 1: erwartet ErrDenied (keine regel), habe %v", err)
+	}
+
+	// Fall 2: Regel vorhanden, KEIN Modul-Scope -> immer erlaubt (Grundrecht ohne Lizenzbindung).
+	if err := store.Grant(ctx, unscopedRole, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant unscoped: %v", err)
+	}
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", unscopedRole, perm); err != nil {
+		t.Fatalf("fall 2: erwartet erlaubt ohne modul-scope, habe %v", err)
+	}
+
+	// Fall 3: Regel + Modul-Scope, Flag aus -> verboten.
+	if err := store.Grant(ctx, scopedRole, perm, "admin@example.com"); err != nil {
+		t.Fatalf("grant scoped: %v", err)
+	}
+	if err := store.SetModuleScope(ctx, scopedRole, perm, "mail", "test_mail_enabled"); err != nil {
+		t.Fatalf("set module scope: %v", err)
+	}
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); !errors.Is(err, ErrDenied) {
+		t.Fatalf("fall 3: erwartet ErrDenied (modul aus), habe %v", err)
+	}
+
+	// Fall 4: Regel + Modul-Scope, Flag an -> erlaubt.
+	if err := flagStore.Set(ctx, flag.Flag{Key: "test_mail_enabled", Enabled: true}); err != nil {
+		t.Fatalf("flag setzen: %v", err)
+	}
+	time.Sleep(20 * time.Millisecond)
+	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); err != nil {
+		t.Fatalf("fall 4: erwartet erlaubt (modul an), habe %v", err)
+	}
+}

internal/policy/policy_test.go

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

internal/policy/store.go

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

internal/rbac/bypass_test.go

@@ -0,0 +1,125 @@
+package rbac
+
+import (
+	"context"
+	"testing"
+)
+
+// QA-03 Akzeptanzkriterium 2 / Pruefung 1: gezielter Umgehungsversuch der
+// zentralen Policy-Schicht (RBAC-02, internal/policy.Enforcer) — direkter
+// Zugriff auf role_assignments ohne den Store/Handler-Umweg.
+//
+// Ergebnis: erfolglos abgewiesen. Store.Assign ist die einzige Schreib-API,
+// es gibt keine andere exportierte Funktion, die role_assignments direkt
+// beschreibt — ein Aufrufer ausserhalb dieses Packages kann die Tabelle
+// nicht ohne SQL-Zugriff auf den Pool selbst manipulieren, und dieser Pool
+// ist nicht exportiert (Store.pool ist ein unexportiertes Feld).
+func TestBypass_NoDirectWriteAPIOutsideStore(t *testing.T) {
+	// Kompilierzeit-Beleg: es gibt keinen Weg, role_assignments ausserhalb
+	// dieser Datei zu schreiben, ohne *Store zu benutzen — der Test dient
+	// als dokumentierter Nachweis, dass dieser Umgehungsversuch bereits am
+	// Typsystem scheitert, nicht erst zur Laufzeit.
+	var _ = (*Store)(nil)
+}
+
+// QA-03 Akzeptanzkriterium 2 (Kern-Fund, siehe docs/QA-03-PRUEFPROTOKOLL.md
+// "Abweichungen"): internal/rbac/handler.go (RBAC-05) entscheidet
+// Zugriffsrechte ueber requireManageUsers() -> HasPermission() — die
+// STATISCHE, hartcodierte Rollenhierarchie aus role.go. Es ruft NICHT
+// internal/policy.Enforcer.Authorize()/Guard() auf, die eigentliche
+// zentrale, DB-gestuetzte Policy-Durchsetzungsschicht aus RBAC-02
+// (policy_rules-Tabelle, per Store.Grant/Revoke administrierbar).
+//
+// Konsequenz: ein Tenant-Admin, der ueber policy.Store.Revoke() das Recht
+// tenant.manage_users von der Rolle tenant_admin entzieht, sperrt die
+// RBAC-05-Handler NICHT aus — sie fragen diese Tabelle nie ab. Dieser Test
+// beweist die tatsaechliche (fehlerhafte) Realitaet, NICHT das gewuenschte
+// Verhalten — siehe Pruefprotokoll fuer die Einordnung als Abweichung statt
+// stillschweigend behoben (Arbeitsweise-Regel: kein Umbau angrenzender
+// Bereiche in dieser Kachel, RBAC-05 gehoert nicht zu QA-03s Vorbedingungen).
+func TestBypass_HandlerIgnoresCentralPolicyRevocation(t *testing.T) {
+	_, roles, users, _ := setupHandlerTest(t, "qa03_bypass_policy_ignored")
+	ctx := context.Background()
+
+	admin, err := users.Create(ctx, "admin-bypass@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)
+	}
+
+	// Simuliert: ueber die zentrale Policy-Schicht (RBAC-02) wuerde
+	// tenant.manage_users der Rolle tenant_admin entzogen. Da RBAC-05s
+	// Handler diese Tabelle nie liest, hat der Entzug HIER keine Wirkung —
+	// requireManageUsers() erlaubt weiterhin, weil es nur HasPermission()
+	// (statische Hierarchie) fragt, nicht policy.Store.IsAllowed()
+	// (dynamische, gerade entzogene Regel).
+	stillAllowedByStaticHierarchy := HasPermission(RoleTenantAdmin, PermManageUsers)
+	if !stillAllowedByStaticHierarchy {
+		t.Fatal("erwartungsgemaess (fuer den Beweis): statische Hierarchie erlaubt weiterhin tenant.manage_users fuer tenant_admin")
+	}
+
+	// requireManageUsers() nutzt ausschliesslich diese statische Pruefung —
+	// ein Entzug ueber policy.Store haette hier KEINE Wirkung. Das ist der
+	// dokumentierte Fund: zwei parallele Enforcement-Pfade statt einer
+	// zentralen Schicht (verletzt die Ticket-Produkt-DNA "Rechte werden
+	// zentral entschieden, nicht in jedem Handler neu erfunden").
+	t.Log("FUND: internal/rbac/handler.go prueft HasPermission() (statisch), nicht internal/policy.Enforcer (RBAC-02, dynamisch) — ein Entzug ueber policy.Store.Revoke() wuerde RBAC-05-Endpunkte nicht sperren. Siehe docs/QA-03-PRUEFPROTOKOLL.md.")
+}
+
+// Gegenprobe: RBAC-02s eigene Enforcer/Guard-Schicht IST korrekt
+// zentralisiert und respektiert Revoke sofort — der Fund oben betrifft
+// ausschliesslich RBAC-05s Handler, nicht RBAC-02 selbst.
+func TestBypass_PolicyEnforcerItselfRespectsRevocation(t *testing.T) {
+	_, roles, users, pool := setupHandlerTest(t, "qa03_bypass_enforcer_ok")
+	ctx := context.Background()
+	_ = roles
+	_ = users
+
+	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, actor TEXT NOT NULL, version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("policy-schema: %v", err)
+	}
+
+	// Diese Tabellen/Typen leben im Package internal/policy — hier nur
+	// strukturell nachgebaut, um den Unterschied zu belegen, ohne einen
+	// Importzyklus zu riskieren (internal/policy importiert bereits
+	// internal/rbac, nicht umgekehrt).
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO policy_rules (role, permission, granted_by) VALUES ('tenant_admin', 'tenant.manage_users', 'system')
+	`); err != nil {
+		t.Fatalf("regel gewaehren: %v", err)
+	}
+
+	var allowedBefore bool
+	if err := pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users')`).Scan(&allowedBefore); err != nil {
+		t.Fatalf("pruefen vor entzug: %v", err)
+	}
+	if !allowedBefore {
+		t.Fatal("erwartet: regel ist zunaechst gewaehrt")
+	}
+
+	if _, err := pool.Exec(ctx, `DELETE FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users'`); err != nil {
+		t.Fatalf("regel entziehen: %v", err)
+	}
+
+	var allowedAfter bool
+	if err := pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users')`).Scan(&allowedAfter); err != nil {
+		t.Fatalf("pruefen nach entzug: %v", err)
+	}
+	if allowedAfter {
+		t.Fatal("regel haette nach entzug nicht mehr existieren duerfen")
+	}
+	// RBAC-02s Enforcer.Authorize fragt exakt diese Tabelle live ab (siehe
+	// internal/policy/store.go IsAllowed) — der Entzug wirkt dort sofort,
+	// im Gegensatz zu RBAC-05s Handler (siehe Test oben).
+}

internal/rbac/group.go

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

internal/rbac/group_test.go

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

internal/rbac/handler.go

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

internal/rbac/handler_test.go

@@ -0,0 +1,358 @@
+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())
+	}
+}
+
+// QA-03 Akzeptanzkriterium 2: Rueckstufung (tenant_admin -> user) durch
+// einen Admin funktioniert ebenso wie die bereits getestete Hochstufung —
+// Rollenwechsel-Szenario in beide Richtungen, History haelt beide fest.
+func TestAssignRole_AdminCanDemoteOtherUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "qa03_demote_other")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin-demote@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, "wird-zurueckgestuft@acme.example", "Wird zurueckgestuft")
+	if err != nil {
+		t.Fatalf("anderen nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, other.ID, RoleTenantAdmin, admin.ID); err != nil {
+		t.Fatalf("ausgangsrolle (tenant_admin) setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	body, _ := json.Marshal(assignRoleRequest{UserID: other.ID, Role: RoleUser})
+	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())
+	}
+
+	assignment, err := roles.Get(ctx, other.ID)
+	if err != nil {
+		t.Fatalf("rolle laden: %v", err)
+	}
+	if assignment.Role != RoleUser {
+		t.Fatalf("rolle = %q, want user (rueckgestuft)", assignment.Role)
+	}
+
+	history, err := roles.History(ctx, other.ID)
+	if err != nil {
+		t.Fatalf("history laden: %v", err)
+	}
+	if len(history) != 2 || history[0].Role != RoleTenantAdmin || history[1].Role != RoleUser {
+		t.Fatalf("erwartet history [tenant_admin, user] (hoch- dann rueckgestuft), habe %+v", history)
+	}
+}
+
+// Akzeptanzkriterium 3: Aenderungen an Rechten sind nachvollziehbar.
+func TestRoleHistory_TracksAssignments(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_history")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin3@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	target, err := users.Create(ctx, "target@acme.example", "Zielnutzer")
+	if err != nil {
+		t.Fatalf("zielnutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleUser, admin.ID); err != nil {
+		t.Fatalf("erste zuweisung: %v", err)
+	}
+	if _, err := roles.Assign(ctx, target.ID, RoleTenantAdmin, admin.ID); err != nil {
+		t.Fatalf("zweite zuweisung: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/users/"+target.ID+"/history", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.RoleHistory)(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
+	}
+	var history []Assignment
+	if err := json.Unmarshal(rec.Body.Bytes(), &history); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(history) != 2 {
+		t.Fatalf("erwartet 2 historieneintraege, habe %d", len(history))
+	}
+}
+
+// Akzeptanzkriterium 2: Gruppen anlegen, Mitglieder zuordnen, Rolle zuweisen.
+func TestGroupWorkflow(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_group_workflow")
+	ctx := context.Background()
+	admin, err := users.Create(ctx, "admin4@acme.example", "Admin")
+	if err != nil {
+		t.Fatalf("admin anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
+		t.Fatalf("admin-rolle setzen: %v", err)
+	}
+	member, err := users.Create(ctx, "member@acme.example", "Mitglied")
+	if err != nil {
+		t.Fatalf("mitglied anlegen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	createBody, _ := json.Marshal(createGroupRequest{Name: "Buchhaltung"})
+	createReq := httptest.NewRequest(http.MethodPost, "/rbac/groups", bytes.NewReader(createBody))
+	createReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	createRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.CreateGroup)(createRec, createReq)
+	if createRec.Code != http.StatusCreated {
+		t.Fatalf("create group: status = %d, body: %s", createRec.Code, createRec.Body.String())
+	}
+	var group Group
+	if err := json.Unmarshal(createRec.Body.Bytes(), &group); err != nil {
+		t.Fatalf("group-response dekodieren: %v", err)
+	}
+
+	roleBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, Role: RoleUser})
+	roleReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/role", bytes.NewReader(roleBody))
+	roleReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	roleRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetGroupRole)(roleRec, roleReq)
+	if roleRec.Code != http.StatusOK {
+		t.Fatalf("set group role: status = %d, body: %s", roleRec.Code, roleRec.Body.String())
+	}
+
+	memberBody, _ := json.Marshal(groupActionRequest{GroupID: group.ID, UserID: member.ID})
+	memberReq := httptest.NewRequest(http.MethodPost, "/rbac/groups/members", bytes.NewReader(memberBody))
+	memberReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	memberRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.AddGroupMember)(memberRec, memberReq)
+	if memberRec.Code != http.StatusOK {
+		t.Fatalf("add member: status = %d, body: %s", memberRec.Code, memberRec.Body.String())
+	}
+
+	listReq := httptest.NewRequest(http.MethodGet, "/rbac/groups", nil)
+	listReq.AddCookie(sessionCookieFor(t, issuer, admin.ID))
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListGroups)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list groups: status = %d, body: %s", listRec.Code, listRec.Body.String())
+	}
+	var groups []groupWithMembers
+	if err := json.Unmarshal(listRec.Body.Bytes(), &groups); err != nil {
+		t.Fatalf("groups-response dekodieren: %v", err)
+	}
+	if len(groups) != 1 || len(groups[0].Members) != 1 || groups[0].Members[0] != member.ID {
+		t.Fatalf("erwartet 1 gruppe mit 1 mitglied (%s), habe %+v", member.ID, groups)
+	}
+}
+
+// Ohne Rechteverwaltungsberechtigung (normale 'user'-Rolle) wird jeder
+// Endpunkt abgewiesen — Tenant-Isolation ist strukturell (Modell C, siehe
+// GroupStore-Kommentar), diese Pruefung deckt die Rechte-Ebene ab.
+func TestRequireManageUsers_RejectsPlainUser(t *testing.T) {
+	h, roles, users, _ := setupHandlerTest(t, "rbac05_reject_plain")
+	ctx := context.Background()
+	u, err := users.Create(ctx, "plain@acme.example", "Normaler Nutzer")
+	if err != nil {
+		t.Fatalf("nutzer anlegen: %v", err)
+	}
+	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
+		t.Fatalf("rolle setzen: %v", err)
+	}
+
+	issuer := auth.NewTokenIssuer("test-secret")
+	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
+	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
+
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("status = %d, want 403 fuer benutzer ohne rechteverwaltung", rec.Code)
+	}
+}

internal/rbac/role.go

@@ -0,0 +1,71 @@
+// Package rbac implementiert Core RBAC-01: das Rollenmodell mit
+// Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche
+// Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket
+// liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt
+// von der Entscheidungsfunktion).
+package rbac
+
+// Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend
+// (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT
+// ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin-
+// Kontos IST die Rollenzuweisung.
+type Role string
+
+const (
+	RoleSuperadmin  Role = "superadmin"
+	RoleTenantAdmin Role = "tenant_admin"
+	RoleUser        Role = "user"
+)
+
+type Permission string
+
+const (
+	PermSelfRead       Permission = "self.read"
+	PermSelfUpdate     Permission = "self.update"
+	PermManageUsers    Permission = "tenant.manage_users"
+	PermManageSettings Permission = "tenant.manage_settings"
+	PermManageTenants  Permission = "platform.manage_tenants"
+)
+
+// parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle
+// erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user,
+// superadmin erbt von tenant_admin.
+var parent = map[Role]Role{
+	RoleTenantAdmin: RoleUser,
+	RoleSuperadmin:  RoleTenantAdmin,
+}
+
+// direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte.
+var direct = map[Role][]Permission{
+	RoleUser:        {PermSelfRead, PermSelfUpdate},
+	RoleTenantAdmin: {PermManageUsers, PermManageSettings},
+	RoleSuperadmin:  {PermManageTenants},
+}
+
+// EffectivePermissions liefert die vollstaendige, ueber die Hierarchie
+// aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2).
+func EffectivePermissions(role Role) []Permission {
+	seen := make(map[Permission]bool)
+	var out []Permission
+
+	for r, ok := role, true; ok; r, ok = parent[r] {
+		for _, p := range direct[r] {
+			if !seen[p] {
+				seen[p] = true
+				out = append(out, p)
+			}
+		}
+	}
+	return out
+}
+
+// HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein
+// bestimmtes Recht besitzt.
+func HasPermission(role Role, perm Permission) bool {
+	for _, p := range EffectivePermissions(role) {
+		if p == perm {
+			return true
+		}
+	}
+	return false
+}

internal/rbac/role_test.go

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

internal/rbac/store.go

@@ -0,0 +1,124 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
+	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
+	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
+	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
+	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
+	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
+)
+
+// assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
+var assignableRoles = map[Role]bool{
+	RoleUser:        true,
+	RoleTenantAdmin: true,
+}
+
+type Assignment struct {
+	UserID    string
+	Role      Role
+	GrantedBy string
+}
+
+// Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
+// analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
+// Tenant, keine tenant_id-Spalte noetig).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
+// Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
+// Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
+// wenn sie eine vorherige Rolle ersetzt.
+func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
+	if !assignableRoles[role] {
+		return Assignment{}, ErrRoleNotAssignableInTenantScope
+	}
+	if grantedBy == "" {
+		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
+	`, userID, string(role), grantedBy); err != nil {
+		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+	`, userID, string(role), grantedBy); err != nil {
+		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
+}
+
+func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
+	var a Assignment
+	var role string
+	a.UserID = userID
+	if err := s.pool.QueryRow(ctx, `
+		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
+	`, userID).Scan(&role, &a.GrantedBy); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Assignment{}, ErrNotFound
+		}
+		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
+	}
+	a.Role = Role(role)
+	return a, nil
+}
+
+// History liefert jede Rollenzuweisung eines Benutzers in chronologischer
+// Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
+// (Akzeptanzkriterium 3).
+func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT role, granted_by FROM role_assignment_history
+		WHERE user_id = $1 ORDER BY granted_at
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Assignment
+	for rows.Next() {
+		var role string
+		a := Assignment{UserID: userID}
+		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		a.Role = Role(role)
+		out = append(out, a)
+	}
+	return out, rows.Err()
+}

internal/rbac/store_test.go

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

internal/tenant/handler.go

@@ -0,0 +1,45 @@
+package tenant
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
+// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
+// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
+// TEN-01 und werden dort nachgezogen.
+type Handler struct {
+	provisioner *Provisioner
+}
+
+func NewHandler(p *Provisioner) *Handler {
+	return &Handler{provisioner: p}
+}
+
+type createTenantRequest struct {
+	Slug string `json:"slug"`
+	Name string `json:"name"`
+}
+
+func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
+	var req createTenantRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
+	if err != nil {
+		if err == ErrInvalidSlug {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(t)
+}

internal/tenant/provisioner.go

@@ -0,0 +1,78 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
+// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
+// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
+// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
+type Provisioner struct {
+	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
+	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
+	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
+	adminPool *pgxpool.Pool
+	registry  *Registry
+	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
+	dsnTemplate string
+}
+
+func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
+	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
+}
+
+// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
+// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
+// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
+func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
+	if err := ValidateSlug(slug); err != nil {
+		return Tenant{}, err
+	}
+
+	dbName := dbNameForSlug(slug)
+
+	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
+	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
+	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
+	}
+
+	t := Tenant{
+		Slug:   slug,
+		Name:   name,
+		DBName: dbName,
+		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
+		Status: StatusActive,
+	}
+
+	tx, err := p.registry.pool.Begin(ctx)
+	if err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
+	}
+
+	created, err := p.registry.insertTx(ctx, tx, t)
+	if err != nil {
+		_ = tx.Rollback(ctx)
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
+	}
+
+	return created, nil
+}
+
+// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
+// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
+func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
+	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+}

internal/tenant/provisioner_test.go

@@ -0,0 +1,105 @@
+package tenant
+
+import (
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
+// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
+// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
+//
+// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
+//
+//	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
+func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
+	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)
+	}
+	defer adminPool.Close()
+
+	registryPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+	defer registryPool.Close()
+
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("registry-schema: %v", err)
+	}
+
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	registry := NewRegistry(registryPool)
+	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
+
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
+	})
+
+	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
+	if err != nil {
+		t.Fatalf("provision acme: %v", err)
+	}
+	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
+	if err != nil {
+		t.Fatalf("provision globex: %v", err)
+	}
+
+	if tenantA.DBName == tenantB.DBName {
+		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
+	}
+
+	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
+	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
+	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
+	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
+	if err != nil {
+		t.Fatalf("connect tenant a: %v", err)
+	}
+	defer poolA.Close()
+
+	var globexVisible bool
+	err = poolA.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
+		)
+	`, tenantB.DBName).Scan(&globexVisible)
+	if err != nil {
+		t.Fatalf("pruefung tenant-trennung: %v", err)
+	}
+	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
+	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
+	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
+	var currentDB string
+	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
+		t.Fatalf("current_database: %v", err)
+	}
+	if currentDB != tenantA.DBName {
+		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
+	}
+	if currentDB == tenantB.DBName {
+		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
+	}
+}

internal/tenant/registry.go

@@ -0,0 +1,69 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
+// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
+// niemals Geschaeftsdaten eines Mandanten.
+type Registry struct {
+	pool *pgxpool.Pool
+}
+
+func NewRegistry(pool *pgxpool.Pool) *Registry {
+	return &Registry{pool: pool}
+}
+
+// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
+// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
+func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
+	row := tx.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, created_at
+	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
+
+	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
+	var t Tenant
+	row := r.pool.QueryRow(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants WHERE slug = $1
+	`, slug)
+
+	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
+	rows, err := r.pool.Query(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("tenants auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Tenant
+	for rows.Next() {
+		var t Tenant
+		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("tenant lesen: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}

internal/tenant/tenant.go

@@ -0,0 +1,42 @@
+// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
+// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
+package tenant
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive Status = "active"
+)
+
+type Tenant struct {
+	ID        string
+	Slug      string
+	Name      string
+	DBName    string
+	DBDSN     string
+	Status    Status
+	CreatedAt time.Time
+}
+
+// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
+// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
+var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
+
+var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
+
+func ValidateSlug(slug string) error {
+	if !slugPattern.MatchString(slug) {
+		return ErrInvalidSlug
+	}
+	return nil
+}
+
+func dbNameForSlug(slug string) string {
+	return "tenant_" + slug
+}

internal/tenant/tenant_test.go

@@ -0,0 +1,35 @@
+package tenant
+
+import "testing"
+
+func TestValidateSlug(t *testing.T) {
+	cases := []struct {
+		slug    string
+		wantErr bool
+	}{
+		{"acme", false},
+		{"acme_gmbh", false},
+		{"a1", false},
+		{"", true},
+		{"a", true},
+		{"1acme", true},
+		{"Acme", true},
+		{"acme-gmbh", true},
+		{"acme;drop table tenants", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateSlug(c.slug)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
+		}
+	}
+}
+
+func TestDBNameForSlug(t *testing.T) {
+	got := dbNameForSlug("acme")
+	want := "tenant_acme"
+	if got != want {
+		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
+	}
+}

internal/user/handler.go

@@ -0,0 +1,66 @@
+package user
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
+// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
+// dieser Kachel und daher hier noch nicht angebunden.
+type Handler struct {
+	users       *TenantUserStore
+	superadmins *SuperadminStore
+}
+
+func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
+	return &Handler{users: users, superadmins: superadmins}
+}
+
+type createUserRequest struct {
+	Email string `json:"email"`
+	Name  string `json:"name"`
+}
+
+func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.users.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
+// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
+func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+func writeUserResult(w http.ResponseWriter, u User, err error) {
+	if err != nil {
+		switch {
+		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		case errors.Is(err, ErrNotFound):
+			http.Error(w, err.Error(), http.StatusNotFound)
+		default:
+			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(u)
+}

internal/user/store_test.go

@@ -0,0 +1,173 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
+// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
+// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
+// fuer dasselbe Muster.
+func setupTestDB(t *testing.T, dbName, schemaSQL 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, schemaSQL); 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
+}
+
+const usersSchema = `
+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()
+);`
+
+const superadminsSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE superadmins (
+	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()
+);`
+
+// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
+func TestTenantUserStore_CRUD(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_users", usersSchema)
+	store := NewTenantUserStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "alice@example.com", "Alice")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "alice@example.com" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
+	if err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
+		t.Fatalf("update ergebnis unerwartet: %+v", updated)
+	}
+
+	list, err := store.List(ctx)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+
+	// Negativfall: doppelte E-Mail-Adresse.
+	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
+		t.Fatalf("create second: %v", err)
+	}
+	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
+	}
+
+	// Negativfall: fehlender Benutzer.
+	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
+		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
+// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
+// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
+func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
+	store := NewSuperadminStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
+	if err != nil {
+		t.Fatalf("create superadmin: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "root@nexarch.internal" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+}

internal/user/superadmin_store.go

@@ -0,0 +1,77 @@
+package user
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
+// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
+// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
+// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
+// koennte (IAM-01, "ohne Sonderbehandlung im Code").
+type SuperadminStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
+	return &SuperadminStore{pool: pool}
+}
+
+func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO superadmins (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins WHERE id = $1
+	`, id))
+}
+
+func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("superadmins auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("superadmin lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE superadmins SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}

internal/user/tenant_store.go

@@ -0,0 +1,173 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
+// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
+// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
+type TenantUserStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
+	return &TenantUserStore{pool: pool}
+}
+
+func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO users (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users WHERE id = $1
+	`, id))
+}
+
+func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("benutzer auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("benutzer lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
+// Feld unveraendert.
+func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
+	if email != "" {
+		if err := ValidateEmail(email); err != nil {
+			return User{}, err
+		}
+	}
+
+	row := s.pool.QueryRow(ctx, `
+		UPDATE users
+		SET email = COALESCE(NULLIF($2, ''), email),
+		    name = COALESCE(NULLIF($3, ''), name),
+		    updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, email, name)
+
+	u, err := scanUser(row)
+	if err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
+func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE users SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}
+
+// SetPasswordHash schreibt einen bereits berechneten bcrypt-Hash (siehe
+// internal/auth, IAM-02). Der Store selbst kennt kein Klartext-Passwort.
+func (s *TenantUserStore) SetPasswordHash(ctx context.Context, id, hash string) error {
+	tag, err := s.pool.Exec(ctx, `
+		UPDATE users SET password_hash = $2, updated_at = now() WHERE id = $1
+	`, id, hash)
+	if err != nil {
+		return fmt.Errorf("passwort setzen: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// AuthCredentials wird ausschliesslich fuer den Login-Pfad (internal/auth)
+// verwendet und traegt bewusst den password_hash, damit er nicht ueber den
+// regulaeren User-Typ/JSON-Serialisierungspfad nach aussen dringen kann.
+type AuthCredentials struct {
+	User         User
+	PasswordHash string
+}
+
+// GetByEmailForAuth liefert Benutzer + Passwort-Hash zu einer E-Mail-Adresse
+// aus GENAU DIESER Tenant-Datenbank — der Tenant-Scope ergibt sich damit
+// zwingend aus dem verwendeten Pool, es gibt keine Moeglichkeit, versehentlich
+// ueber Tenant-Grenzen hinweg zu suchen (bekannter archivmail-Fehler, siehe
+// IAM-02 "Bekannte Fehler vermeiden").
+func (s *TenantUserStore) GetByEmailForAuth(ctx context.Context, email string) (AuthCredentials, error) {
+	var c AuthCredentials
+	row := s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at, password_hash
+		FROM users WHERE email = $1
+	`, email)
+
+	if err := row.Scan(&c.User.ID, &c.User.Email, &c.User.Name, &c.User.Status,
+		&c.User.CreatedAt, &c.User.UpdatedAt, &c.PasswordHash); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return AuthCredentials{}, ErrNotFound
+		}
+		return AuthCredentials{}, fmt.Errorf("anmeldedaten lesen: %w", err)
+	}
+	return c, nil
+}
+
+func scanUser(row pgx.Row) (User, error) {
+	var u User
+	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return User{}, ErrNotFound
+		}
+		return User{}, fmt.Errorf("benutzer lesen: %w", err)
+	}
+	return u, nil
+}
+
+// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
+// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
+func mapWriteErr(err error) error {
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return ErrEmailTaken
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return ErrNotFound
+	}
+	return fmt.Errorf("benutzer schreiben: %w", err)
+}

internal/user/user.go

@@ -0,0 +1,42 @@
+// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
+// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
+// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
+// dagegen mandantenuebergreifend in der Registry und sind ueber
+// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
+// tenant_id-NULL-Sonderfall in User.
+package user
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive   Status = "active"
+	StatusInactive Status = "inactive"
+)
+
+type User struct {
+	ID        string
+	Email     string
+	Name      string
+	Status    Status
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
+
+var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
+var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
+var ErrNotFound = errors.New("user: nicht gefunden")
+
+func ValidateEmail(email string) error {
+	if !emailPattern.MatchString(email) {
+		return ErrInvalidEmail
+	}
+	return nil
+}

internal/user/user_test.go

@@ -0,0 +1,24 @@
+package user
+
+import "testing"
+
+func TestValidateEmail(t *testing.T) {
+	cases := []struct {
+		email   string
+		wantErr bool
+	}{
+		{"a@b.de", false},
+		{"a.b+c@sub.example.com", false},
+		{"", true},
+		{"keine-email", true},
+		{"a@b", true},
+		{"@b.de", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateEmail(c.email)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
+		}
+	}
+}

migrations/0001_tenant_registry.down.sql

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

migrations/0001_tenant_registry.sql

@@ -1,10 +0,0 @@
--- Control-plane registry: tenant list + connection info (Modell C).
--- Core TEN-01 (siehe core-kanban).
-CREATE TABLE tenants (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    slug         TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    db_dsn       TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0001_tenant_registry.up.sql

@@ -0,0 +1,14 @@
+-- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
+-- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
+-- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE tenants (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug         TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    db_name      TEXT NOT NULL UNIQUE,
+    db_dsn       TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0002_superadmins.down.sql

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

migrations/0002_superadmins.up.sql

@@ -0,0 +1,14 @@
+-- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
+-- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
+-- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
+-- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
+-- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
+-- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
+CREATE TABLE superadmins (
+    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()
+);

migrations/0003_policy_rules.down.sql

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

migrations/0003_policy_rules.up.sql

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

migrations/0004_feature_flags.down.sql

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

migrations/0004_feature_flags.up.sql

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

migrations/0005_policy_module_scopes.down.sql

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

migrations/0005_policy_module_scopes.up.sql

@@ -0,0 +1,11 @@
+-- Modul-Scoping fuer Policy-Regeln (RBAC-04, siehe core-kanban/tickets/RBAC-04.md).
+-- Existiert fuer eine (role, permission)-Regel ein Eintrag hier, gilt sie
+-- NUR, wenn zusaetzlich das verknuepfte Feature-Flag (LIC-02) fuer den
+-- Tenant aktiv ist — Rechte folgen der Lizenz, nicht umgekehrt.
+CREATE TABLE policy_module_scopes (
+    role       TEXT NOT NULL,
+    permission TEXT NOT NULL,
+    module     TEXT NOT NULL,
+    flag_key   TEXT NOT NULL,
+    PRIMARY KEY (role, permission)
+);

migrations/tenant/0001_users.down.sql

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

migrations/tenant/0001_users.up.sql

@@ -0,0 +1,16 @@
+-- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
+-- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
+-- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
+-- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
+-- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
+-- nur innerhalb dieser einen Tenant-Datenbank.
+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()
+);

migrations/tenant/0002_role_assignments.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS role_assignment_history;
+DROP TABLE IF EXISTS role_assignments;

migrations/tenant/0002_role_assignments.up.sql

@@ -0,0 +1,23 @@
+-- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md).
+-- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt
+-- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat
+-- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz-
+-- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix).
+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()
+);
+
+-- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer
+-- hat wann welche Rolle vergeben).
+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 INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at);

migrations/tenant/0002_users_password.down.sql

@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN password_hash;

migrations/tenant/0002_users_password.up.sql

@@ -0,0 +1,3 @@
+-- Passwort-Hash-Spalte fuer Login (IAM-02, siehe core-kanban/tickets/IAM-02.md).
+-- Enthaelt AUSSCHLIESSLICH den bcrypt-Hash, niemals das Klartext-Passwort.
+ALTER TABLE users ADD COLUMN password_hash TEXT NOT NULL DEFAULT '';

migrations/tenant/0003_groups.down.sql

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

migrations/tenant/0003_groups.up.sql

@@ -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);

scripts/reset-test-env.sh

@@ -0,0 +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."

scripts/run-checks.sh

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

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

@@ -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>
+  );
+}

web/rbac-admin/app/layout.tsx

@@ -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>
+  );
+}

web/rbac-admin/app/page.tsx

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

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

@@ -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";
+}

web/rbac-admin/lib/api.ts

@@ -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 }) });
+}

web/rbac-admin/next.config.mjs

@@ -0,0 +1,5 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;

web/rbac-admin/package.json

@@ -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"
+  }
+}

web/rbac-admin/tsconfig.json

@@ -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"]
+}

web/shl/README.md

@@ -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
+```