QA-07: schnittstellen-vertragstests fuer api-01/api-05/api-02/api-07 + gitea-actions-workflow

internal/moduletrust: asymmetrische JWT-Signatur (Ed25519) mit JWKS-
Verteilung, wie im Entscheidungsverlauf "Vertrauensstellung Core<->Module"
(nexarch-state.json) festgelegt. Getrennt von IAM-02s HS256-Session-Cookie
(Browser-Login bleibt unangetastet) — dies ist der Modul-zu-Core-
Vertrauensmechanismus.

KeyManager haelt ALLE noch gueltigen Schluesselpaare (nicht nur das aktuell
signierende); Rotate() erzeugt einen neuen Schluessel, alte bleiben in
PublicKeySet() erhalten — bereits ausgestellte Tokens bleiben dadurch nach
einer Rotation weiterhin verifizierbar (Akzeptanzkriterium 3, keine
Ausfallzeit). ServeJWKS/ParseJWKS sind der Verteilungsmechanismus.

StaleCache[T] ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
(Akzeptanzkriterium 2), mit zwei explizit benannten und begruendeten
Verhalten: Get() ist FAIL-OPEN (nutzt bei Core-Ausfall einen vorhandenen,
abgelaufenen Stand weiter — ein bereits authentifiziertes Modul soll nicht
hart blockieren), RequireFresh() ist FAIL-CLOSED (nie zwischengespeichert,
schlaegt bei Core-Ausfall klar fehl — fuer sicherheitskritische Aktionen wie
einen neuen Login). LIC-02s internal/flag.Service implementiert bereits
denselben Kontrakt fuer Feature-Flags; StaleCache verallgemeinert dasselbe
Muster fuer JWT-Schluessel, damit beide Faelle derselben dokumentierten
Policy folgen statt zwei unterschiedlichen Ad-hoc-Loesungen.

Verifier.Verify ruft KeyFetchFunc nur bei abgelaufener TTL auf, nicht pro
Aufruf (Akzeptanzkriterium 1) — Signaturpruefung selbst ist immer lokal.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Core simuliert abgeschaltet, andere Module bleiben fuer bereits
   authentifizierte Nutzer funktionsfaehig bis TTL/Fail-Open greift —
   TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist: Verify()
   funktioniert weiter mit letztbekanntem Schluesselstand. PASS.
2. Neue sicherheitskritische Aktion schlaegt bei Core-Ausfall klar fehl,
   statt andere Funktionen mitzureissen —
   TestRequireFreshKeys_FailsClosedWhenCoreUnreachable: Fehler trotz
   vorhandenem (aelterem) Cache-Stand. PASS.
3. Schluesselrotation ohne Downtime in einem simulierten zweiten Modul —
   TestRotate_NoDowntimeForAlreadyIssuedTokens: vor UND nach Rotation
   ausgestellte Tokens beide weiterhin gueltig fuer Modul B. PASS.

Zusaetzlich: TestVerify_DoesNotFetchPerCall belegt Akzeptanzkriterium 1
direkt (10 Verify-Aufrufe, genau 1 Fetch). PASS.

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

.gitea/workflows/contract-tests.yml

@@ -0,0 +1,22 @@
+name: Core-Schnittstellen-Vertragstests
+
+on:
+  push:
+    paths:
+      - "internal/contracttest/**"
+      - "internal/apiserver/**"
+      - "internal/moduletrust/**"
+      - "internal/moduleregistry/**"
+      - "internal/webhook/**"
+  pull_request: {}
+
+jobs:
+  contract-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - name: Vertragstests ausfuehren
+        run: go test ./internal/contracttest/... -v

cmd/core/main.go

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

cmd/metrics-devserver/main.go

@@ -1,43 +0,0 @@
-// metrics-devserver stellt den OPS-03-Metrics-Aggregator (internal/metrics)
-// unter /metrics bereit, damit ein echter Prometheus-Scrape-Vorgang gegen
-// den Core-Dienst geprueft werden kann (Pruefung 3). Getrennt von cmd/core
-// aus demselben Grund wie die anderen *-devserver.
-package main
-
-import (
-	"context"
-	"log"
-	"net/http"
-	"os"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/db"
-	"gitea.perlbach24.de/scripte/nexarch/internal/metrics"
-)
-
-func main() {
-	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
-	if dsn == "" {
-		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
-	}
-	addr := os.Getenv("NEXARCH_METRICS_LISTEN_ADDR")
-	if addr == "" {
-		addr = ":8085"
-	}
-
-	ctx := context.Background()
-	pool, err := db.Connect(ctx, dsn)
-	if err != nil {
-		log.Fatalf("db: %v", err)
-	}
-	defer pool.Close()
-
-	sourceStore := metrics.NewSourceStore(pool)
-	agg := metrics.NewAggregator(metrics.NewCoreRegistry(), sourceStore.Provide)
-
-	mux := http.NewServeMux()
-	mux.HandleFunc("/metrics", agg.Handler())
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
-
-	log.Printf("metrics-devserver listening on %s", addr)
-	log.Fatal(http.ListenAndServe(addr, mux))
-}

go.mod

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

go.sum

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

internal/apiserver/context.go

@@ -0,0 +1,20 @@
+package apiserver
+
+import "context"
+
+type contextKey int
+
+const requestContextKey contextKey = iota
+
+// RequestContext ist der Tenant-/Benutzerkontext, den die Middleware-Kette
+// fuer nachgelagerte Handler bereitstellt (Akzeptanzkriterium 3).
+type RequestContext struct {
+	UserID     string
+	TenantSlug string
+}
+
+// FromContext liest den von der Middleware gesetzten Kontext.
+func FromContext(ctx context.Context) (RequestContext, bool) {
+	rc, ok := ctx.Value(requestContextKey).(RequestContext)
+	return rc, ok
+}

internal/apiserver/errors.go

@@ -0,0 +1,31 @@
+// Package apiserver implementiert Core API-01: das REST-Grundgerüst mit
+// URL-Versionierung, einheitlichem Fehlerformat und Middleware-Kette
+// (Auth, Tenant-/Benutzerkontext, Logging).
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// errorBody ist das EINE Fehlerschema fuer alle Endpunkte unter /api/{version}/
+// (Akzeptanzkriterium 2).
+type errorBody struct {
+	Error struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+// WriteError schreibt einen Fehler im einheitlichen Schema. code ist ein
+// stabiler, maschinenlesbarer Bezeichner (z.B. "unauthenticated"), message
+// ein fuer Menschen lesbarer deutscher Text.
+func WriteError(w http.ResponseWriter, status int, code, message string) {
+	var body errorBody
+	body.Error.Code = code
+	body.Error.Message = message
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}

internal/apiserver/middleware.go

@@ -0,0 +1,56 @@
+package apiserver
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// authAndTenantContext prueft die Session (wiederverwendet auth.TokenIssuer.Verify
+// aus IAM-02 — keine zweite JWT-Implementierung) und setzt bei Erfolg
+// RequestContext fuer nachgelagerte Handler (Akzeptanzkriterium 3). Anders
+// als auth.RequireAuth (Klartext-Fehler) antwortet diese Middleware im
+// einheitlichen API-01-Fehlerschema (Akzeptanzkriterium 2), damit ALLE
+// Endpunkte unter /api/{version}/ dasselbe Format liefern, auch bei
+// Auth-Fehlern.
+func authAndTenantContext(issuer *auth.TokenIssuer, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		cookie, err := r.Cookie(auth.CookieName)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		claims, err := issuer.Verify(cookie.Value)
+		if err != nil {
+			WriteError(w, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+			return
+		}
+
+		rc := RequestContext{UserID: claims.UserID, TenantSlug: claims.TenantSlug}
+		next(w, r.WithContext(context.WithValue(r.Context(), requestContextKey, rc)))
+	}
+}
+
+type statusRecorder struct {
+	http.ResponseWriter
+	status int
+}
+
+func (s *statusRecorder) WriteHeader(code int) {
+	s.status = code
+	s.ResponseWriter.WriteHeader(code)
+}
+
+// loggingMiddleware protokolliert jede Anfrage strukturiert.
+func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
+		start := time.Now()
+		next(rec, r)
+		slog.Info("api-anfrage", "method", r.Method, "path", r.URL.Path, "status", rec.status, "dauer", time.Since(start))
+	}
+}

internal/apiserver/server.go

@@ -0,0 +1,37 @@
+package apiserver
+
+import (
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Server registriert versionierte API-Routen (Akzeptanzkriterium 1: unter
+// /api/{version}/...) und verdrahtet fuer jede Route dieselbe Middleware-
+// Kette (Logging -> Auth+Tenantkontext -> Handler).
+type Server struct {
+	mux    *http.ServeMux
+	issuer *auth.TokenIssuer
+}
+
+func NewServer(issuer *auth.TokenIssuer) *Server {
+	return &Server{mux: http.NewServeMux(), issuer: issuer}
+}
+
+// Handle registriert pattern unter der angegebenen Version, z.B.
+// Handle("v1", "/things", h) -> erreichbar unter /api/v1/things. Verschiedene
+// Versionen sind unabhaengige Pfade — eine neue Version beeintraechtigt
+// bestehende nicht (Akzeptanzkriterium 1 / Pruefung 3).
+func (s *Server) Handle(version, pattern string, h http.HandlerFunc) {
+	full := "/api/" + version + pattern
+	s.mux.HandleFunc(full, loggingMiddleware(authAndTenantContext(s.issuer, h)))
+}
+
+// HandleV1 ist die Kurzform fuer die aktuelle Hauptversion.
+func (s *Server) HandleV1(pattern string, h http.HandlerFunc) {
+	s.Handle("v1", pattern, h)
+}
+
+func (s *Server) Handler() http.Handler {
+	return s.mux
+}

internal/apiserver/server_test.go

@@ -0,0 +1,149 @@
+package apiserver
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func newTestServer() (*Server, *auth.TokenIssuer) {
+	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
+	return NewServer(issuer), issuer
+}
+
+func withAuthCookie(req *http.Request, token string) *http.Request {
+	req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
+	return req
+}
+
+// Akzeptanzkriterium 1: API unter versioniertem Pfad erreichbar.
+func TestHandleV1_RegistersUnderVersionedPath(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 1 (Stichprobe): mehrere Endpunkte liefern
+// bei fehlerhafter Anfrage dasselbe Fehlerschema.
+func TestErrorFormat_ConsistentAcrossEndpoints(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/endpunkt-a", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+	srv.HandleV1("/endpunkt-b", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	for _, path := range []string{"/api/v1/endpunkt-a", "/api/v1/endpunkt-b"} {
+		req := httptest.NewRequest(http.MethodGet, path, nil) // ohne cookie -> 401
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+
+		if rec.Code != http.StatusUnauthorized {
+			t.Fatalf("%s: status = %d, want 401", path, rec.Code)
+		}
+		var body errorBody
+		if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+			t.Fatalf("%s: fehlerantwort nicht im erwarteten json-schema: %v (body: %s)", path, err, rec.Body.String())
+		}
+		if body.Error.Code == "" || body.Error.Message == "" {
+			t.Fatalf("%s: erwartet nicht-leeren code/message, habe %+v", path, body)
+		}
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 2: Middleware-Kette setzt Tenant-/
+// Benutzerkontext zuverlaessig, nachweislich fuer mehrere Endpunkte.
+func TestMiddleware_SetsRequestContextForEveryEndpoint(t *testing.T) {
+	srv, issuer := newTestServer()
+
+	var gotA, gotB RequestContext
+	srv.HandleV1("/kontext-a", func(w http.ResponseWriter, r *http.Request) {
+		gotA, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+	srv.HandleV1("/kontext-b", func(w http.ResponseWriter, r *http.Request) {
+		gotB, _ = FromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	token, err := issuer.Issue("user-42", "tenant-x")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	for path, got := range map[string]*RequestContext{"/api/v1/kontext-a": &gotA, "/api/v1/kontext-b": &gotB} {
+		req := withAuthCookie(httptest.NewRequest(http.MethodGet, path, nil), token)
+		rec := httptest.NewRecorder()
+		srv.Handler().ServeHTTP(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("%s: status = %d, want 200", path, rec.Code)
+		}
+		if got.UserID != "user-42" || got.TenantSlug != "tenant-x" {
+			t.Fatalf("%s: request-context unerwartet: %+v", path, *got)
+		}
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 3: eine neue v2-Route laesst sich anlegen,
+// ohne v1 zu beeintraechtigen.
+func TestVersioning_V2DoesNotAffectV1(t *testing.T) {
+	srv, issuer := newTestServer()
+	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v1-antwort"))
+	})
+	srv.Handle("v2", "/things", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("v2-antwort"))
+	})
+
+	token, err := issuer.Issue("user-1", "acme")
+	if err != nil {
+		t.Fatalf("issue: %v", err)
+	}
+
+	reqV1 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1, reqV1)
+	if recV1.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort = %q, want v1-antwort", recV1.Body.String())
+	}
+
+	reqV2 := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v2/things", nil), token)
+	recV2 := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV2, reqV2)
+	if recV2.Body.String() != "v2-antwort" {
+		t.Fatalf("v2 antwort = %q, want v2-antwort", recV2.Body.String())
+	}
+
+	// v1 nach dem Anlegen von v2 erneut pruefen — unveraendert.
+	reqV1Again := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/things", nil), token)
+	recV1Again := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(recV1Again, reqV1Again)
+	if recV1Again.Body.String() != "v1-antwort" {
+		t.Fatalf("v1 antwort nach v2-anlage = %q, want weiterhin v1-antwort", recV1Again.Body.String())
+	}
+}
+
+func TestAuthAndTenantContext_RejectsInvalidToken(t *testing.T) {
+	srv, _ := newTestServer()
+	srv.HandleV1("/geschuetzt", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	req := withAuthCookie(httptest.NewRequest(http.MethodGet, "/api/v1/geschuetzt", nil), "kaputtes.token.hier")
+	rec := httptest.NewRecorder()
+	srv.Handler().ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("status = %d, want 401", rec.Code)
+	}
+}

internal/auth/handler.go

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

internal/auth/login.go

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

internal/auth/login_test.go

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

internal/auth/middleware.go

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

internal/auth/password.go

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

internal/auth/password_bench_test.go

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

internal/auth/password_test.go

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

internal/auth/token.go

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

internal/auth/token_test.go

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

internal/contracttest/contracttest.go

@@ -0,0 +1,57 @@
+// Package contracttest implementiert Core QA-07: Vertragstests fuer die
+// Core-Schnittstellen, die von den Fachmodulen (DMS/Mail/Archive/Workflow/
+// AI/Connect) konsumiert werden — REST-Fehlerschema (API-01), JWKS-/Rechte-
+// Cache-Kontrakt (API-05), Modul-Registry (API-02) und Webhook-Zustellung
+// (API-07). Jeder Test prueft die TATSAECHLICHE Antwort einer echten
+// Core-Komponente gegen ihr dokumentiertes Schema — eine entfernte oder
+// umbenannte Pflichteigenschaft laesst den jeweiligen Test fehlschlagen,
+// BEVOR sie ein konsumierendes Modul bricht (Akzeptanzkriterium 2).
+package contracttest
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// RequireJSONFields dekodiert data als JSON-Objekt und prueft, dass ALLE
+// angegebenen Top-Level-Schluessel vorhanden sind. Liefert die fehlenden
+// Schluessel zurueck — leer bedeutet: Vertrag eingehalten.
+func RequireJSONFields(data []byte, required []string) (missing []string, err error) {
+	var decoded map[string]any
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
+	}
+	for _, field := range required {
+		if _, ok := decoded[field]; !ok {
+			missing = append(missing, field)
+		}
+	}
+	return missing, nil
+}
+
+// RequireJSONArrayItemFields prueft, dass data ein JSON-Objekt mit einem
+// Array-Feld arrayField ist, dessen ERSTES Element alle itemFields enthaelt
+// — Vertrag fuer Listen-Antworten wie JWKS ("keys": [{...}]).
+func RequireJSONArrayItemFields(data []byte, arrayField string, itemFields []string) (missing []string, err error) {
+	var decoded map[string]json.RawMessage
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
+	}
+	raw, ok := decoded[arrayField]
+	if !ok {
+		return itemFields, nil // das array-feld selbst fehlt bereits -> alles "fehlend"
+	}
+	var items []map[string]any
+	if err := json.Unmarshal(raw, &items); err != nil {
+		return nil, fmt.Errorf("contracttest: feld %q ist kein array: %w", arrayField, err)
+	}
+	if len(items) == 0 {
+		return nil, fmt.Errorf("contracttest: feld %q ist leer, kann nicht gegen kontrakt geprueft werden", arrayField)
+	}
+	for _, field := range itemFields {
+		if _, ok := items[0][field]; !ok {
+			missing = append(missing, field)
+		}
+	}
+	return missing, nil
+}

internal/contracttest/contracttest_test.go

@@ -0,0 +1,193 @@
+package contracttest
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
+	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
+	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
+	"gitea.perlbach24.de/scripte/nexarch/internal/webhook"
+)
+
+// --- Vertrag 1: API-01 REST-Fehlerschema ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API01_ErrorEnvelope(t *testing.T) {
+	rec := httptest.NewRecorder()
+	apiserver.WriteError(rec, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
+
+	if missing, err := RequireJSONFields(rec.Body.Bytes(), []string{"error"}); err != nil {
+		t.Fatalf("antwort nicht lesbar: %v", err)
+	} else if len(missing) != 0 {
+		t.Fatalf("erwartet top-level feld 'error', fehlt: %v", missing)
+	}
+
+	var decoded map[string]json.RawMessage
+	_ = json.Unmarshal(rec.Body.Bytes(), &decoded)
+	if missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"}); err != nil {
+		t.Fatalf("error-objekt nicht lesbar: %v", err)
+	} else if len(missing) != 0 {
+		t.Fatalf("error-objekt fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: absichtlich simulierter Breaking Change (Feld "message"
+// entfernt) laesst den Vertragstest fehlschlagen.
+func TestContract_API01_DetectsBreakingChange_RemovedField(t *testing.T) {
+	brokenResponse := []byte(`{"error":{"code":"unauthenticated"}}`) // "message" fehlt absichtlich
+	var decoded map[string]json.RawMessage
+	if err := json.Unmarshal(brokenResponse, &decoded); err != nil {
+		t.Fatalf("fixture nicht lesbar: %v", err)
+	}
+	missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "message" {
+		t.Fatalf("erwartet erkanntes fehlendes feld 'message', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 2: API-05 JWKS / Rechte-Cache-Kontrakt ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API05_JWKS(t *testing.T) {
+	km, err := moduletrust.NewKeyManager()
+	if err != nil {
+		t.Fatalf("keymanager: %v", err)
+	}
+	if _, err := km.Rotate(); err != nil {
+		t.Fatalf("rotate: %v", err)
+	}
+
+	rec := httptest.NewRecorder()
+	km.ServeJWKS(rec, httptest.NewRequest(http.MethodGet, "/jwks", nil))
+
+	missing, err := RequireJSONArrayItemFields(rec.Body.Bytes(), "keys", []string{"kid", "public_key"})
+	if err != nil {
+		t.Fatalf("jwks-antwort verletzt vertrag: %v", err)
+	}
+	if len(missing) != 0 {
+		t.Fatalf("jwks-eintrag fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — Feld "public_key" umbenannt
+// (z.B. faelschlich zu "publicKey"), Vertragstest erkennt das fehlende
+// Originalfeld zuverlaessig.
+func TestContract_API05_DetectsBreakingChange_RenamedField(t *testing.T) {
+	brokenJWKS := []byte(`{"keys":[{"kid":"abc","publicKey":"base64..."}]}`)
+	missing, err := RequireJSONArrayItemFields(brokenJWKS, "keys", []string{"kid", "public_key"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "public_key" {
+		t.Fatalf("erwartet erkanntes umbenanntes feld 'public_key', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 3: API-02 Modul-Registry ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func setupModuleRegistryTest(t *testing.T) (*moduleregistry.Registry, 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()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
+	return moduleregistry.NewRegistry(pool, flagService), func() { pool.Close() }
+}
+
+func TestContract_API02_ModuleInfo(t *testing.T) {
+	registry, cleanup := setupModuleRegistryTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	m, err := registry.Register(ctx, "contracttest-dms", "1.0.0", []string{"some-flag"})
+	if err != nil {
+		t.Fatalf("register: %v", err)
+	}
+
+	data, err := json.Marshal(m)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	missing, err := RequireJSONFields(data, []string{"Name", "Version", "RequiredFlags"})
+	if err != nil {
+		t.Fatalf("modul-antwort nicht lesbar: %v", err)
+	}
+	if len(missing) != 0 {
+		t.Fatalf("modul-info fehlen pflichtfelder: %v", missing)
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — Feld "RequiredFlags" entfernt.
+func TestContract_API02_DetectsBreakingChange_RemovedField(t *testing.T) {
+	brokenModuleJSON := []byte(`{"Name":"dms","Version":"1.0.0"}`)
+	missing, err := RequireJSONFields(brokenModuleJSON, []string{"Name", "Version", "RequiredFlags"})
+	if err != nil {
+		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
+	}
+	if len(missing) != 1 || missing[0] != "RequiredFlags" {
+		t.Fatalf("erwartet erkanntes fehlendes feld 'RequiredFlags', habe: %v", missing)
+	}
+}
+
+// --- Vertrag 4: API-07 Webhook-Zustellung (HMAC-Signaturheader) ---
+// Akzeptanzkriterium 1/2 + Pruefung 1/2.
+
+func TestContract_API07_WebhookSignatureHeader(t *testing.T) {
+	if webhook.SignatureHeader != "X-Nexarch-Signature-256" {
+		t.Fatalf("signaturheader-name = %q, want stabilen vertrag 'X-Nexarch-Signature-256' — konsumierende module lesen genau diesen namen", webhook.SignatureHeader)
+	}
+
+	secret := "vertragstest-secret"
+	payload := []byte(`{"event":"test"}`)
+	signature := webhook.Sign(secret, payload)
+
+	if !webhook.VerifySignature(secret, payload, signature) {
+		t.Fatal("konsumentenseitige signaturpruefung schlaegt fuer eine korrekte core-signatur fehl")
+	}
+}
+
+// Pruefung 2: simulierter Breaking Change — eine Zustellung, die den
+// Signaturheader unter einem ANDEREN Namen sendet (wie es ein
+// hypothetischer, den Vertrag brechender Core-Umbau taete). Ein
+// konsumierendes Modul, das nach dem DOKUMENTIERTEN Namen sucht, findet in
+// diesem Fall nichts — der Vertragstest erkennt das zuverlaessig.
+func TestContract_API07_DetectsBreakingChange_RenamedHeader(t *testing.T) {
+	brokenHeaders := http.Header{}
+	brokenHeaders.Set("X-Signature", webhook.Sign("secret", []byte("payload"))) // falscher name, simuliert breaking change
+
+	if got := brokenHeaders.Get(webhook.SignatureHeader); got != "" {
+		t.Fatalf("erwartet leeren wert unter dem dokumentierten headernamen bei simuliertem breaking change, habe: %q", got)
+	}
+}

internal/health/checks.go

@@ -1,25 +0,0 @@
-package health
-
-import (
-	"context"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// DatabaseChecker prueft die tatsaechliche Erreichbarkeit der Datenbank
-// (Ping) — nicht nur, ob der Pool existiert.
-func DatabaseChecker(pool *pgxpool.Pool) CheckerFunc {
-	return func(ctx context.Context) error {
-		return pool.Ping(ctx)
-	}
-}
-
-// QueueChecker prueft, dass die Postgres-basierte Job-Queue (siehe CFG-02)
-// tatsaechlich abfragbar ist — eine eigene, benannte Abhaengigkeit neben der
-// reinen DB-Erreichbarkeit (Akzeptanzkriterium 1).
-func QueueChecker(pool *pgxpool.Pool) CheckerFunc {
-	return func(ctx context.Context) error {
-		_, err := pool.Exec(ctx, `SELECT 1`)
-		return err
-	}
-}

internal/health/handler.go

@@ -1,49 +0,0 @@
-package health
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// LivenessHandler beantwortet IMMER "lebt", solange der Prozess ueberhaupt
-// HTTP-Anfragen verarbeiten kann — prueft bewusst KEINE externen
-// Abhaengigkeiten (Akzeptanzkriterium 2: Liveness und Readiness getrennt).
-// Ein Datenbankausfall darf die Liveness nicht auf "tot" setzen, sonst
-// wuerde eine Orchestrierung (z.B. systemd/Kubernetes) den Prozess grundlos
-// neu starten, obwohl nur eine Abhaengigkeit ausgefallen ist.
-func LivenessHandler(w http.ResponseWriter, r *http.Request) {
-	writeStatus(w, http.StatusOK, map[string]any{"status": "alive"})
-}
-
-// ReadinessHandler prueft ALLE registrierten Abhaengigkeiten
-// (Akzeptanzkriterium 1) und liefert 503, sobald eine davon fehlschlaegt
-// (Akzeptanzkriterium 3) — unterscheidet sich damit nachweislich von
-// LivenessHandler im Fehlerfall (Akzeptanzkriterium 2 / Pruefung 3).
-func (r *Registry) ReadinessHandler() http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		ready, results := r.CheckAll(req.Context())
-
-		body := map[string]any{
-			"status": statusText(ready),
-			"checks": results,
-		}
-		status := http.StatusOK
-		if !ready {
-			status = http.StatusServiceUnavailable
-		}
-		writeStatus(w, status, body)
-	}
-}
-
-func statusText(ready bool) string {
-	if ready {
-		return "ready"
-	}
-	return "not_ready"
-}
-
-func writeStatus(w http.ResponseWriter, status int, body map[string]any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(body)
-}

internal/health/health.go

@@ -1,86 +0,0 @@
-// Package health implementiert Core OPS-01: Health-/Readiness-Endpunkte, die
-// echte Abhaengigkeiten (DB, Job-Queue) statt nur den Prozessstatus pruefen
-// — wiederverwendbar von Core UND jedem registrierten Modul (siehe API-02),
-// nicht nur von Core selbst.
-package health
-
-import (
-	"context"
-	"time"
-)
-
-// Checker prueft EINE Abhaengigkeit (z.B. Datenbank, Job-Queue).
-type Checker interface {
-	Check(ctx context.Context) error
-}
-
-type CheckerFunc func(ctx context.Context) error
-
-func (f CheckerFunc) Check(ctx context.Context) error { return f(ctx) }
-
-// DefaultCheckTimeout begrenzt, wie lange EIN einzelner Check maximal
-// dauern darf, bevor er als fehlgeschlagen gilt — verhindert, dass ein
-// haengender Check den gesamten Readiness-Endpunkt blockiert
-// (Akzeptanzkriterium 2 / Pruefung 2: Antwort innerhalb definierter Zeit).
-const DefaultCheckTimeout = 2 * time.Second
-
-// Registry haelt alle benannten Checks eines Dienstes.
-type Registry struct {
-	checks  map[string]Checker
-	timeout time.Duration
-}
-
-func NewRegistry() *Registry {
-	return &Registry{checks: make(map[string]Checker), timeout: DefaultCheckTimeout}
-}
-
-func (r *Registry) WithTimeout(d time.Duration) *Registry {
-	return &Registry{checks: r.checks, timeout: d}
-}
-
-// Register fuegt einen benannten Check hinzu (z.B. "database", "queue").
-func (r *Registry) Register(name string, c Checker) {
-	r.checks[name] = c
-}
-
-// Result ist der Ausgang eines einzelnen Checks.
-type Result struct {
-	OK    bool
-	Error string
-}
-
-// CheckAll fuehrt alle registrierten Checks NEBENLAEUFIG mit je eigenem
-// Timeout aus (Akzeptanzkriterium 1: echte Abhaengigkeiten statt Prozess-
-// status) und liefert ready=false, sobald irgendein Check fehlschlaegt
-// (Akzeptanzkriterium 3: ein Ausfall wird sichtbar).
-func (r *Registry) CheckAll(ctx context.Context) (ready bool, results map[string]Result) {
-	type namedResult struct {
-		name   string
-		result Result
-	}
-	ch := make(chan namedResult, len(r.checks))
-
-	for name, checker := range r.checks {
-		go func(name string, checker Checker) {
-			checkCtx, cancel := context.WithTimeout(ctx, r.timeout)
-			defer cancel()
-			err := checker.Check(checkCtx)
-			if err != nil {
-				ch <- namedResult{name, Result{OK: false, Error: err.Error()}}
-				return
-			}
-			ch <- namedResult{name, Result{OK: true}}
-		}(name, checker)
-	}
-
-	results = make(map[string]Result, len(r.checks))
-	ready = true
-	for i := 0; i < len(r.checks); i++ {
-		nr := <-ch
-		results[nr.name] = nr.result
-		if !nr.result.OK {
-			ready = false
-		}
-	}
-	return ready, results
-}

internal/health/health_test.go

@@ -1,161 +0,0 @@
-package health
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Akzeptanzkriterium 1 + Pruefung 1: simulierter Datenbankausfall fuehrt zu
-// "nicht bereit".
-func TestReadinessHandler_ReportsNotReadyOnDatabaseFailure(t *testing.T) {
-	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)
-	}
-	// Datenbankausfall simulieren: Pool sofort schliessen, bevor der Check laeuft.
-	pool.Close()
-
-	reg := NewRegistry()
-	reg.Register("database", DatabaseChecker(pool))
-
-	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
-	rec := httptest.NewRecorder()
-	reg.ReadinessHandler()(rec, req)
-
-	if rec.Code != http.StatusServiceUnavailable {
-		t.Fatalf("status = %d, want 503 bei db-ausfall", rec.Code)
-	}
-
-	var body struct {
-		Status string                 `json:"status"`
-		Checks map[string]interface{} `json:"checks"`
-	}
-	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
-		t.Fatalf("body parsen: %v", err)
-	}
-	if body.Status != "not_ready" {
-		t.Fatalf("status-feld = %q, want not_ready", body.Status)
-	}
-	if _, ok := body.Checks["database"]; !ok {
-		t.Fatal("erwartet 'database' im checks-ergebnis")
-	}
-}
-
-func TestReadinessHandler_ReportsReadyWhenAllChecksPass(t *testing.T) {
-	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)
-	}
-	defer pool.Close()
-
-	reg := NewRegistry()
-	reg.Register("database", DatabaseChecker(pool))
-	reg.Register("queue", QueueChecker(pool))
-
-	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
-	rec := httptest.NewRecorder()
-	reg.ReadinessHandler()(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200 bei funktionierenden abhaengigkeiten", rec.Code)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 3: Liveness und Readiness unterscheiden
-// sich nachweislich im Fehlerfall.
-func TestLivenessAndReadiness_DifferOnDatabaseFailure(t *testing.T) {
-	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)
-	}
-	pool.Close() // db-ausfall simulieren
-
-	reg := NewRegistry()
-	reg.Register("database", DatabaseChecker(pool))
-
-	livenessRec := httptest.NewRecorder()
-	LivenessHandler(livenessRec, httptest.NewRequest(http.MethodGet, "/livez", nil))
-	if livenessRec.Code != http.StatusOK {
-		t.Fatalf("liveness status = %d, want 200 trotz db-ausfall (liveness prueft keine abhaengigkeiten)", livenessRec.Code)
-	}
-
-	readinessRec := httptest.NewRecorder()
-	reg.ReadinessHandler()(readinessRec, httptest.NewRequest(http.MethodGet, "/readyz", nil))
-	if readinessRec.Code != http.StatusServiceUnavailable {
-		t.Fatalf("readiness status = %d, want 503 bei db-ausfall", readinessRec.Code)
-	}
-
-	if livenessRec.Code == readinessRec.Code {
-		t.Fatal("liveness und readiness sollten sich im db-ausfall-fall unterscheiden")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: Health-Endpunkt antwortet auch bei
-// haengendem Check innerhalb definierter Zeit (Timeout begrenzt die Dauer).
-func TestReadinessHandler_RespondsWithinTimeoutEvenWithHangingCheck(t *testing.T) {
-	reg := NewRegistry().WithTimeout(50 * time.Millisecond)
-	reg.Register("haengender_dienst", CheckerFunc(func(ctx context.Context) error {
-		select {
-		case <-time.After(10 * time.Second): // wuerde ohne timeout ewig blockieren
-			return nil
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}))
-
-	start := time.Now()
-	req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
-	rec := httptest.NewRecorder()
-	reg.ReadinessHandler()(rec, req)
-	elapsed := time.Since(start)
-
-	if elapsed > time.Second {
-		t.Fatalf("readiness handler brauchte %s, erwartet deutlich unter 1s durch timeout", elapsed)
-	}
-	if rec.Code != http.StatusServiceUnavailable {
-		t.Fatalf("status = %d, want 503 fuer haengenden/timeout-check", rec.Code)
-	}
-}
-
-func TestCheckAll_MultipleChecksRunConcurrently(t *testing.T) {
-	reg := NewRegistry().WithTimeout(time.Second)
-	reg.Register("a", CheckerFunc(func(ctx context.Context) error { return nil }))
-	reg.Register("b", CheckerFunc(func(ctx context.Context) error { return errors.New("kaputt") }))
-
-	ready, results := reg.CheckAll(context.Background())
-	if ready {
-		t.Fatal("erwartet ready=false, da 'b' fehlschlaegt")
-	}
-	if !results["a"].OK {
-		t.Fatalf("erwartet 'a' ok, habe %+v", results["a"])
-	}
-	if results["b"].OK || results["b"].Error == "" {
-		t.Fatalf("erwartet 'b' fehlgeschlagen mit fehlertext, habe %+v", results["b"])
-	}
-}

internal/metrics/core.go

@@ -1,19 +0,0 @@
-package metrics
-
-import "github.com/prometheus/client_golang/prometheus"
-
-// NewCoreRegistry liefert das Prometheus-Registry fuer die EIGENEN
-// Kennzahlen des Core-Dienstes (Akzeptanzkriterium 1) — alle Namen tragen
-// das Praefix "nexarch_core_" gemaess der im Paketkommentar dokumentierten
-// Namenskonvention (Akzeptanzkriterium 3). Ein eigenes Registry statt des
-// globalen DefaultRegisterer, damit Tests unabhaengig voneinander sind.
-func NewCoreRegistry() *prometheus.Registry {
-	reg := prometheus.NewRegistry()
-	reg.MustRegister(
-		prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-			Name: "nexarch_core_up",
-			Help: "1, solange der Core-Dienst laeuft und Metriken liefern kann.",
-		}, func() float64 { return 1 }),
-	)
-	return reg
-}

internal/metrics/metrics.go

@@ -1,168 +0,0 @@
-// Package metrics implementiert Core OPS-03: einen zentralen /metrics-
-// Endpunkt im Prometheus-Textformat, der Kennzahlen des Core-Dienstes UND
-// aggregierte Kennzahlen aller registrierten Module bereitstellt — offenes
-// Pull-Modell nach Prometheus-Vorbild, kein proprietaerer Push-Mechanismus.
-//
-// Namenskonvention (Akzeptanzkriterium 3, modulübergreifend konsistent):
-//
-//	nexarch_core_<name>            — Kennzahlen des Core-Dienstes selbst
-//	nexarch_module_<modul>_<name>  — von einem Modul gescrapte Kennzahl
-//	                                  <name>, umbenannt mit dem
-//	                                  Modulnamen als Praefix
-//
-// Ein Modul liefert seine eigenen Kennzahlen unter EIGENEM Namen (z.B.
-// "requests_total") unter seinem eigenen /metrics-Endpunkt — dieses Paket
-// benennt sie beim Einsammeln konsistent um, damit im aggregierten Core-
-// Endpunkt niemals zwei Module denselben Metrik-Namen kollidieren lassen.
-package metrics
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/prometheus/common/expfmt"
-	"github.com/prometheus/common/model"
-)
-
-// init erzwingt das klassische Prometheus-Namensschema (a-z, A-Z, 0-9, _)
-// fuer die Namensvalidierung von expfmt/model — ohne diese explizite
-// Festlegung liefert die Bibliothek "Invalid name validation scheme
-// requested: unset" beim Parsen/Kodieren, da sie den globalen Default in
-// dieser Version nicht mehr implizit setzt.
-func init() {
-	model.NameValidationScheme = model.LegacyValidation
-}
-
-// Source ist EIN registriertes Modul mit seinem eigenen /metrics-Endpunkt
-// (siehe internal/health fuer das analoge Muster bei Readiness-Checks).
-type Source struct {
-	ModuleName string
-	MetricsURL string
-}
-
-// SourceProvider liefert die aktuell registrierten Module — typischerweise
-// rueckgebunden an internal/moduleregistry.Registry.List (API-02) ueber
-// einen kleinen Adapter im aufrufenden Code, damit dieses Paket
-// internal/moduleregistry nicht direkt importieren muss (Kein Umbau
-// angrenzender Bereiche). Ein NEU registriertes Modul erscheint automatisch
-// beim naechsten Aufruf von Aggregator.Handler, OHNE Codeaenderung an diesem
-// Paket (Akzeptanzkriterium 2 / Pruefung 2).
-type SourceProvider func(ctx context.Context) ([]Source, error)
-
-// FetchTimeout begrenzt, wie lange EIN Modul-Scrape maximal dauern darf —
-// ein haengendes Modul darf den gesamten Aggregations-Request nicht
-// verzoegern (Pruefung 1: Antwort unter Last innerhalb definierter Zeit).
-const FetchTimeout = 2 * time.Second
-
-// Aggregator sammelt Core-eigene Metriken (coreGatherer) und die Metriken
-// aller ueber sourceProvider gemeldeten Module in EINER Antwort ein.
-type Aggregator struct {
-	coreGatherer   prometheus.Gatherer
-	sourceProvider SourceProvider
-	client         *http.Client
-}
-
-func NewAggregator(coreGatherer prometheus.Gatherer, sourceProvider SourceProvider) *Aggregator {
-	return &Aggregator{
-		coreGatherer:   coreGatherer,
-		sourceProvider: sourceProvider,
-		client:         &http.Client{Timeout: FetchTimeout},
-	}
-}
-
-// Gather implementiert prometheus.Gatherer: liefert Core-Metriken PLUS alle
-// erreichbaren Modul-Metriken (umbenannt gemaess Namenskonvention) in einer
-// gemeinsamen Liste von MetricFamilies.
-func (a *Aggregator) Gather(ctx context.Context) ([]*dto.MetricFamily, error) {
-	families, err := a.coreGatherer.Gather()
-	if err != nil {
-		return nil, fmt.Errorf("core-metriken einsammeln: %w", err)
-	}
-
-	sources, err := a.sourceProvider(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("modul-quellen ermitteln: %w", err)
-	}
-
-	// Module werden NEBENLAEUFIG gescrapt (dasselbe Muster wie
-	// internal/health.Registry.CheckAll) — ein langsames/nicht erreichbares
-	// Modul haelt weder andere Module noch den Gesamt-Request auf.
-	type fetchResult struct {
-		families []*dto.MetricFamily
-	}
-	resultCh := make(chan fetchResult, len(sources))
-	for _, src := range sources {
-		go func(src Source) {
-			fetchCtx, cancel := context.WithTimeout(ctx, FetchTimeout)
-			defer cancel()
-			mf, err := a.fetchAndRename(fetchCtx, src)
-			if err != nil {
-				resultCh <- fetchResult{} // Fehlerfall: einfach nichts beitragen, Aggregation laeuft weiter
-				return
-			}
-			resultCh <- fetchResult{families: mf}
-		}(src)
-	}
-	for range sources {
-		r := <-resultCh
-		families = append(families, r.families...)
-	}
-
-	return families, nil
-}
-
-// fetchAndRename ruft die /metrics-URL eines Moduls ab, parst das
-// Prometheus-Textformat und benennt jede Metrik gemaess der
-// Namenskonvention um (Akzeptanzkriterium 2 + 3).
-func (a *Aggregator) fetchAndRename(ctx context.Context, src Source) ([]*dto.MetricFamily, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, src.MetricsURL, nil)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := a.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("modul %s: unerwarteter status %d", src.ModuleName, resp.StatusCode)
-	}
-
-	parser := expfmt.NewTextParser(model.LegacyValidation)
-	parsed, err := parser.TextToMetricFamilies(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("modul %s: metrik-text nicht parsebar: %w", src.ModuleName, err)
-	}
-
-	out := make([]*dto.MetricFamily, 0, len(parsed))
-	for name, mf := range parsed {
-		renamed := fmt.Sprintf("nexarch_module_%s_%s", src.ModuleName, name)
-		mf.Name = &renamed
-		out = append(out, mf)
-	}
-	return out, nil
-}
-
-// Handler liefert einen HTTP-Handler, der Gather aufruft und das Ergebnis im
-// Prometheus-Textformat ausgibt (Akzeptanzkriterium 1).
-func (a *Aggregator) Handler() http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		families, err := a.Gather(r.Context())
-		if err != nil {
-			http.Error(w, "metriken konnten nicht eingesammelt werden", http.StatusInternalServerError)
-			return
-		}
-
-		w.Header().Set("Content-Type", string(expfmt.NewFormat(expfmt.TypeTextPlain)))
-		enc := expfmt.NewEncoder(w, expfmt.NewFormat(expfmt.TypeTextPlain))
-		for _, mf := range families {
-			if err := enc.Encode(mf); err != nil {
-				return
-			}
-		}
-	}
-}

internal/metrics/metrics_test.go

@@ -1,179 +0,0 @@
-package metrics
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/prometheus/common/expfmt"
-	"github.com/prometheus/common/model"
-)
-
-func fakeModuleServer(metricName string) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "text/plain; version=0.0.4")
-		fmt.Fprintf(w, "# HELP %s ein test-zaehler\n# TYPE %s counter\n%s 42\n", metricName, metricName, metricName)
-	}))
-}
-
-// Akzeptanzkriterium 1: Core liefert unter dem Handler valides
-// Prometheus-Textformat mit den eigenen Kennzahlen.
-func TestHandler_ServesCoreMetricsInPrometheusFormat(t *testing.T) {
-	agg := NewAggregator(NewCoreRegistry(), func(ctx context.Context) ([]Source, error) { return nil, nil })
-
-	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
-	rec := httptest.NewRecorder()
-	agg.Handler()(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200", rec.Code)
-	}
-
-	parser := expfmt.NewTextParser(model.LegacyValidation)
-	families, err := parser.TextToMetricFamilies(strings.NewReader(rec.Body.String()))
-	if err != nil {
-		t.Fatalf("antwort ist kein valides prometheus-textformat: %v", err)
-	}
-	if _, ok := families["nexarch_core_up"]; !ok {
-		t.Fatalf("erwartet 'nexarch_core_up' unter den core-metriken, habe: %v", keysOf(families))
-	}
-}
-
-func keysOf[V any](m map[string]V) []string {
-	out := make([]string, 0, len(m))
-	for k := range m {
-		out = append(out, k)
-	}
-	return out
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: ein NEU registriertes Modul erscheint
-// in der Aggregation, OHNE dass dieses Paket oder der Aufrufer Code
-// aendern muss — die Quelle kommt ausschliesslich aus sourceProvider.
-func TestHandler_NewlyRegisteredModuleAppearsWithoutCodeChange(t *testing.T) {
-	moduleServer := fakeModuleServer("requests_total")
-	defer moduleServer.Close()
-
-	// Simuliert eine sich zur Laufzeit aendernde Modul-Liste (z.B. aus
-	// SourceStore.Provide) — zunaechst LEER, dann mit einem Eintrag.
-	var sources []Source
-	var mu sync.Mutex
-	provider := func(ctx context.Context) ([]Source, error) {
-		mu.Lock()
-		defer mu.Unlock()
-		out := make([]Source, len(sources))
-		copy(out, sources)
-		return out, nil
-	}
-
-	agg := NewAggregator(NewCoreRegistry(), provider)
-
-	// Vor der Registrierung: Modul-Metrik nicht vorhanden.
-	rec1 := httptest.NewRecorder()
-	agg.Handler()(rec1, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-	if strings.Contains(rec1.Body.String(), "requests_total") {
-		t.Fatal("modul-metrik haette vor registrierung nicht erscheinen duerfen")
-	}
-
-	// Modul wird "registriert" (kein Code hier oder in metrics.go aendert sich).
-	mu.Lock()
-	sources = append(sources, Source{ModuleName: "dms", MetricsURL: moduleServer.URL})
-	mu.Unlock()
-
-	rec2 := httptest.NewRecorder()
-	agg.Handler()(rec2, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-	body := rec2.Body.String()
-	if !strings.Contains(body, "nexarch_module_dms_requests_total") {
-		t.Fatalf("erwartet umbenannte modul-metrik 'nexarch_module_dms_requests_total' nach registrierung, body:\n%s", body)
-	}
-}
-
-// Akzeptanzkriterium 3: Namenskonvention "nexarch_module_<modul>_<name>"
-// wird tatsaechlich angewendet.
-func TestFetchAndRename_AppliesNamingConvention(t *testing.T) {
-	moduleServer := fakeModuleServer("queue_depth")
-	defer moduleServer.Close()
-
-	agg := NewAggregator(NewCoreRegistry(), nil)
-	families, err := agg.fetchAndRename(context.Background(), Source{ModuleName: "mail", MetricsURL: moduleServer.URL})
-	if err != nil {
-		t.Fatalf("fetchAndRename: %v", err)
-	}
-	if len(families) != 1 || families[0].GetName() != "nexarch_module_mail_queue_depth" {
-		t.Fatalf("erwartet genau 1 metrik 'nexarch_module_mail_queue_depth', habe: %+v", families)
-	}
-}
-
-// Ein nicht erreichbares Modul darf die Aggregation der uebrigen und die
-// Gesamtantwort nicht verhindern (dieselbe Resilienz wie OPS-02).
-func TestHandler_UnreachableModuleDoesNotBreakAggregation(t *testing.T) {
-	reachable := fakeModuleServer("healthy_metric")
-	defer reachable.Close()
-	unreachable := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
-	unreachableURL := unreachable.URL
-	unreachable.Close() // sofort schliessen -> Verbindung schlaegt fehl
-
-	provider := func(ctx context.Context) ([]Source, error) {
-		return []Source{
-			{ModuleName: "ok", MetricsURL: reachable.URL},
-			{ModuleName: "kaputt", MetricsURL: unreachableURL},
-		}, nil
-	}
-	agg := NewAggregator(NewCoreRegistry(), provider)
-
-	rec := httptest.NewRecorder()
-	agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("status = %d, want 200 trotz einem nicht erreichbaren modul", rec.Code)
-	}
-	body := rec.Body.String()
-	if !strings.Contains(body, "nexarch_module_ok_healthy_metric") {
-		t.Fatal("erreichbares modul haette trotz ausfall des anderen aggregiert werden sollen")
-	}
-	if strings.Contains(body, "kaputt") {
-		t.Fatal("nicht erreichbares modul haette keine metrik beitragen duerfen")
-	}
-}
-
-// Pruefung 1: Endpunkt antwortet unter mehreren gleichzeitigen Anfragen
-// innerhalb definierter Zeit — kein unbeschraenktes Blockieren durch
-// langsame Module (FetchTimeout begrenzt jeden Scrape).
-func TestHandler_RespondsWithinBoundedTimeUnderLoad(t *testing.T) {
-	hangingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		time.Sleep(10 * time.Second) // wuerde ohne timeout jede anfrage blockieren
-	}))
-	defer hangingServer.Close()
-
-	provider := func(ctx context.Context) ([]Source, error) {
-		return []Source{{ModuleName: "haengend", MetricsURL: hangingServer.URL}}, nil
-	}
-	agg := NewAggregator(NewCoreRegistry(), provider)
-
-	const concurrentRequests = 10
-	var wg sync.WaitGroup
-	start := time.Now()
-	for i := 0; i < concurrentRequests; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			rec := httptest.NewRecorder()
-			agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-			if rec.Code != http.StatusOK {
-				t.Errorf("status = %d, want 200", rec.Code)
-			}
-		}()
-	}
-	wg.Wait()
-	elapsed := time.Since(start)
-
-	if elapsed > FetchTimeout+3*time.Second {
-		t.Fatalf("%d gleichzeitige anfragen brauchten %s, erwartet deutlich unter %s durch FetchTimeout",
-			concurrentRequests, elapsed, FetchTimeout+3*time.Second)
-	}
-}

internal/metrics/sources.go

@@ -1,52 +0,0 @@
-package metrics
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// SourceStore persistiert, welche Module ihre Metriken unter welcher URL
-// bereitstellen — dieselbe Postgres-basierte "kein Code-Deploy noetig"-
-// Konvention wie internal/statuspage.Store.RegisterTarget (OPS-02): ein neu
-// registriertes Modul erscheint automatisch in der Aggregation, sobald es
-// hier eingetragen ist (Akzeptanzkriterium 2 / Pruefung 2).
-type SourceStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewSourceStore(pool *pgxpool.Pool) *SourceStore {
-	return &SourceStore{pool: pool}
-}
-
-func (s *SourceStore) RegisterSource(ctx context.Context, moduleName, metricsURL string) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO metrics_sources (module_name, metrics_url)
-		VALUES ($1, $2)
-		ON CONFLICT (module_name) DO UPDATE SET metrics_url = $2
-	`, moduleName, metricsURL)
-	if err != nil {
-		return fmt.Errorf("metrik-quelle speichern: %w", err)
-	}
-	return nil
-}
-
-// Provide implementiert SourceProvider direkt aus der Datenbank.
-func (s *SourceStore) Provide(ctx context.Context) ([]Source, error) {
-	rows, err := s.pool.Query(ctx, `SELECT module_name, metrics_url FROM metrics_sources ORDER BY module_name`)
-	if err != nil {
-		return nil, fmt.Errorf("metrik-quellen auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Source
-	for rows.Next() {
-		var src Source
-		if err := rows.Scan(&src.ModuleName, &src.MetricsURL); err != nil {
-			return nil, fmt.Errorf("metrik-quelle lesen: %w", err)
-		}
-		out = append(out, src)
-	}
-	return out, rows.Err()
-}

internal/metrics/sources_test.go

@@ -1,60 +0,0 @@
-package metrics
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupSourceStoreTest(t *testing.T) (*SourceStore, 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 metrics_sources (module_name TEXT PRIMARY KEY, metrics_url TEXT NOT NULL)
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-	cleanup := func() { pool.Close() }
-	return NewSourceStore(pool), cleanup
-}
-
-// Akzeptanzkriterium 2 / Pruefung 2 auf Persistenz-Ebene: eine ueber die
-// Datenbank registrierte Quelle ist sofort ueber Provide() sichtbar — genau
-// der Mechanismus, der ein neues Modul ohne Core-Codeaenderung erscheinen
-// laesst.
-func TestSourceStore_RegisterSourceAppearsInProvide(t *testing.T) {
-	store, cleanup := setupSourceStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := fmt.Sprintf("modul-%d", time.Now().UnixNano())
-
-	if err := store.RegisterSource(ctx, name, "http://example.invalid/metrics"); err != nil {
-		t.Fatalf("registersource: %v", err)
-	}
-
-	sources, err := store.Provide(ctx)
-	if err != nil {
-		t.Fatalf("provide: %v", err)
-	}
-	found := false
-	for _, s := range sources {
-		if s.ModuleName == name {
-			found = true
-		}
-	}
-	if !found {
-		t.Fatalf("erwartet %s in provide()-ergebnis, habe: %+v", name, sources)
-	}
-}

internal/moduletrust/cache.go

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

internal/moduletrust/issuer.go

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

internal/moduletrust/keys.go

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

internal/moduletrust/moduletrust_test.go

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

internal/moduletrust/verifier.go

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

internal/user/handler.go

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

internal/user/store_test.go

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

internal/user/superadmin_store.go

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

internal/user/tenant_store.go

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

internal/user/user.go

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

internal/user/user_test.go

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

internal/webhook/dispatcher.go

@@ -0,0 +1,177 @@
+package webhook
+
+import (
+	"bytes"
+	"context"
+	"crypto/subtle"
+	"encoding/hex"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// DefaultMaxAttempts ist die konfigurierbare Obergrenze, ab der eine
+// Zustellung endgueltig als fehlgeschlagen gilt (Akzeptanzkriterium 2).
+const DefaultMaxAttempts = 5
+
+// DefaultBaseBackoff ist die Basisdauer fuer exponentielles Backoff:
+// naechster Versuch nach BaseBackoff * 2^attempt (Akzeptanzkriterium 2).
+const DefaultBaseBackoff = 2 * time.Second
+
+// Dispatcher liefert faellige Zustellungen aus. Konfigurierbar in Tests
+// (kleine BaseBackoff, kleine MaxAttempts), damit Retry/Backoff/Obergrenze
+// ohne minutenlange Wartezeit real durchlaufen werden koennen.
+type Dispatcher struct {
+	pool        pgxIface
+	client      *http.Client
+	MaxAttempts int
+	BaseBackoff time.Duration
+}
+
+// pgxIface ist die schmale Teilmenge von *pgxpool.Pool, die der Dispatcher
+// braucht — als Interface, damit Tests keine echte Verbindung fuer reine
+// Signatur-/Backoff-Logik brauchen (wird hier aber durchgehend mit echten
+// Integrationstests gegen Postgres verwendet, siehe dispatcher_test.go).
+type pgxIface interface {
+	Begin(ctx context.Context) (pgx.Tx, error)
+}
+
+func NewDispatcher(pool pgxIface, client *http.Client) *Dispatcher {
+	if client == nil {
+		client = &http.Client{Timeout: 5 * time.Second}
+	}
+	return &Dispatcher{pool: pool, client: client, MaxAttempts: DefaultMaxAttempts, BaseBackoff: DefaultBaseBackoff}
+}
+
+// backoffFor berechnet die Wartezeit vor dem naechsten Versuch: exponentiell
+// wachsend mit der Anzahl bereits unternommener Versuche.
+func (d *Dispatcher) backoffFor(attempt int) time.Duration {
+	return d.BaseBackoff * time.Duration(1<<uint(attempt))
+}
+
+// ProcessDue liefert ALLE derzeit faelligen Zustellungen aus — dasselbe
+// SELECT ... FOR UPDATE SKIP LOCKED-Muster wie
+// internal/tenant.Lifecycle.ProcessDueDeletions, damit mehrere Dispatcher-
+// Instanzen dieselbe Zustellung nie doppelt bearbeiten.
+func (d *Dispatcher) ProcessDue(ctx context.Context) (int, error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT wd.id, wd.payload, wd.attempt, ws.target_url, ws.secret
+		FROM webhook_deliveries wd
+		JOIN webhook_subscriptions ws ON ws.id = wd.subscription_id
+		WHERE wd.status = $1 AND wd.next_attempt_at <= now()
+		FOR UPDATE OF wd SKIP LOCKED
+	`, StatusPending)
+	if err != nil {
+		return 0, fmt.Errorf("faellige zustellungen abfragen: %w", err)
+	}
+
+	var deliveries []delivery
+	for rows.Next() {
+		var del delivery
+		if err := rows.Scan(&del.ID, &del.Payload, &del.Attempt, &del.TargetURL, &del.Secret); err != nil {
+			rows.Close()
+			return 0, fmt.Errorf("zustellung lesen: %w", err)
+		}
+		deliveries = append(deliveries, del)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	for _, del := range deliveries {
+		d.attemptOne(ctx, tx, del)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return len(deliveries), nil
+}
+
+// attemptOne fuehrt GENAU EINEN Zustellversuch aus und aktualisiert den
+// Zustellungsdatensatz entsprechend — Erfolg (Akzeptanzkriterium 1/Pruefung
+// 1), erneuter Fehlversuch mit Backoff, oder endgueltiges Scheitern nach
+// DefaultMaxAttempts (Akzeptanzkriterium 2/Pruefung 2). Ein Fehler bei
+// GENAU EINER Zustellung darf die anderen in diesem Batch nicht verhindern.
+func (d *Dispatcher) attemptOne(ctx context.Context, tx pgx.Tx, del delivery) {
+	signature := Sign(del.Secret, del.Payload)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, del.TargetURL, bytes.NewReader(del.Payload))
+	deliveryErr := err
+	var statusCode int
+	if err == nil {
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set(SignatureHeader, signature)
+		resp, err := d.client.Do(req)
+		if err != nil {
+			deliveryErr = err
+		} else {
+			statusCode = resp.StatusCode
+			resp.Body.Close()
+			if statusCode < 200 || statusCode >= 300 {
+				deliveryErr = fmt.Errorf("unerwarteter statuscode %d", statusCode)
+			}
+		}
+	}
+
+	if deliveryErr == nil {
+		_, _ = tx.Exec(ctx, `
+			UPDATE webhook_deliveries SET status = $2, delivered_at = now(), attempt = attempt + 1
+			WHERE id = $1
+		`, del.ID, StatusDelivered)
+		return
+	}
+
+	nextAttempt := del.Attempt + 1
+	if nextAttempt >= d.MaxAttempts {
+		_, _ = tx.Exec(ctx, `
+			UPDATE webhook_deliveries SET status = $2, attempt = $3, last_error = $4
+			WHERE id = $1
+		`, del.ID, StatusFailed, nextAttempt, deliveryErr.Error())
+		return
+	}
+
+	nextAttemptAt := time.Now().Add(d.backoffFor(nextAttempt))
+	_, _ = tx.Exec(ctx, `
+		UPDATE webhook_deliveries SET attempt = $2, next_attempt_at = $3, last_error = $4
+		WHERE id = $1
+	`, del.ID, nextAttempt, nextAttemptAt, deliveryErr.Error())
+}
+
+// Run ruft ProcessDue in festen Abstaenden auf, bis ctx beendet wird —
+// dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
+func (d *Dispatcher) Run(ctx context.Context, interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			_, _ = d.ProcessDue(ctx)
+		}
+	}
+}
+
+// VerifySignature prueft empfaengerseitig, ob signature zu payload und
+// secret passt — timing-safe (dasselbe Muster wie internal/audit.timingsafe),
+// damit ein Empfaenger die Authentizitaet einer Zustellung pruefen kann
+// (Akzeptanzkriterium 3).
+func VerifySignature(secret string, payload []byte, signature string) bool {
+	expected := Sign(secret, payload)
+	expectedBytes, err1 := hex.DecodeString(expected)
+	gotBytes, err2 := hex.DecodeString(signature)
+	if err1 != nil || err2 != nil {
+		return false
+	}
+	return subtle.ConstantTimeCompare(expectedBytes, gotBytes) == 1
+}

internal/webhook/webhook.go

@@ -0,0 +1,131 @@
+// Package webhook implementiert Core API-07: eine zentrale Webhook-Registry
+// und Zustellungs-Engine fuer alle Fachmodule (DMS/Mail/Archive/Workflow/AI).
+// Module reichen Ereignisse EINMAL zur Zustellung ein und implementieren
+// selbst KEINE eigene Retry-/Signatur-Logik — das ist der zentrale Zweck
+// dieser Kachel ("Bewusst vermeiden: jedes Modul baut seine eigene
+// Webhook-Zustellungs-Engine"). Zustellung laeuft ueber dieselbe
+// Postgres-Jobqueue-Konvention (SELECT ... FOR UPDATE SKIP LOCKED) wie
+// internal/tenant.Lifecycle.ProcessDueDeletions (TEN-04) und
+// internal/notify.Dispatcher (CFG-02) — kein Redis/AMQP.
+package webhook
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+const (
+	StatusPending   = "pending"
+	StatusDelivered = "delivered"
+	StatusFailed    = "failed"
+)
+
+// Subscription ist EIN externer Abonnent fuer einen Ereignistyp
+// (Akzeptanzkriterium 1: Module registrieren Ereignistypen, externe
+// Abonnenten registrieren Ziel-URLs — dieses Paket modelliert die
+// Abonnenten-Seite; welche Ereignistypen ein Modul anbietet, ist bewusst
+// NICHT Teil dieser Kachel).
+type Subscription struct {
+	ID         string
+	EventType  string
+	TargetURL  string
+	Secret     string
+	CreatedAt  time.Time
+}
+
+// Store persistiert Abonnements und Zustellversuche.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Subscribe registriert einen Abonnenten fuer einen Ereignistyp. secret wird
+// spaeter zur HMAC-Signierung jeder Zustellung an diesen Abonnenten
+// verwendet (Akzeptanzkriterium 3).
+func (s *Store) Subscribe(ctx context.Context, eventType, targetURL, secret string) (Subscription, error) {
+	var sub Subscription
+	sub.EventType, sub.TargetURL, sub.Secret = eventType, targetURL, secret
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO webhook_subscriptions (event_type, target_url, secret)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at
+	`, eventType, targetURL, secret)
+	if err := row.Scan(&sub.ID, &sub.CreatedAt); err != nil {
+		return Subscription{}, fmt.Errorf("abonnement anlegen: %w", err)
+	}
+	return sub, nil
+}
+
+// Enqueue reicht EIN Ereignis zur Zustellung an ALLE Abonnenten des
+// angegebenen Ereignistyps ein — dies ist die EINZIGE Schnittstelle, die
+// ein Fachmodul braucht (Akzeptanzkriterium 1). Jeder Abonnent erhaelt
+// einen eigenen, unabhaengigen Zustellversuch-Datensatz.
+func (s *Store) Enqueue(ctx context.Context, eventType string, payload any) (int, error) {
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return 0, fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	rows, err := s.pool.Query(ctx, `
+		SELECT id FROM webhook_subscriptions WHERE event_type = $1
+	`, eventType)
+	if err != nil {
+		return 0, fmt.Errorf("abonnenten ermitteln: %w", err)
+	}
+	var subscriptionIDs []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			rows.Close()
+			return 0, fmt.Errorf("abonnent lesen: %w", err)
+		}
+		subscriptionIDs = append(subscriptionIDs, id)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	for _, subID := range subscriptionIDs {
+		if _, err := s.pool.Exec(ctx, `
+			INSERT INTO webhook_deliveries (subscription_id, event_type, payload, status, next_attempt_at)
+			VALUES ($1, $2, $3, $4, now())
+		`, subID, eventType, payloadJSON, StatusPending); err != nil {
+			return 0, fmt.Errorf("zustellung einreihen: %w", err)
+		}
+	}
+	return len(subscriptionIDs), nil
+}
+
+// delivery ist ein interner Datensatz fuer EINEN Zustellversuch, inklusive
+// der zugehoerigen Abonnentendaten (per JOIN geladen).
+type delivery struct {
+	ID        string
+	TargetURL string
+	Secret    string
+	Payload   []byte
+	Attempt   int
+}
+
+// Sign berechnet die HMAC-SHA256-Signatur des Payloads (Akzeptanzkriterium
+// 3) — hex-kodiert, damit sie problemlos als HTTP-Header uebertragen werden
+// kann.
+func Sign(secret string, payload []byte) string {
+	mac := hmac.New(sha256.New, []byte(secret))
+	mac.Write(payload)
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+// SignatureHeader ist der HTTP-Header, unter dem die Signatur uebertragen
+// wird — dokumentierter Vertrag fuer Empfaenger (Akzeptanzkriterium 3).
+const SignatureHeader = "X-Nexarch-Signature-256"

internal/webhook/webhook_test.go

@@ -0,0 +1,205 @@
+package webhook
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, *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 webhook_subscriptions (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), event_type TEXT NOT NULL,
+			target_url TEXT NOT NULL, secret TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS webhook_deliveries (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), subscription_id UUID NOT NULL REFERENCES webhook_subscriptions(id),
+			event_type TEXT NOT NULL, payload JSONB NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
+			attempt INT NOT NULL DEFAULT 0, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), delivered_at TIMESTAMPTZ
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewStore(pool), pool, cleanup
+}
+
+func uniqueEventType(prefix string) string {
+	return prefix + "-" + time.Now().Format("150405.000000000")
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein Modul reicht ein Ereignis ein
+// (Enqueue) ohne eigene Zustellungslogik, der zentrale Dispatcher liefert
+// zuverlaessig aus.
+func TestEnqueueAndProcessDue_DeliversSuccessfully(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	var receivedBody []byte
+	var receivedSignature string
+	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		receivedBody = body
+		receivedSignature = r.Header.Get(SignatureHeader)
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer target.Close()
+
+	eventType := uniqueEventType("dms.file.created")
+	sub, err := store.Subscribe(ctx, eventType, target.URL, "geheimes-secret")
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+
+	n, err := store.Enqueue(ctx, eventType, map[string]string{"file_id": "42"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if n != 1 {
+		t.Fatalf("erwartet 1 eingereihte zustellung, habe %d", n)
+	}
+
+	dispatcher := NewDispatcher(pool, target.Client())
+	processed, err := dispatcher.ProcessDue(ctx)
+	if err != nil {
+		t.Fatalf("processdue: %v", err)
+	}
+	if processed != 1 {
+		t.Fatalf("erwartet 1 verarbeitete zustellung, habe %d", processed)
+	}
+
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != StatusDelivered {
+		t.Fatalf("status = %q, want %q", status, StatusDelivered)
+	}
+
+	// Postgres' JSONB-Spalte kann die Byte-Repraesentation des Payloads
+	// gegenueber dem urspruenglichen json.Marshal kanonisieren (z.B.
+	// Leerzeichen) — das ist unschaedlich, denn der Dispatcher signiert
+	// IMMER exakt die Bytes, die er auch sendet. Die Pruefung vergleicht
+	// deshalb Signatur gegen tatsaechlich empfangene Bytes (Selbstkonsistenz),
+	// nicht gegen eine unabhaengig neu marshalte Referenz.
+	if !VerifySignature("geheimes-secret", receivedBody, receivedSignature) {
+		t.Fatalf("empfangene signatur %q passt nicht zum empfangenen payload %q", receivedSignature, receivedBody)
+	}
+	var decoded map[string]string
+	if err := json.Unmarshal(receivedBody, &decoded); err != nil {
+		t.Fatalf("empfangener payload nicht als json lesbar: %v", err)
+	}
+	if decoded["file_id"] != "42" {
+		t.Fatalf("empfangener payload = %v, want file_id=42", decoded)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: fehlschlagendes Ziel loest Retry mit
+// wachsendem Backoff aus und endet nach der konfigurierten Obergrenze in
+// "failed".
+func TestProcessDue_RetriesWithBackoffThenMarksFailed(t *testing.T) {
+	store, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	var callCount int32
+	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt32(&callCount, 1)
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer target.Close()
+
+	eventType := uniqueEventType("mail.send.failed")
+	sub, err := store.Subscribe(ctx, eventType, target.URL, "secret")
+	if err != nil {
+		t.Fatalf("subscribe: %v", err)
+	}
+	if _, err := store.Enqueue(ctx, eventType, map[string]string{"x": "y"}); err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	dispatcher := NewDispatcher(pool, target.Client())
+	dispatcher.MaxAttempts = 2
+	dispatcher.BaseBackoff = 30 * time.Millisecond
+
+	// 1. Versuch: schlaegt fehl, ist aber noch nicht die Obergrenze.
+	if _, err := dispatcher.ProcessDue(ctx); err != nil {
+		t.Fatalf("processdue 1: %v", err)
+	}
+	var status string
+	var attempt int
+	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
+		t.Fatalf("status lesen 1: %v", err)
+	}
+	if status != StatusPending || attempt != 1 {
+		t.Fatalf("nach 1. fehlschlag: status=%q attempt=%d, want pending/1", status, attempt)
+	}
+
+	// Sofort erneut verarbeiten: Backoff ist noch nicht abgelaufen -> nichts faellig.
+	processedTooEarly, err := dispatcher.ProcessDue(ctx)
+	if err != nil {
+		t.Fatalf("processdue (zu frueh): %v", err)
+	}
+	if processedTooEarly != 0 {
+		t.Fatal("erwartet 0 verarbeitete zustellungen, solange backoff nicht abgelaufen ist")
+	}
+
+	time.Sleep(dispatcher.backoffFor(1) + 20*time.Millisecond)
+
+	// 2. Versuch: erreicht MaxAttempts=2 -> endgueltig fehlgeschlagen.
+	if _, err := dispatcher.ProcessDue(ctx); err != nil {
+		t.Fatalf("processdue 2: %v", err)
+	}
+	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
+		t.Fatalf("status lesen 2: %v", err)
+	}
+	if status != StatusFailed || attempt != 2 {
+		t.Fatalf("nach 2. fehlschlag: status=%q attempt=%d, want failed/2", status, attempt)
+	}
+	if atomic.LoadInt32(&callCount) != 2 {
+		t.Fatalf("erwartet genau 2 tatsaechliche zustellversuche, habe %d", callCount)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: Signaturpruefung erkennt eine
+// manipulierte Payload zuverlaessig.
+func TestVerifySignature_DetectsTamperedPayload(t *testing.T) {
+	secret := "geteiltes-geheimnis"
+	payload := []byte(`{"file_id":"42"}`)
+	signature := Sign(secret, payload)
+
+	if !VerifySignature(secret, payload, signature) {
+		t.Fatal("erwartet gueltige signatur fuer unveraenderte payload")
+	}
+
+	tampered := []byte(`{"file_id":"99"}`)
+	if VerifySignature(secret, tampered, signature) {
+		t.Fatal("erwartet ungueltige signatur fuer manipulierte payload")
+	}
+
+	if VerifySignature("falsches-secret", payload, signature) {
+		t.Fatal("erwartet ungueltige signatur bei falschem secret")
+	}
+}

migrations/0002_superadmins.down.sql

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

migrations/0002_superadmins.up.sql

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

migrations/0004_feature_flags.down.sql

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

migrations/0004_feature_flags.up.sql

@@ -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()
-);

migrations/0005_module_registry.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS module_credentials;
-DROP TABLE IF EXISTS modules;

migrations/0005_module_registry.up.sql

@@ -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()
-);

migrations/0006_metrics_sources.down.sql

@@ -1 +0,0 @@
-DROP TABLE metrics_sources;

migrations/0006_metrics_sources.up.sql

@@ -1,7 +0,0 @@
--- Metrics-Aggregation ueber Module hinweg (OPS-03, siehe
--- core-kanban/tickets/OPS-03.md) — welches Modul liefert seine Kennzahlen
--- unter welcher /metrics-URL.
-CREATE TABLE metrics_sources (
-    module_name TEXT PRIMARY KEY,
-    metrics_url TEXT NOT NULL
-);

migrations/tenant/0001_users.down.sql

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

migrations/tenant/0001_users.up.sql

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

migrations/tenant/0002_users_password.down.sql

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

migrations/tenant/0002_users_password.up.sql

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

scripts/reset-test-env.sh

@@ -1,11 +1,16 @@
 #!/usr/bin/env bash
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
+
 export PGPASSWORD="$PASS"
+
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
+
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,12 +1,18 @@
 #!/usr/bin/env bash
 set -euo pipefail
+
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
+
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
+
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
+
 echo "== go build =="
 go build ./...
+
 echo "== go vet =="
 go vet ./...
+
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1