Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite

OPS-02: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)
2026-08-28 22:02:02 +02:00 · 2026-08-28 21:56:39 +02:00 · 2026-08-28 21:56:31 +02:00 · 2026-08-28 21:47:48 +02:00 · 2026-08-28 21:47:32 +02:00 · 2026-08-28 08:29:27 +02:00
42 changed files with 1646 additions and 1756 deletions
@@ -1,81 +0,0 @@
 // licadmin-devserver stellt das LIC-04-Backend-API (internal/adminapi) fuer
 // die Next.js-Verwaltungsoberflaeche bereit. Getrennt von cmd/core, da die
 // Verdrahtung von license.Validator (Ed25519-Public-Key) in die zentrale
 // Server-Topologie erst mit API-01/IAM-01 (Auth vor internen Endpunkten)
 // sinnvoll ist — dieser Server dient der Entwicklung/dem Betrieb der
 // Verwaltungsoberflaeche gegen eine echte Datenbank, ohne cmd/core
 // anzufassen (Kein Umbau angrenzender Bereiche).
 package main
 import (
 	"context"
 	"crypto/ed25519"
 	"encoding/base64"
 	"log"
 	"net/http"
 	"os"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/internal/adminapi"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/license"
 	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	pubKeyB64 := os.Getenv("NEXARCH_LICENSE_PUBLIC_KEY")
 	if pubKeyB64 == "" {
 		log.Fatal("NEXARCH_LICENSE_PUBLIC_KEY nicht gesetzt (base64, raw-url-encoding)")
 	}
 	pubKeyRaw, err := base64.RawURLEncoding.DecodeString(pubKeyB64)
 	if err != nil || len(pubKeyRaw) != ed25519.PublicKeySize {
 		log.Fatalf("NEXARCH_LICENSE_PUBLIC_KEY ungueltig: %v", err)
 	}
 	addr := os.Getenv("NEXARCH_LICADMIN_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8081"
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	licenseStore := license.NewStore(pool, license.NewValidator(ed25519.PublicKey(pubKeyRaw)))
 	flagStore := flag.NewStore(pool)
 	flagService := flag.NewService(flagStore, 5*time.Second)
 	usageStore := usage.NewStore(pool)
 	handler := adminapi.NewHandler(licenseStore, flagStore, flagService, usageStore)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/admin/overview", withCORS(handler.OverviewHandler))
 	mux.HandleFunc("/admin/flags/toggle", withCORS(handler.ToggleFlagHandler))
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("licadmin-devserver listening on %s", addr)
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
 // withCORS erlaubt lokale Entwicklung des Next.js-Frontends auf einem
 // anderen Port als das Backend-API — ausschliesslich fuer diesen
 // Entwicklungsserver, keine Produktionshaertung.
 func withCORS(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
 		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 		if r.Method == http.MethodOptions {
 			w.WriteHeader(http.StatusOK)
 			return
 		}
 		next(w, r)
 	}
 }
@@ -0,0 +1,66 @@
 // statuspage-devserver stellt das OPS-02-Backend (internal/statuspage) fuer
 // die Next.js-Statusseite bereit und startet den periodischen Poller.
 // Getrennt von cmd/core aus demselben Grund wie die anderen *-devserver.
 package main
 import (
 	"context"
 	"log"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/statuspage"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	addr := os.Getenv("NEXARCH_STATUSPAGE_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8084"
 	}
 	intervalSeconds := 10
 	if v := os.Getenv("NEXARCH_STATUSPAGE_POLL_INTERVAL_SECONDS"); v != "" {
 		if parsed, err := strconv.Atoi(v); err == nil {
 			intervalSeconds = parsed
 		}
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	store := statuspage.NewStore(pool)
 	checker := statuspage.NewHTTPChecker(2 * time.Second)
 	poller := statuspage.NewPoller(store, checker)
 	go poller.Run(ctx, time.Duration(intervalSeconds)*time.Second)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/status/overview", withCORS(store.OverviewHandler))
 	mux.HandleFunc("/status/history", withCORS(store.HistoryHandler))
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("statuspage-devserver listening on %s (poll-intervall: %ds)", addr, intervalSeconds)
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
 func withCORS(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
 		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 		if r.Method == http.MethodOptions {
 			w.WriteHeader(http.StatusOK)
 			return
 		}
 		next(w, r)
 	}
 }
@@ -1,226 +0,0 @@
 // Package adminapi implementiert Core LIC-04: das Backend-API fuer die
 // Lizenz-/Modul-Verwaltungsoberflaeche. Das Paket enthaelt KEINE eigene
 // Lizenz-/Flag-/Quota-Logik, sondern ist ein duenner Vermittler ueber
 // internal/license, internal/flag und internal/usage (Ticket-Vorgabe:
 // "Verwaltungsoberflaeche als duenner Client ... ohne eigene Lizenzlogik").
 package adminapi
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 	"strings"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/license"
 	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
 )
 // UsageMetrics sind die Metriken, die auf der Uebersichtsseite je Tenant
 // dargestellt werden (Akzeptanzkriterium 3). Neue Metriken hinzuzufuegen
 // beruehrt kein bestehendes Verhalten von internal/usage.
 var UsageMetrics = []string{"users", "storage_bytes", "api_calls"}
 // FlagOverview ist ein Flag zusammen mit der fuer den Tenant ausgewerteten
 // Berechtigung, es umzuschalten (Akzeptanzkriterium 2).
 type FlagOverview struct {
 	Key       string `json:"key"`
 	Enabled   bool   `json:"enabled"`
 	Licensed  bool   `json:"licensed"`
 	DenyGrund string `json:"deny_grund,omitempty"`
 }
 // UsageOverview ist eine Metrik mit Zaehlerstand, Quota und Status
 // (Akzeptanzkriterium 3).
 type UsageOverview struct {
 	Metric string       `json:"metric"`
 	Value  int64        `json:"value"`
 	Limit  int64        `json:"limit"`
 	Status usage.Status `json:"status"`
 }
 // Overview ist die vollstaendige Antwort fuer die Uebersichtsseite
 // (Akzeptanzkriterium 1: Lizenzstatus/Laufzeit/Module auf einen Blick).
 type Overview struct {
 	Plan       string          `json:"plan"`
 	Modules    []string        `json:"modules"`
 	IssuedAt   string          `json:"issued_at"`
 	ValidUntil string          `json:"valid_until"`
 	Expired    bool            `json:"expired"`
 	Flags      []FlagOverview  `json:"flags"`
 	Usage      []UsageOverview `json:"usage"`
 }
 // ErrFlagNotLicensed wird geliefert, wenn ein Administrator versucht, ein
 // Flag zu aktivieren, dessen zugehoeriges Modul die Lizenz nicht umfasst
 // (Akzeptanzkriterium 2 / Pruefung 1).
 var ErrFlagNotLicensed = errors.New("adminapi: modul ist durch die aktuelle lizenz nicht freigeschaltet")
 // Handler buendelt die drei Vorbedingungs-Dienste hinter einem gemeinsamen
 // HTTP-API fuer das Frontend.
 type Handler struct {
 	licenseStore *license.Store
 	flagStore    *flag.Store
 	flagService  *flag.Service
 	usageStore   *usage.Store
 }
 func NewHandler(licenseStore *license.Store, flagStore *flag.Store, flagService *flag.Service, usageStore *usage.Store) *Handler {
 	return &Handler{licenseStore: licenseStore, flagStore: flagStore, flagService: flagService, usageStore: usageStore}
 }
 // isModuleLicensed prueft, ob ein Flag-Schluessel als lizenziertes Modul
 // gilt. Konvention: ein Flag-Key der Form "module:<name>" ist an das
 // gleichnamige Modul in Payload.Modules gebunden; alle anderen Flag-Keys
 // gelten als lizenzunabhaengige, rein funktionale Schalter.
 func isModuleLicensed(key string, modules []string) (moduleName string, isModuleFlag bool, licensed bool) {
 	const prefix = "module:"
 	if !strings.HasPrefix(key, prefix) {
 		return "", false, true
 	}
 	moduleName = strings.TrimPrefix(key, prefix)
 	for _, m := range modules {
 		if m == moduleName {
 			return moduleName, true, true
 		}
 	}
 	return moduleName, true, false
 }
 // Overview liefert die kombinierte Uebersicht fuer einen Tenant
 // (Akzeptanzkriterium 1 + 3).
 func (h *Handler) Overview(ctx context.Context, tenantID string) (Overview, error) {
 	lic, err := h.licenseStore.Status(ctx, tenantID)
 	if err != nil {
 		return Overview{}, fmt.Errorf("lizenzstatus lesen: %w", err)
 	}
 	_, expiredErr := h.licenseStore.RequireActive(ctx, tenantID)
 	expired := errors.Is(expiredErr, license.ErrLicenseExpired)
 	flags, err := h.flagStore.List(ctx)
 	if err != nil {
 		return Overview{}, fmt.Errorf("flags lesen: %w", err)
 	}
 	tenantSlug := tenantID // Auswertung erwartet den Tenant-Bezug als String; Aufloesung ID->Slug obliegt dem Aufrufer (siehe Handler-Tests).
 	flagOverviews := make([]FlagOverview, 0, len(flags))
 	for _, f := range flags {
 		_, _, licensed := isModuleLicensed(f.Key, lic.Modules)
 		fo := FlagOverview{
 			Key:      f.Key,
 			Enabled:  h.flagService.IsEnabled(ctx, tenantSlug, f.Key),
 			Licensed: licensed,
 		}
 		if !licensed {
 			fo.DenyGrund = "Modul ist im aktuellen Lizenzplan nicht enthalten"
 		}
 		flagOverviews = append(flagOverviews, fo)
 	}
 	usageOverviews := make([]UsageOverview, 0, len(UsageMetrics))
 	for _, metric := range UsageMetrics {
 		value, limit, status, err := h.usageStore.Check(ctx, tenantID, metric)
 		if err != nil {
 			return Overview{}, fmt.Errorf("nutzungsstand lesen (%s): %w", metric, err)
 		}
 		usageOverviews = append(usageOverviews, UsageOverview{
 			Metric: metric, Value: value, Limit: limit, Status: status,
 		})
 	}
 	return Overview{
 		Plan:       lic.Plan,
 		Modules:    lic.Modules,
 		IssuedAt:   lic.IssuedAt.Format("2006-01-02T15:04:05Z07:00"),
 		ValidUntil: lic.ValidUntil.Format("2006-01-02T15:04:05Z07:00"),
 		Expired:    expired,
 		Flags:      flagOverviews,
 		Usage:      usageOverviews,
 	}, nil
 }
 // ToggleFlag schaltet ein Flag global an/aus, NACHDEM geprueft wurde, dass
 // das zugehoerige Modul lizenziert ist (Akzeptanzkriterium 2 / Pruefung 1).
 // Ein nicht lizenziertes Modul wird mit ErrFlagNotLicensed abgelehnt, bevor
 // irgendein Schreibzugriff erfolgt.
 func (h *Handler) ToggleFlag(ctx context.Context, tenantID, key string, enabled bool) error {
 	lic, err := h.licenseStore.Status(ctx, tenantID)
 	if err != nil {
 		return fmt.Errorf("lizenzstatus lesen: %w", err)
 	}
 	if enabled {
 		if _, _, licensed := isModuleLicensed(key, lic.Modules); !licensed {
 			return ErrFlagNotLicensed
 		}
 	}
 	existing, err := h.flagStore.Get(ctx, key)
 	if err != nil && !errors.Is(err, flag.ErrNotFound) {
 		return fmt.Errorf("flag lesen: %w", err)
 	}
 	existing.Key = key
 	existing.Enabled = enabled
 	if err := h.flagStore.Set(ctx, existing); err != nil {
 		return fmt.Errorf("flag speichern: %w", err)
 	}
 	h.flagService.Invalidate(key)
 	return nil
 }
 // --- HTTP-Bindung ---
 func (h *Handler) OverviewHandler(w http.ResponseWriter, r *http.Request) {
 	tenantID := r.URL.Query().Get("tenant")
 	if tenantID == "" {
 		writeError(w, http.StatusBadRequest, "tenant-parameter fehlt")
 		return
 	}
 	overview, err := h.Overview(r.Context(), tenantID)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	writeJSON(w, http.StatusOK, overview)
 }
 type toggleRequest struct {
 	Tenant  string `json:"tenant"`
 	Key     string `json:"key"`
 	Enabled bool   `json:"enabled"`
 }
 func (h *Handler) ToggleFlagHandler(w http.ResponseWriter, r *http.Request) {
 	var req toggleRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
 		return
 	}
 	if req.Tenant == "" || req.Key == "" {
 		writeError(w, http.StatusBadRequest, "tenant und key sind erforderlich")
 		return
 	}
 	err := h.ToggleFlag(r.Context(), req.Tenant, req.Key, req.Enabled)
 	switch {
 	case err == nil:
 		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
 	case errors.Is(err, ErrFlagNotLicensed):
 		writeError(w, http.StatusForbidden, ErrFlagNotLicensed.Error())
 	default:
 		writeError(w, http.StatusInternalServerError, err.Error())
 	}
 }
 func writeJSON(w http.ResponseWriter, status int, body any) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(status)
 	_ = json.NewEncoder(w).Encode(body)
 }
 func writeError(w http.ResponseWriter, status int, message string) {
 	writeJSON(w, status, map[string]string{"error": message})
 }
@@ -1,275 +0,0 @@
 package adminapi
 import (
 	"bytes"
 	"context"
 	"crypto/ed25519"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/license"
 	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
 )
 type testEnv struct {
 	handler  *Handler
 	tenantID string
 	pool     *pgxpool.Pool
 }
 func setupTest(t *testing.T) (testEnv, 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 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()
 		);
 		CREATE TABLE IF NOT EXISTS tenant_licenses (
 			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
 			plan TEXT NOT NULL,
 			modules TEXT[] NOT NULL,
 			issued_at TIMESTAMPTZ NOT NULL,
 			valid_until TIMESTAMPTZ NOT NULL,
 			raw_key TEXT NOT NULL,
 			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY,
 			enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0,
 			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS usage_counters (
 			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
 		);
 		CREATE TABLE IF NOT EXISTS usage_quotas (
 			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
 			PRIMARY KEY (tenant_id, metric)
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	slug := fmt.Sprintf("adminapi_test_%d", time.Now().UnixNano())
 	var tenantID string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO tenants (slug, name, db_name, db_dsn)
 		VALUES ($1, 'Adminapi Test', $1, 'unused') RETURNING id
 	`, slug).Scan(&tenantID); err != nil {
 		t.Fatalf("test-tenant anlegen: %v", err)
 	}
 	pub, priv, err := ed25519.GenerateKey(nil)
 	if err != nil {
 		t.Fatalf("schluesselpaar: %v", err)
 	}
 	issuer := license.NewIssuer(priv)
 	licenseStore := license.NewStore(pool, license.NewValidator(pub))
 	payload := license.Payload{
 		TenantSlug: slug,
 		Plan:       "professional",
 		Modules:    []string{"dms", "mail"},
 		IssuedAt:   time.Now().Truncate(time.Second),
 		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
 	}
 	key, err := issuer.Issue(payload)
 	if err != nil {
 		t.Fatalf("lizenz ausstellen: %v", err)
 	}
 	if _, err := licenseStore.Install(ctx, tenantID, key); err != nil {
 		t.Fatalf("lizenz installieren: %v", err)
 	}
 	flagStore := flag.NewStore(pool)
 	flagService := flag.NewService(flagStore, time.Millisecond) // sehr kurze TTL, damit Tests nicht auf Cache-Ablauf warten muessen
 	usageStore := usage.NewStore(pool)
 	handler := NewHandler(licenseStore, flagStore, flagService, usageStore)
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM usage_quotas WHERE tenant_id = $1`, tenantID)
 		_, _ = pool.Exec(ctx, `DELETE FROM usage_counters WHERE tenant_id = $1`, tenantID)
 		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`)
 		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
 		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'adminapi\_test\_%' ESCAPE '\'`)
 		pool.Close()
 	}
 	return testEnv{handler: handler, tenantID: tenantID, pool: pool}, cleanup
 }
 // Akzeptanzkriterium 1: Lizenzstatus, Laufzeit und Module sind auf einen
 // Blick abfragbar.
 func TestOverview_ShowsLicenseStatusAndModules(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	overview, err := env.handler.Overview(ctx, env.tenantID)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	if overview.Plan != "professional" {
 		t.Fatalf("plan = %q, want professional", overview.Plan)
 	}
 	if len(overview.Modules) != 2 {
 		t.Fatalf("module = %v, want 2 eintraege", overview.Modules)
 	}
 	if overview.Expired {
 		t.Fatal("lizenz sollte nicht abgelaufen sein")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Umschalten eines nicht lizenzierten
 // Features wird verhindert und verstaendlich begruendet.
 func TestToggleFlag_RejectsUnlicensedModule(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	err := env.handler.ToggleFlag(ctx, env.tenantID, "module:archive", true)
 	if err == nil {
 		t.Fatal("erwartet fehler beim aktivieren eines nicht lizenzierten moduls")
 	}
 	if err.Error() == "" {
 		t.Fatal("fehlermeldung sollte verstaendlich sein, nicht leer")
 	}
 	t.Logf("erhaltene begruendung: %v", err)
 	// Sicherstellen, dass NICHTS geschrieben wurde: Flag existiert weiterhin nicht.
 	if _, ferr := flag.NewStore(env.pool).Get(ctx, "module:archive"); ferr == nil {
 		t.Fatal("flag haette wegen fehlender lizenz nicht angelegt werden duerfen")
 	}
 }
 // Akzeptanzkriterium 2: lizenziertes Modul laesst sich umschalten.
 func TestToggleFlag_AllowsLicensedModule(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := env.handler.ToggleFlag(ctx, env.tenantID, "module:dms", true); err != nil {
 		t.Fatalf("erwartet erfolg fuer lizenziertes modul, habe: %v", err)
 	}
 	overview, err := env.handler.Overview(ctx, env.tenantID)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	found := false
 	for _, f := range overview.Flags {
 		if f.Key == "module:dms" {
 			found = true
 			if !f.Enabled || !f.Licensed {
 				t.Fatalf("flag-status unerwartet: %+v", f)
 			}
 		}
 	}
 	if !found {
 		t.Fatal("erwartet 'module:dms' in der uebersicht nach dem umschalten")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 2: Nutzungsstand stimmt mit den
 // Backend-Zaehlern ueberein.
 func TestOverview_UsageMatchesBackendCounters(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	usageStore := usage.NewStore(env.pool)
 	if err := usageStore.Increment(ctx, env.tenantID, "users", 7); err != nil {
 		t.Fatalf("increment: %v", err)
 	}
 	if err := usageStore.SetQuota(ctx, env.tenantID, "users", 10); err != nil {
 		t.Fatalf("setquota: %v", err)
 	}
 	overview, err := env.handler.Overview(ctx, env.tenantID)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	var got *UsageOverview
 	for i := range overview.Usage {
 		if overview.Usage[i].Metric == "users" {
 			got = &overview.Usage[i]
 		}
 	}
 	if got == nil {
 		t.Fatal("erwartet metrik 'users' in der uebersicht")
 	}
 	if got.Value != 7 || got.Limit != 10 || got.Status != usage.StatusOK {
 		t.Fatalf("nutzungsstand stimmt nicht mit backend-zaehler ueberein: %+v (want value=7 limit=10 status=ok, da 7/10=70%% unter der 80%%-warnschwelle liegt)", got)
 	}
 }
 // Akzeptanzkriterium 2 / Pruefung 1 auf HTTP-Ebene: der Endpunkt liefert
 // 403 mit verstaendlicher Fehlermeldung, kein interner Serverfehler.
 func TestToggleFlagHandler_HTTPForbiddenOnUnlicensed(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	body, _ := json.Marshal(toggleRequest{Tenant: env.tenantID, Key: "module:archive", Enabled: true})
 	req := httptest.NewRequest(http.MethodPost, "/admin/flags/toggle", bytes.NewReader(body))
 	rec := httptest.NewRecorder()
 	env.handler.ToggleFlagHandler(rec, req)
 	if rec.Code != http.StatusForbidden {
 		t.Fatalf("status = %d, want 403", rec.Code)
 	}
 	var resp map[string]string
 	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
 		t.Fatalf("body parsen: %v", err)
 	}
 	if resp["error"] == "" {
 		t.Fatal("erwartet verstaendliche fehlermeldung im response-body")
 	}
 }
 func TestOverviewHandler_HTTPReturnsCombinedData(t *testing.T) {
 	env, cleanup := setupTest(t)
 	defer cleanup()
 	req := httptest.NewRequest(http.MethodGet, "/admin/overview?tenant="+env.tenantID, nil)
 	rec := httptest.NewRecorder()
 	env.handler.OverviewHandler(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200", rec.Code)
 	}
 	var overview Overview
 	if err := json.Unmarshal(rec.Body.Bytes(), &overview); err != nil {
 		t.Fatalf("body parsen: %v", err)
 	}
 	if overview.Plan != "professional" {
 		t.Fatalf("plan = %q, want professional", overview.Plan)
 	}
 }
@@ -50,29 +50,6 @@ func (s *Store) Set(ctx context.Context, f Flag) error {
 	return nil
 }
 // List liefert alle definierten Flags (Admin-Uebersicht, siehe LIC-04) —
 // rein additiv, aendert nichts am bestehenden Verhalten von Set/Get.
 func (s *Store) List(ctx context.Context) ([]Flag, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT key, enabled, rollout_percentage, target_tenant_slugs
 		FROM feature_flags ORDER BY key
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("flags auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Flag
 	for rows.Next() {
 		var f Flag
 		if err := rows.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
 			return nil, fmt.Errorf("flag-zeile lesen: %w", err)
 		}
 		out = append(out, f)
 	}
 	return out, rows.Err()
 }
 func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
 	var f Flag
 	row := s.pool.QueryRow(ctx, `
@@ -0,0 +1,25 @@
 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
 	}
 }
@@ -0,0 +1,49 @@
 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)
 }
@@ -0,0 +1,86 @@
 // 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
 }
@@ -0,0 +1,161 @@
 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,106 +0,0 @@
 // Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
 // Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
 // Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
 // Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
 // — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
 // klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
 package license
 import (
 	"crypto/ed25519"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
 )
 var (
 	ErrInvalidSignature = errors.New("license: signatur ungueltig")
 	ErrMalformedKey     = errors.New("license: lizenzschluessel hat ungueltiges format")
 )
 // Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
 // Modul-Liste, Laufzeit).
 type Payload struct {
 	TenantSlug string    `json:"tenant_slug"`
 	Plan       string    `json:"plan"`
 	Modules    []string  `json:"modules"`
 	IssuedAt   time.Time `json:"issued_at"`
 	ValidUntil time.Time `json:"valid_until"`
 }
 // Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
 // Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
 // laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
 // Schluessel braucht).
 type Issuer struct {
 	priv ed25519.PrivateKey
 }
 func NewIssuer(priv ed25519.PrivateKey) *Issuer {
 	return &Issuer{priv: priv}
 }
 // Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
 func (i *Issuer) Issue(payload Payload) (string, error) {
 	raw, err := json.Marshal(payload)
 	if err != nil {
 		return "", fmt.Errorf("payload serialisieren: %w", err)
 	}
 	sig := ed25519.Sign(i.priv, raw)
 	return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
 }
 // Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
 // — das ist alles, was der laufende Core-Prozess kennen muss.
 type Validator struct {
 	pub ed25519.PublicKey
 }
 func NewValidator(pub ed25519.PublicKey) *Validator {
 	return &Validator{pub: pub}
 }
 // Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
 // bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
 // hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
 // waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
 // (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
 func (v *Validator) Parse(key string) (Payload, error) {
 	rawPart, sigPart, ok := splitOnce(key, '.')
 	if !ok {
 		return Payload{}, ErrMalformedKey
 	}
 	raw, err := base64.RawURLEncoding.DecodeString(rawPart)
 	if err != nil {
 		return Payload{}, ErrMalformedKey
 	}
 	sig, err := base64.RawURLEncoding.DecodeString(sigPart)
 	if err != nil {
 		return Payload{}, ErrMalformedKey
 	}
 	if !ed25519.Verify(v.pub, raw, sig) {
 		return Payload{}, ErrInvalidSignature
 	}
 	var p Payload
 	if err := json.Unmarshal(raw, &p); err != nil {
 		// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
 		// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
 		return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
 	}
 	return p, nil
 }
 func splitOnce(s string, sep byte) (before, after string, ok bool) {
 	for i := 0; i < len(s); i++ {
 		if s[i] == sep {
 			return s[:i], s[i+1:], true
 		}
 	}
 	return "", "", false
 }
@@ -1,106 +0,0 @@
 package license
 import (
 	"crypto/ed25519"
 	"errors"
 	"testing"
 	"time"
 )
 func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
 	t.Helper()
 	pub, priv, err := ed25519.GenerateKey(nil)
 	if err != nil {
 		t.Fatalf("schluesselpaar erzeugen: %v", err)
 	}
 	return pub, priv
 }
 func TestIssueAndParse_RoundTrip(t *testing.T) {
 	pub, priv := testKeyPair(t)
 	issuer := NewIssuer(priv)
 	validator := NewValidator(pub)
 	payload := Payload{
 		TenantSlug: "acme",
 		Plan:       "pro",
 		Modules:    []string{"dms", "mail"},
 		IssuedAt:   time.Now().Truncate(time.Second),
 		ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
 	}
 	key, err := issuer.Issue(payload)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	got, err := validator.Parse(key)
 	if err != nil {
 		t.Fatalf("parse: %v", err)
 	}
 	if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
 		t.Fatalf("payload nach parse unerwartet: %+v", got)
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
 func TestParse_RejectsTamperedKey(t *testing.T) {
 	pub, priv := testKeyPair(t)
 	issuer := NewIssuer(priv)
 	validator := NewValidator(pub)
 	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	// Ein Zeichen im signierten Teil aendern.
 	tampered := []byte(key)
 	changed := false
 	for i, c := range tampered {
 		if c != '.' {
 			if c == 'A' {
 				tampered[i] = 'B'
 			} else {
 				tampered[i] = 'A'
 			}
 			changed = true
 			break
 		}
 	}
 	if !changed {
 		t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
 	}
 	if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
 		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
 	}
 }
 func TestParse_RejectsWrongKeyPair(t *testing.T) {
 	_, priv := testKeyPair(t)
 	otherPub, _ := testKeyPair(t)
 	issuer := NewIssuer(priv)
 	validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
 	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
 		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
 	}
 }
 func TestParse_RejectsMalformedKey(t *testing.T) {
 	pub, _ := testKeyPair(t)
 	validator := NewValidator(pub)
 	cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
 	for _, c := range cases {
 		if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
 			t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
 		}
 	}
 }
@@ -1,88 +0,0 @@
 package license
 import (
 	"context"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrNoLicense      = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
 	ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
 )
 // Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
 // (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
 // unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
 // erweitern).
 type Store struct {
 	pool      *pgxpool.Pool
 	validator *Validator
 }
 func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
 	return &Store{pool: pool, validator: validator}
 }
 // Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
 // und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
 // bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
 // gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
 // bewertet, nicht beim Einspielen.
 func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
 	payload, err := s.validator.Parse(licenseKey)
 	if err != nil {
 		return Payload{}, err
 	}
 	_, err = s.pool.Exec(ctx, `
 		INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
 		VALUES ($1, $2, $3, $4, $5, $6, now())
 		ON CONFLICT (tenant_id) DO UPDATE SET
 			plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
 	`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
 	if err != nil {
 		return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
 	}
 	return payload, nil
 }
 func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
 	var p Payload
 	row := s.pool.QueryRow(ctx, `
 		SELECT plan, modules, issued_at, valid_until
 		FROM tenant_licenses WHERE tenant_id = $1
 	`, tenantID)
 	if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Payload{}, ErrNoLicense
 		}
 		return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
 	}
 	return p, nil
 }
 // Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
 // (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
 func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
 	return s.get(ctx, tenantID)
 }
 // RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
 // abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
 // (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
 // Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
 func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
 	p, err := s.get(ctx, tenantID)
 	if err != nil {
 		return Payload{}, err
 	}
 	if time.Now().After(p.ValidUntil) {
 		return Payload{}, ErrLicenseExpired
 	}
 	return p, nil
 }
@@ -1,177 +0,0 @@
 package license
 import (
 	"context"
 	"crypto/ed25519"
 	"errors"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS 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()
 		);
 		CREATE TABLE IF NOT EXISTS tenant_licenses (
 			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
 			plan TEXT NOT NULL,
 			modules TEXT[] NOT NULL,
 			issued_at TIMESTAMPTZ NOT NULL,
 			valid_until TIMESTAMPTZ NOT NULL,
 			raw_key TEXT NOT NULL,
 			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	var tenantID string
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO tenants (slug, name, db_name, db_dsn)
 		VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
 		RETURNING id
 	`).Scan(&tenantID); err != nil {
 		t.Fatalf("test-tenant anlegen: %v", err)
 	}
 	pub, priv, err := ed25519.GenerateKey(nil)
 	if err != nil {
 		t.Fatalf("schluesselpaar: %v", err)
 	}
 	issuer := NewIssuer(priv)
 	store := NewStore(pool, NewValidator(pub))
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
 		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
 		pool.Close()
 	}
 	return store, issuer, tenantID, cleanup
 }
 // Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
 func TestStore_InstallAndStatus(t *testing.T) {
 	store, issuer, tenantID, cleanup := setupStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	payload := Payload{
 		TenantSlug: "lic_test_tenant",
 		Plan:       "enterprise",
 		Modules:    []string{"dms", "mail", "archive"},
 		IssuedAt:   time.Now().Truncate(time.Second),
 		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
 	}
 	key, err := issuer.Issue(payload)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := store.Install(ctx, tenantID, key); err != nil {
 		t.Fatalf("install: %v", err)
 	}
 	status, err := store.Status(ctx, tenantID)
 	if err != nil {
 		t.Fatalf("status: %v", err)
 	}
 	if status.Plan != "enterprise" || len(status.Modules) != 3 {
 		t.Fatalf("status unerwartet: %+v", status)
 	}
 }
 func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
 	store, _, tenantID, cleanup := setupStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	_, otherPriv, _ := ed25519.GenerateKey(nil)
 	foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
 	key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
 		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
 // eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
 func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
 	store, issuer, tenantID, cleanup := setupStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	expired := Payload{
 		TenantSlug: "lic_test_tenant",
 		Plan:       "pro",
 		Modules:    []string{"dms"},
 		IssuedAt:   time.Now().Add(-48 * time.Hour),
 		ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
 	}
 	key, err := issuer.Issue(expired)
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
 	// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
 	if _, err := store.Install(ctx, tenantID, key); err != nil {
 		t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
 	}
 	func() {
 		defer func() {
 			if r := recover(); r != nil {
 				t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
 			}
 		}()
 		if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
 			t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
 		}
 	}()
 	// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
 	status, err := store.Status(ctx, tenantID)
 	if err != nil {
 		t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
 	}
 	if status.Plan != "pro" {
 		t.Fatalf("status unerwartet: %+v", status)
 	}
 }
 func TestStore_RequireActive_NoLicense(t *testing.T) {
 	store, _, tenantID, cleanup := setupStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
 		t.Fatalf("erwartet ErrNoLicense, habe %v", err)
 	}
 }
@@ -0,0 +1,99 @@
 package moduleregistry
 import (
 	"context"
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/subtle"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 )
 var (
 	ErrModuleNotRegistered = errors.New("moduleregistry: modul muss vor provisionierung registriert sein")
 	ErrInvalidCredential   = errors.New("moduleregistry: ungueltiges oder fehlendes service-credential")
 )
 // Provision stellt ein Service-Credential (Client-ID + Secret) fuer eine
 // Modul-Instanz aus (Akzeptanzkriterium 4). Das Secret wird NUR beim
 // Ausstellen im Klartext zurueckgegeben, gespeichert wird ausschliesslich
 // dessen SHA-256-Hash.
 func (r *Registry) Provision(ctx context.Context, moduleName string) (clientID, secret string, err error) {
 	if _, err := r.Get(ctx, moduleName); err != nil {
 		if errors.Is(err, ErrModuleNotFound) {
 			return "", "", ErrModuleNotRegistered
 		}
 		return "", "", err
 	}
 	clientID, err = randomToken(16)
 	if err != nil {
 		return "", "", fmt.Errorf("client-id erzeugen: %w", err)
 	}
 	secret, err = randomToken(32)
 	if err != nil {
 		return "", "", fmt.Errorf("secret erzeugen: %w", err)
 	}
 	hash := hashSecret(secret)
 	_, err = r.pool.Exec(ctx, `
 		INSERT INTO module_credentials (module_name, client_id, secret_hash, issued_at)
 		VALUES ($1, $2, $3, now())
 		ON CONFLICT (module_name) DO UPDATE SET client_id = $2, secret_hash = $3, issued_at = now()
 	`, moduleName, clientID, hash)
 	if err != nil {
 		return "", "", fmt.Errorf("credential speichern: %w", err)
 	}
 	return clientID, secret, nil
 }
 // Authenticate prueft ein Service-Credential timing-safe (Referenzmuster
 // siehe AUD-02) — Aufrufe ohne gueltiges Credential werden abgelehnt
 // (Akzeptanzkriterium 4 / Pruefung 4).
 func (r *Registry) Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error) {
 	if clientID == "" || secret == "" {
 		return "", false, nil
 	}
 	var storedHash []byte
 	err = r.pool.QueryRow(ctx, `
 		SELECT module_name, secret_hash FROM module_credentials WHERE client_id = $1
 	`, clientID).Scan(&moduleName, &storedHash)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return "", false, nil
 		}
 		return "", false, fmt.Errorf("credential lesen: %w", err)
 	}
 	if !timingSafeEqual(hashSecret(secret), storedHash) {
 		return "", false, nil
 	}
 	return moduleName, true, nil
 }
 func randomToken(n int) (string, error) {
 	buf := make([]byte, n)
 	if _, err := rand.Read(buf); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf), nil
 }
 func hashSecret(secret string) []byte {
 	sum := sha256.Sum256([]byte(secret))
 	return sum[:]
 }
 // timingSafeEqual folgt derselben Referenzimplementierung wie AUD-02
 // (subtle.ConstantTimeCompare) — projektweite Konvention fuer jeden
 // sicherheitsrelevanten Vergleich.
 func timingSafeEqual(a, b []byte) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	return subtle.ConstantTimeCompare(a, b) == 1
 }
@@ -0,0 +1,46 @@
 package moduleregistry
 import "net/http"
 // RequireActiveModule weist Anfragen an ein nicht aktiviertes Modul ZENTRAL
 // ab, bevor der eigentliche Modul-Handler erreicht wird (Akzeptanzkriterium 2 /
 // Pruefung 1) — Casbin-Prinzip: Durchsetzung als Middleware statt verstreuter
 // Pruefungen in jedem Handler. tenantSlug/moduleName werden hier ueber
 // Query-Parameter gelesen (echte Extraktion aus JWT/Tenant-Kontext ist
 // API-05/TEN-06, nicht Teil dieser Kachel).
 func (r *Registry) RequireActiveModule(moduleName string, next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		tenantSlug := req.URL.Query().Get("tenant")
 		active, err := r.IsActive(req.Context(), tenantSlug, moduleName)
 		if err != nil {
 			http.Error(w, "aktivierungspruefung fehlgeschlagen", http.StatusInternalServerError)
 			return
 		}
 		if !active {
 			http.Error(w, "modul nicht aktiviert", http.StatusForbidden)
 			return
 		}
 		next(w, req)
 	}
 }
 // RequireServiceCredential authentifiziert eine Modul-Instanz ueber ihr
 // Service-Credential (X-Client-Id/X-Client-Secret-Header) BEVOR der
 // eigentliche Handler erreicht wird (Akzeptanzkriterium 4 / Pruefung 4).
 func (r *Registry) RequireServiceCredential(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, req *http.Request) {
 		clientID := req.Header.Get("X-Client-Id")
 		secret := req.Header.Get("X-Client-Secret")
 		_, ok, err := r.Authenticate(req.Context(), clientID, secret)
 		if err != nil {
 			http.Error(w, "authentifizierung fehlgeschlagen", http.StatusInternalServerError)
 			return
 		}
 		if !ok {
 			http.Error(w, ErrInvalidCredential.Error(), http.StatusUnauthorized)
 			return
 		}
 		next(w, req)
 	}
 }
@@ -0,0 +1,120 @@
 // Package moduleregistry implementiert Core API-02: die Registry, in der
 // sich Fachmodule (DMS, Mail, weitere) mit Metadaten eintragen, gekoppelt an
 // die Aktivierungspruefung aus LIC-02 (Feature-Flags). Zusaetzlich
 // authentifiziert die Registry Modul-Instanzen selbst ueber ein bei
 // Provisionierung ausgestelltes Service-Credential.
 package moduleregistry
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 )
 var (
 	ErrMissingName    = errors.New("moduleregistry: name darf nicht leer sein")
 	ErrMissingVersion = errors.New("moduleregistry: version darf nicht leer sein")
 	ErrModuleNotFound = errors.New("moduleregistry: modul nicht registriert")
 )
 type Module struct {
 	Name          string
 	Version       string
 	RequiredFlags []string
 }
 type Registry struct {
 	pool  *pgxpool.Pool
 	flags *flag.Service
 }
 func NewRegistry(pool *pgxpool.Pool, flags *flag.Service) *Registry {
 	return &Registry{pool: pool, flags: flags}
 }
 // Register traegt ein Modul mit Name, Version und benoetigten Feature-Flags
 // ein (Akzeptanzkriterium 1). Fehlende Pflichtangaben werden abgewiesen
 // (Akzeptanzkriterium 1 / Pruefung 2). Erneutes Register desselben Namens
 // aktualisiert Version/Flags (Redeploy-Fall).
 func (r *Registry) Register(ctx context.Context, name, version string, requiredFlags []string) (Module, error) {
 	if name == "" {
 		return Module{}, ErrMissingName
 	}
 	if version == "" {
 		return Module{}, ErrMissingVersion
 	}
 	if requiredFlags == nil {
 		requiredFlags = []string{}
 	}
 	_, err := r.pool.Exec(ctx, `
 		INSERT INTO modules (name, version, required_flags, registered_at)
 		VALUES ($1, $2, $3, now())
 		ON CONFLICT (name) DO UPDATE SET version = $2, required_flags = $3, registered_at = now()
 	`, name, version, requiredFlags)
 	if err != nil {
 		return Module{}, fmt.Errorf("modul registrieren: %w", err)
 	}
 	return Module{Name: name, Version: version, RequiredFlags: requiredFlags}, nil
 }
 func (r *Registry) Get(ctx context.Context, name string) (Module, error) {
 	var m Module
 	m.Name = name
 	err := r.pool.QueryRow(ctx, `
 		SELECT version, required_flags FROM modules WHERE name = $1
 	`, name).Scan(&m.Version, &m.RequiredFlags)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Module{}, ErrModuleNotFound
 		}
 		return Module{}, fmt.Errorf("modul lesen: %w", err)
 	}
 	return m, nil
 }
 // List liefert alle registrierten Module (Akzeptanzkriterium 3: ueber API
 // abfragbar, z.B. fuer Statusseite/Lizenzoberflaeche).
 func (r *Registry) List(ctx context.Context) ([]Module, error) {
 	rows, err := r.pool.Query(ctx, `SELECT name, version, required_flags FROM modules ORDER BY name`)
 	if err != nil {
 		return nil, fmt.Errorf("module auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Module
 	for rows.Next() {
 		var m Module
 		if err := rows.Scan(&m.Name, &m.Version, &m.RequiredFlags); err != nil {
 			return nil, fmt.Errorf("modul lesen: %w", err)
 		}
 		out = append(out, m)
 	}
 	return out, rows.Err()
 }
 // IsActive prueft, ob ein registriertes Modul fuer einen Tenant aktiviert
 // ist: registriert UND alle benoetigten Feature-Flags sind fuer diesen
 // Tenant aktiv (Akzeptanzkriterium 2). Ein nicht registriertes Modul gilt
 // immer als nicht aktiv.
 func (r *Registry) IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error) {
 	m, err := r.Get(ctx, moduleName)
 	if err != nil {
 		if errors.Is(err, ErrModuleNotFound) {
 			return false, nil
 		}
 		return false, err
 	}
 	for _, flagKey := range m.RequiredFlags {
 		if !r.flags.IsEnabled(ctx, tenantSlug, flagKey) {
 			return false, nil
 		}
 	}
 	return true, nil
 }
@@ -0,0 +1,304 @@
 package moduleregistry
 import (
 	"context"
 	"errors"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 )
 func setupTest(t *testing.T) (*Registry, *flag.Store, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS modules (
 			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
 			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS module_credentials (
 			module_name TEXT PRIMARY KEY REFERENCES modules(name),
 			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
 			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	flagStore := flag.NewStore(pool)
 	// Kurze TTL, damit Tests, die den Flag-Store direkt aendern (an
 	// Registry.IsActive vorbei), den neuen Stand ohne manuelles Invalidate
 	// zuverlaessig sehen.
 	flagService := flag.NewService(flagStore, 10*time.Millisecond)
 	registry := NewRegistry(pool, flagService)
 	cleanup := func() { pool.Close() }
 	return registry, flagStore, cleanup
 }
 func uniqueModuleName(t *testing.T) string {
 	return fmt.Sprintf("dms_%d", time.Now().UnixNano())
 }
 // Akzeptanzkriterium 1 + Pruefung 2: fehlende Pflichtangaben abgewiesen.
 func TestRegister_RejectsMissingFields(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := registry.Register(ctx, "", "1.0", nil); !errors.Is(err, ErrMissingName) {
 		t.Fatalf("erwartet ErrMissingName, habe %v", err)
 	}
 	if _, err := registry.Register(ctx, "dms", "", nil); !errors.Is(err, ErrMissingVersion) {
 		t.Fatalf("erwartet ErrMissingVersion, habe %v", err)
 	}
 }
 func TestRegister_AndGet(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueModuleName(t)
 	m, err := registry.Register(ctx, name, "1.2.0", []string{"dms_enabled"})
 	if err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	if m.Version != "1.2.0" || len(m.RequiredFlags) != 1 {
 		t.Fatalf("unerwartet: %+v", m)
 	}
 	got, err := registry.Get(ctx, name)
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if got.Version != "1.2.0" {
 		t.Fatalf("get version = %q", got.Version)
 	}
 }
 // Akzeptanzkriterium 2 + 3 + Pruefung 3: konsistente Daten nach
 // Aktivierung/Deaktivierung eines Moduls.
 func TestIsActive_ReflectsFlagStateConsistently(t *testing.T) {
 	registry, flagStore, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueModuleName(t)
 	flagKey := name + "_enabled"
 	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	active, err := registry.IsActive(ctx, "acme", name)
 	if err != nil {
 		t.Fatalf("is active (vor flag): %v", err)
 	}
 	if active {
 		t.Fatal("erwartet nicht aktiv, solange flag nicht gesetzt ist")
 	}
 	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
 		t.Fatalf("flag setzen: %v", err)
 	}
 	time.Sleep(20 * time.Millisecond) // TTL abwarten
 	active, err = registry.IsActive(ctx, "acme", name)
 	if err != nil {
 		t.Fatalf("is active (nach flag an): %v", err)
 	}
 	if !active {
 		t.Fatal("erwartet aktiv, nachdem flag aktiviert wurde")
 	}
 	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: false}); err != nil {
 		t.Fatalf("flag zuruecksetzen: %v", err)
 	}
 	time.Sleep(20 * time.Millisecond) // TTL abwarten
 	active, err = registry.IsActive(ctx, "acme", name)
 	if err != nil {
 		t.Fatalf("is active (nach flag aus): %v", err)
 	}
 	if active {
 		t.Fatal("erwartet wieder nicht aktiv, nachdem flag deaktiviert wurde")
 	}
 }
 func TestIsActive_UnregisteredModuleIsNeverActive(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	active, err := registry.IsActive(ctx, "acme", "nie-registriert")
 	if err != nil {
 		t.Fatalf("is active: %v", err)
 	}
 	if active {
 		t.Fatal("unregistriertes modul darf nie aktiv sein")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Anfrage an deaktiviertes Modul wird
 // zentral abgewiesen, BEVOR die Modul-Logik erreicht wird.
 func TestRequireActiveModule_BlocksBeforeHandler(t *testing.T) {
 	registry, flagStore, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueModuleName(t)
 	flagKey := name + "_enabled"
 	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	handlerReached := false
 	handler := registry.RequireActiveModule(name, func(w http.ResponseWriter, r *http.Request) {
 		handlerReached = true
 		w.WriteHeader(http.StatusOK)
 	})
 	req := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
 	rec := httptest.NewRecorder()
 	handler(rec, req)
 	if rec.Code != http.StatusForbidden {
 		t.Fatalf("status = %d, want 403", rec.Code)
 	}
 	if handlerReached {
 		t.Fatal("handler haette bei deaktiviertem modul NICHT erreicht werden duerfen")
 	}
 	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
 		t.Fatalf("flag setzen: %v", err)
 	}
 	req2 := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
 	rec2 := httptest.NewRecorder()
 	handler(rec2, req2)
 	if rec2.Code != http.StatusOK {
 		t.Fatalf("status nach aktivierung = %d, want 200", rec2.Code)
 	}
 	if !handlerReached {
 		t.Fatal("handler haette bei aktiviertem modul erreicht werden muessen")
 	}
 }
 // Akzeptanzkriterium 4 + Pruefung 4: gueltiges/ungueltiges Service-Credential.
 func TestProvisionAndAuthenticate(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueModuleName(t)
 	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	clientID, secret, err := registry.Provision(ctx, name)
 	if err != nil {
 		t.Fatalf("provision: %v", err)
 	}
 	if clientID == "" || secret == "" {
 		t.Fatal("erwartet nicht-leere client-id/secret")
 	}
 	moduleName, ok, err := registry.Authenticate(ctx, clientID, secret)
 	if err != nil {
 		t.Fatalf("authenticate (korrekt): %v", err)
 	}
 	if !ok || moduleName != name {
 		t.Fatalf("erwartet erfolgreiche authentifizierung fuer %q, habe ok=%v moduleName=%q", name, ok, moduleName)
 	}
 	_, ok, err = registry.Authenticate(ctx, clientID, "falsches-secret")
 	if err != nil {
 		t.Fatalf("authenticate (falsch): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet fehlschlag bei falschem secret")
 	}
 	_, ok, err = registry.Authenticate(ctx, "unbekannte-client-id", secret)
 	if err != nil {
 		t.Fatalf("authenticate (unbekannt): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet fehlschlag bei unbekannter client-id")
 	}
 }
 func TestProvision_RequiresRegisteredModule(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, _, err := registry.Provision(ctx, "nie-registriert"); !errors.Is(err, ErrModuleNotRegistered) {
 		t.Fatalf("erwartet ErrModuleNotRegistered, habe %v", err)
 	}
 }
 func TestRequireServiceCredential_RejectsInvalidAcceptsValid(t *testing.T) {
 	registry, _, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueModuleName(t)
 	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	clientID, secret, err := registry.Provision(ctx, name)
 	if err != nil {
 		t.Fatalf("provision: %v", err)
 	}
 	handler := registry.RequireServiceCredential(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	// Fehlendes Credential.
 	req := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
 	rec := httptest.NewRecorder()
 	handler(rec, req)
 	if rec.Code != http.StatusUnauthorized {
 		t.Fatalf("ohne credential: status = %d, want 401", rec.Code)
 	}
 	// Falsches Secret.
 	req2 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
 	req2.Header.Set("X-Client-Id", clientID)
 	req2.Header.Set("X-Client-Secret", "falsch")
 	rec2 := httptest.NewRecorder()
 	handler(rec2, req2)
 	if rec2.Code != http.StatusUnauthorized {
 		t.Fatalf("falsches secret: status = %d, want 401", rec2.Code)
 	}
 	// Gueltiges Credential.
 	req3 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
 	req3.Header.Set("X-Client-Id", clientID)
 	req3.Header.Set("X-Client-Secret", secret)
 	rec3 := httptest.NewRecorder()
 	handler(rec3, req3)
 	if rec3.Code != http.StatusOK {
 		t.Fatalf("gueltiges credential: status = %d, want 200", rec3.Code)
 	}
 }
@@ -0,0 +1,273 @@
 // Package statuspage implementiert Core OPS-02: eine zentrale Statusseite,
 // die den Health-Zustand aller registrierten Module aggregiert und den
 // Verlauf vergangener Statusaenderungen speichert. Baut auf OPS-01
 // (internal/health) auf, indem es GENAU die dort etablierten
 // Readiness-Endpunkte je Modul abfragt — dieses Paket dupliziert keine
 // Health-Check-Logik, es aggregiert nur deren Ergebnisse ueber die Zeit.
 package statuspage
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Status ist der aggregierte Zustand EINES Moduls zu einem Zeitpunkt.
 type Status string
 const (
 	StatusUp   Status = "up"
 	StatusDown Status = "down"
 )
 // Target ist ein zu ueberwachendes Modul mit seiner Readiness-URL
 // (OPS-01-Endpunkt, z.B. "http://dms:8080/readyz"). Eigenstaendige
 // Konfiguration statt Erweiterung von internal/moduleregistry.Module, um
 // API-02 nicht anzufassen (Kein Umbau angrenzender Bereiche).
 type Target struct {
 	Name      string
 	HealthURL string
 }
 // Store persistiert Ueberwachungsziele und den Verlauf ihrer
 // Statusaenderungen.
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // RegisterTarget traegt ein zu ueberwachendes Modul ein oder aktualisiert
 // dessen URL (Akzeptanzkriterium 1: "aller registrierten Module").
 func (s *Store) RegisterTarget(ctx context.Context, t Target) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO status_targets (name, health_url)
 		VALUES ($1, $2)
 		ON CONFLICT (name) DO UPDATE SET health_url = $2
 	`, t.Name, t.HealthURL)
 	if err != nil {
 		return fmt.Errorf("ueberwachungsziel speichern: %w", err)
 	}
 	return nil
 }
 func (s *Store) ListTargets(ctx context.Context) ([]Target, error) {
 	rows, err := s.pool.Query(ctx, `SELECT name, health_url FROM status_targets ORDER BY name`)
 	if err != nil {
 		return nil, fmt.Errorf("ueberwachungsziele auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Target
 	for rows.Next() {
 		var t Target
 		if err := rows.Scan(&t.Name, &t.HealthURL); err != nil {
 			return nil, fmt.Errorf("ueberwachungsziel lesen: %w", err)
 		}
 		out = append(out, t)
 	}
 	return out, rows.Err()
 }
 // recordIfChanged schreibt NUR dann einen neuen Verlaufseintrag, wenn sich
 // der Status seit dem letzten Eintrag geaendert hat (oder es der erste
 // Eintrag ist) — der Verlauf zeigt Statusaenderungen (Akzeptanzkriterium 3),
 // nicht jede einzelne Abfrage.
 func (s *Store) recordIfChanged(ctx context.Context, name string, status Status) error {
 	var lastStatus string
 	err := s.pool.QueryRow(ctx, `
 		SELECT status FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
 	`, name).Scan(&lastStatus)
 	if err != nil && err != pgx.ErrNoRows {
 		return fmt.Errorf("letzten status lesen: %w", err)
 	}
 	if err == nil && lastStatus == string(status) {
 		return nil // keine Aenderung, kein neuer Eintrag
 	}
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO status_history (name, status, changed_at) VALUES ($1, $2, now())
 	`, name, string(status)); err != nil {
 		return fmt.Errorf("statuseintrag schreiben: %w", err)
 	}
 	return nil
 }
 // ModuleStatus ist der aktuelle Zustand EINES Moduls fuer die Uebersicht.
 type ModuleStatus struct {
 	Name        string    `json:"name"`
 	Status      Status    `json:"status"`
 	LastChecked time.Time `json:"last_checked"`
 }
 // Overview liefert den aktuellen (letzten bekannten) Status jedes
 // registrierten Ziels (Akzeptanzkriterium 1). Ziele ohne jemals erfolgte
 // Pruefung erscheinen mit Status "down" — ein Modul, ueber das nichts
 // bekannt ist, gilt als nicht verfuegbar (Fail-Safe-Default), nicht als
 // stillschweigend "ok".
 func (s *Store) Overview(ctx context.Context) ([]ModuleStatus, error) {
 	targets, err := s.ListTargets(ctx)
 	if err != nil {
 		return nil, err
 	}
 	out := make([]ModuleStatus, 0, len(targets))
 	for _, t := range targets {
 		var status string
 		var changedAt time.Time
 		err := s.pool.QueryRow(ctx, `
 			SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
 		`, t.Name).Scan(&status, &changedAt)
 		if err == pgx.ErrNoRows {
 			out = append(out, ModuleStatus{Name: t.Name, Status: StatusDown})
 			continue
 		}
 		if err != nil {
 			return nil, fmt.Errorf("aktuellen status lesen (%s): %w", t.Name, err)
 		}
 		out = append(out, ModuleStatus{Name: t.Name, Status: Status(status), LastChecked: changedAt})
 	}
 	return out, nil
 }
 // HistoryEntry ist EIN Verlaufseintrag (Akzeptanzkriterium 3).
 type HistoryEntry struct {
 	Status    Status    `json:"status"`
 	ChangedAt time.Time `json:"changed_at"`
 }
 func (s *Store) History(ctx context.Context, name string) ([]HistoryEntry, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC
 	`, name)
 	if err != nil {
 		return nil, fmt.Errorf("verlauf abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []HistoryEntry
 	for rows.Next() {
 		var e HistoryEntry
 		var status string
 		if err := rows.Scan(&status, &e.ChangedAt); err != nil {
 			return nil, fmt.Errorf("verlaufseintrag lesen: %w", err)
 		}
 		e.Status = Status(status)
 		out = append(out, e)
 	}
 	return out, rows.Err()
 }
 // HTTPChecker fragt die Readiness-URL eines Moduls ab (OPS-01-Endpunkt) und
 // liefert StatusUp NUR bei HTTP 200 — jeder andere Statuscode ODER ein
 // Netzwerkfehler/Timeout gilt als StatusDown. Ein einzelnes nicht
 // erreichbares Modul liefert einen FEHLERFREIEN StatusDown-Wert statt eines
 // Go-Errors, damit Poller.Run ein fehlerhaftes Modul niemals mit einem
 // anderen verwechseln oder den gesamten Zyklus abbrechen kann
 // (Akzeptanzkriterium 2).
 type HTTPChecker struct {
 	Client  *http.Client
 	Timeout time.Duration
 }
 func NewHTTPChecker(timeout time.Duration) *HTTPChecker {
 	return &HTTPChecker{Client: &http.Client{}, Timeout: timeout}
 }
 func (c *HTTPChecker) Check(ctx context.Context, url string) Status {
 	ctx, cancel := context.WithTimeout(ctx, c.Timeout)
 	defer cancel()
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return StatusDown
 	}
 	resp, err := c.Client.Do(req)
 	if err != nil {
 		return StatusDown
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode == http.StatusOK {
 		return StatusUp
 	}
 	return StatusDown
 }
 // Poller fragt periodisch alle Ziele ab und schreibt Statusaenderungen fort.
 type Poller struct {
 	store   *Store
 	checker *HTTPChecker
 }
 func NewPoller(store *Store, checker *HTTPChecker) *Poller {
 	return &Poller{store: store, checker: checker}
 }
 // PollOnce prueft ALLE Ziele in einem Durchlauf. Ein fehlschlagendes Ziel
 // (Netzwerkfehler, Timeout, Nicht-200) wird als StatusDown vermerkt und
 // haelt die Pruefung der UEBRIGEN Ziele nicht auf — die Schleife laeuft
 // sequenziell weiter, kein Ziel kann ein anderes blockieren
 // (Akzeptanzkriterium 2 / Pruefung 2).
 func (p *Poller) PollOnce(ctx context.Context) error {
 	targets, err := p.store.ListTargets(ctx)
 	if err != nil {
 		return err
 	}
 	for _, t := range targets {
 		status := p.checker.Check(ctx, t.HealthURL)
 		if err := p.store.recordIfChanged(ctx, t.Name, status); err != nil {
 			// Ein Schreibfehler fuer EIN Ziel darf die Pruefung der anderen
 			// nicht verhindern — dieselbe Fail-Isolation wie bei einem
 			// unerreichbaren Modul.
 			continue
 		}
 	}
 	return nil
 }
 // Run ruft PollOnce in festen Abstaenden auf, bis ctx beendet wird —
 // dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
 func (p *Poller) Run(ctx context.Context, interval time.Duration) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
 			_ = p.PollOnce(ctx)
 		}
 	}
 }
 // --- HTTP-Bindung fuer die Oberflaeche ---
 func (s *Store) OverviewHandler(w http.ResponseWriter, r *http.Request) {
 	overview, err := s.Overview(r.Context())
 	writeJSONResult(w, overview, err)
 }
 func (s *Store) HistoryHandler(w http.ResponseWriter, r *http.Request) {
 	name := r.URL.Query().Get("name")
 	history, err := s.History(r.Context(), name)
 	writeJSONResult(w, history, err)
 }
 func writeJSONResult(w http.ResponseWriter, body any, err error) {
 	w.Header().Set("Content-Type", "application/json")
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		_ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
 		return
 	}
 	w.WriteHeader(http.StatusOK)
 	_ = json.NewEncoder(w).Encode(body)
 }
@@ -0,0 +1,198 @@
 package statuspage
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupTest(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 status_targets (name TEXT PRIMARY KEY, health_url TEXT NOT NULL);
 		CREATE TABLE IF NOT EXISTS status_history (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, status TEXT NOT NULL,
 			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), cleanup
 }
 func uniqueName(prefix string) string {
 	return fmt.Sprintf("%s-%d", prefix, time.Now().UnixNano())
 }
 // Akzeptanzkriterium 1: Uebersicht zeigt den Status ALLER registrierten
 // Module.
 func TestOverview_ShowsAllRegisteredModules(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	nameA, nameB := uniqueName("mod-a"), uniqueName("mod-b")
 	if err := store.RegisterTarget(ctx, Target{Name: nameA, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target a: %v", err)
 	}
 	if err := store.RegisterTarget(ctx, Target{Name: nameB, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target b: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll: %v", err)
 	}
 	overview, err := store.Overview(ctx)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	// Overview() listet ALLE jemals registrierten Ziele (auch aus fruehreren
 	// Testlaeufen auf derselben geteilten Test-DB) — hier wird deshalb nur
 	// der Status von nameA/nameB geprueft, nicht jeder Eintrag der Tabelle.
 	statusByName := map[string]Status{}
 	for _, m := range overview {
 		statusByName[m.Name] = m.Status
 	}
 	if statusByName[nameA] != StatusUp {
 		t.Fatalf("modul %s: status = %s, want up", nameA, statusByName[nameA])
 	}
 	if statusByName[nameB] != StatusUp {
 		t.Fatalf("modul %s: status = %s, want up", nameB, statusByName[nameB])
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1/2: ein simulierter Ausfall eines Moduls
 // wird sichtbar, das ANDERE Modul bleibt unbeeinflusst und die Pruefung
 // beider laeuft trotzdem in einem Durchlauf durch (kein Totalausfall).
 func TestPollOnce_IsolatesFailingModuleFromOthers(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	down := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusInternalServerError) }))
 	down.Close() // Server sofort schliessen -> Verbindung tatsaechlich unerreichbar (simulierter Ausfall)
 	healthyName, downName := uniqueName("healthy"), uniqueName("down")
 	if err := store.RegisterTarget(ctx, Target{Name: healthyName, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target healthy: %v", err)
 	}
 	if err := store.RegisterTarget(ctx, Target{Name: downName, HealthURL: down.URL}); err != nil {
 		t.Fatalf("target down: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(500*time.Millisecond))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll haette trotz einem ausgefallenen modul erfolgreich durchlaufen sollen: %v", err)
 	}
 	overview, err := store.Overview(ctx)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	statusByName := map[string]Status{}
 	for _, m := range overview {
 		statusByName[m.Name] = m.Status
 	}
 	if statusByName[healthyName] != StatusUp {
 		t.Fatalf("healthy modul: status = %s, want up", statusByName[healthyName])
 	}
 	if statusByName[downName] != StatusDown {
 		t.Fatalf("ausgefallenes modul: status = %s, want down", statusByName[downName])
 	}
 }
 // Akzeptanzkriterium 3: Verlauf vergangener Statusaenderungen ist einsehbar.
 func TestHistory_RecordsStatusTransitions(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueName("flaky")
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll 1: %v", err)
 	}
 	// Ziel wird "abgeschaltet" (URL zeigt jetzt auf einen bereits
 	// geschlossenen Server) -> naechster Poll erkennt den Statuswechsel.
 	closedURL := up.URL
 	up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: closedURL}); err != nil {
 		t.Fatalf("target aktualisieren: %v", err)
 	}
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll 2: %v", err)
 	}
 	history, err := store.History(ctx, name)
 	if err != nil {
 		t.Fatalf("history: %v", err)
 	}
 	if len(history) != 2 {
 		t.Fatalf("erwartet genau 2 statuswechsel (up -> down), habe %d: %+v", len(history), history)
 	}
 	if history[0].Status != StatusDown || history[1].Status != StatusUp {
 		t.Fatalf("erwartet verlauf [down, up] (neueste zuerst), habe: %+v", history)
 	}
 }
 // Wiederholte Polls OHNE Statuswechsel duerfen den Verlauf nicht mit
 // identischen Eintraegen fluten (siehe recordIfChanged).
 func TestHistory_DoesNotDuplicateUnchangedStatus(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueName("stable")
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	for i := 0; i < 3; i++ {
 		if err := poller.PollOnce(ctx); err != nil {
 			t.Fatalf("poll %d: %v", i, err)
 		}
 	}
 	history, err := store.History(ctx, name)
 	if err != nil {
 		t.Fatalf("history: %v", err)
 	}
 	if len(history) != 1 {
 		t.Fatalf("erwartet genau 1 eintrag trotz 3 unveraenderter polls, habe %d", len(history))
 	}
 }
@@ -1,32 +0,0 @@
 package usage
 import (
 	"context"
 	"log/slog"
 	"time"
 )
 // AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
 // Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
 // haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
 // Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
 type AggregateFunc func(ctx context.Context) error
 // RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
 // beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
 // internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
 // aggregiert").
 func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
 			if err := aggregate(ctx); err != nil {
 				slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
 			}
 		}
 	}
 }
@@ -1,144 +0,0 @@
 // Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
 // (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
 // gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
 // Hardcode — Zitadel/Unleash-Vorbild.
 package usage
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
 // Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
 type Status string
 const (
 	StatusOK       Status = "ok"
 	StatusWarning  Status = "warning"  // Schwelle (80%) erreicht, aber noch nicht ueberschritten
 	StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
 )
 // warningThreshold liegt bei 80% der Quota.
 const warningThreshold = 0.8
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
 // (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
 // haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
 // (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
 // Lock zu brauchen.
 func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
 		VALUES ($1, $2, $3, now())
 		ON CONFLICT (tenant_id, metric) DO UPDATE
 			SET value = usage_counters.value + $3, updated_at = now()
 	`, tenantID, metric, delta)
 	if err != nil {
 		return fmt.Errorf("zaehler erhoehen: %w", err)
 	}
 	return nil
 }
 // Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
 // Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
 func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
 	var value int64
 	err := s.pool.QueryRow(ctx, `
 		SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
 	`, tenantID, metric).Scan(&value)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return 0, nil
 		}
 		return 0, fmt.Errorf("zaehler lesen: %w", err)
 	}
 	return value, nil
 }
 // SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
 // kein Hardcode.
 func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO usage_quotas (tenant_id, metric, limit_value)
 		VALUES ($1, $2, $3)
 		ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
 	`, tenantID, metric, limit)
 	if err != nil {
 		return fmt.Errorf("quota setzen: %w", err)
 	}
 	return nil
 }
 func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
 	var limit int64
 	err := s.pool.QueryRow(ctx, `
 		SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
 	`, tenantID, metric).Scan(&limit)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return 0, ErrNoQuota
 		}
 		return 0, fmt.Errorf("quota lesen: %w", err)
 	}
 	return limit, nil
 }
 // Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
 // Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
 // gilt die Metrik als unbegrenzt (StatusOK).
 func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
 	value, err = s.Get(ctx, tenantID, metric)
 	if err != nil {
 		return 0, 0, "", err
 	}
 	limit, err = s.GetQuota(ctx, tenantID, metric)
 	if errors.Is(err, ErrNoQuota) {
 		return value, 0, StatusOK, nil
 	}
 	if err != nil {
 		return 0, 0, "", err
 	}
 	switch {
 	case value > limit:
 		return value, limit, StatusExceeded, nil
 	case limit > 0 && float64(value) >= warningThreshold*float64(limit):
 		return value, limit, StatusWarning, nil
 	default:
 		return value, limit, StatusOK, nil
 	}
 }
 // Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
 // (Akzeptanzkriterium 2: "definierte Reaktion").
 type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
 // Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
 // die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
 // Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
 // garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
 func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
 	value, limit, status, err := s.Check(ctx, tenantID, metric)
 	if err != nil {
 		return "", err
 	}
 	if status != StatusOK && react != nil {
 		react(ctx, tenantID, metric, value, limit, status)
 	}
 	return status, nil
 }
@@ -1,206 +0,0 @@
 package usage
 import (
 	"context"
 	"fmt"
 	"os"
 	"sync"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupTest(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 usage_counters (
 			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
 		);
 		CREATE TABLE IF NOT EXISTS usage_quotas (
 			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
 			PRIMARY KEY (tenant_id, metric)
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), cleanup
 }
 func newTenantID() string {
 	return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
 // Schreibzugriffen konsistente Zaehlerstaende.
 func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	const goroutines = 50
 	var wg sync.WaitGroup
 	for i := 0; i < goroutines; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
 				t.Errorf("increment: %v", err)
 			}
 		}()
 	}
 	wg.Wait()
 	value, err := store.Get(ctx, tenant, "api_calls")
 	if err != nil {
 		t.Fatalf("get: %v", err)
 	}
 	if value != goroutines {
 		t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
 // nicht den eines anderen.
 func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenantA, tenantB := newTenantID(), newTenantID()
 	if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
 		t.Fatalf("increment a: %v", err)
 	}
 	if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
 		t.Fatalf("increment b: %v", err)
 	}
 	valA, err := store.Get(ctx, tenantA, "users")
 	if err != nil {
 		t.Fatalf("get a: %v", err)
 	}
 	valB, err := store.Get(ctx, tenantB, "users")
 	if err != nil {
 		t.Fatalf("get b: %v", err)
 	}
 	if valA != 5 || valB != 1 {
 		t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
 // erkannt und die definierte Reaktion ausgeloest.
 func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
 		t.Fatalf("set quota: %v", err)
 	}
 	if err := store.Increment(ctx, tenant, "users", 11); err != nil {
 		t.Fatalf("increment: %v", err)
 	}
 	var reacted bool
 	var gotStatus Status
 	status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
 		reacted = true
 		gotStatus = status
 	})
 	if err != nil {
 		t.Fatalf("enforce: %v", err)
 	}
 	if status != StatusExceeded {
 		t.Fatalf("erwartet StatusExceeded, habe %q", status)
 	}
 	if !reacted || gotStatus != StatusExceeded {
 		t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
 	}
 }
 func TestCheck_WarningThresholdAndOK(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
 		t.Fatalf("set quota: %v", err)
 	}
 	if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
 		t.Fatalf("increment: %v", err)
 	}
 	_, _, status, err := store.Check(ctx, tenant, "storage_mb")
 	if err != nil {
 		t.Fatalf("check: %v", err)
 	}
 	if status != StatusOK {
 		t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
 	}
 	if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
 		t.Fatalf("increment: %v", err)
 	}
 	_, _, status, err = store.Check(ctx, tenant, "storage_mb")
 	if err != nil {
 		t.Fatalf("check: %v", err)
 	}
 	if status != StatusWarning {
 		t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
 	}
 }
 func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
 		t.Fatalf("increment: %v", err)
 	}
 	_, _, status, err := store.Check(ctx, tenant, "api_calls")
 	if err != nil {
 		t.Fatalf("check: %v", err)
 	}
 	if status != StatusOK {
 		t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
 	}
 }
 func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
 	defer cancel()
 	var mu sync.Mutex
 	calls := 0
 	RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
 		mu.Lock()
 		calls++
 		mu.Unlock()
 		return nil
 	})
 	mu.Lock()
 	defer mu.Unlock()
 	if calls < 3 {
 		t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
 	}
 }
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS feature_flags;
@@ -0,0 +1,10 @@
 -- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
 -- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
 -- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
 CREATE TABLE feature_flags (
    key                 TEXT PRIMARY KEY,
    enabled             BOOLEAN NOT NULL DEFAULT false,
    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1 +0,0 @@
 DROP TABLE IF EXISTS tenant_licenses;
@@ -1,12 +0,0 @@
 -- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
 -- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
 -- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
 CREATE TABLE tenant_licenses (
    tenant_id     UUID PRIMARY KEY REFERENCES tenants(id),
    plan          TEXT NOT NULL,
    modules       TEXT[] NOT NULL,
    issued_at     TIMESTAMPTZ NOT NULL,
    valid_until   TIMESTAMPTZ NOT NULL,
    raw_key       TEXT NOT NULL,
    installed_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1,2 @@
 DROP TABLE IF EXISTS module_credentials;
 DROP TABLE IF EXISTS modules;
@@ -0,0 +1,18 @@
 -- Modul-Registry & Aktivierungspruefung (API-02, siehe core-kanban/tickets/API-02.md).
 CREATE TABLE modules (
    name           TEXT PRIMARY KEY,
    version        TEXT NOT NULL CHECK (version <> ''),
    required_flags TEXT[] NOT NULL DEFAULT '{}',
    registered_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Service-Credential je Modul-Instanz, bei Provisionierung ausgestellt
 -- (Akzeptanzkriterium 4). secret_hash enthaelt NIEMALS das Secret im
 -- Klartext, nur dessen SHA-256-Hash (Timing-safe-Vergleich beim Login,
 -- Referenzmuster siehe AUD-02).
 CREATE TABLE module_credentials (
    module_name TEXT PRIMARY KEY REFERENCES modules(name),
    client_id   TEXT NOT NULL UNIQUE,
    secret_hash BYTEA NOT NULL,
    issued_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -1,2 +0,0 @@
 DROP TABLE IF EXISTS usage_quotas;
 DROP TABLE IF EXISTS usage_counters;
@@ -1,15 +0,0 @@
 -- Nutzungszaehler & Quotas je Tenant (LIC-03, siehe core-kanban/tickets/LIC-03.md).
 CREATE TABLE usage_counters (
    tenant_id  UUID NOT NULL,
    metric     TEXT NOT NULL,
    value      BIGINT NOT NULL DEFAULT 0,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (tenant_id, metric)
 );
 CREATE TABLE usage_quotas (
    tenant_id   UUID NOT NULL,
    metric      TEXT NOT NULL,
    limit_value BIGINT NOT NULL,
    PRIMARY KEY (tenant_id, metric)
 );
@@ -0,0 +1,2 @@
 DROP TABLE status_history;
 DROP TABLE status_targets;
@@ -0,0 +1,15 @@
 -- Zentrale Statusseite (OPS-02, siehe core-kanban/tickets/OPS-02.md) —
 -- ueberwachte Module und der Verlauf ihrer Statusaenderungen.
 CREATE TABLE status_targets (
    name       TEXT PRIMARY KEY,
    health_url TEXT NOT NULL
 );
 CREATE TABLE status_history (
    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name       TEXT NOT NULL,
    status     TEXT NOT NULL,
    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE INDEX status_history_name_idx ON status_history (name, changed_at DESC);
@@ -1,23 +1,11 @@
 #!/usr/bin/env bash
 # Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
 # Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
 # tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
 # unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
 # Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
 export PGPASSWORD="$PASS"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -1,24 +1,12 @@
 #!/usr/bin/env bash
 # Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
 # Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
 # -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
 # dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
 echo "== go build =="
 go build ./...
 echo "== go vet =="
 go vet ./...
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1
@@ -1,173 +0,0 @@
 "use client";
 import { useState } from "react";
 import { fetchOverview, toggleFlag, type Overview } from "@/lib/api";
 const STATUS_LABEL: Record<string, string> = {
  ok: "In Ordnung",
  warning: "Nahe am Limit",
  exceeded: "Limit überschritten",
 };
 const STATUS_COLOR: Record<string, string> = {
  ok: "#2e7d32",
  warning: "#ed6c02",
  exceeded: "#c62828",
 };
 export default function Page() {
  const [tenantId, setTenantId] = useState("");
  const [overview, setOverview] = useState<Overview | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [toggleError, setToggleError] = useState<string | null>(null);
  async function load() {
    if (!tenantId.trim()) return;
    setLoading(true);
    setError(null);
    try {
      const data = await fetchOverview(tenantId.trim());
      setOverview(data);
    } catch (e: any) {
      setError(e.message ?? "Unbekannter Fehler");
      setOverview(null);
    } finally {
      setLoading(false);
    }
  }
  async function onToggle(key: string, next: boolean) {
    setToggleError(null);
    try {
      await toggleFlag(tenantId.trim(), key, next);
      await load();
    } catch (e: any) {
      setToggleError(e.message ?? "Umschalten fehlgeschlagen");
    }
  }
  return (
    <main style={{ maxWidth: 800, margin: "0 auto", padding: "2rem 1rem" }}>
      <h1>Lizenz- und Modulverwaltung</h1>
      <div style={{ display: "flex", gap: "0.5rem", marginBottom: "1.5rem" }}>
        <input
          value={tenantId}
          onChange={(e) => setTenantId(e.target.value)}
          placeholder="Tenant-ID eingeben"
          style={{ flex: 1, padding: "0.5rem", fontSize: "1rem" }}
        />
        <button onClick={load} disabled={loading} style={{ padding: "0.5rem 1rem" }}>
          {loading ? "Lädt…" : "Anzeigen"}
        </button>
      </div>
      {error && (
        <p style={{ color: "#c62828" }} role="alert">
          Fehler: {error}
        </p>
      )}
      {overview && (
        <>
          <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginBottom: "1.5rem" }}>
            <h2>Lizenzstatus</h2>
            <p>
              <strong>Plan:</strong> {overview.plan}{" "}
              {overview.expired && (
                <span style={{ color: "#c62828", fontWeight: "bold" }}>
                  (abgelaufen)
                </span>
              )}
            </p>
            <p>
              <strong>Gültig bis:</strong>{" "}
              {new Date(overview.valid_until).toLocaleDateString("de-DE")}
            </p>
            <p>
              <strong>Freigeschaltete Module:</strong>{" "}
              {overview.modules.length > 0 ? overview.modules.join(", ") : "keine"}
            </p>
          </section>
          <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginBottom: "1.5rem" }}>
            <h2>Feature-Flags</h2>
            {toggleError && (
              <p style={{ color: "#c62828" }} role="alert">
                {toggleError}
              </p>
            )}
            {overview.flags.length === 0 && <p>Keine Feature-Flags definiert.</p>}
            <ul style={{ listStyle: "none", padding: 0 }}>
              {overview.flags.map((f) => (
                <li
                  key={f.key}
                  style={{
                    display: "flex",
                    justifyContent: "space-between",
                    alignItems: "center",
                    padding: "0.5rem 0",
                    borderBottom: "1px solid #eee",
                  }}
                >
                  <div>
                    <div>{f.key}</div>
                    {!f.licensed && f.deny_grund && (
                      <div style={{ fontSize: "0.85rem", color: "#c62828" }}>
                        {f.deny_grund}
                      </div>
                    )}
                  </div>
                  <label>
                    <input
                      type="checkbox"
                      checked={f.enabled}
                      disabled={!f.licensed && !f.enabled}
                      onChange={(e) => onToggle(f.key, e.target.checked)}
                    />{" "}
                    aktiv
                  </label>
                </li>
              ))}
            </ul>
          </section>
          <section style={{ background: "white", padding: "1rem", borderRadius: 8 }}>
            <h2>Nutzungsstand</h2>
            {overview.usage.map((u) => {
              const pct = u.limit > 0 ? Math.min(100, (u.value / u.limit) * 100) : 0;
              return (
                <div key={u.metric} style={{ marginBottom: "1rem" }}>
                  <div style={{ display: "flex", justifyContent: "space-between" }}>
                    <span>{u.metric}</span>
                    <span style={{ color: STATUS_COLOR[u.status] }}>
                      {u.value} / {u.limit > 0 ? u.limit : "unbegrenzt"} —{" "}
                      {STATUS_LABEL[u.status]}
                    </span>
                  </div>
                  <div
                    style={{
                      background: "#eee",
                      borderRadius: 4,
                      height: 8,
                      overflow: "hidden",
                    }}
                  >
                    <div
                      style={{
                        width: `${u.limit > 0 ? pct : 0}%`,
                        background: STATUS_COLOR[u.status],
                        height: "100%",
                      }}
                    />
                  </div>
                </div>
              );
            })}
          </section>
        </>
      )}
    </main>
  );
 }
@@ -1,63 +0,0 @@
 // Duenner Client fuer das LIC-04-Backend-API (internal/adminapi) — enthaelt
 // keinerlei eigene Lizenz-/Flag-Logik, nur Datenabruf und -weitergabe.
 export type FlagOverview = {
  key: string;
  enabled: boolean;
  licensed: boolean;
  deny_grund?: string;
 };
 export type UsageOverview = {
  metric: string;
  value: number;
  limit: number;
  status: "ok" | "warning" | "exceeded";
 };
 export type Overview = {
  plan: string;
  modules: string[];
  issued_at: string;
  valid_until: string;
  expired: boolean;
  flags: FlagOverview[];
  usage: UsageOverview[];
 };
 function apiBase(): string {
  const base = process.env.NEXT_PUBLIC_ADMIN_API_URL;
  if (!base) {
    throw new Error(
      "NEXT_PUBLIC_ADMIN_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
    );
  }
  return base;
 }
 export async function fetchOverview(tenantId: string): Promise<Overview> {
  const res = await fetch(
    `${apiBase()}/admin/overview?tenant=${encodeURIComponent(tenantId)}`,
    { cache: "no-store" }
  );
  if (!res.ok) {
    const body = await res.json().catch(() => ({}));
    throw new Error(body.error || `Anfrage fehlgeschlagen (${res.status})`);
  }
  return res.json();
 }
 export async function toggleFlag(
  tenantId: string,
  key: string,
  enabled: boolean
 ): Promise<void> {
  const res = await fetch(`${apiBase()}/admin/flags/toggle`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ tenant: tenantId, key, enabled }),
  });
  if (!res.ok) {
    const body = await res.json().catch(() => ({}));
    throw new Error(body.error || `Umschalten fehlgeschlagen (${res.status})`);
  }
 }
@@ -1,7 +1,7 @@
 import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
 export const metadata = {
-  title: "NEXARCH Lizenz- und Modulverwaltung",
+  title: "NEXARCH Systemstatus",
 };
 export default function RootLayout({
@@ -0,0 +1,125 @@
 "use client";
 import { useEffect, useState } from "react";
 import { fetchOverview, fetchHistory, type ModuleStatus, type HistoryEntry } from "@/lib/api";
 const POLL_INTERVAL_MS = 5000;
 export default function Page() {
  const [modules, setModules] = useState<ModuleStatus[]>([]);
  const [error, setError] = useState<string | null>(null);
  const [selected, setSelected] = useState<string | null>(null);
  const [history, setHistory] = useState<HistoryEntry[] | null>(null);
  const [historyError, setHistoryError] = useState<string | null>(null);
  useEffect(() => {
    let cancelled = false;
    async function poll() {
      try {
        const data = await fetchOverview();
        if (!cancelled) {
          setModules(data);
          setError(null);
        }
      } catch (e: any) {
        // Ein nicht antwortendes Backend darf die zuletzt bekannte Ansicht
        // nicht loeschen und die Seite nicht unbedienbar machen
        // (Akzeptanzkriterium 2) — nur eine Fehlermeldung anzeigen, alte
        // Daten bleiben sichtbar.
        if (!cancelled) {
          setError(e.message ?? "Unbekannter Fehler beim Laden der Uebersicht");
        }
      }
    }
    poll();
    const id = setInterval(poll, POLL_INTERVAL_MS);
    return () => {
      cancelled = true;
      clearInterval(id);
    };
  }, []);
  async function openHistory(name: string) {
    setSelected(name);
    setHistoryError(null);
    try {
      const data = await fetchHistory(name);
      setHistory(data);
    } catch (e: any) {
      setHistoryError(e.message ?? "Verlauf konnte nicht geladen werden");
      setHistory(null);
    }
  }
  const anyDown = modules.some((m) => m.status === "down");
  return (
    <main style={{ maxWidth: 800, margin: "0 auto", padding: "2rem 1rem" }}>
      <h1>Systemstatus</h1>
      {error && (
        <p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }} role="alert">
          Uebersicht konnte gerade nicht aktualisiert werden: {error}. Zuletzt bekannter Stand wird weiter angezeigt.
        </p>
      )}
      {!error && anyDown && (
        <p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }}>
          Mindestens ein Modul ist derzeit nicht erreichbar.
        </p>
      )}
      <ul style={{ listStyle: "none", padding: 0 }}>
        {modules.map((m) => (
          <li
            key={m.name}
            style={{
              display: "flex",
              justifyContent: "space-between",
              alignItems: "center",
              background: "white",
              padding: "0.75rem 1rem",
              marginBottom: "0.5rem",
              borderRadius: 8,
              borderLeft: `6px solid ${m.status === "up" ? "#2e7d32" : "#c62828"}`,
            }}
          >
            <div>
              <strong>{m.name}</strong>
              <div style={{ fontSize: "0.85rem", color: "#666" }}>
                {m.status === "up" ? "Verfügbar" : "Nicht verfügbar"}
                {m.last_checked && ` — zuletzt geprüft ${new Date(m.last_checked).toLocaleString("de-DE")}`}
              </div>
            </div>
            <button onClick={() => openHistory(m.name)}>Verlauf</button>
          </li>
        ))}
        {modules.length === 0 && !error && <li>Lade Modulstatus…</li>}
      </ul>
      {selected && (
        <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
          <h2>Verlauf: {selected}</h2>
          {historyError && (
            <p style={{ color: "#c62828" }} role="alert">
              {historyError}
            </p>
          )}
          {history && (
            <ul>
              {history.map((h, i) => (
                <li key={i}>
                  {new Date(h.changed_at).toLocaleString("de-DE")} — {h.status === "up" ? "verfügbar" : "nicht verfügbar"}
                </li>
              ))}
              {history.length === 0 && <li>Keine Statusänderungen bisher.</li>}
            </ul>
          )}
          <button onClick={() => setSelected(null)}>Schließen</button>
        </section>
      )}
    </main>
  );
 }
@@ -0,0 +1,44 @@
 // Duenner Client des OPS-02-Backends (internal/statuspage) — keine eigene
 // Aggregations-/Polling-Logik im Frontend.
 export type ModuleStatus = {
  name: string;
  status: "up" | "down";
  last_checked?: string;
 };
 export type HistoryEntry = {
  status: "up" | "down";
  changed_at: string;
 };
 function apiBase(): string {
  const base = process.env.NEXT_PUBLIC_STATUSPAGE_API_URL;
  if (!base) {
    throw new Error(
      "NEXT_PUBLIC_STATUSPAGE_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
    );
  }
  return base;
 }
 // fetchOverview holt den Status EINES Moduls unabhaengig vom Erfolg der
 // anderen — ein Netzwerkfehler beim Abruf der Gesamtuebersicht wird vom
 // Aufrufer (Page-Komponente) abgefangen, sodass ein nicht antwortendes
 // Backend die Seite nicht zum Absturz bringt (Akzeptanzkriterium 2).
 export async function fetchOverview(): Promise<ModuleStatus[]> {
  const res = await fetch(`${apiBase()}/status/overview`, { cache: "no-store" });
  if (!res.ok) {
    throw new Error(`Uebersicht konnte nicht geladen werden (${res.status})`);
  }
  return res.json();
 }
 export async function fetchHistory(name: string): Promise<HistoryEntry[]> {
  const res = await fetch(`${apiBase()}/status/history?name=${encodeURIComponent(name)}`, {
    cache: "no-store",
  });
  if (!res.ok) {
    throw new Error(`Verlauf konnte nicht geladen werden (${res.status})`);
  }
  return res.json();
 }
@@ -1,5 +1,5 @@
 {
-  "name": "nexarch-lic-admin",
+  "name": "nexarch-status-page",
  "private": true,
  "scripts": {
    "dev": "next dev",
Author	SHA1	Message	Date
sysops	49a48743f5	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite	2026-08-28 22:02:02 +02:00
sysops	11940e28e6	OPS-02: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)	2026-08-28 21:56:39 +02:00
sysops	f7bc927d50	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite	2026-08-28 21:56:31 +02:00
sysops	0f1add0b78	OPS-02: Retrofit auf SHL-01 (ThemeProvider/I18nProvider/ToastProvider, Design-Tokens statt hartkodierter Werte)	2026-08-28 21:47:48 +02:00
sysops	265c09db24	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite # Conflicts: # DEVLOG.md	2026-08-28 21:47:32 +02:00
sysops	cabcabda8d	OPS-02: test-fix — overview-pruefung nur fuer eigene testziele, nicht alle jemals registrierten	2026-08-28 08:29:27 +02:00
sysops	81ebdd892b	OPS-02: dev-server + next.js zentrale statusseite	2026-08-28 08:21:27 +02:00
sysops	dff760e1ba	OPS-02: zentrale-statusseite (backend: poller + aggregierte uebersicht + verlauf)	2026-08-28 08:19:40 +02:00
sysopsandClaude Sonnet 5	6a03dcafd6	OPS-01: health-check-endpunkte-je-modul internal/health: wiederverwendbare Registry fuer benannte Checks (DB, Queue) — nicht Core-spezifisch, sondern von jedem registrierten Modul (API-02) gleichermassen einsetzbar. LivenessHandler prueft bewusst KEINE externen Abhaengigkeiten (Akzeptanzkriterium 2: Liveness/Readiness getrennt) — ein DB-Ausfall soll den Prozess nicht faelschlich als "tot" markieren und einen grundlosen Neustart ausloesen. ReadinessHandler fuehrt alle registrierten Checks NEBENLAEUFIG mit je eigenem Timeout aus (DefaultCheckTimeout=2s) und liefert 503, sobald irgendeine Abhaengigkeit fehlschlaegt (Akzeptanz- kriterium 1 + 3) — echte Pruefung von DB (Ping) und Job-Queue statt nur Prozessstatus. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Simulierter Datenbankausfall fuehrt zu "nicht bereit" — TestReadinessHandler_ReportsNotReadyOnDatabaseFailure: geschlossener Pool, 503 mit "database" im Checks-Ergebnis. PASS. 2. Health-Endpunkt antwortet auch bei haengendem Check innerhalb definierter Zeit — TestReadinessHandler_RespondsWithinTimeoutEvenWithHangingCheck: ein 10s blockierender Check wird durch 50ms-Timeout begrenzt, Handler antwortet deutlich unter 1s. PASS. 3. Readiness- und Liveness-Antwort unterscheiden sich nachweislich in mindestens einem Fehlerfall — TestLivenessAndReadiness_DifferOnDatabaseFailure: bei DB-Ausfall liefert Liveness weiterhin 200, Readiness 503. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 23:30:30 +02:00
sysopsandClaude Sonnet 5	b23cd1961f	API-02: modul-registry-aktivierungspruefung internal/moduleregistry: Registry.Register traegt Fachmodule mit Name, Version und benoetigten Feature-Flags ein (Akzeptanzkriterium 1), fehlende Pflichtangaben werden abgewiesen. IsActive kombiniert Registrierung + LIC-02 Feature-Flag-Auswertung (ALLE benoetigten Flags muessen fuer den Tenant aktiv sein) — ein nicht registriertes Modul ist nie aktiv. List liefert alle Module fuer Statusseite/Lizenzoberflaeche (Akzeptanzkriterium 3). RequireActiveModule ist die zentrale Durchsetzungs-Middleware (Casbin- Prinzip): weist Anfragen an ein deaktiviertes Modul ab, BEVOR der Modul-Handler ueberhaupt aufgerufen wird (Akzeptanzkriterium 2) — Pruefung per Test belegt, dass der Handler bei Deaktivierung nachweislich nicht erreicht wird. Service-Credentials (Akzeptanzkriterium 4): Registry.Provision stellt pro Modul-Instanz Client-ID + Secret aus, gespeichert wird nur der SHA-256-Hash des Secrets. Registry.Authenticate vergleicht timing-safe (dieselbe subtle.ConstantTimeCompare-Referenzimplementierung wie AUD-02). RequireServiceCredential-Middleware liest X-Client-Id/X-Client-Secret und weist Aufrufe ohne gueltiges Credential mit 401 ab, bevor der Core-seitige Endpunkt (z.B. Audit-Nachlieferung, Nutzungsmeldung) erreicht wird. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Anfrage an deaktiviertes Modul nachweislich vor Modul-Logik abgewiesen — TestRequireActiveModule_BlocksBeforeHandler: handlerReached bleibt false bei 403, wird true erst nach Aktivierung bei 200. PASS. 2. Registrierung mit fehlenden Pflichtangaben abgewiesen — TestRegister_RejectsMissingFields (leerer Name, leere Version). PASS. 3. Registry-Abfrage liefert konsistente Daten nach Aktivierung/Deaktivierung — TestIsActive_ReflectsFlagStateConsistently: aus/an/aus-Zyklus, IsActive folgt dem Flag-Zustand korrekt. PASS. 4. Aufruf mit ungueltigem/fehlendem Service-Credential abgewiesen, mit gueltigem angenommen — TestRequireServiceCredential_RejectsInvalidAcceptsValid und TestProvisionAndAuthenticate (falsches Secret, unbekannte Client-ID, korrektes Credential). PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:17:50 +02:00
sysopsandClaude Sonnet 5	4a30345e07	LIC-02: feature-flag-service-je-tenant internal/flag: Store (Verwaltung) + Service (Auswertung mit TTL-Cache, Default 5s) — Unleash-Prinzip Flag-Verwaltung vs. Flag-Auswertung getrennt, als Kernfunktion des Core-Dienstes selbst statt separater Infrastruktur. evaluate() wendet drei Strategien in fester Reihenfolge an: global an/aus, Tenant-Zielgruppe, deterministischer Prozentsatz-Rollout (FNV-Hash aus Tenant+Key, stabil pro Tenant). IsEnabled liefert IMMER nur bool (kein Fehlerwert) — ein nicht erreichbarer Flag-Dienst kann damit keinen Aufrufer zum Absturz bringen: bei DB-Fehler wird der zuletzt bekannte Cache-Stand verwendet, ohne jeglichen Stand faellt der Dienst sicher auf false zurueck. Service.Invalidate erzwingt sofortiges Neuladen fuer den Schreiber selbst, andere Instanzen sehen Aenderungen spaetestens nach der TTL (Akzeptanzkriterium 3, kein Neustart noetig). Bugfix waehrend Tests: Store.Set uebergab ein nil-TargetTenantSlugs-Slice als SQL NULL statt leerem Array (NOT-NULL-Verletzung) — auf leeres Slice normalisiert. Akzeptanzkriterium 4 (Deaktivierung loescht keine Daten): dieses Paket besitzt ausschliesslich die eigene feature_flags-Zeile, hat keinerlei Code-Pfad, der Modul-Geschaeftsdaten anfassen koennte — Loeschung bleibt strukturell der Archive-Retention-Engine vorbehalten. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Cache-Invalidierungszeit automatisiert gemessen — TestService_CacheInvalidationTiming: Aenderung wirksam nach 153ms bei TTL=150ms (innerhalb Ziel+Toleranz), vorher nachweislich noch alter Stand. PASS. 2. Zielgruppen-Strategie liefert erwartete Auswertung — TestService_TargetTenantStrategy / TestEvaluate_TargetTenantStrategy. PASS. 3. Ausfall des Flag-Dienstes fuehrt zu dokumentiertem Fallback, kein Absturz — TestService_FallsBackOnStoreFailure (mit recover()-Absicherung): Fallback auf Cache-Stand bzw. sicheres false bei komplett unerreichbarer DB, geloggt. PASS. 4. Modul-Deaktivierung/Reaktivierung ohne Datenverlust — architektonisch durch fehlenden Code-Pfad sichergestellt (siehe oben), zusaetzlich durch TestService_InvalidateForcesImmediateRefresh (Toggle aus/an bleibt konsistent nachvollziehbar) mitabgedeckt. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:19:59 +02:00
		`@@ -0,0 +1,2 @@`
							`DROP TABLE IF EXISTS module_credentials;`
							`DROP TABLE IF EXISTS modules;`
		`@@ -1,2 +0,0 @@`
			`DROP TABLE IF EXISTS usage_quotas;`
			`DROP TABLE IF EXISTS usage_counters;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE status_history;`
							`DROP TABLE status_targets;`