Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/lic-04-lizenz-modul-verwaltungsoberflaeche

# Conflicts:
#	DEVLOG.md

cmd/auditlog-devserver/main.go

@@ -1,69 +0,0 @@
-// 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)
-	}
-}

cmd/licadmin-devserver/main.go

@@ -0,0 +1,81 @@
+// 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)
+	}
+}

internal/adminapi/lichandler.go

@@ -0,0 +1,226 @@
+// 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})
+}

internal/adminapi/lichandler_test.go

@@ -0,0 +1,275 @@
+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)
+	}
+}

internal/audit/audit.go

@@ -1,96 +0,0 @@
-// 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
-}

internal/audit/audit_test.go

@@ -1,132 +0,0 @@
-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)
-	}
-}

internal/audit/export.go

@@ -1,122 +0,0 @@
-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()
-}

internal/audit/export_handler.go

@@ -1,73 +0,0 @@
-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)
-		}
-	}
-}

internal/audit/export_test.go

@@ -1,222 +0,0 @@
-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)
-	}
-}

internal/auditadmin/authorize.go

@@ -1,23 +0,0 @@
-// 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
-	}
-}

internal/auditadmin/authorize_test.go

@@ -1,33 +0,0 @@
-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)")
-	}
-}

internal/flag/flag.go

@@ -0,0 +1,110 @@
+// 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
+}

internal/flag/flag_test.go

@@ -0,0 +1,43 @@
+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")
+		}
+	}
+}

internal/flag/service.go

@@ -0,0 +1,87 @@
+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()
+}

internal/flag/service_test.go

@@ -0,0 +1,179 @@
+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")
+		}
+	}()
+}

internal/license/license.go

@@ -0,0 +1,106 @@
+// 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
+}

internal/license/license_test.go

@@ -0,0 +1,106 @@
+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)
+		}
+	}
+}

internal/license/store.go

@@ -0,0 +1,88 @@
+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
+}

internal/license/store_test.go

@@ -0,0 +1,177 @@
+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)
+	}
+}

internal/usage/aggregation.go

@@ -0,0 +1,32 @@
+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)
+			}
+		}
+	}
+}

internal/usage/usage.go

@@ -0,0 +1,144 @@
+// 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
+}

internal/usage/usage_test.go

@@ -0,0 +1,206 @@
+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)
+	}
+}

migrations/0004_audit_events.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS audit_events;

migrations/0004_audit_events.up.sql

@@ -1,17 +0,0 @@
--- 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);

migrations/0004_tenant_licenses.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenant_licenses;

migrations/0004_tenant_licenses.up.sql

@@ -0,0 +1,12 @@
+-- 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()
+);

migrations/0005_usage_counters.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS usage_quotas;
+DROP TABLE IF EXISTS usage_counters;

migrations/0005_usage_counters.up.sql

@@ -0,0 +1,15 @@
+-- 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)
+);

scripts/reset-test-env.sh

@@ -14,7 +14,6 @@ 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

web/audit-log/app/page.tsx

@@ -1,159 +0,0 @@
-"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>
-  );
-}

web/audit-log/lib/api.ts

@@ -1,63 +0,0 @@
-// 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);
-}

web/lic-admin/app/layout.tsx

@@ -1,7 +1,7 @@
 import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
 
 export const metadata = {
-  title: "NEXARCH Audit-Log",
+  title: "NEXARCH Lizenz- und Modulverwaltung",
 };
 
 export default function RootLayout({

web/lic-admin/app/page.tsx

@@ -0,0 +1,173 @@
+"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>
+  );
+}

web/lic-admin/lib/api.ts

@@ -0,0 +1,63 @@
+// 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})`);
+  }
+}

web/lic-admin/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "nexarch-audit-log",
+  "name": "nexarch-lic-admin",
   "private": true,
   "scripts": {
     "dev": "next dev",