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

SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)
AUD-04: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)
2026-08-28 22:02:02 +02:00 · 2026-08-28 22:01:56 +02:00 · 2026-08-28 21:56:27 +02:00 · 2026-08-28 21:56:20 +02:00 · 2026-08-28 21:55:34 +02:00 · 2026-08-28 21:47:23 +02:00
69 changed files with 1734 additions and 3442 deletions
@@ -1,2 +1,4 @@
 *.log
 .env
+web/*/node_modules/
+web/*/.next/
@@ -64,6 +64,9 @@ 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.
@@ -127,5 +130,32 @@ 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 +

 ---
@@ -0,0 +1,69 @@
+// auditlog-devserver stellt AUD-03s ExportHandler (internal/audit) fuer die
+// Next.js-Audit-Log-Ansicht (AUD-04) bereit. Getrennt von cmd/core aus
+// demselben Grund wie die anderen *-devserver (siehe LIC-04/TEN-05): echte
+// Auth/RBAC ist noch nicht in die zentrale Server-Topologie verdrahtet.
+//
+// Authorize wird hier mit einem geteilten Admin-Token ueber
+// crypto/subtle.ConstantTimeCompare umgesetzt — demselben Timing-safe-Muster
+// wie internal/audit.timingsafe (AUD-02), NICHT ueber eine neue
+// Rollen-/Rechteschicht, da diese Kachel ausdruecklich nur von AUD-03
+// abhaengt und keine Rechteverwaltung duplizieren soll.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
+	"gitea.perlbach24.de/scripte/nexarch/internal/auditadmin"
+	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
+	}
+	adminToken := os.Getenv("NEXARCH_AUDIT_ADMIN_TOKEN")
+	if adminToken == "" {
+		log.Fatal("NEXARCH_AUDIT_ADMIN_TOKEN nicht gesetzt")
+	}
+	addr := os.Getenv("NEXARCH_AUDITLOG_LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8083"
+	}
+
+	ctx := context.Background()
+	pool, err := db.Connect(ctx, dsn)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	auditLog := audit.NewLog(pool)
+	tokenAuthorize := auditadmin.NewTokenAuthorizer(adminToken)
+	authorize := func(_ context.Context, caller string) bool { return tokenAuthorize(caller) }
+	handler := audit.NewExportHandler(auditLog, authorize)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/audit/export", withCORS(handler.Export))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("auditlog-devserver listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func withCORS(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next(w, r)
+	}
+}
@@ -1,70 +0,0 @@
-// resync-api ist der Aufrufpunkt fuer API-11: startet den bereits
-// fertigen internal/resync.Handler (API-06) als eigenstaendigen
-// HTTP-Dienst. REINES WIRING — keine Aenderung an internal/resync/,
-// internal/audit/, internal/usage/ oder internal/moduleregistry/.
-package main
-
-import (
-	"context"
-	"log"
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
-	"gitea.perlbach24.de/scripte/nexarch/internal/resync"
-	"gitea.perlbach24.de/scripte/nexarch/internal/usage"
-)
-
-// auditAdapter erfüllt resync.AuditRecorder über den bestehenden
-// audit.Log-Schreibpfad — kein neuer Audit-Code, nur Signatur-Anpassung
-// (audit.Log.Record nimmt ein Event-Struct, resync.AuditRecorder einzelne
-// Felder).
-type auditAdapter struct{ log *audit.Log }
-
-func (a auditAdapter) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
-	return a.log.Record(ctx, audit.Event{
-		TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target,
-		Metadata: metadata, OccurredAt: occurredAt,
-	})
-}
-
-func main() {
-	registryDSN := os.Getenv("NEXARCH_RESYNC_REGISTRY_DSN")
-	if registryDSN == "" {
-		log.Fatal("NEXARCH_RESYNC_REGISTRY_DSN muss gesetzt sein")
-	}
-	addr := os.Getenv("NEXARCH_RESYNC_API_LISTEN_ADDR")
-	if addr == "" {
-		addr = "127.0.0.1:8098"
-	}
-
-	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, registryDSN)
-	if err != nil {
-		log.Fatalf("datenbankverbindung: %v", err)
-	}
-	defer pool.Close()
-
-	flagStore := flag.NewStore(pool)
-	flagService := flag.NewService(flagStore, 30*time.Second)
-	registry := moduleregistry.NewRegistry(pool, flagService)
-	auditLog := audit.NewLog(pool)
-	usageStore := usage.NewStore(pool)
-
-	handler := resync.NewHandler(registry, auditAdapter{log: auditLog}, usageStore)
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
-	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	log.Printf("resync-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
-		log.Fatalf("http server: %v", err)
-	}
-}
@@ -1,14 +0,0 @@
-[Unit]
-Description=NEXARCH Core - Wiederanlauf-Nachsynchronisierung (API-06/API-11)
-After=network.target postgresql.service
-
-[Service]
-Type=simple
-User=nexarch
-EnvironmentFile=/etc/nexarch/resync-api.env
-ExecStart=__INSTALL_DIR__/bin/resync-api
-Restart=on-failure
-StandardOutput=journal
-
-[Install]
-WantedBy=multi-user.target
@@ -1,76 +0,0 @@
-# API-11 – Prüfprotokoll: Wiederanlauf-Nachsynchronisierungs-Endpunkt starten (API-06 als laufender Dienst)
-
-Voraussetzung API-06 – bereits Fertig, hier UNVERÄNDERT.
-
-## Reines Wiring, keine neue Logik
-
-`git diff --stat internal/resync/ internal/audit/ internal/usage/ internal/moduleregistry/`
-liefert KEINEN Diff gegenüber den jeweiligen Ticket-Ständen. `API-11`
-fügt ausschließlich `cmd/resync-api/main.go` hinzu — inklusive eines
-kleinen `auditAdapter`, der `resync.AuditRecorder` (einzelne Felder)
-auf `audit.Log.Record` (Event-Struct) abbildet. Das ist reine
-Signatur-Anpassung, keine neue Geschäftslogik.
-
-## Root Cause (dokumentiert)
-
-`cmd/core/main.go` ist seit TEN-01 minimal geblieben (nur `/healthz`,
-`/internal/tenants`) — kein späteres Ticket (RBAC-02, CFG-02, API-06,
-...) wurde je dort zentral eingehängt. Jedes Modul entstand auf einer
-eigenen, unabhängigen Feature-Branch-Kette. API-11 folgt dem in dieser
-Session etablierten Muster (RBAC-06, CFG-05, RET-09): ein eigener,
-kleiner HTTP-Dienst statt eines zentralen `cmd/core`-Umbaus.
-
-## Umsetzung
-
- `cmd/resync-api/main.go` – startet `internal/resync.Handler` mit
-  echten Produktions-Implementierungen: `moduleregistry.Registry`
-  (Auth), `audit.Log` (über `auditAdapter`), `usage.Store`.
- `deploy/systemd/nexarch-resync-api.service.tmpl`.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-resync-api.service` aktiv, `Restart=on-failure` |
-| 2 | Realer POST /internal/resync/usage von einem externen Testclient gegen den laufenden Dienst liefert die erwartete Verarbeitung | **bestanden** – real per `curl`: mit echtem, über `moduleregistry.Registry.Provision` ausgestelltem Service-Credential (`X-Nexarch-Client-Id`/`X-Nexarch-Client-Secret`) liefert der Aufruf `{"applied":1}`, `usage_counters` zeigt real den erhöhten Zähler; mit falschem Credential 401. Testdaten (Modul, Credential, Zähler-Zeile) anschließend entfernt |
-| 3 | Code-Review: keine Änderung an internal/resync/ selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat` bestätigt: `internal/resync/`, `internal/audit/`, `internal/usage/`, `internal/moduleregistry/` unverändert gegenüber ihren jeweiligen Ticket-Ständen |
-
-## Echte Verdrahtung auf 192.168.1.131
-
- `resync-api` gebaut nach `/opt/nexarch-core/bin/`,
-  `/etc/nexarch/resync-api.env` (0600), `nexarch-resync-api.service`
-  installiert/aktiviert.
- Reale Rechtevergabe-Lücke gefunden und behoben (gleiches Muster wie
-  bei den vorherigen Wrapper-Diensten): `modules`, `module_credentials`,
-  `audit_events`, `feature_flags`, `usage_counters`,
-  `resync_audit_buffer`, `resync_usage_buffer` gehörten `postgres`,
-  `nexarch_core` hatte keine Rechte — `GRANT` nachgezogen und über
-  `information_schema.role_table_grants` verifiziert, bevor der
-  End-zu-Ende-Test erneut lief.
- Zusätzliche reale Erkenntnis: `usage_counters.tenant_id` ist `UUID`,
-  nicht der Tenant-Slug (String) — beim ersten Testversuch mit `"acme"`
-  scheiterte der Insert intern, `UsageHandler` meldete `applied:0` statt
-  eines Fehlers (stiller Fehlschlag pro Delta, so von API-06 selbst so
-  entworfen: "Aufrufer entfernt aus seinem Puffer nur bestätigt
-  übernommene Deltas" — kein API-11-Defekt, sondern korrektes,
-  bestehendes API-06-Verhalten). Mit echter UUID als `tenant_slug`-Wert
-  lieferte der Aufruf real `applied:1`.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./cmd/resync-api/...  -> 0 issues
-```
-
-Keine neuen Go-Tests nötig (kein neuer Fachcode außer main.go/Adapter,
-die eigentliche Logik ist bereits durch API-06s eigene Tests
-abgedeckt).
-
-## Gesamtergebnis
-
-**Bestanden.** API-06 ist jetzt ein real laufender, über systemd
-verwalteter Dienst. Modul-Clients wie DMS' `storage.HTTPUsageReporter`
-(RET-06/DOC-16-Umfeld) können sich jetzt real gegen einen laufenden
-Endpunkt verdrahten, statt gegen unverdrahteten Go-Code zu testen.
@@ -2,10 +2,7 @@ module gitea.perlbach24.de/scripte/nexarch

 go 1.22

-require (
-	github.com/golang-jwt/jwt/v5 v5.3.1
-	github.com/jackc/pgx/v5 v5.6.0
-)
+require github.com/jackc/pgx/v5 v5.6.0

 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
@@ -1,8 +1,6 @@
 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=
@@ -0,0 +1,122 @@
+package audit
+
+import (
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+)
+
+// Filter grenzt einen Export ein (Akzeptanzkriterium 1). Leere/Nil-Felder
+// bedeuten "kein Filter auf diesem Feld".
+type Filter struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	From       *time.Time
+	To         *time.Time
+}
+
+func buildFilterQuery(f Filter) (string, []any) {
+	query := `SELECT occurred_at, tenant_slug, actor, action, target, metadata FROM audit_events WHERE 1=1`
+	var args []any
+
+	if f.TenantSlug != "" {
+		args = append(args, f.TenantSlug)
+		query += fmt.Sprintf(" AND tenant_slug = $%d", len(args))
+	}
+	if f.Actor != "" {
+		args = append(args, f.Actor)
+		query += fmt.Sprintf(" AND actor = $%d", len(args))
+	}
+	if f.Action != "" {
+		args = append(args, f.Action)
+		query += fmt.Sprintf(" AND action = $%d", len(args))
+	}
+	if f.From != nil {
+		args = append(args, *f.From)
+		query += fmt.Sprintf(" AND occurred_at >= $%d", len(args))
+	}
+	if f.To != nil {
+		args = append(args, *f.To)
+		query += fmt.Sprintf(" AND occurred_at <= $%d", len(args))
+	}
+	query += " ORDER BY occurred_at"
+	return query, args
+}
+
+// StreamCSV schreibt gefilterte Audit-Eintraege direkt als CSV in w, Zeile
+// fuer Zeile ueber rows.Next() — es wird zu keinem Zeitpunkt das gesamte
+// Ergebnis im Speicher aufgebaut (Akzeptanzkriterium 3 / Pruefung 1).
+func (l *Log) StreamCSV(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	cw := csv.NewWriter(w)
+	if err := cw.Write([]string{"occurred_at", "tenant_slug", "actor", "action", "target", "metadata"}); err != nil {
+		return fmt.Errorf("csv-header schreiben: %w", err)
+	}
+
+	for rows.Next() {
+		var occurredAt time.Time
+		var tenantSlug, actor, action, target string
+		var metadataJSON []byte
+		if err := rows.Scan(&occurredAt, &tenantSlug, &actor, &action, &target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		if err := cw.Write([]string{
+			occurredAt.Format(time.RFC3339), tenantSlug, actor, action, target, string(metadataJSON),
+		}); err != nil {
+			return fmt.Errorf("csv-zeile schreiben: %w", err)
+		}
+	}
+	cw.Flush()
+	if err := rows.Err(); err != nil {
+		return fmt.Errorf("export lesen: %w", err)
+	}
+	return cw.Error()
+}
+
+// exportRecord ist die JSON-Repraesentation einer exportierten Zeile.
+type exportRecord struct {
+	OccurredAt time.Time       `json:"occurred_at"`
+	TenantSlug string          `json:"tenant_slug"`
+	Actor      string          `json:"actor"`
+	Action     string          `json:"action"`
+	Target     string          `json:"target"`
+	Metadata   json.RawMessage `json:"metadata"`
+}
+
+// StreamJSON schreibt gefilterte Audit-Eintraege als JSON Lines (ein
+// JSON-Objekt pro Zeile) — bewusst kein einzelnes grosses JSON-Array, da
+// dessen korrektes Streaming (Kommas/Klammern ohne Zwischenpufferung)
+// unnoetige Komplexitaet fuer denselben Zweck waere. Wie StreamCSV
+// zeilenweise ueber rows.Next(), kein Aufbau im Speicher.
+func (l *Log) StreamJSON(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	enc := json.NewEncoder(w)
+	for rows.Next() {
+		var rec exportRecord
+		var metadataJSON []byte
+		if err := rows.Scan(&rec.OccurredAt, &rec.TenantSlug, &rec.Actor, &rec.Action, &rec.Target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		rec.Metadata = metadataJSON
+		if err := enc.Encode(rec); err != nil {
+			return fmt.Errorf("json-zeile schreiben: %w", err)
+		}
+	}
+	return rows.Err()
+}
@@ -0,0 +1,73 @@
+package audit
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Authorize entscheidet, ob caller den Export ausfuehren darf. Die
+// eigentliche Rollen-/Rechtepruefung (RBAC-02 Policy-Enforcement) ist nicht
+// Teil dieser Kachel — ExportHandler kennt nur diese schmale Schnittstelle,
+// analog zum RetentionRegistrar-Muster aus AUD-05.
+type Authorize func(ctx context.Context, caller string) bool
+
+// ExportHandler stellt den Export als HTTP-Endpunkt bereit
+// (Akzeptanzkriterium 2: fuer berechtigte Rollen verfuegbar).
+type ExportHandler struct {
+	log       *Log
+	authorize Authorize
+}
+
+func NewExportHandler(log *Log, authorize Authorize) *ExportHandler {
+	return &ExportHandler{log: log, authorize: authorize}
+}
+
+// Export liest Filter-Query-Parameter (tenant, actor, action, from, to,
+// format) und schreibt DIREKT auf den ResponseWriter (io.Writer) — dieselbe
+// Streaming-Funktion wie in export.go, kein zusaetzlicher Pufferungsschritt.
+func (h *ExportHandler) Export(w http.ResponseWriter, r *http.Request) {
+	// "caller" identifiziert die anfragende Person fuer die Berechtigungs-
+	// pruefung — bewusst getrennt vom Filterfeld "actor" (das den
+	// AUDIT-Akteur meint, ueber den gefiltert wird).
+	caller := r.URL.Query().Get("caller")
+	if caller == "" || !h.authorize(r.Context(), caller) {
+		http.Error(w, "keine berechtigung fuer audit-log-export", http.StatusForbidden)
+		return
+	}
+
+	filter := Filter{
+		TenantSlug: r.URL.Query().Get("tenant"),
+		Actor:      r.URL.Query().Get("actor"),
+		Action:     r.URL.Query().Get("action"),
+	}
+	if from := r.URL.Query().Get("from"); from != "" {
+		t, err := time.Parse(time.RFC3339, from)
+		if err != nil {
+			http.Error(w, "ungueltiges from-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.From = &t
+	}
+	if to := r.URL.Query().Get("to"); to != "" {
+		t, err := time.Parse(time.RFC3339, to)
+		if err != nil {
+			http.Error(w, "ungueltiges to-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.To = &t
+	}
+
+	switch r.URL.Query().Get("format") {
+	case "json":
+		w.Header().Set("Content-Type", "application/x-ndjson")
+		if err := h.log.StreamJSON(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	default:
+		w.Header().Set("Content-Type", "text/csv")
+		if err := h.log.StreamCSV(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	}
+}
@@ -0,0 +1,222 @@
+package audit
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupExportTest(t *testing.T) (*Log, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewLog(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Filterkombinationen liefern korrekte
+// Teilmengen.
+func TestExport_FilterCombinations(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	run := fmt.Sprintf("_%d", time.Now().UnixNano())
+	tenantA, tenantB := "test_fa"+run, "test_fb"+run
+	alice, bob := "alice"+run, "bob"+run
+
+	events := []Event{
+		{TenantSlug: tenantA, Actor: alice, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: bob, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: alice, Action: "logout", Target: "x"},
+		{TenantSlug: tenantB, Actor: alice, Action: "login", Target: "x"},
+	}
+	for _, e := range events {
+		if err := log.Record(ctx, e); err != nil {
+			t.Fatalf("record: %v", err)
+		}
+	}
+
+	cases := []struct {
+		name    string
+		filter  Filter
+		wantLen int
+	}{
+		{"nach tenant", Filter{TenantSlug: tenantA}, 3},
+		{"nach tenant+actor", Filter{TenantSlug: tenantA, Actor: alice}, 2},
+		{"nach tenant+actor+action", Filter{TenantSlug: tenantA, Actor: alice, Action: "login"}, 1},
+		{"nach actor ueber beide tenants", Filter{Actor: alice, Action: "login"}, 2},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := log.StreamCSV(ctx, c.filter, &buf); err != nil {
+				t.Fatalf("stream: %v", err)
+			}
+			rows, err := csv.NewReader(&buf).ReadAll()
+			if err != nil {
+				t.Fatalf("csv parsen: %v", err)
+			}
+			got := len(rows) - 1 // Header abziehen
+			if got != c.wantLen {
+				t.Fatalf("erwartet %d zeilen, habe %d", c.wantLen, got)
+			}
+		})
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zeitraum-Filter.
+func TestExport_TimeRangeFilter(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_tr_%d", time.Now().UnixNano())
+	past := time.Now().Add(-48 * time.Hour)
+	future := time.Now().Add(48 * time.Hour)
+
+	if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "a", Action: "x", Target: "t", OccurredAt: time.Now()}); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	var buf bytes.Buffer
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &past, To: &future}, &buf); err != nil {
+		t.Fatalf("stream (innerhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 1 {
+		t.Fatalf("erwartet 1 eintrag innerhalb des zeitraums, habe %d", got)
+	}
+
+	farPast := time.Now().Add(-96 * time.Hour)
+	buf.Reset()
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &farPast, To: &past}, &buf); err != nil {
+		t.Fatalf("stream (ausserhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 0 {
+		t.Fatalf("erwartet 0 eintraege ausserhalb des zeitraums, habe %d", got)
+	}
+}
+
+func countLines(s string) int {
+	s = strings.TrimRight(s, "\n")
+	if s == "" {
+		return 0
+	}
+	return len(strings.Split(s, "\n"))
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Export mit hoher Eintragszahl ohne
+// uebermaessigen Speicherverbrauch — Stichprobe per runtime.MemStats.
+func TestExport_StreamsLargeResultWithoutExcessiveMemory(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_large_%d", time.Now().UnixNano())
+	const n = 20000
+	for i := 0; i < n; i++ {
+		if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "bulk", Action: "test.bulk", Target: fmt.Sprintf("obj-%d", i)}); err != nil {
+			t.Fatalf("record %d: %v", i, err)
+		}
+	}
+
+	runtime.GC()
+	var before runtime.MemStats
+	runtime.ReadMemStats(&before)
+
+	lineCount := 0
+	cw := &countingWriter{onWrite: func(p []byte) { lineCount += strings.Count(string(p), "\n") }}
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant}, cw); err != nil {
+		t.Fatalf("stream: %v", err)
+	}
+
+	runtime.GC()
+	var after runtime.MemStats
+	runtime.ReadMemStats(&after)
+
+	if lineCount != n+1 { // +1 Header
+		t.Fatalf("erwartet %d zeilen (inkl. header), habe %d", n+1, lineCount)
+	}
+
+	// Grobe Stichprobe: ein NICHT streamender Export haette hier locker
+	// mehrere MB an einmal gehaltenen Zeilen/Strings erzeugt. Grosszuegige
+	// Schwelle, da Go-Heap-Messungen naturgemaess rauschen.
+	const maxAcceptableGrowth = 3 * 1024 * 1024 // 3 MB
+	growth := int64(after.HeapAlloc) - int64(before.HeapAlloc)
+	t.Logf("heap-wachstum waehrend export von %d zeilen: %d bytes (schwelle: %d)", n, growth, maxAcceptableGrowth)
+	if growth > maxAcceptableGrowth {
+		t.Fatalf("heap ist um %d bytes gewachsen, erwartet unter %d (hinweis auf vollstaendige pufferung statt streaming)", growth, maxAcceptableGrowth)
+	}
+}
+
+type countingWriter struct {
+	onWrite func(p []byte)
+}
+
+func (w *countingWriter) Write(p []byte) (int, error) {
+	w.onWrite(p)
+	return len(p), nil
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Zugriff ohne passende Berechtigung wird abgewiesen.
+func TestExportHandler_RejectsWithoutAuthorization(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+
+	handler := NewExportHandler(log, func(ctx context.Context, caller string) bool {
+		return caller == "berechtigte-person@example.com"
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/audit/export?caller=unberechtigt@example.com", nil)
+	rec := httptest.NewRecorder()
+	handler.Export(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("unberechtigt: status = %d, want 403", rec.Code)
+	}
+
+	reqNoCaller := httptest.NewRequest(http.MethodGet, "/audit/export", nil)
+	recNoCaller := httptest.NewRecorder()
+	handler.Export(recNoCaller, reqNoCaller)
+	if recNoCaller.Code != http.StatusForbidden {
+		t.Fatalf("ohne caller: status = %d, want 403", recNoCaller.Code)
+	}
+
+	reqOK := httptest.NewRequest(http.MethodGet, "/audit/export?caller=berechtigte-person@example.com", nil)
+	recOK := httptest.NewRecorder()
+	handler.Export(recOK, reqOK)
+	if recOK.Code != http.StatusOK {
+		t.Fatalf("berechtigt: status = %d, want 200", recOK.Code)
+	}
+}
@@ -0,0 +1,23 @@
+// Package auditadmin implementiert Core AUD-04: die Berechtigungspruefung
+// fuer die Audit-Log-Ansicht. Enthaelt bewusst KEINE eigene Filter-/
+// Export-Logik — die Ansicht ist "reiner Konsument der Export-API" (AUD-03,
+// internal/audit.ExportHandler); dieses Paket liefert nur die
+// audit.Authorize-Implementierung, die der Entwicklungs-/Testserver
+// (cmd/auditlog-devserver) einhaengt.
+package auditadmin
+
+import "crypto/subtle"
+
+// NewTokenAuthorizer liefert eine audit.Authorize-Funktion, die den
+// aufrufenden "caller"-Wert timing-safe gegen ein geteiltes Admin-Token
+// vergleicht — dasselbe Muster wie internal/audit.timingsafe (AUD-02),
+// NICHT ueber eine neue Rollen-/Rechteschicht, da AUD-04 ausdruecklich nur
+// von AUD-03 abhaengt.
+func NewTokenAuthorizer(adminToken string) func(caller string) bool {
+	return func(caller string) bool {
+		if caller == "" || adminToken == "" {
+			return false
+		}
+		return subtle.ConstantTimeCompare([]byte(caller), []byte(adminToken)) == 1
+	}
+}
@@ -0,0 +1,33 @@
+package auditadmin
+
+import "testing"
+
+// Grundlage fuer Akzeptanzkriterium 1/2: die Oberflaeche darf Daten und den
+// Export nur bei korrektem Admin-Token abrufen.
+func TestNewTokenAuthorizer_AcceptsCorrectToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if !authorize("geheimes-token") {
+		t.Fatal("erwartet true fuer korrektes token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWrongToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("falsches-token") {
+		t.Fatal("erwartet false fuer falsches token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsEmptyCaller(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("") {
+		t.Fatal("erwartet false fuer leeren aufrufer")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWhenNoTokenConfigured(t *testing.T) {
+	authorize := NewTokenAuthorizer("")
+	if authorize("irgendwas") {
+		t.Fatal("erwartet false, wenn kein admin-token konfiguriert ist (fail-safe-default)")
+	}
+}
@@ -1,87 +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
-}
-
-func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
-	var f Flag
-	row := s.pool.QueryRow(ctx, `
-		SELECT key, enabled, rollout_percentage, target_tenant_slugs
-		FROM feature_flags WHERE key = $1
-	`, key)
-	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Flag{}, ErrNotFound
-		}
-		return Flag{}, fmt.Errorf("flag lesen: %w", err)
-	}
-	return f, nil
-}
-
-// evaluate wendet die Strategien in fester Reihenfolge an: globaler
-// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
-// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
-// kein Feature wird versehentlich aktiv.
-func evaluate(f Flag, tenantSlug string) bool {
-	if f.Enabled {
-		return true
-	}
-	for _, target := range f.TargetTenantSlugs {
-		if target == tenantSlug {
-			return true
-		}
-	}
-	if f.RolloutPercentage > 0 {
-		h := fnv.New32a()
-		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
-		return int(h.Sum32()%100) < f.RolloutPercentage
-	}
-	return false
-}
@@ -1,43 +0,0 @@
-package flag
-
-import "testing"
-
-func TestEvaluate_GlobalEnabled(t *testing.T) {
-	f := Flag{Key: "k", Enabled: true}
-	if !evaluate(f, "irgendein-tenant") {
-		t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
-func TestEvaluate_TargetTenantStrategy(t *testing.T) {
-	f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
-	if !evaluate(f, "acme") {
-		t.Fatal("erwartet true fuer tenant in zielgruppe")
-	}
-	if evaluate(f, "globex") {
-		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
-	}
-}
-
-func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
-	full := Flag{Key: "k", RolloutPercentage: 100}
-	if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
-		t.Fatal("100% rollout sollte immer true liefern")
-	}
-
-	none := Flag{Key: "k", RolloutPercentage: 0}
-	if evaluate(none, "beliebiger-tenant") {
-		t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
-	}
-}
-
-func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
-	f := Flag{Key: "k", RolloutPercentage: 50}
-	first := evaluate(f, "stabiler-tenant")
-	for i := 0; i < 5; i++ {
-		if evaluate(f, "stabiler-tenant") != first {
-			t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
-		}
-	}
-}
@@ -1,87 +0,0 @@
-package flag
-
-import (
-	"context"
-	"log/slog"
-	"sync"
-	"time"
-)
-
-// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
-// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
-// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
-// muss (Akzeptanzkriterium 3).
-const DefaultCacheTTL = 5 * time.Second
-
-type cacheEntry struct {
-	flag      Flag
-	expiresAt time.Time
-}
-
-// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
-// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
-type Service struct {
-	store *Store
-	ttl   time.Duration
-
-	mu    sync.RWMutex
-	cache map[string]cacheEntry
-}
-
-func NewService(store *Store, ttl time.Duration) *Service {
-	if ttl <= 0 {
-		ttl = DefaultCacheTTL
-	}
-	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
-}
-
-// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
-// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
-// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
-// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
-// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
-func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
-	f, ok := s.resolve(ctx, key)
-	if !ok {
-		return false
-	}
-	return evaluate(f, tenantSlug)
-}
-
-func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
-	s.mu.RLock()
-	entry, exists := s.cache[key]
-	fresh := exists && time.Now().Before(entry.expiresAt)
-	s.mu.RUnlock()
-	if fresh {
-		return entry.flag, true
-	}
-
-	f, err := s.store.Get(ctx, key)
-	if err != nil {
-		if exists {
-			slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
-				"flag_key", key, "error", err)
-			return entry.flag, true
-		}
-		slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
-			"flag_key", key, "error", err)
-		return Flag{}, false
-	}
-
-	s.mu.Lock()
-	s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
-	s.mu.Unlock()
-	return f, true
-}
-
-// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
-// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
-// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
-// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
-// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
-func (s *Service) Invalidate(key string) {
-	s.mu.Lock()
-	delete(s.cache, key)
-	s.mu.Unlock()
-}
@@ -1,179 +0,0 @@
-package flag
-
-import (
-	"context"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupFlagStoreTest(t *testing.T) (*Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY,
-			enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0,
-			target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		)`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
-		pool.Close()
-	}
-	return NewStore(pool), cleanup
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
-// die erwartete Auswertung.
-func TestService_TargetTenantStrategy(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour)
-
-	if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
-		t.Fatal("erwartet true fuer tenant in zielgruppe")
-	}
-	if svc.IsEnabled(ctx, "globex", "test_target_flag") {
-		t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
-	}
-}
-
-// Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
-// dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
-func TestService_CacheInvalidationTiming(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	const ttl = 150 * time.Millisecond
-	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, ttl)
-
-	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-		t.Fatal("erwartet false vor der aenderung")
-	}
-
-	// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
-	// Store, ohne svc.Invalidate aufzurufen.
-	changedAt := time.Now()
-	if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-
-	// Sofort danach sollte der Cache noch den alten Stand liefern.
-	if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-		t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
-	}
-
-	deadline := changedAt.Add(ttl + 100*time.Millisecond)
-	for time.Now().Before(deadline) {
-		if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
-			elapsed := time.Since(changedAt)
-			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, ttl)
-			return
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
-}
-
-func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
-	_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
-
-	if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc.Invalidate("test_invalidate_flag")
-
-	if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
-		t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
-// dokumentiertem Fallback-Verhalten, nicht zum Absturz.
-func TestService_FallsBackOnStoreFailure(t *testing.T) {
-	store, cleanup := setupFlagStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
-		t.Fatalf("set: %v", err)
-	}
-	svc := NewService(store, time.Hour)
-
-	// Cache vorwaermen, waehrend die DB noch erreichbar ist.
-	if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
-		t.Fatal("erwartet true bei funktionierender db")
-	}
-
-	brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
-	if err != nil {
-		t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
-	}
-	brokenStore := NewStore(brokenPool)
-
-	svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
-	svcWithCache.mu.Lock()
-	svcWithCache.cache["test_fallback_flag"] = cacheEntry{
-		flag:      Flag{Key: "test_fallback_flag", Enabled: true},
-		expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
-	}
-	svcWithCache.mu.Unlock()
-
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
-			}
-		}()
-		if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
-			t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
-		}
-	}()
-
-	// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
-	// default false, kein absturz.
-	freshSvc := NewService(brokenStore, time.Hour)
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("IsEnabled hat gepanict: %v", r)
-			}
-		}()
-		if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
-			t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
-		}
-	}()
-}
@@ -1,106 +0,0 @@
-// Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
-// Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
-// Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
-// Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
-// — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
-// klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
-package license
-
-import (
-	"crypto/ed25519"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"time"
-)
-
-var (
-	ErrInvalidSignature = errors.New("license: signatur ungueltig")
-	ErrMalformedKey     = errors.New("license: lizenzschluessel hat ungueltiges format")
-)
-
-// Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
-// Modul-Liste, Laufzeit).
-type Payload struct {
-	TenantSlug string    `json:"tenant_slug"`
-	Plan       string    `json:"plan"`
-	Modules    []string  `json:"modules"`
-	IssuedAt   time.Time `json:"issued_at"`
-	ValidUntil time.Time `json:"valid_until"`
-}
-
-// Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
-// Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
-// laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
-// Schluessel braucht).
-type Issuer struct {
-	priv ed25519.PrivateKey
-}
-
-func NewIssuer(priv ed25519.PrivateKey) *Issuer {
-	return &Issuer{priv: priv}
-}
-
-// Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
-func (i *Issuer) Issue(payload Payload) (string, error) {
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("payload serialisieren: %w", err)
-	}
-	sig := ed25519.Sign(i.priv, raw)
-
-	return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
-}
-
-// Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
-// — das ist alles, was der laufende Core-Prozess kennen muss.
-type Validator struct {
-	pub ed25519.PublicKey
-}
-
-func NewValidator(pub ed25519.PublicKey) *Validator {
-	return &Validator{pub: pub}
-}
-
-// Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
-// bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
-// hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
-// waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
-// (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
-func (v *Validator) Parse(key string) (Payload, error) {
-	rawPart, sigPart, ok := splitOnce(key, '.')
-	if !ok {
-		return Payload{}, ErrMalformedKey
-	}
-
-	raw, err := base64.RawURLEncoding.DecodeString(rawPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-	sig, err := base64.RawURLEncoding.DecodeString(sigPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-
-	if !ed25519.Verify(v.pub, raw, sig) {
-		return Payload{}, ErrInvalidSignature
-	}
-
-	var p Payload
-	if err := json.Unmarshal(raw, &p); err != nil {
-		// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
-		// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
-		return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
-	}
-	return p, nil
-}
-
-func splitOnce(s string, sep byte) (before, after string, ok bool) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == sep {
-			return s[:i], s[i+1:], true
-		}
-	}
-	return "", "", false
-}
@@ -1,106 +0,0 @@
-package license
-
-import (
-	"crypto/ed25519"
-	"errors"
-	"testing"
-	"time"
-)
-
-func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
-	t.Helper()
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar erzeugen: %v", err)
-	}
-	return pub, priv
-}
-
-func TestIssueAndParse_RoundTrip(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	payload := Payload{
-		TenantSlug: "acme",
-		Plan:       "pro",
-		Modules:    []string{"dms", "mail"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
-	}
-
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	got, err := validator.Parse(key)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
-		t.Fatalf("payload nach parse unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
-func TestParse_RejectsTamperedKey(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Ein Zeichen im signierten Teil aendern.
-	tampered := []byte(key)
-	changed := false
-	for i, c := range tampered {
-		if c != '.' {
-			if c == 'A' {
-				tampered[i] = 'B'
-			} else {
-				tampered[i] = 'A'
-			}
-			changed = true
-			break
-		}
-	}
-	if !changed {
-		t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
-	}
-
-	if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsWrongKeyPair(t *testing.T) {
-	_, priv := testKeyPair(t)
-	otherPub, _ := testKeyPair(t)
-
-	issuer := NewIssuer(priv)
-	validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-	if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsMalformedKey(t *testing.T) {
-	pub, _ := testKeyPair(t)
-	validator := NewValidator(pub)
-
-	cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
-	for _, c := range cases {
-		if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
-			t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
-		}
-	}
-}
@@ -1,88 +0,0 @@
-package license
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	ErrNoLicense      = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
-	ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
-)
-
-// Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
-// (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
-// unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
-// erweitern).
-type Store struct {
-	pool      *pgxpool.Pool
-	validator *Validator
-}
-
-func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
-	return &Store{pool: pool, validator: validator}
-}
-
-// Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
-// und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
-// bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
-// gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
-// bewertet, nicht beim Einspielen.
-func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
-	payload, err := s.validator.Parse(licenseKey)
-	if err != nil {
-		return Payload{}, err
-	}
-
-	_, err = s.pool.Exec(ctx, `
-		INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
-		VALUES ($1, $2, $3, $4, $5, $6, now())
-		ON CONFLICT (tenant_id) DO UPDATE SET
-			plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
-	`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
-	if err != nil {
-		return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
-	}
-	return payload, nil
-}
-
-func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
-	var p Payload
-	row := s.pool.QueryRow(ctx, `
-		SELECT plan, modules, issued_at, valid_until
-		FROM tenant_licenses WHERE tenant_id = $1
-	`, tenantID)
-	if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Payload{}, ErrNoLicense
-		}
-		return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
-	}
-	return p, nil
-}
-
-// Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
-// (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
-func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
-	return s.get(ctx, tenantID)
-}
-
-// RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
-// abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
-// (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
-// Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
-func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
-	p, err := s.get(ctx, tenantID)
-	if err != nil {
-		return Payload{}, err
-	}
-	if time.Now().After(p.ValidUntil) {
-		return Payload{}, ErrLicenseExpired
-	}
-	return p, nil
-}
@@ -1,177 +0,0 @@
-package license
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS tenant_licenses (
-			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
-			plan TEXT NOT NULL,
-			modules TEXT[] NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL,
-			valid_until TIMESTAMPTZ NOT NULL,
-			raw_key TEXT NOT NULL,
-			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	var tenantID string
-	if err := pool.QueryRow(ctx, `
-		INSERT INTO tenants (slug, name, db_name, db_dsn)
-		VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
-		RETURNING id
-	`).Scan(&tenantID); err != nil {
-		t.Fatalf("test-tenant anlegen: %v", err)
-	}
-
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar: %v", err)
-	}
-	issuer := NewIssuer(priv)
-	store := NewStore(pool, NewValidator(pub))
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
-		pool.Close()
-	}
-	return store, issuer, tenantID, cleanup
-}
-
-// Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
-func TestStore_InstallAndStatus(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	payload := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "enterprise",
-		Modules:    []string{"dms", "mail", "archive"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
-	}
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install: %v", err)
-	}
-
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status: %v", err)
-	}
-	if status.Plan != "enterprise" || len(status.Modules) != 3 {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, otherPriv, _ := ed25519.GenerateKey(nil)
-	foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
-
-	key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
-// eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
-func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	expired := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "pro",
-		Modules:    []string{"dms"},
-		IssuedAt:   time.Now().Add(-48 * time.Hour),
-		ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
-	}
-	key, err := issuer.Issue(expired)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
-	// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
-	}
-
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
-			}
-		}()
-		if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
-			t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
-		}
-	}()
-
-	// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
-	}
-	if status.Plan != "pro" {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_RequireActive_NoLicense(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
-		t.Fatalf("erwartet ErrNoLicense, habe %v", err)
-	}
-}
@@ -1,99 +0,0 @@
-package moduleregistry
-
-import (
-	"context"
-	"crypto/rand"
-	"crypto/sha256"
-	"crypto/subtle"
-	"encoding/hex"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-)
-
-var (
-	ErrModuleNotRegistered = errors.New("moduleregistry: modul muss vor provisionierung registriert sein")
-	ErrInvalidCredential   = errors.New("moduleregistry: ungueltiges oder fehlendes service-credential")
-)
-
-// Provision stellt ein Service-Credential (Client-ID + Secret) fuer eine
-// Modul-Instanz aus (Akzeptanzkriterium 4). Das Secret wird NUR beim
-// Ausstellen im Klartext zurueckgegeben, gespeichert wird ausschliesslich
-// dessen SHA-256-Hash.
-func (r *Registry) Provision(ctx context.Context, moduleName string) (clientID, secret string, err error) {
-	if _, err := r.Get(ctx, moduleName); err != nil {
-		if errors.Is(err, ErrModuleNotFound) {
-			return "", "", ErrModuleNotRegistered
-		}
-		return "", "", err
-	}
-
-	clientID, err = randomToken(16)
-	if err != nil {
-		return "", "", fmt.Errorf("client-id erzeugen: %w", err)
-	}
-	secret, err = randomToken(32)
-	if err != nil {
-		return "", "", fmt.Errorf("secret erzeugen: %w", err)
-	}
-	hash := hashSecret(secret)
-
-	_, err = r.pool.Exec(ctx, `
-		INSERT INTO module_credentials (module_name, client_id, secret_hash, issued_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (module_name) DO UPDATE SET client_id = $2, secret_hash = $3, issued_at = now()
-	`, moduleName, clientID, hash)
-	if err != nil {
-		return "", "", fmt.Errorf("credential speichern: %w", err)
-	}
-	return clientID, secret, nil
-}
-
-// Authenticate prueft ein Service-Credential timing-safe (Referenzmuster
-// siehe AUD-02) — Aufrufe ohne gueltiges Credential werden abgelehnt
-// (Akzeptanzkriterium 4 / Pruefung 4).
-func (r *Registry) Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error) {
-	if clientID == "" || secret == "" {
-		return "", false, nil
-	}
-
-	var storedHash []byte
-	err = r.pool.QueryRow(ctx, `
-		SELECT module_name, secret_hash FROM module_credentials WHERE client_id = $1
-	`, clientID).Scan(&moduleName, &storedHash)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", false, nil
-		}
-		return "", false, fmt.Errorf("credential lesen: %w", err)
-	}
-
-	if !timingSafeEqual(hashSecret(secret), storedHash) {
-		return "", false, nil
-	}
-	return moduleName, true, nil
-}
-
-func randomToken(n int) (string, error) {
-	buf := make([]byte, n)
-	if _, err := rand.Read(buf); err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(buf), nil
-}
-
-func hashSecret(secret string) []byte {
-	sum := sha256.Sum256([]byte(secret))
-	return sum[:]
-}
-
-// timingSafeEqual folgt derselben Referenzimplementierung wie AUD-02
-// (subtle.ConstantTimeCompare) — projektweite Konvention fuer jeden
-// sicherheitsrelevanten Vergleich.
-func timingSafeEqual(a, b []byte) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	return subtle.ConstantTimeCompare(a, b) == 1
-}
@@ -1,46 +0,0 @@
-package moduleregistry
-
-import "net/http"
-
-// RequireActiveModule weist Anfragen an ein nicht aktiviertes Modul ZENTRAL
-// ab, bevor der eigentliche Modul-Handler erreicht wird (Akzeptanzkriterium 2 /
-// Pruefung 1) — Casbin-Prinzip: Durchsetzung als Middleware statt verstreuter
-// Pruefungen in jedem Handler. tenantSlug/moduleName werden hier ueber
-// Query-Parameter gelesen (echte Extraktion aus JWT/Tenant-Kontext ist
-// API-05/TEN-06, nicht Teil dieser Kachel).
-func (r *Registry) RequireActiveModule(moduleName string, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		tenantSlug := req.URL.Query().Get("tenant")
-		active, err := r.IsActive(req.Context(), tenantSlug, moduleName)
-		if err != nil {
-			http.Error(w, "aktivierungspruefung fehlgeschlagen", http.StatusInternalServerError)
-			return
-		}
-		if !active {
-			http.Error(w, "modul nicht aktiviert", http.StatusForbidden)
-			return
-		}
-		next(w, req)
-	}
-}
-
-// RequireServiceCredential authentifiziert eine Modul-Instanz ueber ihr
-// Service-Credential (X-Client-Id/X-Client-Secret-Header) BEVOR der
-// eigentliche Handler erreicht wird (Akzeptanzkriterium 4 / Pruefung 4).
-func (r *Registry) RequireServiceCredential(next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		clientID := req.Header.Get("X-Client-Id")
-		secret := req.Header.Get("X-Client-Secret")
-
-		_, ok, err := r.Authenticate(req.Context(), clientID, secret)
-		if err != nil {
-			http.Error(w, "authentifizierung fehlgeschlagen", http.StatusInternalServerError)
-			return
-		}
-		if !ok {
-			http.Error(w, ErrInvalidCredential.Error(), http.StatusUnauthorized)
-			return
-		}
-		next(w, req)
-	}
-}
@@ -1,120 +0,0 @@
-// Package moduleregistry implementiert Core API-02: die Registry, in der
-// sich Fachmodule (DMS, Mail, weitere) mit Metadaten eintragen, gekoppelt an
-// die Aktivierungspruefung aus LIC-02 (Feature-Flags). Zusaetzlich
-// authentifiziert die Registry Modul-Instanzen selbst ueber ein bei
-// Provisionierung ausgestelltes Service-Credential.
-package moduleregistry
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-)
-
-var (
-	ErrMissingName    = errors.New("moduleregistry: name darf nicht leer sein")
-	ErrMissingVersion = errors.New("moduleregistry: version darf nicht leer sein")
-	ErrModuleNotFound = errors.New("moduleregistry: modul nicht registriert")
-)
-
-type Module struct {
-	Name          string
-	Version       string
-	RequiredFlags []string
-}
-
-type Registry struct {
-	pool  *pgxpool.Pool
-	flags *flag.Service
-}
-
-func NewRegistry(pool *pgxpool.Pool, flags *flag.Service) *Registry {
-	return &Registry{pool: pool, flags: flags}
-}
-
-// Register traegt ein Modul mit Name, Version und benoetigten Feature-Flags
-// ein (Akzeptanzkriterium 1). Fehlende Pflichtangaben werden abgewiesen
-// (Akzeptanzkriterium 1 / Pruefung 2). Erneutes Register desselben Namens
-// aktualisiert Version/Flags (Redeploy-Fall).
-func (r *Registry) Register(ctx context.Context, name, version string, requiredFlags []string) (Module, error) {
-	if name == "" {
-		return Module{}, ErrMissingName
-	}
-	if version == "" {
-		return Module{}, ErrMissingVersion
-	}
-	if requiredFlags == nil {
-		requiredFlags = []string{}
-	}
-
-	_, err := r.pool.Exec(ctx, `
-		INSERT INTO modules (name, version, required_flags, registered_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (name) DO UPDATE SET version = $2, required_flags = $3, registered_at = now()
-	`, name, version, requiredFlags)
-	if err != nil {
-		return Module{}, fmt.Errorf("modul registrieren: %w", err)
-	}
-	return Module{Name: name, Version: version, RequiredFlags: requiredFlags}, nil
-}
-
-func (r *Registry) Get(ctx context.Context, name string) (Module, error) {
-	var m Module
-	m.Name = name
-	err := r.pool.QueryRow(ctx, `
-		SELECT version, required_flags FROM modules WHERE name = $1
-	`, name).Scan(&m.Version, &m.RequiredFlags)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Module{}, ErrModuleNotFound
-		}
-		return Module{}, fmt.Errorf("modul lesen: %w", err)
-	}
-	return m, nil
-}
-
-// List liefert alle registrierten Module (Akzeptanzkriterium 3: ueber API
-// abfragbar, z.B. fuer Statusseite/Lizenzoberflaeche).
-func (r *Registry) List(ctx context.Context) ([]Module, error) {
-	rows, err := r.pool.Query(ctx, `SELECT name, version, required_flags FROM modules ORDER BY name`)
-	if err != nil {
-		return nil, fmt.Errorf("module auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Module
-	for rows.Next() {
-		var m Module
-		if err := rows.Scan(&m.Name, &m.Version, &m.RequiredFlags); err != nil {
-			return nil, fmt.Errorf("modul lesen: %w", err)
-		}
-		out = append(out, m)
-	}
-	return out, rows.Err()
-}
-
-// IsActive prueft, ob ein registriertes Modul fuer einen Tenant aktiviert
-// ist: registriert UND alle benoetigten Feature-Flags sind fuer diesen
-// Tenant aktiv (Akzeptanzkriterium 2). Ein nicht registriertes Modul gilt
-// immer als nicht aktiv.
-func (r *Registry) IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error) {
-	m, err := r.Get(ctx, moduleName)
-	if err != nil {
-		if errors.Is(err, ErrModuleNotFound) {
-			return false, nil
-		}
-		return false, err
-	}
-
-	for _, flagKey := range m.RequiredFlags {
-		if !r.flags.IsEnabled(ctx, tenantSlug, flagKey) {
-			return false, nil
-		}
-	}
-	return true, nil
-}
@@ -1,304 +0,0 @@
-package moduleregistry
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-)
-
-func setupTest(t *testing.T) (*Registry, *flag.Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS modules (
-			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
-			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS module_credentials (
-			module_name TEXT PRIMARY KEY REFERENCES modules(name),
-			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	flagStore := flag.NewStore(pool)
-	// Kurze TTL, damit Tests, die den Flag-Store direkt aendern (an
-	// Registry.IsActive vorbei), den neuen Stand ohne manuelles Invalidate
-	// zuverlaessig sehen.
-	flagService := flag.NewService(flagStore, 10*time.Millisecond)
-	registry := NewRegistry(pool, flagService)
-
-	cleanup := func() { pool.Close() }
-	return registry, flagStore, cleanup
-}
-
-func uniqueModuleName(t *testing.T) string {
-	return fmt.Sprintf("dms_%d", time.Now().UnixNano())
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: fehlende Pflichtangaben abgewiesen.
-func TestRegister_RejectsMissingFields(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := registry.Register(ctx, "", "1.0", nil); !errors.Is(err, ErrMissingName) {
-		t.Fatalf("erwartet ErrMissingName, habe %v", err)
-	}
-	if _, err := registry.Register(ctx, "dms", "", nil); !errors.Is(err, ErrMissingVersion) {
-		t.Fatalf("erwartet ErrMissingVersion, habe %v", err)
-	}
-}
-
-func TestRegister_AndGet(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	m, err := registry.Register(ctx, name, "1.2.0", []string{"dms_enabled"})
-	if err != nil {
-		t.Fatalf("register: %v", err)
-	}
-	if m.Version != "1.2.0" || len(m.RequiredFlags) != 1 {
-		t.Fatalf("unerwartet: %+v", m)
-	}
-
-	got, err := registry.Get(ctx, name)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Version != "1.2.0" {
-		t.Fatalf("get version = %q", got.Version)
-	}
-}
-
-// Akzeptanzkriterium 2 + 3 + Pruefung 3: konsistente Daten nach
-// Aktivierung/Deaktivierung eines Moduls.
-func TestIsActive_ReflectsFlagStateConsistently(t *testing.T) {
-	registry, flagStore, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-	flagKey := name + "_enabled"
-
-	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	active, err := registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (vor flag): %v", err)
-	}
-	if active {
-		t.Fatal("erwartet nicht aktiv, solange flag nicht gesetzt ist")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond) // TTL abwarten
-
-	active, err = registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (nach flag an): %v", err)
-	}
-	if !active {
-		t.Fatal("erwartet aktiv, nachdem flag aktiviert wurde")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: false}); err != nil {
-		t.Fatalf("flag zuruecksetzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond) // TTL abwarten
-	active, err = registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (nach flag aus): %v", err)
-	}
-	if active {
-		t.Fatal("erwartet wieder nicht aktiv, nachdem flag deaktiviert wurde")
-	}
-}
-
-func TestIsActive_UnregisteredModuleIsNeverActive(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	active, err := registry.IsActive(ctx, "acme", "nie-registriert")
-	if err != nil {
-		t.Fatalf("is active: %v", err)
-	}
-	if active {
-		t.Fatal("unregistriertes modul darf nie aktiv sein")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Anfrage an deaktiviertes Modul wird
-// zentral abgewiesen, BEVOR die Modul-Logik erreicht wird.
-func TestRequireActiveModule_BlocksBeforeHandler(t *testing.T) {
-	registry, flagStore, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-	flagKey := name + "_enabled"
-
-	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	handlerReached := false
-	handler := registry.RequireActiveModule(name, func(w http.ResponseWriter, r *http.Request) {
-		handlerReached = true
-		w.WriteHeader(http.StatusOK)
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
-	rec := httptest.NewRecorder()
-	handler(rec, req)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("status = %d, want 403", rec.Code)
-	}
-	if handlerReached {
-		t.Fatal("handler haette bei deaktiviertem modul NICHT erreicht werden duerfen")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	req2 := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
-	rec2 := httptest.NewRecorder()
-	handler(rec2, req2)
-	if rec2.Code != http.StatusOK {
-		t.Fatalf("status nach aktivierung = %d, want 200", rec2.Code)
-	}
-	if !handlerReached {
-		t.Fatal("handler haette bei aktiviertem modul erreicht werden muessen")
-	}
-}
-
-// Akzeptanzkriterium 4 + Pruefung 4: gueltiges/ungueltiges Service-Credential.
-func TestProvisionAndAuthenticate(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	clientID, secret, err := registry.Provision(ctx, name)
-	if err != nil {
-		t.Fatalf("provision: %v", err)
-	}
-	if clientID == "" || secret == "" {
-		t.Fatal("erwartet nicht-leere client-id/secret")
-	}
-
-	moduleName, ok, err := registry.Authenticate(ctx, clientID, secret)
-	if err != nil {
-		t.Fatalf("authenticate (korrekt): %v", err)
-	}
-	if !ok || moduleName != name {
-		t.Fatalf("erwartet erfolgreiche authentifizierung fuer %q, habe ok=%v moduleName=%q", name, ok, moduleName)
-	}
-
-	_, ok, err = registry.Authenticate(ctx, clientID, "falsches-secret")
-	if err != nil {
-		t.Fatalf("authenticate (falsch): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet fehlschlag bei falschem secret")
-	}
-
-	_, ok, err = registry.Authenticate(ctx, "unbekannte-client-id", secret)
-	if err != nil {
-		t.Fatalf("authenticate (unbekannt): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet fehlschlag bei unbekannter client-id")
-	}
-}
-
-func TestProvision_RequiresRegisteredModule(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, _, err := registry.Provision(ctx, "nie-registriert"); !errors.Is(err, ErrModuleNotRegistered) {
-		t.Fatalf("erwartet ErrModuleNotRegistered, habe %v", err)
-	}
-}
-
-func TestRequireServiceCredential_RejectsInvalidAcceptsValid(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-	clientID, secret, err := registry.Provision(ctx, name)
-	if err != nil {
-		t.Fatalf("provision: %v", err)
-	}
-
-	handler := registry.RequireServiceCredential(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	})
-
-	// Fehlendes Credential.
-	req := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	rec := httptest.NewRecorder()
-	handler(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("ohne credential: status = %d, want 401", rec.Code)
-	}
-
-	// Falsches Secret.
-	req2 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	req2.Header.Set("X-Client-Id", clientID)
-	req2.Header.Set("X-Client-Secret", "falsch")
-	rec2 := httptest.NewRecorder()
-	handler(rec2, req2)
-	if rec2.Code != http.StatusUnauthorized {
-		t.Fatalf("falsches secret: status = %d, want 401", rec2.Code)
-	}
-
-	// Gueltiges Credential.
-	req3 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	req3.Header.Set("X-Client-Id", clientID)
-	req3.Header.Set("X-Client-Secret", secret)
-	rec3 := httptest.NewRecorder()
-	handler(rec3, req3)
-	if rec3.Code != http.StatusOK {
-		t.Fatalf("gueltiges credential: status = %d, want 200", rec3.Code)
-	}
-}
@@ -1,97 +0,0 @@
-package moduletrust
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-)
-
-// StaleCache ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
-// (Akzeptanzkriterium 2): TTL-basiert, mit explizitem, benanntem Verhalten
-// bei abgelaufenem Cache waehrend Core nicht erreichbar ist.
-//
-//   - Get: FAIL-OPEN fuer Lesevorgaenge. Schlaegt der Refresh fehl, aber es
-//     gibt bereits einen (wenn auch abgelaufenen) Stand, wird dieser mit
-//     stale=true zurueckgegeben — Begruendung: ein bereits authentifiziertes
-//     Modul soll mit dem letztbekannten Stand weiterarbeiten koennen statt
-//     hart zu blockieren (siehe "Bekannte Fehler vermeiden" im Ticket).
-//     Existiert noch nie ein Stand, gibt es keinen sinnvollen Fallback —
-//     dann liefert auch Get einen Fehler.
-//   - RequireFresh: FAIL-CLOSED fuer sicherheitskritische Aktionen (z.B.
-//     ein komplett NEUER Login). Nutzt NIEMALS einen zwischengespeicherten
-//     Stand, ruft immer frisch ab — Begruendung: eine neue Vertrauens-
-//     entscheidung darf nicht auf veralteten Daten beruhen, auch wenn das
-//     bedeutet, dass die Aktion bei Core-Ausfall sichtbar fehlschlaegt statt
-//     unsicher "irgendwie" durchgelassen zu werden.
-//
-// LIC-02 (internal/flag.Service) implementiert bereits denselben Kontrakt
-// fuer Feature-Flags — StaleCache verallgemeinert dasselbe Muster fuer
-// JWT-Signaturschluessel, damit beide Faelle derselben dokumentierten
-// Policy folgen.
-type StaleCache[T any] struct {
-	mu        sync.RWMutex
-	value     T
-	hasValue  bool
-	fetchedAt time.Time
-	ttl       time.Duration
-	fetch     func(ctx context.Context) (T, error)
-}
-
-func NewStaleCache[T any](ttl time.Duration, fetch func(ctx context.Context) (T, error)) *StaleCache[T] {
-	return &StaleCache[T]{ttl: ttl, fetch: fetch}
-}
-
-// Get liefert den Cache-Wert. FAIL-OPEN: bei Refresh-Fehler wird ein
-// vorhandener, ggf. abgelaufener Stand zurueckgegeben (stale=true).
-func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error) {
-	c.mu.RLock()
-	fresh := c.hasValue && time.Since(c.fetchedAt) < c.ttl
-	if fresh {
-		v := c.value
-		c.mu.RUnlock()
-		return v, false, nil
-	}
-	c.mu.RUnlock()
-
-	newVal, fetchErr := c.fetch(ctx)
-	if fetchErr == nil {
-		c.mu.Lock()
-		c.value, c.hasValue, c.fetchedAt = newVal, true, time.Now()
-		c.mu.Unlock()
-		return newVal, false, nil
-	}
-
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	if c.hasValue {
-		return c.value, true, nil
-	}
-	var zero T
-	return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
-}
-
-// Invalidate erzwingt beim naechsten Get-Aufruf einen sofortigen Refresh
-// statt auf den TTL-Ablauf zu warten (API-06, Akzeptanzkriterium 1: ein
-// Health-Check-getriggerter Wiederanlauf soll den Cache SOFORT aktualisieren,
-// nicht die reguläre TTL abwarten) — rein additiv, aendert nichts an
-// Get/RequireFresh (dasselbe Muster wie internal/flag.Service.Invalidate).
-func (c *StaleCache[T]) Invalidate() {
-	c.mu.Lock()
-	c.hasValue = false
-	c.mu.Unlock()
-}
-
-// RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
-// Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
-func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
-	v, err := c.fetch(ctx)
-	if err != nil {
-		var zero T
-		return zero, fmt.Errorf("core nicht erreichbar, sicherheitskritische aktion abgelehnt: %w", err)
-	}
-	c.mu.Lock()
-	c.value, c.hasValue, c.fetchedAt = v, true, time.Now()
-	c.mu.Unlock()
-	return v, nil
-}
@@ -1,79 +0,0 @@
-package moduletrust
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-type Claims struct {
-	Subject    string `json:"sub"`
-	TenantSlug string `json:"tenant"`
-	jwt.RegisteredClaims
-}
-
-// Issue signiert ein Token mit dem aktuellen Signierschluessel und traegt
-// dessen KID im JWT-Header ein — der Verifier auf Modulseite waehlt darueber
-// den passenden oeffentlichen Schluessel aus PublicKeySet() aus.
-func (m *KeyManager) Issue(subject, tenantSlug string, ttl time.Duration) (string, error) {
-	key, err := m.SigningKey()
-	if err != nil {
-		return "", err
-	}
-
-	now := time.Now()
-	claims := Claims{
-		Subject:    subject,
-		TenantSlug: tenantSlug,
-		RegisteredClaims: jwt.RegisteredClaims{
-			IssuedAt:  jwt.NewNumericDate(now),
-			ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
-		},
-	}
-	token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
-	token.Header["kid"] = key.KID
-	return token.SignedString(key.Private)
-}
-
-type jwksResponse struct {
-	Keys []jwksKey `json:"keys"`
-}
-
-type jwksKey struct {
-	Kid       string `json:"kid"`
-	PublicKey string `json:"public_key"` // base64 (raw Ed25519, 32 Byte)
-}
-
-// ServeJWKS liefert alle bekannten oeffentlichen Schluessel als JSON —
-// Module fragen dies periodisch ab (nicht pro Request), siehe Verifier.
-func (m *KeyManager) ServeJWKS(w http.ResponseWriter, r *http.Request) {
-	set := m.PublicKeySet()
-	resp := jwksResponse{Keys: make([]jwksKey, 0, len(set))}
-	for kid, pub := range set {
-		resp.Keys = append(resp.Keys, jwksKey{Kid: kid, PublicKey: base64.StdEncoding.EncodeToString(pub)})
-	}
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(resp)
-}
-
-// ParseJWKS dekodiert die JSON-Antwort von ServeJWKS zurueck in kid->PublicKey
-// — Hilfsfunktion fuer Module, die JWKS per HTTP abrufen.
-func ParseJWKS(data []byte) (map[string][]byte, error) {
-	var resp jwksResponse
-	if err := json.Unmarshal(data, &resp); err != nil {
-		return nil, fmt.Errorf("jwks parsen: %w", err)
-	}
-	out := make(map[string][]byte, len(resp.Keys))
-	for _, k := range resp.Keys {
-		raw, err := base64.StdEncoding.DecodeString(k.PublicKey)
-		if err != nil {
-			return nil, fmt.Errorf("oeffentlichen schluessel %q dekodieren: %w", k.Kid, err)
-		}
-		out[k.Kid] = raw
-	}
-	return out, nil
-}
@@ -1,83 +0,0 @@
-// Package moduletrust implementiert Core API-05: asymmetrische JWT-Signatur
-// mit Schluesselverteilung (JWKS), damit DMS/Mail/Archive/Workflow JWTs
-// LOKAL verifizieren koennen, ohne pro Aufruf einen synchronen Request an
-// Core zu stellen — Core darf Fundament sein, ohne zum Flaschenhals zu
-// werden (siehe Entscheidungsverlauf "Vertrauensstellung Core<->Module" in
-// nexarch-state.json). IAM-02s HS256-Session-Cookie (Browser-Login) bleibt
-// unangetastet — dies ist ein zusaetzlicher, getrennter Vertrauensmechanismus
-// fuer Modul-zu-Modul/Modul-zu-Core-Aufrufe.
-package moduletrust
-
-import (
-	"crypto/ed25519"
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"sync"
-)
-
-type KeyPair struct {
-	KID     string
-	Private ed25519.PrivateKey
-	Public  ed25519.PublicKey
-}
-
-// KeyManager haelt ALLE noch gueltigen Schluesselpaare — nicht nur das
-// aktuell signierende. Rotate erzeugt ein neues Paar und behaelt die alten
-// fuer die Verifikation bereits ausgestellter Tokens (Akzeptanzkriterium 3:
-// Rotation ohne Ausfallzeit fuer andere Module).
-type KeyManager struct {
-	mu   sync.RWMutex
-	keys []KeyPair // aeltestes zuerst, neuestes zuletzt
-}
-
-func NewKeyManager() (*KeyManager, error) {
-	m := &KeyManager{}
-	if _, err := m.Rotate(); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Rotate erzeugt ein neues Ed25519-Schluesselpaar mit eigener KID und macht
-// es zum aktuellen Signierschluessel. Aeltere Schluessel bleiben in
-// PublicKeySet() erhalten, damit bereits ausgestellte Tokens weiterhin
-// verifizierbar sind.
-func (m *KeyManager) Rotate() (KeyPair, error) {
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		return KeyPair{}, fmt.Errorf("schluesselpaar erzeugen: %w", err)
-	}
-	kidBytes := make([]byte, 8)
-	if _, err := rand.Read(kidBytes); err != nil {
-		return KeyPair{}, fmt.Errorf("kid erzeugen: %w", err)
-	}
-	kp := KeyPair{KID: hex.EncodeToString(kidBytes), Private: priv, Public: pub}
-
-	m.mu.Lock()
-	m.keys = append(m.keys, kp)
-	m.mu.Unlock()
-	return kp, nil
-}
-
-// SigningKey liefert den aktuellen (neuesten) Schluessel zum Signieren neuer Tokens.
-func (m *KeyManager) SigningKey() (KeyPair, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if len(m.keys) == 0 {
-		return KeyPair{}, fmt.Errorf("moduletrust: kein schluessel vorhanden")
-	}
-	return m.keys[len(m.keys)-1], nil
-}
-
-// PublicKeySet liefert ALLE bekannten oeffentlichen Schluessel (kid ->
-// public key) — die Grundlage fuer den JWKS-Endpunkt.
-func (m *KeyManager) PublicKeySet() map[string]ed25519.PublicKey {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	out := make(map[string]ed25519.PublicKey, len(m.keys))
-	for _, k := range m.keys {
-		out[k.KID] = k.Public
-	}
-	return out
-}
@@ -1,214 +0,0 @@
-package moduletrust
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"net/http"
-	"sync"
-	"testing"
-	"time"
-)
-
-func TestIssueAndVerify_RoundTrip(t *testing.T) {
-	km, err := NewKeyManager()
-	if err != nil {
-		t.Fatalf("new key manager: %v", err)
-	}
-	token, err := km.Issue("user-1", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		return km.PublicKeySet(), nil
-	})
-	claims, err := v.Verify(context.Background(), token)
-	if err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-	if claims.Subject != "user-1" || claims.TenantSlug != "acme" {
-		t.Fatalf("claims unerwartet: %+v", claims)
-	}
-}
-
-// Akzeptanzkriterium 1: Verifikation lokal, kein Request pro Aufruf.
-func TestVerify_DoesNotFetchPerCall(t *testing.T) {
-	km, err := NewKeyManager()
-	if err != nil {
-		t.Fatalf("new key manager: %v", err)
-	}
-	token, err := km.Issue("user-1", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	var mu sync.Mutex
-	fetchCalls := 0
-	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		mu.Lock()
-		fetchCalls++
-		mu.Unlock()
-		return km.PublicKeySet(), nil
-	})
-
-	for i := 0; i < 10; i++ {
-		if _, err := v.Verify(context.Background(), token); err != nil {
-			t.Fatalf("verify %d: %v", i, err)
-		}
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if fetchCalls != 1 {
-		t.Fatalf("erwartet genau 1 fetch fuer 10 Verify-Aufrufe innerhalb der TTL, habe %d", fetchCalls)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Core simuliert nicht erreichbar,
-// bereits authentifizierte Nutzer bleiben funktionsfaehig (Fail-Open mit
-// letztbekanntem Schluesselstand).
-func TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist(t *testing.T) {
-	km, err := NewKeyManager()
-	if err != nil {
-		t.Fatalf("new key manager: %v", err)
-	}
-	token, err := km.Issue("user-1", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	coreDown := false
-	v := NewVerifier(30*time.Millisecond, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		if coreDown {
-			return nil, errors.New("core nicht erreichbar (simuliert)")
-		}
-		return km.PublicKeySet(), nil
-	})
-
-	// Cache vorwaermen, waehrend Core noch erreichbar ist.
-	if _, err := v.Verify(context.Background(), token); err != nil {
-		t.Fatalf("verify (warm): %v", err)
-	}
-
-	// "Core abschalten" und TTL ablaufen lassen.
-	coreDown = true
-	time.Sleep(50 * time.Millisecond)
-
-	if _, err := v.Verify(context.Background(), token); err != nil {
-		t.Fatalf("verify sollte trotz core-ausfall mit letztbekanntem stand funktionieren: %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: neue sicherheitskritische Aktionen
-// (z.B. neuer Login) schlagen bei Core-Ausfall klar fehl statt unsicher
-// durchgelassen zu werden — auch wenn ein (aelterer) Cache-Stand existiert.
-func TestRequireFreshKeys_FailsClosedWhenCoreUnreachable(t *testing.T) {
-	km, err := NewKeyManager()
-	if err != nil {
-		t.Fatalf("new key manager: %v", err)
-	}
-
-	coreDown := false
-	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		if coreDown {
-			return nil, errors.New("core nicht erreichbar (simuliert)")
-		}
-		return km.PublicKeySet(), nil
-	})
-
-	// Cache vorwaermen (existiert jetzt ein "veralteter" gueltiger Stand).
-	if _, _, err := v.cache.Get(context.Background()); err != nil {
-		t.Fatalf("warm cache: %v", err)
-	}
-
-	coreDown = true
-	if err := v.RequireFreshKeys(context.Background()); err == nil {
-		t.Fatal("erwartet fehler (fail-closed) bei core-ausfall, habe nil")
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Schluesselrotation ohne Ausfallzeit —
-// ein bereits ausgestelltes Token bleibt nach Rotation weiterhin
-// verifizierbar, ein zweites (simuliertes) Modul bekommt beide Schluessel.
-func TestRotate_NoDowntimeForAlreadyIssuedTokens(t *testing.T) {
-	km, err := NewKeyManager()
-	if err != nil {
-		t.Fatalf("new key manager: %v", err)
-	}
-
-	oldToken, err := km.Issue("user-1", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue (alt): %v", err)
-	}
-
-	if _, err := km.Rotate(); err != nil {
-		t.Fatalf("rotate: %v", err)
-	}
-
-	newToken, err := km.Issue("user-2", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue (neu): %v", err)
-	}
-
-	// Simuliertes zweites Modul: fragt den vollstaendigen Schluesselsatz ab.
-	moduleB := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		return km.PublicKeySet(), nil
-	})
-
-	if _, err := moduleB.Verify(context.Background(), oldToken); err != nil {
-		t.Fatalf("altes token sollte nach rotation weiterhin gueltig sein: %v", err)
-	}
-	if _, err := moduleB.Verify(context.Background(), newToken); err != nil {
-		t.Fatalf("neues token sollte gueltig sein: %v", err)
-	}
-}
-
-func TestVerify_RejectsUnknownKid(t *testing.T) {
-	km1, _ := NewKeyManager()
-	km2, _ := NewKeyManager() // komplett anderer, unbekannter schluessel
-
-	token, err := km1.Issue("user-1", "acme", time.Hour)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		return km2.PublicKeySet(), nil // kennt km1s schluessel nicht
-	})
-	if _, err := v.Verify(context.Background(), token); !errors.Is(err, ErrInvalidToken) {
-		t.Fatalf("erwartet ErrInvalidToken, habe %v", err)
-	}
-}
-
-func TestJWKSRoundTrip(t *testing.T) {
-	km, _ := NewKeyManager()
-	km.Rotate()
-
-	var buf []byte
-	rec := &captureWriter{}
-	km.ServeJWKS(rec, nil)
-	buf = rec.body
-
-	parsed, err := ParseJWKS(buf)
-	if err != nil {
-		t.Fatalf("parse jwks: %v", err)
-	}
-	if len(parsed) != len(km.PublicKeySet()) {
-		t.Fatalf("erwartet %d schluessel, habe %d", len(km.PublicKeySet()), len(parsed))
-	}
-}
-
-type captureWriter struct {
-	body   []byte
-	header http.Header
-}
-
-func (w *captureWriter) Header() http.Header {
-	if w.header == nil {
-		w.header = http.Header{}
-	}
-	return w.header
-}
-func (w *captureWriter) Write(p []byte) (int, error) { w.body = append(w.body, p...); return len(p), nil }
-func (w *captureWriter) WriteHeader(statusCode int)  {}
@@ -1,67 +0,0 @@
-package moduletrust
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"time"
-
-	"github.com/golang-jwt/jwt/v5"
-)
-
-var ErrInvalidToken = errors.New("moduletrust: ungueltiges token")
-
-// KeyFetchFunc holt den aktuellen Schluesselsatz von Core (z.B. per HTTP-GET
-// auf ServeJWKS + ParseJWKS). Wird vom Verifier nur bei abgelaufener TTL
-// aufgerufen — NICHT bei jeder Verify()-Anfrage (Akzeptanzkriterium 1).
-type KeyFetchFunc func(ctx context.Context) (map[string]ed25519.PublicKey, error)
-
-// Verifier ist die Modulseite von API-05: verifiziert JWTs LOKAL gegen einen
-// per StaleCache zwischengespeicherten Schluesselsatz, ohne pro Aufruf einen
-// synchronen Request an Core zu stellen.
-type Verifier struct {
-	cache *StaleCache[map[string]ed25519.PublicKey]
-}
-
-func NewVerifier(ttl time.Duration, fetch KeyFetchFunc) *Verifier {
-	return &Verifier{cache: NewStaleCache(ttl, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
-		return fetch(ctx)
-	})}
-}
-
-// Verify prueft die Signatur LOKAL gegen den (ggf. abgelaufenen, aber
-// vorhandenen) Schluesselsatz — FAIL-OPEN fuer bereits ausgestellte Tokens
-// (Akzeptanzkriterium 2): ist Core nicht erreichbar, aber ein alter
-// Schluesselsatz bekannt, wird damit weiter verifiziert.
-func (v *Verifier) Verify(ctx context.Context, tokenString string) (*Claims, error) {
-	keys, _, err := v.cache.Get(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	claims := &Claims{}
-	token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
-		if _, ok := t.Method.(*jwt.SigningMethodEd25519); !ok {
-			return nil, ErrInvalidToken
-		}
-		kid, _ := t.Header["kid"].(string)
-		pub, ok := keys[kid]
-		if !ok {
-			return nil, ErrInvalidToken
-		}
-		return pub, nil
-	})
-	if err != nil || !token.Valid {
-		return nil, ErrInvalidToken
-	}
-	return claims, nil
-}
-
-// RequireFreshKeys ruft IMMER frisch von Core ab (FAIL-CLOSED) — fuer
-// sicherheitskritische Aktionen wie einen komplett neuen Login
-// (Akzeptanzkriterium 2): schlaegt klar fehl, wenn Core nicht erreichbar
-// ist, statt auf einem veralteten Schluesselsatz zu vertrauen.
-func (v *Verifier) RequireFreshKeys(ctx context.Context) error {
-	_, err := v.cache.RequireFresh(ctx)
-	return err
-}
@@ -1,155 +0,0 @@
-// Package resync implementiert Core API-06: Wiederanlauf & Nachsynchro-
-// nisierung nach einem Core-Ausfall.
-//
-//   - Ein Modul puffert Audit-Events und Nutzungszaehler-Deltas LOKAL in
-//     Postgres (NICHT im Speicher — siehe "Bekannte Fehler vermeiden" im
-//     Ticket: ein erneuter Ausfall waehrend der Nachlieferung darf keine
-//     Daten verlieren, eine In-Memory-Queue wuerde das riskieren).
-//   - Ein Health-Check-getriggerter Worker erkennt die Core-Wiedererreich-
-//     barkeit SOFORT (nicht erst nach TTL-Ablauf, siehe StaleCache.Invalidate)
-//     und liefert die gepufferten Daten in ORIGINALER Reihenfolge, authenti-
-//     fiziert ueber das Service-Credential aus API-02
-//     (internal/moduleregistry.Registry.Authenticate).
-//
-// Dieses Paket dupliziert weder internal/audit (AUD-01) noch internal/usage
-// (LIC-03) — es liefert nur den Puffer- und Nachlieferungs-Mechanismus
-// DAVOR bzw. DANACH.
-package resync
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// BufferedAuditEvent ist ein lokal gepuffertes Audit-Ereignis. Seq
-// garantiert die Wiederherstellung der urspruenglichen Reihenfolge
-// (Akzeptanzkriterium 2) unabhaengig von eventuellen Uhrzeit-Ungenauigkeiten.
-type BufferedAuditEvent struct {
-	ID         int64
-	Seq        int64
-	TenantSlug string
-	Actor      string
-	Action     string
-	Target     string
-	Metadata   map[string]any
-	CreatedAt  time.Time
-}
-
-// BufferedUsageDelta ist ein lokal gepuffertes Nutzungszaehler-Inkrement.
-type BufferedUsageDelta struct {
-	ID         int64
-	Seq        int64
-	TenantSlug string
-	Metric     string
-	Delta      int64
-	CreatedAt  time.Time
-}
-
-// Buffer ist die lokale, persistente Pufferqueue eines Moduls.
-type Buffer struct {
-	pool *pgxpool.Pool
-}
-
-func NewBuffer(pool *pgxpool.Pool) *Buffer {
-	return &Buffer{pool: pool}
-}
-
-// EnqueueAuditEvent puffert EIN Audit-Ereignis lokal — wird von einem
-// Fachmodul aufgerufen, wenn Core gerade nicht erreichbar ist (die
-// Erkennung "Core erreichbar oder nicht" ist NICHT Teil dieses Aufrufs,
-// siehe Worker).
-func (b *Buffer) EnqueueAuditEvent(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any) error {
-	if metadata == nil {
-		metadata = map[string]any{}
-	}
-	metadataJSON, err := json.Marshal(metadata)
-	if err != nil {
-		return fmt.Errorf("metadata serialisieren: %w", err)
-	}
-	_, err = b.pool.Exec(ctx, `
-		INSERT INTO resync_audit_buffer (tenant_slug, actor, action, target, metadata)
-		VALUES ($1, $2, $3, $4, $5)
-	`, tenantSlug, actor, action, target, metadataJSON)
-	if err != nil {
-		return fmt.Errorf("audit-ereignis puffern: %w", err)
-	}
-	return nil
-}
-
-// EnqueueUsageDelta puffert EIN Nutzungszaehler-Inkrement lokal.
-func (b *Buffer) EnqueueUsageDelta(ctx context.Context, tenantSlug, metric string, delta int64) error {
-	_, err := b.pool.Exec(ctx, `
-		INSERT INTO resync_usage_buffer (tenant_slug, metric, delta)
-		VALUES ($1, $2, $3)
-	`, tenantSlug, metric, delta)
-	if err != nil {
-		return fmt.Errorf("nutzungsdelta puffern: %w", err)
-	}
-	return nil
-}
-
-// PendingAuditEvents liefert ALLE noch nicht zugestellten Audit-Events in
-// ORIGINALER Reihenfolge (Akzeptanzkriterium 2 / Pruefung 1).
-func (b *Buffer) PendingAuditEvents(ctx context.Context) ([]BufferedAuditEvent, error) {
-	rows, err := b.pool.Query(ctx, `
-		SELECT id, seq, tenant_slug, actor, action, target, metadata, created_at
-		FROM resync_audit_buffer ORDER BY seq
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("gepufferte audit-events abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []BufferedAuditEvent
-	for rows.Next() {
-		var e BufferedAuditEvent
-		var metadataJSON []byte
-		if err := rows.Scan(&e.ID, &e.Seq, &e.TenantSlug, &e.Actor, &e.Action, &e.Target, &metadataJSON, &e.CreatedAt); err != nil {
-			return nil, fmt.Errorf("gepuffertes audit-event lesen: %w", err)
-		}
-		_ = json.Unmarshal(metadataJSON, &e.Metadata)
-		out = append(out, e)
-	}
-	return out, rows.Err()
-}
-
-// PendingUsageDeltas liefert ALLE noch nicht zugestellten Nutzungsdeltas.
-func (b *Buffer) PendingUsageDeltas(ctx context.Context) ([]BufferedUsageDelta, error) {
-	rows, err := b.pool.Query(ctx, `
-		SELECT id, seq, tenant_slug, metric, delta, created_at
-		FROM resync_usage_buffer ORDER BY seq
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("gepufferte nutzungsdeltas abfragen: %w", err)
-	}
-	defer rows.Close()
-
-	var out []BufferedUsageDelta
-	for rows.Next() {
-		var d BufferedUsageDelta
-		if err := rows.Scan(&d.ID, &d.Seq, &d.TenantSlug, &d.Metric, &d.Delta, &d.CreatedAt); err != nil {
-			return nil, fmt.Errorf("gepuffertes nutzungsdelta lesen: %w", err)
-		}
-		out = append(out, d)
-	}
-	return out, rows.Err()
-}
-
-// RemoveAuditEvent entfernt EIN Audit-Event aus dem Puffer — wird NUR nach
-// von Core BESTAETIGTER Zustellung aufgerufen (Akzeptanzkriterium 2/3: erst
-// entfernen, wenn sicher zugestellt, sonst bleibt es fuer den naechsten
-// Versuch erhalten — kein Datenverlust bei erneutem Ausfall waehrend der
-// Nachlieferung).
-func (b *Buffer) RemoveAuditEvent(ctx context.Context, id int64) error {
-	_, err := b.pool.Exec(ctx, `DELETE FROM resync_audit_buffer WHERE id = $1`, id)
-	return err
-}
-
-func (b *Buffer) RemoveUsageDelta(ctx context.Context, id int64) error {
-	_, err := b.pool.Exec(ctx, `DELETE FROM resync_usage_buffer WHERE id = $1`, id)
-	return err
-}
@@ -1,132 +0,0 @@
-package resync
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"time"
-)
-
-// AuditRecorder ist die schmale Schnittstelle, ueber die Core empfangene
-// Audit-Events tatsaechlich persistiert. In Produktion durch internal/audit
-// (AUD-01, nicht Abhaengigkeit dieser Kachel) implementiert — dieses Paket
-// dupliziert dessen Validierungs-/Speicherlogik NICHT, sondern ruft sie nur
-// auf. Die Events werden vom Aufrufer sequenziell in PendingAuditEvents-
-// Reihenfolge uebergeben (Akzeptanzkriterium 2).
-type AuditRecorder interface {
-	Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error
-}
-
-// UsageIncrementer ist die schmale Schnittstelle zu Core's Nutzungszaehler
-// (in Produktion internal/usage, LIC-03 — nicht Abhaengigkeit dieser
-// Kachel). Jedes gepufferte Delta wird GENAU EINMAL angewendet.
-type UsageIncrementer interface {
-	Increment(ctx context.Context, tenantSlug, metric string, delta int64) error
-}
-
-// CredentialAuthenticator ist die schmale Schnittstelle zu API-02s
-// Service-Credential-Pruefung (internal/moduleregistry.Registry.Authenticate).
-type CredentialAuthenticator interface {
-	Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error)
-}
-
-// Handler nimmt nachgelieferte Audit-Events/Nutzungsdeltas auf der
-// Core-Seite entgegen — authentifiziert ueber dasselbe Service-Credential
-// wie jeder andere Modul-Core-Aufruf (Akzeptanzkriterium 2/3, "authentifiziert
-// ueber das in API-02 definierte Service-Credential").
-type Handler struct {
-	auth  CredentialAuthenticator
-	audit AuditRecorder
-	usage UsageIncrementer
-}
-
-func NewHandler(auth CredentialAuthenticator, audit AuditRecorder, usage UsageIncrementer) *Handler {
-	return &Handler{auth: auth, audit: audit, usage: usage}
-}
-
-type credentialHeader struct {
-	ClientID string `json:"client_id"`
-	Secret   string `json:"secret"`
-}
-
-func (h *Handler) authenticate(w http.ResponseWriter, r *http.Request) bool {
-	clientID := r.Header.Get("X-Nexarch-Client-Id")
-	secret := r.Header.Get("X-Nexarch-Client-Secret")
-	_, ok, err := h.auth.Authenticate(r.Context(), clientID, secret)
-	if err != nil || !ok {
-		http.Error(w, "ungueltiges service-credential", http.StatusUnauthorized)
-		return false
-	}
-	return true
-}
-
-type auditEventDTO struct {
-	TenantSlug string         `json:"tenant_slug"`
-	Actor      string         `json:"actor"`
-	Action     string         `json:"action"`
-	Target     string         `json:"target"`
-	Metadata   map[string]any `json:"metadata"`
-	OccurredAt time.Time      `json:"occurred_at"`
-}
-
-// AuditHandler nimmt EINE Liste gepufferter Audit-Events entgegen und
-// schreibt sie SEQUENZIELL in der gegebenen Reihenfolge fort
-// (Akzeptanzkriterium 2 / Pruefung 1: Vollstaendigkeit + Reihenfolge).
-// Bricht die Verarbeitung bei einem Fehler ab und meldet, wie viele Events
-// bereits sicher geschrieben wurden — der Aufrufer (Worker) entfernt aus
-// seinem lokalen Puffer NUR die bestaetigt geschriebenen Events.
-func (h *Handler) AuditHandler(w http.ResponseWriter, r *http.Request) {
-	if !h.authenticate(w, r) {
-		return
-	}
-	var events []auditEventDTO
-	if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
-		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
-		return
-	}
-
-	written := 0
-	for _, e := range events {
-		if err := h.audit.Record(r.Context(), e.TenantSlug, e.Actor, e.Action, e.Target, e.Metadata, e.OccurredAt); err != nil {
-			break
-		}
-		written++
-	}
-
-	writeJSON(w, map[string]int{"written": written})
-}
-
-type usageDeltaDTO struct {
-	TenantSlug string `json:"tenant_slug"`
-	Metric     string `json:"metric"`
-	Delta      int64  `json:"delta"`
-}
-
-// UsageHandler wendet JEDES gepufferte Delta GENAU EINMAL an
-// (Akzeptanzkriterium 3 / Pruefung 2: keine Doppelzaehlung) — der Aufrufer
-// entfernt aus seinem lokalen Puffer nur die bestaetigt uebernommenen Deltas.
-func (h *Handler) UsageHandler(w http.ResponseWriter, r *http.Request) {
-	if !h.authenticate(w, r) {
-		return
-	}
-	var deltas []usageDeltaDTO
-	if err := json.NewDecoder(r.Body).Decode(&deltas); err != nil {
-		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
-		return
-	}
-
-	applied := 0
-	for _, d := range deltas {
-		if err := h.usage.Increment(r.Context(), d.TenantSlug, d.Metric, d.Delta); err != nil {
-			break
-		}
-		applied++
-	}
-
-	writeJSON(w, map[string]int{"applied": applied})
-}
-
-func writeJSON(w http.ResponseWriter, body any) {
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(body)
-}
@@ -1,320 +0,0 @@
-package resync
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
-)
-
-// fakeAudit steht fuer internal/audit.Log (AUD-01, nicht Abhaengigkeit
-// dieser Kachel) — zeichnet Aufrufe in Empfangsreihenfolge auf, damit
-// Vollstaendigkeit UND Reihenfolge geprueft werden koennen.
-type fakeAudit struct {
-	mu     sync.Mutex
-	events []auditEventDTO
-	failAt int // -1 = nie fehlschlagen; sonst: ab diesem Index (0-basiert) schlaegt Record fehl
-}
-
-func (f *fakeAudit) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	if f.failAt >= 0 && len(f.events) == f.failAt {
-		return fmt.Errorf("simulierter core-ausfall waehrend der nachlieferung")
-	}
-	f.events = append(f.events, auditEventDTO{TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target, Metadata: metadata, OccurredAt: occurredAt})
-	return nil
-}
-
-// fakeUsage steht fuer internal/usage.Store (LIC-03, nicht Abhaengigkeit
-// dieser Kachel) — summiert Deltas wie der echte Store.
-type fakeUsage struct {
-	mu     sync.Mutex
-	totals map[string]int64
-}
-
-func newFakeUsage() *fakeUsage { return &fakeUsage{totals: map[string]int64{}} }
-
-func (f *fakeUsage) Increment(ctx context.Context, tenantSlug, metric string, delta int64) error {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.totals[tenantSlug+"|"+metric] += delta
-	return nil
-}
-
-func setupTest(t *testing.T) (*Buffer, *pgxpool.Pool, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS resync_audit_buffer (
-			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, actor TEXT NOT NULL,
-			action TEXT NOT NULL, target TEXT NOT NULL DEFAULT '', metadata JSONB NOT NULL DEFAULT '{}',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS resync_usage_buffer (
-			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, metric TEXT NOT NULL,
-			delta BIGINT NOT NULL, created_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 modules (
-			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
-			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS module_credentials (
-			module_name TEXT PRIMARY KEY REFERENCES modules(name),
-			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewBuffer(pool), pool, cleanup
-}
-
-func uniqueModuleName() string {
-	return fmt.Sprintf("resync-test-%d", time.Now().UnixNano())
-}
-
-// setupModuleCredential registriert ein echtes Modul + Service-Credential
-// ueber internal/moduleregistry (API-02) — dieselbe Authentifizierung wird
-// vom Handler tatsaechlich geprueft, kein Mock.
-func setupModuleCredential(t *testing.T, pool *pgxpool.Pool) (registry *moduleregistry.Registry, clientID, secret string) {
-	t.Helper()
-	ctx := context.Background()
-	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
-	registry = moduleregistry.NewRegistry(pool, flagService)
-	name := uniqueModuleName()
-	if _, err := registry.Register(ctx, name, "1.0.0", nil); err != nil {
-		t.Fatalf("modul registrieren: %v", err)
-	}
-	clientID, secret, err := registry.Provision(ctx, name)
-	if err != nil {
-		t.Fatalf("credential provisionieren: %v", err)
-	}
-	return registry, clientID, secret
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: waehrend eines simulierten Ausfalls
-// lokal gepufferte Audit-Events sind nach Wiederanlauf vollstaendig und in
-// korrekter Reihenfolge in Core's Audit-Log vorhanden.
-func TestFlushAll_DeliversBufferedAuditEventsCompleteAndInOrder(t *testing.T) {
-	buffer, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	registry, clientID, secret := setupModuleCredential(t, pool)
-
-	tenantSlug := "acme"
-	// Ereignisse "waehrend core down" lokal puffern.
-	actions := []string{"login", "upload", "delete", "logout"}
-	for _, action := range actions {
-		if err := buffer.EnqueueAuditEvent(ctx, tenantSlug, "user-1", action, "res-1", nil); err != nil {
-			t.Fatalf("enqueue %s: %v", action, err)
-		}
-	}
-
-	audit := &fakeAudit{failAt: -1}
-	usage := newFakeUsage()
-	handler := NewHandler(registry, audit, usage)
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
-	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	client := NewCoreClient(server.URL, clientID, secret)
-	worker := NewWorker(buffer, client)
-
-	if err := worker.FlushAll(ctx); err != nil {
-		t.Fatalf("flushall: %v", err)
-	}
-
-	audit.mu.Lock()
-	defer audit.mu.Unlock()
-	if len(audit.events) != len(actions) {
-		t.Fatalf("erwartet %d zugestellte events, habe %d", len(actions), len(audit.events))
-	}
-	for i, e := range audit.events {
-		if e.Action != actions[i] {
-			t.Fatalf("reihenfolge falsch: position %d = %q, want %q", i, e.Action, actions[i])
-		}
-	}
-
-	// Puffer muss nach bestaetigter Zustellung leer sein.
-	remaining, err := buffer.PendingAuditEvents(ctx)
-	if err != nil {
-		t.Fatalf("pending: %v", err)
-	}
-	if len(remaining) != 0 {
-		t.Fatalf("erwartet leeren puffer nach bestaetigter zustellung, habe %d verbleibende", len(remaining))
-	}
-}
-
-// Bekannter-Fehler-Praevention: bricht die Zustellung waehrend der
-// Nachlieferung erneut ab (Core faellt wieder aus), bleiben die NICHT
-// bestaetigten Events sicher im Puffer erhalten statt verloren zu gehen.
-func TestFlushAll_KeepsUnconfirmedEventsInBufferOnPartialFailure(t *testing.T) {
-	buffer, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	registry, clientID, secret := setupModuleCredential(t, pool)
-
-	for i := 0; i < 5; i++ {
-		if err := buffer.EnqueueAuditEvent(ctx, "acme", "user-1", fmt.Sprintf("action-%d", i), "", nil); err != nil {
-			t.Fatalf("enqueue %d: %v", i, err)
-		}
-	}
-
-	// Core-Fake schlaegt AB dem 3. Event fehl -> simuliert erneuten Ausfall
-	// mitten in der Nachlieferung.
-	audit := &fakeAudit{failAt: 3}
-	handler := NewHandler(registry, audit, newFakeUsage())
-	mux := http.NewServeMux()
-	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
-	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	client := NewCoreClient(server.URL, clientID, secret)
-	worker := NewWorker(buffer, client)
-
-	if err := worker.FlushAll(ctx); err == nil {
-		t.Fatal("erwartet fehler, da core nur teilweise bestaetigt hat")
-	}
-
-	remaining, err := buffer.PendingAuditEvents(ctx)
-	if err != nil {
-		t.Fatalf("pending: %v", err)
-	}
-	if len(remaining) != 2 {
-		t.Fatalf("erwartet 2 verbleibende (nicht bestaetigte) events im puffer, habe %d", len(remaining))
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 2: Nutzungszaehler-Differenz aus der
-// Ausfallzeit wird korrekt nachgebucht, ein wiederholter (fehlerhafter)
-// Flush-Versuch fuehrt NICHT zu Doppelzaehlung, weil bereits bestaetigte
-// Deltas aus dem Puffer entfernt sind.
-func TestFlushAll_AppliesUsageDeltasWithoutDoubleCounting(t *testing.T) {
-	buffer, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	registry, clientID, secret := setupModuleCredential(t, pool)
-
-	deltas := []int64{3, 5, 2}
-	var want int64
-	for _, d := range deltas {
-		want += d
-		if err := buffer.EnqueueUsageDelta(ctx, "acme", "api_calls", d); err != nil {
-			t.Fatalf("enqueue delta %d: %v", d, err)
-		}
-	}
-
-	usage := newFakeUsage()
-	handler := NewHandler(registry, &fakeAudit{failAt: -1}, usage)
-	mux := http.NewServeMux()
-	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
-	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	client := NewCoreClient(server.URL, clientID, secret)
-	worker := NewWorker(buffer, client)
-
-	if err := worker.FlushAll(ctx); err != nil {
-		t.Fatalf("flushall 1: %v", err)
-	}
-
-	usage.mu.Lock()
-	got := usage.totals["acme|api_calls"]
-	usage.mu.Unlock()
-	if got != want {
-		t.Fatalf("nutzungsstand nach nachbuchung = %d, want %d", got, want)
-	}
-
-	// Ein zweiter Flush-Versuch (z.B. redundanter Retry) darf NICHTS mehr
-	// nachbuchen, da der Puffer bereits geleert wurde.
-	if err := worker.FlushAll(ctx); err != nil {
-		t.Fatalf("flushall 2: %v", err)
-	}
-	usage.mu.Lock()
-	got2 := usage.totals["acme|api_calls"]
-	usage.mu.Unlock()
-	if got2 != want {
-		t.Fatalf("nutzungsstand nach redundantem zweiten flush = %d, want unveraendert %d (keine doppelzaehlung)", got2, want)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 3: bei erkannter Core-Wiedererreichbarkeit
-// wird der Cache SOFORT invalidiert (naechster Zugriff refetcht), nicht
-// erst nach TTL-Ablauf — Latenz wird gemessen und liegt weit unter einer
-// langen TTL.
-func TestCheckAndSync_InvalidatesCacheImmediatelyOnRecovery(t *testing.T) {
-	buffer, pool, cleanup := setupTest(t)
-	defer cleanup()
-	registry, clientID, secret := setupModuleCredential(t, pool)
-	_ = registry
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-	server := httptest.NewServer(mux)
-	defer server.Close()
-
-	client := NewCoreClient(server.URL, clientID, secret)
-	worker := NewWorker(buffer, client)
-
-	invalidated := false
-	var mu sync.Mutex
-	worker.OnReachable(func() {
-		mu.Lock()
-		invalidated = true
-		mu.Unlock()
-	})
-
-	start := time.Now()
-	becameReachable, err := worker.CheckAndSync(context.Background())
-	elapsed := time.Since(start)
-	if err != nil {
-		t.Fatalf("checkandsync: %v", err)
-	}
-	if !becameReachable {
-		t.Fatal("erwartet erkannten uebergang zu 'erreichbar' beim ersten erfolgreichen check")
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-	if !invalidated {
-		t.Fatal("erwartet sofortigen cache-invalidierungs-callback bei core-wiedererreichbarkeit")
-	}
-	// Zielwert: deutlich unter einer typischen TTL (z.B. 5s beim
-	// Feature-Flag-Cache, LIC-02) — hier im Millisekundenbereich, da rein
-	// lokal ohne Netzwerk-Overhead.
-	if elapsed > time.Second {
-		t.Fatalf("cache-invalidierung brauchte %s, erwartet deutlich unter 1s", elapsed)
-	}
-}
@@ -1,220 +0,0 @@
-package resync
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-)
-
-// CoreClient ist der modul-seitige HTTP-Client fuer die Nachlieferung,
-// authentifiziert ueber dasselbe Service-Credential wie jeder andere
-// Modul-Core-Aufruf (API-02).
-type CoreClient struct {
-	BaseURL  string
-	ClientID string
-	Secret   string
-	HTTP     *http.Client
-}
-
-func NewCoreClient(baseURL, clientID, secret string) *CoreClient {
-	return &CoreClient{BaseURL: baseURL, ClientID: clientID, Secret: secret, HTTP: &http.Client{Timeout: 5 * time.Second}}
-}
-
-func (c *CoreClient) post(ctx context.Context, path string, body any) (*http.Response, error) {
-	payload, err := json.Marshal(body)
-	if err != nil {
-		return nil, fmt.Errorf("payload serialisieren: %w", err)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+path, bytes.NewReader(payload))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-Nexarch-Client-Id", c.ClientID)
-	req.Header.Set("X-Nexarch-Client-Secret", c.Secret)
-	return c.HTTP.Do(req)
-}
-
-// HealthCheck prueft, ob Core erreichbar ist — dieselbe Konvention wie
-// internal/health (OPS-01): HTTP 200 auf einem Health-Endpunkt.
-func (c *CoreClient) HealthCheck(ctx context.Context) bool {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL+"/healthz", nil)
-	if err != nil {
-		return false
-	}
-	resp, err := c.HTTP.Do(req)
-	if err != nil {
-		return false
-	}
-	defer resp.Body.Close()
-	return resp.StatusCode == http.StatusOK
-}
-
-// Worker erkennt Core-Wiedererreichbarkeit und stoesst DANN sofort
-// (Akzeptanzkriterium 1) sowohl registrierte Cache-Invalidierungen als auch
-// das Nachliefern des lokalen Puffers an.
-type Worker struct {
-	buffer      *Buffer
-	client      *CoreClient
-	onReachable []func()
-	wasDown     bool
-}
-
-func NewWorker(buffer *Buffer, client *CoreClient) *Worker {
-	return &Worker{buffer: buffer, client: client, wasDown: true} // Start pessimistisch: erster erfolgreicher Check zaehlt als "Wiedererreichbarkeit".
-}
-
-// OnReachable registriert einen Callback, der bei jeder erkannten
-// Core-Wiedererreichbarkeit sofort ausgefuehrt wird — z.B.
-// moduletrust.StaleCache[T].Invalidate, damit der naechste Zugriff sofort
-// neu abruft statt auf TTL-Ablauf zu warten (Akzeptanzkriterium 1).
-func (w *Worker) OnReachable(fn func()) {
-	w.onReachable = append(w.onReachable, fn)
-}
-
-// CheckAndSync fuehrt EINEN Zyklus aus: Erreichbarkeit pruefen, bei
-// erkanntem UEBERGANG "nicht erreichbar -> erreichbar" sofort die
-// registrierten Callbacks ausloesen und den Puffer nachliefern. Gibt
-// zurueck, ob ein Wiederanlauf in diesem Aufruf erkannt wurde (fuer
-// Latenzmessung in Tests, Pruefung 3).
-func (w *Worker) CheckAndSync(ctx context.Context) (becameReachable bool, err error) {
-	reachable := w.client.HealthCheck(ctx)
-	if !reachable {
-		w.wasDown = true
-		return false, nil
-	}
-
-	justRecovered := w.wasDown
-	w.wasDown = false
-	if !justRecovered {
-		return false, nil
-	}
-
-	for _, fn := range w.onReachable {
-		fn()
-	}
-
-	if err := w.FlushAll(ctx); err != nil {
-		return true, err
-	}
-	return true, nil
-}
-
-// FlushAll liefert ZUERST alle gepufferten Audit-Events (in Reihenfolge),
-// DANN alle gepufferten Nutzungsdeltas nach. Jedes Element wird aus dem
-// lokalen Puffer NUR entfernt, wenn Core es bestaetigt hat — bricht die
-// Uebertragung vorzeitig ab (Core faellt waehrend der Nachlieferung erneut
-// aus), bleibt der Rest sicher im Postgres-Puffer erhalten
-// (Akzeptanzkriterium 2/3, "Bekannte Fehler vermeiden").
-func (w *Worker) FlushAll(ctx context.Context) error {
-	if err := w.flushAuditEvents(ctx); err != nil {
-		return err
-	}
-	return w.flushUsageDeltas(ctx)
-}
-
-func (w *Worker) flushAuditEvents(ctx context.Context) error {
-	events, err := w.buffer.PendingAuditEvents(ctx)
-	if err != nil {
-		return err
-	}
-	if len(events) == 0 {
-		return nil
-	}
-
-	dtos := make([]auditEventDTO, len(events))
-	for i, e := range events {
-		dtos[i] = auditEventDTO{
-			TenantSlug: e.TenantSlug, Actor: e.Actor, Action: e.Action, Target: e.Target,
-			Metadata: e.Metadata, OccurredAt: e.CreatedAt,
-		}
-	}
-
-	resp, err := w.client.post(ctx, "/internal/resync/audit", dtos)
-	if err != nil {
-		return fmt.Errorf("audit-nachlieferung: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("audit-nachlieferung: unerwarteter status %d", resp.StatusCode)
-	}
-
-	var ack struct {
-		Written int `json:"written"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
-		return fmt.Errorf("audit-bestaetigung lesen: %w", err)
-	}
-
-	// NUR die von Core bestaetigt geschriebenen Events entfernen — sie sind
-	// nach PendingAuditEvents-Reihenfolge sortiert, die ersten `Written`
-	// Eintraege entsprechen also genau den bestaetigten.
-	for i := 0; i < ack.Written; i++ {
-		if err := w.buffer.RemoveAuditEvent(ctx, events[i].ID); err != nil {
-			return fmt.Errorf("bestaetigtes audit-event aus puffer entfernen: %w", err)
-		}
-	}
-	if ack.Written < len(events) {
-		return fmt.Errorf("core hat nur %d von %d audit-events bestaetigt", ack.Written, len(events))
-	}
-	return nil
-}
-
-func (w *Worker) flushUsageDeltas(ctx context.Context) error {
-	deltas, err := w.buffer.PendingUsageDeltas(ctx)
-	if err != nil {
-		return err
-	}
-	if len(deltas) == 0 {
-		return nil
-	}
-
-	dtos := make([]usageDeltaDTO, len(deltas))
-	for i, d := range deltas {
-		dtos[i] = usageDeltaDTO{TenantSlug: d.TenantSlug, Metric: d.Metric, Delta: d.Delta}
-	}
-
-	resp, err := w.client.post(ctx, "/internal/resync/usage", dtos)
-	if err != nil {
-		return fmt.Errorf("nutzungs-nachlieferung: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("nutzungs-nachlieferung: unerwarteter status %d", resp.StatusCode)
-	}
-
-	var ack struct {
-		Applied int `json:"applied"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
-		return fmt.Errorf("nutzungs-bestaetigung lesen: %w", err)
-	}
-
-	for i := 0; i < ack.Applied; i++ {
-		if err := w.buffer.RemoveUsageDelta(ctx, deltas[i].ID); err != nil {
-			return fmt.Errorf("bestaetigtes nutzungsdelta aus puffer entfernen: %w", err)
-		}
-	}
-	if ack.Applied < len(deltas) {
-		return fmt.Errorf("core hat nur %d von %d nutzungsdeltas bestaetigt", ack.Applied, len(deltas))
-	}
-	return nil
-}
-
-// Run fuehrt CheckAndSync in festen Abstaenden aus — die "kurze, definierte
-// Zeitspanne" aus Akzeptanzkriterium 1 ist dieses Poll-Intervall.
-func (w *Worker) Run(ctx context.Context, interval time.Duration) {
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			_, _ = w.CheckAndSync(ctx)
-		}
-	}
-}
@@ -1,32 +0,0 @@
-package usage
-
-import (
-	"context"
-	"log/slog"
-	"time"
-)
-
-// AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
-// Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
-// haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
-// Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
-type AggregateFunc func(ctx context.Context) error
-
-// RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
-// beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
-// internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
-// aggregiert").
-func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			if err := aggregate(ctx); err != nil {
-				slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
-			}
-		}
-	}
-}
@@ -1,144 +0,0 @@
-// Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
-// (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
-// gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
-// Hardcode — Zitadel/Unleash-Vorbild.
-package usage
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
-
-// Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
-type Status string
-
-const (
-	StatusOK       Status = "ok"
-	StatusWarning  Status = "warning"  // Schwelle (80%) erreicht, aber noch nicht ueberschritten
-	StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
-)
-
-// warningThreshold liegt bei 80% der Quota.
-const warningThreshold = 0.8
-
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
-// (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
-// haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
-// (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
-// Lock zu brauchen.
-func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (tenant_id, metric) DO UPDATE
-			SET value = usage_counters.value + $3, updated_at = now()
-	`, tenantID, metric, delta)
-	if err != nil {
-		return fmt.Errorf("zaehler erhoehen: %w", err)
-	}
-	return nil
-}
-
-// Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
-// Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
-func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
-	var value int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&value)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, nil
-		}
-		return 0, fmt.Errorf("zaehler lesen: %w", err)
-	}
-	return value, nil
-}
-
-// SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
-// kein Hardcode.
-func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_quotas (tenant_id, metric, limit_value)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
-	`, tenantID, metric, limit)
-	if err != nil {
-		return fmt.Errorf("quota setzen: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
-	var limit int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&limit)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, ErrNoQuota
-		}
-		return 0, fmt.Errorf("quota lesen: %w", err)
-	}
-	return limit, nil
-}
-
-// Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
-// Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
-// gilt die Metrik als unbegrenzt (StatusOK).
-func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
-	value, err = s.Get(ctx, tenantID, metric)
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	limit, err = s.GetQuota(ctx, tenantID, metric)
-	if errors.Is(err, ErrNoQuota) {
-		return value, 0, StatusOK, nil
-	}
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	switch {
-	case value > limit:
-		return value, limit, StatusExceeded, nil
-	case limit > 0 && float64(value) >= warningThreshold*float64(limit):
-		return value, limit, StatusWarning, nil
-	default:
-		return value, limit, StatusOK, nil
-	}
-}
-
-// Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
-// (Akzeptanzkriterium 2: "definierte Reaktion").
-type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
-
-// Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
-// die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
-// Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
-// garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
-func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
-	value, limit, status, err := s.Check(ctx, tenantID, metric)
-	if err != nil {
-		return "", err
-	}
-	if status != StatusOK && react != nil {
-		react(ctx, tenantID, metric, value, limit, status)
-	}
-	return status, nil
-}
@@ -1,206 +0,0 @@
-package usage
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupTest(t *testing.T) (*Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS usage_counters (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
-		);
-		CREATE TABLE IF NOT EXISTS usage_quotas (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
-			PRIMARY KEY (tenant_id, metric)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewStore(pool), cleanup
-}
-
-func newTenantID() string {
-	return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
-// Schreibzugriffen konsistente Zaehlerstaende.
-func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	const goroutines = 50
-	var wg sync.WaitGroup
-	for i := 0; i < goroutines; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
-				t.Errorf("increment: %v", err)
-			}
-		}()
-	}
-	wg.Wait()
-
-	value, err := store.Get(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if value != goroutines {
-		t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
-// nicht den eines anderen.
-func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenantA, tenantB := newTenantID(), newTenantID()
-
-	if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
-		t.Fatalf("increment a: %v", err)
-	}
-	if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
-		t.Fatalf("increment b: %v", err)
-	}
-
-	valA, err := store.Get(ctx, tenantA, "users")
-	if err != nil {
-		t.Fatalf("get a: %v", err)
-	}
-	valB, err := store.Get(ctx, tenantB, "users")
-	if err != nil {
-		t.Fatalf("get b: %v", err)
-	}
-	if valA != 5 || valB != 1 {
-		t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
-// erkannt und die definierte Reaktion ausgeloest.
-func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-	if err := store.Increment(ctx, tenant, "users", 11); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-
-	var reacted bool
-	var gotStatus Status
-	status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
-		reacted = true
-		gotStatus = status
-	})
-	if err != nil {
-		t.Fatalf("enforce: %v", err)
-	}
-	if status != StatusExceeded {
-		t.Fatalf("erwartet StatusExceeded, habe %q", status)
-	}
-	if !reacted || gotStatus != StatusExceeded {
-		t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
-	}
-}
-
-func TestCheck_WarningThresholdAndOK(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err = store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusWarning {
-		t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
-	}
-}
-
-func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
-	}
-}
-
-func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
-	defer cancel()
-
-	var mu sync.Mutex
-	calls := 0
-	RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
-		mu.Lock()
-		calls++
-		mu.Unlock()
-		return nil
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if calls < 3 {
-		t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
-	}
-}
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS feature_flags;
@@ -1,10 +0,0 @@
-- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
-- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
-- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
-CREATE TABLE feature_flags (
-    key                 TEXT PRIMARY KEY,
-    enabled             BOOLEAN NOT NULL DEFAULT false,
-    rollout_percentage  INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
-    target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-    updated_at          TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1 +0,0 @@
-DROP TABLE IF EXISTS tenant_licenses;
@@ -1,12 +0,0 @@
-- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
-- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
-- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
-CREATE TABLE tenant_licenses (
-    tenant_id     UUID PRIMARY KEY REFERENCES tenants(id),
-    plan          TEXT NOT NULL,
-    modules       TEXT[] NOT NULL,
-    issued_at     TIMESTAMPTZ NOT NULL,
-    valid_until   TIMESTAMPTZ NOT NULL,
-    raw_key       TEXT NOT NULL,
-    installed_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS module_credentials;
-DROP TABLE IF EXISTS modules;
@@ -1,18 +0,0 @@
-- Modul-Registry & Aktivierungspruefung (API-02, siehe core-kanban/tickets/API-02.md).
-CREATE TABLE modules (
-    name           TEXT PRIMARY KEY,
-    version        TEXT NOT NULL CHECK (version <> ''),
-    required_flags TEXT[] NOT NULL DEFAULT '{}',
-    registered_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-- Service-Credential je Modul-Instanz, bei Provisionierung ausgestellt
-- (Akzeptanzkriterium 4). secret_hash enthaelt NIEMALS das Secret im
-- Klartext, nur dessen SHA-256-Hash (Timing-safe-Vergleich beim Login,
-- Referenzmuster siehe AUD-02).
-CREATE TABLE module_credentials (
-    module_name TEXT PRIMARY KEY REFERENCES modules(name),
-    client_id   TEXT NOT NULL UNIQUE,
-    secret_hash BYTEA NOT NULL,
-    issued_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS usage_quotas;
-DROP TABLE IF EXISTS usage_counters;
@@ -1,15 +0,0 @@
-- Nutzungszaehler & Quotas je Tenant (LIC-03, siehe core-kanban/tickets/LIC-03.md).
-CREATE TABLE usage_counters (
-    tenant_id  UUID NOT NULL,
-    metric     TEXT NOT NULL,
-    value      BIGINT NOT NULL DEFAULT 0,
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (tenant_id, metric)
-);
-
-CREATE TABLE usage_quotas (
-    tenant_id   UUID NOT NULL,
-    metric      TEXT NOT NULL,
-    limit_value BIGINT NOT NULL,
-    PRIMARY KEY (tenant_id, metric)
-);
@@ -1,2 +0,0 @@
-DROP TABLE resync_usage_buffer;
-DROP TABLE resync_audit_buffer;
@@ -1,22 +0,0 @@
-- Wiederanlauf & Nachsynchronisierung nach Core-Ausfall (API-06, siehe
-- core-kanban/tickets/API-06.md) — lokale, PERSISTENTE Pufferqueue (kein
-- In-Memory) fuer Audit-Events und Nutzungszaehler-Deltas eines Moduls.
-CREATE TABLE resync_audit_buffer (
-    id          BIGSERIAL PRIMARY KEY,
-    seq         BIGSERIAL,
-    tenant_slug TEXT NOT NULL,
-    actor       TEXT NOT NULL,
-    action      TEXT NOT NULL,
-    target      TEXT NOT NULL DEFAULT '',
-    metadata    JSONB NOT NULL DEFAULT '{}',
-    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
-CREATE TABLE resync_usage_buffer (
-    id          BIGSERIAL PRIMARY KEY,
-    seq         BIGSERIAL,
-    tenant_slug TEXT NOT NULL,
-    metric      TEXT NOT NULL,
-    delta       BIGINT NOT NULL,
-    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -0,0 +1,30 @@
+import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
+
+export const metadata = {
+  title: "NEXARCH Audit-Log",
+};
+
+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>
+  );
+}
@@ -0,0 +1,159 @@
+"use client";
+
+import { useState } from "react";
+import { fetchRecords, exportURL, type AuditRecord, type AuditFilter } from "@/lib/api";
+
+const EMPTY_FILTER: AuditFilter = { tenant: "", actor: "", action: "", from: "", to: "" };
+
+export default function Page() {
+  const [caller, setCaller] = useState("");
+  const [filter, setFilter] = useState<AuditFilter>(EMPTY_FILTER);
+  const [records, setRecords] = useState<AuditRecord[] | null>(null);
+  const [selected, setSelected] = useState<AuditRecord | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  async function onSearch() {
+    setError(null);
+    setSelected(null);
+    try {
+      const data = await fetchRecords(caller.trim(), filter);
+      setRecords(data);
+    } catch (e: any) {
+      setError(e.message ?? "Unbekannter Fehler");
+      setRecords(null);
+    }
+  }
+
+  function onExport(format: "csv" | "json") {
+    const url = exportURL(caller.trim(), filter, format);
+    // Echter Datei-Download ueber Browser-Navigation, KEIN erneutes Parsen
+    // im Frontend (Akzeptanzkriterium 2: Export aus AUD-03 direkt ausloesbar).
+    window.open(url, "_blank");
+  }
+
+  return (
+    <main style={{ maxWidth: 1000, margin: "0 auto", padding: "2rem 1rem" }}>
+      <h1>Audit-Log</h1>
+
+      <div style={{ display: "grid", gap: "0.5rem", gridTemplateColumns: "repeat(3, 1fr)", marginBottom: "1rem" }}>
+        <input
+          value={caller}
+          onChange={(e) => setCaller(e.target.value)}
+          placeholder="Admin-Token (Berechtigung)"
+          style={{ padding: "0.5rem", gridColumn: "span 3" }}
+        />
+        <input
+          value={filter.tenant}
+          onChange={(e) => setFilter({ ...filter, tenant: e.target.value })}
+          placeholder="Tenant"
+          style={{ padding: "0.5rem" }}
+        />
+        <input
+          value={filter.actor}
+          onChange={(e) => setFilter({ ...filter, actor: e.target.value })}
+          placeholder="Akteur"
+          style={{ padding: "0.5rem" }}
+        />
+        <input
+          value={filter.action}
+          onChange={(e) => setFilter({ ...filter, action: e.target.value })}
+          placeholder="Aktion"
+          style={{ padding: "0.5rem" }}
+        />
+        <label>
+          Von
+          <input
+            type="datetime-local"
+            value={filter.from}
+            onChange={(e) =>
+              setFilter({ ...filter, from: e.target.value ? new Date(e.target.value).toISOString() : "" })
+            }
+            style={{ width: "100%", padding: "0.4rem" }}
+          />
+        </label>
+        <label>
+          Bis
+          <input
+            type="datetime-local"
+            value={filter.to}
+            onChange={(e) =>
+              setFilter({ ...filter, to: e.target.value ? new Date(e.target.value).toISOString() : "" })
+            }
+            style={{ width: "100%", padding: "0.4rem" }}
+          />
+        </label>
+      </div>
+
+      <div style={{ display: "flex", gap: "0.5rem", marginBottom: "1rem" }}>
+        <button onClick={onSearch}>Suchen</button>
+        <button onClick={() => onExport("csv")}>Export als CSV</button>
+        <button onClick={() => onExport("json")}>Export als JSON</button>
+      </div>
+
+      {error && (
+        <p style={{ color: "#c62828" }} role="alert">
+          Fehler: {error}
+        </p>
+      )}
+
+      {records && (
+        <table style={{ width: "100%", borderCollapse: "collapse", background: "white" }}>
+          <thead>
+            <tr style={{ textAlign: "left", borderBottom: "2px solid #ddd" }}>
+              <th style={{ padding: "0.5rem" }}>Zeitpunkt</th>
+              <th style={{ padding: "0.5rem" }}>Tenant</th>
+              <th style={{ padding: "0.5rem" }}>Akteur</th>
+              <th style={{ padding: "0.5rem" }}>Aktion</th>
+              <th style={{ padding: "0.5rem" }}></th>
+            </tr>
+          </thead>
+          <tbody>
+            {records.map((r, i) => (
+              <tr key={i} style={{ borderBottom: "1px solid #eee" }}>
+                <td style={{ padding: "0.5rem" }}>{new Date(r.occurred_at).toLocaleString("de-DE")}</td>
+                <td style={{ padding: "0.5rem" }}>{r.tenant_slug}</td>
+                <td style={{ padding: "0.5rem" }}>{r.actor}</td>
+                <td style={{ padding: "0.5rem" }}>{r.action}</td>
+                <td style={{ padding: "0.5rem" }}>
+                  <button onClick={() => setSelected(r)}>Details</button>
+                </td>
+              </tr>
+            ))}
+            {records.length === 0 && (
+              <tr>
+                <td colSpan={5} style={{ padding: "0.5rem" }}>
+                  Keine Einträge gefunden.
+                </td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      )}
+
+      {selected && (
+        <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
+          <h2>Eintrag-Details</h2>
+          <dl>
+            <dt>Zeitpunkt</dt>
+            <dd>{new Date(selected.occurred_at).toLocaleString("de-DE")}</dd>
+            <dt>Tenant</dt>
+            <dd>{selected.tenant_slug}</dd>
+            <dt>Akteur</dt>
+            <dd>{selected.actor}</dd>
+            <dt>Aktion</dt>
+            <dd>{selected.action}</dd>
+            <dt>Ziel</dt>
+            <dd>{selected.target}</dd>
+            <dt>Metadaten</dt>
+            <dd>
+              <pre style={{ whiteSpace: "pre-wrap", background: "#f5f6f8", padding: "0.5rem" }}>
+                {JSON.stringify(selected.metadata, null, 2)}
+              </pre>
+            </dd>
+          </dl>
+          <button onClick={() => setSelected(null)}>Schließen</button>
+        </section>
+      )}
+    </main>
+  );
+}
@@ -0,0 +1,63 @@
+// Duenner Client der AUD-03-Export-API (internal/audit.ExportHandler) —
+// keine eigene Aggregations-/Filterlogik im Frontend (Ticket-Vorgabe:
+// "reiner Konsument der Export-API"). Die JSON-Lines-Antwort wird nur
+// dekodiert, nicht neu berechnet oder gefiltert.
+export type AuditRecord = {
+  occurred_at: string;
+  tenant_slug: string;
+  actor: string;
+  action: string;
+  target: string;
+  metadata: unknown;
+};
+
+export type AuditFilter = {
+  tenant: string;
+  actor: string;
+  action: string;
+  from: string; // RFC3339, leer = kein Filter
+  to: string;
+};
+
+function apiBase(): string {
+  const base = process.env.NEXT_PUBLIC_AUDITLOG_API_URL;
+  if (!base) {
+    throw new Error(
+      "NEXT_PUBLIC_AUDITLOG_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
+    );
+  }
+  return base;
+}
+
+function buildParams(caller: string, filter: AuditFilter, format: "json" | "csv"): URLSearchParams {
+  const params = new URLSearchParams({ caller, format });
+  if (filter.tenant) params.set("tenant", filter.tenant);
+  if (filter.actor) params.set("actor", filter.actor);
+  if (filter.action) params.set("action", filter.action);
+  if (filter.from) params.set("from", filter.from);
+  if (filter.to) params.set("to", filter.to);
+  return params;
+}
+
+// exportURL liefert die Adresse desselben Endpunkts, den auch die
+// Export-Datei-Funktion (Akzeptanzkriterium 2) verwendet — Liste und Export
+// sind bewusst DERSELBE API-Aufruf mit unterschiedlichem "format".
+export function exportURL(caller: string, filter: AuditFilter, format: "json" | "csv"): string {
+  return `${apiBase()}/audit/export?${buildParams(caller, filter, format)}`;
+}
+
+// fetchRecords laedt die Liste als JSON-Lines und dekodiert Zeile fuer
+// Zeile — dieselben Filterparameter wie ein direkter API-Aufruf
+// (Akzeptanzkriterium 1 / Pruefung 1).
+export async function fetchRecords(caller: string, filter: AuditFilter): Promise<AuditRecord[]> {
+  const res = await fetch(exportURL(caller, filter, "json"), { cache: "no-store" });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(text || `Anfrage fehlgeschlagen (${res.status})`);
+  }
+  const text = await res.text();
+  return text
+    .split("\n")
+    .filter((line) => line.trim() !== "")
+    .map((line) => JSON.parse(line) as AuditRecord);
+}
@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // @nexarch/shl liegt als file:-Dependency mit TS-Quellen in node_modules —
+  // Next.js transpiliert node_modules standardmäßig nicht, siehe web/shl/README.md.
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;
@@ -0,0 +1,22 @@
+{
+  "name": "nexarch-audit-log",
+  "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"
+  }
+}
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
@@ -0,0 +1,45 @@
+# @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
+```
@@ -0,0 +1,38 @@
+// 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");
+  });
+});
@@ -0,0 +1,39 @@
+// 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);
+    });
+  }
+});
@@ -0,0 +1,88 @@
+"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>
+  );
+}
@@ -0,0 +1,98 @@
+// 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>
+  );
+}
@@ -0,0 +1,62 @@
+"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>
+  );
+}
@@ -0,0 +1,83 @@
+// 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>
+  );
+}
@@ -0,0 +1,67 @@
+"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;
+}
@@ -0,0 +1,75 @@
+"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;
+}
@@ -0,0 +1,25 @@
+// Ö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";
@@ -0,0 +1,25 @@
+{
+  "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"
+  }
+}
@@ -0,0 +1,81 @@
+"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];
+}
@@ -0,0 +1,96 @@
+// 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;
+}
@@ -0,0 +1,18 @@
+{
+  "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"]
+}
@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    setupFiles: ["./vitest.setup.ts"],
+  },
+});
@@ -0,0 +1,9 @@
+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();
+});
Author	SHA1	Message	Date
sysops	6537888da6	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht	2026-08-28 22:02:02 +02:00
sysops	bfa5c61db5	SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)	2026-08-28 22:01:56 +02:00
sysops	554c9aae66	AUD-04: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)	2026-08-28 21:56:27 +02:00
sysops	1ba90319a2	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht	2026-08-28 21:56:20 +02:00
sysops	3c226dab12	SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)	2026-08-28 21:55:34 +02:00
sysops	f344f79326	AUD-04: Retrofit auf SHL-01 (ThemeProvider/I18nProvider/ToastProvider, Design-Tokens statt hartkodierter Werte)	2026-08-28 21:47:23 +02:00
sysops	c4bcfa8caf	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht # Conflicts: # DEVLOG.md	2026-08-28 21:47:09 +02:00
sysops	584cefa388	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 21:45:55 +02:00
sysops	00665592f6	SHL-01: ui-shell-design-system-zentral (tokens, theming, i18n-rahmen, basis-komponenten)	2026-08-28 21:41:56 +02:00
sysops	3b96d8ef41	AUD-04: backend-authorizer + dev-server + next.js audit-log-ansicht	2026-08-28 00:10:48 +02:00
sysopsandClaude Sonnet 5	c9e8edbbf0	AUD-03: audit-log-export-filter-api internal/audit/export.go: StreamCSV/StreamJSON filtern nach Tenant, Akteur, Aktion und Zeitraum (Akzeptanzkriterium 1) und schreiben Zeile fuer Zeile ueber rows.Next() DIREKT auf den uebergebenen io.Writer — zu keinem Zeitpunkt wird das komplette Ergebnis im Speicher aufgebaut (Akzeptanz- kriterium 3). JSON-Export als JSON Lines statt einem grossen Array, um Streaming ohne Sonderbehandlung von Klammern/Kommas zu ermoeglichen. ExportHandler (Akzeptanzkriterium 2) schreibt direkt auf http.ResponseWriter — derselbe Streaming-Pfad wie in Tests, kein Zwischenpuffer nur fuer HTTP. Authorize ist eine schmale Schnittstelle (Vorbild: AUD-05 RetentionRegistrar- Muster), da die eigentliche Rollenpruefung RBAC-02 (Policy-Enforcement) ist und nicht Teil dieser Kachel — der Handler kennt nur "darf dieser Aufrufer exportieren", nicht wie das entschieden wird. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Export mit hoher Eintragszahl ohne uebermaessigen Speicherverbrauch — TestExport_StreamsLargeResultWithoutExcessiveMemory: 20.000 Eintraege, Heap-Wachstum waehrend Export nur ~1.8KB (Schwelle 3MB). PASS. 2. Filterkombinationen automatisiert gegen erwartete Ergebnismengen — TestExport_FilterCombinations (Tenant/Actor/Action einzeln und kombiniert) und TestExport_TimeRangeFilter (innerhalb/ausserhalb Zeitraum). PASS. 3. Zugriff ohne passende Berechtigung abgewiesen — TestExportHandler_RejectsWithoutAuthorization: fehlender/falscher caller -> 403, berechtigter caller -> 200. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:02:56 +02:00