Merge branch 'feature/lic-04-lizenz-modul-verwaltungsoberflaeche' into feature/qa-09-barrierefreiheits-audit

# Conflicts:
#	DEVLOG.md
#	go.mod
#	go.sum
#	internal/flag/flag.go
#	scripts/reset-test-env.sh

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)
+	}
+}

go.sum

@@ -1,8 +1,11 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+<<<<<<< HEAD
 github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
 github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+=======
+>>>>>>> feature/lic-04-lizenz-modul-verwaltungsoberflaeche
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=

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/flag/flag.go

@@ -50,6 +50,29 @@ func (s *Store) Set(ctx context.Context, f Flag) error {
 	return nil
 }
 
+// List liefert alle definierten Flags (Admin-Uebersicht, siehe LIC-04) —
+// rein additiv, aendert nichts am bestehenden Verhalten von Set/Get.
+func (s *Store) List(ctx context.Context) ([]Flag, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags ORDER BY key
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("flags auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Flag
+	for rows.Next() {
+		var f Flag
+		if err := rows.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+			return nil, fmt.Errorf("flag-zeile lesen: %w", err)
+		}
+		out = append(out, f)
+	}
+	return out, rows.Err()
+}
+
 func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
 	var f Flag
 	row := s.pool.QueryRow(ctx, `

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_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

@@ -32,6 +32,9 @@ psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EX
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS feature_flags CASCADE;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS module_credentials CASCADE;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS modules CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS usage_quotas CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS usage_counters CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenant_licenses 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/lic-admin/app/layout.tsx

@@ -0,0 +1,30 @@
+import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
+
+export const metadata = {
+  title: "NEXARCH Lizenz- und Modulverwaltung",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="de">
+      <body
+        style={{
+          fontFamily: typography.fontFamily,
+          margin: 0,
+          background: "var(--shl-color-background, #ffffff)",
+          color: "var(--shl-color-text-primary, #14181f)",
+        }}
+      >
+        <ThemeProvider>
+          <I18nProvider initialLocale="de">
+            <ToastProvider>{children}</ToastProvider>
+          </I18nProvider>
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}

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/next.config.mjs

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // @nexarch/shl liegt als file:-Dependency mit TS-Quellen in node_modules —
+  // Next.js transpiliert node_modules standardmäßig nicht, siehe web/shl/README.md.
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;

web/lic-admin/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "nexarch-lic-admin",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@nexarch/shl": "file:../shl",
+    "next": "14.2.35",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "20.14.9",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "typescript": "5.5.3"
+  }
+}

web/lic-admin/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}