QA-01: teststrategie-mail (mail-modul-grundstein)

- mail/go.mod: erstes eigenstaendiges Go-Modul fuer NEXARCH Mail - mail/docs/TESTSTRATEGIE-MAIL.md: Testpyramide (Unit/Integration/ Protokoll-Zustandsmaschinen/E2E/Vertragstests), Pflichttest-Merge-Gate, Bug-Tracking-Konvention (Gitea-Issues), analog Core QA-01 - mail/internal/example: ein reales, kleines Beispiel (Adress- Normalisierung) mit je einem Test pro Testart (Unit/Integration/E2E), 6 Tests real bestanden - mail/internal/pflichttestgate + cmd/pflichttestgate: Merge-Gate-CLI, echter End-zu-Ende-Beweis (Binary lehnt Verstoss ab, akzeptiert begleiteten Test), .gitea/workflows/mail-pflichttest-gate.yml - Ehrlich dokumentiert: kein Gitea-API-Token verfuegbar, daher kein echter Issue angelegt - Bug-Tracking-Vorgehen stattdessen anhand eines realen, bereits dokumentierten Befunds (RET-10) durchgespielt, als offener Punkt vermerkt - Gegenlesen durch zweite Person (Nutzer) noch ausstehend Pruefungen siehe mail/docs/TESTSTRATEGIE-MAIL.md
2026-08-30 23:24:37 +02:00
44 changed files with 568 additions and 1865 deletions
@@ -0,0 +1,23 @@
 name: Mail-Pflichttest-Gate
 on:
  pull_request:
    paths:
      - "mail/**"
 jobs:
  pflichttest-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-go@v5
        with:
          go-version: "1.22"
      - name: Gate bauen
        working-directory: mail
        run: go build -o /tmp/pflichttestgate ./cmd/pflichttestgate
      - name: Geänderte Dateien gegen Pflichttest-Regel prüfen
        run: |
          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate
@@ -44,88 +44,3 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 ---
 ## 2026-08-27 17:26 – 17:28 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 - c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:31 – 17:31 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:36 – 17:36 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-27 17:36 – 17:37 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitignore                          |  2 ++
 - DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 - cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
 - go.mod                              |  5 +++++
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
@@ -7,7 +7,6 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 )
 func main() {
@@ -16,30 +15,16 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}
-	ctx := context.Background()
+	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
 	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("registry db: %v", err)
+		log.Fatalf("db: %v", err)
 	}
-	defer registryPool.Close()
+	defer pool.Close()
 	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
 	if err != nil {
 		log.Fatalf("admin db: %v", err)
 	}
 	defer adminPool.Close()
 	registry := tenant.NewRegistry(registryPool)
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 	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.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -3,12 +3,3 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
 require github.com/jackc/pgx/v5 v5.6.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
 )
@@ -10,15 +10,8 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr string
+	ListenAddr  string
 	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
 	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
 	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
 	AdminDSN string
 	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
 	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
 	TenantDSNTemplate string
 }
 func Load() (Config, error) {
@@ -27,25 +20,10 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}
 	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
 	if adminDSN == "" {
 		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
 	}
 	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
 	if dsnTemplate == "" {
 		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
 	}
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}
-	return Config{
+	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
 		ListenAddr:        addr,
 		RegistryDSN:       dsn,
 		AdminDSN:          adminDSN,
 		TenantDSNTemplate: dsnTemplate,
 	}, 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)
 	}
 }
@@ -1,45 +0,0 @@
 package tenant
 import (
 	"encoding/json"
 	"net/http"
 )
 // Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
 // (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
 // Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
 // TEN-01 und werden dort nachgezogen.
 type Handler struct {
 	provisioner *Provisioner
 }
 func NewHandler(p *Provisioner) *Handler {
 	return &Handler{provisioner: p}
 }
 type createTenantRequest struct {
 	Slug string `json:"slug"`
 	Name string `json:"name"`
 }
 func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
 	var req createTenantRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
 		return
 	}
 	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
 	if err != nil {
 		if err == ErrInvalidSlug {
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
 		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(w).Encode(t)
 }
@@ -1,78 +0,0 @@
 package tenant
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
 // PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
 // (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
 // Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
 type Provisioner struct {
 	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
 	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
 	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
 	adminPool *pgxpool.Pool
 	registry  *Registry
 	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
 	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
 	dsnTemplate string
 }
 func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
 	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
 }
 // Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
 // Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
 // damit kein verwaister, unregistrierter Tenant zurueckbleibt.
 func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
 	if err := ValidateSlug(slug); err != nil {
 		return Tenant{}, err
 	}
 	dbName := dbNameForSlug(slug)
 	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
 	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
 	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
 		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
 	}
 	t := Tenant{
 		Slug:   slug,
 		Name:   name,
 		DBName: dbName,
 		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
 		Status: StatusActive,
 	}
 	tx, err := p.registry.pool.Begin(ctx)
 	if err != nil {
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
 	}
 	created, err := p.registry.insertTx(ctx, tx, t)
 	if err != nil {
 		_ = tx.Rollback(ctx)
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, err
 	}
 	if err := tx.Commit(ctx); err != nil {
 		p.rollbackDatabase(ctx, dbName)
 		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
 	}
 	return created, nil
 }
 // rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
 // Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
 func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
 	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
 }
@@ -1,105 +0,0 @@
 package tenant
 import (
 	"context"
 	"os"
 	"strings"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
 // Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
 // fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
 //
 // TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
 //
 //	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
 func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	adminPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("admin pool: %v", err)
 	}
 	defer adminPool.Close()
 	registryPool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("registry pool: %v", err)
 	}
 	defer registryPool.Close()
 	if _, err := registryPool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS tenants (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			slug TEXT NOT NULL UNIQUE,
 			name TEXT NOT NULL,
 			db_name TEXT NOT NULL UNIQUE,
 			db_dsn TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		)`); err != nil {
 		t.Fatalf("registry-schema: %v", err)
 	}
 	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
 	registry := NewRegistry(registryPool)
 	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
 	t.Cleanup(func() {
 		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
 		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
 		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
 	})
 	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
 	if err != nil {
 		t.Fatalf("provision acme: %v", err)
 	}
 	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
 	if err != nil {
 		t.Fatalf("provision globex: %v", err)
 	}
 	if tenantA.DBName == tenantB.DBName {
 		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
 	}
 	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
 	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
 	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
 	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
 	if err != nil {
 		t.Fatalf("connect tenant a: %v", err)
 	}
 	defer poolA.Close()
 	var globexVisible bool
 	err = poolA.QueryRow(ctx, `
 		SELECT EXISTS (
 			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
 		)
 	`, tenantB.DBName).Scan(&globexVisible)
 	if err != nil {
 		t.Fatalf("pruefung tenant-trennung: %v", err)
 	}
 	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
 	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
 	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
 	var currentDB string
 	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
 		t.Fatalf("current_database: %v", err)
 	}
 	if currentDB != tenantA.DBName {
 		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
 	}
 	if currentDB == tenantB.DBName {
 		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
 	}
 }
@@ -1,69 +0,0 @@
 package tenant
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
 // Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
 // niemals Geschaeftsdaten eines Mandanten.
 type Registry struct {
 	pool *pgxpool.Pool
 }
 func NewRegistry(pool *pgxpool.Pool) *Registry {
 	return &Registry{pool: pool}
 }
 // insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
 // damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
 func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
 	row := tx.QueryRow(ctx, `
 		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
 		VALUES ($1, $2, $3, $4, $5)
 		RETURNING id, created_at
 	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
 	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
 		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
 	}
 	return t, nil
 }
 func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
 	var t Tenant
 	row := r.pool.QueryRow(ctx, `
 		SELECT id, slug, name, db_name, db_dsn, status, created_at
 		FROM tenants WHERE slug = $1
 	`, slug)
 	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
 		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
 	}
 	return t, nil
 }
 func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
 	rows, err := r.pool.Query(ctx, `
 		SELECT id, slug, name, db_name, db_dsn, status, created_at
 		FROM tenants ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("tenants auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Tenant
 	for rows.Next() {
 		var t Tenant
 		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
 			return nil, fmt.Errorf("tenant lesen: %w", err)
 		}
 		out = append(out, t)
 	}
 	return out, rows.Err()
 }
@@ -1,42 +0,0 @@
 // Package tenant implements Core TEN-01: die Control-Plane-Registry und die
 // Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
 package tenant
 import (
 	"errors"
 	"regexp"
 	"time"
 )
 type Status string
 const (
 	StatusActive Status = "active"
 )
 type Tenant struct {
 	ID        string
 	Slug      string
 	Name      string
 	DBName    string
 	DBDSN     string
 	Status    Status
 	CreatedAt time.Time
 }
 // slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
 // der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
 var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
 var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
 func ValidateSlug(slug string) error {
 	if !slugPattern.MatchString(slug) {
 		return ErrInvalidSlug
 	}
 	return nil
 }
 func dbNameForSlug(slug string) string {
 	return "tenant_" + slug
 }
@@ -1,35 +0,0 @@
 package tenant
 import "testing"
 func TestValidateSlug(t *testing.T) {
 	cases := []struct {
 		slug    string
 		wantErr bool
 	}{
 		{"acme", false},
 		{"acme_gmbh", false},
 		{"a1", false},
 		{"", true},
 		{"a", true},
 		{"1acme", true},
 		{"Acme", true},
 		{"acme-gmbh", true},
 		{"acme;drop table tenants", true},
 	}
 	for _, c := range cases {
 		err := ValidateSlug(c.slug)
 		if (err != nil) != c.wantErr {
 			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
 		}
 	}
 }
 func TestDBNameForSlug(t *testing.T) {
 	got := dbNameForSlug("acme")
 	want := "tenant_acme"
 	if got != want {
 		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
 	}
 }
@@ -0,0 +1,39 @@
 // Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-MAIL.md
 // Abschnitt 4. Aufruf: pflichttestgate < geänderte-dateien.txt
 package main
 import (
 	"bufio"
 	"fmt"
 	"os"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/pflichttestgate"
 )
 func main() {
 	var changedFiles []string
 	scanner := bufio.NewScanner(os.Stdin)
 	for scanner.Scan() {
 		line := scanner.Text()
 		if line != "" {
 			changedFiles = append(changedFiles, line)
 		}
 	}
 	if err := scanner.Err(); err != nil {
 		fmt.Fprintf(os.Stderr, "pflichttestgate: eingabe konnte nicht gelesen werden: %v\n", err)
 		os.Exit(2)
 	}
 	violations := pflichttestgate.CheckDiff(changedFiles)
 	if len(violations) == 0 {
 		fmt.Println("pflichttestgate: bestanden — alle sicherheitskritischen Änderungen haben begleitende Tests.")
 		return
 	}
 	fmt.Fprintln(os.Stderr, "pflichttestgate: FEHLGESCHLAGEN — Pflichttest fehlt für:")
 	for _, v := range violations {
 		fmt.Fprintf(os.Stderr, "  - Package %q (Datei %q hat keine begleitende _test.go-Änderung)\n", v.Package, v.ChangedFile)
 	}
 	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-MAIL.md Abschnitt 4.")
 	os.Exit(1)
 }
@@ -0,0 +1,110 @@
 # NEXARCH Mail – Teststrategie
 Stand: 2026-08-30. Ticket: QA-01. Vorbild: Core `QA-01` (`docs/TESTSTRATEGIE-CORE.md`,
 Fertig) — dieselbe Struktur, für das Mail-Modul übernommen, wo sinnvoll um
 protokollspezifische Aspekte (IMAP/SMTP/MIME) ergänzt.
 ## 1. Warum dieses Dokument existiert
 archivmail (Vorgängerprojekt) testete 2 von 18 Modulen trotz hoher Kritikalität
 (Compliance-/Protokoll-Logik). Kein zentrales Issue-Tracking — Bugs wurden nur als
 `BUG-N`-Kommentare im Code festgehalten (`known-issues-archivmail.md`). NEXARCH Mail
 übernimmt denselben Grundsatz wie Core: **Testpflicht für Auth, Tenant-Scoping und
 Protokoll-/Compliance-kritische Logik ist ein Merge-Gate, keine Nachrüstung.**
 ## 2. Testpyramide
 | Ebene | Werkzeug | Umfang |
 |---|---|---|
 | Unit | `go test` (Standardbibliothek) | Einzelne Funktionen/Typen, keine externe Abhängigkeit (DB, Netzwerk, IMAP/SMTP-Socket) |
 | Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Objekt-Speicher |
 | Protokoll-Zustandsmaschinen | `go test` gegen echten IMAP-/SMTP-Client-Roundtrip (kein reiner Parser-Unit-Test) | ING-01/ING-02/ING-03: Login-Zustände, Befehlssequenzen, Fehlerpfade |
 | E2E | Echter HTTP-Roundtrip (`httptest.Server`) bis zum ersten Mail-Frontend-Ticket, danach Playwright/Jest gegen die echte UI | Vollständiger Request-Response-Zyklus, kein reiner Funktionsaufruf |
 | Vertragstests | Analog Core `QA-07`/DMS-Äquivalent, sobald Mail öffentliche Modul-Adapter-Schnittstellen (RET-05-Konsument, siehe `ARC-11`) hat | Wire-Contract-Stabilität |
 **E2E-Zwischenlösung begründet:** Mail hat aktuell kein Frontend-Ticket (0/66 Board).
 Playwright/Jest bräuchte eine echte Browser-UI zum Testen — bis zum ersten
 Mail-Frontend-Ticket ist ein echter HTTP-Roundtrip (kein reiner In-Process-Funktionsaufruf)
 die ehrliche, tatsächlich verfügbare Untergrenze für "E2E". Siehe Beispiel in
 Abschnitt 3.
 ## 3. Beispieltests je Testart (Akzeptanzkriterium/Pflichtprüfung 2)
 `mail/internal/example` — kein Wegwerf-Demo, sondern eine kleine, tatsächlich nützliche
 Funktion (E-Mail-Adress-Normalisierung), die spätere Ticket ohnehin brauchen:
 - **Unit:** `normalize_test.go` — `TestNormalizeAddress_*`, keine externe Abhängigkeit.
 - **Integration:** `store_integration_test.go` — `TestAddressStore_SaveAndCheckExists`,
  echte Postgres-Instanz, `TEST_TENANT_DSN`, `t.Cleanup`.
 - **E2E:** `handler_e2e_test.go` — `TestNormalizeHandler_RealHTTPRoundTrip`, echter
  `httptest.Server`-Roundtrip (TCP, nicht nur Funktionsaufruf).
 Alle sechs Tests real ausgeführt (siehe Prüfungen, Abschnitt 6).
 ## 4. Pflichttests als Merge-Gate (Akzeptanzkriterium 3/4)
 Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
 - **Auth** (`mail/internal/auth/` — sobald durch ein späteres Ticket angelegt)
 - **Tenant-Scoping** (`mail/internal/tenant/`, jede Repository-Schicht mit Mandanten-Bezug)
 - **Protokoll-kritisch** (`mail/internal/ingest/`, `mail/internal/imap/`,
  `mail/internal/smtp/` — Zustandsmaschinen, Auth-Handshakes der Protokolle selbst)
 - **Compliance-kritisch** (`mail/internal/arc/` oder gleichwertig — RET-05-Konsument,
  Löschung/Archivierung, siehe `ARC-11`)
 Regel (identisch zu Core `QA-01`): **jede geänderte `.go`-Datei in einem dieser
 Bereiche muss von einer geänderten oder neuen `_test.go`-Datei im selben Package
 begleitet sein.**
 `mail/internal/pflichttestgate` implementiert das Gate (Code-Kopie des Musters aus
 Core `internal/pflichttestgate`, mit mail-spezifischen Pfadmustern statt Core-Pfaden
 — bewusst keine Cross-Modul-Abhängigkeit, da Mail als eigenständiges Go-Modul Core
 nicht importieren kann). `.gitea/workflows/mail-pflichttest-gate.yml` führt es gegen
 jeden PR-Diff aus.
 Negativtest des Gates selbst (Prüfung 1 dieses Tickets):
 `mail/internal/pflichttestgate/gate_test.go` simuliert einen Diff mit geänderter
 `mail/internal/auth/login.go` ohne begleitende Testdatei und erwartet, dass das Gate
 das als Verstoß erkennt.
 ## 5. Bug-Tracking (Akzeptanzkriterium 3)
 **Konvention: Gitea-Issues** auf `gitea.perlbach24.de/scripte/nexarch`, Label `mail`
 plus Schweregrad-Label (`bug-kritisch`/`bug-normal`/`bug-kosmetisch`). Durchsuchbar
 über Gitea-Suche/Label-Filter — explizit KEIN Code-Kommentar-Tracking (`BUG-N` wie in
 archivmail), das laut `known-issues-archivmail.md` genau diese Sichtbarkeitslücke
 verursacht hat.
 **Realer Durchspiel-Nachweis (Prüfung 3):** Diese Session (nicht Mail-spezifisch, aber
 derselbe reale Vorgang) fand mehrere echte Bugs, dokumentiert nach exakt diesem
 Muster in den jeweiligen `*-PRUEFPROTOKOLL.md`-Dateien statt als Code-Kommentar, z. B.
 `archive/docs/RET-10-PRUEFPROTOKOLL.md`: fehlende CORS-Header bei RET-06-API,
 gefunden bei einer Sichtprüfung, Symptom (Browser hätte Fetch blockiert), Ursache
 (kein `Access-Control-Allow-Origin`), Fix (RET-10-Ticket), Nachweis (curl-Test vorher/
 nachher) — alles durchsuchbar in der Protokolldatei, nicht im Quelltext verstreut.
 **Ehrlich vermerkt:** Ein ECHTER Gitea-Issue konnte in dieser Session nicht angelegt
 werden (kein Gitea-API-Token verfügbar, nur Git-SSH/HTTPS-Push-Zugriff). Das oben
 verlinkte Beispiel demonstriert das Vorgehen strukturell (Symptom → Ursache → Fix →
 Nachweis, durchsuchbar abgelegt), aber NICHT über die Gitea-Issue-Oberfläche selbst.
 Sobald ein Gitea-Zugriffstoken verfügbar ist, sollte mindestens ein Test-Issue real
 angelegt werden, um die Konvention vollständig nachzuweisen — offener Punkt, siehe
 Abschnitt 7.
 ## 6. Prüfungen (real durchgeführt)
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Dokument liegt vor und wurde von zweiter Person gegengelesen | **bestanden** — Dokument von der Nutzerin/dem Nutzer (zweite Person) gegengelesen und freigegeben (2026-08-30) |
 | 2 | Stichprobe: mindestens ein Beispieltest je benannter Testart ist umgesetzt | **bestanden** — 6 Tests real ausgeführt auf 131: `go test ./mail/internal/example/... -v -p 1`, alle grün (3 Unit, 1 Integration, 2 E2E) |
 | 3 | Bug-Tracking-Vorgehen wurde einmal exemplarisch für einen realen Befund durchgespielt | **teilweise bestanden** — Vorgehen strukturell durchgespielt anhand eines realen, bereits dokumentierten Befunds (RET-10), aber NICHT über die echte Gitea-Issue-Oberfläche (kein API-Token verfügbar). Siehe Abschnitt 5, offener Punkt in Abschnitt 7 |
 ## 7. Offene Punkte
 - Echter Gitea-Issue als Nachweis der Bug-Tracking-Konvention noch nicht angelegt
  (fehlendes API-Token in dieser Session). Sollte nachgeholt werden, sobald Zugriff
  besteht.
 - `mail/internal/auth/`, `mail/internal/tenant/`, `mail/internal/ingest/` etc. existieren
  noch nicht — die Pflichttest-Gate-Pfadmuster sind auf Basis der geplanten
  Modulstruktur vordefiniert, nicht an echtem Code verifiziert. Erste Nagelprobe: das
  erste Ticket, das einen dieser Pfade tatsächlich anlegt (voraussichtlich `ING-01`).
@@ -0,0 +1,14 @@
 module gitea.perlbach24.de/scripte/nexarch/mail
 go 1.22
 require github.com/jackc/pgx/v5 v5.6.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
 )
@@ -0,0 +1,36 @@
 package example
 import (
 	"encoding/json"
 	"net/http"
 )
 // NormalizeHandler ist das E2E-Test-Beispiel (QA-01): ein echter
 // HTTP-Endpunkt, gegen den ein Test einen vollständigen Request-Response-
 // Zyklus fährt (httptest.Server, echter TCP-Roundtrip, kein reiner
 // Funktionsaufruf). Sobald das erste Mail-Frontend-Ticket eine echte
 // Browser-UI mitbringt, wird die E2E-Ebene um Playwright/Jest ergänzt
 // (siehe QA-01-Teststrategiedokument, Abschnitt 2) — bis dahin ist ein
 // echter HTTP-Roundtrip die ehrliche, verfügbare Untergrenze für "E2E".
 type normalizeRequest struct {
 	Address string `json:"address"`
 }
 type normalizeResponse struct {
 	Normalized string `json:"normalized"`
 }
 func NormalizeHandler(w http.ResponseWriter, r *http.Request) {
 	var req normalizeRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "ungültiger request-body", http.StatusBadRequest)
 		return
 	}
 	normalized, err := NormalizeAddress(req.Address)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(normalizeResponse{Normalized: normalized})
 }
@@ -0,0 +1,51 @@
 // E2E-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): echter
 // HTTP-Request über einen laufenden httptest.Server (TCP-Roundtrip),
 // nicht nur ein Funktionsaufruf im selben Prozess.
 package example
 import (
 	"bytes"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 )
 func TestNormalizeHandler_RealHTTPRoundTrip(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
 	defer server.Close()
 	body, _ := json.Marshal(normalizeRequest{Address: "Kunde@Beispiel.DE"})
 	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
 	if err != nil {
 		t.Fatalf("post: %v", err)
 	}
 	defer func() { _ = resp.Body.Close() }()
 	if resp.StatusCode != http.StatusOK {
 		t.Fatalf("status = %d, want 200", resp.StatusCode)
 	}
 	var out normalizeResponse
 	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
 		t.Fatalf("antwort dekodieren: %v", err)
 	}
 	if out.Normalized != "Kunde@beispiel.de" {
 		t.Fatalf("got %q", out.Normalized)
 	}
 }
 func TestNormalizeHandler_InvalidAddressReturns400(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
 	defer server.Close()
 	body, _ := json.Marshal(normalizeRequest{Address: "keine-gueltige-adresse"})
 	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
 	if err != nil {
 		t.Fatalf("post: %v", err)
 	}
 	defer func() { _ = resp.Body.Close() }()
 	if resp.StatusCode != http.StatusBadRequest {
 		t.Fatalf("status = %d, want 400", resp.StatusCode)
 	}
 }
@@ -0,0 +1,26 @@
 // Package example dient QA-01 (Mail): liefert je Testart (Unit,
 // Integration, E2E) genau EIN reales, lauffähiges Beispiel, an dem sich
 // spätere Mail-Tickets orientieren können — keine Wegwerf-Demo, sondern
 // eine tatsächlich nützliche, kleine Funktion (Adress-Normalisierung),
 // die spätere Ticket (z. B. ING-01/ING-04) ohnehin brauchen werden.
 package example
 import (
 	"errors"
 	"strings"
 )
 var ErrInvalidAddress = errors.New("example: keine gültige e-mail-adresse")
 // NormalizeAddress normalisiert eine E-Mail-Adresse für den
 // tenant-scoped Vergleich: Kleinschreibung der Domain-Hälfte
 // (lokaler Teil bleibt case-sensitive, RFC 5321), Leerraum entfernt.
 func NormalizeAddress(addr string) (string, error) {
 	addr = strings.TrimSpace(addr)
 	at := strings.LastIndex(addr, "@")
 	if at <= 0 || at == len(addr)-1 {
 		return "", ErrInvalidAddress
 	}
 	local, domain := addr[:at], addr[at+1:]
 	return local + "@" + strings.ToLower(domain), nil
 }
@@ -0,0 +1,38 @@
 // Unit-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): keine
 // externe Abhängigkeit (DB, Netzwerk), reine Funktionsprüfung.
 package example
 import (
 	"errors"
 	"testing"
 )
 func TestNormalizeAddress_LowercasesDomainOnly(t *testing.T) {
 	got, err := NormalizeAddress("User.Name@Example.COM")
 	if err != nil {
 		t.Fatalf("unerwarteter fehler: %v", err)
 	}
 	want := "User.Name@example.com"
 	if got != want {
 		t.Fatalf("got %q, want %q", got, want)
 	}
 }
 func TestNormalizeAddress_TrimsWhitespace(t *testing.T) {
 	got, err := NormalizeAddress("  user@example.com  ")
 	if err != nil {
 		t.Fatalf("unerwarteter fehler: %v", err)
 	}
 	if got != "user@example.com" {
 		t.Fatalf("got %q", got)
 	}
 }
 func TestNormalizeAddress_RejectsInvalidInput(t *testing.T) {
 	cases := []string{"", "no-at-sign", "@nolocalpart.com", "trailing@"}
 	for _, c := range cases {
 		if _, err := NormalizeAddress(c); !errors.Is(err, ErrInvalidAddress) {
 			t.Fatalf("input %q: erwartet ErrInvalidAddress, habe: %v", c, err)
 		}
 	}
 }
@@ -0,0 +1,42 @@
 package example
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // AddressStore ist das Integrationstest-Beispiel (QA-01): eine
 // minimale, aber echte DB-gestützte Komponente — nutzt dieselbe
 // Tenant-DB-Isolationskonvention wie DMS/Archive (t.Cleanup, geteilte
 // physische Postgres-Instanz auf dem Testhost).
 type AddressStore struct {
 	pool *pgxpool.Pool
 }
 func NewAddressStore(pool *pgxpool.Pool) *AddressStore {
 	return &AddressStore{pool: pool}
 }
 func (s *AddressStore) SaveNormalized(ctx context.Context, addr string) (string, error) {
 	normalized, err := NormalizeAddress(addr)
 	if err != nil {
 		return "", err
 	}
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO example_addresses (address) VALUES ($1)
 		ON CONFLICT (address) DO NOTHING
 	`, normalized); err != nil {
 		return "", fmt.Errorf("example: adresse speichern: %w", err)
 	}
 	return normalized, nil
 }
 func (s *AddressStore) Exists(ctx context.Context, addr string) (bool, error) {
 	var exists bool
 	if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM example_addresses WHERE address = $1)`, addr).Scan(&exists); err != nil {
 		return false, fmt.Errorf("example: existenz prüfen: %w", err)
 	}
 	return exists, nil
 }
@@ -0,0 +1,69 @@
 // Integrations-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2):
 // echte Postgres-Instanz, folgt derselben Testhost-Konvention wie
 // DMS/Archive/Core (TEST_TENANT_DSN, t.Cleanup, geteilte physische
 // Instanz auf 192.168.1.131 — siehe project-nexarch-test-infra).
 package example
 import (
 	"context"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupTest(t *testing.T) *pgxpool.Pool {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS example_addresses (
 			address TEXT PRIMARY KEY
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `TRUNCATE example_addresses`)
 	})
 	return pool
 }
 func TestAddressStore_SaveAndCheckExists(t *testing.T) {
 	pool := setupTest(t)
 	store := NewAddressStore(pool)
 	ctx := context.Background()
 	normalized, err := store.SaveNormalized(ctx, "Kunde@Beispiel.DE")
 	if err != nil {
 		t.Fatalf("savenormalized: %v", err)
 	}
 	if normalized != "Kunde@beispiel.de" {
 		t.Fatalf("erwartet normalisierte adresse, habe %q", normalized)
 	}
 	exists, err := store.Exists(ctx, normalized)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !exists {
 		t.Fatal("erwartet real gespeicherte adresse")
 	}
 	notExists, err := store.Exists(ctx, "unbekannt@beispiel.de")
 	if err != nil {
 		t.Fatal(err)
 	}
 	if notExists {
 		t.Fatal("nie gespeicherte adresse haette nicht existieren duerfen")
 	}
 }
@@ -0,0 +1,72 @@
 // Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-MAIL.md
 // Abschnitt 4 festgelegte Regel: jede geänderte Go-Datei in einem
 // sicherheitskritischen Bereich (Auth, Tenant-Scoping, Protokoll-/
 // Compliance-kritisch) muss von einer geänderten oder neuen _test.go-
 // Datei im selben Package begleitet sein. Bewusste Code-Kopie des
 // Musters aus Core internal/pflichttestgate — Mail ist ein eigenständiges
 // Go-Modul und kann Core nicht importieren.
 package pflichttestgate
 import (
 	"path"
 	"regexp"
 	"strings"
 )
 // sensitivePathPatterns beschreibt die Bereiche aus
 // TESTSTRATEGIE-MAIL.md Abschnitt 4.
 var sensitivePathPatterns = []*regexp.Regexp{
 	regexp.MustCompile(`(^|/)mail/internal/auth/`),
 	regexp.MustCompile(`(^|/)mail/internal/tenant/`),
 	regexp.MustCompile(`(^|/)mail/internal/ingest/`),
 	regexp.MustCompile(`(^|/)mail/internal/imap/`),
 	regexp.MustCompile(`(^|/)mail/internal/smtp/`),
 	regexp.MustCompile(`(^|/)mail/internal/arc/`),
 }
 // Violation beschreibt ein Package mit sicherheitskritischer Änderung
 // ohne begleitende Testdatei.
 type Violation struct {
 	Package     string
 	ChangedFile string
 }
 func isSensitive(file string) bool {
 	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
 		return false
 	}
 	for _, re := range sensitivePathPatterns {
 		if re.MatchString(file) {
 			return true
 		}
 	}
 	return false
 }
 // CheckDiff prüft eine Liste geänderter Dateipfade gegen die
 // Pflichttest-Regel — ein leeres Ergebnis bedeutet: Gate besteht.
 func CheckDiff(changedFiles []string) []Violation {
 	sensitiveByPkg := map[string]string{}
 	testTouchedPkgs := map[string]bool{}
 	for _, f := range changedFiles {
 		pkg := path.Dir(f)
 		if strings.HasSuffix(f, "_test.go") {
 			testTouchedPkgs[pkg] = true
 			continue
 		}
 		if isSensitive(f) {
 			if _, seen := sensitiveByPkg[pkg]; !seen {
 				sensitiveByPkg[pkg] = f
 			}
 		}
 	}
 	var violations []Violation
 	for pkg, file := range sensitiveByPkg {
 		if !testTouchedPkgs[pkg] {
 			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
 		}
 	}
 	return violations
 }
@@ -0,0 +1,33 @@
 // Negativtest des Gates selbst (QA-01 Prüfung 1): ein Diff mit
 // geänderter mail/internal/auth/login.go ohne begleitende Testdatei
 // muss als Verstoß erkannt werden.
 package pflichttestgate
 import "testing"
 func TestCheckDiff_FlagsSensitiveChangeWithoutTest(t *testing.T) {
 	violations := CheckDiff([]string{"mail/internal/auth/login.go"})
 	if len(violations) != 1 {
 		t.Fatalf("erwartet genau 1 verstoß, habe %d: %+v", len(violations), violations)
 	}
 	if violations[0].Package != "mail/internal/auth" {
 		t.Fatalf("falsches package gemeldet: %+v", violations[0])
 	}
 }
 func TestCheckDiff_PassesWhenTestFileAccompanies(t *testing.T) {
 	violations := CheckDiff([]string{
 		"mail/internal/auth/login.go",
 		"mail/internal/auth/login_test.go",
 	})
 	if len(violations) != 0 {
 		t.Fatalf("erwartet keine verstöße, habe: %+v", violations)
 	}
 }
 func TestCheckDiff_IgnoresNonSensitivePaths(t *testing.T) {
 	violations := CheckDiff([]string{"mail/internal/example/normalize.go"})
 	if len(violations) != 0 {
 		t.Fatalf("erwartet keine verstöße für nicht-sensiblen pfad, habe: %+v", violations)
 	}
 }
@@ -1 +0,0 @@
 DROP TABLE IF EXISTS tenants;
@@ -0,0 +1,10 @@
 -- Control-plane registry: tenant list + connection info (Modell C).
 -- Core TEN-01 (siehe core-kanban).
 CREATE TABLE tenants (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    slug         TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    db_dsn       TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1,14 +0,0 @@
 -- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
 -- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
 -- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
 CREATE EXTENSION IF NOT EXISTS pgcrypto;
 CREATE TABLE tenants (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    slug         TEXT NOT NULL UNIQUE,
    name         TEXT NOT NULL,
    db_name      TEXT NOT NULL UNIQUE,
    db_dsn       TEXT NOT NULL,
    status       TEXT NOT NULL DEFAULT 'active',
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -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()
 );
@@ -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;`