CFG-06: benachrichtigungs-einstellungen-dienst-starten

- cmd/notifyprefs-api: startet internal/notifyprefs.Handler (CFG-04),
  hinter auth.RequireAuth mit demselben JWT-Secret wie IAM-16
- reines Wiring, kein Diff an internal/notifyprefs/ (verifiziert)
- real deployed auf 131, cross-service-Session real bewiesen: Login
  gegen account-api, dasselbe Cookie gegen notifyprefs-api verwendet ->
  echtes Setzen und Lesen einer Praeferenz, ohne Cookie -> 401
- nutzt dieselbe nexarch_registry-DB wie CFG-05, Grants bereits
  vorhanden

Pruefungen siehe docs/CFG-06-PRUEFPROTOKOLL.md

.gitignore

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

DEVLOG.md

@@ -64,6 +64,9 @@ Keine Änderungen ermittelbar.
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
+## 2026-08-28 21:44 – 21:44 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
 
 ### Commits
 Keine Commits in dieser Session.
@@ -127,25 +130,60 @@ Keine Commits in dieser Session.
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
+- web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/index.ts                    | 25 +++++++++++++++++++++++++
+- web/shl/package.json                | 23 +++++++++++++++++++++++
+- web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tsconfig.json               | 18 ++++++++++++++++++
 
 ---
-## 2026-08-28 23:55 – 23:59 (3m)
+## 2026-08-28 21:51 – 21:57 (5m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 
 ### Commits
-- 369a40a OPS-05: alerting-bei-schwellwert-ueberschreitung (internal/alerting: regel-store, evaluator gegen ops-03-metriken, cfg-02-zustellung, drosselung je regel+zeitreihe)
-- 06dbd52 Merge branch 'feature/cfg-02-benachrichtigungs-dispatcher-core-service-fuer-module' into feature/ops-05-alerting-bei-schwellwert-ueberschreitung
+- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
 
 ### Geänderte Dateien
-- internal/alerting/evaluator.go       | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- internal/alerting/evaluator_test.go  | 233 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- internal/alerting/rules.go           | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- migrations/0006_alert_rules.down.sql |   2 ++
-- migrations/0006_alert_rules.up.sql   |  24 ++++++++++++++++++++++
+- web/shl/package.json     | 2 ++
+- web/shl/vitest.config.ts | 8 ++++++++
+- web/shl/vitest.setup.ts  | 1 +
 
 ---
-## 2026-08-29 00:00 – 00:00 (0m)
+## 2026-08-28 23:45 – 23:51 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- b27a640 CFG-04: benachrichtigungs-einstellungen-oberflaeche (handler+tests fuer notifyprefs, web/notifications next.js-frontend auf shl-01)
+- 81ff8c1 Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche
+- 22b3349 Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche
+- 2df3f93 CFG-04: backend teil 1 — internal/notifyprefs (praeferenz-store + enqueueifallowed-filter vor dispatcher)
+
+### Geänderte Dateien
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:51 – 23:51 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 
@@ -153,10 +191,37 @@ Keine Commits in dieser Session.
 Keine Commits in dieser Session.
 
 ### Geänderte Dateien
-- internal/alerting/evaluator.go       | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- internal/alerting/evaluator_test.go  | 233 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- internal/alerting/rules.go           | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- migrations/0006_alert_rules.down.sql |   2 ++
-- migrations/0006_alert_rules.up.sql   |  24 ++++++++++++++++++++++
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
+
+---
+## 2026-08-28 23:52 – 23:52 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- internal/notifyprefs/handler.go         |  83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/handler_test.go    | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/notifyprefs/prefs_test.go      | 183 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/layout.tsx        |  30 ++++++++++++++++++++++++++++++
+- web/notifications/app/overview/page.tsx |  43 +++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/app/page.tsx          |   5 +++++
+- web/notifications/app/settings/page.tsx |  97 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/lib/api.ts            |  45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/notifications/next.config.mjs       |   5 +++++
+- web/notifications/package.json          |  22 ++++++++++++++++++++++
+- web/notifications/tsconfig.json         |  21 +++++++++++++++++++++
 
 ---

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

cmd/notifyprefs-api/main.go

@@ -0,0 +1,59 @@
+// notifyprefs-api ist der Aufrufpunkt fuer CFG-06: startet den bereits
+// fertigen CFG-04-Handler (internal/notifyprefs) als eigenstaendigen
+// HTTP-Dienst, hinter derselben Session-Auth wie IAM-16 (account-api) —
+// GLEICHER JWT-Secret. REINES WIRING — keine Aenderung an
+// internal/notifyprefs/.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+	"gitea.perlbach24.de/scripte/nexarch/internal/notifyprefs"
+)
+
+func requireEnv(name string) string {
+	v := os.Getenv(name)
+	if v == "" {
+		log.Fatalf("%s muss gesetzt sein", name)
+	}
+	return v
+}
+
+func main() {
+	dsn := requireEnv("NEXARCH_NOTIFYPREFS_TENANT_DSN")
+	// MUSS identisch mit NEXARCH_ACCOUNT_JWT_SECRET (IAM-16) sein, sonst
+	// verwirft dieser Dienst gueltige account-api-Sessions.
+	jwtSecret := requireEnv("NEXARCH_NOTIFYPREFS_JWT_SECRET")
+	addr := os.Getenv("NEXARCH_NOTIFYPREFS_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8101"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	tokenIssuer := auth.NewTokenIssuer(jwtSecret)
+	handler := notifyprefs.NewHandler(notifyprefs.NewStore(pool))
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	mux.HandleFunc("GET /notifications/preferences", auth.RequireAuth(tokenIssuer, handler.ListMine))
+	mux.HandleFunc("POST /notifications/preferences", auth.RequireAuth(tokenIssuer, handler.SetPreference))
+	mux.HandleFunc("GET /notifications/preferences/tenant", auth.RequireAuth(tokenIssuer, handler.ListTenantOverview))
+
+	log.Printf("notifyprefs-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}

deploy/systemd/nexarch-notifyprefs-api.service.tmpl

@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Core - Benachrichtigungs-Einstellungen-Dienst (CFG-04/CFG-06)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/notifyprefs-api.env
+ExecStart=__INSTALL_DIR__/bin/notifyprefs-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target

docs/CFG-06-PRUEFPROTOKOLL.md

@@ -0,0 +1,52 @@
+# CFG-06 – Prüfprotokoll: Benachrichtigungs-Einstellungen-Dienst starten (CFG-04 als laufender Dienst)
+
+Voraussetzung CFG-04, IAM-16 – beide bereits Fertig, hier UNVERÄNDERT.
+
+## Reines Wiring, keine neue Logik
+
+`git diff --stat internal/notifyprefs/` liefert KEINEN Diff.
+`cmd/notifyprefs-api/main.go` setzt ausschließlich bestehende
+Konstruktoren zusammen, jeder Endpunkt hinter `auth.RequireAuth` mit
+demselben JWT-Secret wie IAM-16 (account-api) — dritter Baustein der
+Core-GUI mit bewiesener Cross-Service-Session-Gültigkeit nach RBAC-07.
+
+## Umsetzung
+
+- `cmd/notifyprefs-api/main.go` – `GET/POST /notifications/preferences`,
+  `GET /notifications/preferences/tenant`, alle hinter `auth.RequireAuth`.
+- `deploy/systemd/nexarch-notifyprefs-api.service.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-notifyprefs-api.service` aktiv |
+| 2 | Realer Aufruf mit gültigem IAM-16-Session-Cookie setzt/liest eine echte Präferenz, ohne Cookie 401 | **bestanden** – real per `curl`: ohne Cookie → 401; mit dem bei `account-api` ausgestellten Cookie: `POST /notifications/preferences` (Kanal `email` für `invoice_ready` deaktiviert) → 200, anschließendes `GET` liefert exakt diese Zeile zurück, korrekt dem einloggten Nutzer und Tenant (`acme`) zugeordnet |
+| 3 | Code-Review: keine Änderung an internal/notifyprefs/ selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat internal/notifyprefs/` liefert leeren Diff |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `notifyprefs-api` gebaut nach `/opt/nexarch-core/bin/`,
+  `/etc/nexarch/notifyprefs-api.env` (0600, `NEXARCH_NOTIFYPREFS_JWT_SECRET`
+  identisch zu `NEXARCH_ACCOUNT_JWT_SECRET`), Dienst installiert/aktiviert.
+- Nutzt dieselbe `nexarch_registry`-DB/Tabellen (`notification_preferences`)
+  wie CFG-05 — Grants dort bereits aus CFG-05 vorhanden, keine neue
+  Grant-Lücke gefunden.
+- End-zu-Ende-Beweis: Testnutzer angelegt, Login gegen `account-api`,
+  dasselbe Cookie gegen `notifyprefs-api` verwendet → echtes Setzen und
+  Lesen einer Präferenz. Testdaten anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./cmd/notifyprefs-api/...  -> 0 issues
+```
+
+## Gesamtergebnis
+
+**Bestanden.** CFG-04 ist jetzt ein real laufender, über systemd
+verwalteter Dienst, cross-service authentifiziert über dieselbe
+IAM-16-Session wie RBAC-07 — dritter erfolgreich real geprüfter
+Auth-geschützter Baustein der Core-GUI.

go.mod

@@ -1,25 +1,17 @@
 module gitea.perlbach24.de/scripte/nexarch
 
-go 1.25.0
+go 1.22
 
 require (
+	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/jackc/pgx/v5 v5.6.0
-	github.com/prometheus/client_golang v1.24.1
-	github.com/prometheus/client_model v0.6.2
-	github.com/prometheus/common v0.70.1
+	golang.org/x/crypto v0.17.0
 )
 
 require (
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	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
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/prometheus/procfs v0.21.1 // indirect
-	golang.org/x/crypto v0.17.0 // indirect
-	golang.org/x/sync v0.22.0 // indirect
-	golang.org/x/sys v0.47.0 // indirect
-	golang.org/x/text v0.40.0 // indirect
-	google.golang.org/protobuf v1.36.11 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 )

go.sum

@@ -1,12 +1,8 @@
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
-github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+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=
@@ -15,37 +11,19 @@ github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
 github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU=
-github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE=
-github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
-github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY=
-github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc=
-github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
-github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
-go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
 golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
-golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
-golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
-golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/alerting/evaluator.go

@@ -1,194 +0,0 @@
-package alerting
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	dto "github.com/prometheus/client_model/go"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
-)
-
-// DefaultDebounceInterval: wiederholte Alarmierung für denselben
-// anhaltenden Zustand ist gedrosselt (Akzeptanzkriterium 3) — 15 Minuten
-// ist ein üblicher Kompromiss zwischen "schnell genug informiert" und
-// "kein Alarm-Spam bei dauerhaft überschrittenem Wert".
-const DefaultDebounceInterval = 15 * time.Minute
-
-// AlertChannel ist der CFG-02-Kanal, über den Schwellwert-Alarme zugestellt
-// werden — ein eigener Kanalname, damit Zustellregeln/-vorlagen (CFG-03)
-// unabhängig von anderen Benachrichtigungsarten konfiguriert werden können.
-const AlertChannel = "alert"
-
-// Evaluator prüft konfigurierte Regeln gegen aktuell gesammelte Metriken
-// (aus internal/metrics.Aggregator.Gather) und löst bei Überschreitung eine
-// Benachrichtigung über CFG-02 aus (Akzeptanzkriterium 2), gedrosselt je
-// Regel+Zeitreihe (Akzeptanzkriterium 3).
-type Evaluator struct {
-	rules      *RuleStore
-	debounce   *debounceStore
-	dispatcher *notify.Dispatcher
-	interval   time.Duration
-}
-
-func NewEvaluator(rules *RuleStore, dispatcher *notify.Dispatcher, debouncePool *pgxpool.Pool, interval time.Duration) *Evaluator {
-	if interval <= 0 {
-		interval = DefaultDebounceInterval
-	}
-	return &Evaluator{
-		rules:      rules,
-		debounce:   &debounceStore{pool: debouncePool},
-		dispatcher: dispatcher,
-		interval:   interval,
-	}
-}
-
-// FiredAlert beschreibt einen tatsächlich ausgelösten (nicht gedrosselten)
-// Alarm — fürs Testen/Logging, nicht Teil des öffentlichen Zustellwegs.
-type FiredAlert struct {
-	RuleID     string
-	MetricName string
-	Value      float64
-	Threshold  float64
-	Labels     map[string]string
-	Skipped    bool // true, wenn wegen Drosselung NICHT tatsaechlich zugestellt
-}
-
-// Evaluate prüft alle konfigurierten Regeln gegen families (Akzeptanzkriterium 1).
-// Für jede Zeitreihe, die eine Regel verletzt, wird — sofern nicht gedrosselt
-// — eine Benachrichtigung mit Metrik/Wert/Schwellwert/Labels (Tenant/Modul,
-// falls als Label vorhanden) über CFG-02 eingereiht (Akzeptanzkriterium 2).
-func (e *Evaluator) Evaluate(ctx context.Context, families []*dto.MetricFamily) ([]FiredAlert, error) {
-	rules, err := e.rules.ListRules(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("regeln laden: %w", err)
-	}
-	if len(rules) == 0 {
-		return nil, nil
-	}
-
-	byName := make(map[string]*dto.MetricFamily, len(families))
-	for _, f := range families {
-		if f.Name != nil {
-			byName[*f.Name] = f
-		}
-	}
-
-	var fired []FiredAlert
-	for _, rule := range rules {
-		family, ok := byName[rule.MetricName]
-		if !ok {
-			continue // Metrik (noch) nicht vorhanden -> keine Aussage moeglich, kein Fehler.
-		}
-
-		for _, m := range family.Metric {
-			labels := labelMap(m)
-			if !matchesFilter(labels, rule.LabelFilters) {
-				continue
-			}
-			value, ok := metricValue(m)
-			if !ok {
-				continue
-			}
-			if !violates(rule, value) {
-				continue
-			}
-
-			ruleKey := ruleKeyFor(rule.ID, labels)
-			allowed, err := e.debounce.shouldFire(ctx, ruleKey, e.interval.Seconds())
-			if err != nil {
-				return fired, fmt.Errorf("drosselung pruefen: %w", err)
-			}
-
-			alert := FiredAlert{
-				RuleID: rule.ID, MetricName: rule.MetricName, Value: value,
-				Threshold: rule.Threshold, Labels: labels, Skipped: !allowed,
-			}
-			fired = append(fired, alert)
-
-			if !allowed {
-				continue
-			}
-
-			payload := map[string]any{
-				"metric":      rule.MetricName,
-				"value":       value,
-				"threshold":   rule.Threshold,
-				"comparison":  string(rule.Comparison),
-				"description": rule.Description,
-				"labels":      labels,
-			}
-			if _, err := e.dispatcher.Enqueue(ctx, AlertChannel, rule.Recipient, payload); err != nil {
-				return fired, fmt.Errorf("alarm einreihen: %w", err)
-			}
-		}
-	}
-	return fired, nil
-}
-
-func violates(rule Rule, value float64) bool {
-	switch rule.Comparison {
-	case ComparisonGreaterThan:
-		return value > rule.Threshold
-	case ComparisonLessThan:
-		return value < rule.Threshold
-	default:
-		return false
-	}
-}
-
-func labelMap(m *dto.Metric) map[string]string {
-	out := make(map[string]string, len(m.Label))
-	for _, l := range m.Label {
-		if l.Name != nil && l.Value != nil {
-			out[*l.Name] = *l.Value
-		}
-	}
-	return out
-}
-
-func matchesFilter(labels, filter map[string]string) bool {
-	for k, v := range filter {
-		if labels[k] != v {
-			return false
-		}
-	}
-	return true
-}
-
-func metricValue(m *dto.Metric) (float64, bool) {
-	switch {
-	case m.Gauge != nil && m.Gauge.Value != nil:
-		return *m.Gauge.Value, true
-	case m.Counter != nil && m.Counter.Value != nil:
-		return *m.Counter.Value, true
-	case m.Untyped != nil && m.Untyped.Value != nil:
-		return *m.Untyped.Value, true
-	default:
-		return 0, false
-	}
-}
-
-// ruleKeyFor macht die Drosselung unabhaengig je Regel UND je konkreter
-// Zeitreihe (z. B. verschiedene Tenants/Module derselben Metrik loesen
-// unabhaengig voneinander aus, siehe Migrationskommentar).
-func ruleKeyFor(ruleID string, labels map[string]string) string {
-	keys := make([]string, 0, len(labels))
-	for k := range labels {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	var b strings.Builder
-	b.WriteString(ruleID)
-	for _, k := range keys {
-		b.WriteString("|")
-		b.WriteString(k)
-		b.WriteString("=")
-		b.WriteString(labels[k])
-	}
-	return b.String()
-}

internal/alerting/evaluator_test.go

@@ -1,233 +0,0 @@
-package alerting
-
-import (
-	"context"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-	dto "github.com/prometheus/client_model/go"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
-)
-
-func setupTest(t *testing.T) (*RuleStore, *notify.Dispatcher, *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 alert_rules (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), metric_name TEXT NOT NULL,
-			comparison TEXT NOT NULL CHECK (comparison IN ('gt','lt')), threshold DOUBLE PRECISION NOT NULL,
-			label_filters JSONB NOT NULL DEFAULT '{}'::jsonb, recipient TEXT NOT NULL,
-			description TEXT NOT NULL DEFAULT '', created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS alert_debounce_state (
-			rule_key TEXT PRIMARY KEY, last_fired_at TIMESTAMPTZ NOT NULL
-		);
-		CREATE TABLE IF NOT EXISTS notification_jobs (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
-			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending', attempts INT NOT NULL DEFAULT 0,
-			max_attempts INT NOT NULL DEFAULT 5, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM alert_rules`)
-		_, _ = pool.Exec(ctx, `DELETE FROM alert_debounce_state`)
-		_, _ = pool.Exec(ctx, `DELETE FROM notification_jobs`)
-		pool.Close()
-	}
-	return NewRuleStore(pool), notify.NewDispatcher(pool), pool, cleanup
-}
-
-func gaugeFamily(name string, labels map[string]string, value float64) *dto.MetricFamily {
-	pairs := make([]*dto.LabelPair, 0, len(labels))
-	for k, v := range labels {
-		k, v := k, v
-		pairs = append(pairs, &dto.LabelPair{Name: &k, Value: &v})
-	}
-	n := name
-	return &dto.MetricFamily{
-		Name: &n,
-		Metric: []*dto.Metric{
-			{Label: pairs, Gauge: &dto.Gauge{Value: &value}},
-		},
-	}
-}
-
-// Akzeptanzkriterium 1 + 2 / Pruefung 1 + 2: Überschreitung löst eine
-// Benachrichtigung mit vollständigem Inhalt (Metrik/Tenant/Modul) aus.
-func TestEvaluate_FiresAlertOnThresholdExceeded(t *testing.T) {
-	rules, dispatcher, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	rule, err := rules.CreateRule(ctx, Rule{
-		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
-		Recipient: "ops@acme.example", Description: "Fehlerrate zu hoch",
-	})
-	if err != nil {
-		t.Fatalf("create rule: %v", err)
-	}
-
-	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
-	families := []*dto.MetricFamily{
-		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme", "module": "dms"}, 0.12),
-	}
-
-	fired, err := eval.Evaluate(ctx, families)
-	if err != nil {
-		t.Fatalf("evaluate: %v", err)
-	}
-	if len(fired) != 1 || fired[0].Skipped {
-		t.Fatalf("erwartet genau 1 tatsaechlich ausgeloesten alarm, habe %+v", fired)
-	}
-	if fired[0].RuleID != rule.ID {
-		t.Fatalf("rule id = %q, want %q", fired[0].RuleID, rule.ID)
-	}
-
-	// Pruefung 2: Benachrichtigungsinhalt vollstaendig (Metrik/Tenant/Modul).
-	var payloadJSON []byte
-	if err := pool.QueryRow(ctx, `SELECT payload FROM notification_jobs LIMIT 1`).Scan(&payloadJSON); err != nil {
-		t.Fatalf("notification_jobs lesen: %v", err)
-	}
-	payload := string(payloadJSON)
-	for _, want := range []string{`"metric"`, `nexarch_core_error_rate`, `"tenant"`, `"acme"`, `"module"`, `"dms"`} {
-		if !strings.Contains(payload, want) {
-			t.Errorf("payload enthaelt nicht %q: %s", want, payload)
-		}
-	}
-}
-
-func TestEvaluate_DoesNotFireBelowThreshold(t *testing.T) {
-	rules, dispatcher, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := rules.CreateRule(ctx, Rule{
-		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
-		Recipient: "ops@acme.example",
-	}); err != nil {
-		t.Fatalf("create rule: %v", err)
-	}
-
-	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
-	families := []*dto.MetricFamily{
-		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme"}, 0.01),
-	}
-
-	fired, err := eval.Evaluate(ctx, families)
-	if err != nil {
-		t.Fatalf("evaluate: %v", err)
-	}
-	if len(fired) != 0 {
-		t.Fatalf("erwartet keinen alarm unterhalb des schwellwerts, habe %+v", fired)
-	}
-}
-
-// Akzeptanzkriterium 3 / Pruefung 3: anhaltende Überschreitung erzeugt NICHT
-// bei jeder Messung eine neue Benachrichtigung.
-func TestEvaluate_DebouncesRepeatedFiring(t *testing.T) {
-	rules, dispatcher, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := rules.CreateRule(ctx, Rule{
-		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
-		Recipient: "ops@acme.example",
-	}); err != nil {
-		t.Fatalf("create rule: %v", err)
-	}
-
-	// Langes Debounce-Intervall: der zweite Evaluate-Lauf (simuliert die
-	// naechste Messung bei anhaltend ueberschrittenem Wert) darf keinen
-	// weiteren Job einreihen.
-	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
-	families := []*dto.MetricFamily{
-		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme"}, 0.5),
-	}
-
-	first, err := eval.Evaluate(ctx, families)
-	if err != nil {
-		t.Fatalf("erster evaluate-lauf: %v", err)
-	}
-	if len(first) != 1 || first[0].Skipped {
-		t.Fatalf("erster lauf haette feuern muessen, habe %+v", first)
-	}
-
-	second, err := eval.Evaluate(ctx, families)
-	if err != nil {
-		t.Fatalf("zweiter evaluate-lauf: %v", err)
-	}
-	if len(second) != 1 || !second[0].Skipped {
-		t.Fatalf("zweiter lauf haette gedrosselt werden muessen, habe %+v", second)
-	}
-
-	var count int
-	if err := pool.QueryRow(ctx, `SELECT count(*) FROM notification_jobs`).Scan(&count); err != nil {
-		t.Fatalf("notification_jobs zaehlen: %v", err)
-	}
-	if count != 1 {
-		t.Fatalf("erwartet genau 1 eingereihten job trotz zwei ueberschreitenden messungen, habe %d", count)
-	}
-}
-
-// Verschiedene Zeitreihen derselben Regel (unterschiedlicher Tenant) werden
-// unabhaengig voneinander gedrosselt.
-func TestEvaluate_DebouncesIndependentlyPerLabelSet(t *testing.T) {
-	rules, dispatcher, pool, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := rules.CreateRule(ctx, Rule{
-		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
-		Recipient: "ops@acme.example",
-	}); err != nil {
-		t.Fatalf("create rule: %v", err)
-	}
-
-	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
-	families := []*dto.MetricFamily{
-		{
-			Name: strPtr("nexarch_core_error_rate"),
-			Metric: []*dto.Metric{
-				metricWithLabel("tenant", "acme", 0.5),
-				metricWithLabel("tenant", "beta", 0.6),
-			},
-		},
-	}
-
-	fired, err := eval.Evaluate(ctx, families)
-	if err != nil {
-		t.Fatalf("evaluate: %v", err)
-	}
-	if len(fired) != 2 {
-		t.Fatalf("erwartet 2 unabhaengige alarme (verschiedene tenants), habe %d", len(fired))
-	}
-	for _, a := range fired {
-		if a.Skipped {
-			t.Fatalf("beide tenants sollten beim ersten mal feuern, habe %+v", a)
-		}
-	}
-}
-
-func metricWithLabel(name, value string, gaugeValue float64) *dto.Metric {
-	n, v := name, value
-	return &dto.Metric{Label: []*dto.LabelPair{{Name: &n, Value: &v}}, Gauge: &dto.Gauge{Value: &gaugeValue}}
-}
-
-func strPtr(s string) *string { return &s }

internal/alerting/rules.go

@@ -1,132 +0,0 @@
-// Package alerting implementiert Core OPS-05: schwellwertbasierte
-// Alarmierung auf den aus OPS-03 aggregierten Metriken, Zustellung über den
-// Core-Benachrichtigungs-Dispatcher (CFG-02). Der Alertmanager-Gedanke von
-// Prometheus/Grafana, aber auf das Nötigste reduziert (Schwellwert, Ziel,
-// Drosselung) — keine eigene Ausdruckssprache.
-package alerting
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Comparison legt fest, ob ein Schwellwert nach oben oder unten überwacht
-// wird — bewusst nur zwei Operatoren, keine eigene Ausdruckssprache
-// (Ticket-Produkt-DNA).
-type Comparison string
-
-const (
-	ComparisonGreaterThan Comparison = "gt"
-	ComparisonLessThan    Comparison = "lt"
-)
-
-// Rule ist eine Schwellwert-Regel auf einer beliebigen aggregierten Metrik
-// (Akzeptanzkriterium 1). LabelFilters schränkt optional auf bestimmte
-// Label-Werte ein (z. B. tenant/module), leer = alle Zeitreihen der Metrik.
-type Rule struct {
-	ID           string
-	MetricName   string
-	Comparison   Comparison
-	Threshold    float64
-	LabelFilters map[string]string
-	Recipient    string
-	Description  string
-}
-
-// RuleStore verwaltet Alert-Regeln in der zentralen Registry-DB.
-type RuleStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewRuleStore(pool *pgxpool.Pool) *RuleStore {
-	return &RuleStore{pool: pool}
-}
-
-// CreateRule legt eine neue Schwellwert-Regel an (Akzeptanzkriterium 1).
-func (s *RuleStore) CreateRule(ctx context.Context, r Rule) (Rule, error) {
-	if r.MetricName == "" || r.Recipient == "" {
-		return Rule{}, errors.New("alerting: metricName und recipient duerfen nicht leer sein")
-	}
-	if r.Comparison != ComparisonGreaterThan && r.Comparison != ComparisonLessThan {
-		return Rule{}, fmt.Errorf("alerting: unbekannter comparison-operator %q", r.Comparison)
-	}
-	if r.LabelFilters == nil {
-		r.LabelFilters = map[string]string{}
-	}
-	filtersJSON, err := json.Marshal(r.LabelFilters)
-	if err != nil {
-		return Rule{}, fmt.Errorf("label-filter serialisieren: %w", err)
-	}
-
-	err = s.pool.QueryRow(ctx, `
-		INSERT INTO alert_rules (metric_name, comparison, threshold, label_filters, recipient, description)
-		VALUES ($1, $2, $3, $4, $5, $6)
-		RETURNING id
-	`, r.MetricName, string(r.Comparison), r.Threshold, filtersJSON, r.Recipient, r.Description).Scan(&r.ID)
-	if err != nil {
-		return Rule{}, fmt.Errorf("regel speichern: %w", err)
-	}
-	return r, nil
-}
-
-// ListRules liefert alle konfigurierten Regeln — Grundlage für Evaluate.
-func (s *RuleStore) ListRules(ctx context.Context) ([]Rule, error) {
-	rows, err := s.pool.Query(ctx, `
-		SELECT id, metric_name, comparison, threshold, label_filters, recipient, description
-		FROM alert_rules ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("regeln auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Rule
-	for rows.Next() {
-		var r Rule
-		var comparison string
-		var filtersJSON []byte
-		if err := rows.Scan(&r.ID, &r.MetricName, &comparison, &r.Threshold, &filtersJSON, &r.Recipient, &r.Description); err != nil {
-			return nil, fmt.Errorf("regel lesen: %w", err)
-		}
-		r.Comparison = Comparison(comparison)
-		if err := json.Unmarshal(filtersJSON, &r.LabelFilters); err != nil {
-			return nil, fmt.Errorf("label-filter lesen: %w", err)
-		}
-		out = append(out, r)
-	}
-	return out, rows.Err()
-}
-
-// DeleteRule entfernt eine Regel.
-func (s *RuleStore) DeleteRule(ctx context.Context, id string) error {
-	_, err := s.pool.Exec(ctx, `DELETE FROM alert_rules WHERE id = $1`, id)
-	if err != nil {
-		return fmt.Errorf("regel loeschen: %w", err)
-	}
-	return nil
-}
-
-// debounceStore kapselt die Drosselungs-Zustandstabelle (Akzeptanzkriterium 3).
-type debounceStore struct {
-	pool *pgxpool.Pool
-}
-
-// shouldFire prueft, ob seit dem letzten Alarm fuer ruleKey mindestens
-// interval vergangen ist — atomar ueber eine bedingte UPDATE/INSERT-
-// Sequenz, damit zwei gleichzeitige Evaluate-Laeufe (z. B. bei mehreren
-// Core-Instanzen) nicht beide gleichzeitig alarmieren.
-func (d *debounceStore) shouldFire(ctx context.Context, ruleKey string, intervalSeconds float64) (bool, error) {
-	tag, err := d.pool.Exec(ctx, `
-		INSERT INTO alert_debounce_state (rule_key, last_fired_at) VALUES ($1, now())
-		ON CONFLICT (rule_key) DO UPDATE SET last_fired_at = now()
-		WHERE alert_debounce_state.last_fired_at <= now() - ($2 * interval '1 second')
-	`, ruleKey, intervalSeconds)
-	if err != nil {
-		return false, fmt.Errorf("drosselungszustand pruefen: %w", err)
-	}
-	return tag.RowsAffected() == 1, nil
-}

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/channels/channels_test.go

@@ -0,0 +1,207 @@
+package channels
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*TemplateStore, *InAppStore, 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 notification_templates (
+			tenant_slug TEXT NOT NULL, key TEXT NOT NULL, subject TEXT NOT NULL, body TEXT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_slug, key)
+		);
+		CREATE TABLE IF NOT EXISTS in_app_notifications (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL,
+			title TEXT NOT NULL, body TEXT NOT NULL, read_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','failed')),
+			attempts INT NOT NULL DEFAULT 0, max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewTemplateStore(pool), NewInAppStore(pool), cleanup
+}
+
+func uniqueKey(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Vorlagenrendering mit fehlenden
+// Platzhaltern bricht kontrolliert ab.
+func TestRender_MissingPlaceholderAborts(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	_, _, err := Render(tmpl, map[string]any{"name": "Alice"}) // "code" fehlt
+	if err == nil {
+		t.Fatal("erwartet fehler bei fehlendem platzhalter 'code'")
+	}
+}
+
+func TestRender_SucceedsWithAllPlaceholders(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	subject, body, err := Render(tmpl, map[string]any{"name": "Alice", "code": "1234"})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	if subject != "Hallo Alice" || body != "Dein Code: 1234" {
+		t.Fatalf("unerwartet: subject=%q body=%q", subject, body)
+	}
+}
+
+// Akzeptanzkriterium 3: Vorlagen pro Tenant anpassbar, Fallback auf global.
+func TestTemplateStore_TenantOverrideFallsBackToGlobal(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	key := uniqueKey("welcome")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Willkommen", "Standardtext"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if err := templates.Set(ctx, "acme", key, "Willkommen bei ACME", "ACME-Text"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	got, err := templates.Resolve(ctx, "acme", key)
+	if err != nil {
+		t.Fatalf("resolve acme: %v", err)
+	}
+	if got.Subject != "Willkommen bei ACME" {
+		t.Fatalf("erwartet tenant-vorlage, habe %q", got.Subject)
+	}
+
+	got, err = templates.Resolve(ctx, "globex", key) // hat keine eigene vorlage
+	if err != nil {
+		t.Fatalf("resolve globex: %v", err)
+	}
+	if got.Subject != "Willkommen" {
+		t.Fatalf("erwartet global-fallback, habe %q", got.Subject)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: als gelesen markiert wird korrekt gefuehrt.
+func TestInAppStore_MarkReadIsReflectedCorrectly(t *testing.T) {
+	_, inApp, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	userID := uniqueKey("user")
+	id, err := inApp.Create(ctx, "acme", userID, "Titel", "Text")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	list, err := inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (vor markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt != nil {
+		t.Fatalf("erwartet 1 ungelesene benachrichtigung, habe %+v", list)
+	}
+
+	if err := inApp.MarkRead(ctx, id); err != nil {
+		t.Fatalf("mark read: %v", err)
+	}
+
+	list, err = inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (nach markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt == nil {
+		t.Fatalf("erwartet als gelesen markiert, habe %+v", list)
+	}
+}
+
+// EmailSender bricht ab, BEVOR SMTP ueberhaupt kontaktiert wird, wenn keine
+// Vorlage aufloesbar ist — Nachweis, dass der Abbruch vor dem Netzwerkzugriff
+// erfolgt (Akzeptanzkriterium 1).
+func TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+
+	err := sender.Send(ctx, notify.Notification{
+		Recipient: "user@example.com",
+		Payload:   map[string]any{"template_key": uniqueKey("nie_konfiguriert"), "tenant_slug": "acme"},
+	})
+	if !errors.Is(err, ErrTemplateNotFound) {
+		t.Fatalf("erwartet ErrTemplateNotFound (kein smtp-versuch), habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: E-Mail-Versand bei nicht erreichbarem
+// SMTP-Server loest das dokumentierte Retry-Verhalten ueber CFG-02 aus.
+func TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	key := uniqueKey("retry_test")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Betreff", "Text ohne Platzhalter"); err != nil {
+		t.Fatalf("set template: %v", err)
+	}
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+	dispatcher := notify.NewDispatcher(pool).WithRetryPolicy(2, time.Millisecond)
+
+	jobID, err := dispatcher.Enqueue(ctx, "email", "user@example.com", map[string]any{"template_key": key, "tenant_slug": "acme"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	for i := 0; i < 2; i++ {
+		time.Sleep(5 * time.Millisecond)
+		if _, _, err := dispatcher.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process due %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, jobID).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach ausgeschoepften wiederholungen bei unerreichbarem smtp, habe %q", status)
+	}
+	if attempts != 2 {
+		t.Fatalf("erwartet 2 versuche, habe %d", attempts)
+	}
+}

internal/channels/email.go

@@ -0,0 +1,81 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// EmailSender implementiert notify.Sender fuer den E-Mail-Kanal
+// (Akzeptanzkriterium 1). SMTP-Zugangsdaten kommen ausschliesslich aus
+// Umgebungsvariablen, nie aus Code/DB.
+type EmailSender struct {
+	templates *TemplateStore
+	host      string
+	port      string
+	from      string
+	username  string
+	password  string
+}
+
+// NewEmailSenderFromEnv liest NEXARCH_SMTP_HOST/PORT/FROM (Pflicht) sowie
+// optional NEXARCH_SMTP_USER/PASSWORD.
+func NewEmailSenderFromEnv(templates *TemplateStore) (*EmailSender, error) {
+	host := os.Getenv("NEXARCH_SMTP_HOST")
+	port := os.Getenv("NEXARCH_SMTP_PORT")
+	from := os.Getenv("NEXARCH_SMTP_FROM")
+	if host == "" || port == "" || from == "" {
+		return nil, fmt.Errorf("channels: NEXARCH_SMTP_HOST/PORT/FROM muessen gesetzt sein")
+	}
+	return &EmailSender{
+		templates: templates,
+		host:      host,
+		port:      port,
+		from:      from,
+		username:  os.Getenv("NEXARCH_SMTP_USER"),
+		password:  os.Getenv("NEXARCH_SMTP_PASSWORD"),
+	}, nil
+}
+
+// NewEmailSender erlaubt Tests, Host/Port explizit zu setzen (z.B. einen
+// absichtlich nicht erreichbaren Host fuer den Retry-Nachweis), ohne
+// Umgebungsvariablen zu benoetigen.
+func NewEmailSender(templates *TemplateStore, host, port, from string) *EmailSender {
+	return &EmailSender{templates: templates, host: host, port: port, from: from}
+}
+
+// Send rendert zuerst die Vorlage — schlaegt das fehl (z.B. fehlender
+// Platzhalter), wird NIE eine SMTP-Verbindung aufgebaut
+// (Akzeptanzkriterium 1 / Pruefung 1: kontrollierter Abbruch statt
+// fehlerhafter Mail). Ein danach fehlschlagender SMTP-Versand liefert einen
+// Fehler zurueck, den CFG-02s Dispatcher fuer die bereits getestete
+// Wiederholungslogik nutzt (Akzeptanzkriterium 3 / Pruefung 3) — kein
+// zweiter Retry-Mechanismus hier.
+func (e *EmailSender) Send(ctx context.Context, n notify.Notification) error {
+	templateKey, _ := n.Payload["template_key"].(string)
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	tmpl, err := e.templates.Resolve(ctx, tenantSlug, templateKey)
+	if err != nil {
+		return fmt.Errorf("vorlage aufloesen: %w", err)
+	}
+	subject, body, err := Render(tmpl, n.Payload)
+	if err != nil {
+		return err
+	}
+
+	msg := []byte("Subject: " + subject + "\r\n\r\n" + body)
+
+	var auth smtp.Auth
+	if e.username != "" {
+		auth = smtp.PlainAuth("", e.username, e.password, e.host)
+	}
+	addr := e.host + ":" + e.port
+	if err := smtp.SendMail(addr, auth, e.from, []string{n.Recipient}, msg); err != nil {
+		return fmt.Errorf("smtp-versand fehlgeschlagen: %w", err)
+	}
+	return nil
+}

internal/channels/inapp.go

@@ -0,0 +1,74 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type InAppNotification struct {
+	ID         string
+	TenantSlug string
+	UserID     string
+	Title      string
+	Body       string
+	ReadAt     *time.Time
+	CreatedAt  time.Time
+}
+
+// InAppStore persistiert In-App-Benachrichtigungen (Akzeptanzkriterium 2).
+type InAppStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewInAppStore(pool *pgxpool.Pool) *InAppStore {
+	return &InAppStore{pool: pool}
+}
+
+func (s *InAppStore) Create(ctx context.Context, tenantSlug, userID, title, body string) (string, error) {
+	var id string
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO in_app_notifications (tenant_slug, user_id, title, body)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, tenantSlug, userID, title, body).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("in-app-benachrichtigung speichern: %w", err)
+	}
+	return id, nil
+}
+
+// ListForUser liefert alle Benachrichtigungen eines Benutzers (ueber API
+// abrufbar, Akzeptanzkriterium 2).
+func (s *InAppStore) ListForUser(ctx context.Context, tenantSlug, userID string) ([]InAppNotification, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, title, body, read_at, created_at FROM in_app_notifications
+		WHERE tenant_slug = $1 AND user_id = $2 ORDER BY created_at DESC
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("benachrichtigungen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []InAppNotification
+	for rows.Next() {
+		n := InAppNotification{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&n.ID, &n.Title, &n.Body, &n.ReadAt, &n.CreatedAt); err != nil {
+			return nil, fmt.Errorf("benachrichtigung lesen: %w", err)
+		}
+		out = append(out, n)
+	}
+	return out, rows.Err()
+}
+
+// MarkRead markiert eine Benachrichtigung als gelesen (Akzeptanzkriterium 2
+// / Pruefung 2).
+func (s *InAppStore) MarkRead(ctx context.Context, id string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE in_app_notifications SET read_at = now() WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("als gelesen markieren: %w", err)
+	}
+	return nil
+}

internal/channels/inapp_sender.go

@@ -0,0 +1,41 @@
+package channels
+
+import (
+	"context"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// InAppSender implementiert notify.Sender fuer den In-App-Kanal
+// (Akzeptanzkriterium 2). Nutzt eine Vorlage, falls payload["template_key"]
+// gesetzt ist, sonst direkt payload["title"]/["body"].
+type InAppSender struct {
+	store     *InAppStore
+	templates *TemplateStore
+}
+
+func NewInAppSender(store *InAppStore, templates *TemplateStore) *InAppSender {
+	return &InAppSender{store: store, templates: templates}
+}
+
+func (s *InAppSender) Send(ctx context.Context, n notify.Notification) error {
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	var title, body string
+	if templateKey, ok := n.Payload["template_key"].(string); ok && templateKey != "" {
+		tmpl, err := s.templates.Resolve(ctx, tenantSlug, templateKey)
+		if err != nil {
+			return err
+		}
+		title, body, err = Render(tmpl, n.Payload)
+		if err != nil {
+			return err
+		}
+	} else {
+		title, _ = n.Payload["title"].(string)
+		body, _ = n.Payload["body"].(string)
+	}
+
+	_, err := s.store.Create(ctx, tenantSlug, n.Recipient, title, body)
+	return err
+}

internal/channels/router.go

@@ -0,0 +1,32 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// Router waehlt anhand von Notification.Channel den zustaendigen Kanal aus
+// — ein neuer Kanal wird per Register() ergaenzt, ohne den Dispatcher
+// (CFG-02) oder Router selbst umzubauen (Unleash-artiger Strategie-Gedanke,
+// siehe Ticket-DNA).
+type Router struct {
+	channels map[string]notify.Sender
+}
+
+func NewRouter() *Router {
+	return &Router{channels: make(map[string]notify.Sender)}
+}
+
+func (r *Router) Register(channel string, sender notify.Sender) {
+	r.channels[channel] = sender
+}
+
+func (r *Router) Send(ctx context.Context, n notify.Notification) error {
+	sender, ok := r.channels[n.Channel]
+	if !ok {
+		return fmt.Errorf("channels: unbekannter kanal %q", n.Channel)
+	}
+	return sender.Send(ctx, n)
+}

internal/channels/template.go

@@ -0,0 +1,104 @@
+// Package channels implementiert Core CFG-03: konkrete Zustellkanaele fuer
+// den CFG-02-Dispatcher (E-Mail, In-App) inklusive Vorlagenverwaltung.
+// Neue Kanaele lassen sich ergaenzen, ohne den Dispatcher selbst
+// anzufassen — jeder Kanal implementiert nur notify.Sender.
+package channels
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"text/template"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalTemplateScope ist der Fallback-Wert, wenn ein Tenant keine eigene
+// Vorlage konfiguriert hat (Akzeptanzkriterium 3).
+const GlobalTemplateScope = "global"
+
+var ErrTemplateNotFound = errors.New("channels: keine vorlage gefunden")
+
+type Template struct {
+	Subject string
+	Body    string
+}
+
+type TemplateStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTemplateStore(pool *pgxpool.Pool) *TemplateStore {
+	return &TemplateStore{pool: pool}
+}
+
+// Set legt eine Vorlage fuer einen Tenant (oder GlobalTemplateScope) fest.
+func (s *TemplateStore) Set(ctx context.Context, tenantSlug, key, subject, body string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_templates (tenant_slug, key, subject, body, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (tenant_slug, key) DO UPDATE SET subject = $3, body = $4, updated_at = now()
+	`, tenantSlug, key, subject, body)
+	if err != nil {
+		return fmt.Errorf("vorlage speichern: %w", err)
+	}
+	return nil
+}
+
+// Resolve liefert die Vorlage eines Tenants, faellt auf GlobalTemplateScope
+// zurueck, wenn der Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3).
+func (s *TemplateStore) Resolve(ctx context.Context, tenantSlug, key string) (Template, error) {
+	if tenantSlug != "" && tenantSlug != GlobalTemplateScope {
+		if t, err := s.get(ctx, tenantSlug, key); err == nil {
+			return t, nil
+		} else if !errors.Is(err, ErrTemplateNotFound) {
+			return Template{}, err
+		}
+	}
+	return s.get(ctx, GlobalTemplateScope, key)
+}
+
+func (s *TemplateStore) get(ctx context.Context, tenantSlug, key string) (Template, error) {
+	var t Template
+	err := s.pool.QueryRow(ctx, `
+		SELECT subject, body FROM notification_templates WHERE tenant_slug = $1 AND key = $2
+	`, tenantSlug, key).Scan(&t.Subject, &t.Body)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Template{}, ErrTemplateNotFound
+		}
+		return Template{}, fmt.Errorf("vorlage lesen: %w", err)
+	}
+	return t, nil
+}
+
+// Render fuellt eine Vorlage mit data. Fehlt ein referenzierter Platzhalter
+// in data, bricht das Rendering kontrolliert MIT FEHLER ab, statt eine
+// fehlerhafte/unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1 /
+// Pruefung 1) — text/template mit Option("missingkey=error") liefert dafuer
+// einen Fehler statt stillschweigend "<no value>" einzusetzen.
+func Render(tmpl Template, data map[string]any) (subject, body string, err error) {
+	subject, err = renderOne("subject", tmpl.Subject, data)
+	if err != nil {
+		return "", "", err
+	}
+	body, err = renderOne("body", tmpl.Body, data)
+	if err != nil {
+		return "", "", err
+	}
+	return subject, body, nil
+}
+
+func renderOne(name, text string, data map[string]any) (string, error) {
+	tmpl, err := template.New(name).Option("missingkey=error").Parse(text)
+	if err != nil {
+		return "", fmt.Errorf("vorlage %q parsen: %w", name, err)
+	}
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return "", fmt.Errorf("vorlage %q rendern (fehlender platzhalter?): %w", name, err)
+	}
+	return buf.String(), nil
+}

internal/flag/flag.go

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

internal/flag/flag_test.go

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

internal/flag/service.go

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

internal/flag/service_test.go

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

internal/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/moduleregistry/credentials.go

@@ -1,99 +0,0 @@
-package moduleregistry
-
-import (
-	"context"
-	"crypto/rand"
-	"crypto/sha256"
-	"crypto/subtle"
-	"encoding/hex"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-)
-
-var (
-	ErrModuleNotRegistered = errors.New("moduleregistry: modul muss vor provisionierung registriert sein")
-	ErrInvalidCredential   = errors.New("moduleregistry: ungueltiges oder fehlendes service-credential")
-)
-
-// Provision stellt ein Service-Credential (Client-ID + Secret) fuer eine
-// Modul-Instanz aus (Akzeptanzkriterium 4). Das Secret wird NUR beim
-// Ausstellen im Klartext zurueckgegeben, gespeichert wird ausschliesslich
-// dessen SHA-256-Hash.
-func (r *Registry) Provision(ctx context.Context, moduleName string) (clientID, secret string, err error) {
-	if _, err := r.Get(ctx, moduleName); err != nil {
-		if errors.Is(err, ErrModuleNotFound) {
-			return "", "", ErrModuleNotRegistered
-		}
-		return "", "", err
-	}
-
-	clientID, err = randomToken(16)
-	if err != nil {
-		return "", "", fmt.Errorf("client-id erzeugen: %w", err)
-	}
-	secret, err = randomToken(32)
-	if err != nil {
-		return "", "", fmt.Errorf("secret erzeugen: %w", err)
-	}
-	hash := hashSecret(secret)
-
-	_, err = r.pool.Exec(ctx, `
-		INSERT INTO module_credentials (module_name, client_id, secret_hash, issued_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (module_name) DO UPDATE SET client_id = $2, secret_hash = $3, issued_at = now()
-	`, moduleName, clientID, hash)
-	if err != nil {
-		return "", "", fmt.Errorf("credential speichern: %w", err)
-	}
-	return clientID, secret, nil
-}
-
-// Authenticate prueft ein Service-Credential timing-safe (Referenzmuster
-// siehe AUD-02) — Aufrufe ohne gueltiges Credential werden abgelehnt
-// (Akzeptanzkriterium 4 / Pruefung 4).
-func (r *Registry) Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error) {
-	if clientID == "" || secret == "" {
-		return "", false, nil
-	}
-
-	var storedHash []byte
-	err = r.pool.QueryRow(ctx, `
-		SELECT module_name, secret_hash FROM module_credentials WHERE client_id = $1
-	`, clientID).Scan(&moduleName, &storedHash)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return "", false, nil
-		}
-		return "", false, fmt.Errorf("credential lesen: %w", err)
-	}
-
-	if !timingSafeEqual(hashSecret(secret), storedHash) {
-		return "", false, nil
-	}
-	return moduleName, true, nil
-}
-
-func randomToken(n int) (string, error) {
-	buf := make([]byte, n)
-	if _, err := rand.Read(buf); err != nil {
-		return "", err
-	}
-	return hex.EncodeToString(buf), nil
-}
-
-func hashSecret(secret string) []byte {
-	sum := sha256.Sum256([]byte(secret))
-	return sum[:]
-}
-
-// timingSafeEqual folgt derselben Referenzimplementierung wie AUD-02
-// (subtle.ConstantTimeCompare) — projektweite Konvention fuer jeden
-// sicherheitsrelevanten Vergleich.
-func timingSafeEqual(a, b []byte) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	return subtle.ConstantTimeCompare(a, b) == 1
-}

internal/moduleregistry/middleware.go

@@ -1,46 +0,0 @@
-package moduleregistry
-
-import "net/http"
-
-// RequireActiveModule weist Anfragen an ein nicht aktiviertes Modul ZENTRAL
-// ab, bevor der eigentliche Modul-Handler erreicht wird (Akzeptanzkriterium 2 /
-// Pruefung 1) — Casbin-Prinzip: Durchsetzung als Middleware statt verstreuter
-// Pruefungen in jedem Handler. tenantSlug/moduleName werden hier ueber
-// Query-Parameter gelesen (echte Extraktion aus JWT/Tenant-Kontext ist
-// API-05/TEN-06, nicht Teil dieser Kachel).
-func (r *Registry) RequireActiveModule(moduleName string, next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		tenantSlug := req.URL.Query().Get("tenant")
-		active, err := r.IsActive(req.Context(), tenantSlug, moduleName)
-		if err != nil {
-			http.Error(w, "aktivierungspruefung fehlgeschlagen", http.StatusInternalServerError)
-			return
-		}
-		if !active {
-			http.Error(w, "modul nicht aktiviert", http.StatusForbidden)
-			return
-		}
-		next(w, req)
-	}
-}
-
-// RequireServiceCredential authentifiziert eine Modul-Instanz ueber ihr
-// Service-Credential (X-Client-Id/X-Client-Secret-Header) BEVOR der
-// eigentliche Handler erreicht wird (Akzeptanzkriterium 4 / Pruefung 4).
-func (r *Registry) RequireServiceCredential(next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		clientID := req.Header.Get("X-Client-Id")
-		secret := req.Header.Get("X-Client-Secret")
-
-		_, ok, err := r.Authenticate(req.Context(), clientID, secret)
-		if err != nil {
-			http.Error(w, "authentifizierung fehlgeschlagen", http.StatusInternalServerError)
-			return
-		}
-		if !ok {
-			http.Error(w, ErrInvalidCredential.Error(), http.StatusUnauthorized)
-			return
-		}
-		next(w, req)
-	}
-}

internal/moduleregistry/registry.go

@@ -1,120 +0,0 @@
-// Package moduleregistry implementiert Core API-02: die Registry, in der
-// sich Fachmodule (DMS, Mail, weitere) mit Metadaten eintragen, gekoppelt an
-// die Aktivierungspruefung aus LIC-02 (Feature-Flags). Zusaetzlich
-// authentifiziert die Registry Modul-Instanzen selbst ueber ein bei
-// Provisionierung ausgestelltes Service-Credential.
-package moduleregistry
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-)
-
-var (
-	ErrMissingName    = errors.New("moduleregistry: name darf nicht leer sein")
-	ErrMissingVersion = errors.New("moduleregistry: version darf nicht leer sein")
-	ErrModuleNotFound = errors.New("moduleregistry: modul nicht registriert")
-)
-
-type Module struct {
-	Name          string
-	Version       string
-	RequiredFlags []string
-}
-
-type Registry struct {
-	pool  *pgxpool.Pool
-	flags *flag.Service
-}
-
-func NewRegistry(pool *pgxpool.Pool, flags *flag.Service) *Registry {
-	return &Registry{pool: pool, flags: flags}
-}
-
-// Register traegt ein Modul mit Name, Version und benoetigten Feature-Flags
-// ein (Akzeptanzkriterium 1). Fehlende Pflichtangaben werden abgewiesen
-// (Akzeptanzkriterium 1 / Pruefung 2). Erneutes Register desselben Namens
-// aktualisiert Version/Flags (Redeploy-Fall).
-func (r *Registry) Register(ctx context.Context, name, version string, requiredFlags []string) (Module, error) {
-	if name == "" {
-		return Module{}, ErrMissingName
-	}
-	if version == "" {
-		return Module{}, ErrMissingVersion
-	}
-	if requiredFlags == nil {
-		requiredFlags = []string{}
-	}
-
-	_, err := r.pool.Exec(ctx, `
-		INSERT INTO modules (name, version, required_flags, registered_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (name) DO UPDATE SET version = $2, required_flags = $3, registered_at = now()
-	`, name, version, requiredFlags)
-	if err != nil {
-		return Module{}, fmt.Errorf("modul registrieren: %w", err)
-	}
-	return Module{Name: name, Version: version, RequiredFlags: requiredFlags}, nil
-}
-
-func (r *Registry) Get(ctx context.Context, name string) (Module, error) {
-	var m Module
-	m.Name = name
-	err := r.pool.QueryRow(ctx, `
-		SELECT version, required_flags FROM modules WHERE name = $1
-	`, name).Scan(&m.Version, &m.RequiredFlags)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Module{}, ErrModuleNotFound
-		}
-		return Module{}, fmt.Errorf("modul lesen: %w", err)
-	}
-	return m, nil
-}
-
-// List liefert alle registrierten Module (Akzeptanzkriterium 3: ueber API
-// abfragbar, z.B. fuer Statusseite/Lizenzoberflaeche).
-func (r *Registry) List(ctx context.Context) ([]Module, error) {
-	rows, err := r.pool.Query(ctx, `SELECT name, version, required_flags FROM modules ORDER BY name`)
-	if err != nil {
-		return nil, fmt.Errorf("module auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Module
-	for rows.Next() {
-		var m Module
-		if err := rows.Scan(&m.Name, &m.Version, &m.RequiredFlags); err != nil {
-			return nil, fmt.Errorf("modul lesen: %w", err)
-		}
-		out = append(out, m)
-	}
-	return out, rows.Err()
-}
-
-// IsActive prueft, ob ein registriertes Modul fuer einen Tenant aktiviert
-// ist: registriert UND alle benoetigten Feature-Flags sind fuer diesen
-// Tenant aktiv (Akzeptanzkriterium 2). Ein nicht registriertes Modul gilt
-// immer als nicht aktiv.
-func (r *Registry) IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error) {
-	m, err := r.Get(ctx, moduleName)
-	if err != nil {
-		if errors.Is(err, ErrModuleNotFound) {
-			return false, nil
-		}
-		return false, err
-	}
-
-	for _, flagKey := range m.RequiredFlags {
-		if !r.flags.IsEnabled(ctx, tenantSlug, flagKey) {
-			return false, nil
-		}
-	}
-	return true, nil
-}

internal/moduleregistry/registry_test.go

@@ -1,304 +0,0 @@
-package moduleregistry
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
-)
-
-func setupTest(t *testing.T) (*Registry, *flag.Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS feature_flags (
-			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
-			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS modules (
-			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
-			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS module_credentials (
-			module_name TEXT PRIMARY KEY REFERENCES modules(name),
-			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	flagStore := flag.NewStore(pool)
-	// Kurze TTL, damit Tests, die den Flag-Store direkt aendern (an
-	// Registry.IsActive vorbei), den neuen Stand ohne manuelles Invalidate
-	// zuverlaessig sehen.
-	flagService := flag.NewService(flagStore, 10*time.Millisecond)
-	registry := NewRegistry(pool, flagService)
-
-	cleanup := func() { pool.Close() }
-	return registry, flagStore, cleanup
-}
-
-func uniqueModuleName(t *testing.T) string {
-	return fmt.Sprintf("dms_%d", time.Now().UnixNano())
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: fehlende Pflichtangaben abgewiesen.
-func TestRegister_RejectsMissingFields(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := registry.Register(ctx, "", "1.0", nil); !errors.Is(err, ErrMissingName) {
-		t.Fatalf("erwartet ErrMissingName, habe %v", err)
-	}
-	if _, err := registry.Register(ctx, "dms", "", nil); !errors.Is(err, ErrMissingVersion) {
-		t.Fatalf("erwartet ErrMissingVersion, habe %v", err)
-	}
-}
-
-func TestRegister_AndGet(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	m, err := registry.Register(ctx, name, "1.2.0", []string{"dms_enabled"})
-	if err != nil {
-		t.Fatalf("register: %v", err)
-	}
-	if m.Version != "1.2.0" || len(m.RequiredFlags) != 1 {
-		t.Fatalf("unerwartet: %+v", m)
-	}
-
-	got, err := registry.Get(ctx, name)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if got.Version != "1.2.0" {
-		t.Fatalf("get version = %q", got.Version)
-	}
-}
-
-// Akzeptanzkriterium 2 + 3 + Pruefung 3: konsistente Daten nach
-// Aktivierung/Deaktivierung eines Moduls.
-func TestIsActive_ReflectsFlagStateConsistently(t *testing.T) {
-	registry, flagStore, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-	flagKey := name + "_enabled"
-
-	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	active, err := registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (vor flag): %v", err)
-	}
-	if active {
-		t.Fatal("erwartet nicht aktiv, solange flag nicht gesetzt ist")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond) // TTL abwarten
-
-	active, err = registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (nach flag an): %v", err)
-	}
-	if !active {
-		t.Fatal("erwartet aktiv, nachdem flag aktiviert wurde")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: false}); err != nil {
-		t.Fatalf("flag zuruecksetzen: %v", err)
-	}
-	time.Sleep(20 * time.Millisecond) // TTL abwarten
-	active, err = registry.IsActive(ctx, "acme", name)
-	if err != nil {
-		t.Fatalf("is active (nach flag aus): %v", err)
-	}
-	if active {
-		t.Fatal("erwartet wieder nicht aktiv, nachdem flag deaktiviert wurde")
-	}
-}
-
-func TestIsActive_UnregisteredModuleIsNeverActive(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	active, err := registry.IsActive(ctx, "acme", "nie-registriert")
-	if err != nil {
-		t.Fatalf("is active: %v", err)
-	}
-	if active {
-		t.Fatal("unregistriertes modul darf nie aktiv sein")
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Anfrage an deaktiviertes Modul wird
-// zentral abgewiesen, BEVOR die Modul-Logik erreicht wird.
-func TestRequireActiveModule_BlocksBeforeHandler(t *testing.T) {
-	registry, flagStore, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-	flagKey := name + "_enabled"
-
-	if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	handlerReached := false
-	handler := registry.RequireActiveModule(name, func(w http.ResponseWriter, r *http.Request) {
-		handlerReached = true
-		w.WriteHeader(http.StatusOK)
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
-	rec := httptest.NewRecorder()
-	handler(rec, req)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("status = %d, want 403", rec.Code)
-	}
-	if handlerReached {
-		t.Fatal("handler haette bei deaktiviertem modul NICHT erreicht werden duerfen")
-	}
-
-	if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
-		t.Fatalf("flag setzen: %v", err)
-	}
-	req2 := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
-	rec2 := httptest.NewRecorder()
-	handler(rec2, req2)
-	if rec2.Code != http.StatusOK {
-		t.Fatalf("status nach aktivierung = %d, want 200", rec2.Code)
-	}
-	if !handlerReached {
-		t.Fatal("handler haette bei aktiviertem modul erreicht werden muessen")
-	}
-}
-
-// Akzeptanzkriterium 4 + Pruefung 4: gueltiges/ungueltiges Service-Credential.
-func TestProvisionAndAuthenticate(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-
-	clientID, secret, err := registry.Provision(ctx, name)
-	if err != nil {
-		t.Fatalf("provision: %v", err)
-	}
-	if clientID == "" || secret == "" {
-		t.Fatal("erwartet nicht-leere client-id/secret")
-	}
-
-	moduleName, ok, err := registry.Authenticate(ctx, clientID, secret)
-	if err != nil {
-		t.Fatalf("authenticate (korrekt): %v", err)
-	}
-	if !ok || moduleName != name {
-		t.Fatalf("erwartet erfolgreiche authentifizierung fuer %q, habe ok=%v moduleName=%q", name, ok, moduleName)
-	}
-
-	_, ok, err = registry.Authenticate(ctx, clientID, "falsches-secret")
-	if err != nil {
-		t.Fatalf("authenticate (falsch): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet fehlschlag bei falschem secret")
-	}
-
-	_, ok, err = registry.Authenticate(ctx, "unbekannte-client-id", secret)
-	if err != nil {
-		t.Fatalf("authenticate (unbekannt): %v", err)
-	}
-	if ok {
-		t.Fatal("erwartet fehlschlag bei unbekannter client-id")
-	}
-}
-
-func TestProvision_RequiresRegisteredModule(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, _, err := registry.Provision(ctx, "nie-registriert"); !errors.Is(err, ErrModuleNotRegistered) {
-		t.Fatalf("erwartet ErrModuleNotRegistered, habe %v", err)
-	}
-}
-
-func TestRequireServiceCredential_RejectsInvalidAcceptsValid(t *testing.T) {
-	registry, _, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	name := uniqueModuleName(t)
-
-	if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
-		t.Fatalf("register: %v", err)
-	}
-	clientID, secret, err := registry.Provision(ctx, name)
-	if err != nil {
-		t.Fatalf("provision: %v", err)
-	}
-
-	handler := registry.RequireServiceCredential(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	})
-
-	// Fehlendes Credential.
-	req := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	rec := httptest.NewRecorder()
-	handler(rec, req)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("ohne credential: status = %d, want 401", rec.Code)
-	}
-
-	// Falsches Secret.
-	req2 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	req2.Header.Set("X-Client-Id", clientID)
-	req2.Header.Set("X-Client-Secret", "falsch")
-	rec2 := httptest.NewRecorder()
-	handler(rec2, req2)
-	if rec2.Code != http.StatusUnauthorized {
-		t.Fatalf("falsches secret: status = %d, want 401", rec2.Code)
-	}
-
-	// Gueltiges Credential.
-	req3 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
-	req3.Header.Set("X-Client-Id", clientID)
-	req3.Header.Set("X-Client-Secret", secret)
-	rec3 := httptest.NewRecorder()
-	handler(rec3, req3)
-	if rec3.Code != http.StatusOK {
-		t.Fatalf("gueltiges credential: status = %d, want 200", rec3.Code)
-	}
-}

internal/notifyprefs/handler.go

@@ -0,0 +1,83 @@
+package notifyprefs
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+// Handler stellt Benachrichtigungspraeferenzen als HTTP-Endpunkte bereit
+// (CFG-04). Duenner Client von Store — keine eigene Zustelllogik.
+type Handler struct {
+	prefs *Store
+}
+
+func NewHandler(prefs *Store) *Handler {
+	return &Handler{prefs: prefs}
+}
+
+type setPreferenceRequest struct {
+	EventType string `json:"event_type"`
+	Channel   string `json:"channel"`
+	Enabled   bool   `json:"enabled"`
+}
+
+// SetPreference setzt die eigene Praeferenz des angemeldeten Benutzers
+// (Akzeptanzkriterium 1). Muss hinter auth.RequireAuth haengen.
+func (h *Handler) SetPreference(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	var req setPreferenceRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+	if err := h.prefs.Set(r.Context(), claims.TenantSlug, claims.UserID, req.EventType, req.Channel, req.Enabled); err != nil {
+		http.Error(w, "Einstellung konnte nicht gespeichert werden.", http.StatusBadRequest)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// ListMine liefert die eigenen Praeferenzen (Akzeptanzkriterium 1) — nur die
+// EIGENEN, niemals die eines anderen Benutzers (Pruefung 2). claims.UserID
+// kommt ausschliesslich aus dem verifizierten Session-Token, ist also nicht
+// vom Client manipulierbar.
+func (h *Handler) ListMine(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	prefs, err := h.prefs.ListForUser(r.Context(), claims.TenantSlug, claims.UserID)
+	if err != nil {
+		http.Error(w, "Einstellungen konnten nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(prefs)
+}
+
+// ListTenantOverview liefert die Praeferenzen ALLER Benutzer des eigenen
+// Mandanten (Akzeptanzkriterium 3: Tenant-Admin-Übersicht). Die Zugriffs-
+// beschraenkung "nur Tenant-Admin" ist Aufgabe von RBAC-02 (Policy-
+// Enforcement-Schicht) vor diesem Handler — hier wird bewusst keine eigene
+// Rechtelogik dupliziert (Ticket-Produkt-DNA: duenner Client).
+func (h *Handler) ListTenantOverview(w http.ResponseWriter, r *http.Request) {
+	claims, ok := auth.ClaimsFromContext(r.Context())
+	if !ok {
+		http.Error(w, "nicht angemeldet", http.StatusUnauthorized)
+		return
+	}
+	prefs, err := h.prefs.ListForTenant(r.Context(), claims.TenantSlug)
+	if err != nil {
+		http.Error(w, "Übersicht konnte nicht geladen werden.", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(prefs)
+}

internal/notifyprefs/handler_test.go

@@ -0,0 +1,122 @@
+package notifyprefs
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
+)
+
+func sessionCookie(t *testing.T, issuer *auth.TokenIssuer, userID, tenantSlug string) *http.Cookie {
+	t.Helper()
+	token, err := issuer.Issue(userID, tenantSlug)
+	if err != nil {
+		t.Fatalf("session-token ausstellen: %v", err)
+	}
+	return &http.Cookie{Name: auth.CookieName, Value: token}
+}
+
+// Akzeptanzkriterium 1: Benutzer setzt eigene Praeferenz per HTTP.
+func TestHandlerSetAndListMine(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+	cookie := sessionCookie(t, issuer, "user-1", "acme")
+
+	setBody, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+	setReq := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(setBody))
+	setReq.AddCookie(cookie)
+	setRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetPreference)(setRec, setReq)
+	if setRec.Code != http.StatusOK {
+		t.Fatalf("set: status = %d, body: %s", setRec.Code, setRec.Body.String())
+	}
+
+	listReq := httptest.NewRequest(http.MethodGet, "/notifications/preferences", nil)
+	listReq.AddCookie(cookie)
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListMine)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list: status = %d, body: %s", listRec.Code, listRec.Body.String())
+	}
+	var out []Preference
+	if err := json.Unmarshal(listRec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 1 || out[0].Enabled {
+		t.Fatalf("erwartet genau 1 deaktivierte praeferenz, habe %+v", out)
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 2: ListMine zeigt AUSSCHLIESSLICH die
+// eigenen Praeferenzen — die UserID kommt aus dem Session-Token, nicht aus
+// einem vom Client kontrollierbaren Parameter.
+func TestHandlerListMine_NeverShowsOtherUsersPreferences(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	setBody, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+	setReq := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(setBody))
+	setReq.AddCookie(sessionCookie(t, issuer, "user-1", "acme"))
+	setRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.SetPreference)(setRec, setReq)
+	if setRec.Code != http.StatusOK {
+		t.Fatalf("set fuer user-1: status = %d", setRec.Code)
+	}
+
+	// user-2 fragt seine eigenen Praeferenzen ab — muss leer sein.
+	listReq := httptest.NewRequest(http.MethodGet, "/notifications/preferences", nil)
+	listReq.AddCookie(sessionCookie(t, issuer, "user-2", "acme"))
+	listRec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListMine)(listRec, listReq)
+	if listRec.Code != http.StatusOK {
+		t.Fatalf("list fuer user-2: status = %d", listRec.Code)
+	}
+	var out []Preference
+	if err := json.Unmarshal(listRec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 0 {
+		t.Fatalf("user-2 haette user-1s praeferenzen NICHT sehen duerfen, habe %+v", out)
+	}
+}
+
+// Akzeptanzkriterium 3: Tenant-Übersicht liefert alle Benutzer des Mandanten.
+func TestHandlerListTenantOverview(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	h := NewHandler(prefs)
+	issuer := auth.NewTokenIssuer("test-secret")
+
+	for _, u := range []string{"user-1", "user-2"} {
+		body, _ := json.Marshal(setPreferenceRequest{EventType: "welcome", Channel: "email", Enabled: false})
+		req := httptest.NewRequest(http.MethodPost, "/notifications/preferences", bytes.NewReader(body))
+		req.AddCookie(sessionCookie(t, issuer, u, "acme"))
+		rec := httptest.NewRecorder()
+		auth.RequireAuth(issuer, h.SetPreference)(rec, req)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("set fuer %s: status = %d", u, rec.Code)
+		}
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/notifications/preferences/tenant", nil)
+	req.AddCookie(sessionCookie(t, issuer, "admin-1", "acme"))
+	rec := httptest.NewRecorder()
+	auth.RequireAuth(issuer, h.ListTenantOverview)(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("overview: status = %d, body: %s", rec.Code, rec.Body.String())
+	}
+	var out []Preference
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response dekodieren: %v", err)
+	}
+	if len(out) != 2 {
+		t.Fatalf("erwartet 2 eintraege (beide Benutzer), habe %d", len(out))
+	}
+}

internal/notifyprefs/prefs.go

@@ -0,0 +1,144 @@
+// Package notifyprefs implementiert Core CFG-04: Benachrichtigungspräferenzen
+// je Benutzer, Ereignistyp und Kanal. Duenner Client von CFG-02/03 — keine
+// eigene Zustelllogik, nur ein Filter DAVOR, ob eine Benachrichtigung
+// überhaupt in die Warteschlange (internal/notify.Dispatcher) eingereiht wird.
+package notifyprefs
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+type Preference struct {
+	TenantSlug string
+	UserID     string
+	EventType  string
+	Channel    string
+	Enabled    bool
+}
+
+// Store verwaltet Benachrichtigungspraeferenzen in der zentralen Registry-DB
+// (gleiche Ablageebene wie CFG-03s notification_templates/in_app_notifications).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set setzt die Praeferenz eines Benutzers fuer einen Ereignistyp+Kanal
+// (Akzeptanzkriterium 1). Wirkt sofort — es gibt keinen Cache dazwischen,
+// jede Pruefung (IsEnabled) liest direkt aus der DB (Akzeptanzkriterium 2).
+func (s *Store) Set(ctx context.Context, tenantSlug, userID, eventType, channel string, enabled bool) error {
+	if tenantSlug == "" || userID == "" || eventType == "" || channel == "" {
+		return errors.New("notifyprefs: tenantSlug, userID, eventType und channel duerfen nicht leer sein")
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_preferences (tenant_slug, user_id, event_type, channel, enabled)
+		VALUES ($1, $2, $3, $4, $5)
+		ON CONFLICT (tenant_slug, user_id, event_type, channel)
+		DO UPDATE SET enabled = $5, updated_at = now()
+	`, tenantSlug, userID, eventType, channel, enabled)
+	if err != nil {
+		return fmt.Errorf("praeferenz speichern: %w", err)
+	}
+	return nil
+}
+
+// IsEnabled prueft, ob ein Kanal fuer einen Ereignistyp aktiv ist. Ohne
+// explizite Praeferenz gilt der Kanal als AKTIVIERT (Opt-out-Default,
+// siehe Migration).
+func (s *Store) IsEnabled(ctx context.Context, tenantSlug, userID, eventType, channel string) (bool, error) {
+	var enabled bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT enabled FROM notification_preferences
+		WHERE tenant_slug = $1 AND user_id = $2 AND event_type = $3 AND channel = $4
+	`, tenantSlug, userID, eventType, channel).Scan(&enabled)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return true, nil
+		}
+		return false, fmt.Errorf("praeferenz lesen: %w", err)
+	}
+	return enabled, nil
+}
+
+// ListForUser liefert alle expliziten Praeferenzen eines Benutzers
+// (Akzeptanzkriterium 1: eigene Einstellungen einsehen/aendern).
+func (s *Store) ListForUser(ctx context.Context, tenantSlug, userID string) ([]Preference, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT event_type, channel, enabled FROM notification_preferences
+		WHERE tenant_slug = $1 AND user_id = $2
+		ORDER BY event_type, channel
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("praeferenzen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Preference
+	for rows.Next() {
+		p := Preference{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&p.EventType, &p.Channel, &p.Enabled); err != nil {
+			return nil, fmt.Errorf("praeferenz lesen: %w", err)
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
+
+// ListForTenant liefert ALLE expliziten Praeferenzen aller Benutzer eines
+// Mandanten (Akzeptanzkriterium 3: Tenant-Admin-Übersicht).
+func (s *Store) ListForTenant(ctx context.Context, tenantSlug string) ([]Preference, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT user_id, event_type, channel, enabled FROM notification_preferences
+		WHERE tenant_slug = $1
+		ORDER BY user_id, event_type, channel
+	`, tenantSlug)
+	if err != nil {
+		return nil, fmt.Errorf("mandanten-praeferenzen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Preference
+	for rows.Next() {
+		p := Preference{TenantSlug: tenantSlug}
+		if err := rows.Scan(&p.UserID, &p.EventType, &p.Channel, &p.Enabled); err != nil {
+			return nil, fmt.Errorf("praeferenz lesen: %w", err)
+		}
+		out = append(out, p)
+	}
+	return out, rows.Err()
+}
+
+// EnqueueIfAllowed ist der einzige vorgesehene Weg, wie ein Modul eine
+// Benachrichtigung fuer einen konkreten Benutzer+Ereignistyp auslöst: prueft
+// zuerst die Praeferenz, reiht NUR bei Aktivierung tatsaechlich in
+// internal/notify.Dispatcher ein (Akzeptanzkriterium 1 / Pruefung 1 — ein
+// deaktivierter Kanal erzeugt nachweislich KEINE notification_jobs-Zeile,
+// nicht nur eine ignorierte). skipped=true bedeutet: bewusst nicht zugestellt,
+// kein Fehler.
+func EnqueueIfAllowed(
+	ctx context.Context,
+	prefs *Store,
+	dispatcher *notify.Dispatcher,
+	tenantSlug, userID, eventType, channel, recipient string,
+	payload map[string]any,
+) (jobID string, skipped bool, err error) {
+	enabled, err := prefs.IsEnabled(ctx, tenantSlug, userID, eventType, channel)
+	if err != nil {
+		return "", false, err
+	}
+	if !enabled {
+		return "", true, nil
+	}
+	jobID, err = dispatcher.Enqueue(ctx, channel, recipient, payload)
+	return jobID, false, err
+}

internal/notifyprefs/prefs_test.go

@@ -0,0 +1,183 @@
+package notifyprefs
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*Store, *notify.Dispatcher, *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 notification_preferences (
+			tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL, event_type TEXT NOT NULL, channel TEXT NOT NULL,
+			enabled BOOLEAN NOT NULL, updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (tenant_slug, user_id, event_type, channel)
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending', attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM notification_preferences`)
+		_, _ = pool.Exec(ctx, `DELETE FROM notification_jobs`)
+		pool.Close()
+	}
+	return NewStore(pool), notify.NewDispatcher(pool), pool, cleanup
+}
+
+// Ohne explizite Praeferenz gilt ein Kanal als aktiviert (Opt-out-Default).
+func TestIsEnabled_DefaultsToTrueWithoutPreference(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	enabled, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled: %v", err)
+	}
+	if !enabled {
+		t.Fatal("erwartet aktiviert als default ohne gesetzte praeferenz")
+	}
+}
+
+// Akzeptanzkriterium 1 + 2: gesetzte Praeferenz wirkt sofort.
+func TestSetAndIsEnabled(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	enabled, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled: %v", err)
+	}
+	if enabled {
+		t.Fatal("erwartet deaktiviert nach Set(..., false)")
+	}
+
+	// Andere Kanaele/Ereignistypen desselben Benutzers bleiben unberuehrt.
+	stillOn, err := prefs.IsEnabled(ctx, "acme", "user-1", "welcome", "in_app")
+	if err != nil {
+		t.Fatalf("is enabled (anderer kanal): %v", err)
+	}
+	if !stillOn {
+		t.Fatal("erwartet: anderer kanal bleibt aktiviert")
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 2: Einstellungen eines Benutzers wirken
+// sich NICHT auf einen anderen Benutzer aus.
+func TestSet_DoesNotAffectOtherUser(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set fuer user-1: %v", err)
+	}
+
+	enabledForOther, err := prefs.IsEnabled(ctx, "acme", "user-2", "welcome", "email")
+	if err != nil {
+		t.Fatalf("is enabled fuer user-2: %v", err)
+	}
+	if !enabledForOther {
+		t.Fatal("praeferenz von user-1 haette user-2 nicht beeinflussen duerfen")
+	}
+}
+
+// Akzeptanzkriterium 1 / Pruefung 1 (Kernbeweis): ein deaktivierter Kanal
+// erhaelt NACHWEISLICH keine weitere Zustellung — geprueft ueber die
+// tatsaechliche notification_jobs-Tabelle, nicht nur ueber den Rueckgabewert.
+func TestEnqueueIfAllowed_SkipsWhenDisabled(t *testing.T) {
+	prefs, dispatcher, pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "invoice_ready", "email", false); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	jobID, skipped, err := EnqueueIfAllowed(ctx, prefs, dispatcher, "acme", "user-1", "invoice_ready", "email", "user1@acme.example", nil)
+	if err != nil {
+		t.Fatalf("enqueue if allowed: %v", err)
+	}
+	if !skipped {
+		t.Fatal("erwartet skipped=true bei deaktiviertem kanal")
+	}
+	if jobID != "" {
+		t.Fatalf("erwartet keine job-id, habe %q", jobID)
+	}
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM notification_jobs`).Scan(&count); err != nil {
+		t.Fatalf("notification_jobs zaehlen: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("erwartet 0 eingereihte jobs bei deaktiviertem kanal, habe %d", count)
+	}
+}
+
+func TestEnqueueIfAllowed_EnqueuesWhenEnabled(t *testing.T) {
+	prefs, dispatcher, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	jobID, skipped, err := EnqueueIfAllowed(ctx, prefs, dispatcher, "acme", "user-1", "invoice_ready", "email", "user1@acme.example", nil)
+	if err != nil {
+		t.Fatalf("enqueue if allowed: %v", err)
+	}
+	if skipped {
+		t.Fatal("erwartet skipped=false ohne deaktivierte praeferenz")
+	}
+	if jobID == "" {
+		t.Fatal("erwartet gesetzte job-id")
+	}
+}
+
+// Akzeptanzkriterium 3: Tenant-Admin-Übersicht zeigt alle Benutzer.
+func TestListForTenant_ShowsAllUsers(t *testing.T) {
+	prefs, _, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := prefs.Set(ctx, "acme", "user-1", "welcome", "email", false); err != nil {
+		t.Fatalf("set user-1: %v", err)
+	}
+	if err := prefs.Set(ctx, "acme", "user-2", "welcome", "in_app", false); err != nil {
+		t.Fatalf("set user-2: %v", err)
+	}
+	if err := prefs.Set(ctx, "other-tenant", "user-3", "welcome", "email", false); err != nil {
+		t.Fatalf("set user-3 (anderer tenant): %v", err)
+	}
+
+	overview, err := prefs.ListForTenant(ctx, "acme")
+	if err != nil {
+		t.Fatalf("list for tenant: %v", err)
+	}
+	if len(overview) != 2 {
+		t.Fatalf("erwartet 2 eintraege fuer tenant acme (nicht den anderen tenant), habe %d", len(overview))
+	}
+}

internal/user/handler.go

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

internal/user/store_test.go

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

internal/user/superadmin_store.go

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

internal/user/tenant_store.go

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

internal/user/user.go

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

internal/user/user_test.go

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

migrations/0002_superadmins.down.sql

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

migrations/0002_superadmins.up.sql

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

migrations/0004_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_alert_rules.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE alert_debounce_state;
-DROP TABLE alert_rules;

migrations/0006_alert_rules.up.sql

@@ -1,24 +0,0 @@
--- OPS-05: Schwellwert-Regeln fuer Alerting auf den aus OPS-03 aggregierten
--- Metriken. Lebt wie config_values/notification_jobs (CFG-01/02) in der
--- zentralen Registry-DB — modulübergreifende Betriebskonfiguration, keine
--- Mandanten-Geschaeftsdaten.
-CREATE TABLE alert_rules (
-    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    metric_name   TEXT NOT NULL,
-    comparison    TEXT NOT NULL CHECK (comparison IN ('gt', 'lt')),
-    threshold     DOUBLE PRECISION NOT NULL,
-    label_filters JSONB NOT NULL DEFAULT '{}'::jsonb,
-    recipient     TEXT NOT NULL,
-    description   TEXT NOT NULL DEFAULT '',
-    created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-
--- Haelt fest, wann eine Regel zuletzt tatsaechlich einen Alarm ausgeloest
--- hat (Akzeptanzkriterium 3: Drosselung wiederholter Alarmierung fuer
--- denselben anhaltenden Zustand). rule_key kombiniert Regel-ID mit den
--- tatsaechlichen Label-Werten der ausloesenden Zeitreihe, damit dieselbe
--- Regel fuer unterschiedliche Tenants/Module unabhaengig gedrosselt wird.
-CREATE TABLE alert_debounce_state (
-    rule_key      TEXT PRIMARY KEY,
-    last_fired_at TIMESTAMPTZ NOT NULL
-);

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/0006_notification_channels.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS in_app_notifications;
+DROP TABLE IF EXISTS notification_templates;

migrations/0006_notification_channels.up.sql

@@ -0,0 +1,28 @@
+-- Benachrichtigungs-Kanaele: Vorlagen (E-Mail) + In-App-Nachrichten
+-- (CFG-03, siehe core-kanban/tickets/CFG-03.md). Beide leben in der
+-- Registry-DB, analog zu feature_flags/config_values — modulübergreifende
+-- Konfiguration/UI-Zustand, keine Mandanten-Geschaeftsdaten.
+
+-- tenant_slug = 'global' ist der Fallback-Wert, wenn ein Tenant keine
+-- eigene Vorlage gesetzt hat (Akzeptanzkriterium 3: Vorlagen pro Tenant
+-- anpassbar, mit sinnvollem Default).
+CREATE TABLE notification_templates (
+    tenant_slug TEXT NOT NULL,
+    key         TEXT NOT NULL,
+    subject     TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_slug, key)
+);
+
+CREATE TABLE in_app_notifications (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_slug TEXT NOT NULL,
+    user_id     TEXT NOT NULL,
+    title       TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    read_at     TIMESTAMPTZ,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX in_app_notifications_user_idx ON in_app_notifications (tenant_slug, user_id, created_at);

migrations/0007_notification_preferences.down.sql

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

migrations/0007_notification_preferences.up.sql

@@ -0,0 +1,17 @@
+-- CFG-04: Benachrichtigungspraeferenzen je Benutzer, Ereignistyp und Kanal.
+-- Lebt wie notification_templates/in_app_notifications (CFG-03) in der
+-- Registry-DB — modulübergreifende Konfiguration, keine Mandanten-Geschaeftsdaten.
+--
+-- Kein Row = aktiviert (Opt-out-Modell): ein Benutzer verpasst nichts, bis er
+-- aktiv einen Kanal/Ereignistyp abschaltet — sicherer Default als Opt-in.
+CREATE TABLE notification_preferences (
+    tenant_slug TEXT NOT NULL,
+    user_id     TEXT NOT NULL,
+    event_type  TEXT NOT NULL,
+    channel     TEXT NOT NULL,
+    enabled     BOOLEAN NOT NULL,
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_slug, user_id, event_type, channel)
+);
+
+CREATE INDEX notification_preferences_tenant_idx ON notification_preferences (tenant_slug);

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

scripts/run-checks.sh

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

web/notifications/app/layout.tsx

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

web/notifications/app/overview/page.tsx

@@ -0,0 +1,43 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Table } from "@nexarch/shl";
+import type { TableColumn } from "@nexarch/shl";
+import { Preference, fetchTenantOverview } from "../../lib/api";
+
+// Akzeptanzkriterium 3: Tenant-Admin sieht eine Übersicht der
+// Benachrichtigungs-Konfiguration seines Tenants. Zugriffsbeschränkung
+// (nur Tenant-Admin) ist RBAC-02s Aufgabe vor diesem Endpunkt, siehe
+// internal/notifyprefs/handler.go.
+export default function OverviewPage() {
+  const [prefs, setPrefs] = useState<Preference[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchTenantOverview()
+      .then(setPrefs)
+      .catch(() => setError("Übersicht konnte nicht geladen werden. Nur Tenant-Admins haben Zugriff."));
+  }, []);
+
+  const columns: TableColumn<Preference>[] = [
+    { key: "user", header: "Benutzer-ID", render: (p) => p.UserID },
+    { key: "event", header: "Ereignistyp", render: (p) => p.EventType },
+    { key: "channel", header: "Kanal", render: (p) => p.Channel },
+    { key: "enabled", header: "Aktiviert", render: (p) => (p.Enabled ? "Ja" : "Nein") },
+  ];
+
+  return (
+    <main style={{ maxWidth: 800, margin: "40px auto", padding: "0 16px" }}>
+      <h1>Benachrichtigungs-Übersicht (Mandant)</h1>
+      {error && <p role="alert">{error}</p>}
+      {prefs && (
+        <Table
+          columns={columns}
+          rows={prefs}
+          rowKey={(p) => `${p.UserID}-${p.EventType}-${p.Channel}`}
+          caption="Von der Standardeinstellung abweichende Benachrichtigungspräferenzen aller Benutzer"
+        />
+      )}
+    </main>
+  );
+}

web/notifications/app/page.tsx

@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function IndexPage() {
+  redirect("/settings");
+}

web/notifications/app/settings/page.tsx

@@ -0,0 +1,97 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { CheckboxField, useToast } from "@nexarch/shl";
+import {
+  ApiError,
+  KNOWN_CHANNELS,
+  KNOWN_EVENT_TYPES,
+  Preference,
+  fetchMyPreferences,
+  setPreference,
+} from "../../lib/api";
+
+const EVENT_LABELS: Record<string, string> = {
+  welcome: "Willkommen",
+  invoice_ready: "Rechnung verfügbar",
+  password_reset: "Passwort-Zurücksetzung",
+  security_alert: "Sicherheitshinweis",
+};
+
+const CHANNEL_LABELS: Record<string, string> = {
+  email: "E-Mail",
+  in_app: "In-App",
+};
+
+export default function SettingsPage() {
+  const { push } = useToast();
+  const [prefs, setPrefs] = useState<Preference[] | null>(null);
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const [pending, setPending] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchMyPreferences()
+      .then(setPrefs)
+      .catch(() => setLoadError("Einstellungen konnten nicht geladen werden. Bitte melden Sie sich an."));
+  }, []);
+
+  // Default: aktiviert, solange keine explizite Praeferenz existiert
+  // (Akzeptanzkriterium 1) — gleicher Opt-out-Default wie im Backend.
+  function isEnabled(eventType: string, channel: string): boolean {
+    const explicit = prefs?.find((p) => p.EventType === eventType && p.Channel === channel);
+    return explicit ? explicit.Enabled : true;
+  }
+
+  async function onToggle(eventType: string, channel: string, nextEnabled: boolean) {
+    const key = `${eventType}:${channel}`;
+    setPending(key);
+    try {
+      // Akzeptanzkriterium 2: sofort speichern, kein Sammel-Speichern-Button —
+      // wirkt unmittelbar auf künftige Zustellungen (EnqueueIfAllowed prüft
+      // bei jedem Aufruf live, kein Cache dazwischen).
+      await setPreference(eventType, channel, nextEnabled);
+      setPrefs((current) => {
+        const withoutThis = (current ?? []).filter((p) => !(p.EventType === eventType && p.Channel === channel));
+        return [...withoutThis, { TenantSlug: "", UserID: "", EventType: eventType, Channel: channel, Enabled: nextEnabled }];
+      });
+      push(nextEnabled ? "Benachrichtigung aktiviert." : "Benachrichtigung deaktiviert.", "success");
+    } catch (err) {
+      push(err instanceof ApiError ? err.message : "Einstellung konnte nicht gespeichert werden.", "danger");
+    } finally {
+      setPending(null);
+    }
+  }
+
+  if (loadError) {
+    return (
+      <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
+        <p role="alert">{loadError}</p>
+      </main>
+    );
+  }
+
+  return (
+    <main style={{ maxWidth: 640, margin: "40px auto", padding: "0 16px" }}>
+      <h1>Benachrichtigungseinstellungen</h1>
+      <p>Wählen Sie je Ereignis, über welche Kanäle Sie benachrichtigt werden möchten.</p>
+
+      {KNOWN_EVENT_TYPES.map((eventType) => (
+        <fieldset key={eventType} style={{ marginBottom: 16 }}>
+          <legend>{EVENT_LABELS[eventType] ?? eventType}</legend>
+          {KNOWN_CHANNELS.map((channel) => {
+            const key = `${eventType}:${channel}`;
+            return (
+              <CheckboxField
+                key={key}
+                label={CHANNEL_LABELS[channel] ?? channel}
+                checked={isEnabled(eventType, channel)}
+                disabled={pending === key}
+                onChange={(e) => onToggle(eventType, channel, e.target.checked)}
+              />
+            );
+          })}
+        </fieldset>
+      ))}
+    </main>
+  );
+}

web/notifications/lib/api.ts

@@ -0,0 +1,45 @@
+const API_BASE = process.env.NEXT_PUBLIC_CORE_API_BASE ?? "";
+
+export class ApiError extends Error {}
+
+async function req<T>(path: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(`${API_BASE}${path}`, {
+    credentials: "include",
+    headers: init?.body ? { "Content-Type": "application/json" } : undefined,
+    ...init,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new ApiError(data.error ?? data.message ?? "Unbekannter Fehler");
+  }
+  return data as T;
+}
+
+export interface Preference {
+  TenantSlug: string;
+  UserID: string;
+  EventType: string;
+  Channel: string;
+  Enabled: boolean;
+}
+
+// Bekannte Ereignistypen/Kanäle — das Backend erzwingt keine feste Liste
+// (jedes Modul kann eigene event_type-Werte an EnqueueIfAllowed übergeben),
+// diese Liste ist der aktuell bekannte Stand fürs Frontend-Formular.
+export const KNOWN_EVENT_TYPES = ["welcome", "invoice_ready", "password_reset", "security_alert"] as const;
+export const KNOWN_CHANNELS = ["email", "in_app"] as const;
+
+export function fetchMyPreferences(): Promise<Preference[]> {
+  return req("/notifications/preferences");
+}
+
+export function setPreference(eventType: string, channel: string, enabled: boolean): Promise<void> {
+  return req("/notifications/preferences", {
+    method: "POST",
+    body: JSON.stringify({ event_type: eventType, channel, enabled }),
+  });
+}
+
+export function fetchTenantOverview(): Promise<Preference[]> {
+  return req("/notifications/preferences/tenant");
+}

web/notifications/next.config.mjs

@@ -0,0 +1,5 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;

web/notifications/package.json

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

web/notifications/tsconfig.json

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

web/shl/README.md

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

web/shl/__tests__/Dialog.test.tsx

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

web/shl/__tests__/tokens.test.ts

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

web/shl/components/Dialog.tsx

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

web/shl/components/FormElements.tsx

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

web/shl/components/Shell.tsx

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

web/shl/components/Table.tsx

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

web/shl/components/Toast.tsx

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

web/shl/i18n/i18n.tsx

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

web/shl/index.ts

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

web/shl/package.json

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

web/shl/theme/ThemeProvider.tsx

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

web/shl/tokens/tokens.ts

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

web/shl/tsconfig.json

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

web/shl/vitest.config.ts

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

web/shl/vitest.setup.ts

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