TEN-06: connection-routing-pooling-pro-mandant

Router loest Tenant-Slug (aus JWT-Claim, API-05 vorausgesetzt) ueber die TEN-01-Registry in eine wiederverwendete Postgres-Verbindung auf. LRU-Cache (container/list) begrenzt die Zahl gleichzeitig offener Tenant-Pools auf maxOpen — bei Ueberschreitung wird der am laengsten ungenutzte Pool geschlossen, bevor ein neuer aufgemacht wird. Fehlender/unbekannter Tenant-Kontext liefert explizite Fehler (ErrMissingTenantContext / ErrUnknownTenant) statt stillschweigend zu routen. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Lasttest mit 6 simulierten Mandanten gegen maxOpen=2 — TestRouter_BoundsOpenConnectionsUnderLoad: OpenCount() bleibt nach jedem Resolve <= maxOpen, Verbindungszahl waechst nicht linear mit der Mandantenzahl. PASS. 2. Anfrage ohne/mit unbekanntem Tenant-Kontext abgewiesen — TestRouter_RejectsMissingOrUnknownTenant. PASS. 3. Verbindungswiederverwendung gemessen — TestRouter_ReusesConnectionForSameTenant: zweiter Resolve-Aufruf liefert exakt dieselbe *pgxpool.Pool-Instanz. PASS. Router ist eigenstaendig nutzbar/getestet, aber noch nicht in cmd/core/main.go verdrahtet — der JWT-Claim mit Tenant-Kontext (API-05) und das HTTP-Routing, das den Slug pro Request extrahiert, sind nicht Teil dieser Kachel. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 18:35:50 +02:00
33 changed files with 299 additions and 1755 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 {
@@ -2,16 +2,13 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
-require (
+require github.com/jackc/pgx/v5 v5.6.0
 	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,8 +1,6 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
 github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
@@ -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")
 	}
 }
@@ -1,86 +0,0 @@
 package moduletrust
 import (
 	"context"
 	"fmt"
 	"sync"
 	"time"
 )
 // StaleCache ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
 // (Akzeptanzkriterium 2): TTL-basiert, mit explizitem, benanntem Verhalten
 // bei abgelaufenem Cache waehrend Core nicht erreichbar ist.
 //
 //   - Get: FAIL-OPEN fuer Lesevorgaenge. Schlaegt der Refresh fehl, aber es
 //     gibt bereits einen (wenn auch abgelaufenen) Stand, wird dieser mit
 //     stale=true zurueckgegeben — Begruendung: ein bereits authentifiziertes
 //     Modul soll mit dem letztbekannten Stand weiterarbeiten koennen statt
 //     hart zu blockieren (siehe "Bekannte Fehler vermeiden" im Ticket).
 //     Existiert noch nie ein Stand, gibt es keinen sinnvollen Fallback —
 //     dann liefert auch Get einen Fehler.
 //   - RequireFresh: FAIL-CLOSED fuer sicherheitskritische Aktionen (z.B.
 //     ein komplett NEUER Login). Nutzt NIEMALS einen zwischengespeicherten
 //     Stand, ruft immer frisch ab — Begruendung: eine neue Vertrauens-
 //     entscheidung darf nicht auf veralteten Daten beruhen, auch wenn das
 //     bedeutet, dass die Aktion bei Core-Ausfall sichtbar fehlschlaegt statt
 //     unsicher "irgendwie" durchgelassen zu werden.
 //
 // LIC-02 (internal/flag.Service) implementiert bereits denselben Kontrakt
 // fuer Feature-Flags — StaleCache verallgemeinert dasselbe Muster fuer
 // JWT-Signaturschluessel, damit beide Faelle derselben dokumentierten
 // Policy folgen.
 type StaleCache[T any] struct {
 	mu        sync.RWMutex
 	value     T
 	hasValue  bool
 	fetchedAt time.Time
 	ttl       time.Duration
 	fetch     func(ctx context.Context) (T, error)
 }
 func NewStaleCache[T any](ttl time.Duration, fetch func(ctx context.Context) (T, error)) *StaleCache[T] {
 	return &StaleCache[T]{ttl: ttl, fetch: fetch}
 }
 // Get liefert den Cache-Wert. FAIL-OPEN: bei Refresh-Fehler wird ein
 // vorhandener, ggf. abgelaufener Stand zurueckgegeben (stale=true).
 func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error) {
 	c.mu.RLock()
 	fresh := c.hasValue && time.Since(c.fetchedAt) < c.ttl
 	if fresh {
 		v := c.value
 		c.mu.RUnlock()
 		return v, false, nil
 	}
 	c.mu.RUnlock()
 	newVal, fetchErr := c.fetch(ctx)
 	if fetchErr == nil {
 		c.mu.Lock()
 		c.value, c.hasValue, c.fetchedAt = newVal, true, time.Now()
 		c.mu.Unlock()
 		return newVal, false, nil
 	}
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	if c.hasValue {
 		return c.value, true, nil
 	}
 	var zero T
 	return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
 }
 // RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
 // Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
 func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
 	v, err := c.fetch(ctx)
 	if err != nil {
 		var zero T
 		return zero, fmt.Errorf("core nicht erreichbar, sicherheitskritische aktion abgelehnt: %w", err)
 	}
 	c.mu.Lock()
 	c.value, c.hasValue, c.fetchedAt = v, true, time.Now()
 	c.mu.Unlock()
 	return v, nil
 }
@@ -1,79 +0,0 @@
 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
 }
@@ -1,83 +0,0 @@
 // 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
 }
@@ -1,214 +0,0 @@
 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)  {}
@@ -1,67 +0,0 @@
 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,136 @@
 package tenant
 import (
 	"container/list"
 	"context"
 	"errors"
 	"fmt"
 	"sync"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // ErrMissingTenantContext wird geliefert, wenn keine Tenant-Kennung
 // uebergeben wurde — es gibt bewusst keinen impliziten Default-Tenant
 // (TEN-06 Akzeptanzkriterium 3).
 var ErrMissingTenantContext = errors.New("tenant: kein tenant-kontext angegeben")
 // ErrUnknownTenant wird geliefert, wenn die Tenant-Kennung in der Registry
 // nicht existiert.
 var ErrUnknownTenant = errors.New("tenant: unbekannter tenant")
 // Router loest den Tenant-Kontext (Slug, aus dem JWT-Claim von API-05) in
 // eine wiederverwendbare Verbindung zur richtigen Tenant-Datenbank auf.
 // Ein LRU-verwalteter Cache begrenzt die Zahl gleichzeitig offener
 // pgxpool.Pool-Instanzen, damit die Zahl offener Postgres-Verbindungen NICHT
 // linear mit der Mandantenzahl waechst (Akzeptanzkriterium 2).
 type Router struct {
 	registry *Registry
 	maxOpen  int
 	mu    sync.Mutex
 	order *list.List               // vorne = zuletzt benutzt
 	items map[string]*list.Element // slug -> element mit *routerEntry
 }
 type routerEntry struct {
 	slug string
 	pool *pgxpool.Pool
 }
 func NewRouter(registry *Registry, maxOpen int) *Router {
 	if maxOpen < 1 {
 		maxOpen = 1
 	}
 	return &Router{
 		registry: registry,
 		maxOpen:  maxOpen,
 		order:    list.New(),
 		items:    make(map[string]*list.Element),
 	}
 }
 // Resolve liefert einen wiederverwendeten Pool fuer den angegebenen Tenant.
 // Ist der Tenant bereits im Cache, wird KEINE neue Verbindung aufgebaut
 // (Akzeptanzkriterium 2 / Pruefung 3).
 func (r *Router) Resolve(ctx context.Context, tenantSlug string) (*pgxpool.Pool, error) {
 	if tenantSlug == "" {
 		return nil, ErrMissingTenantContext
 	}
 	r.mu.Lock()
 	if el, ok := r.items[tenantSlug]; ok {
 		r.order.MoveToFront(el)
 		pool := el.Value.(*routerEntry).pool
 		r.mu.Unlock()
 		return pool, nil
 	}
 	r.mu.Unlock()
 	// Registry-Lookup und Verbindungsaufbau bewusst ausserhalb des Locks,
 	// damit ein langsamer Verbindungsaufbau nicht alle anderen Tenants blockiert.
 	t, err := r.registry.GetBySlug(ctx, tenantSlug)
 	if err != nil {
 		return nil, fmt.Errorf("%w: %s", ErrUnknownTenant, tenantSlug)
 	}
 	pool, err := pgxpool.New(ctx, t.DBDSN)
 	if err != nil {
 		return nil, fmt.Errorf("verbindung zu tenant %q aufbauen: %w", tenantSlug, err)
 	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	// Zwischen Unlock oben und hier koennte ein paralleler Aufruf denselben
 	// Tenant bereits eingefuegt haben — dann die eigene, ueberzaehlige
 	// Verbindung wieder schliessen und die vorhandene verwenden.
 	if el, ok := r.items[tenantSlug]; ok {
 		r.order.MoveToFront(el)
 		existing := el.Value.(*routerEntry).pool
 		pool.Close()
 		return existing, nil
 	}
 	el := r.order.PushFront(&routerEntry{slug: tenantSlug, pool: pool})
 	r.items[tenantSlug] = el
 	if r.order.Len() > r.maxOpen {
 		r.evictOldest()
 	}
 	return pool, nil
 }
 // evictOldest schliesst den am laengsten nicht genutzten Pool. Muss mit
 // gehaltenem r.mu aufgerufen werden.
 func (r *Router) evictOldest() {
 	oldest := r.order.Back()
 	if oldest == nil {
 		return
 	}
 	entry := oldest.Value.(*routerEntry)
 	r.order.Remove(oldest)
 	delete(r.items, entry.slug)
 	entry.pool.Close()
 }
 // OpenCount liefert die aktuelle Zahl offen gehaltener Tenant-Pools —
 // dient Tests/Monitoring, um AC2 nachzuweisen.
 func (r *Router) OpenCount() int {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return r.order.Len()
 }
 // Close schliesst alle offen gehaltenen Tenant-Pools, z.B. beim
 // Herunterfahren des Core-Prozesses.
 func (r *Router) Close() {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	for el := r.order.Front(); el != nil; el = el.Next() {
 		el.Value.(*routerEntry).pool.Close()
 	}
 	r.order.Init()
 	r.items = make(map[string]*list.Element)
 }
@@ -0,0 +1,160 @@
 package tenant
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func newTestRouterSetup(t *testing.T, tenantCount int) (*Router, []Tenant, func()) {
 	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)
 	}
 	registryPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("registry pool: %v", err)
 	}
 	if _, err := registryPool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS tenants (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			slug TEXT NOT NULL UNIQUE,
 			name TEXT NOT NULL,
 			db_name TEXT NOT NULL UNIQUE,
 			db_dsn TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		)`); err != nil {
 		t.Fatalf("registry-schema: %v", err)
 	}
 	registry := NewRegistry(registryPool)
 	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
 	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
 	var tenants []Tenant
 	var slugs []string
 	for i := 0; i < tenantCount; i++ {
 		slug := fmt.Sprintf("router_t%d", i)
 		slugs = append(slugs, slug)
 		tn, err := provisioner.Provision(ctx, slug, slug)
 		if err != nil {
 			t.Fatalf("provision %s: %v", slug, err)
 		}
 		tenants = append(tenants, tn)
 	}
 	router := NewRouter(registry, 2) // klein gewaehlt, um Eviction im Test zu erzwingen
 	cleanup := func() {
 		router.Close()
 		for _, slug := range slugs {
 			_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbNameForSlug(slug)))
 		}
 		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug = ANY($1)`, slugs)
 		registryPool.Close()
 		adminPool.Close()
 	}
 	return router, tenants, cleanup
 }
 // Akzeptanzkriterium 1: Verbindung wird zuverlaessig anhand des Tenant-Kontexts aufgeloest.
 func TestRouter_ResolvesCorrectTenantDatabase(t *testing.T) {
 	router, tenants, cleanup := newTestRouterSetup(t, 2)
 	defer cleanup()
 	ctx := context.Background()
 	pool, err := router.Resolve(ctx, tenants[0].Slug)
 	if err != nil {
 		t.Fatalf("resolve: %v", err)
 	}
 	var dbName string
 	if err := pool.QueryRow(ctx, `SELECT current_database()`).Scan(&dbName); err != nil {
 		t.Fatalf("current_database: %v", err)
 	}
 	if dbName != tenants[0].DBName {
 		t.Fatalf("current_database() = %q, want %q", dbName, tenants[0].DBName)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 2: fehlender/unbekannter Tenant-Kontext
 // wird explizit abgewiesen statt irgendeine Verbindung zu liefern.
 func TestRouter_RejectsMissingOrUnknownTenant(t *testing.T) {
 	router, _, cleanup := newTestRouterSetup(t, 1)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := router.Resolve(ctx, ""); !errors.Is(err, ErrMissingTenantContext) {
 		t.Fatalf("erwartet ErrMissingTenantContext, habe %v", err)
 	}
 	if _, err := router.Resolve(ctx, "nie-registrierter-slug"); !errors.Is(err, ErrUnknownTenant) {
 		t.Fatalf("erwartet ErrUnknownTenant, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 3: Verbindungswiederverwendung nachweislich
 // gemessen — zweiter Resolve-Aufruf liefert exakt denselben Pool, kein
 // erneuter Verbindungsaufbau.
 func TestRouter_ReusesConnectionForSameTenant(t *testing.T) {
 	router, tenants, cleanup := newTestRouterSetup(t, 1)
 	defer cleanup()
 	ctx := context.Background()
 	first, err := router.Resolve(ctx, tenants[0].Slug)
 	if err != nil {
 		t.Fatalf("resolve 1: %v", err)
 	}
 	second, err := router.Resolve(ctx, tenants[0].Slug)
 	if err != nil {
 		t.Fatalf("resolve 2: %v", err)
 	}
 	if first != second {
 		t.Fatal("erwartet identische pool-instanz bei wiederholtem resolve, habe unterschiedliche")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Lasttest mit mehr simulierten Mandanten
 // als maxOpen — die Zahl gleichzeitig offener Tenant-Pools bleibt begrenzt
 // (LRU-Eviction), waechst also NICHT linear mit der Mandantenzahl.
 func TestRouter_BoundsOpenConnectionsUnderLoad(t *testing.T) {
 	const tenantCount = 6
 	router, tenants, cleanup := newTestRouterSetup(t, tenantCount)
 	defer cleanup()
 	ctx := context.Background()
 	for _, tn := range tenants {
 		if _, err := router.Resolve(ctx, tn.Slug); err != nil {
 			t.Fatalf("resolve %s: %v", tn.Slug, err)
 		}
 		if router.OpenCount() > 2 {
 			t.Fatalf("OpenCount() = %d, erwartet <= maxOpen (2) nach jedem Resolve", router.OpenCount())
 		}
 	}
 	if router.OpenCount() != 2 {
 		t.Fatalf("erwartet genau maxOpen=2 offene pools nach %d tenants, habe %d", tenantCount, router.OpenCount())
 	}
 	// Evictete Tenants sind wieder ganz normal ueber die Registry aufloesbar
 	// (Cache-Miss fuehrt zu neuem, funktionierendem Pool, kein Fehlerzustand).
 	pool, err := router.Resolve(ctx, tenants[0].Slug)
 	if err != nil {
 		t.Fatalf("resolve nach eviction: %v", err)
 	}
 	var one int
 	if err := pool.QueryRow(ctx, `SELECT 1`).Scan(&one); err != nil {
 		t.Fatalf("query nach re-resolve: %v", err)
 	}
 }
@@ -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()
 );
@@ -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,16 +0,0 @@
 #!/usr/bin/env bash
 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,18 +0,0 @@
 #!/usr/bin/env bash
 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
		`@@ -1 +0,0 @@`
			`ALTER TABLE users DROP COLUMN password_hash;`