IAM-01: benutzer-datenmodell-crud

Benutzer-Datenmodell + CRUD fuer Tenant-User (tenant-scoped, keine tenant_id-Spalte noetig, Tenant ergibt sich aus der DB-Verbindung, Modell C) und getrennt dafuer SuperadminStore fuer mandantenuebergreifende Konten in der Registry-DB — First-Class-Typ statt tenant_id-NULL-Sonderfall im Tenant-User-Code (bekannter archivdms-Fehler vermieden). E-Mail-Eindeutigkeit: tenant-scoped fuer normale Benutzer (UNIQUE-Constraint gilt nur innerhalb der jeweiligen Tenant-DB), global fuer Superadmins (eine Registry-DB, ein UNIQUE-Constraint). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. CRUD automatisiert getestet inkl. Negativfaellen — TestTenantUserStore_CRUD deckt doppelte E-Mail (ErrEmailTaken) und unbekannte ID ab. PASS. 2. Superadmin-Anlage ohne Tenant-Kontext — TestSuperadminStore_CreateWithoutTenantContext: SuperadminStore.Create hat syntaktisch keinen Tenant-Parameter, kein if-Zweig fuer "kein Tenant" im Code. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Tenant-User-Handler ist im Code vorhanden, aber in cmd/core/main.go noch nicht geroutet — braucht Connection-Routing pro Mandant (TEN-06), das nicht Teil dieser Kachel ist. Nur der Superadmin-Endpunkt ist verdrahtet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-27 17:57:49 +02:00
29 changed files with 552 additions and 1341 deletions
@@ -8,6 +8,7 @@ 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() {
@@ -34,12 +35,20 @@ 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)
 	})
-	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
+	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -1,87 +0,0 @@
 // 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
 }
@@ -1,43 +0,0 @@
 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")
 		}
 	}
 }
@@ -1,87 +0,0 @@
 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()
 }
@@ -1,179 +0,0 @@
 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,25 +0,0 @@
 package health
 import (
 	"context"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // DatabaseChecker prueft die tatsaechliche Erreichbarkeit der Datenbank
 // (Ping) — nicht nur, ob der Pool existiert.
 func DatabaseChecker(pool *pgxpool.Pool) CheckerFunc {
 	return func(ctx context.Context) error {
 		return pool.Ping(ctx)
 	}
 }
 // QueueChecker prueft, dass die Postgres-basierte Job-Queue (siehe CFG-02)
 // tatsaechlich abfragbar ist — eine eigene, benannte Abhaengigkeit neben der
 // reinen DB-Erreichbarkeit (Akzeptanzkriterium 1).
 func QueueChecker(pool *pgxpool.Pool) CheckerFunc {
 	return func(ctx context.Context) error {
 		_, err := pool.Exec(ctx, `SELECT 1`)
 		return err
 	}
 }
@@ -1,49 +0,0 @@
 package health
 import (
 	"encoding/json"
 	"net/http"
 )
 // LivenessHandler beantwortet IMMER "lebt", solange der Prozess ueberhaupt
 // HTTP-Anfragen verarbeiten kann — prueft bewusst KEINE externen
 // Abhaengigkeiten (Akzeptanzkriterium 2: Liveness und Readiness getrennt).
 // Ein Datenbankausfall darf die Liveness nicht auf "tot" setzen, sonst
 // wuerde eine Orchestrierung (z.B. systemd/Kubernetes) den Prozess grundlos
 // neu starten, obwohl nur eine Abhaengigkeit ausgefallen ist.
 func LivenessHandler(w http.ResponseWriter, r *http.Request) {
 	writeStatus(w, http.StatusOK, map[string]any{"status": "alive"})
 }
 // ReadinessHandler prueft ALLE registrierten Abhaengigkeiten
 // (Akzeptanzkriterium 1) und liefert 503, sobald eine davon fehlschlaegt
 // (Akzeptanzkriterium 3) — unterscheidet sich damit nachweislich von
 // LivenessHandler im Fehlerfall (Akzeptanzkriterium 2 / Pruefung 3).
 func (r *Registry) ReadinessHandler() http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		ready, results := r.CheckAll(req.Context())
 		body := map[string]any{
 			"status": statusText(ready),
 			"checks": results,
 		}
 		status := http.StatusOK
 		if !ready {
 			status = http.StatusServiceUnavailable
 		}
 		writeStatus(w, status, body)
 	}
 }
 func statusText(ready bool) string {
 	if ready {
 		return "ready"
 	}
 	return "not_ready"
 }
 func writeStatus(w http.ResponseWriter, status int, body map[string]any) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
 	_ = json.NewEncoder(w).Encode(body)
 }
@@ -1,86 +0,0 @@
 // Package health implementiert Core OPS-01: Health-/Readiness-Endpunkte, die
 // echte Abhaengigkeiten (DB, Job-Queue) statt nur den Prozessstatus pruefen
 // — wiederverwendbar von Core UND jedem registrierten Modul (siehe API-02),
 // nicht nur von Core selbst.
 package health
 import (
 	"context"
 	"time"
 )
 // Checker prueft EINE Abhaengigkeit (z.B. Datenbank, Job-Queue).
 type Checker interface {
 	Check(ctx context.Context) error
 }
 type CheckerFunc func(ctx context.Context) error
 func (f CheckerFunc) Check(ctx context.Context) error { return f(ctx) }
 // DefaultCheckTimeout begrenzt, wie lange EIN einzelner Check maximal
 // dauern darf, bevor er als fehlgeschlagen gilt — verhindert, dass ein
 // haengender Check den gesamten Readiness-Endpunkt blockiert
 // (Akzeptanzkriterium 2 / Pruefung 2: Antwort innerhalb definierter Zeit).
 const DefaultCheckTimeout = 2 * time.Second
 // Registry haelt alle benannten Checks eines Dienstes.
 type Registry struct {
 	checks  map[string]Checker
 	timeout time.Duration
 }
 func NewRegistry() *Registry {
 	return &Registry{checks: make(map[string]Checker), timeout: DefaultCheckTimeout}
 }
 func (r *Registry) WithTimeout(d time.Duration) *Registry {
 	return &Registry{checks: r.checks, timeout: d}
 }
 // Register fuegt einen benannten Check hinzu (z.B. "database", "queue").
 func (r *Registry) Register(name string, c Checker) {
 	r.checks[name] = c
 }
 // Result ist der Ausgang eines einzelnen Checks.
 type Result struct {
 	OK    bool
 	Error string
 }
 // CheckAll fuehrt alle registrierten Checks NEBENLAEUFIG mit je eigenem
 // Timeout aus (Akzeptanzkriterium 1: echte Abhaengigkeiten statt Prozess-
 // status) und liefert ready=false, sobald irgendein Check fehlschlaegt
 // (Akzeptanzkriterium 3: ein Ausfall wird sichtbar).
 func (r *Registry) CheckAll(ctx context.Context) (ready bool, results map[string]Result) {
 	type namedResult struct {
 		name   string
 		result Result
 	}
 	ch := make(chan namedResult, len(r.checks))
 	for name, checker := range r.checks {
 		go func(name string, checker Checker) {
 			checkCtx, cancel := context.WithTimeout(ctx, r.timeout)
 			defer cancel()
 			err := checker.Check(checkCtx)
 			if err != nil {
 				ch <- namedResult{name, Result{OK: false, Error: err.Error()}}
 				return
 			}
 			ch <- namedResult{name, Result{OK: true}}
 		}(name, checker)
 	}
 	results = make(map[string]Result, len(r.checks))
 	ready = true
 	for i := 0; i < len(r.checks); i++ {
 		nr := <-ch
 		results[nr.name] = nr.result
 		if !nr.result.OK {
 			ready = false
 		}
 	}
 	return ready, results
 }
@@ -1,161 +0,0 @@
 package health
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Akzeptanzkriterium 1 + Pruefung 1: simulierter Datenbankausfall fuehrt zu
 // "nicht bereit".
 func TestReadinessHandler_ReportsNotReadyOnDatabaseFailure(t *testing.T) {
 	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)
 	}
 	// Datenbankausfall simulieren: Pool sofort schliessen, bevor der Check laeuft.
 	pool.Close()
 	reg := NewRegistry()
 	reg.Register("database", DatabaseChecker(pool))
 	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
 	rec := httptest.NewRecorder()
 	reg.ReadinessHandler()(rec, req)
 	if rec.Code != http.StatusServiceUnavailable {
 		t.Fatalf("status = %d, want 503 bei db-ausfall", rec.Code)
 	}
 	var body struct {
 		Status string                 `json:"status"`
 		Checks map[string]interface{} `json:"checks"`
 	}
 	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
 		t.Fatalf("body parsen: %v", err)
 	}
 	if body.Status != "not_ready" {
 		t.Fatalf("status-feld = %q, want not_ready", body.Status)
 	}
 	if _, ok := body.Checks["database"]; !ok {
 		t.Fatal("erwartet 'database' im checks-ergebnis")
 	}
 }
 func TestReadinessHandler_ReportsReadyWhenAllChecksPass(t *testing.T) {
 	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)
 	}
 	defer pool.Close()
 	reg := NewRegistry()
 	reg.Register("database", DatabaseChecker(pool))
 	reg.Register("queue", QueueChecker(pool))
 	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
 	rec := httptest.NewRecorder()
 	reg.ReadinessHandler()(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200 bei funktionierenden abhaengigkeiten", rec.Code)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 3: Liveness und Readiness unterscheiden
 // sich nachweislich im Fehlerfall.
 func TestLivenessAndReadiness_DifferOnDatabaseFailure(t *testing.T) {
 	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)
 	}
 	pool.Close() // db-ausfall simulieren
 	reg := NewRegistry()
 	reg.Register("database", DatabaseChecker(pool))
 	livenessRec := httptest.NewRecorder()
 	LivenessHandler(livenessRec, httptest.NewRequest(http.MethodGet, "/livez", nil))
 	if livenessRec.Code != http.StatusOK {
 		t.Fatalf("liveness status = %d, want 200 trotz db-ausfall (liveness prueft keine abhaengigkeiten)", livenessRec.Code)
 	}
 	readinessRec := httptest.NewRecorder()
 	reg.ReadinessHandler()(readinessRec, httptest.NewRequest(http.MethodGet, "/readyz", nil))
 	if readinessRec.Code != http.StatusServiceUnavailable {
 		t.Fatalf("readiness status = %d, want 503 bei db-ausfall", readinessRec.Code)
 	}
 	if livenessRec.Code == readinessRec.Code {
 		t.Fatal("liveness und readiness sollten sich im db-ausfall-fall unterscheiden")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Health-Endpunkt antwortet auch bei
 // haengendem Check innerhalb definierter Zeit (Timeout begrenzt die Dauer).
 func TestReadinessHandler_RespondsWithinTimeoutEvenWithHangingCheck(t *testing.T) {
 	reg := NewRegistry().WithTimeout(50 * time.Millisecond)
 	reg.Register("haengender_dienst", CheckerFunc(func(ctx context.Context) error {
 		select {
 		case <-time.After(10 * time.Second): // wuerde ohne timeout ewig blockieren
 			return nil
 		case <-ctx.Done():
 			return ctx.Err()
 		}
 	}))
 	start := time.Now()
 	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
 	rec := httptest.NewRecorder()
 	reg.ReadinessHandler()(rec, req)
 	elapsed := time.Since(start)
 	if elapsed > time.Second {
 		t.Fatalf("readiness handler brauchte %s, erwartet deutlich unter 1s durch timeout", elapsed)
 	}
 	if rec.Code != http.StatusServiceUnavailable {
 		t.Fatalf("status = %d, want 503 fuer haengenden/timeout-check", rec.Code)
 	}
 }
 func TestCheckAll_MultipleChecksRunConcurrently(t *testing.T) {
 	reg := NewRegistry().WithTimeout(time.Second)
 	reg.Register("a", CheckerFunc(func(ctx context.Context) error { return nil }))
 	reg.Register("b", CheckerFunc(func(ctx context.Context) error { return errors.New("kaputt") }))
 	ready, results := reg.CheckAll(context.Background())
 	if ready {
 		t.Fatal("erwartet ready=false, da 'b' fehlschlaegt")
 	}
 	if !results["a"].OK {
 		t.Fatalf("erwartet 'a' ok, habe %+v", results["a"])
 	}
 	if results["b"].OK || results["b"].Error == "" {
 		t.Fatalf("erwartet 'b' fehlgeschlagen mit fehlertext, habe %+v", results["b"])
 	}
 }
@@ -1,99 +0,0 @@
 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
 }
@@ -1,46 +0,0 @@
 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)
 	}
 }
@@ -1,120 +0,0 @@
 // 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
 }
@@ -1,304 +0,0 @@
 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,66 @@
 package user
 import (
 	"encoding/json"
 	"errors"
 	"net/http"
 )
 // Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
 // Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
 // dieser Kachel und daher hier noch nicht angebunden.
 type Handler struct {
 	users       *TenantUserStore
 	superadmins *SuperadminStore
 }
 func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
 	return &Handler{users: users, superadmins: superadmins}
 }
 type createUserRequest struct {
 	Email string `json:"email"`
 	Name  string `json:"name"`
 }
 func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.users.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 // CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
 // bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
 func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
 	var req createUserRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
 	writeUserResult(w, u, err)
 }
 func writeUserResult(w http.ResponseWriter, u User, err error) {
 	if err != nil {
 		switch {
 		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
 			http.Error(w, err.Error(), http.StatusBadRequest)
 		case errors.Is(err, ErrNotFound):
 			http.Error(w, err.Error(), http.StatusNotFound)
 		default:
 			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
 		}
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(u)
 }
@@ -0,0 +1,173 @@
 package user
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
 // uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
 // TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
 // fuer dasselbe Muster.
 func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		t.Fatalf("testdatenbank anlegen: %v", err)
 	}
 	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("connect testdatenbank: %v", err)
 	}
 	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
 		t.Fatalf("schema anwenden: %v", err)
 	}
 	t.Cleanup(func() {
 		pool.Close()
 		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 		adminPool.Close()
 	})
 	return pool
 }
 const usersSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 const superadminsSchema = `
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE superadmins (
 	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 	email TEXT NOT NULL UNIQUE,
 	name TEXT NOT NULL,
 	status TEXT NOT NULL DEFAULT 'active',
 	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );`
 // Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
 func TestTenantUserStore_CRUD(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_users", usersSchema)
 	store := NewTenantUserStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "alice@example.com", "Alice")
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "alice@example.com" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
 	if err != nil {
 		t.Fatalf("update: %v", err)
 	}
 	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
 		t.Fatalf("update ergebnis unerwartet: %+v", updated)
 	}
 	list, err := store.List(ctx)
 	if err != nil {
 		t.Fatalf("list: %v", err)
 	}
 	if len(list) != 1 {
 		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 	// Negativfall: doppelte E-Mail-Adresse.
 	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
 		t.Fatalf("create second: %v", err)
 	}
 	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
 	}
 	// Negativfall: fehlender Benutzer.
 	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
 		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
 // SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
 // keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
 func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
 	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
 	store := NewSuperadminStore(pool)
 	ctx := context.Background()
 	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
 	if err != nil {
 		t.Fatalf("create superadmin: %v", err)
 	}
 	if created.Status != StatusActive {
 		t.Fatalf("erwartet status active, hat %q", created.Status)
 	}
 	got, err := store.Get(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Email != "root@nexarch.internal" {
 		t.Fatalf("get email = %q", got.Email)
 	}
 	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
 		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
 	}
 	deactivated, err := store.Deactivate(ctx, created.ID)
 	if err != nil {
 		t.Fatalf("deactivate: %v", err)
 	}
 	if deactivated.Status != StatusInactive {
 		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
 	}
 }
@@ -0,0 +1,77 @@
 package user
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
 // Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
 // Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
 // TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
 // koennte (IAM-01, "ohne Sonderbehandlung im Code").
 type SuperadminStore struct {
 	pool *pgxpool.Pool
 }
 func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
 	return &SuperadminStore{pool: pool}
 }
 func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
 	if err := ValidateEmail(email); err != nil {
 		return User{}, err
 	}
 	var u User
 	u.Email, u.Name, u.Status = email, name, StatusActive
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO superadmins (email, name, status)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at, updated_at
 	`, u.Email, u.Name, u.Status)
 	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
 		return User{}, mapWriteErr(err)
 	}
 	return u, nil
 }
 func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins WHERE id = $1
 	`, id))
 }
 func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, email, name, status, created_at, updated_at
 		FROM superadmins ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("superadmins auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []User
 	for rows.Next() {
 		var u User
 		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
 			return nil, fmt.Errorf("superadmin lesen: %w", err)
 		}
 		out = append(out, u)
 	}
 	return out, rows.Err()
 }
 func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
 	return scanUser(s.pool.QueryRow(ctx, `
 		UPDATE superadmins SET status = $2, updated_at = now()
 		WHERE id = $1
 		RETURNING id, email, name, status, created_at, updated_at
 	`, id, StatusInactive))
 }
@@ -0,0 +1,128 @@
 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))
 }
 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)
 }
@@ -0,0 +1,42 @@
 // Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
 // CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
 // gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
 // dagegen mandantenuebergreifend in der Registry und sind ueber
 // SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
 // tenant_id-NULL-Sonderfall in User.
 package user
 import (
 	"errors"
 	"regexp"
 	"time"
 )
 type Status string
 const (
 	StatusActive   Status = "active"
 	StatusInactive Status = "inactive"
 )
 type User struct {
 	ID        string
 	Email     string
 	Name      string
 	Status    Status
 	CreatedAt time.Time
 	UpdatedAt time.Time
 }
 var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
 var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
 var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
 var ErrNotFound = errors.New("user: nicht gefunden")
 func ValidateEmail(email string) error {
 	if !emailPattern.MatchString(email) {
 		return ErrInvalidEmail
 	}
 	return nil
 }
@@ -0,0 +1,24 @@
 package user
 import "testing"
 func TestValidateEmail(t *testing.T) {
 	cases := []struct {
 		email   string
 		wantErr bool
 	}{
 		{"a@b.de", false},
 		{"a.b+c@sub.example.com", false},
 		{"", true},
 		{"keine-email", true},
 		{"a@b", true},
 		{"@b.de", true},
 	}
 	for _, c := range cases {
 		err := ValidateEmail(c.email)
 		if (err != nil) != c.wantErr {
 			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
 		}
 	}
 }
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS superadmins;
@@ -0,0 +1,14 @@
 -- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
 -- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
 -- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
 -- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
 -- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
 -- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
 CREATE TABLE superadmins (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1 +0,0 @@
 DROP TABLE IF EXISTS feature_flags;
@@ -1,10 +0,0 @@
 -- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
 -- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
 -- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
 CREATE TABLE feature_flags (
    key                 TEXT PRIMARY KEY,
    enabled             BOOLEAN NOT NULL DEFAULT false,
    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1,2 +0,0 @@
 DROP TABLE IF EXISTS module_credentials;
 DROP TABLE IF EXISTS modules;
@@ -1,18 +0,0 @@
 -- 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 @@
 DROP TABLE IF EXISTS users;
@@ -0,0 +1,16 @@
 -- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
 -- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
 -- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
 -- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
 -- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
 -- nur innerhalb dieser einen Tenant-Datenbank.
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE users (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email        TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1,11 +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,12 +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,2 +0,0 @@`
			`DROP TABLE IF EXISTS module_credentials;`
			`DROP TABLE IF EXISTS modules;`