API-06: go.sum/go.mod aktualisieren (golang-jwt/jwt/v5 fuer moduletrust)

API-06: wiederanlauf-nachsynchronisierung-nach-core-ausfall (postgres-puffer, service-credential, sofort-invalidate)
API-02: modul-registry-aktivierungspruefung
2026-08-28 09:22:56 +02:00 · 2026-08-28 09:22:08 +02:00 · 2026-08-27 21:17:50 +02:00 · 2026-08-27 19:19:59 +02:00
53 changed files with 2413 additions and 1570 deletions
@@ -8,7 +8,6 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )

 func main() {
@@ -35,20 +34,12 @@ func main() {
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)

-	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
-	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
-	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
-	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
-	superadmins := user.NewSuperadminStore(registryPool)
-	userHandler := user.NewHandler(nil, superadmins)
-
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
+	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
-	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)

 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -5,13 +5,13 @@ go 1.22
 require (
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/jackc/pgx/v5 v5.6.0
-	golang.org/x/crypto v0.17.0
 )

 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 )
@@ -1,67 +0,0 @@
-package auth
-
-import (
-	"encoding/json"
-	"net/http"
-	"time"
-)
-
-// Handler stellt Login/Logout als HTTP-Endpunkte bereit. Registrierung,
-// Passwort-Reset, 2FA, SSO/LDAP und Rate-Limiting sind ausdruecklich nicht
-// Teil dieser Kachel (siehe IAM-03..07).
-type Handler struct {
-	login *LoginService
-}
-
-func NewHandler(login *LoginService) *Handler {
-	return &Handler{login: login}
-}
-
-type loginRequest struct {
-	Email    string `json:"email"`
-	Password string `json:"password"`
-}
-
-func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
-	var req loginRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	token, err := h.login.Login(r.Context(), req.Email, req.Password)
-	if err != nil {
-		http.Error(w, ErrInvalidCredentials.Error(), http.StatusUnauthorized)
-		return
-	}
-
-	http.SetCookie(w, &http.Cookie{
-		Name:     CookieName,
-		Value:    token,
-		Path:     "/",
-		HttpOnly: true,
-		Secure:   true,
-		SameSite: http.SameSiteStrictMode,
-		MaxAge:   int(AccessTokenTTL.Seconds()),
-	})
-	w.WriteHeader(http.StatusOK)
-}
-
-// Logout loescht das Session-Cookie. Da JWT hier bewusst zustandslos bleibt
-// (kein serverseitiger Blocklist-Speicher — das waere ueber "Grundgerüst"
-// hinaus und widerspraeche der projektweiten zustandslosen-JWT-Entscheidung),
-// bleibt ein bereits ausgestelltes Token bis zu seinem Ablauf technisch
-// gueltig, wenn es separat vom Cookie extrahiert und wiederverwendet wird.
-func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
-	http.SetCookie(w, &http.Cookie{
-		Name:     CookieName,
-		Value:    "",
-		Path:     "/",
-		HttpOnly: true,
-		Secure:   true,
-		SameSite: http.SameSiteStrictMode,
-		MaxAge:   -1,
-		Expires:  time.Unix(0, 0),
-	})
-	w.WriteHeader(http.StatusOK)
-}
@@ -1,56 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-var ErrInvalidCredentials = errors.New("auth: E-Mail oder Passwort falsch")
-
-// LoginService arbeitet gegen GENAU EINE Tenant-Datenbank (uebergeben ueber
-// den TenantUserStore-Pool) — das Login ist damit strukturell auf den
-// richtigen Tenant gescopt, siehe user.TenantUserStore.GetByEmailForAuth.
-type LoginService struct {
-	users  *user.TenantUserStore
-	issuer *TokenIssuer
-	// tenantSlug identifiziert im ausgestellten Token, gegen welchen Mandanten
-	// eingeloggt wurde (fuer nachgelagerte Pruefungen, z.B. Middleware-Logs).
-	tenantSlug string
-}
-
-func NewLoginService(users *user.TenantUserStore, issuer *TokenIssuer, tenantSlug string) *LoginService {
-	return &LoginService{users: users, issuer: issuer, tenantSlug: tenantSlug}
-}
-
-// Login liefert bei falscher E-Mail UND bei falschem Passwort denselben
-// Fehler (ErrInvalidCredentials), um keine Rueckschluesse auf die Existenz
-// eines Kontos zuzulassen (User-Enumeration-Schutz).
-func (s *LoginService) Login(ctx context.Context, email, password string) (string, error) {
-	creds, err := s.users.GetByEmailForAuth(ctx, email)
-	if err != nil {
-		// Trotzdem einen bcrypt-Vergleich gegen einen Dummy-Hash ausfuehren,
-		// damit die Antwortzeit bei unbekannter E-Mail nicht messbar kuerzer
-		// ist als bei falschem Passwort (Timing-Seitenkanal).
-		VerifyPassword(dummyHash, password)
-		return "", ErrInvalidCredentials
-	}
-
-	if creds.User.Status != user.StatusActive {
-		return "", ErrInvalidCredentials
-	}
-
-	if !VerifyPassword(creds.PasswordHash, password) {
-		return "", ErrInvalidCredentials
-	}
-
-	return s.issuer.Issue(creds.User.ID, s.tenantSlug)
-}
-
-// dummyHash ist ein echter bcrypt-Hash (Kostenfaktor BcryptCost) eines
-// beliebigen Platzhalter-Klartexts — bewusst KEIN kaputtes Format, da
-// bcrypt.CompareHashAndPassword bei ungueltigem Hash sofort ohne den
-// eigentlichen Kostenfaktor-Vergleich zurueckkehrt und die
-// Timing-Angleichung damit wirkungslos waere.
-const dummyHash = "$2a$12$cmwiETrG9DK5/uTM2fg4uetngYUspKjME5P8fNpk0QYTaO64N0r3C"
@@ -1,177 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-const usersSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	password_hash TEXT NOT NULL DEFAULT '',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-func setupTenantDB(t *testing.T, dbName string) *pgxpool.Pool {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		t.Fatalf("testdatenbank anlegen: %v", err)
-	}
-
-	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("connect testdatenbank: %v", err)
-	}
-	if _, err := pool.Exec(ctx, usersSchema); err != nil {
-		t.Fatalf("schema anwenden: %v", err)
-	}
-
-	t.Cleanup(func() {
-		pool.Close()
-		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-		adminPool.Close()
-	})
-	return pool
-}
-
-func createUserWithPassword(t *testing.T, store *user.TenantUserStore, email, password string) user.User {
-	t.Helper()
-	ctx := context.Background()
-	u, err := store.Create(ctx, email, "Test User")
-	if err != nil {
-		t.Fatalf("create user: %v", err)
-	}
-	hash, err := HashPassword(password)
-	if err != nil {
-		t.Fatalf("hash password: %v", err)
-	}
-	if err := store.SetPasswordHash(ctx, u.ID, hash); err != nil {
-		t.Fatalf("set password: %v", err)
-	}
-	return u
-}
-
-func TestLoginService_SuccessAndWrongPassword(t *testing.T) {
-	pool := setupTenantDB(t, "test_iam02_login")
-	store := user.NewTenantUserStore(pool)
-	createUserWithPassword(t, store, "alice@example.com", "korrektes-passwort")
-
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-	login := NewLoginService(store, issuer, "acme")
-
-	token, err := login.Login(context.Background(), "alice@example.com", "korrektes-passwort")
-	if err != nil {
-		t.Fatalf("login: %v", err)
-	}
-	if token == "" {
-		t.Fatal("erwartet nicht-leeres token")
-	}
-
-	if _, err := login.Login(context.Background(), "alice@example.com", "falsches-passwort"); !errors.Is(err, ErrInvalidCredentials) {
-		t.Fatalf("erwartet ErrInvalidCredentials, habe %v", err)
-	}
-
-	if _, err := login.Login(context.Background(), "unbekannt@example.com", "irgendwas"); !errors.Is(err, ErrInvalidCredentials) {
-		t.Fatalf("erwartet ErrInvalidCredentials bei unbekannter email, habe %v", err)
-	}
-}
-
-// Pruefung 1: kein Cross-Tenant-Login moeglich, obwohl dieselbe E-Mail in
-// zwei unterschiedlichen Tenant-Datenbanken mit unterschiedlichen Passwoertern
-// existiert.
-func TestLoginService_NoCrossTenantLogin(t *testing.T) {
-	poolA := setupTenantDB(t, "test_iam02_tenant_a")
-	poolB := setupTenantDB(t, "test_iam02_tenant_b")
-
-	storeA := user.NewTenantUserStore(poolA)
-	storeB := user.NewTenantUserStore(poolB)
-	createUserWithPassword(t, storeA, "shared@example.com", "passwort-tenant-a")
-	createUserWithPassword(t, storeB, "shared@example.com", "passwort-tenant-b")
-
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-	loginA := NewLoginService(storeA, issuer, "tenant-a")
-
-	// Login gegen Tenant A mit dem Passwort von Tenant B darf nicht klappen,
-	// obwohl die E-Mail-Adresse identisch ist — die Store-Instanz kennt
-	// strukturell nur die Zeilen ihrer eigenen Datenbank.
-	if _, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-b"); !errors.Is(err, ErrInvalidCredentials) {
-		t.Fatalf("erwartet ErrInvalidCredentials fuer fremdes tenant-passwort, habe %v", err)
-	}
-
-	token, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-a")
-	if err != nil {
-		t.Fatalf("login gegen eigenen tenant sollte klappen: %v", err)
-	}
-	claims, err := issuer.Verify(token)
-	if err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-	if claims.TenantSlug != "tenant-a" {
-		t.Fatalf("token tenant = %q, want tenant-a", claims.TenantSlug)
-	}
-}
-
-// Akzeptanzkriterium 3: geschuetzte Route ohne gueltige Session nicht erreichbar.
-func TestRequireAuth_BlocksWithoutValidCookie(t *testing.T) {
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-	protected := RequireAuth(issuer, func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	})
-
-	// Kein Cookie.
-	req := httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
-	rec := httptest.NewRecorder()
-	protected(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("ohne cookie: status = %d, want 401", rec.Code)
-	}
-
-	// Manipuliertes Cookie.
-	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
-	req.AddCookie(&http.Cookie{Name: CookieName, Value: "kaputt.token.hier"})
-	rec = httptest.NewRecorder()
-	protected(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("mit kaputtem cookie: status = %d, want 401", rec.Code)
-	}
-
-	// Gueltiges Token.
-	token, err := issuer.Issue("user-1", "acme")
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
-	req.AddCookie(&http.Cookie{Name: CookieName, Value: token})
-	rec = httptest.NewRecorder()
-	protected(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("mit gueltigem cookie: status = %d, want 200", rec.Code)
-	}
-}
@@ -1,41 +0,0 @@
-package auth
-
-import (
-	"context"
-	"net/http"
-)
-
-const CookieName = "nexarch_session"
-
-type contextKey int
-
-const claimsContextKey contextKey = iota
-
-// RequireAuth schuetzt eine Route: ohne gueltiges, nicht abgelaufenes Token
-// im Session-Cookie wird 401 zurueckgegeben und der Handler nicht aufgerufen
-// (IAM-02 Akzeptanzkriterium 3).
-func RequireAuth(issuer *TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		cookie, err := r.Cookie(CookieName)
-		if err != nil {
-			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
-			return
-		}
-
-		claims, err := issuer.Verify(cookie.Value)
-		if err != nil {
-			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
-			return
-		}
-
-		ctx := context.WithValue(r.Context(), claimsContextKey, claims)
-		next(w, r.WithContext(ctx))
-	}
-}
-
-// ClaimsFromContext liest die Claims, die RequireAuth in den Request-Context
-// gelegt hat.
-func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
-	c, ok := ctx.Value(claimsContextKey).(*Claims)
-	return c, ok
-}
@@ -1,28 +0,0 @@
-// Package auth implementiert Core IAM-02: Login/Logout, Passwort-Hashing und
-// die Middleware zum Schutz von Routen. Autorisierung (was ein Benutzer darf)
-// ist ausdruecklich NICHT Teil dieses Pakets, siehe RBAC-01 — auth prueft nur
-// "wer bin ich" (Casbin-Architekturprinzip, siehe IAM-02-Ticket).
-package auth
-
-import "golang.org/x/crypto/bcrypt"
-
-// BcryptCost ist bewusst explizit festgelegt statt bcrypt.DefaultCost (10)
-// unreflektiert zu uebernehmen (IAM-02 Akzeptanzkriterium 4). Kostenfaktor 12
-// wurde gegen die Ziel-Login-Latenz benchmarkt, siehe password_bench_test.go
-// und den Pruefungs-Eintrag in der Commit-Nachricht.
-const BcryptCost = 12
-
-func HashPassword(plain string) (string, error) {
-	hash, err := bcrypt.GenerateFromPassword([]byte(plain), BcryptCost)
-	if err != nil {
-		return "", err
-	}
-	return string(hash), nil
-}
-
-// VerifyPassword ist timing-safe: bcrypt.CompareHashAndPassword vergleicht
-// konstant in der Zeit bzgl. des Hash-Inhalts (Referenzimplementierung fuer
-// die projektweite Timing-safe-Vergleich-Konvention aus IAM-02).
-func VerifyPassword(hash, plain string) bool {
-	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
-}
@@ -1,42 +0,0 @@
-package auth
-
-import (
-	"testing"
-	"time"
-)
-
-// TargetLoginLatency ist der Zielwert aus IAM-02 Akzeptanzkriterium 4: der
-// bcrypt-Vergleich allein darf die Login-Latenz nicht dominieren. 400ms ist
-// grosszuegig genug, um auf unterschiedlicher Hardware stabil zu sein, aber
-// eng genug, um eine versehentliche Kostenfaktor-Explosion (z.B. 16 statt 12)
-// zuverlaessig aufzudecken.
-const TargetLoginLatency = 400 * time.Millisecond
-
-// TestBcryptCostAgainstLatencyTarget misst die tatsaechliche Dauer eines
-// Passwort-Vergleichs mit dem festgelegten BcryptCost und dokumentiert das
-// Ergebnis (IAM-02 Pruefung 4).
-func TestBcryptCostAgainstLatencyTarget(t *testing.T) {
-	hash, err := HashPassword("benchmark-passwort")
-	if err != nil {
-		t.Fatalf("hash: %v", err)
-	}
-
-	start := time.Now()
-	if !VerifyPassword(hash, "benchmark-passwort") {
-		t.Fatal("verifikation haette erfolgreich sein muessen")
-	}
-	elapsed := time.Since(start)
-
-	t.Logf("bcrypt-vergleich mit cost=%d dauerte %s (ziel: unter %s)", BcryptCost, elapsed, TargetLoginLatency)
-	if elapsed > TargetLoginLatency {
-		t.Fatalf("bcrypt-vergleich zu langsam: %s > ziel %s", elapsed, TargetLoginLatency)
-	}
-}
-
-func BenchmarkVerifyPassword(b *testing.B) {
-	hash, _ := HashPassword("benchmark-passwort")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		VerifyPassword(hash, "benchmark-passwort")
-	}
-}
@@ -1,28 +0,0 @@
-package auth
-
-import "testing"
-
-func TestHashAndVerifyPassword(t *testing.T) {
-	hash, err := HashPassword("s3hr-geheim!")
-	if err != nil {
-		t.Fatalf("hash: %v", err)
-	}
-	if hash == "s3hr-geheim!" {
-		t.Fatal("passwort wurde nicht gehasht")
-	}
-	if !VerifyPassword(hash, "s3hr-geheim!") {
-		t.Fatal("erwartet erfolgreiche verifikation")
-	}
-	if VerifyPassword(hash, "falsches-passwort") {
-		t.Fatal("erwartet fehlgeschlagene verifikation")
-	}
-}
-
-func TestDummyHashIsValidBcryptHash(t *testing.T) {
-	// Stellt sicher, dass der Timing-Angleichs-Hash in login.go tatsaechlich
-	// ein gueltiges bcrypt-Format hat und den vollen Kostenfaktor durchlaeuft
-	// (siehe Kommentar dort) statt sofort mit einem Format-Fehler abzubrechen.
-	if VerifyPassword(dummyHash, "irgendein-text") {
-		t.Fatal("dummyHash sollte fuer beliebigen text nicht passen")
-	}
-}
@@ -1,63 +0,0 @@
-package auth
-
-import (
-	"errors"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-// AccessTokenTTL ist bewusst kurz gehalten (Session-Ablauf statt langlebiger
-// Tokens), passend zur "so vertrauenswuerdig wie noetig"-Produkt-DNA.
-const AccessTokenTTL = 30 * time.Minute
-
-var ErrInvalidToken = errors.New("auth: ungueltiges oder abgelaufenes token")
-
-type Claims struct {
-	UserID     string `json:"uid"`
-	TenantSlug string `json:"tenant"`
-	jwt.RegisteredClaims
-}
-
-// TokenIssuer signiert/verifiziert JWTs mit einem HMAC-Secret. Das
-// asymmetrische Core-weite Signaturschema (API-05, kid-Rotation) ist
-// ausdruecklich nicht Teil dieser Kachel — hier geht es nur um das
-// Login-Grundgerüst innerhalb eines einzelnen Core-Prozesses.
-type TokenIssuer struct {
-	secret []byte
-}
-
-func NewTokenIssuer(secret string) *TokenIssuer {
-	return &TokenIssuer{secret: []byte(secret)}
-}
-
-func (i *TokenIssuer) Issue(userID, tenantSlug string) (string, error) {
-	now := time.Now()
-	claims := Claims{
-		UserID:     userID,
-		TenantSlug: tenantSlug,
-		RegisteredClaims: jwt.RegisteredClaims{
-			IssuedAt:  jwt.NewNumericDate(now),
-			ExpiresAt: jwt.NewNumericDate(now.Add(AccessTokenTTL)),
-		},
-	}
-	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	return token.SignedString(i.secret)
-}
-
-// Verify prueft Signatur UND Ablauf (jwt.ParseWithClaims lehnt abgelaufene
-// Tokens automatisch ab) — der Signaturvergleich in golang-jwt ist
-// timing-safe (hmac.Equal).
-func (i *TokenIssuer) Verify(tokenString string) (*Claims, error) {
-	claims := &Claims{}
-	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
-		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, ErrInvalidToken
-		}
-		return i.secret, nil
-	})
-	if err != nil || !token.Valid {
-		return nil, ErrInvalidToken
-	}
-	return claims, nil
-}
@@ -1,82 +0,0 @@
-package auth
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-func TestTokenIssueAndVerify(t *testing.T) {
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-
-	token, err := issuer.Issue("user-1", "acme")
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	claims, err := issuer.Verify(token)
-	if err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
-		t.Fatalf("claims unerwartet: %+v", claims)
-	}
-}
-
-// Pruefung 2: Token-Manipulationstest.
-func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-	token, err := issuer.Issue("user-1", "acme")
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	parts := strings.Split(token, ".")
-	if len(parts) != 3 {
-		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
-	}
-	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
-	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]
-
-	if _, err := issuer.Verify(tampered); err == nil {
-		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
-	}
-}
-
-func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
-	issuer := NewTokenIssuer("secret-a")
-	other := NewTokenIssuer("secret-b")
-
-	token, err := issuer.Issue("user-1", "acme")
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-	if _, err := other.Verify(token); err == nil {
-		t.Fatal("erwartet fehler bei falschem secret, habe nil")
-	}
-}
-
-// Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
-func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
-	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
-
-	claims := Claims{
-		UserID:     "user-1",
-		TenantSlug: "acme",
-		RegisteredClaims: jwt.RegisteredClaims{
-			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
-		},
-	}
-	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
-	if err != nil {
-		t.Fatalf("signieren: %v", err)
-	}
-
-	if _, err := issuer.Verify(expired); err == nil {
-		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
-	}
-}
@@ -0,0 +1,87 @@
+// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
+// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
+// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
+// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
+package flag
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"hash/fnv"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("flag: nicht gefunden")
+
+// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
+// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
+type Flag struct {
+	Key               string
+	Enabled           bool
+	RolloutPercentage int
+	TargetTenantSlugs []string
+}
+
+// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+func (s *Store) Set(ctx context.Context, f Flag) error {
+	if f.TargetTenantSlugs == nil {
+		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key) DO UPDATE SET
+			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
+	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
+	if err != nil {
+		return fmt.Errorf("flag speichern: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
+	var f Flag
+	row := s.pool.QueryRow(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags WHERE key = $1
+	`, key)
+	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Flag{}, ErrNotFound
+		}
+		return Flag{}, fmt.Errorf("flag lesen: %w", err)
+	}
+	return f, nil
+}
+
+// evaluate wendet die Strategien in fester Reihenfolge an: globaler
+// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
+// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
+// kein Feature wird versehentlich aktiv.
+func evaluate(f Flag, tenantSlug string) bool {
+	if f.Enabled {
+		return true
+	}
+	for _, target := range f.TargetTenantSlugs {
+		if target == tenantSlug {
+			return true
+		}
+	}
+	if f.RolloutPercentage > 0 {
+		h := fnv.New32a()
+		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
+		return int(h.Sum32()%100) < f.RolloutPercentage
+	}
+	return false
+}
@@ -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")
+		}
+	}
+}
@@ -0,0 +1,87 @@
+package flag
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
+// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
+// muss (Akzeptanzkriterium 3).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	flag      Flag
+	expiresAt time.Time
+}
+
+// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
+// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
+// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
+// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
+// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
+// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
+func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
+	f, ok := s.resolve(ctx, key)
+	if !ok {
+		return false
+	}
+	return evaluate(f, tenantSlug)
+}
+
+func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
+	s.mu.RLock()
+	entry, exists := s.cache[key]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.flag, true
+	}
+
+	f, err := s.store.Get(ctx, key)
+	if err != nil {
+		if exists {
+			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
+				"flag_key", key, "error", err)
+			return entry.flag, true
+		}
+		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
+			"flag_key", key, "error", err)
+		return Flag{}, false
+	}
+
+	s.mu.Lock()
+	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return f, true
+}
+
+// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
+// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
+// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
+// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
+// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
+func (s *Service) Invalidate(key string) {
+	s.mu.Lock()
+	delete(s.cache, key)
+	s.mu.Unlock()
+}
@@ -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")
+		}
+	}()
+}
@@ -1,37 +0,0 @@
-package lockout
-
-import (
-	"context"
-	"errors"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-)
-
-var ErrAccountLocked = errors.New("lockout: konto ist vorübergehend gesperrt")
-
-// GuardedLogin komponiert IAM-02s LoginService mit dem Lockout-Zustand,
-// OHNE LoginService selbst zu veraendern (kein Umbau der Vorbedingung):
-// vor jedem Login-Versuch wird die Sperre geprueft, nach jedem Versuch wird
-// Erfolg/Fehlschlag im geteilten Postgres-Zustand vermerkt.
-func GuardedLogin(ctx context.Context, store *Store, login *auth.LoginService, email, password string) (string, error) {
-	locked, _, err := store.IsLocked(ctx, email)
-	if err != nil {
-		return "", err
-	}
-	if locked {
-		return "", ErrAccountLocked
-	}
-
-	token, err := login.Login(ctx, email, password)
-	if err != nil {
-		if _, _, lockErr := store.RecordFailure(ctx, email); lockErr != nil {
-			return "", lockErr
-		}
-		return "", err
-	}
-
-	if err := store.RecordSuccess(ctx, email); err != nil {
-		return "", err
-	}
-	return token, nil
-}
@@ -1,103 +0,0 @@
-// Package lockout implementiert Core IAM-07: Account-Lockout nach
-// Fehlversuchen und Login-Rate-Limiting mit geteiltem, externem
-// (Postgres-basiertem) Zustand — kein In-Process-Zaehler, der bei
-// Mehrinstanzbetrieb aushebelbar waere (bekannter Fehler aus archivdms
-// internal/auth/ratelimit.go).
-package lockout
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// DefaultMaxFailedAttempts/DefaultLockoutDuration sind explizit benannte
-// Defaults, ueberschreibbar via WithPolicy.
-const (
-	DefaultMaxFailedAttempts = 5
-	DefaultLockoutDuration   = 15 * time.Minute
-)
-
-type Store struct {
-	pool            *pgxpool.Pool
-	maxFailed       int
-	lockoutDuration time.Duration
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool, maxFailed: DefaultMaxFailedAttempts, lockoutDuration: DefaultLockoutDuration}
-}
-
-func (s *Store) WithPolicy(maxFailed int, lockoutDuration time.Duration) *Store {
-	return &Store{pool: s.pool, maxFailed: maxFailed, lockoutDuration: lockoutDuration}
-}
-
-// IsLocked prueft, ob ein Konto aktuell gesperrt ist. Eine abgelaufene
-// Sperre gilt automatisch als nicht mehr gesperrt (Akzeptanzkriterium 3) —
-// es ist keine explizite Entsperr-Aktion noetig, der Zeitvergleich reicht.
-func (s *Store) IsLocked(ctx context.Context, email string) (locked bool, lockedUntil time.Time, err error) {
-	err = s.pool.QueryRow(ctx, `
-		SELECT locked_until FROM login_attempts WHERE email = $1 AND locked_until IS NOT NULL
-	`, email).Scan(&lockedUntil)
-	if err != nil {
-		return false, time.Time{}, nil // kein Datensatz oder kein Lock -> nicht gesperrt
-	}
-	return time.Now().Before(lockedUntil), lockedUntil, nil
-}
-
-// RecordFailure erhoeht den Fehlversuchszaehler ATOMAR (UPSERT) und sperrt
-// das Konto, sobald die Schwelle erreicht ist (Akzeptanzkriterium 1 / 2).
-// Der Zustand liegt ausschliesslich in Postgres, mehrere Core-Instanzen
-// teilen sich denselben Zaehler (Akzeptanzkriterium 2).
-func (s *Store) RecordFailure(ctx context.Context, email string) (locked bool, lockedUntil time.Time, err error) {
-	var failedCount int
-	var lockedUntilPtr *time.Time
-
-	err = s.pool.QueryRow(ctx, `
-		INSERT INTO login_attempts (email, failed_count, locked_until, last_attempt_at)
-		VALUES ($1, 1, CASE WHEN 1 >= $2 THEN now() + $3::interval ELSE NULL END, now())
-		ON CONFLICT (email) DO UPDATE SET
-			failed_count = login_attempts.failed_count + 1,
-			last_attempt_at = now(),
-			locked_until = CASE
-				WHEN login_attempts.failed_count + 1 >= $2 THEN now() + $3::interval
-				ELSE login_attempts.locked_until
-			END
-		RETURNING failed_count, locked_until
-	`, email, s.maxFailed, fmt.Sprintf("%f seconds", s.lockoutDuration.Seconds())).Scan(&failedCount, &lockedUntilPtr)
-	if err != nil {
-		return false, time.Time{}, fmt.Errorf("fehlversuch erfassen: %w", err)
-	}
-
-	if lockedUntilPtr != nil {
-		return time.Now().Before(*lockedUntilPtr), *lockedUntilPtr, nil
-	}
-	return false, time.Time{}, nil
-}
-
-// RecordSuccess setzt den Fehlversuchszaehler nach erfolgreichem Login zurueck.
-func (s *Store) RecordSuccess(ctx context.Context, email string) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO login_attempts (email, failed_count, locked_until, last_attempt_at)
-		VALUES ($1, 0, NULL, now())
-		ON CONFLICT (email) DO UPDATE SET failed_count = 0, locked_until = NULL, last_attempt_at = now()
-	`, email)
-	if err != nil {
-		return fmt.Errorf("erfolgreichen login erfassen: %w", err)
-	}
-	return nil
-}
-
-// Unlock entsperrt ein Konto durch Administratoreingriff, unabhaengig von
-// der Sperrzeit (Akzeptanzkriterium 3).
-func (s *Store) Unlock(ctx context.Context, email string) error {
-	_, err := s.pool.Exec(ctx, `
-		UPDATE login_attempts SET failed_count = 0, locked_until = NULL WHERE email = $1
-	`, email)
-	if err != nil {
-		return fmt.Errorf("konto entsperren: %w", err)
-	}
-	return nil
-}
@@ -1,233 +0,0 @@
-package lockout
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
-	"gitea.perlbach24.de/scripte/nexarch/internal/user"
-)
-
-const schema = `
-CREATE TABLE IF NOT EXISTS users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-CREATE TABLE IF NOT EXISTS login_attempts (
-	email TEXT PRIMARY KEY, failed_count INT NOT NULL DEFAULT 0,
-	locked_until TIMESTAMPTZ, last_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, schema); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-	cleanup := func() { pool.Close() }
-	return pool, cleanup
-}
-
-func uniqueEmail() string {
-	return fmt.Sprintf("lockout-test-%d@example.com", time.Now().UnixNano())
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Sperre greift nach definierten
-// Fehlversuchen zuverlaessig.
-func TestRecordFailure_LocksAfterThreshold(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	store := NewStore(pool).WithPolicy(3, time.Hour)
-	email := uniqueEmail()
-
-	for i := 0; i < 2; i++ {
-		locked, _, err := store.RecordFailure(ctx, email)
-		if err != nil {
-			t.Fatalf("record failure %d: %v", i, err)
-		}
-		if locked {
-			t.Fatalf("sollte nach %d fehlversuchen noch nicht gesperrt sein", i+1)
-		}
-	}
-
-	locked, lockedUntil, err := store.RecordFailure(ctx, email)
-	if err != nil {
-		t.Fatalf("record failure 3: %v", err)
-	}
-	if !locked {
-		t.Fatal("erwartet gesperrt nach 3 fehlversuchen (schwelle=3)")
-	}
-	if !lockedUntil.After(time.Now()) {
-		t.Fatal("lockedUntil sollte in der zukunft liegen")
-	}
-
-	isLocked, _, err := store.IsLocked(ctx, email)
-	if err != nil {
-		t.Fatalf("is locked: %v", err)
-	}
-	if !isLocked {
-		t.Fatal("IsLocked sollte true liefern")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: zwei Dienstinstanzen teilen sich
-// denselben Zaehler (Mehrinstanz-Test) — hier durch zwei unabhaengige
-// pgxpool.Pool-Verbindungen zur selben Datenbank simuliert.
-func TestRecordFailure_SharedAcrossInstances(t *testing.T) {
-	_, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	email := uniqueEmail()
-
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	instanceA, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("instance a: %v", err)
-	}
-	defer instanceA.Close()
-	instanceB, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("instance b: %v", err)
-	}
-	defer instanceB.Close()
-
-	storeA := NewStore(instanceA).WithPolicy(4, time.Hour)
-	storeB := NewStore(instanceB).WithPolicy(4, time.Hour)
-
-	// Zwei fehlversuche ueber "instanz A", zwei ueber "instanz B" — beide
-	// muessen sich denselben Zaehler teilen und gemeinsam die Schwelle erreichen.
-	if _, _, err := storeA.RecordFailure(ctx, email); err != nil {
-		t.Fatalf("a1: %v", err)
-	}
-	if _, _, err := storeB.RecordFailure(ctx, email); err != nil {
-		t.Fatalf("b1: %v", err)
-	}
-	if _, _, err := storeA.RecordFailure(ctx, email); err != nil {
-		t.Fatalf("a2: %v", err)
-	}
-	locked, _, err := storeB.RecordFailure(ctx, email)
-	if err != nil {
-		t.Fatalf("b2: %v", err)
-	}
-	if !locked {
-		t.Fatal("erwartet gesperrt nach insgesamt 4 fehlversuchen ueber beide instanzen hinweg")
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: automatische Entsperrung nach Ablauf
-// der Sperrzeit, Zeitversatz automatisiert getestet.
-func TestIsLocked_AutoUnlocksAfterExpiry(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	store := NewStore(pool).WithPolicy(1, 50*time.Millisecond)
-	email := uniqueEmail()
-
-	locked, _, err := store.RecordFailure(ctx, email)
-	if err != nil {
-		t.Fatalf("record failure: %v", err)
-	}
-	if !locked {
-		t.Fatal("erwartet sofort gesperrt bei schwelle=1")
-	}
-
-	isLocked, _, err := store.IsLocked(ctx, email)
-	if err != nil {
-		t.Fatalf("is locked (vor ablauf): %v", err)
-	}
-	if !isLocked {
-		t.Fatal("erwartet gesperrt vor ablauf der sperrzeit")
-	}
-
-	time.Sleep(70 * time.Millisecond)
-
-	isLocked, _, err = store.IsLocked(ctx, email)
-	if err != nil {
-		t.Fatalf("is locked (nach ablauf): %v", err)
-	}
-	if isLocked {
-		t.Fatal("erwartet automatisch entsperrt nach ablauf der sperrzeit")
-	}
-}
-
-// Akzeptanzkriterium 3: Entsperrung durch Administratoreingriff.
-func TestUnlock_ClearsLockImmediately(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	store := NewStore(pool).WithPolicy(1, time.Hour)
-	email := uniqueEmail()
-
-	if _, _, err := store.RecordFailure(ctx, email); err != nil {
-		t.Fatalf("record failure: %v", err)
-	}
-	locked, _, _ := store.IsLocked(ctx, email)
-	if !locked {
-		t.Fatal("erwartet gesperrt vor admin-eingriff")
-	}
-
-	if err := store.Unlock(ctx, email); err != nil {
-		t.Fatalf("unlock: %v", err)
-	}
-	locked, _, err := store.IsLocked(ctx, email)
-	if err != nil {
-		t.Fatalf("is locked nach unlock: %v", err)
-	}
-	if locked {
-		t.Fatal("erwartet sofort entsperrt nach admin-eingriff, unabhaengig von der sperrzeit")
-	}
-}
-
-// Integrationstest: GuardedLogin komponiert IAM-02 LoginService mit dem
-// Lockout-Zustand, ohne LoginService selbst zu veraendern.
-func TestGuardedLogin_LocksAfterRepeatedFailures(t *testing.T) {
-	pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	email := uniqueEmail()
-	userStore := user.NewTenantUserStore(pool)
-	u, err := userStore.Create(ctx, email, "Lockout Test")
-	if err != nil {
-		t.Fatalf("create user: %v", err)
-	}
-	hash, err := auth.HashPassword("korrektes-passwort")
-	if err != nil {
-		t.Fatalf("hash: %v", err)
-	}
-	if err := userStore.SetPasswordHash(ctx, u.ID, hash); err != nil {
-		t.Fatalf("set password: %v", err)
-	}
-
-	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
-	loginService := auth.NewLoginService(userStore, issuer, "acme")
-	lockoutStore := NewStore(pool).WithPolicy(3, time.Hour)
-
-	for i := 0; i < 3; i++ {
-		if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "falsches-passwort"); !errors.Is(err, auth.ErrInvalidCredentials) {
-			t.Fatalf("versuch %d: erwartet ErrInvalidCredentials, habe %v", i, err)
-		}
-	}
-
-	// Selbst das RICHTIGE Passwort wird jetzt abgewiesen, weil das Konto gesperrt ist.
-	if _, err := GuardedLogin(ctx, lockoutStore, loginService, email, "korrektes-passwort"); !errors.Is(err, ErrAccountLocked) {
-		t.Fatalf("erwartet ErrAccountLocked trotz korrektem passwort, habe %v", err)
-	}
-}
@@ -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
+}
@@ -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)
+	}
+}
@@ -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
+}
@@ -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)
+	}
+}
@@ -0,0 +1,97 @@
+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)
+}
+
+// Invalidate erzwingt beim naechsten Get-Aufruf einen sofortigen Refresh
+// statt auf den TTL-Ablauf zu warten (API-06, Akzeptanzkriterium 1: ein
+// Health-Check-getriggerter Wiederanlauf soll den Cache SOFORT aktualisieren,
+// nicht die reguläre TTL abwarten) — rein additiv, aendert nichts an
+// Get/RequireFresh (dasselbe Muster wie internal/flag.Service.Invalidate).
+func (c *StaleCache[T]) Invalidate() {
+	c.mu.Lock()
+	c.hasValue = false
+	c.mu.Unlock()
+}
+
+// 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
+}
@@ -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
+}
@@ -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
+}
@@ -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)  {}
@@ -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
+}
@@ -0,0 +1,155 @@
+// Package resync implementiert Core API-06: Wiederanlauf & Nachsynchro-
+// nisierung nach einem Core-Ausfall.
+//
+//   - Ein Modul puffert Audit-Events und Nutzungszaehler-Deltas LOKAL in
+//     Postgres (NICHT im Speicher — siehe "Bekannte Fehler vermeiden" im
+//     Ticket: ein erneuter Ausfall waehrend der Nachlieferung darf keine
+//     Daten verlieren, eine In-Memory-Queue wuerde das riskieren).
+//   - Ein Health-Check-getriggerter Worker erkennt die Core-Wiedererreich-
+//     barkeit SOFORT (nicht erst nach TTL-Ablauf, siehe StaleCache.Invalidate)
+//     und liefert die gepufferten Daten in ORIGINALER Reihenfolge, authenti-
+//     fiziert ueber das Service-Credential aus API-02
+//     (internal/moduleregistry.Registry.Authenticate).
+//
+// Dieses Paket dupliziert weder internal/audit (AUD-01) noch internal/usage
+// (LIC-03) — es liefert nur den Puffer- und Nachlieferungs-Mechanismus
+// DAVOR bzw. DANACH.
+package resync
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// BufferedAuditEvent ist ein lokal gepuffertes Audit-Ereignis. Seq
+// garantiert die Wiederherstellung der urspruenglichen Reihenfolge
+// (Akzeptanzkriterium 2) unabhaengig von eventuellen Uhrzeit-Ungenauigkeiten.
+type BufferedAuditEvent struct {
+	ID         int64
+	Seq        int64
+	TenantSlug string
+	Actor      string
+	Action     string
+	Target     string
+	Metadata   map[string]any
+	CreatedAt  time.Time
+}
+
+// BufferedUsageDelta ist ein lokal gepuffertes Nutzungszaehler-Inkrement.
+type BufferedUsageDelta struct {
+	ID         int64
+	Seq        int64
+	TenantSlug string
+	Metric     string
+	Delta      int64
+	CreatedAt  time.Time
+}
+
+// Buffer ist die lokale, persistente Pufferqueue eines Moduls.
+type Buffer struct {
+	pool *pgxpool.Pool
+}
+
+func NewBuffer(pool *pgxpool.Pool) *Buffer {
+	return &Buffer{pool: pool}
+}
+
+// EnqueueAuditEvent puffert EIN Audit-Ereignis lokal — wird von einem
+// Fachmodul aufgerufen, wenn Core gerade nicht erreichbar ist (die
+// Erkennung "Core erreichbar oder nicht" ist NICHT Teil dieses Aufrufs,
+// siehe Worker).
+func (b *Buffer) EnqueueAuditEvent(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any) error {
+	if metadata == nil {
+		metadata = map[string]any{}
+	}
+	metadataJSON, err := json.Marshal(metadata)
+	if err != nil {
+		return fmt.Errorf("metadata serialisieren: %w", err)
+	}
+	_, err = b.pool.Exec(ctx, `
+		INSERT INTO resync_audit_buffer (tenant_slug, actor, action, target, metadata)
+		VALUES ($1, $2, $3, $4, $5)
+	`, tenantSlug, actor, action, target, metadataJSON)
+	if err != nil {
+		return fmt.Errorf("audit-ereignis puffern: %w", err)
+	}
+	return nil
+}
+
+// EnqueueUsageDelta puffert EIN Nutzungszaehler-Inkrement lokal.
+func (b *Buffer) EnqueueUsageDelta(ctx context.Context, tenantSlug, metric string, delta int64) error {
+	_, err := b.pool.Exec(ctx, `
+		INSERT INTO resync_usage_buffer (tenant_slug, metric, delta)
+		VALUES ($1, $2, $3)
+	`, tenantSlug, metric, delta)
+	if err != nil {
+		return fmt.Errorf("nutzungsdelta puffern: %w", err)
+	}
+	return nil
+}
+
+// PendingAuditEvents liefert ALLE noch nicht zugestellten Audit-Events in
+// ORIGINALER Reihenfolge (Akzeptanzkriterium 2 / Pruefung 1).
+func (b *Buffer) PendingAuditEvents(ctx context.Context) ([]BufferedAuditEvent, error) {
+	rows, err := b.pool.Query(ctx, `
+		SELECT id, seq, tenant_slug, actor, action, target, metadata, created_at
+		FROM resync_audit_buffer ORDER BY seq
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("gepufferte audit-events abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []BufferedAuditEvent
+	for rows.Next() {
+		var e BufferedAuditEvent
+		var metadataJSON []byte
+		if err := rows.Scan(&e.ID, &e.Seq, &e.TenantSlug, &e.Actor, &e.Action, &e.Target, &metadataJSON, &e.CreatedAt); err != nil {
+			return nil, fmt.Errorf("gepuffertes audit-event lesen: %w", err)
+		}
+		_ = json.Unmarshal(metadataJSON, &e.Metadata)
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}
+
+// PendingUsageDeltas liefert ALLE noch nicht zugestellten Nutzungsdeltas.
+func (b *Buffer) PendingUsageDeltas(ctx context.Context) ([]BufferedUsageDelta, error) {
+	rows, err := b.pool.Query(ctx, `
+		SELECT id, seq, tenant_slug, metric, delta, created_at
+		FROM resync_usage_buffer ORDER BY seq
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("gepufferte nutzungsdeltas abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []BufferedUsageDelta
+	for rows.Next() {
+		var d BufferedUsageDelta
+		if err := rows.Scan(&d.ID, &d.Seq, &d.TenantSlug, &d.Metric, &d.Delta, &d.CreatedAt); err != nil {
+			return nil, fmt.Errorf("gepuffertes nutzungsdelta lesen: %w", err)
+		}
+		out = append(out, d)
+	}
+	return out, rows.Err()
+}
+
+// RemoveAuditEvent entfernt EIN Audit-Event aus dem Puffer — wird NUR nach
+// von Core BESTAETIGTER Zustellung aufgerufen (Akzeptanzkriterium 2/3: erst
+// entfernen, wenn sicher zugestellt, sonst bleibt es fuer den naechsten
+// Versuch erhalten — kein Datenverlust bei erneutem Ausfall waehrend der
+// Nachlieferung).
+func (b *Buffer) RemoveAuditEvent(ctx context.Context, id int64) error {
+	_, err := b.pool.Exec(ctx, `DELETE FROM resync_audit_buffer WHERE id = $1`, id)
+	return err
+}
+
+func (b *Buffer) RemoveUsageDelta(ctx context.Context, id int64) error {
+	_, err := b.pool.Exec(ctx, `DELETE FROM resync_usage_buffer WHERE id = $1`, id)
+	return err
+}
@@ -0,0 +1,132 @@
+package resync
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+)
+
+// AuditRecorder ist die schmale Schnittstelle, ueber die Core empfangene
+// Audit-Events tatsaechlich persistiert. In Produktion durch internal/audit
+// (AUD-01, nicht Abhaengigkeit dieser Kachel) implementiert — dieses Paket
+// dupliziert dessen Validierungs-/Speicherlogik NICHT, sondern ruft sie nur
+// auf. Die Events werden vom Aufrufer sequenziell in PendingAuditEvents-
+// Reihenfolge uebergeben (Akzeptanzkriterium 2).
+type AuditRecorder interface {
+	Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error
+}
+
+// UsageIncrementer ist die schmale Schnittstelle zu Core's Nutzungszaehler
+// (in Produktion internal/usage, LIC-03 — nicht Abhaengigkeit dieser
+// Kachel). Jedes gepufferte Delta wird GENAU EINMAL angewendet.
+type UsageIncrementer interface {
+	Increment(ctx context.Context, tenantSlug, metric string, delta int64) error
+}
+
+// CredentialAuthenticator ist die schmale Schnittstelle zu API-02s
+// Service-Credential-Pruefung (internal/moduleregistry.Registry.Authenticate).
+type CredentialAuthenticator interface {
+	Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error)
+}
+
+// Handler nimmt nachgelieferte Audit-Events/Nutzungsdeltas auf der
+// Core-Seite entgegen — authentifiziert ueber dasselbe Service-Credential
+// wie jeder andere Modul-Core-Aufruf (Akzeptanzkriterium 2/3, "authentifiziert
+// ueber das in API-02 definierte Service-Credential").
+type Handler struct {
+	auth  CredentialAuthenticator
+	audit AuditRecorder
+	usage UsageIncrementer
+}
+
+func NewHandler(auth CredentialAuthenticator, audit AuditRecorder, usage UsageIncrementer) *Handler {
+	return &Handler{auth: auth, audit: audit, usage: usage}
+}
+
+type credentialHeader struct {
+	ClientID string `json:"client_id"`
+	Secret   string `json:"secret"`
+}
+
+func (h *Handler) authenticate(w http.ResponseWriter, r *http.Request) bool {
+	clientID := r.Header.Get("X-Nexarch-Client-Id")
+	secret := r.Header.Get("X-Nexarch-Client-Secret")
+	_, ok, err := h.auth.Authenticate(r.Context(), clientID, secret)
+	if err != nil || !ok {
+		http.Error(w, "ungueltiges service-credential", http.StatusUnauthorized)
+		return false
+	}
+	return true
+}
+
+type auditEventDTO struct {
+	TenantSlug string         `json:"tenant_slug"`
+	Actor      string         `json:"actor"`
+	Action     string         `json:"action"`
+	Target     string         `json:"target"`
+	Metadata   map[string]any `json:"metadata"`
+	OccurredAt time.Time      `json:"occurred_at"`
+}
+
+// AuditHandler nimmt EINE Liste gepufferter Audit-Events entgegen und
+// schreibt sie SEQUENZIELL in der gegebenen Reihenfolge fort
+// (Akzeptanzkriterium 2 / Pruefung 1: Vollstaendigkeit + Reihenfolge).
+// Bricht die Verarbeitung bei einem Fehler ab und meldet, wie viele Events
+// bereits sicher geschrieben wurden — der Aufrufer (Worker) entfernt aus
+// seinem lokalen Puffer NUR die bestaetigt geschriebenen Events.
+func (h *Handler) AuditHandler(w http.ResponseWriter, r *http.Request) {
+	if !h.authenticate(w, r) {
+		return
+	}
+	var events []auditEventDTO
+	if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
+		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
+		return
+	}
+
+	written := 0
+	for _, e := range events {
+		if err := h.audit.Record(r.Context(), e.TenantSlug, e.Actor, e.Action, e.Target, e.Metadata, e.OccurredAt); err != nil {
+			break
+		}
+		written++
+	}
+
+	writeJSON(w, map[string]int{"written": written})
+}
+
+type usageDeltaDTO struct {
+	TenantSlug string `json:"tenant_slug"`
+	Metric     string `json:"metric"`
+	Delta      int64  `json:"delta"`
+}
+
+// UsageHandler wendet JEDES gepufferte Delta GENAU EINMAL an
+// (Akzeptanzkriterium 3 / Pruefung 2: keine Doppelzaehlung) — der Aufrufer
+// entfernt aus seinem lokalen Puffer nur die bestaetigt uebernommenen Deltas.
+func (h *Handler) UsageHandler(w http.ResponseWriter, r *http.Request) {
+	if !h.authenticate(w, r) {
+		return
+	}
+	var deltas []usageDeltaDTO
+	if err := json.NewDecoder(r.Body).Decode(&deltas); err != nil {
+		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
+		return
+	}
+
+	applied := 0
+	for _, d := range deltas {
+		if err := h.usage.Increment(r.Context(), d.TenantSlug, d.Metric, d.Delta); err != nil {
+			break
+		}
+		applied++
+	}
+
+	writeJSON(w, map[string]int{"applied": applied})
+}
+
+func writeJSON(w http.ResponseWriter, body any) {
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(body)
+}
@@ -0,0 +1,320 @@
+package resync
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
+)
+
+// fakeAudit steht fuer internal/audit.Log (AUD-01, nicht Abhaengigkeit
+// dieser Kachel) — zeichnet Aufrufe in Empfangsreihenfolge auf, damit
+// Vollstaendigkeit UND Reihenfolge geprueft werden koennen.
+type fakeAudit struct {
+	mu     sync.Mutex
+	events []auditEventDTO
+	failAt int // -1 = nie fehlschlagen; sonst: ab diesem Index (0-basiert) schlaegt Record fehl
+}
+
+func (f *fakeAudit) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if f.failAt >= 0 && len(f.events) == f.failAt {
+		return fmt.Errorf("simulierter core-ausfall waehrend der nachlieferung")
+	}
+	f.events = append(f.events, auditEventDTO{TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target, Metadata: metadata, OccurredAt: occurredAt})
+	return nil
+}
+
+// fakeUsage steht fuer internal/usage.Store (LIC-03, nicht Abhaengigkeit
+// dieser Kachel) — summiert Deltas wie der echte Store.
+type fakeUsage struct {
+	mu     sync.Mutex
+	totals map[string]int64
+}
+
+func newFakeUsage() *fakeUsage { return &fakeUsage{totals: map[string]int64{}} }
+
+func (f *fakeUsage) Increment(ctx context.Context, tenantSlug, metric string, delta int64) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.totals[tenantSlug+"|"+metric] += delta
+	return nil
+}
+
+func setupTest(t *testing.T) (*Buffer, *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 resync_audit_buffer (
+			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, actor TEXT NOT NULL,
+			action TEXT NOT NULL, target TEXT NOT NULL DEFAULT '', metadata JSONB NOT NULL DEFAULT '{}',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS resync_usage_buffer (
+			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, metric TEXT NOT NULL,
+			delta BIGINT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS feature_flags (
+			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
+			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS 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)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewBuffer(pool), pool, cleanup
+}
+
+func uniqueModuleName() string {
+	return fmt.Sprintf("resync-test-%d", time.Now().UnixNano())
+}
+
+// setupModuleCredential registriert ein echtes Modul + Service-Credential
+// ueber internal/moduleregistry (API-02) — dieselbe Authentifizierung wird
+// vom Handler tatsaechlich geprueft, kein Mock.
+func setupModuleCredential(t *testing.T, pool *pgxpool.Pool) (registry *moduleregistry.Registry, clientID, secret string) {
+	t.Helper()
+	ctx := context.Background()
+	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
+	registry = moduleregistry.NewRegistry(pool, flagService)
+	name := uniqueModuleName()
+	if _, err := registry.Register(ctx, name, "1.0.0", nil); err != nil {
+		t.Fatalf("modul registrieren: %v", err)
+	}
+	clientID, secret, err := registry.Provision(ctx, name)
+	if err != nil {
+		t.Fatalf("credential provisionieren: %v", err)
+	}
+	return registry, clientID, secret
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1: waehrend eines simulierten Ausfalls
+// lokal gepufferte Audit-Events sind nach Wiederanlauf vollstaendig und in
+// korrekter Reihenfolge in Core's Audit-Log vorhanden.
+func TestFlushAll_DeliversBufferedAuditEventsCompleteAndInOrder(t *testing.T) {
+	buffer, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	registry, clientID, secret := setupModuleCredential(t, pool)
+
+	tenantSlug := "acme"
+	// Ereignisse "waehrend core down" lokal puffern.
+	actions := []string{"login", "upload", "delete", "logout"}
+	for _, action := range actions {
+		if err := buffer.EnqueueAuditEvent(ctx, tenantSlug, "user-1", action, "res-1", nil); err != nil {
+			t.Fatalf("enqueue %s: %v", action, err)
+		}
+	}
+
+	audit := &fakeAudit{failAt: -1}
+	usage := newFakeUsage()
+	handler := NewHandler(registry, audit, usage)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
+	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client := NewCoreClient(server.URL, clientID, secret)
+	worker := NewWorker(buffer, client)
+
+	if err := worker.FlushAll(ctx); err != nil {
+		t.Fatalf("flushall: %v", err)
+	}
+
+	audit.mu.Lock()
+	defer audit.mu.Unlock()
+	if len(audit.events) != len(actions) {
+		t.Fatalf("erwartet %d zugestellte events, habe %d", len(actions), len(audit.events))
+	}
+	for i, e := range audit.events {
+		if e.Action != actions[i] {
+			t.Fatalf("reihenfolge falsch: position %d = %q, want %q", i, e.Action, actions[i])
+		}
+	}
+
+	// Puffer muss nach bestaetigter Zustellung leer sein.
+	remaining, err := buffer.PendingAuditEvents(ctx)
+	if err != nil {
+		t.Fatalf("pending: %v", err)
+	}
+	if len(remaining) != 0 {
+		t.Fatalf("erwartet leeren puffer nach bestaetigter zustellung, habe %d verbleibende", len(remaining))
+	}
+}
+
+// Bekannter-Fehler-Praevention: bricht die Zustellung waehrend der
+// Nachlieferung erneut ab (Core faellt wieder aus), bleiben die NICHT
+// bestaetigten Events sicher im Puffer erhalten statt verloren zu gehen.
+func TestFlushAll_KeepsUnconfirmedEventsInBufferOnPartialFailure(t *testing.T) {
+	buffer, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	registry, clientID, secret := setupModuleCredential(t, pool)
+
+	for i := 0; i < 5; i++ {
+		if err := buffer.EnqueueAuditEvent(ctx, "acme", "user-1", fmt.Sprintf("action-%d", i), "", nil); err != nil {
+			t.Fatalf("enqueue %d: %v", i, err)
+		}
+	}
+
+	// Core-Fake schlaegt AB dem 3. Event fehl -> simuliert erneuten Ausfall
+	// mitten in der Nachlieferung.
+	audit := &fakeAudit{failAt: 3}
+	handler := NewHandler(registry, audit, newFakeUsage())
+	mux := http.NewServeMux()
+	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
+	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client := NewCoreClient(server.URL, clientID, secret)
+	worker := NewWorker(buffer, client)
+
+	if err := worker.FlushAll(ctx); err == nil {
+		t.Fatal("erwartet fehler, da core nur teilweise bestaetigt hat")
+	}
+
+	remaining, err := buffer.PendingAuditEvents(ctx)
+	if err != nil {
+		t.Fatalf("pending: %v", err)
+	}
+	if len(remaining) != 2 {
+		t.Fatalf("erwartet 2 verbleibende (nicht bestaetigte) events im puffer, habe %d", len(remaining))
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Nutzungszaehler-Differenz aus der
+// Ausfallzeit wird korrekt nachgebucht, ein wiederholter (fehlerhafter)
+// Flush-Versuch fuehrt NICHT zu Doppelzaehlung, weil bereits bestaetigte
+// Deltas aus dem Puffer entfernt sind.
+func TestFlushAll_AppliesUsageDeltasWithoutDoubleCounting(t *testing.T) {
+	buffer, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+	registry, clientID, secret := setupModuleCredential(t, pool)
+
+	deltas := []int64{3, 5, 2}
+	var want int64
+	for _, d := range deltas {
+		want += d
+		if err := buffer.EnqueueUsageDelta(ctx, "acme", "api_calls", d); err != nil {
+			t.Fatalf("enqueue delta %d: %v", d, err)
+		}
+	}
+
+	usage := newFakeUsage()
+	handler := NewHandler(registry, &fakeAudit{failAt: -1}, usage)
+	mux := http.NewServeMux()
+	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
+	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client := NewCoreClient(server.URL, clientID, secret)
+	worker := NewWorker(buffer, client)
+
+	if err := worker.FlushAll(ctx); err != nil {
+		t.Fatalf("flushall 1: %v", err)
+	}
+
+	usage.mu.Lock()
+	got := usage.totals["acme|api_calls"]
+	usage.mu.Unlock()
+	if got != want {
+		t.Fatalf("nutzungsstand nach nachbuchung = %d, want %d", got, want)
+	}
+
+	// Ein zweiter Flush-Versuch (z.B. redundanter Retry) darf NICHTS mehr
+	// nachbuchen, da der Puffer bereits geleert wurde.
+	if err := worker.FlushAll(ctx); err != nil {
+		t.Fatalf("flushall 2: %v", err)
+	}
+	usage.mu.Lock()
+	got2 := usage.totals["acme|api_calls"]
+	usage.mu.Unlock()
+	if got2 != want {
+		t.Fatalf("nutzungsstand nach redundantem zweiten flush = %d, want unveraendert %d (keine doppelzaehlung)", got2, want)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 3: bei erkannter Core-Wiedererreichbarkeit
+// wird der Cache SOFORT invalidiert (naechster Zugriff refetcht), nicht
+// erst nach TTL-Ablauf — Latenz wird gemessen und liegt weit unter einer
+// langen TTL.
+func TestCheckAndSync_InvalidatesCacheImmediatelyOnRecovery(t *testing.T) {
+	buffer, pool, cleanup := setupTest(t)
+	defer cleanup()
+	registry, clientID, secret := setupModuleCredential(t, pool)
+	_ = registry
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+	server := httptest.NewServer(mux)
+	defer server.Close()
+
+	client := NewCoreClient(server.URL, clientID, secret)
+	worker := NewWorker(buffer, client)
+
+	invalidated := false
+	var mu sync.Mutex
+	worker.OnReachable(func() {
+		mu.Lock()
+		invalidated = true
+		mu.Unlock()
+	})
+
+	start := time.Now()
+	becameReachable, err := worker.CheckAndSync(context.Background())
+	elapsed := time.Since(start)
+	if err != nil {
+		t.Fatalf("checkandsync: %v", err)
+	}
+	if !becameReachable {
+		t.Fatal("erwartet erkannten uebergang zu 'erreichbar' beim ersten erfolgreichen check")
+	}
+
+	mu.Lock()
+	defer mu.Unlock()
+	if !invalidated {
+		t.Fatal("erwartet sofortigen cache-invalidierungs-callback bei core-wiedererreichbarkeit")
+	}
+	// Zielwert: deutlich unter einer typischen TTL (z.B. 5s beim
+	// Feature-Flag-Cache, LIC-02) — hier im Millisekundenbereich, da rein
+	// lokal ohne Netzwerk-Overhead.
+	if elapsed > time.Second {
+		t.Fatalf("cache-invalidierung brauchte %s, erwartet deutlich unter 1s", elapsed)
+	}
+}
@@ -0,0 +1,220 @@
+package resync
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+// CoreClient ist der modul-seitige HTTP-Client fuer die Nachlieferung,
+// authentifiziert ueber dasselbe Service-Credential wie jeder andere
+// Modul-Core-Aufruf (API-02).
+type CoreClient struct {
+	BaseURL  string
+	ClientID string
+	Secret   string
+	HTTP     *http.Client
+}
+
+func NewCoreClient(baseURL, clientID, secret string) *CoreClient {
+	return &CoreClient{BaseURL: baseURL, ClientID: clientID, Secret: secret, HTTP: &http.Client{Timeout: 5 * time.Second}}
+}
+
+func (c *CoreClient) post(ctx context.Context, path string, body any) (*http.Response, error) {
+	payload, err := json.Marshal(body)
+	if err != nil {
+		return nil, fmt.Errorf("payload serialisieren: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+path, bytes.NewReader(payload))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Nexarch-Client-Id", c.ClientID)
+	req.Header.Set("X-Nexarch-Client-Secret", c.Secret)
+	return c.HTTP.Do(req)
+}
+
+// HealthCheck prueft, ob Core erreichbar ist — dieselbe Konvention wie
+// internal/health (OPS-01): HTTP 200 auf einem Health-Endpunkt.
+func (c *CoreClient) HealthCheck(ctx context.Context) bool {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL+"/healthz", nil)
+	if err != nil {
+		return false
+	}
+	resp, err := c.HTTP.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+	return resp.StatusCode == http.StatusOK
+}
+
+// Worker erkennt Core-Wiedererreichbarkeit und stoesst DANN sofort
+// (Akzeptanzkriterium 1) sowohl registrierte Cache-Invalidierungen als auch
+// das Nachliefern des lokalen Puffers an.
+type Worker struct {
+	buffer      *Buffer
+	client      *CoreClient
+	onReachable []func()
+	wasDown     bool
+}
+
+func NewWorker(buffer *Buffer, client *CoreClient) *Worker {
+	return &Worker{buffer: buffer, client: client, wasDown: true} // Start pessimistisch: erster erfolgreicher Check zaehlt als "Wiedererreichbarkeit".
+}
+
+// OnReachable registriert einen Callback, der bei jeder erkannten
+// Core-Wiedererreichbarkeit sofort ausgefuehrt wird — z.B.
+// moduletrust.StaleCache[T].Invalidate, damit der naechste Zugriff sofort
+// neu abruft statt auf TTL-Ablauf zu warten (Akzeptanzkriterium 1).
+func (w *Worker) OnReachable(fn func()) {
+	w.onReachable = append(w.onReachable, fn)
+}
+
+// CheckAndSync fuehrt EINEN Zyklus aus: Erreichbarkeit pruefen, bei
+// erkanntem UEBERGANG "nicht erreichbar -> erreichbar" sofort die
+// registrierten Callbacks ausloesen und den Puffer nachliefern. Gibt
+// zurueck, ob ein Wiederanlauf in diesem Aufruf erkannt wurde (fuer
+// Latenzmessung in Tests, Pruefung 3).
+func (w *Worker) CheckAndSync(ctx context.Context) (becameReachable bool, err error) {
+	reachable := w.client.HealthCheck(ctx)
+	if !reachable {
+		w.wasDown = true
+		return false, nil
+	}
+
+	justRecovered := w.wasDown
+	w.wasDown = false
+	if !justRecovered {
+		return false, nil
+	}
+
+	for _, fn := range w.onReachable {
+		fn()
+	}
+
+	if err := w.FlushAll(ctx); err != nil {
+		return true, err
+	}
+	return true, nil
+}
+
+// FlushAll liefert ZUERST alle gepufferten Audit-Events (in Reihenfolge),
+// DANN alle gepufferten Nutzungsdeltas nach. Jedes Element wird aus dem
+// lokalen Puffer NUR entfernt, wenn Core es bestaetigt hat — bricht die
+// Uebertragung vorzeitig ab (Core faellt waehrend der Nachlieferung erneut
+// aus), bleibt der Rest sicher im Postgres-Puffer erhalten
+// (Akzeptanzkriterium 2/3, "Bekannte Fehler vermeiden").
+func (w *Worker) FlushAll(ctx context.Context) error {
+	if err := w.flushAuditEvents(ctx); err != nil {
+		return err
+	}
+	return w.flushUsageDeltas(ctx)
+}
+
+func (w *Worker) flushAuditEvents(ctx context.Context) error {
+	events, err := w.buffer.PendingAuditEvents(ctx)
+	if err != nil {
+		return err
+	}
+	if len(events) == 0 {
+		return nil
+	}
+
+	dtos := make([]auditEventDTO, len(events))
+	for i, e := range events {
+		dtos[i] = auditEventDTO{
+			TenantSlug: e.TenantSlug, Actor: e.Actor, Action: e.Action, Target: e.Target,
+			Metadata: e.Metadata, OccurredAt: e.CreatedAt,
+		}
+	}
+
+	resp, err := w.client.post(ctx, "/internal/resync/audit", dtos)
+	if err != nil {
+		return fmt.Errorf("audit-nachlieferung: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("audit-nachlieferung: unerwarteter status %d", resp.StatusCode)
+	}
+
+	var ack struct {
+		Written int `json:"written"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
+		return fmt.Errorf("audit-bestaetigung lesen: %w", err)
+	}
+
+	// NUR die von Core bestaetigt geschriebenen Events entfernen — sie sind
+	// nach PendingAuditEvents-Reihenfolge sortiert, die ersten `Written`
+	// Eintraege entsprechen also genau den bestaetigten.
+	for i := 0; i < ack.Written; i++ {
+		if err := w.buffer.RemoveAuditEvent(ctx, events[i].ID); err != nil {
+			return fmt.Errorf("bestaetigtes audit-event aus puffer entfernen: %w", err)
+		}
+	}
+	if ack.Written < len(events) {
+		return fmt.Errorf("core hat nur %d von %d audit-events bestaetigt", ack.Written, len(events))
+	}
+	return nil
+}
+
+func (w *Worker) flushUsageDeltas(ctx context.Context) error {
+	deltas, err := w.buffer.PendingUsageDeltas(ctx)
+	if err != nil {
+		return err
+	}
+	if len(deltas) == 0 {
+		return nil
+	}
+
+	dtos := make([]usageDeltaDTO, len(deltas))
+	for i, d := range deltas {
+		dtos[i] = usageDeltaDTO{TenantSlug: d.TenantSlug, Metric: d.Metric, Delta: d.Delta}
+	}
+
+	resp, err := w.client.post(ctx, "/internal/resync/usage", dtos)
+	if err != nil {
+		return fmt.Errorf("nutzungs-nachlieferung: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("nutzungs-nachlieferung: unerwarteter status %d", resp.StatusCode)
+	}
+
+	var ack struct {
+		Applied int `json:"applied"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
+		return fmt.Errorf("nutzungs-bestaetigung lesen: %w", err)
+	}
+
+	for i := 0; i < ack.Applied; i++ {
+		if err := w.buffer.RemoveUsageDelta(ctx, deltas[i].ID); err != nil {
+			return fmt.Errorf("bestaetigtes nutzungsdelta aus puffer entfernen: %w", err)
+		}
+	}
+	if ack.Applied < len(deltas) {
+		return fmt.Errorf("core hat nur %d von %d nutzungsdeltas bestaetigt", ack.Applied, len(deltas))
+	}
+	return nil
+}
+
+// Run fuehrt CheckAndSync in festen Abstaenden aus — die "kurze, definierte
+// Zeitspanne" aus Akzeptanzkriterium 1 ist dieses Poll-Intervall.
+func (w *Worker) Run(ctx context.Context, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			_, _ = w.CheckAndSync(ctx)
+		}
+	}
+}
@@ -1,66 +0,0 @@
-package user
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-)
-
-// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
-// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
-// dieser Kachel und daher hier noch nicht angebunden.
-type Handler struct {
-	users       *TenantUserStore
-	superadmins *SuperadminStore
-}
-
-func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
-	return &Handler{users: users, superadmins: superadmins}
-}
-
-type createUserRequest struct {
-	Email string `json:"email"`
-	Name  string `json:"name"`
-}
-
-func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.users.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
-// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
-func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
-	var req createUserRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
-	writeUserResult(w, u, err)
-}
-
-func writeUserResult(w http.ResponseWriter, u User, err error) {
-	if err != nil {
-		switch {
-		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
-			http.Error(w, err.Error(), http.StatusBadRequest)
-		case errors.Is(err, ErrNotFound):
-			http.Error(w, err.Error(), http.StatusNotFound)
-		default:
-			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
-		}
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-	_ = json.NewEncoder(w).Encode(u)
-}
@@ -1,173 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
-// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
-// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
-// fuer dasselbe Muster.
-func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
-	t.Helper()
-
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-
-	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		t.Fatalf("testdatenbank anlegen: %v", err)
-	}
-
-	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("connect testdatenbank: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
-		t.Fatalf("schema anwenden: %v", err)
-	}
-
-	t.Cleanup(func() {
-		pool.Close()
-		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-		adminPool.Close()
-	})
-
-	return pool
-}
-
-const usersSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE users (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-const superadminsSchema = `
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE TABLE superadmins (
-	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-	email TEXT NOT NULL UNIQUE,
-	name TEXT NOT NULL,
-	status TEXT NOT NULL DEFAULT 'active',
-	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);`
-
-// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
-func TestTenantUserStore_CRUD(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_users", usersSchema)
-	store := NewTenantUserStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "alice@example.com", "Alice")
-	if err != nil {
-		t.Fatalf("create: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "alice@example.com" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
-	if err != nil {
-		t.Fatalf("update: %v", err)
-	}
-	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
-		t.Fatalf("update ergebnis unerwartet: %+v", updated)
-	}
-
-	list, err := store.List(ctx)
-	if err != nil {
-		t.Fatalf("list: %v", err)
-	}
-	if len(list) != 1 {
-		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-
-	// Negativfall: doppelte E-Mail-Adresse.
-	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
-		t.Fatalf("create second: %v", err)
-	}
-	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
-	}
-
-	// Negativfall: fehlender Benutzer.
-	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
-		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
-// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
-// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
-func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
-	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
-	store := NewSuperadminStore(pool)
-	ctx := context.Background()
-
-	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
-	if err != nil {
-		t.Fatalf("create superadmin: %v", err)
-	}
-	if created.Status != StatusActive {
-		t.Fatalf("erwartet status active, hat %q", created.Status)
-	}
-
-	got, err := store.Get(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Email != "root@nexarch.internal" {
-		t.Fatalf("get email = %q", got.Email)
-	}
-
-	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
-		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
-	}
-
-	deactivated, err := store.Deactivate(ctx, created.ID)
-	if err != nil {
-		t.Fatalf("deactivate: %v", err)
-	}
-	if deactivated.Status != StatusInactive {
-		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
-	}
-}
@@ -1,77 +0,0 @@
-package user
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
-// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
-// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
-// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
-// koennte (IAM-01, "ohne Sonderbehandlung im Code").
-type SuperadminStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
-	return &SuperadminStore{pool: pool}
-}
-
-func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO superadmins (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins WHERE id = $1
-	`, id))
-}
-
-func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM superadmins ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("superadmins auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("superadmin lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE superadmins SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}
@@ -1,173 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgconn"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
-// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
-// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
-type TenantUserStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
-	return &TenantUserStore{pool: pool}
-}
-
-func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
-	if err := ValidateEmail(email); err != nil {
-		return User{}, err
-	}
-
-	var u User
-	u.Email, u.Name, u.Status = email, name, StatusActive
-
-	row := s.pool.QueryRow(ctx, `
-		INSERT INTO users (email, name, status)
-		VALUES ($1, $2, $3)
-		RETURNING id, created_at, updated_at
-	`, u.Email, u.Name, u.Status)
-
-	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users WHERE id = $1
-	`, id))
-}
-
-func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, email, name, status, created_at, updated_at
-		FROM users ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("benutzer auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []User
-	for rows.Next() {
-		var u User
-		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-			return nil, fmt.Errorf("benutzer lesen: %w", err)
-		}
-		out = append(out, u)
-	}
-	return out, rows.Err()
-}
-
-// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
-// Feld unveraendert.
-func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
-	if email != "" {
-		if err := ValidateEmail(email); err != nil {
-			return User{}, err
-		}
-	}
-
-	row := s.pool.QueryRow(ctx, `
-		UPDATE users
-		SET email = COALESCE(NULLIF($2, ''), email),
-		    name = COALESCE(NULLIF($3, ''), name),
-		    updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, email, name)
-
-	u, err := scanUser(row)
-	if err != nil {
-		return User{}, mapWriteErr(err)
-	}
-	return u, nil
-}
-
-// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
-func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
-	return scanUser(s.pool.QueryRow(ctx, `
-		UPDATE users SET status = $2, updated_at = now()
-		WHERE id = $1
-		RETURNING id, email, name, status, created_at, updated_at
-	`, id, StatusInactive))
-}
-
-// SetPasswordHash schreibt einen bereits berechneten bcrypt-Hash (siehe
-// internal/auth, IAM-02). Der Store selbst kennt kein Klartext-Passwort.
-func (s *TenantUserStore) SetPasswordHash(ctx context.Context, id, hash string) error {
-	tag, err := s.pool.Exec(ctx, `
-		UPDATE users SET password_hash = $2, updated_at = now() WHERE id = $1
-	`, id, hash)
-	if err != nil {
-		return fmt.Errorf("passwort setzen: %w", err)
-	}
-	if tag.RowsAffected() == 0 {
-		return ErrNotFound
-	}
-	return nil
-}
-
-// AuthCredentials wird ausschliesslich fuer den Login-Pfad (internal/auth)
-// verwendet und traegt bewusst den password_hash, damit er nicht ueber den
-// regulaeren User-Typ/JSON-Serialisierungspfad nach aussen dringen kann.
-type AuthCredentials struct {
-	User         User
-	PasswordHash string
-}
-
-// GetByEmailForAuth liefert Benutzer + Passwort-Hash zu einer E-Mail-Adresse
-// aus GENAU DIESER Tenant-Datenbank — der Tenant-Scope ergibt sich damit
-// zwingend aus dem verwendeten Pool, es gibt keine Moeglichkeit, versehentlich
-// ueber Tenant-Grenzen hinweg zu suchen (bekannter archivmail-Fehler, siehe
-// IAM-02 "Bekannte Fehler vermeiden").
-func (s *TenantUserStore) GetByEmailForAuth(ctx context.Context, email string) (AuthCredentials, error) {
-	var c AuthCredentials
-	row := s.pool.QueryRow(ctx, `
-		SELECT id, email, name, status, created_at, updated_at, password_hash
-		FROM users WHERE email = $1
-	`, email)
-
-	if err := row.Scan(&c.User.ID, &c.User.Email, &c.User.Name, &c.User.Status,
-		&c.User.CreatedAt, &c.User.UpdatedAt, &c.PasswordHash); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return AuthCredentials{}, ErrNotFound
-		}
-		return AuthCredentials{}, fmt.Errorf("anmeldedaten lesen: %w", err)
-	}
-	return c, nil
-}
-
-func scanUser(row pgx.Row) (User, error) {
-	var u User
-	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return User{}, ErrNotFound
-		}
-		return User{}, fmt.Errorf("benutzer lesen: %w", err)
-	}
-	return u, nil
-}
-
-// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
-// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
-func mapWriteErr(err error) error {
-	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
-		return ErrEmailTaken
-	}
-	if errors.Is(err, pgx.ErrNoRows) {
-		return ErrNotFound
-	}
-	return fmt.Errorf("benutzer schreiben: %w", err)
-}
@@ -1,42 +0,0 @@
-// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
-// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
-// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
-// dagegen mandantenuebergreifend in der Registry und sind ueber
-// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
-// tenant_id-NULL-Sonderfall in User.
-package user
-
-import (
-	"errors"
-	"regexp"
-	"time"
-)
-
-type Status string
-
-const (
-	StatusActive   Status = "active"
-	StatusInactive Status = "inactive"
-)
-
-type User struct {
-	ID        string
-	Email     string
-	Name      string
-	Status    Status
-	CreatedAt time.Time
-	UpdatedAt time.Time
-}
-
-var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
-
-var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
-var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
-var ErrNotFound = errors.New("user: nicht gefunden")
-
-func ValidateEmail(email string) error {
-	if !emailPattern.MatchString(email) {
-		return ErrInvalidEmail
-	}
-	return nil
-}
@@ -1,24 +0,0 @@
-package user
-
-import "testing"
-
-func TestValidateEmail(t *testing.T) {
-	cases := []struct {
-		email   string
-		wantErr bool
-	}{
-		{"a@b.de", false},
-		{"a.b+c@sub.example.com", false},
-		{"", true},
-		{"keine-email", true},
-		{"a@b", true},
-		{"@b.de", true},
-	}
-
-	for _, c := range cases {
-		err := ValidateEmail(c.email)
-		if (err != nil) != c.wantErr {
-			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
-		}
-	}
-}
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS superadmins;
@@ -1,14 +0,0 @@
-- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
-- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
-- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
-- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
-- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
-- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
-CREATE TABLE superadmins (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    email        TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS feature_flags;
@@ -0,0 +1,10 @@
+-- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
+-- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
+-- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
+CREATE TABLE feature_flags (
+    key                 TEXT PRIMARY KEY,
+    enabled             BOOLEAN NOT NULL DEFAULT false,
+    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
+    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
+    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS module_credentials;
+DROP TABLE IF EXISTS modules;
@@ -0,0 +1,18 @@
+-- Modul-Registry & Aktivierungspruefung (API-02, siehe core-kanban/tickets/API-02.md).
+CREATE TABLE modules (
+    name           TEXT PRIMARY KEY,
+    version        TEXT NOT NULL CHECK (version <> ''),
+    required_flags TEXT[] NOT NULL DEFAULT '{}',
+    registered_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Service-Credential je Modul-Instanz, bei Provisionierung ausgestellt
+-- (Akzeptanzkriterium 4). secret_hash enthaelt NIEMALS das Secret im
+-- Klartext, nur dessen SHA-256-Hash (Timing-safe-Vergleich beim Login,
+-- Referenzmuster siehe AUD-02).
+CREATE TABLE module_credentials (
+    module_name TEXT PRIMARY KEY REFERENCES modules(name),
+    client_id   TEXT NOT NULL UNIQUE,
+    secret_hash BYTEA NOT NULL,
+    issued_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1,2 @@
+DROP TABLE resync_usage_buffer;
+DROP TABLE resync_audit_buffer;
@@ -0,0 +1,22 @@
+-- Wiederanlauf & Nachsynchronisierung nach Core-Ausfall (API-06, siehe
+-- core-kanban/tickets/API-06.md) — lokale, PERSISTENTE Pufferqueue (kein
+-- In-Memory) fuer Audit-Events und Nutzungszaehler-Deltas eines Moduls.
+CREATE TABLE resync_audit_buffer (
+    id          BIGSERIAL PRIMARY KEY,
+    seq         BIGSERIAL,
+    tenant_slug TEXT NOT NULL,
+    actor       TEXT NOT NULL,
+    action      TEXT NOT NULL,
+    target      TEXT NOT NULL DEFAULT '',
+    metadata    JSONB NOT NULL DEFAULT '{}',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TABLE resync_usage_buffer (
+    id          BIGSERIAL PRIMARY KEY,
+    seq         BIGSERIAL,
+    tenant_slug TEXT NOT NULL,
+    metric      TEXT NOT NULL,
+    delta       BIGINT NOT NULL,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS users;
@@ -1,16 +0,0 @@
-- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
-- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
-- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
-- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
-- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
-- nur innerhalb dieser einen Tenant-Datenbank.
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-
-CREATE TABLE users (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    email        TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1 +0,0 @@
-ALTER TABLE users DROP COLUMN password_hash;
@@ -1,3 +0,0 @@
-- Passwort-Hash-Spalte fuer Login (IAM-02, siehe core-kanban/tickets/IAM-02.md).
-- Enthaelt AUSSCHLIESSLICH den bcrypt-Hash, niemals das Klartext-Passwort.
-ALTER TABLE users ADD COLUMN password_hash TEXT NOT NULL DEFAULT '';
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS login_attempts;
@@ -1,10 +0,0 @@
-- Account-Lockout & Login-Rate-Limiting (IAM-07, siehe
-- core-kanban/tickets/IAM-07.md). Geteilter, externer Zustand in Postgres —
-- kein In-Process-Zaehler (bekannter Fehler aus archivdms
-- internal/auth/ratelimit.go), gilt korrekt ueber mehrere Core-Instanzen.
-CREATE TABLE login_attempts (
-    email           TEXT PRIMARY KEY,
-    failed_count    INT NOT NULL DEFAULT 0,
-    locked_until    TIMESTAMPTZ,
-    last_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1,11 +1,23 @@
 #!/usr/bin/env bash
+# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
+# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
+# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
+# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
+# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
+
 export PGPASSWORD="$PASS"
+
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
+
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -1,12 +1,24 @@
 #!/usr/bin/env bash
+# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
+# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
+# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
+# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
+
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
+
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
+
 echo "== go build =="
 go build ./...
+
 echo "== go vet =="
 go vet ./...
+
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1
Author	SHA1	Message	Date
sysops	ec9bb27bb3	API-06: go.sum/go.mod aktualisieren (golang-jwt/jwt/v5 fuer moduletrust)	2026-08-28 09:22:56 +02:00
sysops	0fd9856b10	API-06: wiederanlauf-nachsynchronisierung-nach-core-ausfall (postgres-puffer, service-credential, sofort-invalidate)	2026-08-28 09:22:08 +02:00
sysopsandClaude Sonnet 5	b23cd1961f	API-02: modul-registry-aktivierungspruefung internal/moduleregistry: Registry.Register traegt Fachmodule mit Name, Version und benoetigten Feature-Flags ein (Akzeptanzkriterium 1), fehlende Pflichtangaben werden abgewiesen. IsActive kombiniert Registrierung + LIC-02 Feature-Flag-Auswertung (ALLE benoetigten Flags muessen fuer den Tenant aktiv sein) — ein nicht registriertes Modul ist nie aktiv. List liefert alle Module fuer Statusseite/Lizenzoberflaeche (Akzeptanzkriterium 3). RequireActiveModule ist die zentrale Durchsetzungs-Middleware (Casbin- Prinzip): weist Anfragen an ein deaktiviertes Modul ab, BEVOR der Modul-Handler ueberhaupt aufgerufen wird (Akzeptanzkriterium 2) — Pruefung per Test belegt, dass der Handler bei Deaktivierung nachweislich nicht erreicht wird. Service-Credentials (Akzeptanzkriterium 4): Registry.Provision stellt pro Modul-Instanz Client-ID + Secret aus, gespeichert wird nur der SHA-256-Hash des Secrets. Registry.Authenticate vergleicht timing-safe (dieselbe subtle.ConstantTimeCompare-Referenzimplementierung wie AUD-02). RequireServiceCredential-Middleware liest X-Client-Id/X-Client-Secret und weist Aufrufe ohne gueltiges Credential mit 401 ab, bevor der Core-seitige Endpunkt (z.B. Audit-Nachlieferung, Nutzungsmeldung) erreicht wird. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Anfrage an deaktiviertes Modul nachweislich vor Modul-Logik abgewiesen — TestRequireActiveModule_BlocksBeforeHandler: handlerReached bleibt false bei 403, wird true erst nach Aktivierung bei 200. PASS. 2. Registrierung mit fehlenden Pflichtangaben abgewiesen — TestRegister_RejectsMissingFields (leerer Name, leere Version). PASS. 3. Registry-Abfrage liefert konsistente Daten nach Aktivierung/Deaktivierung — TestIsActive_ReflectsFlagStateConsistently: aus/an/aus-Zyklus, IsActive folgt dem Flag-Zustand korrekt. PASS. 4. Aufruf mit ungueltigem/fehlendem Service-Credential abgewiesen, mit gueltigem angenommen — TestRequireServiceCredential_RejectsInvalidAcceptsValid und TestProvisionAndAuthenticate (falsches Secret, unbekannte Client-ID, korrektes Credential). PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:17:50 +02:00
sysopsandClaude Sonnet 5	4a30345e07	LIC-02: feature-flag-service-je-tenant internal/flag: Store (Verwaltung) + Service (Auswertung mit TTL-Cache, Default 5s) — Unleash-Prinzip Flag-Verwaltung vs. Flag-Auswertung getrennt, als Kernfunktion des Core-Dienstes selbst statt separater Infrastruktur. evaluate() wendet drei Strategien in fester Reihenfolge an: global an/aus, Tenant-Zielgruppe, deterministischer Prozentsatz-Rollout (FNV-Hash aus Tenant+Key, stabil pro Tenant). IsEnabled liefert IMMER nur bool (kein Fehlerwert) — ein nicht erreichbarer Flag-Dienst kann damit keinen Aufrufer zum Absturz bringen: bei DB-Fehler wird der zuletzt bekannte Cache-Stand verwendet, ohne jeglichen Stand faellt der Dienst sicher auf false zurueck. Service.Invalidate erzwingt sofortiges Neuladen fuer den Schreiber selbst, andere Instanzen sehen Aenderungen spaetestens nach der TTL (Akzeptanzkriterium 3, kein Neustart noetig). Bugfix waehrend Tests: Store.Set uebergab ein nil-TargetTenantSlugs-Slice als SQL NULL statt leerem Array (NOT-NULL-Verletzung) — auf leeres Slice normalisiert. Akzeptanzkriterium 4 (Deaktivierung loescht keine Daten): dieses Paket besitzt ausschliesslich die eigene feature_flags-Zeile, hat keinerlei Code-Pfad, der Modul-Geschaeftsdaten anfassen koennte — Loeschung bleibt strukturell der Archive-Retention-Engine vorbehalten. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Cache-Invalidierungszeit automatisiert gemessen — TestService_CacheInvalidationTiming: Aenderung wirksam nach 153ms bei TTL=150ms (innerhalb Ziel+Toleranz), vorher nachweislich noch alter Stand. PASS. 2. Zielgruppen-Strategie liefert erwartete Auswertung — TestService_TargetTenantStrategy / TestEvaluate_TargetTenantStrategy. PASS. 3. Ausfall des Flag-Dienstes fuehrt zu dokumentiertem Fallback, kein Absturz — TestService_FallsBackOnStoreFailure (mit recover()-Absicherung): Fallback auf Cache-Stand bzw. sicheres false bei komplett unerreichbarer DB, geloggt. PASS. 4. Modul-Deaktivierung/Reaktivierung ohne Datenverlust — architektonisch durch fehlenden Code-Pfad sichergestellt (siehe oben), zusaetzlich durch TestService_InvalidateForcesImmediateRefresh (Toggle aus/an bleibt konsistent nachvollziehbar) mitabgedeckt. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:19:59 +02:00
				`@@ -1 +0,0 @@`
				`ALTER TABLE users DROP COLUMN password_hash;`