IAM-05: ldap-active-directory-anbindung

internal/ldapsync: Client ist eine Schnittstelle (Search() liefert Entry-
Liste) — in dieser Umgebung steht kein echter LDAP/AD-Server zur Verfuegung
(analog AUD-05/Archive), daher ist die Sync-/Rollenzuordnungs-Logik
vollstaendig gegen einen Fake getestet, eine echte Verbindungspruefung gegen
LDAP/AD steht noch aus.

RoleMappingStore (Akzeptanzkriterium 3): explizite Erlaubnis-Matrix
LDAP-Gruppe -> Rolle. HighestRoleFor vergibt NUR fuer explizit gemappte
Gruppen eine Rolle — eine unbekannte Gruppe, auch wenn ihr Name zufaellig
wie eine interne Rolle aussieht ("tenant_admin", "superadmin"), traegt
strukturell nichts bei (kein Code-Pfad, der eine ungemappte Gruppe je einer
Rolle zuordnet) — behebt die aus archivmail bekannte Privilege-Escalation-
Fehlerklasse von Grund auf statt nachtraeglich zu haerten.

Syncer.Run ruft Search() als ALLERERSTES auf; schlaegt es fehl, wird ohne
jede Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2).
Pro Eintrag isolierte Fehler landen in SyncResult.Failed, ohne andere
Eintraege zu beeintraechtigen. Deaktivierung in LDAP wird als
users.Deactivate uebernommen (Akzeptanzkriterium 3). ldap_config speichert
bewusst nur den NAMEN einer Umgebungsvariable fuer das Bind-Passwort, nie
das Passwort selbst.

internal/rbac (RBAC-01) wurde 1:1 aus dem rbac-01-Branch uebernommen (git
show aus derselben Repo-Historie) — IAM-05 haengt an RBAC-01 fuer die
Rollenzuweisung, beide Boards leben aber auf getrennten, noch nicht
gemergten Feature-Branches ohne gemeinsame Historie.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Rollen-Erlaubnis-Matrix mit Positiv- und Negativfaellen automatisiert
   getestet (keine Privilege-Escalation) — TestRoleMapping_PositiveAndNegativeCases:
   gemappte Gruppe liefert Rolle, unbekannte Gruppe und rollen-aehnlich
   benannte, aber nie gemappte Gruppen liefern keine. PASS.
2. Synchronisationslauf mit fehlerhafter/nicht erreichbarer LDAP-Quelle
   bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen —
   TestSyncer_AbortsCleanlyOnSourceError: bestehendes Konto bleibt nach
   fehlgeschlagenem Lauf unveraendert aktiv. PASS.
3. Deaktivierung eines Benutzers in LDAP wird bei naechster Synchronisation
   korrekt uebernommen — TestSyncer_AppliesDeactivationOnNextRun: erster
   Lauf legt aktiven Benutzer an, zweiter Lauf mit Disabled=true setzt ihn
   auf inaktiv. PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -1,4 +1,2 @@
 *.log
 .env
-web/*/node_modules/
-web/*/.next/

DEVLOG.md

@@ -64,9 +64,6 @@ Keine Änderungen ermittelbar.
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
-## 2026-08-28 21:44 – 21:44 (0m)
-**Beschreibung:** Claude Code Session
-**Projekt:** nexarch
 
 ### Commits
 Keine Commits in dieser Session.
@@ -130,32 +127,5 @@ Keine Commits in dieser Session.
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
-- web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
-- web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
-- web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/index.ts                    | 25 +++++++++++++++++++++++++
-- web/shl/package.json                | 23 +++++++++++++++++++++++
-- web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- web/shl/tsconfig.json               | 18 ++++++++++++++++++
-
----
-## 2026-08-28 21:51 – 21:57 (5m)
-**Beschreibung:** Claude Code Session
-**Projekt:** nexarch
-
-### Commits
-- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
-
-### Geänderte Dateien
-- web/shl/package.json     | 2 ++
-- web/shl/vitest.config.ts | 8 ++++++++
-- web/shl/vitest.setup.ts  | 1 +
 
 ---

cmd/core/main.go

@@ -8,6 +8,7 @@ import (
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 
 func main() {
@@ -34,12 +35,20 @@ func main() {
 	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
 	tenantHandler := tenant.NewHandler(provisioner)
 
+	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
+	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
+	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
+	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
+	superadmins := user.NewSuperadminStore(registryPool)
+	userHandler := user.NewHandler(nil, superadmins)
+
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
+	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
 	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
+	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

cmd/licadmin-devserver/main.go

@@ -1,81 +0,0 @@
-// licadmin-devserver stellt das LIC-04-Backend-API (internal/adminapi) fuer
-// die Next.js-Verwaltungsoberflaeche bereit. Getrennt von cmd/core, da die
-// Verdrahtung von license.Validator (Ed25519-Public-Key) in die zentrale
-// Server-Topologie erst mit API-01/IAM-01 (Auth vor internen Endpunkten)
-// sinnvoll ist — dieser Server dient der Entwicklung/dem Betrieb der
-// Verwaltungsoberflaeche gegen eine echte Datenbank, ohne cmd/core
-// anzufassen (Kein Umbau angrenzender Bereiche).
-package main
-
-import (
-	"context"
-	"crypto/ed25519"
-	"encoding/base64"
-	"log"
-	"net/http"
-	"os"
-	"time"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/adminapi"
-	"gitea.perlbach24.de/scripte/nexarch/internal/db"
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/license"
-	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
-)
-
-func main() {
-	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
-	if dsn == "" {
-		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
-	}
-	pubKeyB64 := os.Getenv("NEXARCH_LICENSE_PUBLIC_KEY")
-	if pubKeyB64 == "" {
-		log.Fatal("NEXARCH_LICENSE_PUBLIC_KEY nicht gesetzt (base64, raw-url-encoding)")
-	}
-	pubKeyRaw, err := base64.RawURLEncoding.DecodeString(pubKeyB64)
-	if err != nil || len(pubKeyRaw) != ed25519.PublicKeySize {
-		log.Fatalf("NEXARCH_LICENSE_PUBLIC_KEY ungueltig: %v", err)
-	}
-
-	addr := os.Getenv("NEXARCH_LICADMIN_LISTEN_ADDR")
-	if addr == "" {
-		addr = ":8081"
-	}
-
-	ctx := context.Background()
-	pool, err := db.Connect(ctx, dsn)
-	if err != nil {
-		log.Fatalf("db: %v", err)
-	}
-	defer pool.Close()
-
-	licenseStore := license.NewStore(pool, license.NewValidator(ed25519.PublicKey(pubKeyRaw)))
-	flagStore := flag.NewStore(pool)
-	flagService := flag.NewService(flagStore, 5*time.Second)
-	usageStore := usage.NewStore(pool)
-	handler := adminapi.NewHandler(licenseStore, flagStore, flagService, usageStore)
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/admin/overview", withCORS(handler.OverviewHandler))
-	mux.HandleFunc("/admin/flags/toggle", withCORS(handler.ToggleFlagHandler))
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	log.Printf("licadmin-devserver listening on %s", addr)
-	log.Fatal(http.ListenAndServe(addr, mux))
-}
-
-// withCORS erlaubt lokale Entwicklung des Next.js-Frontends auf einem
-// anderen Port als das Backend-API — ausschliesslich fuer diesen
-// Entwicklungsserver, keine Produktionshaertung.
-func withCORS(next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
-		if r.Method == http.MethodOptions {
-			w.WriteHeader(http.StatusOK)
-			return
-		}
-		next(w, r)
-	}
-}

go.mod

@@ -2,13 +2,16 @@ module gitea.perlbach24.de/scripte/nexarch
 
 go 1.22
 
-require github.com/jackc/pgx/v5 v5.6.0
+require (
+	github.com/golang-jwt/jwt/v5 v5.3.1
+	github.com/jackc/pgx/v5 v5.6.0
+	golang.org/x/crypto v0.17.0
+)
 
 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
-	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 )

go.sum

@@ -1,6 +1,8 @@
 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=
+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=
 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

@@ -1,226 +0,0 @@
-// Package adminapi implementiert Core LIC-04: das Backend-API fuer die
-// Lizenz-/Modul-Verwaltungsoberflaeche. Das Paket enthaelt KEINE eigene
-// Lizenz-/Flag-/Quota-Logik, sondern ist ein duenner Vermittler ueber
-// internal/license, internal/flag und internal/usage (Ticket-Vorgabe:
-// "Verwaltungsoberflaeche als duenner Client ... ohne eigene Lizenzlogik").
-package adminapi
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/license"
-	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
-)
-
-// UsageMetrics sind die Metriken, die auf der Uebersichtsseite je Tenant
-// dargestellt werden (Akzeptanzkriterium 3). Neue Metriken hinzuzufuegen
-// beruehrt kein bestehendes Verhalten von internal/usage.
-var UsageMetrics = []string{"users", "storage_bytes", "api_calls"}
-
-// FlagOverview ist ein Flag zusammen mit der fuer den Tenant ausgewerteten
-// Berechtigung, es umzuschalten (Akzeptanzkriterium 2).
-type FlagOverview struct {
-	Key       string `json:"key"`
-	Enabled   bool   `json:"enabled"`
-	Licensed  bool   `json:"licensed"`
-	DenyGrund string `json:"deny_grund,omitempty"`
-}
-
-// UsageOverview ist eine Metrik mit Zaehlerstand, Quota und Status
-// (Akzeptanzkriterium 3).
-type UsageOverview struct {
-	Metric string       `json:"metric"`
-	Value  int64        `json:"value"`
-	Limit  int64        `json:"limit"`
-	Status usage.Status `json:"status"`
-}
-
-// Overview ist die vollstaendige Antwort fuer die Uebersichtsseite
-// (Akzeptanzkriterium 1: Lizenzstatus/Laufzeit/Module auf einen Blick).
-type Overview struct {
-	Plan       string          `json:"plan"`
-	Modules    []string        `json:"modules"`
-	IssuedAt   string          `json:"issued_at"`
-	ValidUntil string          `json:"valid_until"`
-	Expired    bool            `json:"expired"`
-	Flags      []FlagOverview  `json:"flags"`
-	Usage      []UsageOverview `json:"usage"`
-}
-
-// ErrFlagNotLicensed wird geliefert, wenn ein Administrator versucht, ein
-// Flag zu aktivieren, dessen zugehoeriges Modul die Lizenz nicht umfasst
-// (Akzeptanzkriterium 2 / Pruefung 1).
-var ErrFlagNotLicensed = errors.New("adminapi: modul ist durch die aktuelle lizenz nicht freigeschaltet")
-
-// Handler buendelt die drei Vorbedingungs-Dienste hinter einem gemeinsamen
-// HTTP-API fuer das Frontend.
-type Handler struct {
-	licenseStore *license.Store
-	flagStore    *flag.Store
-	flagService  *flag.Service
-	usageStore   *usage.Store
-}
-
-func NewHandler(licenseStore *license.Store, flagStore *flag.Store, flagService *flag.Service, usageStore *usage.Store) *Handler {
-	return &Handler{licenseStore: licenseStore, flagStore: flagStore, flagService: flagService, usageStore: usageStore}
-}
-
-// isModuleLicensed prueft, ob ein Flag-Schluessel als lizenziertes Modul
-// gilt. Konvention: ein Flag-Key der Form "module:<name>" ist an das
-// gleichnamige Modul in Payload.Modules gebunden; alle anderen Flag-Keys
-// gelten als lizenzunabhaengige, rein funktionale Schalter.
-func isModuleLicensed(key string, modules []string) (moduleName string, isModuleFlag bool, licensed bool) {
-	const prefix = "module:"
-	if !strings.HasPrefix(key, prefix) {
-		return "", false, true
-	}
-	moduleName = strings.TrimPrefix(key, prefix)
-	for _, m := range modules {
-		if m == moduleName {
-			return moduleName, true, true
-		}
-	}
-	return moduleName, true, false
-}
-
-// Overview liefert die kombinierte Uebersicht fuer einen Tenant
-// (Akzeptanzkriterium 1 + 3).
-func (h *Handler) Overview(ctx context.Context, tenantID string) (Overview, error) {
-	lic, err := h.licenseStore.Status(ctx, tenantID)
-	if err != nil {
-		return Overview{}, fmt.Errorf("lizenzstatus lesen: %w", err)
-	}
-	_, expiredErr := h.licenseStore.RequireActive(ctx, tenantID)
-	expired := errors.Is(expiredErr, license.ErrLicenseExpired)
-
-	flags, err := h.flagStore.List(ctx)
-	if err != nil {
-		return Overview{}, fmt.Errorf("flags lesen: %w", err)
-	}
-
-	tenantSlug := tenantID // Auswertung erwartet den Tenant-Bezug als String; Aufloesung ID->Slug obliegt dem Aufrufer (siehe Handler-Tests).
-	flagOverviews := make([]FlagOverview, 0, len(flags))
-	for _, f := range flags {
-		_, _, licensed := isModuleLicensed(f.Key, lic.Modules)
-		fo := FlagOverview{
-			Key:      f.Key,
-			Enabled:  h.flagService.IsEnabled(ctx, tenantSlug, f.Key),
-			Licensed: licensed,
-		}
-		if !licensed {
-			fo.DenyGrund = "Modul ist im aktuellen Lizenzplan nicht enthalten"
-		}
-		flagOverviews = append(flagOverviews, fo)
-	}
-
-	usageOverviews := make([]UsageOverview, 0, len(UsageMetrics))
-	for _, metric := range UsageMetrics {
-		value, limit, status, err := h.usageStore.Check(ctx, tenantID, metric)
-		if err != nil {
-			return Overview{}, fmt.Errorf("nutzungsstand lesen (%s): %w", metric, err)
-		}
-		usageOverviews = append(usageOverviews, UsageOverview{
-			Metric: metric, Value: value, Limit: limit, Status: status,
-		})
-	}
-
-	return Overview{
-		Plan:       lic.Plan,
-		Modules:    lic.Modules,
-		IssuedAt:   lic.IssuedAt.Format("2006-01-02T15:04:05Z07:00"),
-		ValidUntil: lic.ValidUntil.Format("2006-01-02T15:04:05Z07:00"),
-		Expired:    expired,
-		Flags:      flagOverviews,
-		Usage:      usageOverviews,
-	}, nil
-}
-
-// ToggleFlag schaltet ein Flag global an/aus, NACHDEM geprueft wurde, dass
-// das zugehoerige Modul lizenziert ist (Akzeptanzkriterium 2 / Pruefung 1).
-// Ein nicht lizenziertes Modul wird mit ErrFlagNotLicensed abgelehnt, bevor
-// irgendein Schreibzugriff erfolgt.
-func (h *Handler) ToggleFlag(ctx context.Context, tenantID, key string, enabled bool) error {
-	lic, err := h.licenseStore.Status(ctx, tenantID)
-	if err != nil {
-		return fmt.Errorf("lizenzstatus lesen: %w", err)
-	}
-
-	if enabled {
-		if _, _, licensed := isModuleLicensed(key, lic.Modules); !licensed {
-			return ErrFlagNotLicensed
-		}
-	}
-
-	existing, err := h.flagStore.Get(ctx, key)
-	if err != nil && !errors.Is(err, flag.ErrNotFound) {
-		return fmt.Errorf("flag lesen: %w", err)
-	}
-	existing.Key = key
-	existing.Enabled = enabled
-
-	if err := h.flagStore.Set(ctx, existing); err != nil {
-		return fmt.Errorf("flag speichern: %w", err)
-	}
-	h.flagService.Invalidate(key)
-	return nil
-}
-
-// --- HTTP-Bindung ---
-
-func (h *Handler) OverviewHandler(w http.ResponseWriter, r *http.Request) {
-	tenantID := r.URL.Query().Get("tenant")
-	if tenantID == "" {
-		writeError(w, http.StatusBadRequest, "tenant-parameter fehlt")
-		return
-	}
-	overview, err := h.Overview(r.Context(), tenantID)
-	if err != nil {
-		writeError(w, http.StatusInternalServerError, err.Error())
-		return
-	}
-	writeJSON(w, http.StatusOK, overview)
-}
-
-type toggleRequest struct {
-	Tenant  string `json:"tenant"`
-	Key     string `json:"key"`
-	Enabled bool   `json:"enabled"`
-}
-
-func (h *Handler) ToggleFlagHandler(w http.ResponseWriter, r *http.Request) {
-	var req toggleRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
-		return
-	}
-	if req.Tenant == "" || req.Key == "" {
-		writeError(w, http.StatusBadRequest, "tenant und key sind erforderlich")
-		return
-	}
-
-	err := h.ToggleFlag(r.Context(), req.Tenant, req.Key, req.Enabled)
-	switch {
-	case err == nil:
-		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
-	case errors.Is(err, ErrFlagNotLicensed):
-		writeError(w, http.StatusForbidden, ErrFlagNotLicensed.Error())
-	default:
-		writeError(w, http.StatusInternalServerError, err.Error())
-	}
-}
-
-func writeJSON(w http.ResponseWriter, status int, body any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(body)
-}
-
-func writeError(w http.ResponseWriter, status int, message string) {
-	writeJSON(w, status, map[string]string{"error": message})
-}

internal/adminapi/lichandler_test.go

@@ -1,275 +0,0 @@
-package adminapi
-
-import (
-	"bytes"
-	"context"
-	"crypto/ed25519"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/license"
-	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
-)
-
-type testEnv struct {
-	handler  *Handler
-	tenantID string
-	pool     *pgxpool.Pool
-}
-
-func setupTest(t *testing.T) (testEnv, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS tenant_licenses (
-			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
-			plan TEXT NOT NULL,
-			modules TEXT[] NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL,
-			valid_until TIMESTAMPTZ NOT NULL,
-			raw_key TEXT NOT NULL,
-			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY,
-			enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0,
-			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS usage_counters (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
-		);
-		CREATE TABLE IF NOT EXISTS usage_quotas (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
-			PRIMARY KEY (tenant_id, metric)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	slug := fmt.Sprintf("adminapi_test_%d", time.Now().UnixNano())
-	var tenantID string
-	if err := pool.QueryRow(ctx, `
-		INSERT INTO tenants (slug, name, db_name, db_dsn)
-		VALUES ($1, 'Adminapi Test', $1, 'unused') RETURNING id
-	`, slug).Scan(&tenantID); err != nil {
-		t.Fatalf("test-tenant anlegen: %v", err)
-	}
-
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar: %v", err)
-	}
-	issuer := license.NewIssuer(priv)
-	licenseStore := license.NewStore(pool, license.NewValidator(pub))
-
-	payload := license.Payload{
-		TenantSlug: slug,
-		Plan:       "professional",
-		Modules:    []string{"dms", "mail"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
-	}
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("lizenz ausstellen: %v", err)
-	}
-	if _, err := licenseStore.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("lizenz installieren: %v", err)
-	}
-
-	flagStore := flag.NewStore(pool)
-	flagService := flag.NewService(flagStore, time.Millisecond) // sehr kurze TTL, damit Tests nicht auf Cache-Ablauf warten muessen
-	usageStore := usage.NewStore(pool)
-
-	handler := NewHandler(licenseStore, flagStore, flagService, usageStore)
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM usage_quotas WHERE tenant_id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM usage_counters WHERE tenant_id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`)
-		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'adminapi\_test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return testEnv{handler: handler, tenantID: tenantID, pool: pool}, cleanup
-}
-
-// Akzeptanzkriterium 1: Lizenzstatus, Laufzeit und Module sind auf einen
-// Blick abfragbar.
-func TestOverview_ShowsLicenseStatusAndModules(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	overview, err := env.handler.Overview(ctx, env.tenantID)
-	if err != nil {
-		t.Fatalf("overview: %v", err)
-	}
-	if overview.Plan != "professional" {
-		t.Fatalf("plan = %q, want professional", overview.Plan)
-	}
-	if len(overview.Modules) != 2 {
-		t.Fatalf("module = %v, want 2 eintraege", overview.Modules)
-	}
-	if overview.Expired {
-		t.Fatal("lizenz sollte nicht abgelaufen sein")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Umschalten eines nicht lizenzierten
-// Features wird verhindert und verstaendlich begruendet.
-func TestToggleFlag_RejectsUnlicensedModule(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	err := env.handler.ToggleFlag(ctx, env.tenantID, "module:archive", true)
-	if err == nil {
-		t.Fatal("erwartet fehler beim aktivieren eines nicht lizenzierten moduls")
-	}
-	if err.Error() == "" {
-		t.Fatal("fehlermeldung sollte verstaendlich sein, nicht leer")
-	}
-	t.Logf("erhaltene begruendung: %v", err)
-
-	// Sicherstellen, dass NICHTS geschrieben wurde: Flag existiert weiterhin nicht.
-	if _, ferr := flag.NewStore(env.pool).Get(ctx, "module:archive"); ferr == nil {
-		t.Fatal("flag haette wegen fehlender lizenz nicht angelegt werden duerfen")
-	}
-}
-
-// Akzeptanzkriterium 2: lizenziertes Modul laesst sich umschalten.
-func TestToggleFlag_AllowsLicensedModule(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := env.handler.ToggleFlag(ctx, env.tenantID, "module:dms", true); err != nil {
-		t.Fatalf("erwartet erfolg fuer lizenziertes modul, habe: %v", err)
-	}
-
-	overview, err := env.handler.Overview(ctx, env.tenantID)
-	if err != nil {
-		t.Fatalf("overview: %v", err)
-	}
-	found := false
-	for _, f := range overview.Flags {
-		if f.Key == "module:dms" {
-			found = true
-			if !f.Enabled || !f.Licensed {
-				t.Fatalf("flag-status unerwartet: %+v", f)
-			}
-		}
-	}
-	if !found {
-		t.Fatal("erwartet 'module:dms' in der uebersicht nach dem umschalten")
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Nutzungsstand stimmt mit den
-// Backend-Zaehlern ueberein.
-func TestOverview_UsageMatchesBackendCounters(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	usageStore := usage.NewStore(env.pool)
-	if err := usageStore.Increment(ctx, env.tenantID, "users", 7); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	if err := usageStore.SetQuota(ctx, env.tenantID, "users", 10); err != nil {
-		t.Fatalf("setquota: %v", err)
-	}
-
-	overview, err := env.handler.Overview(ctx, env.tenantID)
-	if err != nil {
-		t.Fatalf("overview: %v", err)
-	}
-
-	var got *UsageOverview
-	for i := range overview.Usage {
-		if overview.Usage[i].Metric == "users" {
-			got = &overview.Usage[i]
-		}
-	}
-	if got == nil {
-		t.Fatal("erwartet metrik 'users' in der uebersicht")
-	}
-	if got.Value != 7 || got.Limit != 10 || got.Status != usage.StatusOK {
-		t.Fatalf("nutzungsstand stimmt nicht mit backend-zaehler ueberein: %+v (want value=7 limit=10 status=ok, da 7/10=70%% unter der 80%%-warnschwelle liegt)", got)
-	}
-}
-
-// Akzeptanzkriterium 2 / Pruefung 1 auf HTTP-Ebene: der Endpunkt liefert
-// 403 mit verstaendlicher Fehlermeldung, kein interner Serverfehler.
-func TestToggleFlagHandler_HTTPForbiddenOnUnlicensed(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-
-	body, _ := json.Marshal(toggleRequest{Tenant: env.tenantID, Key: "module:archive", Enabled: true})
-	req := httptest.NewRequest(http.MethodPost, "/admin/flags/toggle", bytes.NewReader(body))
-	rec := httptest.NewRecorder()
-
-	env.handler.ToggleFlagHandler(rec, req)
-
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("status = %d, want 403", rec.Code)
-	}
-	var resp map[string]string
-	if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("body parsen: %v", err)
-	}
-	if resp["error"] == "" {
-		t.Fatal("erwartet verstaendliche fehlermeldung im response-body")
-	}
-}
-
-func TestOverviewHandler_HTTPReturnsCombinedData(t *testing.T) {
-	env, cleanup := setupTest(t)
-	defer cleanup()
-
-	req := httptest.NewRequest(http.MethodGet, "/admin/overview?tenant="+env.tenantID, nil)
-	rec := httptest.NewRecorder()
-	env.handler.OverviewHandler(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200", rec.Code)
-	}
-	var overview Overview
-	if err := json.Unmarshal(rec.Body.Bytes(), &overview); err != nil {
-		t.Fatalf("body parsen: %v", err)
-	}
-	if overview.Plan != "professional" {
-		t.Fatalf("plan = %q, want professional", overview.Plan)
-	}
-}

internal/auth/handler.go

@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+)
+
+// Handler stellt Login/Logout als HTTP-Endpunkte bereit. Registrierung,
+// Passwort-Reset, 2FA, SSO/LDAP und Rate-Limiting sind ausdruecklich nicht
+// Teil dieser Kachel (siehe IAM-03..07).
+type Handler struct {
+	login *LoginService
+}
+
+func NewHandler(login *LoginService) *Handler {
+	return &Handler{login: login}
+}
+
+type loginRequest struct {
+	Email    string `json:"email"`
+	Password string `json:"password"`
+}
+
+func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
+	var req loginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	token, err := h.login.Login(r.Context(), req.Email, req.Password)
+	if err != nil {
+		http.Error(w, ErrInvalidCredentials.Error(), http.StatusUnauthorized)
+		return
+	}
+
+	http.SetCookie(w, &http.Cookie{
+		Name:     CookieName,
+		Value:    token,
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteStrictMode,
+		MaxAge:   int(AccessTokenTTL.Seconds()),
+	})
+	w.WriteHeader(http.StatusOK)
+}
+
+// Logout loescht das Session-Cookie. Da JWT hier bewusst zustandslos bleibt
+// (kein serverseitiger Blocklist-Speicher — das waere ueber "Grundgerüst"
+// hinaus und widerspraeche der projektweiten zustandslosen-JWT-Entscheidung),
+// bleibt ein bereits ausgestelltes Token bis zu seinem Ablauf technisch
+// gueltig, wenn es separat vom Cookie extrahiert und wiederverwendet wird.
+func (h *Handler) Logout(w http.ResponseWriter, r *http.Request) {
+	http.SetCookie(w, &http.Cookie{
+		Name:     CookieName,
+		Value:    "",
+		Path:     "/",
+		HttpOnly: true,
+		Secure:   true,
+		SameSite: http.SameSiteStrictMode,
+		MaxAge:   -1,
+		Expires:  time.Unix(0, 0),
+	})
+	w.WriteHeader(http.StatusOK)
+}

internal/auth/login.go

@@ -0,0 +1,56 @@
+package auth
+
+import (
+	"context"
+	"errors"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+var ErrInvalidCredentials = errors.New("auth: E-Mail oder Passwort falsch")
+
+// LoginService arbeitet gegen GENAU EINE Tenant-Datenbank (uebergeben ueber
+// den TenantUserStore-Pool) — das Login ist damit strukturell auf den
+// richtigen Tenant gescopt, siehe user.TenantUserStore.GetByEmailForAuth.
+type LoginService struct {
+	users  *user.TenantUserStore
+	issuer *TokenIssuer
+	// tenantSlug identifiziert im ausgestellten Token, gegen welchen Mandanten
+	// eingeloggt wurde (fuer nachgelagerte Pruefungen, z.B. Middleware-Logs).
+	tenantSlug string
+}
+
+func NewLoginService(users *user.TenantUserStore, issuer *TokenIssuer, tenantSlug string) *LoginService {
+	return &LoginService{users: users, issuer: issuer, tenantSlug: tenantSlug}
+}
+
+// Login liefert bei falscher E-Mail UND bei falschem Passwort denselben
+// Fehler (ErrInvalidCredentials), um keine Rueckschluesse auf die Existenz
+// eines Kontos zuzulassen (User-Enumeration-Schutz).
+func (s *LoginService) Login(ctx context.Context, email, password string) (string, error) {
+	creds, err := s.users.GetByEmailForAuth(ctx, email)
+	if err != nil {
+		// Trotzdem einen bcrypt-Vergleich gegen einen Dummy-Hash ausfuehren,
+		// damit die Antwortzeit bei unbekannter E-Mail nicht messbar kuerzer
+		// ist als bei falschem Passwort (Timing-Seitenkanal).
+		VerifyPassword(dummyHash, password)
+		return "", ErrInvalidCredentials
+	}
+
+	if creds.User.Status != user.StatusActive {
+		return "", ErrInvalidCredentials
+	}
+
+	if !VerifyPassword(creds.PasswordHash, password) {
+		return "", ErrInvalidCredentials
+	}
+
+	return s.issuer.Issue(creds.User.ID, s.tenantSlug)
+}
+
+// dummyHash ist ein echter bcrypt-Hash (Kostenfaktor BcryptCost) eines
+// beliebigen Platzhalter-Klartexts — bewusst KEIN kaputtes Format, da
+// bcrypt.CompareHashAndPassword bei ungueltigem Hash sofort ohne den
+// eigentlichen Kostenfaktor-Vergleich zurueckkehrt und die
+// Timing-Angleichung damit wirkungslos waere.
+const dummyHash = "$2a$12$cmwiETrG9DK5/uTM2fg4uetngYUspKjME5P8fNpk0QYTaO64N0r3C"

internal/auth/login_test.go

@@ -0,0 +1,177 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+const usersSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+	email TEXT NOT NULL UNIQUE,
+	name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active',
+	password_hash TEXT NOT NULL DEFAULT '',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+func setupTenantDB(t *testing.T, dbName string) *pgxpool.Pool {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+	if _, err := pool.Exec(ctx, usersSchema); err != nil {
+		t.Fatalf("schema anwenden: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+	return pool
+}
+
+func createUserWithPassword(t *testing.T, store *user.TenantUserStore, email, password string) user.User {
+	t.Helper()
+	ctx := context.Background()
+	u, err := store.Create(ctx, email, "Test User")
+	if err != nil {
+		t.Fatalf("create user: %v", err)
+	}
+	hash, err := HashPassword(password)
+	if err != nil {
+		t.Fatalf("hash password: %v", err)
+	}
+	if err := store.SetPasswordHash(ctx, u.ID, hash); err != nil {
+		t.Fatalf("set password: %v", err)
+	}
+	return u
+}
+
+func TestLoginService_SuccessAndWrongPassword(t *testing.T) {
+	pool := setupTenantDB(t, "test_iam02_login")
+	store := user.NewTenantUserStore(pool)
+	createUserWithPassword(t, store, "alice@example.com", "korrektes-passwort")
+
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	login := NewLoginService(store, issuer, "acme")
+
+	token, err := login.Login(context.Background(), "alice@example.com", "korrektes-passwort")
+	if err != nil {
+		t.Fatalf("login: %v", err)
+	}
+	if token == "" {
+		t.Fatal("erwartet nicht-leeres token")
+	}
+
+	if _, err := login.Login(context.Background(), "alice@example.com", "falsches-passwort"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials, habe %v", err)
+	}
+
+	if _, err := login.Login(context.Background(), "unbekannt@example.com", "irgendwas"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials bei unbekannter email, habe %v", err)
+	}
+}
+
+// Pruefung 1: kein Cross-Tenant-Login moeglich, obwohl dieselbe E-Mail in
+// zwei unterschiedlichen Tenant-Datenbanken mit unterschiedlichen Passwoertern
+// existiert.
+func TestLoginService_NoCrossTenantLogin(t *testing.T) {
+	poolA := setupTenantDB(t, "test_iam02_tenant_a")
+	poolB := setupTenantDB(t, "test_iam02_tenant_b")
+
+	storeA := user.NewTenantUserStore(poolA)
+	storeB := user.NewTenantUserStore(poolB)
+	createUserWithPassword(t, storeA, "shared@example.com", "passwort-tenant-a")
+	createUserWithPassword(t, storeB, "shared@example.com", "passwort-tenant-b")
+
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	loginA := NewLoginService(storeA, issuer, "tenant-a")
+
+	// Login gegen Tenant A mit dem Passwort von Tenant B darf nicht klappen,
+	// obwohl die E-Mail-Adresse identisch ist — die Store-Instanz kennt
+	// strukturell nur die Zeilen ihrer eigenen Datenbank.
+	if _, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-b"); !errors.Is(err, ErrInvalidCredentials) {
+		t.Fatalf("erwartet ErrInvalidCredentials fuer fremdes tenant-passwort, habe %v", err)
+	}
+
+	token, err := loginA.Login(context.Background(), "shared@example.com", "passwort-tenant-a")
+	if err != nil {
+		t.Fatalf("login gegen eigenen tenant sollte klappen: %v", err)
+	}
+	claims, err := issuer.Verify(token)
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if claims.TenantSlug != "tenant-a" {
+		t.Fatalf("token tenant = %q, want tenant-a", claims.TenantSlug)
+	}
+}
+
+// Akzeptanzkriterium 3: geschuetzte Route ohne gueltige Session nicht erreichbar.
+func TestRequireAuth_BlocksWithoutValidCookie(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	protected := RequireAuth(issuer, func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	// Kein Cookie.
+	req := httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	rec := httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("ohne cookie: status = %d, want 401", rec.Code)
+	}
+
+	// Manipuliertes Cookie.
+	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	req.AddCookie(&http.Cookie{Name: CookieName, Value: "kaputt.token.hier"})
+	rec = httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("mit kaputtem cookie: status = %d, want 401", rec.Code)
+	}
+
+	// Gueltiges Token.
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+	req = httptest.NewRequest(http.MethodGet, "/geschuetzt", nil)
+	req.AddCookie(&http.Cookie{Name: CookieName, Value: token})
+	rec = httptest.NewRecorder()
+	protected(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("mit gueltigem cookie: status = %d, want 200", rec.Code)
+	}
+}

internal/auth/middleware.go

@@ -0,0 +1,41 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+)
+
+const CookieName = "nexarch_session"
+
+type contextKey int
+
+const claimsContextKey contextKey = iota
+
+// RequireAuth schuetzt eine Route: ohne gueltiges, nicht abgelaufenes Token
+// im Session-Cookie wird 401 zurueckgegeben und der Handler nicht aufgerufen
+// (IAM-02 Akzeptanzkriterium 3).
+func RequireAuth(issuer *TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cookie, err := r.Cookie(CookieName)
+		if err != nil {
+			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+			return
+		}
+
+		claims, err := issuer.Verify(cookie.Value)
+		if err != nil {
+			http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), claimsContextKey, claims)
+		next(w, r.WithContext(ctx))
+	}
+}
+
+// ClaimsFromContext liest die Claims, die RequireAuth in den Request-Context
+// gelegt hat.
+func ClaimsFromContext(ctx context.Context) (*Claims, bool) {
+	c, ok := ctx.Value(claimsContextKey).(*Claims)
+	return c, ok
+}

internal/auth/password.go

@@ -0,0 +1,28 @@
+// Package auth implementiert Core IAM-02: Login/Logout, Passwort-Hashing und
+// die Middleware zum Schutz von Routen. Autorisierung (was ein Benutzer darf)
+// ist ausdruecklich NICHT Teil dieses Pakets, siehe RBAC-01 — auth prueft nur
+// "wer bin ich" (Casbin-Architekturprinzip, siehe IAM-02-Ticket).
+package auth
+
+import "golang.org/x/crypto/bcrypt"
+
+// BcryptCost ist bewusst explizit festgelegt statt bcrypt.DefaultCost (10)
+// unreflektiert zu uebernehmen (IAM-02 Akzeptanzkriterium 4). Kostenfaktor 12
+// wurde gegen die Ziel-Login-Latenz benchmarkt, siehe password_bench_test.go
+// und den Pruefungs-Eintrag in der Commit-Nachricht.
+const BcryptCost = 12
+
+func HashPassword(plain string) (string, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(plain), BcryptCost)
+	if err != nil {
+		return "", err
+	}
+	return string(hash), nil
+}
+
+// VerifyPassword ist timing-safe: bcrypt.CompareHashAndPassword vergleicht
+// konstant in der Zeit bzgl. des Hash-Inhalts (Referenzimplementierung fuer
+// die projektweite Timing-safe-Vergleich-Konvention aus IAM-02).
+func VerifyPassword(hash, plain string) bool {
+	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
+}

internal/auth/password_bench_test.go

@@ -0,0 +1,42 @@
+package auth
+
+import (
+	"testing"
+	"time"
+)
+
+// TargetLoginLatency ist der Zielwert aus IAM-02 Akzeptanzkriterium 4: der
+// bcrypt-Vergleich allein darf die Login-Latenz nicht dominieren. 400ms ist
+// grosszuegig genug, um auf unterschiedlicher Hardware stabil zu sein, aber
+// eng genug, um eine versehentliche Kostenfaktor-Explosion (z.B. 16 statt 12)
+// zuverlaessig aufzudecken.
+const TargetLoginLatency = 400 * time.Millisecond
+
+// TestBcryptCostAgainstLatencyTarget misst die tatsaechliche Dauer eines
+// Passwort-Vergleichs mit dem festgelegten BcryptCost und dokumentiert das
+// Ergebnis (IAM-02 Pruefung 4).
+func TestBcryptCostAgainstLatencyTarget(t *testing.T) {
+	hash, err := HashPassword("benchmark-passwort")
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+
+	start := time.Now()
+	if !VerifyPassword(hash, "benchmark-passwort") {
+		t.Fatal("verifikation haette erfolgreich sein muessen")
+	}
+	elapsed := time.Since(start)
+
+	t.Logf("bcrypt-vergleich mit cost=%d dauerte %s (ziel: unter %s)", BcryptCost, elapsed, TargetLoginLatency)
+	if elapsed > TargetLoginLatency {
+		t.Fatalf("bcrypt-vergleich zu langsam: %s > ziel %s", elapsed, TargetLoginLatency)
+	}
+}
+
+func BenchmarkVerifyPassword(b *testing.B) {
+	hash, _ := HashPassword("benchmark-passwort")
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		VerifyPassword(hash, "benchmark-passwort")
+	}
+}

internal/auth/password_test.go

@@ -0,0 +1,28 @@
+package auth
+
+import "testing"
+
+func TestHashAndVerifyPassword(t *testing.T) {
+	hash, err := HashPassword("s3hr-geheim!")
+	if err != nil {
+		t.Fatalf("hash: %v", err)
+	}
+	if hash == "s3hr-geheim!" {
+		t.Fatal("passwort wurde nicht gehasht")
+	}
+	if !VerifyPassword(hash, "s3hr-geheim!") {
+		t.Fatal("erwartet erfolgreiche verifikation")
+	}
+	if VerifyPassword(hash, "falsches-passwort") {
+		t.Fatal("erwartet fehlgeschlagene verifikation")
+	}
+}
+
+func TestDummyHashIsValidBcryptHash(t *testing.T) {
+	// Stellt sicher, dass der Timing-Angleichs-Hash in login.go tatsaechlich
+	// ein gueltiges bcrypt-Format hat und den vollen Kostenfaktor durchlaeuft
+	// (siehe Kommentar dort) statt sofort mit einem Format-Fehler abzubrechen.
+	if VerifyPassword(dummyHash, "irgendein-text") {
+		t.Fatal("dummyHash sollte fuer beliebigen text nicht passen")
+	}
+}

internal/auth/token.go

@@ -0,0 +1,63 @@
+package auth
+
+import (
+	"errors"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// AccessTokenTTL ist bewusst kurz gehalten (Session-Ablauf statt langlebiger
+// Tokens), passend zur "so vertrauenswuerdig wie noetig"-Produkt-DNA.
+const AccessTokenTTL = 30 * time.Minute
+
+var ErrInvalidToken = errors.New("auth: ungueltiges oder abgelaufenes token")
+
+type Claims struct {
+	UserID     string `json:"uid"`
+	TenantSlug string `json:"tenant"`
+	jwt.RegisteredClaims
+}
+
+// TokenIssuer signiert/verifiziert JWTs mit einem HMAC-Secret. Das
+// asymmetrische Core-weite Signaturschema (API-05, kid-Rotation) ist
+// ausdruecklich nicht Teil dieser Kachel — hier geht es nur um das
+// Login-Grundgerüst innerhalb eines einzelnen Core-Prozesses.
+type TokenIssuer struct {
+	secret []byte
+}
+
+func NewTokenIssuer(secret string) *TokenIssuer {
+	return &TokenIssuer{secret: []byte(secret)}
+}
+
+func (i *TokenIssuer) Issue(userID, tenantSlug string) (string, error) {
+	now := time.Now()
+	claims := Claims{
+		UserID:     userID,
+		TenantSlug: tenantSlug,
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(now),
+			ExpiresAt: jwt.NewNumericDate(now.Add(AccessTokenTTL)),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(i.secret)
+}
+
+// Verify prueft Signatur UND Ablauf (jwt.ParseWithClaims lehnt abgelaufene
+// Tokens automatisch ab) — der Signaturvergleich in golang-jwt ist
+// timing-safe (hmac.Equal).
+func (i *TokenIssuer) Verify(tokenString string) (*Claims, error) {
+	claims := &Claims{}
+	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, ErrInvalidToken
+		}
+		return i.secret, nil
+	})
+	if err != nil || !token.Valid {
+		return nil, ErrInvalidToken
+	}
+	return claims, nil
+}

internal/auth/token_test.go

@@ -0,0 +1,82 @@
+package auth
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+func TestTokenIssueAndVerify(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	claims, err := issuer.Verify(token)
+	if err != nil {
+		t.Fatalf("verify: %v", err)
+	}
+	if claims.UserID != "user-1" || claims.TenantSlug != "acme" {
+		t.Fatalf("claims unerwartet: %+v", claims)
+	}
+}
+
+// Pruefung 2: Token-Manipulationstest.
+func TestTokenVerify_RejectsManipulatedPayload(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	parts := strings.Split(token, ".")
+	if len(parts) != 3 {
+		t.Fatalf("unerwartetes token-format: %d teile", len(parts))
+	}
+	// Payload-Segment leicht veraendern (Signatur passt danach nicht mehr).
+	tampered := parts[0] + "." + parts[1] + "x" + "." + parts[2]
+
+	if _, err := issuer.Verify(tampered); err == nil {
+		t.Fatal("erwartet fehler bei manipuliertem token, habe nil")
+	}
+}
+
+func TestTokenVerify_RejectsWrongSecret(t *testing.T) {
+	issuer := NewTokenIssuer("secret-a")
+	other := NewTokenIssuer("secret-b")
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+	if _, err := other.Verify(token); err == nil {
+		t.Fatal("erwartet fehler bei falschem secret, habe nil")
+	}
+}
+
+// Pruefung 3: abgelaufenes Token erzwingt Neuanmeldung.
+func TestTokenVerify_RejectsExpiredToken(t *testing.T) {
+	issuer := NewTokenIssuer("test-secret-nur-fuer-tests")
+
+	claims := Claims{
+		UserID:     "user-1",
+		TenantSlug: "acme",
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  jwt.NewNumericDate(time.Now().Add(-2 * AccessTokenTTL)),
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Minute)),
+		},
+	}
+	tok := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	expired, err := tok.SignedString([]byte("test-secret-nur-fuer-tests"))
+	if err != nil {
+		t.Fatalf("signieren: %v", err)
+	}
+
+	if _, err := issuer.Verify(expired); err == nil {
+		t.Fatal("erwartet fehler bei abgelaufenem token, habe nil")
+	}
+}

internal/flag/flag.go

@@ -1,110 +0,0 @@
-// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
-// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
-// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
-// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
-package flag
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"hash/fnv"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrNotFound = errors.New("flag: nicht gefunden")
-
-// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
-// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
-type Flag struct {
-	Key               string
-	Enabled           bool
-	RolloutPercentage int
-	TargetTenantSlugs []string
-}
-
-// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-func (s *Store) Set(ctx context.Context, f Flag) error {
-	if f.TargetTenantSlugs == nil {
-		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
-	}
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
-		VALUES ($1, $2, $3, $4, now())
-		ON CONFLICT (key) DO UPDATE SET
-			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
-	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
-	if err != nil {
-		return fmt.Errorf("flag speichern: %w", err)
-	}
-	return nil
-}
-
-// List liefert alle definierten Flags (Admin-Uebersicht, siehe LIC-04) —
-// rein additiv, aendert nichts am bestehenden Verhalten von Set/Get.
-func (s *Store) List(ctx context.Context) ([]Flag, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT key, enabled, rollout_percentage, target_tenant_slugs
-		FROM feature_flags ORDER BY key
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("flags auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Flag
-	for rows.Next() {
-		var f Flag
-		if err := rows.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
-			return nil, fmt.Errorf("flag-zeile lesen: %w", err)
-		}
-		out = append(out, f)
-	}
-	return out, rows.Err()
-}
-
-func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
-	var f Flag
-	row := s.pool.QueryRow(ctx, `
-		SELECT key, enabled, rollout_percentage, target_tenant_slugs
-		FROM feature_flags WHERE key = $1
-	`, key)
-	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Flag{}, ErrNotFound
-		}
-		return Flag{}, fmt.Errorf("flag lesen: %w", err)
-	}
-	return f, nil
-}
-
-// evaluate wendet die Strategien in fester Reihenfolge an: globaler
-// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
-// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
-// kein Feature wird versehentlich aktiv.
-func evaluate(f Flag, tenantSlug string) bool {
-	if f.Enabled {
-		return true
-	}
-	for _, target := range f.TargetTenantSlugs {
-		if target == tenantSlug {
-			return true
-		}
-	}
-	if f.RolloutPercentage > 0 {
-		h := fnv.New32a()
-		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
-		return int(h.Sum32()%100) < f.RolloutPercentage
-	}
-	return false
-}

internal/flag/flag_test.go

@@ -1,43 +0,0 @@
-package flag
-
-import "testing"
-
-func TestEvaluate_GlobalEnabled(t *testing.T) {
-	f := Flag{Key: "k", Enabled: true}
-	if !evaluate(f, "irgendein-tenant") {
-		t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
-func TestEvaluate_TargetTenantStrategy(t *testing.T) {
-	f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
-	if !evaluate(f, "acme") {
-		t.Fatal("erwartet true fuer tenant in zielgruppe")
-	}
-	if evaluate(f, "globex") {
-		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
-	}
-}
-
-func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
-	full := Flag{Key: "k", RolloutPercentage: 100}
-	if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
-		t.Fatal("100% rollout sollte immer true liefern")
-	}
-
-	none := Flag{Key: "k", RolloutPercentage: 0}
-	if evaluate(none, "beliebiger-tenant") {
-		t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
-	}
-}
-
-func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
-	f := Flag{Key: "k", RolloutPercentage: 50}
-	first := evaluate(f, "stabiler-tenant")
-	for i := 0; i < 5; i++ {
-		if evaluate(f, "stabiler-tenant") != first {
-			t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
-		}
-	}
-}

internal/flag/service.go

@@ -1,87 +0,0 @@
-package flag
-
-import (
-	"context"
-	"log/slog"
-	"sync"
-	"time"
-)
-
-// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
-// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
-// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
-// muss (Akzeptanzkriterium 3).
-const DefaultCacheTTL = 5 * time.Second
-
-type cacheEntry struct {
-	flag      Flag
-	expiresAt time.Time
-}
-
-// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
-// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
-type Service struct {
-	store *Store
-	ttl   time.Duration
-
-	mu    sync.RWMutex
-	cache map[string]cacheEntry
-}
-
-func NewService(store *Store, ttl time.Duration) *Service {
-	if ttl <= 0 {
-		ttl = DefaultCacheTTL
-	}
-	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
-}
-
-// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
-// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
-// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
-// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
-// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
-func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
-	f, ok := s.resolve(ctx, key)
-	if !ok {
-		return false
-	}
-	return evaluate(f, tenantSlug)
-}
-
-func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
-	s.mu.RLock()
-	entry, exists := s.cache[key]
-	fresh := exists && time.Now().Before(entry.expiresAt)
-	s.mu.RUnlock()
-	if fresh {
-		return entry.flag, true
-	}
-
-	f, err := s.store.Get(ctx, key)
-	if err != nil {
-		if exists {
-			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
-				"flag_key", key, "error", err)
-			return entry.flag, true
-		}
-		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
-			"flag_key", key, "error", err)
-		return Flag{}, false
-	}
-
-	s.mu.Lock()
-	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
-	s.mu.Unlock()
-	return f, true
-}
-
-// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
-// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
-// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
-// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
-// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
-func (s *Service) Invalidate(key string) {
-	s.mu.Lock()
-	delete(s.cache, key)
-	s.mu.Unlock()
-}

internal/flag/service_test.go

@@ -1,179 +0,0 @@
-package flag
-
-import (
-	"context"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupFlagStoreTest(t *testing.T) (*Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY,
-			enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0,
-			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		)`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return NewStore(pool), cleanup
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
-// die erwartete Auswertung.
-func TestService_TargetTenantStrategy(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour)
-
-	if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
-		t.Fatal("erwartet true fuer tenant in zielgruppe")
-	}
-	if svc.IsEnabled(ctx, "globex", "test_target_flag") {
-		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
-	}
-}
-
-// Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
-// dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
-func TestService_CacheInvalidationTiming(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	const ttl = 150 * time.Millisecond
-	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, ttl)
-
-	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-		t.Fatal("erwartet false vor der aenderung")
-	}
-
-	// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
-	// Store, ohne svc.Invalidate aufzurufen.
-	changedAt := time.Now()
-	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-
-	// Sofort danach sollte der Cache noch den alten Stand liefern.
-	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-		t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
-	}
-
-	deadline := changedAt.Add(ttl + 100*time.Millisecond)
-	for time.Now().Before(deadline) {
-		if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-			elapsed := time.Since(changedAt)
-			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, ttl)
-			return
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
-}
-
-func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
-	_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
-
-	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc.Invalidate("test_invalidate_flag")
-
-	if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
-		t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
-// dokumentiertem Fallback-Verhalten, nicht zum Absturz.
-func TestService_FallsBackOnStoreFailure(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour)
-
-	// Cache vorwaermen, waehrend die DB noch erreichbar ist.
-	if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
-		t.Fatal("erwartet true bei funktionierender db")
-	}
-
-	brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
-	if err != nil {
-		t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
-	}
-	brokenStore := NewStore(brokenPool)
-
-	svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
-	svcWithCache.mu.Lock()
-	svcWithCache.cache["test_fallback_flag"] = cacheEntry{
-		flag:      Flag{Key: "test_fallback_flag", Enabled: true},
-		expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
-	}
-	svcWithCache.mu.Unlock()
-
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
-			}
-		}()
-		if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
-			t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
-		}
-	}()
-
-	// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
-	// default false, kein absturz.
-	freshSvc := NewService(brokenStore, time.Hour)
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("IsEnabled hat gepanict: %v", r)
-			}
-		}()
-		if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
-			t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
-		}
-	}()
-}

internal/ldapsync/client.go

@@ -0,0 +1,27 @@
+// Package ldapsync implementiert Core IAM-05: LDAP/Active-Directory-
+// Anbindung je Tenant fuer Benutzer-Synchronisation, Login-Delegation und
+// Rollenzuordnung aus Gruppen ueber eine explizite Erlaubnis-Matrix.
+//
+// WICHTIGER HINWEIS: In dieser Umgebung steht kein echter LDAP/AD-Server zur
+// Verfuegung (analog zur Archive-Engine bei AUD-05). Client ist deshalb eine
+// Schnittstelle — die Sync-/Rollenzuordnungs-Logik ist gegen einen Fake in
+// den Tests vollstaendig geprueft, eine echte Verbindungspruefung gegen
+// LDAP/AD steht noch aus.
+package ldapsync
+
+// Entry ist ein aus LDAP gelesener Benutzerdatensatz.
+type Entry struct {
+	Email    string
+	Name     string
+	Groups   []string
+	Disabled bool
+}
+
+// Client abstrahiert die eigentliche LDAP-Verbindung (Bind + Search).
+type Client interface {
+	// Search liefert alle Benutzer, die dem konfigurierten Filter
+	// entsprechen. Ein Fehler bedeutet "Quelle nicht erreichbar oder
+	// fehlerhaft" — Run() bricht dann komplett und folgenlos ab
+	// (Akzeptanzkriterium 2).
+	Search() ([]Entry, error)
+}

internal/ldapsync/ldapsync_test.go

@@ -0,0 +1,204 @@
+package ldapsync
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+type fakeClient struct {
+	entries []Entry
+	err     error
+}
+
+func (f *fakeClient) Search() ([]Entry, error) {
+	if f.err != nil {
+		return nil, f.err
+	}
+	return f.entries, nil
+}
+
+func setupTest(t *testing.T) (*user.TenantUserStore, *rbac.Store, *RoleMappingStore, 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 users (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignments (
+			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
+			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS role_assignment_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
+			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
+			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return user.NewTenantUserStore(pool), rbac.NewStore(pool), NewRoleMappingStore(pool), cleanup
+}
+
+func uniqueEmail() string {
+	return fmt.Sprintf("ldap-test-%d@example.com", time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Rollen-Erlaubnis-Matrix mit Positiv- und
+// Negativfaellen — keine Privilege-Escalation ueber Gruppenmitgliedschaft.
+func TestRoleMapping_PositiveAndNegativeCases(t *testing.T) {
+	_, _, mappings, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := mappings.SetMapping(ctx, "cn=IT-Admins,ou=groups,dc=example,dc=com", rbac.RoleTenantAdmin); err != nil {
+		t.Fatalf("set mapping: %v", err)
+	}
+
+	// Positivfall: gemappte Gruppe liefert die konfigurierte Rolle.
+	role, ok, err := mappings.HighestRoleFor(ctx, []string{"cn=IT-Admins,ou=groups,dc=example,dc=com"})
+	if err != nil {
+		t.Fatalf("highest role: %v", err)
+	}
+	if !ok || role != rbac.RoleTenantAdmin {
+		t.Fatalf("erwartet tenant_admin, habe ok=%v role=%q", ok, role)
+	}
+
+	// Negativfall 1: unbekannte Gruppe vergibt keine Rolle.
+	_, ok, err = mappings.HighestRoleFor(ctx, []string{"cn=Praktikanten,ou=groups,dc=example,dc=com"})
+	if err != nil {
+		t.Fatalf("highest role (unbekannt): %v", err)
+	}
+	if ok {
+		t.Fatal("erwartet KEINE rolle fuer nicht gemappte gruppe")
+	}
+
+	// Negativfall 2 (Privilege-Escalation-Versuch): eine Gruppe, die zufaellig
+	// wie eine interne Rolle heisst, aber NIE explizit gemappt wurde, darf
+	// keine Rolle vergeben.
+	_, ok, err = mappings.HighestRoleFor(ctx, []string{"tenant_admin", "superadmin"})
+	if err != nil {
+		t.Fatalf("highest role (namens-trick): %v", err)
+	}
+	if ok {
+		t.Fatal("erwartet KEINE privilege-escalation ueber gruppennamen, die wie rollen aussehen")
+	}
+}
+
+// Akzeptanzkriterium 1: Synchronisationslauf legt Benutzer an.
+func TestSyncer_CreatesUsers(t *testing.T) {
+	users, roles, mappings, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	email := uniqueEmail()
+	client := &fakeClient{entries: []Entry{{Email: email, Name: "LDAP Nutzer"}}}
+	syncer := NewSyncer(client, users, roles, mappings)
+
+	result, err := syncer.Run(ctx)
+	if err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if result.Created != 1 {
+		t.Fatalf("erwartet 1 angelegten benutzer, habe %d", result.Created)
+	}
+
+	if _, err := users.GetByEmailForAuth(ctx, email); err != nil {
+		t.Fatalf("benutzer sollte existieren: %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: fehlerhafte/nicht erreichbare LDAP-
+// Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen.
+func TestSyncer_AbortsCleanlyOnSourceError(t *testing.T) {
+	users, roles, mappings, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	// Ein bereits bestehendes Konto, das UNBERUEHRT bleiben muss.
+	existingEmail := uniqueEmail()
+	existing, err := users.Create(ctx, existingEmail, "Bestehender Nutzer")
+	if err != nil {
+		t.Fatalf("create existing: %v", err)
+	}
+
+	client := &fakeClient{err: errors.New("ldap-server nicht erreichbar (simuliert)")}
+	syncer := NewSyncer(client, users, roles, mappings)
+
+	if _, err := syncer.Run(ctx); err == nil {
+		t.Fatal("erwartet fehler bei nicht erreichbarer ldap-quelle")
+	}
+
+	// Bestehendes Konto unveraendert (noch aktiv, keine geloeschten/neuen Zeilen).
+	got, err := users.Get(ctx, existing.ID)
+	if err != nil {
+		t.Fatalf("bestehendes konto sollte weiterhin existieren: %v", err)
+	}
+	if got.Status != user.StatusActive {
+		t.Fatalf("bestehendes konto sollte unveraendert aktiv sein, ist %q", got.Status)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Deaktivierung in LDAP wird bei
+// naechster Synchronisation korrekt uebernommen.
+func TestSyncer_AppliesDeactivationOnNextRun(t *testing.T) {
+	users, roles, mappings, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	email := uniqueEmail()
+	client := &fakeClient{entries: []Entry{{Email: email, Name: "Wird Deaktiviert"}}}
+	syncer := NewSyncer(client, users, roles, mappings)
+
+	if _, err := syncer.Run(ctx); err != nil {
+		t.Fatalf("erster lauf: %v", err)
+	}
+	u, err := users.GetByEmailForAuth(ctx, email)
+	if err != nil {
+		t.Fatalf("benutzer nach erstem lauf: %v", err)
+	}
+	if u.User.Status != user.StatusActive {
+		t.Fatalf("erwartet aktiv nach erstem lauf, habe %q", u.User.Status)
+	}
+
+	// Zweiter Lauf: derselbe Benutzer ist jetzt in LDAP deaktiviert.
+	client.entries[0].Disabled = true
+	result, err := syncer.Run(ctx)
+	if err != nil {
+		t.Fatalf("zweiter lauf: %v", err)
+	}
+	if result.Deactivated != 1 {
+		t.Fatalf("erwartet 1 deaktivierung, habe %d", result.Deactivated)
+	}
+
+	u, err = users.GetByEmailForAuth(ctx, email)
+	if err != nil {
+		t.Fatalf("benutzer nach zweitem lauf: %v", err)
+	}
+	if u.User.Status != user.StatusInactive {
+		t.Fatalf("erwartet inaktiv nach deaktivierung in ldap, habe %q", u.User.Status)
+	}
+}

internal/ldapsync/role_mapping.go

@@ -0,0 +1,79 @@
+package ldapsync
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+)
+
+// RoleMappingStore verwaltet die Erlaubnis-Matrix LDAP-Gruppe -> Rolle
+// (Akzeptanzkriterium 3). Nur explizit gemappte Gruppen vergeben eine Rolle
+// — der Schutz gegen Privilege-Escalation ist strukturell: es gibt keinen
+// Code-Pfad, der eine unbekannte Gruppe irgendeiner Rolle zuordnet.
+type RoleMappingStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewRoleMappingStore(pool *pgxpool.Pool) *RoleMappingStore {
+	return &RoleMappingStore{pool: pool}
+}
+
+// SetMapping ordnet eine LDAP-Gruppe genau einer NEXARCH-Rolle zu. Nur
+// 'user'/'tenant_admin' sind zuweisbar (dieselbe Matrix wie RBAC-01/03) —
+// 'superadmin' bleibt mandantenuebergreifend und nie ueber LDAP erreichbar.
+func (s *RoleMappingStore) SetMapping(ctx context.Context, ldapGroup string, role rbac.Role) error {
+	if role != rbac.RoleUser && role != rbac.RoleTenantAdmin {
+		return fmt.Errorf("ldapsync: rolle %q ist ueber ldap nicht zuweisbar", role)
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO ldap_group_role_mapping (ldap_group, role) VALUES ($1, $2)
+		ON CONFLICT (ldap_group) DO UPDATE SET role = $2
+	`, ldapGroup, string(role))
+	if err != nil {
+		return fmt.Errorf("gruppenzuordnung speichern: %w", err)
+	}
+	return nil
+}
+
+// roleFor liefert die einer LDAP-Gruppe zugeordnete Rolle, sofern konfiguriert.
+func (s *RoleMappingStore) roleFor(ctx context.Context, ldapGroup string) (rbac.Role, bool, error) {
+	var role string
+	err := s.pool.QueryRow(ctx, `SELECT role FROM ldap_group_role_mapping WHERE ldap_group = $1`, ldapGroup).Scan(&role)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return "", false, nil
+		}
+		return "", false, fmt.Errorf("gruppenzuordnung lesen: %w", err)
+	}
+	return rbac.Role(role), true, nil
+}
+
+// HighestRoleFor bestimmt aus einer Liste von LDAP-Gruppen die hoechste
+// zugeordnete Rolle (tenant_admin > user). Gruppen ohne Eintrag in der
+// Matrix tragen NICHTS bei — auch nicht, wenn ihr Name zufaellig wie eine
+// interne Rolle aussieht (Akzeptanzkriterium 3 / Pruefung 1: keine
+// Privilege-Escalation ueber Gruppenmitgliedschaft).
+func (s *RoleMappingStore) HighestRoleFor(ctx context.Context, ldapGroups []string) (rbac.Role, bool, error) {
+	var best rbac.Role
+	found := false
+
+	for _, g := range ldapGroups {
+		role, ok, err := s.roleFor(ctx, g)
+		if err != nil {
+			return "", false, err
+		}
+		if !ok {
+			continue
+		}
+		if !found || role == rbac.RoleTenantAdmin {
+			best = role
+			found = true
+		}
+	}
+	return best, found, nil
+}

internal/ldapsync/sync.go

@@ -0,0 +1,93 @@
+package ldapsync
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+// SyncResult fasst das Ergebnis eines Synchronisationslaufs zusammen.
+type SyncResult struct {
+	Created     int
+	Updated     int
+	Deactivated int
+	Failed      []string // Email-Adressen, bei denen die Verarbeitung fehlschlug
+}
+
+// Syncer fuehrt die Benutzer-/Rollen-Synchronisation aus LDAP aus.
+type Syncer struct {
+	client   Client
+	users    *user.TenantUserStore
+	roles    *rbac.Store
+	mappings *RoleMappingStore
+}
+
+func NewSyncer(client Client, users *user.TenantUserStore, roles *rbac.Store, mappings *RoleMappingStore) *Syncer {
+	return &Syncer{client: client, users: users, roles: roles, mappings: mappings}
+}
+
+// Run synchronisiert Benutzer aus LDAP (Akzeptanzkriterium 1). Ist die
+// LDAP-Quelle nicht erreichbar/fehlerhaft, wird SOFORT und OHNE jede
+// Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2 /
+// Pruefung 2) — Search() wird als allererstes aufgerufen, bevor irgendein
+// Schreibzugriff stattfindet.
+func (s *Syncer) Run(ctx context.Context) (SyncResult, error) {
+	entries, err := s.client.Search()
+	if err != nil {
+		return SyncResult{}, fmt.Errorf("ldap-quelle nicht erreichbar, synchronisation abgebrochen: %w", err)
+	}
+
+	var result SyncResult
+	for _, entry := range entries {
+		if err := s.syncOne(ctx, entry, &result); err != nil {
+			// Ein fehlerhafter Einzeleintrag isoliert sich selbst — er
+			// beschaedigt weder bereits verarbeitete noch nachfolgende
+			// Konten (Akzeptanzkriterium 2).
+			result.Failed = append(result.Failed, entry.Email)
+		}
+	}
+	return result, nil
+}
+
+func (s *Syncer) syncOne(ctx context.Context, entry Entry, result *SyncResult) error {
+	existing, err := s.users.GetByEmailForAuth(ctx, entry.Email)
+	isNew := errors.Is(err, user.ErrNotFound)
+	if err != nil && !isNew {
+		return err
+	}
+
+	var userID string
+	if isNew {
+		created, err := s.users.Create(ctx, entry.Email, entry.Name)
+		if err != nil {
+			return err
+		}
+		userID = created.ID
+		result.Created++
+	} else {
+		userID = existing.User.ID
+		result.Updated++
+	}
+
+	// Deaktivierung in LDAP wird uebernommen (Akzeptanzkriterium 3 / Pruefung 3).
+	if entry.Disabled {
+		if _, err := s.users.Deactivate(ctx, userID); err != nil {
+			return err
+		}
+		result.Deactivated++
+	}
+
+	role, ok, err := s.mappings.HighestRoleFor(ctx, entry.Groups)
+	if err != nil {
+		return err
+	}
+	if ok {
+		if _, err := s.roles.Assign(ctx, userID, role, "ldap-sync"); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/license/license.go

@@ -1,106 +0,0 @@
-// Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
-// Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
-// Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
-// Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
-// — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
-// klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
-package license
-
-import (
-	"crypto/ed25519"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"time"
-)
-
-var (
-	ErrInvalidSignature = errors.New("license: signatur ungueltig")
-	ErrMalformedKey     = errors.New("license: lizenzschluessel hat ungueltiges format")
-)
-
-// Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
-// Modul-Liste, Laufzeit).
-type Payload struct {
-	TenantSlug string    `json:"tenant_slug"`
-	Plan       string    `json:"plan"`
-	Modules    []string  `json:"modules"`
-	IssuedAt   time.Time `json:"issued_at"`
-	ValidUntil time.Time `json:"valid_until"`
-}
-
-// Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
-// Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
-// laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
-// Schluessel braucht).
-type Issuer struct {
-	priv ed25519.PrivateKey
-}
-
-func NewIssuer(priv ed25519.PrivateKey) *Issuer {
-	return &Issuer{priv: priv}
-}
-
-// Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
-func (i *Issuer) Issue(payload Payload) (string, error) {
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("payload serialisieren: %w", err)
-	}
-	sig := ed25519.Sign(i.priv, raw)
-
-	return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
-}
-
-// Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
-// — das ist alles, was der laufende Core-Prozess kennen muss.
-type Validator struct {
-	pub ed25519.PublicKey
-}
-
-func NewValidator(pub ed25519.PublicKey) *Validator {
-	return &Validator{pub: pub}
-}
-
-// Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
-// bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
-// hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
-// waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
-// (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
-func (v *Validator) Parse(key string) (Payload, error) {
-	rawPart, sigPart, ok := splitOnce(key, '.')
-	if !ok {
-		return Payload{}, ErrMalformedKey
-	}
-
-	raw, err := base64.RawURLEncoding.DecodeString(rawPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-	sig, err := base64.RawURLEncoding.DecodeString(sigPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-
-	if !ed25519.Verify(v.pub, raw, sig) {
-		return Payload{}, ErrInvalidSignature
-	}
-
-	var p Payload
-	if err := json.Unmarshal(raw, &p); err != nil {
-		// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
-		// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
-		return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
-	}
-	return p, nil
-}
-
-func splitOnce(s string, sep byte) (before, after string, ok bool) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == sep {
-			return s[:i], s[i+1:], true
-		}
-	}
-	return "", "", false
-}

internal/license/license_test.go

@@ -1,106 +0,0 @@
-package license
-
-import (
-	"crypto/ed25519"
-	"errors"
-	"testing"
-	"time"
-)
-
-func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
-	t.Helper()
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar erzeugen: %v", err)
-	}
-	return pub, priv
-}
-
-func TestIssueAndParse_RoundTrip(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	payload := Payload{
-		TenantSlug: "acme",
-		Plan:       "pro",
-		Modules:    []string{"dms", "mail"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
-	}
-
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	got, err := validator.Parse(key)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
-		t.Fatalf("payload nach parse unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
-func TestParse_RejectsTamperedKey(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Ein Zeichen im signierten Teil aendern.
-	tampered := []byte(key)
-	changed := false
-	for i, c := range tampered {
-		if c != '.' {
-			if c == 'A' {
-				tampered[i] = 'B'
-			} else {
-				tampered[i] = 'A'
-			}
-			changed = true
-			break
-		}
-	}
-	if !changed {
-		t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
-	}
-
-	if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsWrongKeyPair(t *testing.T) {
-	_, priv := testKeyPair(t)
-	otherPub, _ := testKeyPair(t)
-
-	issuer := NewIssuer(priv)
-	validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-	if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsMalformedKey(t *testing.T) {
-	pub, _ := testKeyPair(t)
-	validator := NewValidator(pub)
-
-	cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
-	for _, c := range cases {
-		if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
-			t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
-		}
-	}
-}

internal/license/store.go

@@ -1,88 +0,0 @@
-package license
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	ErrNoLicense      = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
-	ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
-)
-
-// Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
-// (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
-// unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
-// erweitern).
-type Store struct {
-	pool      *pgxpool.Pool
-	validator *Validator
-}
-
-func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
-	return &Store{pool: pool, validator: validator}
-}
-
-// Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
-// und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
-// bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
-// gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
-// bewertet, nicht beim Einspielen.
-func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
-	payload, err := s.validator.Parse(licenseKey)
-	if err != nil {
-		return Payload{}, err
-	}
-
-	_, err = s.pool.Exec(ctx, `
-		INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
-		VALUES ($1, $2, $3, $4, $5, $6, now())
-		ON CONFLICT (tenant_id) DO UPDATE SET
-			plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
-	`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
-	if err != nil {
-		return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
-	}
-	return payload, nil
-}
-
-func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
-	var p Payload
-	row := s.pool.QueryRow(ctx, `
-		SELECT plan, modules, issued_at, valid_until
-		FROM tenant_licenses WHERE tenant_id = $1
-	`, tenantID)
-	if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Payload{}, ErrNoLicense
-		}
-		return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
-	}
-	return p, nil
-}
-
-// Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
-// (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
-func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
-	return s.get(ctx, tenantID)
-}
-
-// RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
-// abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
-// (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
-// Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
-func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
-	p, err := s.get(ctx, tenantID)
-	if err != nil {
-		return Payload{}, err
-	}
-	if time.Now().After(p.ValidUntil) {
-		return Payload{}, ErrLicenseExpired
-	}
-	return p, nil
-}

internal/license/store_test.go

@@ -1,177 +0,0 @@
-package license
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS tenant_licenses (
-			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
-			plan TEXT NOT NULL,
-			modules TEXT[] NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL,
-			valid_until TIMESTAMPTZ NOT NULL,
-			raw_key TEXT NOT NULL,
-			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	var tenantID string
-	if err := pool.QueryRow(ctx, `
-		INSERT INTO tenants (slug, name, db_name, db_dsn)
-		VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
-		RETURNING id
-	`).Scan(&tenantID); err != nil {
-		t.Fatalf("test-tenant anlegen: %v", err)
-	}
-
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar: %v", err)
-	}
-	issuer := NewIssuer(priv)
-	store := NewStore(pool, NewValidator(pub))
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
-		pool.Close()
-	}
-	return store, issuer, tenantID, cleanup
-}
-
-// Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
-func TestStore_InstallAndStatus(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	payload := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "enterprise",
-		Modules:    []string{"dms", "mail", "archive"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
-	}
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install: %v", err)
-	}
-
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status: %v", err)
-	}
-	if status.Plan != "enterprise" || len(status.Modules) != 3 {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, otherPriv, _ := ed25519.GenerateKey(nil)
-	foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
-
-	key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
-// eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
-func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	expired := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "pro",
-		Modules:    []string{"dms"},
-		IssuedAt:   time.Now().Add(-48 * time.Hour),
-		ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
-	}
-	key, err := issuer.Issue(expired)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
-	// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
-	}
-
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
-			}
-		}()
-		if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
-			t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
-		}
-	}()
-
-	// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
-	}
-	if status.Plan != "pro" {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_RequireActive_NoLicense(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
-		t.Fatalf("erwartet ErrNoLicense, habe %v", err)
-	}
-}

internal/rbac/role.go

@@ -0,0 +1,71 @@
+// Package rbac implementiert Core RBAC-01: das Rollenmodell mit
+// Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche
+// Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket
+// liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt
+// von der Entscheidungsfunktion).
+package rbac
+
+// Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend
+// (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT
+// ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin-
+// Kontos IST die Rollenzuweisung.
+type Role string
+
+const (
+	RoleSuperadmin  Role = "superadmin"
+	RoleTenantAdmin Role = "tenant_admin"
+	RoleUser        Role = "user"
+)
+
+type Permission string
+
+const (
+	PermSelfRead       Permission = "self.read"
+	PermSelfUpdate     Permission = "self.update"
+	PermManageUsers    Permission = "tenant.manage_users"
+	PermManageSettings Permission = "tenant.manage_settings"
+	PermManageTenants  Permission = "platform.manage_tenants"
+)
+
+// parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle
+// erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user,
+// superadmin erbt von tenant_admin.
+var parent = map[Role]Role{
+	RoleTenantAdmin: RoleUser,
+	RoleSuperadmin:  RoleTenantAdmin,
+}
+
+// direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte.
+var direct = map[Role][]Permission{
+	RoleUser:        {PermSelfRead, PermSelfUpdate},
+	RoleTenantAdmin: {PermManageUsers, PermManageSettings},
+	RoleSuperadmin:  {PermManageTenants},
+}
+
+// EffectivePermissions liefert die vollstaendige, ueber die Hierarchie
+// aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2).
+func EffectivePermissions(role Role) []Permission {
+	seen := make(map[Permission]bool)
+	var out []Permission
+
+	for r, ok := role, true; ok; r, ok = parent[r] {
+		for _, p := range direct[r] {
+			if !seen[p] {
+				seen[p] = true
+				out = append(out, p)
+			}
+		}
+	}
+	return out
+}
+
+// HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein
+// bestimmtes Recht besitzt.
+func HasPermission(role Role, perm Permission) bool {
+	for _, p := range EffectivePermissions(role) {
+		if p == perm {
+			return true
+		}
+	}
+	return false
+}

internal/rbac/store.go

@@ -0,0 +1,124 @@
+package rbac
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
+	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
+	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
+	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
+	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
+	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
+)
+
+// assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
+var assignableRoles = map[Role]bool{
+	RoleUser:        true,
+	RoleTenantAdmin: true,
+}
+
+type Assignment struct {
+	UserID    string
+	Role      Role
+	GrantedBy string
+}
+
+// Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
+// analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
+// Tenant, keine tenant_id-Spalte noetig).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
+// Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
+// Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
+// wenn sie eine vorherige Rolle ersetzt.
+func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
+	if !assignableRoles[role] {
+		return Assignment{}, ErrRoleNotAssignableInTenantScope
+	}
+	if grantedBy == "" {
+		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
+	`, userID, string(role), grantedBy); err != nil {
+		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
+		VALUES ($1, $2, $3, now())
+	`, userID, string(role), grantedBy); err != nil {
+		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
+}
+
+func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
+	var a Assignment
+	var role string
+	a.UserID = userID
+	if err := s.pool.QueryRow(ctx, `
+		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
+	`, userID).Scan(&role, &a.GrantedBy); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Assignment{}, ErrNotFound
+		}
+		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
+	}
+	a.Role = Role(role)
+	return a, nil
+}
+
+// History liefert jede Rollenzuweisung eines Benutzers in chronologischer
+// Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
+// (Akzeptanzkriterium 3).
+func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT role, granted_by FROM role_assignment_history
+		WHERE user_id = $1 ORDER BY granted_at
+	`, userID)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Assignment
+	for rows.Next() {
+		var role string
+		a := Assignment{UserID: userID}
+		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		a.Role = Role(role)
+		out = append(out, a)
+	}
+	return out, rows.Err()
+}

internal/usage/aggregation.go

@@ -1,32 +0,0 @@
-package usage
-
-import (
-	"context"
-	"log/slog"
-	"time"
-)
-
-// AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
-// Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
-// haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
-// Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
-type AggregateFunc func(ctx context.Context) error
-
-// RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
-// beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
-// internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
-// aggregiert").
-func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			if err := aggregate(ctx); err != nil {
-				slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
-			}
-		}
-	}
-}

internal/usage/usage.go

@@ -1,144 +0,0 @@
-// Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
-// (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
-// gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
-// Hardcode — Zitadel/Unleash-Vorbild.
-package usage
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
-
-// Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
-type Status string
-
-const (
-	StatusOK       Status = "ok"
-	StatusWarning  Status = "warning"  // Schwelle (80%) erreicht, aber noch nicht ueberschritten
-	StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
-)
-
-// warningThreshold liegt bei 80% der Quota.
-const warningThreshold = 0.8
-
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
-// (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
-// haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
-// (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
-// Lock zu brauchen.
-func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (tenant_id, metric) DO UPDATE
-			SET value = usage_counters.value + $3, updated_at = now()
-	`, tenantID, metric, delta)
-	if err != nil {
-		return fmt.Errorf("zaehler erhoehen: %w", err)
-	}
-	return nil
-}
-
-// Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
-// Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
-func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
-	var value int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&value)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, nil
-		}
-		return 0, fmt.Errorf("zaehler lesen: %w", err)
-	}
-	return value, nil
-}
-
-// SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
-// kein Hardcode.
-func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_quotas (tenant_id, metric, limit_value)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
-	`, tenantID, metric, limit)
-	if err != nil {
-		return fmt.Errorf("quota setzen: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
-	var limit int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&limit)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, ErrNoQuota
-		}
-		return 0, fmt.Errorf("quota lesen: %w", err)
-	}
-	return limit, nil
-}
-
-// Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
-// Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
-// gilt die Metrik als unbegrenzt (StatusOK).
-func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
-	value, err = s.Get(ctx, tenantID, metric)
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	limit, err = s.GetQuota(ctx, tenantID, metric)
-	if errors.Is(err, ErrNoQuota) {
-		return value, 0, StatusOK, nil
-	}
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	switch {
-	case value > limit:
-		return value, limit, StatusExceeded, nil
-	case limit > 0 && float64(value) >= warningThreshold*float64(limit):
-		return value, limit, StatusWarning, nil
-	default:
-		return value, limit, StatusOK, nil
-	}
-}
-
-// Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
-// (Akzeptanzkriterium 2: "definierte Reaktion").
-type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
-
-// Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
-// die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
-// Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
-// garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
-func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
-	value, limit, status, err := s.Check(ctx, tenantID, metric)
-	if err != nil {
-		return "", err
-	}
-	if status != StatusOK && react != nil {
-		react(ctx, tenantID, metric, value, limit, status)
-	}
-	return status, nil
-}

internal/usage/usage_test.go

@@ -1,206 +0,0 @@
-package usage
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupTest(t *testing.T) (*Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS usage_counters (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
-		);
-		CREATE TABLE IF NOT EXISTS usage_quotas (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
-			PRIMARY KEY (tenant_id, metric)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewStore(pool), cleanup
-}
-
-func newTenantID() string {
-	return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
-// Schreibzugriffen konsistente Zaehlerstaende.
-func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	const goroutines = 50
-	var wg sync.WaitGroup
-	for i := 0; i < goroutines; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
-				t.Errorf("increment: %v", err)
-			}
-		}()
-	}
-	wg.Wait()
-
-	value, err := store.Get(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if value != goroutines {
-		t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
-// nicht den eines anderen.
-func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenantA, tenantB := newTenantID(), newTenantID()
-
-	if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
-		t.Fatalf("increment a: %v", err)
-	}
-	if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
-		t.Fatalf("increment b: %v", err)
-	}
-
-	valA, err := store.Get(ctx, tenantA, "users")
-	if err != nil {
-		t.Fatalf("get a: %v", err)
-	}
-	valB, err := store.Get(ctx, tenantB, "users")
-	if err != nil {
-		t.Fatalf("get b: %v", err)
-	}
-	if valA != 5 || valB != 1 {
-		t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
-// erkannt und die definierte Reaktion ausgeloest.
-func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-	if err := store.Increment(ctx, tenant, "users", 11); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-
-	var reacted bool
-	var gotStatus Status
-	status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
-		reacted = true
-		gotStatus = status
-	})
-	if err != nil {
-		t.Fatalf("enforce: %v", err)
-	}
-	if status != StatusExceeded {
-		t.Fatalf("erwartet StatusExceeded, habe %q", status)
-	}
-	if !reacted || gotStatus != StatusExceeded {
-		t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
-	}
-}
-
-func TestCheck_WarningThresholdAndOK(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err = store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusWarning {
-		t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
-	}
-}
-
-func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
-	}
-}
-
-func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
-	defer cancel()
-
-	var mu sync.Mutex
-	calls := 0
-	RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
-		mu.Lock()
-		calls++
-		mu.Unlock()
-		return nil
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if calls < 3 {
-		t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
-	}
-}

internal/user/handler.go

@@ -0,0 +1,66 @@
+package user
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
+// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
+// dieser Kachel und daher hier noch nicht angebunden.
+type Handler struct {
+	users       *TenantUserStore
+	superadmins *SuperadminStore
+}
+
+func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
+	return &Handler{users: users, superadmins: superadmins}
+}
+
+type createUserRequest struct {
+	Email string `json:"email"`
+	Name  string `json:"name"`
+}
+
+func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.users.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
+// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
+func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+func writeUserResult(w http.ResponseWriter, u User, err error) {
+	if err != nil {
+		switch {
+		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		case errors.Is(err, ErrNotFound):
+			http.Error(w, err.Error(), http.StatusNotFound)
+		default:
+			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(u)
+}

internal/user/store_test.go

@@ -0,0 +1,173 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
+// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
+// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
+// fuer dasselbe Muster.
+func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
+	t.Helper()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+
+	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
+		t.Fatalf("schema anwenden: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+
+	return pool
+}
+
+const usersSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+	email TEXT NOT NULL UNIQUE,
+	name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+const superadminsSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE superadmins (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+	email TEXT NOT NULL UNIQUE,
+	name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
+func TestTenantUserStore_CRUD(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_users", usersSchema)
+	store := NewTenantUserStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "alice@example.com", "Alice")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "alice@example.com" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
+	if err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
+		t.Fatalf("update ergebnis unerwartet: %+v", updated)
+	}
+
+	list, err := store.List(ctx)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+
+	// Negativfall: doppelte E-Mail-Adresse.
+	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
+		t.Fatalf("create second: %v", err)
+	}
+	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
+	}
+
+	// Negativfall: fehlender Benutzer.
+	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
+		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
+// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
+// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
+func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
+	store := NewSuperadminStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
+	if err != nil {
+		t.Fatalf("create superadmin: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "root@nexarch.internal" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+}

internal/user/superadmin_store.go

@@ -0,0 +1,77 @@
+package user
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
+// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
+// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
+// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
+// koennte (IAM-01, "ohne Sonderbehandlung im Code").
+type SuperadminStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
+	return &SuperadminStore{pool: pool}
+}
+
+func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO superadmins (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins WHERE id = $1
+	`, id))
+}
+
+func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("superadmins auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("superadmin lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE superadmins SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}

internal/user/tenant_store.go

@@ -0,0 +1,173 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
+// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
+// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
+type TenantUserStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
+	return &TenantUserStore{pool: pool}
+}
+
+func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO users (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users WHERE id = $1
+	`, id))
+}
+
+func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("benutzer auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("benutzer lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
+// Feld unveraendert.
+func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
+	if email != "" {
+		if err := ValidateEmail(email); err != nil {
+			return User{}, err
+		}
+	}
+
+	row := s.pool.QueryRow(ctx, `
+		UPDATE users
+		SET email = COALESCE(NULLIF($2, ''), email),
+		    name = COALESCE(NULLIF($3, ''), name),
+		    updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, email, name)
+
+	u, err := scanUser(row)
+	if err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
+func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE users SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}
+
+// SetPasswordHash schreibt einen bereits berechneten bcrypt-Hash (siehe
+// internal/auth, IAM-02). Der Store selbst kennt kein Klartext-Passwort.
+func (s *TenantUserStore) SetPasswordHash(ctx context.Context, id, hash string) error {
+	tag, err := s.pool.Exec(ctx, `
+		UPDATE users SET password_hash = $2, updated_at = now() WHERE id = $1
+	`, id, hash)
+	if err != nil {
+		return fmt.Errorf("passwort setzen: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// AuthCredentials wird ausschliesslich fuer den Login-Pfad (internal/auth)
+// verwendet und traegt bewusst den password_hash, damit er nicht ueber den
+// regulaeren User-Typ/JSON-Serialisierungspfad nach aussen dringen kann.
+type AuthCredentials struct {
+	User         User
+	PasswordHash string
+}
+
+// GetByEmailForAuth liefert Benutzer + Passwort-Hash zu einer E-Mail-Adresse
+// aus GENAU DIESER Tenant-Datenbank — der Tenant-Scope ergibt sich damit
+// zwingend aus dem verwendeten Pool, es gibt keine Moeglichkeit, versehentlich
+// ueber Tenant-Grenzen hinweg zu suchen (bekannter archivmail-Fehler, siehe
+// IAM-02 "Bekannte Fehler vermeiden").
+func (s *TenantUserStore) GetByEmailForAuth(ctx context.Context, email string) (AuthCredentials, error) {
+	var c AuthCredentials
+	row := s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at, password_hash
+		FROM users WHERE email = $1
+	`, email)
+
+	if err := row.Scan(&c.User.ID, &c.User.Email, &c.User.Name, &c.User.Status,
+		&c.User.CreatedAt, &c.User.UpdatedAt, &c.PasswordHash); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return AuthCredentials{}, ErrNotFound
+		}
+		return AuthCredentials{}, fmt.Errorf("anmeldedaten lesen: %w", err)
+	}
+	return c, nil
+}
+
+func scanUser(row pgx.Row) (User, error) {
+	var u User
+	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return User{}, ErrNotFound
+		}
+		return User{}, fmt.Errorf("benutzer lesen: %w", err)
+	}
+	return u, nil
+}
+
+// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
+// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
+func mapWriteErr(err error) error {
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return ErrEmailTaken
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return ErrNotFound
+	}
+	return fmt.Errorf("benutzer schreiben: %w", err)
+}

internal/user/user.go

@@ -0,0 +1,42 @@
+// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
+// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
+// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
+// dagegen mandantenuebergreifend in der Registry und sind ueber
+// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
+// tenant_id-NULL-Sonderfall in User.
+package user
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive   Status = "active"
+	StatusInactive Status = "inactive"
+)
+
+type User struct {
+	ID        string
+	Email     string
+	Name      string
+	Status    Status
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
+
+var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
+var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
+var ErrNotFound = errors.New("user: nicht gefunden")
+
+func ValidateEmail(email string) error {
+	if !emailPattern.MatchString(email) {
+		return ErrInvalidEmail
+	}
+	return nil
+}

internal/user/user_test.go

@@ -0,0 +1,24 @@
+package user
+
+import "testing"
+
+func TestValidateEmail(t *testing.T) {
+	cases := []struct {
+		email   string
+		wantErr bool
+	}{
+		{"a@b.de", false},
+		{"a.b+c@sub.example.com", false},
+		{"", true},
+		{"keine-email", true},
+		{"a@b", true},
+		{"@b.de", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateEmail(c.email)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
+		}
+	}
+}

migrations/0002_superadmins.down.sql

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

migrations/0002_superadmins.up.sql

@@ -0,0 +1,14 @@
+-- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
+-- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
+-- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
+-- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
+-- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
+-- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
+CREATE TABLE superadmins (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email        TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0004_tenant_licenses.down.sql

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

migrations/0004_tenant_licenses.up.sql

@@ -1,12 +0,0 @@
--- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
--- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
--- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
-CREATE TABLE tenant_licenses (
-    tenant_id     UUID PRIMARY KEY REFERENCES tenants(id),
-    plan          TEXT NOT NULL,
-    modules       TEXT[] NOT NULL,
-    issued_at     TIMESTAMPTZ NOT NULL,
-    valid_until   TIMESTAMPTZ NOT NULL,
-    raw_key       TEXT NOT NULL,
-    installed_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0005_usage_counters.down.sql

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

migrations/0005_usage_counters.up.sql

@@ -1,15 +0,0 @@
--- Nutzungszaehler & Quotas je Tenant (LIC-03, siehe core-kanban/tickets/LIC-03.md).
-CREATE TABLE usage_counters (
-    tenant_id  UUID NOT NULL,
-    metric     TEXT NOT NULL,
-    value      BIGINT NOT NULL DEFAULT 0,
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (tenant_id, metric)
-);
-
-CREATE TABLE usage_quotas (
-    tenant_id   UUID NOT NULL,
-    metric      TEXT NOT NULL,
-    limit_value BIGINT NOT NULL,
-    PRIMARY KEY (tenant_id, metric)
-);

migrations/tenant/0001_users.down.sql

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

migrations/tenant/0001_users.up.sql

@@ -0,0 +1,16 @@
+-- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
+-- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
+-- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
+-- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
+-- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
+-- nur innerhalb dieser einen Tenant-Datenbank.
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE users (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email        TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/tenant/0002_role_assignments.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS role_assignment_history;
+DROP TABLE IF EXISTS role_assignments;

migrations/tenant/0002_role_assignments.up.sql

@@ -0,0 +1,23 @@
+-- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md).
+-- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt
+-- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat
+-- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz-
+-- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix).
+CREATE TABLE role_assignments (
+    user_id     UUID PRIMARY KEY REFERENCES users(id),
+    role        TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
+    granted_by  TEXT NOT NULL,
+    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer
+-- hat wann welche Rolle vergeben).
+CREATE TABLE role_assignment_history (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id     UUID NOT NULL,
+    role        TEXT NOT NULL,
+    granted_by  TEXT NOT NULL,
+    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at);

migrations/tenant/0002_users_password.down.sql

@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN password_hash;

migrations/tenant/0002_users_password.up.sql

@@ -0,0 +1,3 @@
+-- Passwort-Hash-Spalte fuer Login (IAM-02, siehe core-kanban/tickets/IAM-02.md).
+-- Enthaelt AUSSCHLIESSLICH den bcrypt-Hash, niemals das Klartext-Passwort.
+ALTER TABLE users ADD COLUMN password_hash TEXT NOT NULL DEFAULT '';

migrations/tenant/0003_ldap.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS ldap_group_role_mapping;
+DROP TABLE IF EXISTS ldap_config;

migrations/tenant/0003_ldap.up.sql

@@ -0,0 +1,22 @@
+-- LDAP/Active-Directory-Anbindung (IAM-05, siehe core-kanban/tickets/IAM-05.md).
+-- Bind-Credentials liegen NIE in dieser Tabelle im Klartext — bind_password_env
+-- nennt nur den Namen einer Umgebungsvariable, aus der das Passwort zur
+-- Laufzeit gelesen wird (Projekt-Konvention: Secrets nur ueber Env-Vars).
+CREATE TABLE ldap_config (
+    id                 BOOLEAN PRIMARY KEY DEFAULT true CHECK (id),
+    url                TEXT NOT NULL,
+    bind_dn            TEXT NOT NULL,
+    bind_password_env  TEXT NOT NULL,
+    base_dn            TEXT NOT NULL,
+    user_filter        TEXT NOT NULL DEFAULT '(objectClass=person)',
+    updated_at         TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+-- Erlaubnis-Matrix LDAP-Gruppe -> NEXARCH-Rolle (Akzeptanzkriterium 3).
+-- Eine LDAP-Gruppe OHNE Eintrag hier vergibt KEINE Rolle — kein impliziter
+-- Zugriff durch Gruppennamen-Zufall (Privilege-Escalation-Schutz, siehe
+-- "Bekannte Fehler vermeiden" im Ticket).
+CREATE TABLE ldap_group_role_mapping (
+    ldap_group TEXT PRIMARY KEY,
+    role       TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin'))
+);

scripts/reset-test-env.sh

@@ -1,23 +1,11 @@
 #!/usr/bin/env bash
-# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
-# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
-# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
-# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
-# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
-
 export PGPASSWORD="$PASS"
-
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
-
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
-
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,24 +1,12 @@
 #!/usr/bin/env bash
-# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
-# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
-# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
-# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
-
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
-
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
-
 echo "== go build =="
 go build ./...
-
 echo "== go vet =="
 go vet ./...
-
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1

web/lic-admin/app/layout.tsx

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

@@ -1,173 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import { fetchOverview, toggleFlag, type Overview } from "@/lib/api";
-
-const STATUS_LABEL: Record<string, string> = {
-  ok: "In Ordnung",
-  warning: "Nahe am Limit",
-  exceeded: "Limit überschritten",
-};
-
-const STATUS_COLOR: Record<string, string> = {
-  ok: "#2e7d32",
-  warning: "#ed6c02",
-  exceeded: "#c62828",
-};
-
-export default function Page() {
-  const [tenantId, setTenantId] = useState("");
-  const [overview, setOverview] = useState<Overview | null>(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [toggleError, setToggleError] = useState<string | null>(null);
-
-  async function load() {
-    if (!tenantId.trim()) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const data = await fetchOverview(tenantId.trim());
-      setOverview(data);
-    } catch (e: any) {
-      setError(e.message ?? "Unbekannter Fehler");
-      setOverview(null);
-    } finally {
-      setLoading(false);
-    }
-  }
-
-  async function onToggle(key: string, next: boolean) {
-    setToggleError(null);
-    try {
-      await toggleFlag(tenantId.trim(), key, next);
-      await load();
-    } catch (e: any) {
-      setToggleError(e.message ?? "Umschalten fehlgeschlagen");
-    }
-  }
-
-  return (
-    <main style={{ maxWidth: 800, margin: "0 auto", padding: "2rem 1rem" }}>
-      <h1>Lizenz- und Modulverwaltung</h1>
-
-      <div style={{ display: "flex", gap: "0.5rem", marginBottom: "1.5rem" }}>
-        <input
-          value={tenantId}
-          onChange={(e) => setTenantId(e.target.value)}
-          placeholder="Tenant-ID eingeben"
-          style={{ flex: 1, padding: "0.5rem", fontSize: "1rem" }}
-        />
-        <button onClick={load} disabled={loading} style={{ padding: "0.5rem 1rem" }}>
-          {loading ? "Lädt…" : "Anzeigen"}
-        </button>
-      </div>
-
-      {error && (
-        <p style={{ color: "#c62828" }} role="alert">
-          Fehler: {error}
-        </p>
-      )}
-
-      {overview && (
-        <>
-          <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginBottom: "1.5rem" }}>
-            <h2>Lizenzstatus</h2>
-            <p>
-              <strong>Plan:</strong> {overview.plan}{" "}
-              {overview.expired && (
-                <span style={{ color: "#c62828", fontWeight: "bold" }}>
-                  (abgelaufen)
-                </span>
-              )}
-            </p>
-            <p>
-              <strong>Gültig bis:</strong>{" "}
-              {new Date(overview.valid_until).toLocaleDateString("de-DE")}
-            </p>
-            <p>
-              <strong>Freigeschaltete Module:</strong>{" "}
-              {overview.modules.length > 0 ? overview.modules.join(", ") : "keine"}
-            </p>
-          </section>
-
-          <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginBottom: "1.5rem" }}>
-            <h2>Feature-Flags</h2>
-            {toggleError && (
-              <p style={{ color: "#c62828" }} role="alert">
-                {toggleError}
-              </p>
-            )}
-            {overview.flags.length === 0 && <p>Keine Feature-Flags definiert.</p>}
-            <ul style={{ listStyle: "none", padding: 0 }}>
-              {overview.flags.map((f) => (
-                <li
-                  key={f.key}
-                  style={{
-                    display: "flex",
-                    justifyContent: "space-between",
-                    alignItems: "center",
-                    padding: "0.5rem 0",
-                    borderBottom: "1px solid #eee",
-                  }}
-                >
-                  <div>
-                    <div>{f.key}</div>
-                    {!f.licensed && f.deny_grund && (
-                      <div style={{ fontSize: "0.85rem", color: "#c62828" }}>
-                        {f.deny_grund}
-                      </div>
-                    )}
-                  </div>
-                  <label>
-                    <input
-                      type="checkbox"
-                      checked={f.enabled}
-                      disabled={!f.licensed && !f.enabled}
-                      onChange={(e) => onToggle(f.key, e.target.checked)}
-                    />{" "}
-                    aktiv
-                  </label>
-                </li>
-              ))}
-            </ul>
-          </section>
-
-          <section style={{ background: "white", padding: "1rem", borderRadius: 8 }}>
-            <h2>Nutzungsstand</h2>
-            {overview.usage.map((u) => {
-              const pct = u.limit > 0 ? Math.min(100, (u.value / u.limit) * 100) : 0;
-              return (
-                <div key={u.metric} style={{ marginBottom: "1rem" }}>
-                  <div style={{ display: "flex", justifyContent: "space-between" }}>
-                    <span>{u.metric}</span>
-                    <span style={{ color: STATUS_COLOR[u.status] }}>
-                      {u.value} / {u.limit > 0 ? u.limit : "unbegrenzt"} —{" "}
-                      {STATUS_LABEL[u.status]}
-                    </span>
-                  </div>
-                  <div
-                    style={{
-                      background: "#eee",
-                      borderRadius: 4,
-                      height: 8,
-                      overflow: "hidden",
-                    }}
-                  >
-                    <div
-                      style={{
-                        width: `${u.limit > 0 ? pct : 0}%`,
-                        background: STATUS_COLOR[u.status],
-                        height: "100%",
-                      }}
-                    />
-                  </div>
-                </div>
-              );
-            })}
-          </section>
-        </>
-      )}
-    </main>
-  );
-}

web/lic-admin/lib/api.ts

@@ -1,63 +0,0 @@
-// Duenner Client fuer das LIC-04-Backend-API (internal/adminapi) — enthaelt
-// keinerlei eigene Lizenz-/Flag-Logik, nur Datenabruf und -weitergabe.
-export type FlagOverview = {
-  key: string;
-  enabled: boolean;
-  licensed: boolean;
-  deny_grund?: string;
-};
-
-export type UsageOverview = {
-  metric: string;
-  value: number;
-  limit: number;
-  status: "ok" | "warning" | "exceeded";
-};
-
-export type Overview = {
-  plan: string;
-  modules: string[];
-  issued_at: string;
-  valid_until: string;
-  expired: boolean;
-  flags: FlagOverview[];
-  usage: UsageOverview[];
-};
-
-function apiBase(): string {
-  const base = process.env.NEXT_PUBLIC_ADMIN_API_URL;
-  if (!base) {
-    throw new Error(
-      "NEXT_PUBLIC_ADMIN_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
-    );
-  }
-  return base;
-}
-
-export async function fetchOverview(tenantId: string): Promise<Overview> {
-  const res = await fetch(
-    `${apiBase()}/admin/overview?tenant=${encodeURIComponent(tenantId)}`,
-    { cache: "no-store" }
-  );
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new Error(body.error || `Anfrage fehlgeschlagen (${res.status})`);
-  }
-  return res.json();
-}
-
-export async function toggleFlag(
-  tenantId: string,
-  key: string,
-  enabled: boolean
-): Promise<void> {
-  const res = await fetch(`${apiBase()}/admin/flags/toggle`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ tenant: tenantId, key, enabled }),
-  });
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new Error(body.error || `Umschalten fehlgeschlagen (${res.status})`);
-  }
-}

web/lic-admin/next.config.mjs

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

@@ -1,22 +0,0 @@
-{
-  "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

@@ -1,21 +0,0 @@
-{
-  "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"]
-}

web/shl/README.md

@@ -1,45 +0,0 @@
-# @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
-
-Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
-Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
-
-## Enthält
-
-- **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
-- **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
-- **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
-- **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
-
-## Verwendung in einem Modul-Frontend
-
-```tsx
-import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
-
-export default function RootLayout({ children }: { children: React.ReactNode }) {
-  return (
-    <ThemeProvider>
-      <I18nProvider initialLocale="de">
-        <ToastProvider>
-          <Shell modules={[]} tenantLabel="Mandant XY">
-            {children}
-          </Shell>
-        </ToastProvider>
-      </I18nProvider>
-    </ThemeProvider>
-  );
-}
-```
-
-## Bekannter offener Punkt
-
-Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
-
-## Tests
-
-Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
-
-```bash
-npm install
-npm test
-npm run typecheck
-```

web/shl/__tests__/Dialog.test.tsx

@@ -1,38 +0,0 @@
-// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
-import { describe, expect, it, vi } from "vitest";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { Dialog } from "../components/Dialog";
-import { I18nProvider } from "../i18n/i18n";
-
-function renderDialog(onClose: () => void) {
-  return render(
-    <I18nProvider>
-      <Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
-        <button type="button">Erste Aktion</button>
-        <button type="button">Zweite Aktion</button>
-      </Dialog>
-    </I18nProvider>,
-  );
-}
-
-describe("Dialog: Tastaturbedienung", () => {
-  it("schließt sich bei ESC", () => {
-    const onClose = vi.fn();
-    renderDialog(onClose);
-    fireEvent.keyDown(document, { key: "Escape" });
-    expect(onClose).toHaveBeenCalledOnce();
-  });
-
-  it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
-    renderDialog(vi.fn());
-    const closeButton = screen.getByRole("button", { name: /schließen/i });
-    expect(document.activeElement).toBe(closeButton);
-  });
-
-  it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
-    renderDialog(vi.fn());
-    const dialog = screen.getByRole("dialog");
-    expect(dialog).toHaveAttribute("aria-modal", "true");
-    expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
-  });
-});

web/shl/__tests__/tokens.test.ts

@@ -1,39 +0,0 @@
-// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
-import { describe, expect, it } from "vitest";
-import { colorTokens } from "../tokens/tokens";
-
-// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
-function relLuminance(hex: string): number {
-  const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
-  const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-}
-
-function contrastRatio(a: string, b: string): number {
-  const l1 = relLuminance(a);
-  const l2 = relLuminance(b);
-  const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
-  return (lighter + 0.05) / (darker + 0.05);
-}
-
-describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
-  for (const scheme of ["light", "dark"] as const) {
-    const c = colorTokens[scheme];
-
-    it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
-    });
-
-    it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
-      expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
-    });
-  }
-});

web/shl/components/Dialog.tsx

@@ -1,88 +0,0 @@
-"use client";
-
-// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
-
-import { useEffect, useRef } from "react";
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-const FOCUSABLE_SELECTOR =
-  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
-
-export interface DialogProps {
-  open: boolean;
-  onClose: () => void;
-  titleId: string;
-  title: string;
-  children: ReactNode;
-}
-
-export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
-  const { t } = useI18n();
-  const dialogRef = useRef<HTMLDivElement>(null);
-  const previouslyFocused = useRef<HTMLElement | null>(null);
-
-  useEffect(() => {
-    if (!open) return;
-    previouslyFocused.current = document.activeElement as HTMLElement | null;
-
-    const node = dialogRef.current;
-    const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
-    focusables?.[0]?.focus();
-
-    function handleKeyDown(event: KeyboardEvent) {
-      if (event.key === "Escape") {
-        onClose();
-        return;
-      }
-      if (event.key !== "Tab" || !node) return;
-
-      const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
-      if (items.length === 0) return;
-      const first = items[0];
-      const last = items[items.length - 1];
-
-      if (event.shiftKey && document.activeElement === first) {
-        event.preventDefault();
-        last.focus();
-      } else if (!event.shiftKey && document.activeElement === last) {
-        event.preventDefault();
-        first.focus();
-      }
-    }
-
-    document.addEventListener("keydown", handleKeyDown);
-    return () => {
-      document.removeEventListener("keydown", handleKeyDown);
-      previouslyFocused.current?.focus();
-    };
-  }, [open, onClose]);
-
-  if (!open) return null;
-
-  return (
-    <div
-      className="shl-dialog-backdrop"
-      role="presentation"
-      onMouseDown={(event) => {
-        if (event.target === event.currentTarget) onClose();
-      }}
-    >
-      <div
-        ref={dialogRef}
-        className="shl-dialog"
-        role="dialog"
-        aria-modal="true"
-        aria-labelledby={titleId}
-      >
-        <div className="shl-dialog-header">
-          <h2 id={titleId}>{title}</h2>
-          <button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
-            ×
-          </button>
-        </div>
-        <div className="shl-dialog-body">{children}</div>
-      </div>
-    </div>
-  );
-}

web/shl/components/FormElements.tsx

@@ -1,98 +0,0 @@
-// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
-// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
-
-import { useId } from "react";
-import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
-
-interface FieldWrapperProps {
-  label: string;
-  error?: string;
-  hint?: string;
-  children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
-}
-
-function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
-  const inputId = useId();
-  const hintId = hint ? `${inputId}-hint` : undefined;
-  const errorId = error ? `${inputId}-error` : undefined;
-  const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
-
-  return (
-    <div className="shl-field">
-      <label htmlFor={inputId}>{label}</label>
-      {children({ inputId, describedBy })}
-      {hint && (
-        <p id={hintId} className="shl-field-hint">
-          {hint}
-        </p>
-      )}
-      {error && (
-        <p id={errorId} className="shl-field-error" role="alert">
-          {error}
-        </p>
-      )}
-    </div>
-  );
-}
-
-export interface TextFieldProps
-  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
-  label: string;
-  error?: string;
-  hint?: string;
-}
-
-export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
-  return (
-    <FieldWrapper label={label} error={error} hint={hint}>
-      {({ inputId, describedBy }) => (
-        <input
-          id={inputId}
-          aria-describedby={describedBy}
-          aria-invalid={error ? true : undefined}
-          {...inputProps}
-        />
-      )}
-    </FieldWrapper>
-  );
-}
-
-export interface SelectFieldProps
-  extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
-  label: string;
-  error?: string;
-  hint?: string;
-  children: ReactNode;
-}
-
-export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
-  return (
-    <FieldWrapper label={label} error={error} hint={hint}>
-      {({ inputId, describedBy }) => (
-        <select
-          id={inputId}
-          aria-describedby={describedBy}
-          aria-invalid={error ? true : undefined}
-          {...selectProps}
-        >
-          {children}
-        </select>
-      )}
-    </FieldWrapper>
-  );
-}
-
-export interface CheckboxFieldProps
-  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
-  label: string;
-}
-
-export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
-  const inputId = useId();
-  return (
-    <div className="shl-field shl-field-checkbox">
-      <input id={inputId} type="checkbox" {...inputProps} />
-      <label htmlFor={inputId}>{label}</label>
-    </div>
-  );
-}

web/shl/components/Shell.tsx

@@ -1,62 +0,0 @@
-"use client";
-
-// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
-// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
-
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-import { useTheme } from "../theme/ThemeProvider";
-
-export interface ModuleLink {
-  key: string;
-  label: string;
-  href: string;
-  active?: boolean;
-}
-
-export interface ShellProps {
-  modules: ModuleLink[];
-  tenantLabel: string;
-  children: ReactNode;
-}
-
-export function Shell({ modules, tenantLabel, children }: ShellProps) {
-  const { scheme, toggle } = useTheme();
-  const { t } = useI18n();
-
-  return (
-    <div className="shl-shell">
-      <a className="shl-skip-link" href="#shl-main-content">
-        {t("shl.shell.skipToContent", "Zum Inhalt springen")}
-      </a>
-      <header className="shl-shell-header">
-        <nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
-          <ul>
-            {modules.map((mod) => (
-              <li key={mod.key}>
-                <a href={mod.href} aria-current={mod.active ? "page" : undefined}>
-                  {mod.label}
-                </a>
-              </li>
-            ))}
-          </ul>
-        </nav>
-        <div className="shl-shell-context">
-          <span className="shl-tenant-context">{tenantLabel}</span>
-          <button
-            type="button"
-            onClick={toggle}
-            aria-label={
-              scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
-            }
-          >
-            {scheme === "light" ? "🌙" : "☀️"}
-          </button>
-        </div>
-      </header>
-      <main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
-        {children}
-      </main>
-    </div>
-  );
-}

web/shl/components/Table.tsx

@@ -1,83 +0,0 @@
-// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
-
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-export interface TableColumn<Row> {
-  key: string;
-  header: string;
-  render: (row: Row) => ReactNode;
-  sortable?: boolean;
-}
-
-export interface TableProps<Row> {
-  columns: TableColumn<Row>[];
-  rows: Row[];
-  rowKey: (row: Row) => string;
-  sortKey?: string;
-  sortDirection?: "asc" | "desc";
-  onSort?: (key: string) => void;
-  caption?: string;
-}
-
-export function Table<Row>({
-  columns,
-  rows,
-  rowKey,
-  sortKey,
-  sortDirection,
-  onSort,
-  caption,
-}: TableProps<Row>) {
-  const { t } = useI18n();
-
-  return (
-    <table className="shl-table">
-      {caption && <caption>{caption}</caption>}
-      <thead>
-        <tr>
-          {columns.map((column) => {
-            const isSorted = column.key === sortKey;
-            const ariaSort = column.sortable
-              ? isSorted
-                ? sortDirection === "asc"
-                  ? "ascending"
-                  : "descending"
-                : "none"
-              : undefined;
-            return (
-              <th key={column.key} scope="col" aria-sort={ariaSort}>
-                {column.sortable ? (
-                  <button
-                    type="button"
-                    onClick={() => onSort?.(column.key)}
-                    className="shl-table-sort-button"
-                  >
-                    {column.header}
-                  </button>
-                ) : (
-                  column.header
-                )}
-              </th>
-            );
-          })}
-        </tr>
-      </thead>
-      <tbody>
-        {rows.length === 0 ? (
-          <tr>
-            <td colSpan={columns.length}>{t("shl.table.noRows")}</td>
-          </tr>
-        ) : (
-          rows.map((row) => (
-            <tr key={rowKey(row)}>
-              {columns.map((column) => (
-                <td key={column.key}>{column.render(row)}</td>
-              ))}
-            </tr>
-          ))
-        )}
-      </tbody>
-    </table>
-  );
-}

web/shl/components/Toast.tsx

@@ -1,67 +0,0 @@
-"use client";
-
-// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
-
-import { createContext, useCallback, useContext, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-import { useI18n } from "../i18n/i18n";
-
-export type ToastVariant = "info" | "success" | "danger" | "warning";
-
-export interface ToastMessage {
-  id: string;
-  text: string;
-  variant: ToastVariant;
-}
-
-interface ToastContextValue {
-  toasts: ToastMessage[];
-  push: (text: string, variant?: ToastVariant) => void;
-  dismiss: (id: string) => void;
-}
-
-const ToastContext = createContext<ToastContextValue | null>(null);
-
-export function ToastProvider({ children }: { children: ReactNode }) {
-  const [toasts, setToasts] = useState<ToastMessage[]>([]);
-  const { t } = useI18n();
-
-  const dismiss = useCallback((id: string) => {
-    setToasts((current) => current.filter((toast) => toast.id !== id));
-  }, []);
-
-  const push = useCallback((text: string, variant: ToastVariant = "info") => {
-    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    setToasts((current) => [...current, { id, text, variant }]);
-  }, []);
-
-  const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
-
-  return (
-    <ToastContext.Provider value={value}>
-      {children}
-      <div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
-        {toasts.map((toast) => (
-          <div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
-            <span>{toast.text}</span>
-            <button
-              type="button"
-              onClick={() => dismiss(toast.id)}
-              aria-label={t("shl.toast.dismiss")}
-            >
-              ×
-            </button>
-          </div>
-        ))}
-      </div>
-    </ToastContext.Provider>
-  );
-}
-
-export function useToast(): ToastContextValue {
-  const ctx = useContext(ToastContext);
-  if (!ctx) {
-    throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
-  }
-  return ctx;
-}

web/shl/i18n/i18n.tsx

@@ -1,75 +0,0 @@
-"use client";
-
-// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
-// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
-// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
-// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
-
-import { createContext, useContext, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-
-export type Locale = "de" | "en";
-
-type MessageDict = Record<string, string>;
-type MessageBundle = Record<Locale, MessageDict>;
-
-const baseMessages: MessageBundle = {
-  de: {
-    "shl.dialog.close": "Schließen",
-    "shl.toast.dismiss": "Meldung schließen",
-    "shl.table.noRows": "Keine Einträge vorhanden",
-    "shl.theme.toggleToLight": "Helles Erscheinungsbild",
-    "shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
-  },
-  en: {
-    "shl.dialog.close": "Close",
-    "shl.toast.dismiss": "Dismiss message",
-    "shl.table.noRows": "No entries",
-    "shl.theme.toggleToLight": "Switch to light theme",
-    "shl.theme.toggleToDark": "Switch to dark theme",
-  },
-};
-
-// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
-const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
-
-export function registerMessages(locale: Locale, messages: MessageDict): void {
-  registry[locale] = { ...registry[locale], ...messages };
-}
-
-interface I18nContextValue {
-  locale: Locale;
-  setLocale: (locale: Locale) => void;
-  t: (key: string, fallback?: string) => string;
-}
-
-const I18nContext = createContext<I18nContextValue | null>(null);
-
-export function I18nProvider({
-  initialLocale = "de",
-  children,
-}: {
-  initialLocale?: Locale;
-  children: ReactNode;
-}) {
-  const [locale, setLocale] = useState<Locale>(initialLocale);
-
-  const value = useMemo<I18nContextValue>(
-    () => ({
-      locale,
-      setLocale,
-      t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
-    }),
-    [locale],
-  );
-
-  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
-}
-
-export function useI18n(): I18nContextValue {
-  const ctx = useContext(I18nContext);
-  if (!ctx) {
-    throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
-  }
-  return ctx;
-}

web/shl/index.ts

@@ -1,25 +0,0 @@
-// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
-// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
-
-export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
-export type { ColorScheme, ColorTokens } from "./tokens/tokens";
-
-export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
-
-export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
-export type { Locale } from "./i18n/i18n";
-
-export { Shell } from "./components/Shell";
-export type { ShellProps, ModuleLink } from "./components/Shell";
-
-export { Dialog } from "./components/Dialog";
-export type { DialogProps } from "./components/Dialog";
-
-export { Table } from "./components/Table";
-export type { TableProps, TableColumn } from "./components/Table";
-
-export { TextField, SelectField, CheckboxField } from "./components/FormElements";
-export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
-
-export { ToastProvider, useToast } from "./components/Toast";
-export type { ToastMessage, ToastVariant } from "./components/Toast";

web/shl/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "@nexarch/shl",
-  "version": "0.1.0",
-  "private": true,
-  "description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
-  "main": "index.ts",
-  "types": "index.ts",
-  "scripts": {
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "peerDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
-  },
-  "devDependencies": {
-    "@testing-library/jest-dom": "^6.4.8",
-    "@testing-library/react": "^16.0.0",
-    "@types/react": "18.3.3",
-    "@types/react-dom": "18.3.0",
-    "jsdom": "^24.1.1",
-    "typescript": "5.5.3",
-    "vitest": "^2.0.0"
-  }
-}

web/shl/theme/ThemeProvider.tsx

@@ -1,81 +0,0 @@
-"use client";
-
-// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
-// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
-
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
-import type { ReactNode } from "react";
-import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
-
-const STORAGE_KEY = "nexarch-shl-theme";
-
-interface ThemeContextValue {
-  scheme: ColorScheme;
-  setScheme: (scheme: ColorScheme) => void;
-  toggle: () => void;
-}
-
-const ThemeContext = createContext<ThemeContextValue | null>(null);
-
-function readStoredScheme(): ColorScheme | null {
-  if (typeof window === "undefined") return null;
-  try {
-    const stored = window.localStorage.getItem(STORAGE_KEY);
-    return stored === "light" || stored === "dark" ? stored : null;
-  } catch {
-    // localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
-    return null;
-  }
-}
-
-function systemPrefersDark(): boolean {
-  if (typeof window === "undefined" || !window.matchMedia) return false;
-  return window.matchMedia("(prefers-color-scheme: dark)").matches;
-}
-
-export function ThemeProvider({ children }: { children: ReactNode }) {
-  const [scheme, setSchemeState] = useState<ColorScheme>("light");
-
-  useEffect(() => {
-    const stored = readStoredScheme();
-    setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
-  }, []);
-
-  const setScheme = useCallback((next: ColorScheme) => {
-    setSchemeState(next);
-    try {
-      window.localStorage.setItem(STORAGE_KEY, next);
-    } catch {
-      // Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
-    }
-  }, []);
-
-  const toggle = useCallback(() => {
-    setScheme(scheme === "light" ? "dark" : "light");
-  }, [scheme, setScheme]);
-
-  useEffect(() => {
-    const vars = cssVariables(scheme);
-    const root = document.documentElement;
-    for (const [key, value] of Object.entries(vars)) {
-      root.style.setProperty(key, value);
-    }
-    root.dataset.shlTheme = scheme;
-  }, [scheme]);
-
-  const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
-
-  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
-}
-
-export function useTheme(): ThemeContextValue {
-  const ctx = useContext(ThemeContext);
-  if (!ctx) {
-    throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
-  }
-  return ctx;
-}
-
-export function currentColors(scheme: ColorScheme) {
-  return colorTokens[scheme];
-}

web/shl/tokens/tokens.ts

@@ -1,96 +0,0 @@
-// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
-// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
-// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
-
-export type ColorScheme = "light" | "dark";
-
-export interface ColorTokens {
-  background: string;
-  surface: string;
-  surfaceRaised: string;
-  border: string;
-  textPrimary: string;
-  textSecondary: string;
-  accent: string;
-  accentContrast: string;
-  danger: string;
-  dangerContrast: string;
-  success: string;
-  warning: string;
-  focusRing: string;
-}
-
-// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
-// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
-export const colorTokens: Record<ColorScheme, ColorTokens> = {
-  light: {
-    background: "#FFFFFF",
-    surface: "#F5F6F8",
-    surfaceRaised: "#FFFFFF",
-    border: "#D7DBE0",
-    textPrimary: "#14181F",
-    textSecondary: "#4B5563",
-    accent: "#1D4ED8",
-    accentContrast: "#FFFFFF",
-    danger: "#B91C1C",
-    dangerContrast: "#FFFFFF",
-    success: "#15803D",
-    warning: "#B45309",
-    focusRing: "#1D4ED8",
-  },
-  dark: {
-    background: "#0F1115",
-    surface: "#181B21",
-    surfaceRaised: "#20242C",
-    border: "#333944",
-    textPrimary: "#F2F4F7",
-    textSecondary: "#B4BAC4",
-    accent: "#5B8DEF",
-    accentContrast: "#0F1115",
-    danger: "#F87171",
-    dangerContrast: "#0F1115",
-    success: "#4ADE80",
-    warning: "#FBBF24",
-    focusRing: "#5B8DEF",
-  },
-};
-
-export const spacing = {
-  xs: "4px",
-  sm: "8px",
-  md: "16px",
-  lg: "24px",
-  xl: "32px",
-  xxl: "48px",
-} as const;
-
-export const breakpoints = {
-  mobile: "0px",
-  tablet: "768px",
-  desktop: "1200px",
-} as const;
-
-export const typography = {
-  fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
-  fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
-  sizeSm: "13px",
-  sizeMd: "15px",
-  sizeLg: "18px",
-  sizeXl: "24px",
-  lineHeight: 1.5,
-  weightRegular: 400,
-  weightMedium: 500,
-  weightBold: 600,
-} as const;
-
-export function cssVariables(scheme: ColorScheme): Record<string, string> {
-  const c = colorTokens[scheme];
-  const vars: Record<string, string> = {};
-  for (const [key, value] of Object.entries(c)) {
-    vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
-  }
-  for (const [key, value] of Object.entries(spacing)) {
-    vars[`--shl-spacing-${key}`] = value;
-  }
-  return vars;
-}

web/shl/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "jsx": "react-jsx",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true
-  },
-  "include": ["**/*.ts", "**/*.tsx"],
-  "exclude": ["node_modules"]
-}

web/shl/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "jsdom",
-    setupFiles: ["./vitest.setup.ts"],
-  },
-});

web/shl/vitest.setup.ts

@@ -1,9 +0,0 @@
-import "@testing-library/jest-dom/vitest";
-import { afterEach } from "vitest";
-import { cleanup } from "@testing-library/react";
-
-// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
-// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
-afterEach(() => {
-  cleanup();
-});