Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht

AUD-04: 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:27 +02:00 · 2026-08-28 21:56:20 +02:00 · 2026-08-28 21:47:23 +02:00 · 2026-08-28 21:47:09 +02:00 · 2026-08-28 00:10:48 +02:00
37 changed files with 1013 additions and 2128 deletions
@@ -0,0 +1,69 @@
 // auditlog-devserver stellt AUD-03s ExportHandler (internal/audit) fuer die
 // Next.js-Audit-Log-Ansicht (AUD-04) bereit. Getrennt von cmd/core aus
 // demselben Grund wie die anderen *-devserver (siehe LIC-04/TEN-05): echte
 // Auth/RBAC ist noch nicht in die zentrale Server-Topologie verdrahtet.
 //
 // Authorize wird hier mit einem geteilten Admin-Token ueber
 // crypto/subtle.ConstantTimeCompare umgesetzt — demselben Timing-safe-Muster
 // wie internal/audit.timingsafe (AUD-02), NICHT ueber eine neue
 // Rollen-/Rechteschicht, da diese Kachel ausdruecklich nur von AUD-03
 // abhaengt und keine Rechteverwaltung duplizieren soll.
 package main
 import (
 	"context"
 	"log"
 	"net/http"
 	"os"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auditadmin"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	adminToken := os.Getenv("NEXARCH_AUDIT_ADMIN_TOKEN")
 	if adminToken == "" {
 		log.Fatal("NEXARCH_AUDIT_ADMIN_TOKEN nicht gesetzt")
 	}
 	addr := os.Getenv("NEXARCH_AUDITLOG_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8083"
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	auditLog := audit.NewLog(pool)
 	tokenAuthorize := auditadmin.NewTokenAuthorizer(adminToken)
 	authorize := func(_ context.Context, caller string) bool { return tokenAuthorize(caller) }
 	handler := audit.NewExportHandler(auditLog, authorize)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/audit/export", withCORS(handler.Export))
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("auditlog-devserver listening on %s", addr)
 	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,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)
 	}
 }
@@ -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)
 	}
 }
@@ -0,0 +1,96 @@
 // Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
 // Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
 // compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
 // Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
 // — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
 // Schreibpfad (Akzeptanzkriterium 3).
 package audit
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
 // Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
 // Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
 const SystemTenant = "system"
 var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
 var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
 var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
 // Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
 // Aktion, Zielobjekt, Zeitpunkt, Tenant).
 type Event struct {
 	TenantSlug string
 	Actor      string
 	Action     string
 	Target     string
 	Metadata   map[string]any
 	OccurredAt time.Time
 }
 // Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
 // bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
 // direkt in audit_events schreibt und dabei die Validierung umgeht
 // (Akzeptanzkriterium 3).
 type Log struct {
 	pool *pgxpool.Pool
 }
 func NewLog(pool *pgxpool.Pool) *Log {
 	return &Log{pool: pool}
 }
 // Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
 // bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
 // Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
 // zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
 func (l *Log) Record(ctx context.Context, e Event) error {
 	if e.TenantSlug == "" {
 		return ErrMissingTenant
 	}
 	if e.Actor == "" {
 		return ErrMissingActor
 	}
 	if e.Action == "" {
 		return ErrMissingAction
 	}
 	if e.Metadata == nil {
 		e.Metadata = map[string]any{}
 	}
 	metadataJSON, err := json.Marshal(e.Metadata)
 	if err != nil {
 		return fmt.Errorf("metadaten serialisieren: %w", err)
 	}
 	if e.OccurredAt.IsZero() {
 		e.OccurredAt = time.Now()
 	}
 	_, err = l.pool.Exec(ctx, `
 		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
 		VALUES ($1, $2, $3, $4, $5, $6)
 	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
 	if err != nil {
 		return fmt.Errorf("audit-ereignis schreiben: %w", err)
 	}
 	return nil
 }
 // CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
 // eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
 func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
 	var n int
 	if err := l.pool.QueryRow(ctx, `
 		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
 	`, tenantSlug).Scan(&n); err != nil {
 		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
 	}
 	return n, nil
 }
@@ -0,0 +1,132 @@
 package audit
 import (
 	"context"
 	"errors"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupAuditTest(t *testing.T) (*Log, *pgxpool.Pool, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS audit_events (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
 			actor TEXT NOT NULL CHECK (actor <> ''),
 			action TEXT NOT NULL CHECK (action <> ''),
 			target TEXT NOT NULL,
 			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
 		pool.Close()
 	}
 	return NewLog(pool), pool, cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
 // (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
 func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
 	log, pool, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	err := log.Record(ctx, Event{
 		TenantSlug: "test_acme",
 		Actor:      "alice@example.com",
 		Action:     "iam.login_failed",
 		Target:     "user:alice@example.com",
 		Metadata:   map[string]any{"reason": "falsches passwort"},
 	})
 	if err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	count, err := log.CountByTenant(ctx, "test_acme")
 	if err != nil {
 		t.Fatalf("count: %v", err)
 	}
 	if count != 1 {
 		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
 	}
 	var actor, action, target string
 	if err := pool.QueryRow(ctx, `
 		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
 	`).Scan(&actor, &action, &target); err != nil {
 		t.Fatalf("eintrag lesen: %v", err)
 	}
 	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
 		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
 // bereits vom zentralen Schreibpfad abgewiesen.
 func TestRecord_RejectsMissingTenant(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
 	if !errors.Is(err, ErrMissingTenant) {
 		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
 // der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
 // Schutz haengt nicht allein von der Go-Validierung ab.
 func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
 	_, pool, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	_, err := pool.Exec(ctx, `
 		INSERT INTO audit_events (tenant_slug, actor, action, target)
 		VALUES ('', 'alice', 'irgendwas', 'ziel')
 	`)
 	if err == nil {
 		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
 	}
 }
 func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
 		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
 	}
 	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
 		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
 	}
 }
 func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
 	log, _, cleanup := setupAuditTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
 		t.Fatalf("record mit SystemTenant: %v", err)
 	}
 }
@@ -0,0 +1,122 @@
 package audit
 import (
 	"context"
 	"encoding/csv"
 	"encoding/json"
 	"fmt"
 	"io"
 	"time"
 )
 // Filter grenzt einen Export ein (Akzeptanzkriterium 1). Leere/Nil-Felder
 // bedeuten "kein Filter auf diesem Feld".
 type Filter struct {
 	TenantSlug string
 	Actor      string
 	Action     string
 	From       *time.Time
 	To         *time.Time
 }
 func buildFilterQuery(f Filter) (string, []any) {
 	query := `SELECT occurred_at, tenant_slug, actor, action, target, metadata FROM audit_events WHERE 1=1`
 	var args []any
 	if f.TenantSlug != "" {
 		args = append(args, f.TenantSlug)
 		query += fmt.Sprintf(" AND tenant_slug = $%d", len(args))
 	}
 	if f.Actor != "" {
 		args = append(args, f.Actor)
 		query += fmt.Sprintf(" AND actor = $%d", len(args))
 	}
 	if f.Action != "" {
 		args = append(args, f.Action)
 		query += fmt.Sprintf(" AND action = $%d", len(args))
 	}
 	if f.From != nil {
 		args = append(args, *f.From)
 		query += fmt.Sprintf(" AND occurred_at >= $%d", len(args))
 	}
 	if f.To != nil {
 		args = append(args, *f.To)
 		query += fmt.Sprintf(" AND occurred_at <= $%d", len(args))
 	}
 	query += " ORDER BY occurred_at"
 	return query, args
 }
 // StreamCSV schreibt gefilterte Audit-Eintraege direkt als CSV in w, Zeile
 // fuer Zeile ueber rows.Next() — es wird zu keinem Zeitpunkt das gesamte
 // Ergebnis im Speicher aufgebaut (Akzeptanzkriterium 3 / Pruefung 1).
 func (l *Log) StreamCSV(ctx context.Context, filter Filter, w io.Writer) error {
 	query, args := buildFilterQuery(filter)
 	rows, err := l.pool.Query(ctx, query, args...)
 	if err != nil {
 		return fmt.Errorf("export abfragen: %w", err)
 	}
 	defer rows.Close()
 	cw := csv.NewWriter(w)
 	if err := cw.Write([]string{"occurred_at", "tenant_slug", "actor", "action", "target", "metadata"}); err != nil {
 		return fmt.Errorf("csv-header schreiben: %w", err)
 	}
 	for rows.Next() {
 		var occurredAt time.Time
 		var tenantSlug, actor, action, target string
 		var metadataJSON []byte
 		if err := rows.Scan(&occurredAt, &tenantSlug, &actor, &action, &target, &metadataJSON); err != nil {
 			return fmt.Errorf("zeile lesen: %w", err)
 		}
 		if err := cw.Write([]string{
 			occurredAt.Format(time.RFC3339), tenantSlug, actor, action, target, string(metadataJSON),
 		}); err != nil {
 			return fmt.Errorf("csv-zeile schreiben: %w", err)
 		}
 	}
 	cw.Flush()
 	if err := rows.Err(); err != nil {
 		return fmt.Errorf("export lesen: %w", err)
 	}
 	return cw.Error()
 }
 // exportRecord ist die JSON-Repraesentation einer exportierten Zeile.
 type exportRecord struct {
 	OccurredAt time.Time       `json:"occurred_at"`
 	TenantSlug string          `json:"tenant_slug"`
 	Actor      string          `json:"actor"`
 	Action     string          `json:"action"`
 	Target     string          `json:"target"`
 	Metadata   json.RawMessage `json:"metadata"`
 }
 // StreamJSON schreibt gefilterte Audit-Eintraege als JSON Lines (ein
 // JSON-Objekt pro Zeile) — bewusst kein einzelnes grosses JSON-Array, da
 // dessen korrektes Streaming (Kommas/Klammern ohne Zwischenpufferung)
 // unnoetige Komplexitaet fuer denselben Zweck waere. Wie StreamCSV
 // zeilenweise ueber rows.Next(), kein Aufbau im Speicher.
 func (l *Log) StreamJSON(ctx context.Context, filter Filter, w io.Writer) error {
 	query, args := buildFilterQuery(filter)
 	rows, err := l.pool.Query(ctx, query, args...)
 	if err != nil {
 		return fmt.Errorf("export abfragen: %w", err)
 	}
 	defer rows.Close()
 	enc := json.NewEncoder(w)
 	for rows.Next() {
 		var rec exportRecord
 		var metadataJSON []byte
 		if err := rows.Scan(&rec.OccurredAt, &rec.TenantSlug, &rec.Actor, &rec.Action, &rec.Target, &metadataJSON); err != nil {
 			return fmt.Errorf("zeile lesen: %w", err)
 		}
 		rec.Metadata = metadataJSON
 		if err := enc.Encode(rec); err != nil {
 			return fmt.Errorf("json-zeile schreiben: %w", err)
 		}
 	}
 	return rows.Err()
 }
@@ -0,0 +1,73 @@
 package audit
 import (
 	"context"
 	"net/http"
 	"time"
 )
 // Authorize entscheidet, ob caller den Export ausfuehren darf. Die
 // eigentliche Rollen-/Rechtepruefung (RBAC-02 Policy-Enforcement) ist nicht
 // Teil dieser Kachel — ExportHandler kennt nur diese schmale Schnittstelle,
 // analog zum RetentionRegistrar-Muster aus AUD-05.
 type Authorize func(ctx context.Context, caller string) bool
 // ExportHandler stellt den Export als HTTP-Endpunkt bereit
 // (Akzeptanzkriterium 2: fuer berechtigte Rollen verfuegbar).
 type ExportHandler struct {
 	log       *Log
 	authorize Authorize
 }
 func NewExportHandler(log *Log, authorize Authorize) *ExportHandler {
 	return &ExportHandler{log: log, authorize: authorize}
 }
 // Export liest Filter-Query-Parameter (tenant, actor, action, from, to,
 // format) und schreibt DIREKT auf den ResponseWriter (io.Writer) — dieselbe
 // Streaming-Funktion wie in export.go, kein zusaetzlicher Pufferungsschritt.
 func (h *ExportHandler) Export(w http.ResponseWriter, r *http.Request) {
 	// "caller" identifiziert die anfragende Person fuer die Berechtigungs-
 	// pruefung — bewusst getrennt vom Filterfeld "actor" (das den
 	// AUDIT-Akteur meint, ueber den gefiltert wird).
 	caller := r.URL.Query().Get("caller")
 	if caller == "" || !h.authorize(r.Context(), caller) {
 		http.Error(w, "keine berechtigung fuer audit-log-export", http.StatusForbidden)
 		return
 	}
 	filter := Filter{
 		TenantSlug: r.URL.Query().Get("tenant"),
 		Actor:      r.URL.Query().Get("actor"),
 		Action:     r.URL.Query().Get("action"),
 	}
 	if from := r.URL.Query().Get("from"); from != "" {
 		t, err := time.Parse(time.RFC3339, from)
 		if err != nil {
 			http.Error(w, "ungueltiges from-datum, erwartet RFC3339", http.StatusBadRequest)
 			return
 		}
 		filter.From = &t
 	}
 	if to := r.URL.Query().Get("to"); to != "" {
 		t, err := time.Parse(time.RFC3339, to)
 		if err != nil {
 			http.Error(w, "ungueltiges to-datum, erwartet RFC3339", http.StatusBadRequest)
 			return
 		}
 		filter.To = &t
 	}
 	switch r.URL.Query().Get("format") {
 	case "json":
 		w.Header().Set("Content-Type", "application/x-ndjson")
 		if err := h.log.StreamJSON(r.Context(), filter, w); err != nil {
 			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
 		}
 	default:
 		w.Header().Set("Content-Type", "text/csv")
 		if err := h.log.StreamCSV(r.Context(), filter, w); err != nil {
 			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
 		}
 	}
 }
@@ -0,0 +1,222 @@
 package audit
 import (
 	"bytes"
 	"context"
 	"encoding/csv"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"runtime"
 	"strings"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupExportTest(t *testing.T) (*Log, 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 audit_events (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
 			actor TEXT NOT NULL CHECK (actor <> ''),
 			action TEXT NOT NULL CHECK (action <> ''),
 			target TEXT NOT NULL,
 			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewLog(pool), cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Filterkombinationen liefern korrekte
 // Teilmengen.
 func TestExport_FilterCombinations(t *testing.T) {
 	log, cleanup := setupExportTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	run := fmt.Sprintf("_%d", time.Now().UnixNano())
 	tenantA, tenantB := "test_fa"+run, "test_fb"+run
 	alice, bob := "alice"+run, "bob"+run
 	events := []Event{
 		{TenantSlug: tenantA, Actor: alice, Action: "login", Target: "x"},
 		{TenantSlug: tenantA, Actor: bob, Action: "login", Target: "x"},
 		{TenantSlug: tenantA, Actor: alice, Action: "logout", Target: "x"},
 		{TenantSlug: tenantB, Actor: alice, Action: "login", Target: "x"},
 	}
 	for _, e := range events {
 		if err := log.Record(ctx, e); err != nil {
 			t.Fatalf("record: %v", err)
 		}
 	}
 	cases := []struct {
 		name    string
 		filter  Filter
 		wantLen int
 	}{
 		{"nach tenant", Filter{TenantSlug: tenantA}, 3},
 		{"nach tenant+actor", Filter{TenantSlug: tenantA, Actor: alice}, 2},
 		{"nach tenant+actor+action", Filter{TenantSlug: tenantA, Actor: alice, Action: "login"}, 1},
 		{"nach actor ueber beide tenants", Filter{Actor: alice, Action: "login"}, 2},
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			var buf bytes.Buffer
 			if err := log.StreamCSV(ctx, c.filter, &buf); err != nil {
 				t.Fatalf("stream: %v", err)
 			}
 			rows, err := csv.NewReader(&buf).ReadAll()
 			if err != nil {
 				t.Fatalf("csv parsen: %v", err)
 			}
 			got := len(rows) - 1 // Header abziehen
 			if got != c.wantLen {
 				t.Fatalf("erwartet %d zeilen, habe %d", c.wantLen, got)
 			}
 		})
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Zeitraum-Filter.
 func TestExport_TimeRangeFilter(t *testing.T) {
 	log, cleanup := setupExportTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := fmt.Sprintf("test_tr_%d", time.Now().UnixNano())
 	past := time.Now().Add(-48 * time.Hour)
 	future := time.Now().Add(48 * time.Hour)
 	if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "a", Action: "x", Target: "t", OccurredAt: time.Now()}); err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	var buf bytes.Buffer
 	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &past, To: &future}, &buf); err != nil {
 		t.Fatalf("stream (innerhalb range): %v", err)
 	}
 	if got := countLines(buf.String()) - 1; got != 1 {
 		t.Fatalf("erwartet 1 eintrag innerhalb des zeitraums, habe %d", got)
 	}
 	farPast := time.Now().Add(-96 * time.Hour)
 	buf.Reset()
 	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &farPast, To: &past}, &buf); err != nil {
 		t.Fatalf("stream (ausserhalb range): %v", err)
 	}
 	if got := countLines(buf.String()) - 1; got != 0 {
 		t.Fatalf("erwartet 0 eintraege ausserhalb des zeitraums, habe %d", got)
 	}
 }
 func countLines(s string) int {
 	s = strings.TrimRight(s, "\n")
 	if s == "" {
 		return 0
 	}
 	return len(strings.Split(s, "\n"))
 }
 // Akzeptanzkriterium 3 + Pruefung 1: Export mit hoher Eintragszahl ohne
 // uebermaessigen Speicherverbrauch — Stichprobe per runtime.MemStats.
 func TestExport_StreamsLargeResultWithoutExcessiveMemory(t *testing.T) {
 	log, cleanup := setupExportTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := fmt.Sprintf("test_large_%d", time.Now().UnixNano())
 	const n = 20000
 	for i := 0; i < n; i++ {
 		if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "bulk", Action: "test.bulk", Target: fmt.Sprintf("obj-%d", i)}); err != nil {
 			t.Fatalf("record %d: %v", i, err)
 		}
 	}
 	runtime.GC()
 	var before runtime.MemStats
 	runtime.ReadMemStats(&before)
 	lineCount := 0
 	cw := &countingWriter{onWrite: func(p []byte) { lineCount += strings.Count(string(p), "\n") }}
 	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant}, cw); err != nil {
 		t.Fatalf("stream: %v", err)
 	}
 	runtime.GC()
 	var after runtime.MemStats
 	runtime.ReadMemStats(&after)
 	if lineCount != n+1 { // +1 Header
 		t.Fatalf("erwartet %d zeilen (inkl. header), habe %d", n+1, lineCount)
 	}
 	// Grobe Stichprobe: ein NICHT streamender Export haette hier locker
 	// mehrere MB an einmal gehaltenen Zeilen/Strings erzeugt. Grosszuegige
 	// Schwelle, da Go-Heap-Messungen naturgemaess rauschen.
 	const maxAcceptableGrowth = 3 * 1024 * 1024 // 3 MB
 	growth := int64(after.HeapAlloc) - int64(before.HeapAlloc)
 	t.Logf("heap-wachstum waehrend export von %d zeilen: %d bytes (schwelle: %d)", n, growth, maxAcceptableGrowth)
 	if growth > maxAcceptableGrowth {
 		t.Fatalf("heap ist um %d bytes gewachsen, erwartet unter %d (hinweis auf vollstaendige pufferung statt streaming)", growth, maxAcceptableGrowth)
 	}
 }
 type countingWriter struct {
 	onWrite func(p []byte)
 }
 func (w *countingWriter) Write(p []byte) (int, error) {
 	w.onWrite(p)
 	return len(p), nil
 }
 // Akzeptanzkriterium 2 + Pruefung 3: Zugriff ohne passende Berechtigung wird abgewiesen.
 func TestExportHandler_RejectsWithoutAuthorization(t *testing.T) {
 	log, cleanup := setupExportTest(t)
 	defer cleanup()
 	handler := NewExportHandler(log, func(ctx context.Context, caller string) bool {
 		return caller == "berechtigte-person@example.com"
 	})
 	req := httptest.NewRequest(http.MethodGet, "/audit/export?caller=unberechtigt@example.com", nil)
 	rec := httptest.NewRecorder()
 	handler.Export(rec, req)
 	if rec.Code != http.StatusForbidden {
 		t.Fatalf("unberechtigt: status = %d, want 403", rec.Code)
 	}
 	reqNoCaller := httptest.NewRequest(http.MethodGet, "/audit/export", nil)
 	recNoCaller := httptest.NewRecorder()
 	handler.Export(recNoCaller, reqNoCaller)
 	if recNoCaller.Code != http.StatusForbidden {
 		t.Fatalf("ohne caller: status = %d, want 403", recNoCaller.Code)
 	}
 	reqOK := httptest.NewRequest(http.MethodGet, "/audit/export?caller=berechtigte-person@example.com", nil)
 	recOK := httptest.NewRecorder()
 	handler.Export(recOK, reqOK)
 	if recOK.Code != http.StatusOK {
 		t.Fatalf("berechtigt: status = %d, want 200", recOK.Code)
 	}
 }
@@ -0,0 +1,23 @@
 // Package auditadmin implementiert Core AUD-04: die Berechtigungspruefung
 // fuer die Audit-Log-Ansicht. Enthaelt bewusst KEINE eigene Filter-/
 // Export-Logik — die Ansicht ist "reiner Konsument der Export-API" (AUD-03,
 // internal/audit.ExportHandler); dieses Paket liefert nur die
 // audit.Authorize-Implementierung, die der Entwicklungs-/Testserver
 // (cmd/auditlog-devserver) einhaengt.
 package auditadmin
 import "crypto/subtle"
 // NewTokenAuthorizer liefert eine audit.Authorize-Funktion, die den
 // aufrufenden "caller"-Wert timing-safe gegen ein geteiltes Admin-Token
 // vergleicht — dasselbe Muster wie internal/audit.timingsafe (AUD-02),
 // NICHT ueber eine neue Rollen-/Rechteschicht, da AUD-04 ausdruecklich nur
 // von AUD-03 abhaengt.
 func NewTokenAuthorizer(adminToken string) func(caller string) bool {
 	return func(caller string) bool {
 		if caller == "" || adminToken == "" {
 			return false
 		}
 		return subtle.ConstantTimeCompare([]byte(caller), []byte(adminToken)) == 1
 	}
 }
@@ -0,0 +1,33 @@
 package auditadmin
 import "testing"
 // Grundlage fuer Akzeptanzkriterium 1/2: die Oberflaeche darf Daten und den
 // Export nur bei korrektem Admin-Token abrufen.
 func TestNewTokenAuthorizer_AcceptsCorrectToken(t *testing.T) {
 	authorize := NewTokenAuthorizer("geheimes-token")
 	if !authorize("geheimes-token") {
 		t.Fatal("erwartet true fuer korrektes token")
 	}
 }
 func TestNewTokenAuthorizer_RejectsWrongToken(t *testing.T) {
 	authorize := NewTokenAuthorizer("geheimes-token")
 	if authorize("falsches-token") {
 		t.Fatal("erwartet false fuer falsches token")
 	}
 }
 func TestNewTokenAuthorizer_RejectsEmptyCaller(t *testing.T) {
 	authorize := NewTokenAuthorizer("geheimes-token")
 	if authorize("") {
 		t.Fatal("erwartet false fuer leeren aufrufer")
 	}
 }
 func TestNewTokenAuthorizer_RejectsWhenNoTokenConfigured(t *testing.T) {
 	authorize := NewTokenAuthorizer("")
 	if authorize("irgendwas") {
 		t.Fatal("erwartet false, wenn kein admin-token konfiguriert ist (fail-safe-default)")
 	}
 }
@@ -1,110 +0,0 @@
 // Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
 // Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
 // des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
 // + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
 package flag
 import (
 	"context"
 	"errors"
 	"fmt"
 	"hash/fnv"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var ErrNotFound = errors.New("flag: nicht gefunden")
 // Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
 // getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
 type Flag struct {
 	Key               string
 	Enabled           bool
 	RolloutPercentage int
 	TargetTenantSlugs []string
 }
 // Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 func (s *Store) Set(ctx context.Context, f Flag) error {
 	if f.TargetTenantSlugs == nil {
 		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
 	}
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
 		VALUES ($1, $2, $3, $4, now())
 		ON CONFLICT (key) DO UPDATE SET
 			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
 	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
 	if err != nil {
 		return fmt.Errorf("flag speichern: %w", err)
 	}
 	return nil
 }
 // 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, `
 		SELECT key, enabled, rollout_percentage, target_tenant_slugs
 		FROM feature_flags WHERE key = $1
 	`, key)
 	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Flag{}, ErrNotFound
 		}
 		return Flag{}, fmt.Errorf("flag lesen: %w", err)
 	}
 	return f, nil
 }
 // evaluate wendet die Strategien in fester Reihenfolge an: globaler
 // An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
 // Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
 // kein Feature wird versehentlich aktiv.
 func evaluate(f Flag, tenantSlug string) bool {
 	if f.Enabled {
 		return true
 	}
 	for _, target := range f.TargetTenantSlugs {
 		if target == tenantSlug {
 			return true
 		}
 	}
 	if f.RolloutPercentage > 0 {
 		h := fnv.New32a()
 		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
 		return int(h.Sum32()%100) < f.RolloutPercentage
 	}
 	return false
 }
@@ -1,43 +0,0 @@
 package flag
 import "testing"
 func TestEvaluate_GlobalEnabled(t *testing.T) {
 	f := Flag{Key: "k", Enabled: true}
 	if !evaluate(f, "irgendein-tenant") {
 		t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
 func TestEvaluate_TargetTenantStrategy(t *testing.T) {
 	f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
 	if !evaluate(f, "acme") {
 		t.Fatal("erwartet true fuer tenant in zielgruppe")
 	}
 	if evaluate(f, "globex") {
 		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
 	}
 }
 func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
 	full := Flag{Key: "k", RolloutPercentage: 100}
 	if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
 		t.Fatal("100% rollout sollte immer true liefern")
 	}
 	none := Flag{Key: "k", RolloutPercentage: 0}
 	if evaluate(none, "beliebiger-tenant") {
 		t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
 	}
 }
 func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
 	f := Flag{Key: "k", RolloutPercentage: 50}
 	first := evaluate(f, "stabiler-tenant")
 	for i := 0; i < 5; i++ {
 		if evaluate(f, "stabiler-tenant") != first {
 			t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
 		}
 	}
 }
@@ -1,87 +0,0 @@
 package flag
 import (
 	"context"
 	"log/slog"
 	"sync"
 	"time"
 )
 // DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
 // (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
 // Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
 // muss (Akzeptanzkriterium 3).
 const DefaultCacheTTL = 5 * time.Second
 type cacheEntry struct {
 	flag      Flag
 	expiresAt time.Time
 }
 // Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
 // lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
 type Service struct {
 	store *Store
 	ttl   time.Duration
 	mu    sync.RWMutex
 	cache map[string]cacheEntry
 }
 func NewService(store *Store, ttl time.Duration) *Service {
 	if ttl <= 0 {
 		ttl = DefaultCacheTTL
 	}
 	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
 }
 // IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
 // bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
 // Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
 // der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
 // Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
 func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
 	f, ok := s.resolve(ctx, key)
 	if !ok {
 		return false
 	}
 	return evaluate(f, tenantSlug)
 }
 func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
 	s.mu.RLock()
 	entry, exists := s.cache[key]
 	fresh := exists && time.Now().Before(entry.expiresAt)
 	s.mu.RUnlock()
 	if fresh {
 		return entry.flag, true
 	}
 	f, err := s.store.Get(ctx, key)
 	if err != nil {
 		if exists {
 			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
 				"flag_key", key, "error", err)
 			return entry.flag, true
 		}
 		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
 			"flag_key", key, "error", err)
 		return Flag{}, false
 	}
 	s.mu.Lock()
 	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
 	s.mu.Unlock()
 	return f, true
 }
 // Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
 // aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
 // auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
 // ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
 // DefaultCacheTTL (siehe Akzeptanzkriterium 3).
 func (s *Service) Invalidate(key string) {
 	s.mu.Lock()
 	delete(s.cache, key)
 	s.mu.Unlock()
 }
@@ -1,179 +0,0 @@
 package flag
 import (
 	"context"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupFlagStoreTest(t *testing.T) (*Store, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY,
 			enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0,
 			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
 		pool.Close()
 	}
 	return NewStore(pool), cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
 // die erwartete Auswertung.
 func TestService_TargetTenantStrategy(t *testing.T) {
 	store, cleanup := setupFlagStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	svc := NewService(store, time.Hour)
 	if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
 		t.Fatal("erwartet true fuer tenant in zielgruppe")
 	}
 	if svc.IsEnabled(ctx, "globex", "test_target_flag") {
 		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
 	}
 }
 // Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
 // dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
 func TestService_CacheInvalidationTiming(t *testing.T) {
 	store, cleanup := setupFlagStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	const ttl = 150 * time.Millisecond
 	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	svc := NewService(store, ttl)
 	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
 		t.Fatal("erwartet false vor der aenderung")
 	}
 	// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
 	// Store, ohne svc.Invalidate aufzurufen.
 	changedAt := time.Now()
 	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	// Sofort danach sollte der Cache noch den alten Stand liefern.
 	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
 		t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
 	}
 	deadline := changedAt.Add(ttl + 100*time.Millisecond)
 	for time.Now().Before(deadline) {
 		if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
 			elapsed := time.Since(changedAt)
 			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, ttl)
 			return
 		}
 		time.Sleep(10 * time.Millisecond)
 	}
 	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
 }
 func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
 	store, cleanup := setupFlagStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
 	_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
 	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	svc.Invalidate("test_invalidate_flag")
 	if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
 		t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
 // dokumentiertem Fallback-Verhalten, nicht zum Absturz.
 func TestService_FallsBackOnStoreFailure(t *testing.T) {
 	store, cleanup := setupFlagStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
 		t.Fatalf("set: %v", err)
 	}
 	svc := NewService(store, time.Hour)
 	// Cache vorwaermen, waehrend die DB noch erreichbar ist.
 	if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
 		t.Fatal("erwartet true bei funktionierender db")
 	}
 	brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
 	if err != nil {
 		t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
 	}
 	brokenStore := NewStore(brokenPool)
 	svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
 	svcWithCache.mu.Lock()
 	svcWithCache.cache["test_fallback_flag"] = cacheEntry{
 		flag:      Flag{Key: "test_fallback_flag", Enabled: true},
 		expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
 	}
 	svcWithCache.mu.Unlock()
 	func() {
 		defer func() {
 			if r := recover(); r != nil {
 				t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
 			}
 		}()
 		if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
 			t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
 		}
 	}()
 	// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
 	// default false, kein absturz.
 	freshSvc := NewService(brokenStore, time.Hour)
 	func() {
 		defer func() {
 			if r := recover(); r != nil {
 				t.Fatalf("IsEnabled hat gepanict: %v", r)
 			}
 		}()
 		if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
 			t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
 		}
 	}()
 }
@@ -1,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)
 	}
 }
@@ -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 audit_events;
@@ -0,0 +1,17 @@
 -- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
 -- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
 -- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
 -- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
 -- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
 -- Wert 'system', niemals NULL oder leeren String.
 CREATE TABLE audit_events (
    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
    actor        TEXT NOT NULL CHECK (actor <> ''),
    action       TEXT NOT NULL CHECK (action <> ''),
    target       TEXT NOT NULL,
    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
 );
 CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);
@@ -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()
 );
@@ -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)
 );
@@ -14,6 +14,7 @@ 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;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events 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
@@ -1,7 +1,7 @@
 import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
 export const metadata = {
-  title: "NEXARCH Lizenz- und Modulverwaltung",
+  title: "NEXARCH Audit-Log",
 };
 export default function RootLayout({
@@ -0,0 +1,159 @@
 "use client";
 import { useState } from "react";
 import { fetchRecords, exportURL, type AuditRecord, type AuditFilter } from "@/lib/api";
 const EMPTY_FILTER: AuditFilter = { tenant: "", actor: "", action: "", from: "", to: "" };
 export default function Page() {
  const [caller, setCaller] = useState("");
  const [filter, setFilter] = useState<AuditFilter>(EMPTY_FILTER);
  const [records, setRecords] = useState<AuditRecord[] | null>(null);
  const [selected, setSelected] = useState<AuditRecord | null>(null);
  const [error, setError] = useState<string | null>(null);
  async function onSearch() {
    setError(null);
    setSelected(null);
    try {
      const data = await fetchRecords(caller.trim(), filter);
      setRecords(data);
    } catch (e: any) {
      setError(e.message ?? "Unbekannter Fehler");
      setRecords(null);
    }
  }
  function onExport(format: "csv" | "json") {
    const url = exportURL(caller.trim(), filter, format);
    // Echter Datei-Download ueber Browser-Navigation, KEIN erneutes Parsen
    // im Frontend (Akzeptanzkriterium 2: Export aus AUD-03 direkt ausloesbar).
    window.open(url, "_blank");
  }
  return (
    <main style={{ maxWidth: 1000, margin: "0 auto", padding: "2rem 1rem" }}>
      <h1>Audit-Log</h1>
      <div style={{ display: "grid", gap: "0.5rem", gridTemplateColumns: "repeat(3, 1fr)", marginBottom: "1rem" }}>
        <input
          value={caller}
          onChange={(e) => setCaller(e.target.value)}
          placeholder="Admin-Token (Berechtigung)"
          style={{ padding: "0.5rem", gridColumn: "span 3" }}
        />
        <input
          value={filter.tenant}
          onChange={(e) => setFilter({ ...filter, tenant: e.target.value })}
          placeholder="Tenant"
          style={{ padding: "0.5rem" }}
        />
        <input
          value={filter.actor}
          onChange={(e) => setFilter({ ...filter, actor: e.target.value })}
          placeholder="Akteur"
          style={{ padding: "0.5rem" }}
        />
        <input
          value={filter.action}
          onChange={(e) => setFilter({ ...filter, action: e.target.value })}
          placeholder="Aktion"
          style={{ padding: "0.5rem" }}
        />
        <label>
          Von
          <input
            type="datetime-local"
            value={filter.from}
            onChange={(e) =>
              setFilter({ ...filter, from: e.target.value ? new Date(e.target.value).toISOString() : "" })
            }
            style={{ width: "100%", padding: "0.4rem" }}
          />
        </label>
        <label>
          Bis
          <input
            type="datetime-local"
            value={filter.to}
            onChange={(e) =>
              setFilter({ ...filter, to: e.target.value ? new Date(e.target.value).toISOString() : "" })
            }
            style={{ width: "100%", padding: "0.4rem" }}
          />
        </label>
      </div>
      <div style={{ display: "flex", gap: "0.5rem", marginBottom: "1rem" }}>
        <button onClick={onSearch}>Suchen</button>
        <button onClick={() => onExport("csv")}>Export als CSV</button>
        <button onClick={() => onExport("json")}>Export als JSON</button>
      </div>
      {error && (
        <p style={{ color: "#c62828" }} role="alert">
          Fehler: {error}
        </p>
      )}
      {records && (
        <table style={{ width: "100%", borderCollapse: "collapse", background: "white" }}>
          <thead>
            <tr style={{ textAlign: "left", borderBottom: "2px solid #ddd" }}>
              <th style={{ padding: "0.5rem" }}>Zeitpunkt</th>
              <th style={{ padding: "0.5rem" }}>Tenant</th>
              <th style={{ padding: "0.5rem" }}>Akteur</th>
              <th style={{ padding: "0.5rem" }}>Aktion</th>
              <th style={{ padding: "0.5rem" }}></th>
            </tr>
          </thead>
          <tbody>
            {records.map((r, i) => (
              <tr key={i} style={{ borderBottom: "1px solid #eee" }}>
                <td style={{ padding: "0.5rem" }}>{new Date(r.occurred_at).toLocaleString("de-DE")}</td>
                <td style={{ padding: "0.5rem" }}>{r.tenant_slug}</td>
                <td style={{ padding: "0.5rem" }}>{r.actor}</td>
                <td style={{ padding: "0.5rem" }}>{r.action}</td>
                <td style={{ padding: "0.5rem" }}>
                  <button onClick={() => setSelected(r)}>Details</button>
                </td>
              </tr>
            ))}
            {records.length === 0 && (
              <tr>
                <td colSpan={5} style={{ padding: "0.5rem" }}>
                  Keine Einträge gefunden.
                </td>
              </tr>
            )}
          </tbody>
        </table>
      )}
      {selected && (
        <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
          <h2>Eintrag-Details</h2>
          <dl>
            <dt>Zeitpunkt</dt>
            <dd>{new Date(selected.occurred_at).toLocaleString("de-DE")}</dd>
            <dt>Tenant</dt>
            <dd>{selected.tenant_slug}</dd>
            <dt>Akteur</dt>
            <dd>{selected.actor}</dd>
            <dt>Aktion</dt>
            <dd>{selected.action}</dd>
            <dt>Ziel</dt>
            <dd>{selected.target}</dd>
            <dt>Metadaten</dt>
            <dd>
              <pre style={{ whiteSpace: "pre-wrap", background: "#f5f6f8", padding: "0.5rem" }}>
                {JSON.stringify(selected.metadata, null, 2)}
              </pre>
            </dd>
          </dl>
          <button onClick={() => setSelected(null)}>Schließen</button>
        </section>
      )}
    </main>
  );
 }
@@ -0,0 +1,63 @@
 // Duenner Client der AUD-03-Export-API (internal/audit.ExportHandler) —
 // keine eigene Aggregations-/Filterlogik im Frontend (Ticket-Vorgabe:
 // "reiner Konsument der Export-API"). Die JSON-Lines-Antwort wird nur
 // dekodiert, nicht neu berechnet oder gefiltert.
 export type AuditRecord = {
  occurred_at: string;
  tenant_slug: string;
  actor: string;
  action: string;
  target: string;
  metadata: unknown;
 };
 export type AuditFilter = {
  tenant: string;
  actor: string;
  action: string;
  from: string; // RFC3339, leer = kein Filter
  to: string;
 };
 function apiBase(): string {
  const base = process.env.NEXT_PUBLIC_AUDITLOG_API_URL;
  if (!base) {
    throw new Error(
      "NEXT_PUBLIC_AUDITLOG_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
    );
  }
  return base;
 }
 function buildParams(caller: string, filter: AuditFilter, format: "json" | "csv"): URLSearchParams {
  const params = new URLSearchParams({ caller, format });
  if (filter.tenant) params.set("tenant", filter.tenant);
  if (filter.actor) params.set("actor", filter.actor);
  if (filter.action) params.set("action", filter.action);
  if (filter.from) params.set("from", filter.from);
  if (filter.to) params.set("to", filter.to);
  return params;
 }
 // exportURL liefert die Adresse desselben Endpunkts, den auch die
 // Export-Datei-Funktion (Akzeptanzkriterium 2) verwendet — Liste und Export
 // sind bewusst DERSELBE API-Aufruf mit unterschiedlichem "format".
 export function exportURL(caller: string, filter: AuditFilter, format: "json" | "csv"): string {
  return `${apiBase()}/audit/export?${buildParams(caller, filter, format)}`;
 }
 // fetchRecords laedt die Liste als JSON-Lines und dekodiert Zeile fuer
 // Zeile — dieselben Filterparameter wie ein direkter API-Aufruf
 // (Akzeptanzkriterium 1 / Pruefung 1).
 export async function fetchRecords(caller: string, filter: AuditFilter): Promise<AuditRecord[]> {
  const res = await fetch(exportURL(caller, filter, "json"), { cache: "no-store" });
  if (!res.ok) {
    const text = await res.text().catch(() => "");
    throw new Error(text || `Anfrage fehlgeschlagen (${res.status})`);
  }
  const text = await res.text();
  return text
    .split("\n")
    .filter((line) => line.trim() !== "")
    .map((line) => JSON.parse(line) as AuditRecord);
 }
@@ -1,5 +1,5 @@
 {
-  "name": "nexarch-lic-admin",
+  "name": "nexarch-audit-log",
  "private": true,
  "scripts": {
    "dev": "next dev",
@@ -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})`);
  }
 }
Author	SHA1	Message	Date
sysops	6537888da6	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht	2026-08-28 22:02:02 +02:00
sysops	554c9aae66	AUD-04: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)	2026-08-28 21:56:27 +02:00
sysops	1ba90319a2	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht	2026-08-28 21:56:20 +02:00
sysops	f344f79326	AUD-04: Retrofit auf SHL-01 (ThemeProvider/I18nProvider/ToastProvider, Design-Tokens statt hartkodierter Werte)	2026-08-28 21:47:23 +02:00
sysops	c4bcfa8caf	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht # Conflicts: # DEVLOG.md	2026-08-28 21:47:09 +02:00
sysops	3b96d8ef41	AUD-04: backend-authorizer + dev-server + next.js audit-log-ansicht	2026-08-28 00:10:48 +02:00
sysopsandClaude Sonnet 5	c9e8edbbf0	AUD-03: audit-log-export-filter-api internal/audit/export.go: StreamCSV/StreamJSON filtern nach Tenant, Akteur, Aktion und Zeitraum (Akzeptanzkriterium 1) und schreiben Zeile fuer Zeile ueber rows.Next() DIREKT auf den uebergebenen io.Writer — zu keinem Zeitpunkt wird das komplette Ergebnis im Speicher aufgebaut (Akzeptanz- kriterium 3). JSON-Export als JSON Lines statt einem grossen Array, um Streaming ohne Sonderbehandlung von Klammern/Kommas zu ermoeglichen. ExportHandler (Akzeptanzkriterium 2) schreibt direkt auf http.ResponseWriter — derselbe Streaming-Pfad wie in Tests, kein Zwischenpuffer nur fuer HTTP. Authorize ist eine schmale Schnittstelle (Vorbild: AUD-05 RetentionRegistrar- Muster), da die eigentliche Rollenpruefung RBAC-02 (Policy-Enforcement) ist und nicht Teil dieser Kachel — der Handler kennt nur "darf dieser Aufrufer exportieren", nicht wie das entschieden wird. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Export mit hoher Eintragszahl ohne uebermaessigen Speicherverbrauch — TestExport_StreamsLargeResultWithoutExcessiveMemory: 20.000 Eintraege, Heap-Wachstum waehrend Export nur ~1.8KB (Schwelle 3MB). PASS. 2. Filterkombinationen automatisiert gegen erwartete Ergebnismengen — TestExport_FilterCombinations (Tenant/Actor/Action einzeln und kombiniert) und TestExport_TimeRangeFilter (innerhalb/ausserhalb Zeitraum). PASS. 3. Zugriff ohne passende Berechtigung abgewiesen — TestExportHandler_RejectsWithoutAuthorization: fehlender/falscher caller -> 403, berechtigter caller -> 200. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:02:56 +02:00
sysopsandClaude Sonnet 5	b12d53f469	AUD-01: zentrales-audit-log-modell internal/audit: eigenes, strukturiertes Audit-Datenmodell (Akteur, Aktion, Zielobjekt, Zeitpunkt, Tenant) in der Registry-DB, getrennt von jedem allgemeinen Anwendungs-Log (eigenes Paket, eigene Tabelle audit_events, kein Logging-Framework). Log.Record ist der EINE zentrale Schreibpfad — es gibt keine zweite Schreibmoeglichkeit, ueber die ein Handler die Validierung umgehen koennte. Fehlender Tenant-Bezug wird zweifach verhindert (Akzeptanzkriterium 2): Log.Record weist leeren TenantSlug direkt ab (ErrMissingTenant), zusaetzlich erzwingt eine CHECK-Constraint in der Migration dasselbe auf Datenbankebene, selbst wenn Log.Record umgangen wuerde. Mandantenuebergreifende Ereignisse (z.B. Superadmin-Aktionen) nutzen den reservierten Wert audit.SystemTenant statt NULL oder leerem String — es gibt keinen Weg, ganz ohne Tenant-Bezug zu schreiben. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Automatisierter Test belegt genau einen Audit-Eintrag pro sicherheitsrelevantem Vorgang — TestRecord_PersistsExactlyOneEventPerSecurityIncident (simulierter fehlgeschlagener Login), Feldinhalte verifiziert. PASS. 2. Fehlender Tenant-Bezug durch Constraint/Test verhindert — TestRecord_RejectsMissingTenant (App-Ebene) UND TestConstraint_RejectsMissingTenantAtDatabaseLevel (direkter INSERT unter Umgehung von Log.Record, durch CHECK-Constraint abgewiesen). PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:22:50 +02:00
		`@@ -1,2 +0,0 @@`
			`DROP TABLE IF EXISTS usage_quotas;`
			`DROP TABLE IF EXISTS usage_counters;`