QA-07: schnittstellen-vertragstests fuer api-01/api-05/api-02/api-07 + gitea-actions-workflow

internal/moduletrust: asymmetrische JWT-Signatur (Ed25519) mit JWKS-
Verteilung, wie im Entscheidungsverlauf "Vertrauensstellung Core<->Module"
(nexarch-state.json) festgelegt. Getrennt von IAM-02s HS256-Session-Cookie
(Browser-Login bleibt unangetastet) — dies ist der Modul-zu-Core-
Vertrauensmechanismus.

KeyManager haelt ALLE noch gueltigen Schluesselpaare (nicht nur das aktuell
signierende); Rotate() erzeugt einen neuen Schluessel, alte bleiben in
PublicKeySet() erhalten — bereits ausgestellte Tokens bleiben dadurch nach
einer Rotation weiterhin verifizierbar (Akzeptanzkriterium 3, keine
Ausfallzeit). ServeJWKS/ParseJWKS sind der Verteilungsmechanismus.

StaleCache[T] ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
(Akzeptanzkriterium 2), mit zwei explizit benannten und begruendeten
Verhalten: Get() ist FAIL-OPEN (nutzt bei Core-Ausfall einen vorhandenen,
abgelaufenen Stand weiter — ein bereits authentifiziertes Modul soll nicht
hart blockieren), RequireFresh() ist FAIL-CLOSED (nie zwischengespeichert,
schlaegt bei Core-Ausfall klar fehl — fuer sicherheitskritische Aktionen wie
einen neuen Login). LIC-02s internal/flag.Service implementiert bereits
denselben Kontrakt fuer Feature-Flags; StaleCache verallgemeinert dasselbe
Muster fuer JWT-Schluessel, damit beide Faelle derselben dokumentierten
Policy folgen statt zwei unterschiedlichen Ad-hoc-Loesungen.

Verifier.Verify ruft KeyFetchFunc nur bei abgelaufener TTL auf, nicht pro
Aufruf (Akzeptanzkriterium 1) — Signaturpruefung selbst ist immer lokal.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Core simuliert abgeschaltet, andere Module bleiben fuer bereits
   authentifizierte Nutzer funktionsfaehig bis TTL/Fail-Open greift —
   TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist: Verify()
   funktioniert weiter mit letztbekanntem Schluesselstand. PASS.
2. Neue sicherheitskritische Aktion schlaegt bei Core-Ausfall klar fehl,
   statt andere Funktionen mitzureissen —
   TestRequireFreshKeys_FailsClosedWhenCoreUnreachable: Fehler trotz
   vorhandenem (aelterem) Cache-Stand. PASS.
3. Schluesselrotation ohne Downtime in einem simulierten zweiten Modul —
   TestRotate_NoDowntimeForAlreadyIssuedTokens: vor UND nach Rotation
   ausgestellte Tokens beide weiterhin gueltig fuer Modul B. PASS.

Zusaetzlich: TestVerify_DoesNotFetchPerCall belegt Akzeptanzkriterium 1
direkt (10 Verify-Aufrufe, genau 1 Fetch). PASS.

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

.gitea/workflows/contract-tests.yml

@@ -0,0 +1,22 @@
+name: Core-Schnittstellen-Vertragstests
+
+on:
+  push:
+    paths:
+      - "internal/contracttest/**"
+      - "internal/apiserver/**"
+      - "internal/moduletrust/**"
+      - "internal/moduleregistry/**"
+      - "internal/webhook/**"
+  pull_request: {}
+
+jobs:
+  contract-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - name: Vertragstests ausfuehren
+        run: go test ./internal/contracttest/... -v

.gitignore

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

DEVLOG.md

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

docs/QA-03-PRUEFPROTOKOLL.md

@@ -1,68 +0,0 @@
-# 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).

internal/apiserver/context.go

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

internal/apiserver/errors.go

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

internal/apiserver/middleware.go

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

internal/apiserver/server.go

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

internal/apiserver/server_test.go

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

internal/contracttest/contracttest.go

@@ -0,0 +1,57 @@
+// Package contracttest implementiert Core QA-07: Vertragstests fuer die
+// Core-Schnittstellen, die von den Fachmodulen (DMS/Mail/Archive/Workflow/
+// AI/Connect) konsumiert werden — REST-Fehlerschema (API-01), JWKS-/Rechte-
+// Cache-Kontrakt (API-05), Modul-Registry (API-02) und Webhook-Zustellung
+// (API-07). Jeder Test prueft die TATSAECHLICHE Antwort einer echten
+// Core-Komponente gegen ihr dokumentiertes Schema — eine entfernte oder
+// umbenannte Pflichteigenschaft laesst den jeweiligen Test fehlschlagen,
+// BEVOR sie ein konsumierendes Modul bricht (Akzeptanzkriterium 2).
+package contracttest
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// RequireJSONFields dekodiert data als JSON-Objekt und prueft, dass ALLE
+// angegebenen Top-Level-Schluessel vorhanden sind. Liefert die fehlenden
+// Schluessel zurueck — leer bedeutet: Vertrag eingehalten.
+func RequireJSONFields(data []byte, required []string) (missing []string, err error) {
+	var decoded map[string]any
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
+	}
+	for _, field := range required {
+		if _, ok := decoded[field]; !ok {
+			missing = append(missing, field)
+		}
+	}
+	return missing, nil
+}
+
+// RequireJSONArrayItemFields prueft, dass data ein JSON-Objekt mit einem
+// Array-Feld arrayField ist, dessen ERSTES Element alle itemFields enthaelt
+// — Vertrag fuer Listen-Antworten wie JWKS ("keys": [{...}]).
+func RequireJSONArrayItemFields(data []byte, arrayField string, itemFields []string) (missing []string, err error) {
+	var decoded map[string]json.RawMessage
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
+	}
+	raw, ok := decoded[arrayField]
+	if !ok {
+		return itemFields, nil // das array-feld selbst fehlt bereits -> alles "fehlend"
+	}
+	var items []map[string]any
+	if err := json.Unmarshal(raw, &items); err != nil {
+		return nil, fmt.Errorf("contracttest: feld %q ist kein array: %w", arrayField, err)
+	}
+	if len(items) == 0 {
+		return nil, fmt.Errorf("contracttest: feld %q ist leer, kann nicht gegen kontrakt geprueft werden", arrayField)
+	}
+	for _, field := range itemFields {
+		if _, ok := items[0][field]; !ok {
+			missing = append(missing, field)
+		}
+	}
+	return missing, nil
+}

internal/contracttest/contracttest_test.go

@@ -0,0 +1,193 @@
+package contracttest
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
+	"gitea.perlbach24.de/scripte/nexarch/internal/webhook"
+)
+
+// --- Vertrag 1: API-01 REST-Fehlerschema ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API01_ErrorEnvelope(t *testing.T) {
+	rec := httptest.NewRecorder()
+	apiserver.WriteError(rec, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+
+	if missing, err := RequireJSONFields(rec.Body.Bytes(), []string{"error"}); err != nil {
+		t.Fatalf("antwort nicht lesbar: %v", err)
+	} else if len(missing) != 0 {
+		t.Fatalf("erwartet top-level feld 'error', fehlt: %v", missing)
+	}
+
+	var decoded map[string]json.RawMessage
+	_ = json.Unmarshal(rec.Body.Bytes(), &decoded)
+	if missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"}); err != nil {
+		t.Fatalf("error-objekt nicht lesbar: %v", err)
+	} else if len(missing) != 0 {
+		t.Fatalf("error-objekt fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: absichtlich simulierter Breaking Change (Feld "message"
+// entfernt) laesst den Vertragstest fehlschlagen.
+func TestContract_API01_DetectsBreakingChange_RemovedField(t *testing.T) {
+	brokenResponse := []byte(`{"error":{"code":"unauthenticated"}}`) // "message" fehlt absichtlich
+	var decoded map[string]json.RawMessage
+	if err := json.Unmarshal(brokenResponse, &decoded); err != nil {
+		t.Fatalf("fixture nicht lesbar: %v", err)
+	}
+	missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "message" {
+		t.Fatalf("erwartet erkanntes fehlendes feld 'message', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 2: API-05 JWKS / Rechte-Cache-Kontrakt ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API05_JWKS(t *testing.T) {
+	km, err := moduletrust.NewKeyManager()
+	if err != nil {
+		t.Fatalf("keymanager: %v", err)
+	}
+	if _, err := km.Rotate(); err != nil {
+		t.Fatalf("rotate: %v", err)
+	}
+
+	rec := httptest.NewRecorder()
+	km.ServeJWKS(rec, httptest.NewRequest(http.MethodGet, "/jwks", nil))
+
+	missing, err := RequireJSONArrayItemFields(rec.Body.Bytes(), "keys", []string{"kid", "public_key"})
+	if err != nil {
+		t.Fatalf("jwks-antwort verletzt vertrag: %v", err)
+	}
+	if len(missing) != 0 {
+		t.Fatalf("jwks-eintrag fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — Feld "public_key" umbenannt
+// (z.B. faelschlich zu "publicKey"), Vertragstest erkennt das fehlende
+// Originalfeld zuverlaessig.
+func TestContract_API05_DetectsBreakingChange_RenamedField(t *testing.T) {
+	brokenJWKS := []byte(`{"keys":[{"kid":"abc","publicKey":"base64..."}]}`)
+	missing, err := RequireJSONArrayItemFields(brokenJWKS, "keys", []string{"kid", "public_key"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "public_key" {
+		t.Fatalf("erwartet erkanntes umbenanntes feld 'public_key', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 3: API-02 Modul-Registry ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func setupModuleRegistryTest(t *testing.T) (*moduleregistry.Registry, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS modules (
+			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
+			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
+	return moduleregistry.NewRegistry(pool, flagService), func() { pool.Close() }
+}
+
+func TestContract_API02_ModuleInfo(t *testing.T) {
+	registry, cleanup := setupModuleRegistryTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	m, err := registry.Register(ctx, "contracttest-dms", "1.0.0", []string{"some-flag"})
+	if err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	data, err := json.Marshal(m)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	missing, err := RequireJSONFields(data, []string{"Name", "Version", "RequiredFlags"})
+	if err != nil {
+		t.Fatalf("modul-antwort nicht lesbar: %v", err)
+	}
+	if len(missing) != 0 {
+		t.Fatalf("modul-info fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — Feld "RequiredFlags" entfernt.
+func TestContract_API02_DetectsBreakingChange_RemovedField(t *testing.T) {
+	brokenModuleJSON := []byte(`{"Name":"dms","Version":"1.0.0"}`)
+	missing, err := RequireJSONFields(brokenModuleJSON, []string{"Name", "Version", "RequiredFlags"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "RequiredFlags" {
+		t.Fatalf("erwartet erkanntes fehlendes feld 'RequiredFlags', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 4: API-07 Webhook-Zustellung (HMAC-Signaturheader) ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API07_WebhookSignatureHeader(t *testing.T) {
+	if webhook.SignatureHeader != "X-Nexarch-Signature-256" {
+		t.Fatalf("signaturheader-name = %q, want stabilen vertrag 'X-Nexarch-Signature-256' — konsumierende module lesen genau diesen namen", webhook.SignatureHeader)
+	}
+
+	secret := "vertragstest-secret"
+	payload := []byte(`{"event":"test"}`)
+	signature := webhook.Sign(secret, payload)
+
+	if !webhook.VerifySignature(secret, payload, signature) {
+		t.Fatal("konsumentenseitige signaturpruefung schlaegt fuer eine korrekte core-signatur fehl")
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — eine Zustellung, die den
+// Signaturheader unter einem ANDEREN Namen sendet (wie es ein
+// hypothetischer, den Vertrag brechender Core-Umbau taete). Ein
+// konsumierendes Modul, das nach dem DOKUMENTIERTEN Namen sucht, findet in
+// diesem Fall nichts — der Vertragstest erkennt das zuverlaessig.
+func TestContract_API07_DetectsBreakingChange_RenamedHeader(t *testing.T) {
+	brokenHeaders := http.Header{}
+	brokenHeaders.Set("X-Signature", webhook.Sign("secret", []byte("payload"))) // falscher name, simuliert breaking change
+
+	if got := brokenHeaders.Get(webhook.SignatureHeader); got != "" {
+		t.Fatalf("erwartet leeren wert unter dem dokumentierten headernamen bei simuliertem breaking change, habe: %q", got)
+	}
+}

internal/flag/flag_test.go

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

internal/flag/service_test.go

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

internal/moduleregistry/credentials.go

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

internal/moduleregistry/middleware.go

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

internal/moduleregistry/registry.go

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

internal/moduleregistry/registry_test.go

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

internal/moduletrust/cache.go

@@ -0,0 +1,86 @@
+package moduletrust
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+)
+
+// StaleCache ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
+// (Akzeptanzkriterium 2): TTL-basiert, mit explizitem, benanntem Verhalten
+// bei abgelaufenem Cache waehrend Core nicht erreichbar ist.
+//
+//   - Get: FAIL-OPEN fuer Lesevorgaenge. Schlaegt der Refresh fehl, aber es
+//     gibt bereits einen (wenn auch abgelaufenen) Stand, wird dieser mit
+//     stale=true zurueckgegeben — Begruendung: ein bereits authentifiziertes
+//     Modul soll mit dem letztbekannten Stand weiterarbeiten koennen statt
+//     hart zu blockieren (siehe "Bekannte Fehler vermeiden" im Ticket).
+//     Existiert noch nie ein Stand, gibt es keinen sinnvollen Fallback —
+//     dann liefert auch Get einen Fehler.
+//   - RequireFresh: FAIL-CLOSED fuer sicherheitskritische Aktionen (z.B.
+//     ein komplett NEUER Login). Nutzt NIEMALS einen zwischengespeicherten
+//     Stand, ruft immer frisch ab — Begruendung: eine neue Vertrauens-
+//     entscheidung darf nicht auf veralteten Daten beruhen, auch wenn das
+//     bedeutet, dass die Aktion bei Core-Ausfall sichtbar fehlschlaegt statt
+//     unsicher "irgendwie" durchgelassen zu werden.
+//
+// LIC-02 (internal/flag.Service) implementiert bereits denselben Kontrakt
+// fuer Feature-Flags — StaleCache verallgemeinert dasselbe Muster fuer
+// JWT-Signaturschluessel, damit beide Faelle derselben dokumentierten
+// Policy folgen.
+type StaleCache[T any] struct {
+	mu        sync.RWMutex
+	value     T
+	hasValue  bool
+	fetchedAt time.Time
+	ttl       time.Duration
+	fetch     func(ctx context.Context) (T, error)
+}
+
+func NewStaleCache[T any](ttl time.Duration, fetch func(ctx context.Context) (T, error)) *StaleCache[T] {
+	return &StaleCache[T]{ttl: ttl, fetch: fetch}
+}
+
+// Get liefert den Cache-Wert. FAIL-OPEN: bei Refresh-Fehler wird ein
+// vorhandener, ggf. abgelaufener Stand zurueckgegeben (stale=true).
+func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error) {
+	c.mu.RLock()
+	fresh := c.hasValue && time.Since(c.fetchedAt) < c.ttl
+	if fresh {
+		v := c.value
+		c.mu.RUnlock()
+		return v, false, nil
+	}
+	c.mu.RUnlock()
+
+	newVal, fetchErr := c.fetch(ctx)
+	if fetchErr == nil {
+		c.mu.Lock()
+		c.value, c.hasValue, c.fetchedAt = newVal, true, time.Now()
+		c.mu.Unlock()
+		return newVal, false, nil
+	}
+
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	if c.hasValue {
+		return c.value, true, nil
+	}
+	var zero T
+	return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
+}
+
+// RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
+// Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
+func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
+	v, err := c.fetch(ctx)
+	if err != nil {
+		var zero T
+		return zero, fmt.Errorf("core nicht erreichbar, sicherheitskritische aktion abgelehnt: %w", err)
+	}
+	c.mu.Lock()
+	c.value, c.hasValue, c.fetchedAt = v, true, time.Now()
+	c.mu.Unlock()
+	return v, nil
+}

internal/moduletrust/issuer.go

@@ -0,0 +1,79 @@
+package moduletrust
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+type Claims struct {
+	Subject    string `json:"sub"`
+	TenantSlug string `json:"tenant"`
+	jwt.RegisteredClaims
+}
+
+// Issue signiert ein Token mit dem aktuellen Signierschluessel und traegt
+// dessen KID im JWT-Header ein — der Verifier auf Modulseite waehlt darueber
+// den passenden oeffentlichen Schluessel aus PublicKeySet() aus.
+func (m *KeyManager) Issue(subject, tenantSlug string, ttl time.Duration) (string, error) {
+	key, err := m.SigningKey()
+	if err != nil {
+		return "", err
+	}
+
+	now := time.Now()
+	claims := Claims{
+		Subject:    subject,
+		TenantSlug: tenantSlug,
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
+	token.Header["kid"] = key.KID
+	return token.SignedString(key.Private)
+}
+
+type jwksResponse struct {
+	Keys []jwksKey `json:"keys"`
+}
+
+type jwksKey struct {
+	Kid       string `json:"kid"`
+	PublicKey string `json:"public_key"` // base64 (raw Ed25519, 32 Byte)
+}
+
+// ServeJWKS liefert alle bekannten oeffentlichen Schluessel als JSON —
+// Module fragen dies periodisch ab (nicht pro Request), siehe Verifier.
+func (m *KeyManager) ServeJWKS(w http.ResponseWriter, r *http.Request) {
+	set := m.PublicKeySet()
+	resp := jwksResponse{Keys: make([]jwksKey, 0, len(set))}
+	for kid, pub := range set {
+		resp.Keys = append(resp.Keys, jwksKey{Kid: kid, PublicKey: base64.StdEncoding.EncodeToString(pub)})
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(resp)
+}
+
+// ParseJWKS dekodiert die JSON-Antwort von ServeJWKS zurueck in kid->PublicKey
+// — Hilfsfunktion fuer Module, die JWKS per HTTP abrufen.
+func ParseJWKS(data []byte) (map[string][]byte, error) {
+	var resp jwksResponse
+	if err := json.Unmarshal(data, &resp); err != nil {
+		return nil, fmt.Errorf("jwks parsen: %w", err)
+	}
+	out := make(map[string][]byte, len(resp.Keys))
+	for _, k := range resp.Keys {
+		raw, err := base64.StdEncoding.DecodeString(k.PublicKey)
+		if err != nil {
+			return nil, fmt.Errorf("oeffentlichen schluessel %q dekodieren: %w", k.Kid, err)
+		}
+		out[k.Kid] = raw
+	}
+	return out, nil
+}

internal/moduletrust/keys.go

@@ -0,0 +1,83 @@
+// Package moduletrust implementiert Core API-05: asymmetrische JWT-Signatur
+// mit Schluesselverteilung (JWKS), damit DMS/Mail/Archive/Workflow JWTs
+// LOKAL verifizieren koennen, ohne pro Aufruf einen synchronen Request an
+// Core zu stellen — Core darf Fundament sein, ohne zum Flaschenhals zu
+// werden (siehe Entscheidungsverlauf "Vertrauensstellung Core<->Module" in
+// nexarch-state.json). IAM-02s HS256-Session-Cookie (Browser-Login) bleibt
+// unangetastet — dies ist ein zusaetzlicher, getrennter Vertrauensmechanismus
+// fuer Modul-zu-Modul/Modul-zu-Core-Aufrufe.
+package moduletrust
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"sync"
+)
+
+type KeyPair struct {
+	KID     string
+	Private ed25519.PrivateKey
+	Public  ed25519.PublicKey
+}
+
+// KeyManager haelt ALLE noch gueltigen Schluesselpaare — nicht nur das
+// aktuell signierende. Rotate erzeugt ein neues Paar und behaelt die alten
+// fuer die Verifikation bereits ausgestellter Tokens (Akzeptanzkriterium 3:
+// Rotation ohne Ausfallzeit fuer andere Module).
+type KeyManager struct {
+	mu   sync.RWMutex
+	keys []KeyPair // aeltestes zuerst, neuestes zuletzt
+}
+
+func NewKeyManager() (*KeyManager, error) {
+	m := &KeyManager{}
+	if _, err := m.Rotate(); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Rotate erzeugt ein neues Ed25519-Schluesselpaar mit eigener KID und macht
+// es zum aktuellen Signierschluessel. Aeltere Schluessel bleiben in
+// PublicKeySet() erhalten, damit bereits ausgestellte Tokens weiterhin
+// verifizierbar sind.
+func (m *KeyManager) Rotate() (KeyPair, error) {
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		return KeyPair{}, fmt.Errorf("schluesselpaar erzeugen: %w", err)
+	}
+	kidBytes := make([]byte, 8)
+	if _, err := rand.Read(kidBytes); err != nil {
+		return KeyPair{}, fmt.Errorf("kid erzeugen: %w", err)
+	}
+	kp := KeyPair{KID: hex.EncodeToString(kidBytes), Private: priv, Public: pub}
+
+	m.mu.Lock()
+	m.keys = append(m.keys, kp)
+	m.mu.Unlock()
+	return kp, nil
+}
+
+// SigningKey liefert den aktuellen (neuesten) Schluessel zum Signieren neuer Tokens.
+func (m *KeyManager) SigningKey() (KeyPair, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if len(m.keys) == 0 {
+		return KeyPair{}, fmt.Errorf("moduletrust: kein schluessel vorhanden")
+	}
+	return m.keys[len(m.keys)-1], nil
+}
+
+// PublicKeySet liefert ALLE bekannten oeffentlichen Schluessel (kid ->
+// public key) — die Grundlage fuer den JWKS-Endpunkt.
+func (m *KeyManager) PublicKeySet() map[string]ed25519.PublicKey {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	out := make(map[string]ed25519.PublicKey, len(m.keys))
+	for _, k := range m.keys {
+		out[k.KID] = k.Public
+	}
+	return out
+}

internal/moduletrust/moduletrust_test.go

@@ -0,0 +1,214 @@
+package moduletrust
+
+import (
+	"context"
+	"crypto/ed25519"
+	"errors"
+	"net/http"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestIssueAndVerify_RoundTrip(t *testing.T) {
+	km, err := NewKeyManager()
+	if err != nil {
+		t.Fatalf("new key manager: %v", err)
+	}
+	token, err := km.Issue("user-1", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		return km.PublicKeySet(), nil
+	})
+	claims, err := v.Verify(context.Background(), token)
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if claims.Subject != "user-1" || claims.TenantSlug != "acme" {
+		t.Fatalf("claims unerwartet: %+v", claims)
+	}
+}
+
+// Akzeptanzkriterium 1: Verifikation lokal, kein Request pro Aufruf.
+func TestVerify_DoesNotFetchPerCall(t *testing.T) {
+	km, err := NewKeyManager()
+	if err != nil {
+		t.Fatalf("new key manager: %v", err)
+	}
+	token, err := km.Issue("user-1", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	var mu sync.Mutex
+	fetchCalls := 0
+	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		mu.Lock()
+		fetchCalls++
+		mu.Unlock()
+		return km.PublicKeySet(), nil
+	})
+
+	for i := 0; i < 10; i++ {
+		if _, err := v.Verify(context.Background(), token); err != nil {
+			t.Fatalf("verify %d: %v", i, err)
+		}
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if fetchCalls != 1 {
+		t.Fatalf("erwartet genau 1 fetch fuer 10 Verify-Aufrufe innerhalb der TTL, habe %d", fetchCalls)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: Core simuliert nicht erreichbar,
+// bereits authentifizierte Nutzer bleiben funktionsfaehig (Fail-Open mit
+// letztbekanntem Schluesselstand).
+func TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist(t *testing.T) {
+	km, err := NewKeyManager()
+	if err != nil {
+		t.Fatalf("new key manager: %v", err)
+	}
+	token, err := km.Issue("user-1", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	coreDown := false
+	v := NewVerifier(30*time.Millisecond, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		if coreDown {
+			return nil, errors.New("core nicht erreichbar (simuliert)")
+		}
+		return km.PublicKeySet(), nil
+	})
+
+	// Cache vorwaermen, waehrend Core noch erreichbar ist.
+	if _, err := v.Verify(context.Background(), token); err != nil {
+		t.Fatalf("verify (warm): %v", err)
+	}
+
+	// "Core abschalten" und TTL ablaufen lassen.
+	coreDown = true
+	time.Sleep(50 * time.Millisecond)
+
+	if _, err := v.Verify(context.Background(), token); err != nil {
+		t.Fatalf("verify sollte trotz core-ausfall mit letztbekanntem stand funktionieren: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: neue sicherheitskritische Aktionen
+// (z.B. neuer Login) schlagen bei Core-Ausfall klar fehl statt unsicher
+// durchgelassen zu werden — auch wenn ein (aelterer) Cache-Stand existiert.
+func TestRequireFreshKeys_FailsClosedWhenCoreUnreachable(t *testing.T) {
+	km, err := NewKeyManager()
+	if err != nil {
+		t.Fatalf("new key manager: %v", err)
+	}
+
+	coreDown := false
+	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		if coreDown {
+			return nil, errors.New("core nicht erreichbar (simuliert)")
+		}
+		return km.PublicKeySet(), nil
+	})
+
+	// Cache vorwaermen (existiert jetzt ein "veralteter" gueltiger Stand).
+	if _, _, err := v.cache.Get(context.Background()); err != nil {
+		t.Fatalf("warm cache: %v", err)
+	}
+
+	coreDown = true
+	if err := v.RequireFreshKeys(context.Background()); err == nil {
+		t.Fatal("erwartet fehler (fail-closed) bei core-ausfall, habe nil")
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Schluesselrotation ohne Ausfallzeit —
+// ein bereits ausgestelltes Token bleibt nach Rotation weiterhin
+// verifizierbar, ein zweites (simuliertes) Modul bekommt beide Schluessel.
+func TestRotate_NoDowntimeForAlreadyIssuedTokens(t *testing.T) {
+	km, err := NewKeyManager()
+	if err != nil {
+		t.Fatalf("new key manager: %v", err)
+	}
+
+	oldToken, err := km.Issue("user-1", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue (alt): %v", err)
+	}
+
+	if _, err := km.Rotate(); err != nil {
+		t.Fatalf("rotate: %v", err)
+	}
+
+	newToken, err := km.Issue("user-2", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue (neu): %v", err)
+	}
+
+	// Simuliertes zweites Modul: fragt den vollstaendigen Schluesselsatz ab.
+	moduleB := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		return km.PublicKeySet(), nil
+	})
+
+	if _, err := moduleB.Verify(context.Background(), oldToken); err != nil {
+		t.Fatalf("altes token sollte nach rotation weiterhin gueltig sein: %v", err)
+	}
+	if _, err := moduleB.Verify(context.Background(), newToken); err != nil {
+		t.Fatalf("neues token sollte gueltig sein: %v", err)
+	}
+}
+
+func TestVerify_RejectsUnknownKid(t *testing.T) {
+	km1, _ := NewKeyManager()
+	km2, _ := NewKeyManager() // komplett anderer, unbekannter schluessel
+
+	token, err := km1.Issue("user-1", "acme", time.Hour)
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		return km2.PublicKeySet(), nil // kennt km1s schluessel nicht
+	})
+	if _, err := v.Verify(context.Background(), token); !errors.Is(err, ErrInvalidToken) {
+		t.Fatalf("erwartet ErrInvalidToken, habe %v", err)
+	}
+}
+
+func TestJWKSRoundTrip(t *testing.T) {
+	km, _ := NewKeyManager()
+	km.Rotate()
+
+	var buf []byte
+	rec := &captureWriter{}
+	km.ServeJWKS(rec, nil)
+	buf = rec.body
+
+	parsed, err := ParseJWKS(buf)
+	if err != nil {
+		t.Fatalf("parse jwks: %v", err)
+	}
+	if len(parsed) != len(km.PublicKeySet()) {
+		t.Fatalf("erwartet %d schluessel, habe %d", len(km.PublicKeySet()), len(parsed))
+	}
+}
+
+type captureWriter struct {
+	body   []byte
+	header http.Header
+}
+
+func (w *captureWriter) Header() http.Header {
+	if w.header == nil {
+		w.header = http.Header{}
+	}
+	return w.header
+}
+func (w *captureWriter) Write(p []byte) (int, error) { w.body = append(w.body, p...); return len(p), nil }
+func (w *captureWriter) WriteHeader(statusCode int)  {}

internal/moduletrust/verifier.go

@@ -0,0 +1,67 @@
+package moduletrust
+
+import (
+	"context"
+	"crypto/ed25519"
+	"errors"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+var ErrInvalidToken = errors.New("moduletrust: ungueltiges token")
+
+// KeyFetchFunc holt den aktuellen Schluesselsatz von Core (z.B. per HTTP-GET
+// auf ServeJWKS + ParseJWKS). Wird vom Verifier nur bei abgelaufener TTL
+// aufgerufen — NICHT bei jeder Verify()-Anfrage (Akzeptanzkriterium 1).
+type KeyFetchFunc func(ctx context.Context) (map[string]ed25519.PublicKey, error)
+
+// Verifier ist die Modulseite von API-05: verifiziert JWTs LOKAL gegen einen
+// per StaleCache zwischengespeicherten Schluesselsatz, ohne pro Aufruf einen
+// synchronen Request an Core zu stellen.
+type Verifier struct {
+	cache *StaleCache[map[string]ed25519.PublicKey]
+}
+
+func NewVerifier(ttl time.Duration, fetch KeyFetchFunc) *Verifier {
+	return &Verifier{cache: NewStaleCache(ttl, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
+		return fetch(ctx)
+	})}
+}
+
+// Verify prueft die Signatur LOKAL gegen den (ggf. abgelaufenen, aber
+// vorhandenen) Schluesselsatz — FAIL-OPEN fuer bereits ausgestellte Tokens
+// (Akzeptanzkriterium 2): ist Core nicht erreichbar, aber ein alter
+// Schluesselsatz bekannt, wird damit weiter verifiziert.
+func (v *Verifier) Verify(ctx context.Context, tokenString string) (*Claims, error) {
+	keys, _, err := v.cache.Get(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	claims := &Claims{}
+	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodEd25519); !ok {
+			return nil, ErrInvalidToken
+		}
+		kid, _ := t.Header["kid"].(string)
+		pub, ok := keys[kid]
+		if !ok {
+			return nil, ErrInvalidToken
+		}
+		return pub, nil
+	})
+	if err != nil || !token.Valid {
+		return nil, ErrInvalidToken
+	}
+	return claims, nil
+}
+
+// RequireFreshKeys ruft IMMER frisch von Core ab (FAIL-CLOSED) — fuer
+// sicherheitskritische Aktionen wie einen komplett neuen Login
+// (Akzeptanzkriterium 2): schlaegt klar fehl, wenn Core nicht erreichbar
+// ist, statt auf einem veralteten Schluesselsatz zu vertrauen.
+func (v *Verifier) RequireFreshKeys(ctx context.Context) error {
+	_, err := v.cache.RequireFresh(ctx)
+	return err
+}

internal/policy/enforcer.go

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

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

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

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

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

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

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

internal/rbac/group_test.go

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

internal/rbac/handler.go

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

internal/rbac/handler_test.go

@@ -1,358 +0,0 @@
-package rbac
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-const handlerSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE role_assignments (
-	user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
-	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE role_assignment_history (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
-	granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE groups (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, role TEXT CHECK (role IN ('user','tenant_admin')),
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE group_members (
-	group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, user_id UUID NOT NULL REFERENCES users(id),
-	added_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (group_id, user_id)
-);`
-
-func setupHandlerTest(t *testing.T, dbName string) (*Handler, *Store, *user.TenantUserStore, *pgxpool.Pool) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		t.Fatalf("testdatenbank anlegen: %v", err)
-	}
-
-	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("connect testdatenbank: %v", err)
-	}
-	if _, err := pool.Exec(ctx, handlerSchema); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	t.Cleanup(func() {
-		pool.Close()
-		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-		adminPool.Close()
-	})
-
-	roleStore := NewStore(pool)
-	groupStore := NewGroupStore(pool)
-	return NewHandler(roleStore, groupStore), roleStore, user.NewTenantUserStore(pool), pool
-}
-
-func sessionCookieFor(t *testing.T, issuer *auth.TokenIssuer, userID string) *http.Cookie {
-	t.Helper()
-	token, err := issuer.Issue(userID, "acme")
-	if err != nil {
-		t.Fatalf("session-token ausstellen: %v", err)
-	}
-	return &http.Cookie{Name: auth.CookieName, Value: token}
-}
-
-// Akzeptanzkriterium 1: Rollen und ihre Grundrechte sind einsehbar.
-func TestListRoles(t *testing.T) {
-	h, roles, users, _ := setupHandlerTest(t, "rbac05_list_roles")
-	ctx := context.Background()
-	admin, err := users.Create(ctx, "admin@acme.example", "Admin")
-	if err != nil {
-		t.Fatalf("admin anlegen: %v", err)
-	}
-	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
-		t.Fatalf("admin-rolle setzen: %v", err)
-	}
-
-	issuer := auth.NewTokenIssuer("test-secret")
-	req := httptest.NewRequest(http.MethodGet, "/rbac/roles", nil)
-	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
-	rec := httptest.NewRecorder()
-	auth.RequireAuth(issuer, h.ListRoles)(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
-	}
-	var out []roleInfo
-	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
-		t.Fatalf("response dekodieren: %v", err)
-	}
-	if len(out) != 2 {
-		t.Fatalf("erwartet 2 zuweisbare rollen (user, tenant_admin), habe %d", len(out))
-	}
-}
-
-// Akzeptanzkriterium 2 / Pruefung 2: Selbst-Eskalation wird abgewiesen.
-func TestAssignRole_RejectsSelfEscalation(t *testing.T) {
-	h, roles, users, _ := setupHandlerTest(t, "rbac05_self_escalation")
-	ctx := context.Background()
-	u, err := users.Create(ctx, "normal@acme.example", "Normaler Nutzer")
-	if err != nil {
-		t.Fatalf("nutzer anlegen: %v", err)
-	}
-	if _, err := roles.Assign(ctx, u.ID, RoleUser, "system"); err != nil {
-		t.Fatalf("ausgangsrolle setzen: %v", err)
-	}
-
-	issuer := auth.NewTokenIssuer("test-secret")
-	body, _ := json.Marshal(assignRoleRequest{UserID: u.ID, Role: RoleTenantAdmin})
-	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
-	req.AddCookie(sessionCookieFor(t, issuer, u.ID))
-	rec := httptest.NewRecorder()
-	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
-
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("status = %d, want 403 (selbst-eskalation muss abgewiesen werden)", rec.Code)
-	}
-
-	// Rolle muss unveraendert geblieben sein.
-	assignment, err := roles.Get(ctx, u.ID)
-	if err != nil {
-		t.Fatalf("rolle laden: %v", err)
-	}
-	if assignment.Role != RoleUser {
-		t.Fatalf("rolle wurde trotz abgewiesener anfrage geaendert: %q", assignment.Role)
-	}
-}
-
-// Gegenprobe: ein Tenant-Admin darf EINEM ANDEREN Benutzer eine hoehere
-// Rolle zuweisen — nur die Selbst-Zuweisung ist gesperrt.
-func TestAssignRole_AdminCanPromoteOtherUser(t *testing.T) {
-	h, roles, users, _ := setupHandlerTest(t, "rbac05_promote_other")
-	ctx := context.Background()
-	admin, err := users.Create(ctx, "admin2@acme.example", "Admin")
-	if err != nil {
-		t.Fatalf("admin anlegen: %v", err)
-	}
-	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
-		t.Fatalf("admin-rolle setzen: %v", err)
-	}
-	other, err := users.Create(ctx, "other@acme.example", "Anderer Nutzer")
-	if err != nil {
-		t.Fatalf("anderen nutzer anlegen: %v", err)
-	}
-
-	issuer := auth.NewTokenIssuer("test-secret")
-	body, _ := json.Marshal(assignRoleRequest{UserID: other.ID, Role: RoleTenantAdmin})
-	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
-	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
-	rec := httptest.NewRecorder()
-	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
-	}
-}
-
-// 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

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

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

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

@@ -1,144 +0,0 @@
-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/webhook/dispatcher.go

@@ -0,0 +1,177 @@
+package webhook
+
+import (
+	"bytes"
+	"context"
+	"crypto/subtle"
+	"encoding/hex"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// DefaultMaxAttempts ist die konfigurierbare Obergrenze, ab der eine
+// Zustellung endgueltig als fehlgeschlagen gilt (Akzeptanzkriterium 2).
+const DefaultMaxAttempts = 5
+
+// DefaultBaseBackoff ist die Basisdauer fuer exponentielles Backoff:
+// naechster Versuch nach BaseBackoff * 2^attempt (Akzeptanzkriterium 2).
+const DefaultBaseBackoff = 2 * time.Second
+
+// Dispatcher liefert faellige Zustellungen aus. Konfigurierbar in Tests
+// (kleine BaseBackoff, kleine MaxAttempts), damit Retry/Backoff/Obergrenze
+// ohne minutenlange Wartezeit real durchlaufen werden koennen.
+type Dispatcher struct {
+	pool        pgxIface
+	client      *http.Client
+	MaxAttempts int
+	BaseBackoff time.Duration
+}
+
+// pgxIface ist die schmale Teilmenge von *pgxpool.Pool, die der Dispatcher
+// braucht — als Interface, damit Tests keine echte Verbindung fuer reine
+// Signatur-/Backoff-Logik brauchen (wird hier aber durchgehend mit echten
+// Integrationstests gegen Postgres verwendet, siehe dispatcher_test.go).
+type pgxIface interface {
+	Begin(ctx context.Context) (pgx.Tx, error)
+}
+
+func NewDispatcher(pool pgxIface, client *http.Client) *Dispatcher {
+	if client == nil {
+		client = &http.Client{Timeout: 5 * time.Second}
+	}
+	return &Dispatcher{pool: pool, client: client, MaxAttempts: DefaultMaxAttempts, BaseBackoff: DefaultBaseBackoff}
+}
+
+// backoffFor berechnet die Wartezeit vor dem naechsten Versuch: exponentiell
+// wachsend mit der Anzahl bereits unternommener Versuche.
+func (d *Dispatcher) backoffFor(attempt int) time.Duration {
+	return d.BaseBackoff * time.Duration(1<<uint(attempt))
+}
+
+// ProcessDue liefert ALLE derzeit faelligen Zustellungen aus — dasselbe
+// SELECT ... FOR UPDATE SKIP LOCKED-Muster wie
+// internal/tenant.Lifecycle.ProcessDueDeletions, damit mehrere Dispatcher-
+// Instanzen dieselbe Zustellung nie doppelt bearbeiten.
+func (d *Dispatcher) ProcessDue(ctx context.Context) (int, error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT wd.id, wd.payload, wd.attempt, ws.target_url, ws.secret
+		FROM webhook_deliveries wd
+		JOIN webhook_subscriptions ws ON ws.id = wd.subscription_id
+		WHERE wd.status = $1 AND wd.next_attempt_at <= now()
+		FOR UPDATE OF wd SKIP LOCKED
+	`, StatusPending)
+	if err != nil {
+		return 0, fmt.Errorf("faellige zustellungen abfragen: %w", err)
+	}
+
+	var deliveries []delivery
+	for rows.Next() {
+		var del delivery
+		if err := rows.Scan(&del.ID, &del.Payload, &del.Attempt, &del.TargetURL, &del.Secret); err != nil {
+			rows.Close()
+			return 0, fmt.Errorf("zustellung lesen: %w", err)
+		}
+		deliveries = append(deliveries, del)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	for _, del := range deliveries {
+		d.attemptOne(ctx, tx, del)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return len(deliveries), nil
+}
+
+// attemptOne fuehrt GENAU EINEN Zustellversuch aus und aktualisiert den
+// Zustellungsdatensatz entsprechend — Erfolg (Akzeptanzkriterium 1/Pruefung
+// 1), erneuter Fehlversuch mit Backoff, oder endgueltiges Scheitern nach
+// DefaultMaxAttempts (Akzeptanzkriterium 2/Pruefung 2). Ein Fehler bei
+// GENAU EINER Zustellung darf die anderen in diesem Batch nicht verhindern.
+func (d *Dispatcher) attemptOne(ctx context.Context, tx pgx.Tx, del delivery) {
+	signature := Sign(del.Secret, del.Payload)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, del.TargetURL, bytes.NewReader(del.Payload))
+	deliveryErr := err
+	var statusCode int
+	if err == nil {
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set(SignatureHeader, signature)
+		resp, err := d.client.Do(req)
+		if err != nil {
+			deliveryErr = err
+		} else {
+			statusCode = resp.StatusCode
+			resp.Body.Close()
+			if statusCode < 200 || statusCode >= 300 {
+				deliveryErr = fmt.Errorf("unerwarteter statuscode %d", statusCode)
+			}
+		}
+	}
+
+	if deliveryErr == nil {
+		_, _ = tx.Exec(ctx, `
+			UPDATE webhook_deliveries SET status = $2, delivered_at = now(), attempt = attempt + 1
+			WHERE id = $1
+		`, del.ID, StatusDelivered)
+		return
+	}
+
+	nextAttempt := del.Attempt + 1
+	if nextAttempt >= d.MaxAttempts {
+		_, _ = tx.Exec(ctx, `
+			UPDATE webhook_deliveries SET status = $2, attempt = $3, last_error = $4
+			WHERE id = $1
+		`, del.ID, StatusFailed, nextAttempt, deliveryErr.Error())
+		return
+	}
+
+	nextAttemptAt := time.Now().Add(d.backoffFor(nextAttempt))
+	_, _ = tx.Exec(ctx, `
+		UPDATE webhook_deliveries SET attempt = $2, next_attempt_at = $3, last_error = $4
+		WHERE id = $1
+	`, del.ID, nextAttempt, nextAttemptAt, deliveryErr.Error())
+}
+
+// Run ruft ProcessDue in festen Abstaenden auf, bis ctx beendet wird —
+// dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
+func (d *Dispatcher) Run(ctx context.Context, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			_, _ = d.ProcessDue(ctx)
+		}
+	}
+}
+
+// VerifySignature prueft empfaengerseitig, ob signature zu payload und
+// secret passt — timing-safe (dasselbe Muster wie internal/audit.timingsafe),
+// damit ein Empfaenger die Authentizitaet einer Zustellung pruefen kann
+// (Akzeptanzkriterium 3).
+func VerifySignature(secret string, payload []byte, signature string) bool {
+	expected := Sign(secret, payload)
+	expectedBytes, err1 := hex.DecodeString(expected)
+	gotBytes, err2 := hex.DecodeString(signature)
+	if err1 != nil || err2 != nil {
+		return false
+	}
+	return subtle.ConstantTimeCompare(expectedBytes, gotBytes) == 1
+}

internal/webhook/webhook.go

@@ -0,0 +1,131 @@
+// Package webhook implementiert Core API-07: eine zentrale Webhook-Registry
+// und Zustellungs-Engine fuer alle Fachmodule (DMS/Mail/Archive/Workflow/AI).
+// Module reichen Ereignisse EINMAL zur Zustellung ein und implementieren
+// selbst KEINE eigene Retry-/Signatur-Logik — das ist der zentrale Zweck
+// dieser Kachel ("Bewusst vermeiden: jedes Modul baut seine eigene
+// Webhook-Zustellungs-Engine"). Zustellung laeuft ueber dieselbe
+// Postgres-Jobqueue-Konvention (SELECT ... FOR UPDATE SKIP LOCKED) wie
+// internal/tenant.Lifecycle.ProcessDueDeletions (TEN-04) und
+// internal/notify.Dispatcher (CFG-02) — kein Redis/AMQP.
+package webhook
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+const (
+	StatusPending   = "pending"
+	StatusDelivered = "delivered"
+	StatusFailed    = "failed"
+)
+
+// Subscription ist EIN externer Abonnent fuer einen Ereignistyp
+// (Akzeptanzkriterium 1: Module registrieren Ereignistypen, externe
+// Abonnenten registrieren Ziel-URLs — dieses Paket modelliert die
+// Abonnenten-Seite; welche Ereignistypen ein Modul anbietet, ist bewusst
+// NICHT Teil dieser Kachel).
+type Subscription struct {
+	ID         string
+	EventType  string
+	TargetURL  string
+	Secret     string
+	CreatedAt  time.Time
+}
+
+// Store persistiert Abonnements und Zustellversuche.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Subscribe registriert einen Abonnenten fuer einen Ereignistyp. secret wird
+// spaeter zur HMAC-Signierung jeder Zustellung an diesen Abonnenten
+// verwendet (Akzeptanzkriterium 3).
+func (s *Store) Subscribe(ctx context.Context, eventType, targetURL, secret string) (Subscription, error) {
+	var sub Subscription
+	sub.EventType, sub.TargetURL, sub.Secret = eventType, targetURL, secret
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO webhook_subscriptions (event_type, target_url, secret)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at
+	`, eventType, targetURL, secret)
+	if err := row.Scan(&sub.ID, &sub.CreatedAt); err != nil {
+		return Subscription{}, fmt.Errorf("abonnement anlegen: %w", err)
+	}
+	return sub, nil
+}
+
+// Enqueue reicht EIN Ereignis zur Zustellung an ALLE Abonnenten des
+// angegebenen Ereignistyps ein — dies ist die EINZIGE Schnittstelle, die
+// ein Fachmodul braucht (Akzeptanzkriterium 1). Jeder Abonnent erhaelt
+// einen eigenen, unabhaengigen Zustellversuch-Datensatz.
+func (s *Store) Enqueue(ctx context.Context, eventType string, payload any) (int, error) {
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return 0, fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	rows, err := s.pool.Query(ctx, `
+		SELECT id FROM webhook_subscriptions WHERE event_type = $1
+	`, eventType)
+	if err != nil {
+		return 0, fmt.Errorf("abonnenten ermitteln: %w", err)
+	}
+	var subscriptionIDs []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			rows.Close()
+			return 0, fmt.Errorf("abonnent lesen: %w", err)
+		}
+		subscriptionIDs = append(subscriptionIDs, id)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	for _, subID := range subscriptionIDs {
+		if _, err := s.pool.Exec(ctx, `
+			INSERT INTO webhook_deliveries (subscription_id, event_type, payload, status, next_attempt_at)
+			VALUES ($1, $2, $3, $4, now())
+		`, subID, eventType, payloadJSON, StatusPending); err != nil {
+			return 0, fmt.Errorf("zustellung einreihen: %w", err)
+		}
+	}
+	return len(subscriptionIDs), nil
+}
+
+// delivery ist ein interner Datensatz fuer EINEN Zustellversuch, inklusive
+// der zugehoerigen Abonnentendaten (per JOIN geladen).
+type delivery struct {
+	ID        string
+	TargetURL string
+	Secret    string
+	Payload   []byte
+	Attempt   int
+}
+
+// Sign berechnet die HMAC-SHA256-Signatur des Payloads (Akzeptanzkriterium
+// 3) — hex-kodiert, damit sie problemlos als HTTP-Header uebertragen werden
+// kann.
+func Sign(secret string, payload []byte) string {
+	mac := hmac.New(sha256.New, []byte(secret))
+	mac.Write(payload)
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+// SignatureHeader ist der HTTP-Header, unter dem die Signatur uebertragen
+// wird — dokumentierter Vertrag fuer Empfaenger (Akzeptanzkriterium 3).
+const SignatureHeader = "X-Nexarch-Signature-256"

internal/webhook/webhook_test.go

@@ -0,0 +1,205 @@
+package webhook
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS webhook_subscriptions (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), event_type TEXT NOT NULL,
+			target_url TEXT NOT NULL, secret TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS webhook_deliveries (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), subscription_id UUID NOT NULL REFERENCES webhook_subscriptions(id),
+			event_type TEXT NOT NULL, payload JSONB NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
+			attempt INT NOT NULL DEFAULT 0, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), delivered_at TIMESTAMPTZ
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), pool, cleanup
+}
+
+func uniqueEventType(prefix string) string {
+	return prefix + "-" + time.Now().Format("150405.000000000")
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein Modul reicht ein Ereignis ein
+// (Enqueue) ohne eigene Zustellungslogik, der zentrale Dispatcher liefert
+// zuverlaessig aus.
+func TestEnqueueAndProcessDue_DeliversSuccessfully(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	var receivedBody []byte
+	var receivedSignature string
+	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		receivedBody = body
+		receivedSignature = r.Header.Get(SignatureHeader)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer target.Close()
+
+	eventType := uniqueEventType("dms.file.created")
+	sub, err := store.Subscribe(ctx, eventType, target.URL, "geheimes-secret")
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+
+	n, err := store.Enqueue(ctx, eventType, map[string]string{"file_id": "42"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("erwartet 1 eingereihte zustellung, habe %d", n)
+	}
+
+	dispatcher := NewDispatcher(pool, target.Client())
+	processed, err := dispatcher.ProcessDue(ctx)
+	if err != nil {
+		t.Fatalf("processdue: %v", err)
+	}
+	if processed != 1 {
+		t.Fatalf("erwartet 1 verarbeitete zustellung, habe %d", processed)
+	}
+
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != StatusDelivered {
+		t.Fatalf("status = %q, want %q", status, StatusDelivered)
+	}
+
+	// Postgres' JSONB-Spalte kann die Byte-Repraesentation des Payloads
+	// gegenueber dem urspruenglichen json.Marshal kanonisieren (z.B.
+	// Leerzeichen) — das ist unschaedlich, denn der Dispatcher signiert
+	// IMMER exakt die Bytes, die er auch sendet. Die Pruefung vergleicht
+	// deshalb Signatur gegen tatsaechlich empfangene Bytes (Selbstkonsistenz),
+	// nicht gegen eine unabhaengig neu marshalte Referenz.
+	if !VerifySignature("geheimes-secret", receivedBody, receivedSignature) {
+		t.Fatalf("empfangene signatur %q passt nicht zum empfangenen payload %q", receivedSignature, receivedBody)
+	}
+	var decoded map[string]string
+	if err := json.Unmarshal(receivedBody, &decoded); err != nil {
+		t.Fatalf("empfangener payload nicht als json lesbar: %v", err)
+	}
+	if decoded["file_id"] != "42" {
+		t.Fatalf("empfangener payload = %v, want file_id=42", decoded)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: fehlschlagendes Ziel loest Retry mit
+// wachsendem Backoff aus und endet nach der konfigurierten Obergrenze in
+// "failed".
+func TestProcessDue_RetriesWithBackoffThenMarksFailed(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	var callCount int32
+	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt32(&callCount, 1)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer target.Close()
+
+	eventType := uniqueEventType("mail.send.failed")
+	sub, err := store.Subscribe(ctx, eventType, target.URL, "secret")
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+	if _, err := store.Enqueue(ctx, eventType, map[string]string{"x": "y"}); err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	dispatcher := NewDispatcher(pool, target.Client())
+	dispatcher.MaxAttempts = 2
+	dispatcher.BaseBackoff = 30 * time.Millisecond
+
+	// 1. Versuch: schlaegt fehl, ist aber noch nicht die Obergrenze.
+	if _, err := dispatcher.ProcessDue(ctx); err != nil {
+		t.Fatalf("processdue 1: %v", err)
+	}
+	var status string
+	var attempt int
+	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
+		t.Fatalf("status lesen 1: %v", err)
+	}
+	if status != StatusPending || attempt != 1 {
+		t.Fatalf("nach 1. fehlschlag: status=%q attempt=%d, want pending/1", status, attempt)
+	}
+
+	// Sofort erneut verarbeiten: Backoff ist noch nicht abgelaufen -> nichts faellig.
+	processedTooEarly, err := dispatcher.ProcessDue(ctx)
+	if err != nil {
+		t.Fatalf("processdue (zu frueh): %v", err)
+	}
+	if processedTooEarly != 0 {
+		t.Fatal("erwartet 0 verarbeitete zustellungen, solange backoff nicht abgelaufen ist")
+	}
+
+	time.Sleep(dispatcher.backoffFor(1) + 20*time.Millisecond)
+
+	// 2. Versuch: erreicht MaxAttempts=2 -> endgueltig fehlgeschlagen.
+	if _, err := dispatcher.ProcessDue(ctx); err != nil {
+		t.Fatalf("processdue 2: %v", err)
+	}
+	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
+		t.Fatalf("status lesen 2: %v", err)
+	}
+	if status != StatusFailed || attempt != 2 {
+		t.Fatalf("nach 2. fehlschlag: status=%q attempt=%d, want failed/2", status, attempt)
+	}
+	if atomic.LoadInt32(&callCount) != 2 {
+		t.Fatalf("erwartet genau 2 tatsaechliche zustellversuche, habe %d", callCount)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Signaturpruefung erkennt eine
+// manipulierte Payload zuverlaessig.
+func TestVerifySignature_DetectsTamperedPayload(t *testing.T) {
+	secret := "geteiltes-geheimnis"
+	payload := []byte(`{"file_id":"42"}`)
+	signature := Sign(secret, payload)
+
+	if !VerifySignature(secret, payload, signature) {
+		t.Fatal("erwartet gueltige signatur fuer unveraenderte payload")
+	}
+
+	tampered := []byte(`{"file_id":"99"}`)
+	if VerifySignature(secret, tampered, signature) {
+		t.Fatal("erwartet ungueltige signatur fuer manipulierte payload")
+	}
+
+	if VerifySignature("falsches-secret", payload, signature) {
+		t.Fatal("erwartet ungueltige signatur bei falschem secret")
+	}
+}

migrations/0003_policy_rules.down.sql

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

migrations/0003_policy_rules.up.sql

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

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

migrations/0004_feature_flags.up.sql

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

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

migrations/0005_policy_module_scopes.up.sql

@@ -1,11 +0,0 @@
--- 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/0002_role_assignments.down.sql

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

migrations/tenant/0002_role_assignments.up.sql

@@ -1,23 +0,0 @@
--- 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/0003_groups.down.sql

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

migrations/tenant/0003_groups.up.sql

@@ -1,21 +0,0 @@
--- Gruppen/Abteilungen mit Rollenzuweisung auf Gruppenebene (RBAC-03, siehe
--- core-kanban/tickets/RBAC-03.md). Lebt in der Tenant-Datenbank (Modell C) —
--- Gruppen sind implizit tenant-isoliert, da jede Tenant-DB ihre eigenen hat.
-CREATE TABLE groups (
-    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    name       TEXT NOT NULL,
-    role       TEXT CHECK (role IN ('user', 'tenant_admin')),
-    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
--- ON DELETE CASCADE: Loeschen einer Gruppe entzieht die gruppenbasierten
--- Rechte automatisch, ohne Benutzerkonten selbst zu beruehren
--- (Akzeptanzkriterium 3).
-CREATE TABLE group_members (
-    group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
-    user_id  UUID NOT NULL REFERENCES users(id),
-    added_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (group_id, user_id)
-);
-
-CREATE INDEX group_members_user_idx ON group_members (user_id);

scripts/reset-test-env.sh

@@ -1,11 +1,4 @@
 #!/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}"

scripts/run-checks.sh

@@ -1,10 +1,4 @@
 #!/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}"

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

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

web/rbac-admin/app/layout.tsx

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

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

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

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

web/rbac-admin/lib/api.ts

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

web/rbac-admin/next.config.mjs

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

web/rbac-admin/package.json

@@ -1,22 +0,0 @@
-{
-  "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

@@ -1,21 +0,0 @@
-{
-  "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

@@ -1,45 +0,0 @@
-# @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
-```

web/shl/__tests__/Dialog.test.tsx

@@ -1,38 +0,0 @@
-// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
-import { describe, expect, it, vi } from "vitest";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { Dialog } from "../components/Dialog";
-import { I18nProvider } from "../i18n/i18n";
-
-function renderDialog(onClose: () => void) {
-  return render(
-    <I18nProvider>
-      <Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
-        <button type="button">Erste Aktion</button>
-        <button type="button">Zweite Aktion</button>
-      </Dialog>
-    </I18nProvider>,
-  );
-}
-
-describe("Dialog: Tastaturbedienung", () => {
-  it("schließt sich bei ESC", () => {
-    const onClose = vi.fn();
-    renderDialog(onClose);
-    fireEvent.keyDown(document, { key: "Escape" });
-    expect(onClose).toHaveBeenCalledOnce();
-  });
-
-  it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
-    renderDialog(vi.fn());
-    const closeButton = screen.getByRole("button", { name: /schließen/i });
-    expect(document.activeElement).toBe(closeButton);
-  });
-
-  it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
-    renderDialog(vi.fn());
-    const dialog = screen.getByRole("dialog");
-    expect(dialog).toHaveAttribute("aria-modal", "true");
-    expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
-  });
-});

web/shl/__tests__/tokens.test.ts

@@ -1,39 +0,0 @@
-// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
-import { describe, expect, it } from "vitest";
-import { colorTokens } from "../tokens/tokens";
-
-// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
-function relLuminance(hex: string): number {
-  const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
-  const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-}
-
-function contrastRatio(a: string, b: string): number {
-  const l1 = relLuminance(a);
-  const l2 = relLuminance(b);
-  const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
-  return (lighter + 0.05) / (darker + 0.05);
-}
-
-describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
-  for (const scheme of ["light", "dark"] as const) {
-    const c = colorTokens[scheme];
-
-    it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
-    });
-  }
-});

web/shl/components/Dialog.tsx

@@ -1,88 +0,0 @@
-"use client";
-
-// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
-
-import { useEffect, useRef } from "react";
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-const FOCUSABLE_SELECTOR =
-  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
-
-export interface DialogProps {
-  open: boolean;
-  onClose: () => void;
-  titleId: string;
-  title: string;
-  children: ReactNode;
-}
-
-export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
-  const { t } = useI18n();
-  const dialogRef = useRef<HTMLDivElement>(null);
-  const previouslyFocused = useRef<HTMLElement | null>(null);
-
-  useEffect(() => {
-    if (!open) return;
-    previouslyFocused.current = document.activeElement as HTMLElement | null;
-
-    const node = dialogRef.current;
-    const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
-    focusables?.[0]?.focus();
-
-    function handleKeyDown(event: KeyboardEvent) {
-      if (event.key === "Escape") {
-        onClose();
-        return;
-      }
-      if (event.key !== "Tab" || !node) return;
-
-      const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
-      if (items.length === 0) return;
-      const first = items[0];
-      const last = items[items.length - 1];
-
-      if (event.shiftKey && document.activeElement === first) {
-        event.preventDefault();
-        last.focus();
-      } else if (!event.shiftKey && document.activeElement === last) {
-        event.preventDefault();
-        first.focus();
-      }
-    }
-
-    document.addEventListener("keydown", handleKeyDown);
-    return () => {
-      document.removeEventListener("keydown", handleKeyDown);
-      previouslyFocused.current?.focus();
-    };
-  }, [open, onClose]);
-
-  if (!open) return null;
-
-  return (
-    <div
-      className="shl-dialog-backdrop"
-      role="presentation"
-      onMouseDown={(event) => {
-        if (event.target === event.currentTarget) onClose();
-      }}
-    >
-      <div
-        ref={dialogRef}
-        className="shl-dialog"
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={titleId}
-      >
-        <div className="shl-dialog-header">
-          <h2 id={titleId}>{title}</h2>
-          <button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
-            ×
-          </button>
-        </div>
-        <div className="shl-dialog-body">{children}</div>
-      </div>
-    </div>
-  );
-}

web/shl/components/FormElements.tsx

@@ -1,98 +0,0 @@
-// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
-// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
-
-import { useId } from "react";
-import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
-
-interface FieldWrapperProps {
-  label: string;
-  error?: string;
-  hint?: string;
-  children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
-}
-
-function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
-  const inputId = useId();
-  const hintId = hint ? `${inputId}-hint` : undefined;
-  const errorId = error ? `${inputId}-error` : undefined;
-  const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
-
-  return (
-    <div className="shl-field">
-      <label htmlFor={inputId}>{label}</label>
-      {children({ inputId, describedBy })}
-      {hint && (
-        <p id={hintId} className="shl-field-hint">
-          {hint}
-        </p>
-      )}
-      {error && (
-        <p id={errorId} className="shl-field-error" role="alert">
-          {error}
-        </p>
-      )}
-    </div>
-  );
-}
-
-export interface TextFieldProps
-  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
-  label: string;
-  error?: string;
-  hint?: string;
-}
-
-export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
-  return (
-    <FieldWrapper label={label} error={error} hint={hint}>
-      {({ inputId, describedBy }) => (
-        <input
-          id={inputId}
-          aria-describedby={describedBy}
-          aria-invalid={error ? true : undefined}
-          {...inputProps}
-        />
-      )}
-    </FieldWrapper>
-  );
-}
-
-export interface SelectFieldProps
-  extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
-  label: string;
-  error?: string;
-  hint?: string;
-  children: ReactNode;
-}
-
-export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
-  return (
-    <FieldWrapper label={label} error={error} hint={hint}>
-      {({ inputId, describedBy }) => (
-        <select
-          id={inputId}
-          aria-describedby={describedBy}
-          aria-invalid={error ? true : undefined}
-          {...selectProps}
-        >
-          {children}
-        </select>
-      )}
-    </FieldWrapper>
-  );
-}
-
-export interface CheckboxFieldProps
-  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
-  label: string;
-}
-
-export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
-  const inputId = useId();
-  return (
-    <div className="shl-field shl-field-checkbox">
-      <input id={inputId} type="checkbox" {...inputProps} />
-      <label htmlFor={inputId}>{label}</label>
-    </div>
-  );
-}

web/shl/components/Shell.tsx

@@ -1,62 +0,0 @@
-"use client";
-
-// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
-// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
-
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-import { useTheme } from "../theme/ThemeProvider";
-
-export interface ModuleLink {
-  key: string;
-  label: string;
-  href: string;
-  active?: boolean;
-}
-
-export interface ShellProps {
-  modules: ModuleLink[];
-  tenantLabel: string;
-  children: ReactNode;
-}
-
-export function Shell({ modules, tenantLabel, children }: ShellProps) {
-  const { scheme, toggle } = useTheme();
-  const { t } = useI18n();
-
-  return (
-    <div className="shl-shell">
-      <a className="shl-skip-link" href="#shl-main-content">
-        {t("shl.shell.skipToContent", "Zum Inhalt springen")}
-      </a>
-      <header className="shl-shell-header">
-        <nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
-          <ul>
-            {modules.map((mod) => (
-              <li key={mod.key}>
-                <a href={mod.href} aria-current={mod.active ? "page" : undefined}>
-                  {mod.label}
-                </a>
-              </li>
-            ))}
-          </ul>
-        </nav>
-        <div className="shl-shell-context">
-          <span className="shl-tenant-context">{tenantLabel}</span>
-          <button
-            type="button"
-            onClick={toggle}
-            aria-label={
-              scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
-            }
-          >
-            {scheme === "light" ? "🌙" : "☀️"}
-          </button>
-        </div>
-      </header>
-      <main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
-        {children}
-      </main>
-    </div>
-  );
-}

web/shl/components/Table.tsx

@@ -1,83 +0,0 @@
-// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
-
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-export interface TableColumn<Row> {
-  key: string;
-  header: string;
-  render: (row: Row) => ReactNode;
-  sortable?: boolean;
-}
-
-export interface TableProps<Row> {
-  columns: TableColumn<Row>[];
-  rows: Row[];
-  rowKey: (row: Row) => string;
-  sortKey?: string;
-  sortDirection?: "asc" | "desc";
-  onSort?: (key: string) => void;
-  caption?: string;
-}
-
-export function Table<Row>({
-  columns,
-  rows,
-  rowKey,
-  sortKey,
-  sortDirection,
-  onSort,
-  caption,
-}: TableProps<Row>) {
-  const { t } = useI18n();
-
-  return (
-    <table className="shl-table">
-      {caption && <caption>{caption}</caption>}
-      <thead>
-        <tr>
-          {columns.map((column) => {
-            const isSorted = column.key === sortKey;
-            const ariaSort = column.sortable
-              ? isSorted
-                ? sortDirection === "asc"
-                  ? "ascending"
-                  : "descending"
-                : "none"
-              : undefined;
-            return (
-              <th key={column.key} scope="col" aria-sort={ariaSort}>
-                {column.sortable ? (
-                  <button
-                    type="button"
-                    onClick={() => onSort?.(column.key)}
-                    className="shl-table-sort-button"
-                  >
-                    {column.header}
-                  </button>
-                ) : (
-                  column.header
-                )}
-              </th>
-            );
-          })}
-        </tr>
-      </thead>
-      <tbody>
-        {rows.length === 0 ? (
-          <tr>
-            <td colSpan={columns.length}>{t("shl.table.noRows")}</td>
-          </tr>
-        ) : (
-          rows.map((row) => (
-            <tr key={rowKey(row)}>
-              {columns.map((column) => (
-                <td key={column.key}>{column.render(row)}</td>
-              ))}
-            </tr>
-          ))
-        )}
-      </tbody>
-    </table>
-  );
-}

web/shl/components/Toast.tsx

@@ -1,67 +0,0 @@
-"use client";
-
-// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
-
-import { createContext, useCallback, useContext, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-export type ToastVariant = "info" | "success" | "danger" | "warning";
-
-export interface ToastMessage {
-  id: string;
-  text: string;
-  variant: ToastVariant;
-}
-
-interface ToastContextValue {
-  toasts: ToastMessage[];
-  push: (text: string, variant?: ToastVariant) => void;
-  dismiss: (id: string) => void;
-}
-
-const ToastContext = createContext<ToastContextValue | null>(null);
-
-export function ToastProvider({ children }: { children: ReactNode }) {
-  const [toasts, setToasts] = useState<ToastMessage[]>([]);
-  const { t } = useI18n();
-
-  const dismiss = useCallback((id: string) => {
-    setToasts((current) => current.filter((toast) => toast.id !== id));
-  }, []);
-
-  const push = useCallback((text: string, variant: ToastVariant = "info") => {
-    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    setToasts((current) => [...current, { id, text, variant }]);
-  }, []);
-
-  const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
-
-  return (
-    <ToastContext.Provider value={value}>
-      {children}
-      <div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
-        {toasts.map((toast) => (
-          <div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
-            <span>{toast.text}</span>
-            <button
-              type="button"
-              onClick={() => dismiss(toast.id)}
-              aria-label={t("shl.toast.dismiss")}
-            >
-              ×
-            </button>
-          </div>
-        ))}
-      </div>
-    </ToastContext.Provider>
-  );
-}
-
-export function useToast(): ToastContextValue {
-  const ctx = useContext(ToastContext);
-  if (!ctx) {
-    throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
-  }
-  return ctx;
-}

web/shl/i18n/i18n.tsx

@@ -1,75 +0,0 @@
-"use client";
-
-// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
-// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
-// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
-// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
-
-import { createContext, useContext, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-
-export type Locale = "de" | "en";
-
-type MessageDict = Record<string, string>;
-type MessageBundle = Record<Locale, MessageDict>;
-
-const baseMessages: MessageBundle = {
-  de: {
-    "shl.dialog.close": "Schließen",
-    "shl.toast.dismiss": "Meldung schließen",
-    "shl.table.noRows": "Keine Einträge vorhanden",
-    "shl.theme.toggleToLight": "Helles Erscheinungsbild",
-    "shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
-  },
-  en: {
-    "shl.dialog.close": "Close",
-    "shl.toast.dismiss": "Dismiss message",
-    "shl.table.noRows": "No entries",
-    "shl.theme.toggleToLight": "Switch to light theme",
-    "shl.theme.toggleToDark": "Switch to dark theme",
-  },
-};
-
-// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
-const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
-
-export function registerMessages(locale: Locale, messages: MessageDict): void {
-  registry[locale] = { ...registry[locale], ...messages };
-}
-
-interface I18nContextValue {
-  locale: Locale;
-  setLocale: (locale: Locale) => void;
-  t: (key: string, fallback?: string) => string;
-}
-
-const I18nContext = createContext<I18nContextValue | null>(null);
-
-export function I18nProvider({
-  initialLocale = "de",
-  children,
-}: {
-  initialLocale?: Locale;
-  children: ReactNode;
-}) {
-  const [locale, setLocale] = useState<Locale>(initialLocale);
-
-  const value = useMemo<I18nContextValue>(
-    () => ({
-      locale,
-      setLocale,
-      t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
-    }),
-    [locale],
-  );
-
-  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
-}
-
-export function useI18n(): I18nContextValue {
-  const ctx = useContext(I18nContext);
-  if (!ctx) {
-    throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
-  }
-  return ctx;
-}

web/shl/index.ts

@@ -1,25 +0,0 @@
-// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
-// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
-
-export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
-export type { ColorScheme, ColorTokens } from "./tokens/tokens";
-
-export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
-
-export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
-export type { Locale } from "./i18n/i18n";
-
-export { Shell } from "./components/Shell";
-export type { ShellProps, ModuleLink } from "./components/Shell";
-
-export { Dialog } from "./components/Dialog";
-export type { DialogProps } from "./components/Dialog";
-
-export { Table } from "./components/Table";
-export type { TableProps, TableColumn } from "./components/Table";
-
-export { TextField, SelectField, CheckboxField } from "./components/FormElements";
-export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
-
-export { ToastProvider, useToast } from "./components/Toast";
-export type { ToastMessage, ToastVariant } from "./components/Toast";

web/shl/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "@nexarch/shl",
-  "version": "0.1.0",
-  "private": true,
-  "description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
-  "main": "index.ts",
-  "types": "index.ts",
-  "scripts": {
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "peerDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
-  },
-  "devDependencies": {
-    "@testing-library/jest-dom": "^6.4.8",
-    "@testing-library/react": "^16.0.0",
-    "@types/react": "18.3.3",
-    "@types/react-dom": "18.3.0",
-    "jsdom": "^24.1.1",
-    "typescript": "5.5.3",
-    "vitest": "^2.0.0"
-  }
-}

web/shl/theme/ThemeProvider.tsx

@@ -1,81 +0,0 @@
-"use client";
-
-// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
-// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
-
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
-
-const STORAGE_KEY = "nexarch-shl-theme";
-
-interface ThemeContextValue {
-  scheme: ColorScheme;
-  setScheme: (scheme: ColorScheme) => void;
-  toggle: () => void;
-}
-
-const ThemeContext = createContext<ThemeContextValue | null>(null);
-
-function readStoredScheme(): ColorScheme | null {
-  if (typeof window === "undefined") return null;
-  try {
-    const stored = window.localStorage.getItem(STORAGE_KEY);
-    return stored === "light" || stored === "dark" ? stored : null;
-  } catch {
-    // localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
-    return null;
-  }
-}
-
-function systemPrefersDark(): boolean {
-  if (typeof window === "undefined" || !window.matchMedia) return false;
-  return window.matchMedia("(prefers-color-scheme: dark)").matches;
-}
-
-export function ThemeProvider({ children }: { children: ReactNode }) {
-  const [scheme, setSchemeState] = useState<ColorScheme>("light");
-
-  useEffect(() => {
-    const stored = readStoredScheme();
-    setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
-  }, []);
-
-  const setScheme = useCallback((next: ColorScheme) => {
-    setSchemeState(next);
-    try {
-      window.localStorage.setItem(STORAGE_KEY, next);
-    } catch {
-      // Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
-    }
-  }, []);
-
-  const toggle = useCallback(() => {
-    setScheme(scheme === "light" ? "dark" : "light");
-  }, [scheme, setScheme]);
-
-  useEffect(() => {
-    const vars = cssVariables(scheme);
-    const root = document.documentElement;
-    for (const [key, value] of Object.entries(vars)) {
-      root.style.setProperty(key, value);
-    }
-    root.dataset.shlTheme = scheme;
-  }, [scheme]);
-
-  const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
-
-  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
-}
-
-export function useTheme(): ThemeContextValue {
-  const ctx = useContext(ThemeContext);
-  if (!ctx) {
-    throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
-  }
-  return ctx;
-}
-
-export function currentColors(scheme: ColorScheme) {
-  return colorTokens[scheme];
-}

web/shl/tokens/tokens.ts

@@ -1,96 +0,0 @@
-// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
-// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
-// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
-
-export type ColorScheme = "light" | "dark";
-
-export interface ColorTokens {
-  background: string;
-  surface: string;
-  surfaceRaised: string;
-  border: string;
-  textPrimary: string;
-  textSecondary: string;
-  accent: string;
-  accentContrast: string;
-  danger: string;
-  dangerContrast: string;
-  success: string;
-  warning: string;
-  focusRing: string;
-}
-
-// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
-// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
-export const colorTokens: Record<ColorScheme, ColorTokens> = {
-  light: {
-    background: "#FFFFFF",
-    surface: "#F5F6F8",
-    surfaceRaised: "#FFFFFF",
-    border: "#D7DBE0",
-    textPrimary: "#14181F",
-    textSecondary: "#4B5563",
-    accent: "#1D4ED8",
-    accentContrast: "#FFFFFF",
-    danger: "#B91C1C",
-    dangerContrast: "#FFFFFF",
-    success: "#15803D",
-    warning: "#B45309",
-    focusRing: "#1D4ED8",
-  },
-  dark: {
-    background: "#0F1115",
-    surface: "#181B21",
-    surfaceRaised: "#20242C",
-    border: "#333944",
-    textPrimary: "#F2F4F7",
-    textSecondary: "#B4BAC4",
-    accent: "#5B8DEF",
-    accentContrast: "#0F1115",
-    danger: "#F87171",
-    dangerContrast: "#0F1115",
-    success: "#4ADE80",
-    warning: "#FBBF24",
-    focusRing: "#5B8DEF",
-  },
-};
-
-export const spacing = {
-  xs: "4px",
-  sm: "8px",
-  md: "16px",
-  lg: "24px",
-  xl: "32px",
-  xxl: "48px",
-} as const;
-
-export const breakpoints = {
-  mobile: "0px",
-  tablet: "768px",
-  desktop: "1200px",
-} as const;
-
-export const typography = {
-  fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
-  fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
-  sizeSm: "13px",
-  sizeMd: "15px",
-  sizeLg: "18px",
-  sizeXl: "24px",
-  lineHeight: 1.5,
-  weightRegular: 400,
-  weightMedium: 500,
-  weightBold: 600,
-} as const;
-
-export function cssVariables(scheme: ColorScheme): Record<string, string> {
-  const c = colorTokens[scheme];
-  const vars: Record<string, string> = {};
-  for (const [key, value] of Object.entries(c)) {
-    vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
-  }
-  for (const [key, value] of Object.entries(spacing)) {
-    vars[`--shl-spacing-${key}`] = value;
-  }
-  return vars;
-}

web/shl/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "jsx": "react-jsx",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true
-  },
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules"]
-}

web/shl/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "jsdom",
-    setupFiles: ["./vitest.setup.ts"],
-  },
-});

web/shl/vitest.setup.ts

@@ -1,9 +0,0 @@
-import "@testing-library/jest-dom/vitest";
-import { afterEach } from "vitest";
-import { cleanup } from "@testing-library/react";
-
-// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
-// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
-afterEach(() => {
-  cleanup();
-});