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
DEVLOG: Sessionlog-Eintrag (Auto-Hook)
2026-08-30 21:48:09 +02:00 · 2026-08-28 23:54:01 +02:00 · 2026-08-28 23:53:39 +02:00 · 2026-08-28 23:50:54 +02:00 · 2026-08-28 23:48:23 +02:00 · 2026-08-28 23:48:13 +02:00
116 changed files with 5131 additions and 1311 deletions
@@ -1,2 +1,4 @@
 *.log
 .env
+web/*/node_modules/
+web/*/.next/
@@ -44,3 +44,184 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.

 ---
+## 2026-08-27 17:26 – 17:28 (1m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 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.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:31 – 17:31 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:36 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:37 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+- web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/index.ts                    | 25 +++++++++++++++++++++++++
+- web/shl/package.json                | 23 +++++++++++++++++++++++
+- web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tsconfig.json               | 18 ++++++++++++++++++
+
+---
+## 2026-08-28 21:51 – 21:57 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
+
+### Geänderte Dateien
+- web/shl/package.json     | 2 ++
+- web/shl/vitest.config.ts | 8 ++++++++
+- web/shl/vitest.setup.ts  | 1 +
+
+---
+## 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
+
+### 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 +++++++++++++++++++++
+
+---
+## 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 +++++++++++++++++++++
+
+---
@@ -1,18 +0,0 @@
-version: "2"
-
-run:
-  timeout: 3m
-
-linters:
-  default: none
-  enable:
-    - govet
-    - staticcheck
-    - errcheck
-    - unused
-    - ineffassign
-
-formatters:
-  enable:
-    - gofmt
-    - goimports
@@ -1,19 +0,0 @@
-.PHONY: build lint fmt test check
-
-build:
-	go build ./...
-
-lint:
-	golangci-lint run ./...
-
-fmt:
-	gofmt -l .
-	@test -z "$$(gofmt -l .)" || (echo "gofmt-Verstoesse gefunden, siehe oben" && exit 1)
-
-test:
-	go test ./... -p 1 -count=1
-
-check: build
-	go vet ./...
-	golangci-lint run ./...
-	go test ./... -p 1 -count=1
@@ -1,62 +0,0 @@
-# NEXARCH Archive
-
-Zentrales, modulübergreifendes Modul für Aufbewahrung, WORM, Compliance und
-Backup. Dieses Verzeichnis enthält bisher `internal/backup` (BAK-01,
-Datenbank-Backup-Strategie) — weitere Bausteine folgen ticketweise.
-
-## BAK-01: Datenbank-Backup
-
-`cmd/backup-cli` — Aufrufpunkt für systemd-Timer (siehe
-`../deploy/systemd/nexarch-archive-backup-*.timer`):
-
-```bash
-export NEXARCH_BACKUP_PG_USER=nexarch_backup
-export NEXARCH_BACKUP_PG_PASSWORD=...
-export NEXARCH_BACKUP_DIR=/var/nexarch-archiv/backups/postgres   # NICHT auf einem ephemeren Test-Dataset (siehe Betrieb)
-export NEXARCH_BACKUP_KEEP_GENERATIONS=7   # optional, Default 7
-
-backup-cli full          # neue Vollsicherung + Verifikation
-backup-cli incremental   # inkrementelle Sicherung gegen die neueste Generation
-backup-cli rotate        # entfernt alle bis auf die neuesten N Generationen
-```
-
-Voraussetzung: die konfigurierte Postgres-Rolle braucht das
-`REPLICATION`-Attribut (`pg_basebackup` nutzt eine
-Replikationsverbindung), und `summarize_wal = on` muss serverseitig gesetzt
-sein (PostgreSQL 17s natives inkrementelles Backup, keine WAL-Archivierung
-nötig).
-
-## BAK-02: Objekt-Storage-Backup
-
-`cmd/objectbackup-cli` sichert einen lokalen Verzeichnisbaum (den
-FDN-03-`LocalDriver`-Basisordner direkt, oder — für S3-gestützte
-Deployments — einen vorgelagerten `rclone`-Spiegel) mit
-[restic](https://restic.net) (Content-defined Chunking, verschlüsseltes
-Repository, geprüftes Tooling statt Eigenbau):
-
-```bash
-export NEXARCH_OBJECTBACKUP_REPO_DIR=/var/nexarch-archiv/backups/objects
-export NEXARCH_OBJECTBACKUP_PASSWORD=...
-export NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS=30   # optional, Default 7
-
-objectbackup-cli backup /var/nexarch-objects   # Sicherung + Verifikation
-objectbackup-cli check                          # vollständiges Lesen aller Datenblöcke
-objectbackup-cli rotate                          # restic forget --keep-last N --prune
-```
-
-## Betrieb: Backup-Zielverzeichnis
-
-Backup-Ziele liegen unter `/var/nexarch-archiv/` (persistentes ZFS-Dataset,
-`zfs/data/subvol-1131-disk-0` auf 192.168.1.131), NIEMALS unter
-`/var/nexarch-test/` (ephemeres Dataset, wird von den `reset-test-env.sh`-
-Skripten der anderen Module geleert). ZFS-seitige Snapshots/Replikation
-dieses Datasets sind ein eigenständiges Infra-Runbook (siehe
-`../../STORAGE-KONZEPT.md` Abschnitt 7), kein Ticket-Code — `zfs
-dedup=on` bewusst NICHT setzen (hoher RAM-Bedarf), Deduplizierung läuft
-ausschließlich App-seitig über restic.
-
-## Prüfungen
-
-```bash
-make check   # build + vet + lint + test, analog Core/DMS
-```
@@ -1,107 +0,0 @@
-// backup-cli ist der Aufrufpunkt für BAK-01, gedacht für systemd-Timer
-// (siehe deploy/systemd/) — "automatisiert nach Zeitplan" (Akzeptanzkriterium
-// 1) entsteht durch die Zeitplan-Definition im Timer-Unit, nicht durch
-// einen eigenen In-Prozess-Scheduler (kein zusätzlicher Dauerprozess nötig,
-// passt zur Produkt-DNA "kein Anwendungsserver mit unnötigem
-// Ressourcenverbrauch").
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"time"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/backup"
-)
-
-func loadConfig() backup.Config {
-	cfg := backup.Config{
-		Host:      os.Getenv("NEXARCH_BACKUP_PG_HOST"),
-		Port:      os.Getenv("NEXARCH_BACKUP_PG_PORT"),
-		User:      os.Getenv("NEXARCH_BACKUP_PG_USER"),
-		Password:  os.Getenv("NEXARCH_BACKUP_PG_PASSWORD"),
-		BackupDir: os.Getenv("NEXARCH_BACKUP_DIR"),
-	}
-	if cfg.Host == "" {
-		cfg.Host = "localhost"
-	}
-	if cfg.Port == "" {
-		cfg.Port = "5432"
-	}
-	if cfg.User == "" || cfg.Password == "" || cfg.BackupDir == "" {
-		log.Fatal("NEXARCH_BACKUP_PG_USER, NEXARCH_BACKUP_PG_PASSWORD und NEXARCH_BACKUP_DIR muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func latestManifest(backupDir string) (string, error) {
-	generations, err := backup.ListGenerations(backupDir)
-	if err != nil {
-		return "", err
-	}
-	if len(generations) == 0 {
-		return "", fmt.Errorf("keine vorhandene generation fuer inkrementelle sicherung gefunden - zuerst 'full' ausfuehren")
-	}
-	latest := generations[len(generations)-1]
-	full := backupDir + "/" + latest + "/" + backup.FullBackupDirName + "/" + backup.BackupManifestFile
-	if _, err := os.Stat(full); err == nil {
-		return full, nil
-	}
-	return "", fmt.Errorf("kein backup_manifest in der neuesten generation %q gefunden", latest)
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: backup-cli <full|incremental|verify|rotate> [args]")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	switch os.Args[1] {
-	case "full":
-		genID := backup.NewGenerationID(time.Now())
-		manifest, err := backup.FullBackup(ctx, cfg, genID)
-		if err != nil {
-			log.Fatalf("vollsicherung fehlgeschlagen: %v", err)
-		}
-		dir := manifest[:len(manifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der vollsicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("vollsicherung %q erstellt und verifiziert: %s\n", genID, manifest)
-
-	case "incremental":
-		manifest, err := latestManifest(cfg.BackupDir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		generations, _ := backup.ListGenerations(cfg.BackupDir)
-		genID := generations[len(generations)-1]
-		incID := backup.NewGenerationID(time.Now())
-		newManifest, err := backup.IncrementalBackup(ctx, cfg, genID, incID, manifest)
-		if err != nil {
-			log.Fatalf("inkrementelle sicherung fehlgeschlagen: %v", err)
-		}
-		dir := newManifest[:len(newManifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der inkrementellen sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("inkrementelle sicherung %q erstellt und verifiziert: %s\n", incID, newManifest)
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_BACKUP_KEEP_GENERATIONS"); v != "" {
-			_, _ = fmt.Sscanf(v, "%d", &keep)
-		}
-		removed, err := backup.Rotate(cfg.BackupDir, keep)
-		if err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("rotation abgeschlossen, %d generation(en) entfernt: %v\n", len(removed), removed)
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}
@@ -1,75 +0,0 @@
-// objectbackup-cli ist der Aufrufpunkt für BAK-02, für systemd-Timer
-// gedacht (siehe deploy/systemd/) — "automatisiert nach Zeitplan" entsteht
-// durch die Timer-Definition, kein eigener Dauerprozess (dieselbe
-// Begründung wie BAK-01 / cmd/backup-cli).
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"strconv"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/objectbackup"
-)
-
-func loadConfig() objectbackup.Config {
-	cfg := objectbackup.Config{
-		RepoDir:  os.Getenv("NEXARCH_OBJECTBACKUP_REPO_DIR"),
-		Password: os.Getenv("NEXARCH_OBJECTBACKUP_PASSWORD"),
-	}
-	if cfg.RepoDir == "" || cfg.Password == "" {
-		log.Fatal("NEXARCH_OBJECTBACKUP_REPO_DIR und NEXARCH_OBJECTBACKUP_PASSWORD muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: objectbackup-cli <backup <quellverzeichnis>|check|rotate>")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	if err := objectbackup.InitRepo(ctx, cfg); err != nil {
-		log.Fatalf("repository initialisieren: %v", err)
-	}
-
-	switch os.Args[1] {
-	case "backup":
-		if len(os.Args) < 3 {
-			log.Fatal("aufruf: objectbackup-cli backup <quellverzeichnis>")
-		}
-		summary, err := objectbackup.Backup(ctx, cfg, os.Args[2])
-		if err != nil {
-			log.Fatalf("sicherung fehlgeschlagen: %v", err)
-		}
-		if err := objectbackup.Check(ctx, cfg, false); err != nil {
-			log.Fatalf("verifikation nach sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("sicherung %q erstellt und verifiziert (neu=%d geaendert=%d unveraendert=%d)\n",
-			summary.SnapshotID, summary.FilesNew, summary.FilesChanged, summary.FilesUnmodified)
-
-	case "check":
-		if err := objectbackup.Check(ctx, cfg, true); err != nil {
-			log.Fatalf("verifikation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("verifikation (mit vollstaendigem lesen) erfolgreich")
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS"); v != "" {
-			if n, err := strconv.Atoi(v); err == nil {
-				keep = n
-			}
-		}
-		if err := objectbackup.Forget(ctx, cfg, keep); err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("rotation abgeschlossen")
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}
@@ -1,87 +0,0 @@
-# BAK-01 – Prüfprotokoll: Datenbank-Backup-Strategie
-
-Welle 1, keine Vorbedingungen. Neues Modul-Verzeichnis `code/archive/`
-(gleiches Monorepo-Muster wie `code/dms/`), eigenes Go-Modul
-`gitea.perlbach24.de/scripte/nexarch/archive`.
-
-## Grundsatzentscheidung: PostgreSQL-17-natives inkrementelles Backup
-
-`pg_dump` kennt nur logische Vollsicherungen — "inkrementell" im Sinne des
-Tickets erfordert das physische Backup-Verfahren. Gewählt: PostgreSQL 17s
-natives `pg_basebackup --incremental` (WAL-Summarization), NICHT klassisches
-WAL-Archiving (`archive_mode`), weil letzteres einen Neustart der
-(geteilten, auch von Core/DMS-Tests genutzten) Postgres-Instanz auf
-192.168.1.131 erfordert hätte. Stattdessen `summarize_wal = on` gesetzt —
-nur ein `pg_reload_conf()`, kein Neustart, keine Unterbrechung laufender
-Verbindungen (per Health-Check nach der Änderung bestätigt).
-
-Voraussetzung geschaffen: Rolle `nexarch_backup` mit `REPLICATION`-Attribut
-angelegt (Postgres verlangt eine Replikationsverbindung für
-`pg_basebackup`), `pg_hba.conf` erlaubte lokale Replikationsverbindungen
-bereits.
-
-## Umsetzung
-
- `internal/backup.FullBackup`/`IncrementalBackup` — rufen `pg_basebackup`
-  über `os/exec` auf, Ergebnis landet in einer Generationsstruktur
-  (`<BackupDir>/<Generation>/full/` bzw. `.../incremental/<ID>/`).
- `internal/backup.Verify` — öffnet `base.tar.gz` vollständig (gzip- UND
-  tar-Stream, jeder Eintrag bis zum Ende gelesen, nicht nur Kopfdaten) —
-  Akzeptanzkriterium 2: Verifikation auf Lesbarkeit, nicht nur Erstellung.
- `internal/backup.Rotate`/`ListGenerations` — Generationen sind nach
-  Zeitstempel-ID sortierbar, `Rotate` entfernt die ältesten bis auf `keep`
-  komplett (inklusive aller abhängigen Inkremente).
- `cmd/backup-cli` — `full`/`incremental`/`rotate`, aufgerufen von
-  systemd-Timern (`deploy/systemd/nexarch-archive-backup-*.timer`) —
-  "automatisiert nach Zeitplan" (Akzeptanzkriterium 1) entsteht durch die
-  Timer-Definition, kein zusätzlicher Dauerprozess nötig.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Sicherung gegen Testdatenbank erfolgreich erstellt und verifiziert | **bestanden** — `TestFullBackup_CreatesVerifiedBackup` gegen die echte Postgres-17-Instanz auf 192.168.1.131 (kein Mock), zusätzlich `TestIncrementalBackup_IsSmallerThanFull`: inkrementelle Sicherung real deutlich kleiner als Vollsicherung (167 KB vs. 16 MB bei der ersten manuellen Probe) — beweist echte inkrementelle Übertragung, nicht nur eine zweite Vollsicherung |
-| 2 | Verifikation erkennt eine absichtlich beschädigte Sicherungsdatei | **bestanden** — `TestVerify_DetectsCorruptedFile`: 64 Bytes in der Mitte von `base.tar.gz` gekippt, `Verify` schlägt danach fehl (unbeschädigt zuvor erfolgreich) |
-| 3 | Rotationsregel entfernt nachweislich nur die ältesten Generationen | **bestanden** — `TestRotate_RemovesOnlyOldestGenerations`: 5 Generationen, `keep=2`, exakt die 3 ältesten entfernt, die 2 neuesten nachweislich unangetastet |
-
-## Echte Verdrahtung auf 192.168.1.131 (nicht nur Testcode)
-
-Anders als die zuletzt in DMS gefundenen "Baustein existiert, ist aber
-nirgends verdrahtet"-Fälle (FDN-03/FDN-09 gegen Core) wurde hier die
-komplette Kette tatsächlich installiert und ausgeführt:
-
- `backup-cli` gebaut nach `/opt/nexarch-archive/bin/`
- `/etc/nexarch/archive-backup.env` mit den Verbindungsdaten (0600)
- 3 systemd-Timer installiert und aktiviert (`enable --now`):
-  Vollsicherung täglich 02:00 UTC, Inkrement stündlich, Rotation täglich
-  03:00 UTC (`systemctl list-timers` bestätigt alle drei scharf)
- Jeder der drei Dienste (`full`/`incremental`/`rotate`) einmal manuell über
-  `systemctl start` ausgelöst (nicht nur `go test` direkt) — alle drei mit
-  `status=0/SUCCESS`, Journal bestätigt inhaltlich korrekte Ausgabe
-  (Vollsicherung erstellt+verifiziert, Inkrement erstellt+verifiziert
-  gegen die richtige Vorgänger-Generation, Rotation lief ohne Fehler)
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 4/4 Tests ok, 0 Fehlschläge (echter Postgres 17, kein Mock)
-```
-
-## Nachtrag (BAK-02-Sitzung): Backup-Zielverzeichnis korrigiert
-
-`NEXARCH_BACKUP_DIR` zeigte ursprünglich auf `/var/backups/nexarch`
-(Root-Dateisystem des Containers, kein dediziertes Dataset) — korrigiert auf
-`/var/nexarch-archiv/backups/postgres` (persistentes ZFS-Dataset), siehe
-`docs/BAK-02-PRUEFPROTOKOLL.md` Abschnitt „Korrektur an BAK-01" für Details.
-Vollsicherung nach der Korrektur erneut über systemd ausgelöst, landet
-nachweislich am neuen Ort.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt — inklusive tatsächlicher systemd-Timer-Installation und
-manuell ausgelöstem End-to-End-Lauf aller drei Dienste auf dem Testhost,
-nicht nur isolierter Testcode.
@@ -1,93 +0,0 @@
-# BAK-02 – Prüfprotokoll: Objekt-Storage-Backup/Snapshots
-
-Welle 1, keine Vorbedingungen.
-
-## Grundsatzentscheidung: restic statt Eigenbau
-
-Nutzerentscheidung: restic statt einer Neuimplementierung, weil restic alle
-vier Akzeptanzkriterien mit ausgereiftem, breit geprüftem Tooling erfüllt
-(Content-defined Chunking für Dedup, `check --read-data` für
-Vollständigkeit, `forget --keep-last` für Rotation, Repository-Verschlüsselung
-ab Werk). Installiert via `apt-get install restic` (Version 0.18.0).
-
-Backup-Quelle ist ein lokaler Verzeichnisbaum — für den FDN-03-`LocalDriver`
-direkt dessen Basisverzeichnis. Für S3-gestützte Produktions-Deployments
-(Betriebsmodus 2/3 aus `STORAGE-KONZEPT.md` Abschnitt 6.2) wäre ein
-vorgelagerter Sync-Schritt (z. B. `rclone`) nötig, um Bucket-Inhalte lokal
-zu spiegeln, bevor restic sie sichert — restic sichert Dateibäume, keine
-S3-Buckets direkt. Das bleibt hier bewusst unimplementiert (kein konkreter
-S3-Produktionsbestand vorhanden, der das aktuell erfordert), aber
-architektonisch vorgesehen und dokumentiert (`README.md`).
-
-## Umsetzung
-
- `internal/objectbackup.InitRepo` — idempotent, erkennt "bereits
-  initialisiert" am `restic init`-Fehlertext statt zu scheitern.
- `internal/objectbackup.Backup` — `restic backup --json`, parst die
-  `summary`-Zeile (mehrere JSON-Zeilen in der Ausgabe, gezielt die mit
-  `message_type=="summary"` gesucht).
- `internal/objectbackup.Check` — `restic check [--read-data]` (Akzeptanz-
-  kriterium 3: Vollständigkeitsprüfung).
- `internal/objectbackup.Forget` — `restic forget --keep-last N --prune`
-  (Rotation).
- `cmd/objectbackup-cli` — `backup <dir>`/`check`/`rotate`, aufgerufen von
-  systemd-Timern (stündlich/wöchentlich/täglich).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Zweiter Sicherungslauf nach unverändertem Bestand überträgt keine Daten erneut | **bestanden** — `TestBackup_UnchangedSecondRunTransmitsNothingNew`: zweiter Lauf gegen unveränderten Bestand liefert `files_new=0`, `files_changed=0`, `files_unmodified=1` |
-| 2 | Zwei identische Testdateien belegen nachweislich nur einmal Speicherplatz | **bestanden** — `TestBackup_DeduplicatesIdenticalContent`: zwei Dateien mit identischem Inhalt erzeugen `data_blobs=1`, nicht 2 — echter Dedup-Nachweis über restics Content-defined Chunking, nicht nur Namensvergleich |
-| 3 | Vollständigkeitsprüfung erkennt ein fehlendes Objekt in der Sicherung | **bestanden** — `TestCheck_DetectsCorruptedPack`: ein Byte in einer echten Repository-Pack-Datei gekippt, `Check(readData=true)` schlägt danach fehl (unbeschädigt zuvor erfolgreich) — dieselbe Vorgehensweise wie die manuelle Recherche vor der Implementierung |
-
-Zusätzlich (nicht explizit als Pflichtprüfung gefordert, aber Teil von
-Akzeptanzkriterium 3 „lässt sich einzeln prüfen"): `TestForget_
-KeepsOnlyRequestedSnapshotCount` — 3 Sicherungsläufe, `Forget(keepLast=1)`
-reduziert auf genau 1 verbleibenden Snapshot.
-
-## Korrektur an BAK-01 im selben Rutsch: Backup-Zielverzeichnis
-
-Nutzerhinweis aufgegriffen: `NEXARCH_BACKUP_DIR` zeigte bei BAK-01
-ursprünglich auf `/var/backups/nexarch` (Root-Dateisystem des LXC-
-Containers, nicht auf einem der beiden dedizierten ZFS-Datasets). Korrigiert
-auf `/var/nexarch-archiv/backups/postgres` (persistentes Dataset
-`zfs/data/subvol-1131-disk-0`), NICHT `/var/nexarch-test/` (ephemeres
-Dataset `ssd-rpool-data/swap/subvol-1131-disk-0`, wird von
-`reset-test-env.sh`-Skripten anderer Module geleert). `objectbackup-cli`s
-Repository liegt von Anfang an korrekt unter
-`/var/nexarch-archiv/backups/objects`. Beide Pfade real auf
-192.168.1.131 verifiziert (`df`/`mount` bestätigt ZFS-Dataset-Zuordnung),
-BAK-01s Vollsicherung nach der Korrektur erneut über systemd ausgelöst und
-bestätigt am neuen Ort gelandet.
-
-ZFS-seitige Snapshot-/Replikations-Strategie für `nexarch/archiv` bleibt
-bewusst außerhalb dieses Tickets (Infra-Runbook, siehe
-`STORAGE-KONZEPT.md` Abschnitt 7 „Backup vs. Storage-Redundanz" sowie den
-Hinweis, `zfs dedup=on` NICHT zu setzen — App-seitige Dedup über restic
-genügt, ZFS-Dedup wäre auf dem 4-GB-Testhost ein Speicherrisiko).
-
-## Echte Verdrahtung auf 192.168.1.131
-
- `objectbackup-cli` gebaut nach `/opt/nexarch-archive/bin/`
- `/etc/nexarch/archive-objectbackup.env` (0600)
- 3 systemd-Timer installiert und aktiviert: Sicherung stündlich (`:30`),
-  Vollständigkeitsprüfung wöchentlich (So. 04:00 UTC), Rotation täglich
-  (03:30 UTC) — `systemctl list-timers` bestätigt alle scharf
- Jeder der drei Dienste einmal über `systemctl start` ausgelöst, alle mit
-  `status=0/SUCCESS`; Journal bestätigt inhaltlich korrekte Ausgabe
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 2/2 Pakete mit Tests ok (internal/backup, internal/objectbackup), 0 Fehlschläge
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real gegen echtes restic-Tooling erfüllt. BAK-01-Pfadfehler im selben
-Rutsch korrigiert und erneut end-to-end verifiziert.
@@ -1,3 +0,0 @@
-module gitea.perlbach24.de/scripte/nexarch/archive
-
-go 1.22
@@ -1,102 +0,0 @@
-// Package backup implementiert BAK-01: automatisierte, inkrementelle
-// Sicherung der PostgreSQL-Datenbank per pg_basebackup (PostgreSQL 17s
-// natives inkrementelles Backup über WAL-Summarization, siehe
-// `summarize_wal`), mit Verifikation jeder Sicherung und
-// generationsbasierter Rotation. Kein pg_dump-basierter Ansatz, weil
-// pg_dump ausschließlich logische Vollsicherungen kennt — "inkrementell"
-// im Sinne des Tickets erfordert das physische, WAL-summary-gestützte
-// Verfahren aus PostgreSQL 17.
-package backup
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"time"
-)
-
-// Config enthält die Verbindungsdaten für pg_basebackup — ausschließlich
-// über Umgebungsvariablen befüllt, nie im Code (siehe Ticket-Abschluss-
-// Regel).
-type Config struct {
-	Host             string
-	Port             string
-	User             string
-	Password         string
-	BackupDir        string
-	PgBaseBackupPath string // Default "pg_basebackup", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.PgBaseBackupPath != "" {
-		return c.PgBaseBackupPath
-	}
-	return "pg_basebackup"
-}
-
-// FullBackupDirName/IncrementalDirName sind die festen Unterverzeichnis-
-// namen je Generation.
-const (
-	FullBackupDirName  = "full"
-	IncrementalSubdir  = "incremental"
-	BackupManifestFile = "backup_manifest"
-	BaseTarGzFile      = "base.tar.gz"
-)
-
-// NewGenerationID liefert eine sortierbare, eindeutige Generation-Kennung
-// (RFC3339-artig, dateisystemtauglich) — Generationen werden anhand dieser
-// Kennung chronologisch sortiert (Rotate, ListGenerations).
-func NewGenerationID(t time.Time) string {
-	return t.UTC().Format("20060102T150405Z")
-}
-
-// FullBackup erstellt eine neue Vollsicherung (Akzeptanzkriterium 1) als
-// eigene Generation. Liefert den Pfad zum backup_manifest, das spätere
-// IncrementalBackup-Aufrufe als Referenz brauchen.
-func FullBackup(ctx context.Context, cfg Config, generationID string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, FullBackupDirName)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: generationsverzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: vollsicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-// IncrementalBackup erstellt eine inkrementelle Sicherung gegen die zuletzt
-// bekannte Vollsicherung ODER die letzte Inkrement-Sicherung (priorManifestPath
-// zeigt jeweils auf das backup_manifest der Referenz).
-func IncrementalBackup(ctx context.Context, cfg Config, generationID, incrementID, priorManifestPath string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, IncrementalSubdir, incrementID)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: inkrement-verzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-		"--incremental=" + priorManifestPath,
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: inkrementelle sicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-func runPgBaseBackup(ctx context.Context, cfg Config, args []string) error {
-	cmd := exec.CommandContext(ctx, cfg.binary(), args...)
-	cmd.Env = append(os.Environ(), "PGPASSWORD="+cfg.Password)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("%s fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), err, string(output))
-	}
-	return nil
-}
@@ -1,187 +0,0 @@
-package backup
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func requireTestConfig(t *testing.T) Config {
-	t.Helper()
-	user := os.Getenv("TEST_BACKUP_PG_USER")
-	if user == "" {
-		t.Skip("TEST_BACKUP_PG_USER nicht gesetzt, Integrationstest uebersprungen (braucht echten Postgres mit REPLICATION-Rolle)")
-	}
-	return Config{
-		Host:      envOr("TEST_BACKUP_PG_HOST", "localhost"),
-		Port:      envOr("TEST_BACKUP_PG_PORT", "5432"),
-		User:      user,
-		Password:  os.Getenv("TEST_BACKUP_PG_PASSWORD"),
-		BackupDir: t.TempDir(),
-	}
-}
-
-func envOr(key, fallback string) string {
-	if v := os.Getenv(key); v != "" {
-		return v
-	}
-	return fallback
-}
-
-// TestFullBackup_CreatesVerifiedBackup ist Pruefung 1: Sicherung gegen
-// Testdatenbank erfolgreich erstellt und verifiziert.
-func TestFullBackup_CreatesVerifiedBackup(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	if _, err := os.Stat(manifest); err != nil {
-		t.Fatalf("backup_manifest fehlt: %v", err)
-	}
-
-	dir := filepath.Dir(manifest)
-	if _, err := os.Stat(filepath.Join(dir, BaseTarGzFile)); err != nil {
-		t.Fatalf("%s fehlt: %v", BaseTarGzFile, err)
-	}
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-}
-
-// TestIncrementalBackup_IsSmallerThanFull ist der Nachweis fuer
-// Akzeptanzkriterium 1 (inkrementell): eine echte inkrementelle Sicherung
-// gegen unveraenderten Bestand ist deutlich kleiner als die Vollsicherung —
-// beweist, dass tatsaechlich nur Aenderungen uebertragen wurden (PostgreSQL
-// 17 WAL-Summarization), nicht nochmal alles.
-func TestIncrementalBackup_IsSmallerThanFull(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	fullManifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	fullDir := filepath.Dir(fullManifest)
-	fullSize := fileSize(t, filepath.Join(fullDir, BaseTarGzFile))
-
-	incID := NewGenerationID(time.Now().Add(time.Second))
-	incManifest, err := IncrementalBackup(ctx, cfg, genID, incID, fullManifest)
-	if err != nil {
-		t.Fatalf("incrementalbackup: %v", err)
-	}
-	incDir := filepath.Dir(incManifest)
-	if err := Verify(incDir); err != nil {
-		t.Fatalf("verify (inkrementell): %v", err)
-	}
-	incSize := fileSize(t, filepath.Join(incDir, BaseTarGzFile))
-
-	if incSize >= fullSize {
-		t.Fatalf("inkrementelle sicherung (%d bytes) ist nicht kleiner als die vollsicherung (%d bytes) - keine echte inkrementelle Uebertragung", incSize, fullSize)
-	}
-}
-
-func fileSize(t *testing.T, path string) int64 {
-	t.Helper()
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatalf("dateigroesse von %q ermitteln: %v", path, err)
-	}
-	return info.Size()
-}
-
-// TestVerify_DetectsCorruptedFile ist Pruefung 2: Verifikation erkennt eine
-// absichtlich beschaedigte Sicherungsdatei.
-func TestVerify_DetectsCorruptedFile(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	dir := filepath.Dir(manifest)
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: mehrere Bytes in der Mitte der Datei kippen.
-	path := filepath.Join(dir, BaseTarGzFile)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("sicherungsdatei lesen: %v", err)
-	}
-	mid := len(data) / 2
-	for i := mid; i < mid+64 && i < len(data); i++ {
-		data[i] ^= 0xFF
-	}
-	if err := os.WriteFile(path, data, 0o600); err != nil {
-		t.Fatalf("beschaedigte sicherungsdatei schreiben: %v", err)
-	}
-
-	if err := Verify(dir); err == nil {
-		t.Fatal("verify haette die beschaedigte sicherungsdatei erkennen muessen")
-	}
-}
-
-// TestRotate_RemovesOnlyOldestGenerations ist Pruefung 3.
-func TestRotate_RemovesOnlyOldestGenerations(t *testing.T) {
-	backupDir := t.TempDir()
-	generationIDs := []string{
-		"20260101T000000Z",
-		"20260102T000000Z",
-		"20260103T000000Z",
-		"20260104T000000Z",
-		"20260105T000000Z",
-	}
-	for _, id := range generationIDs {
-		if err := os.MkdirAll(filepath.Join(backupDir, id, FullBackupDirName), 0o750); err != nil {
-			t.Fatalf("generation %q anlegen: %v", id, err)
-		}
-	}
-
-	removed, err := Rotate(backupDir, 2)
-	if err != nil {
-		t.Fatalf("rotate: %v", err)
-	}
-	wantRemoved := []string{"20260101T000000Z", "20260102T000000Z", "20260103T000000Z"}
-	if len(removed) != len(wantRemoved) {
-		t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-	}
-	for i, w := range wantRemoved {
-		if removed[i] != w {
-			t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-		}
-	}
-
-	remaining, err := ListGenerations(backupDir)
-	if err != nil {
-		t.Fatalf("listgenerations: %v", err)
-	}
-	wantRemaining := []string{"20260104T000000Z", "20260105T000000Z"}
-	if len(remaining) != len(wantRemaining) {
-		t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-	}
-	for i, w := range wantRemaining {
-		if remaining[i] != w {
-			t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-		}
-	}
-
-	// Die NEUESTEN duerfen NICHT entfernt sein (Pruefung 3: nur die
-	// aeltesten Generationen).
-	for _, w := range wantRemaining {
-		if _, err := os.Stat(filepath.Join(backupDir, w)); err != nil {
-			t.Fatalf("neueste generation %q wurde faelschlich entfernt: %v", w, err)
-		}
-	}
-}
@@ -1,56 +0,0 @@
-package backup
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-)
-
-// ListGenerations liefert alle Generation-IDs in backupDir, aufsteigend
-// sortiert (die GenerationID selbst ist chronologisch sortierbar, siehe
-// NewGenerationID — kein Blick auf Dateisystem-Zeitstempel nötig, die bei
-// einem Restore/Kopiervorgang verändert werden könnten).
-func ListGenerations(backupDir string) ([]string, error) {
-	entries, err := os.ReadDir(backupDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, fmt.Errorf("backup: sicherungsverzeichnis lesen: %w", err)
-	}
-	var generations []string
-	for _, e := range entries {
-		if e.IsDir() {
-			generations = append(generations, e.Name())
-		}
-	}
-	sort.Strings(generations)
-	return generations, nil
-}
-
-// Rotate entfernt alle bis auf die `keep` NEUESTEN Generationen
-// (Akzeptanzkriterium 3) — jede Generation umfasst ihre Vollsicherung UND
-// alle davon abhängigen Inkremente, ein Löschen der gesamten
-// Generationsverzeichnisses entfernt beides konsistent zusammen.
-func Rotate(backupDir string, keep int) (removed []string, err error) {
-	if keep < 0 {
-		keep = 0
-	}
-	generations, err := ListGenerations(backupDir)
-	if err != nil {
-		return nil, err
-	}
-	if len(generations) <= keep {
-		return nil, nil
-	}
-
-	toRemove := generations[:len(generations)-keep]
-	for _, gen := range toRemove {
-		if err := os.RemoveAll(filepath.Join(backupDir, gen)); err != nil {
-			return removed, fmt.Errorf("backup: generation %q entfernen: %w", gen, err)
-		}
-		removed = append(removed, gen)
-	}
-	return removed, nil
-}
@@ -1,54 +0,0 @@
-package backup
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// ErrCorrupted wird geliefert, wenn eine Sicherungsdatei nicht lesbar ist
-// (Akzeptanzkriterium 2: Verifikation, nicht nur Erstellungs-Prüfung).
-var ErrCorrupted = fmt.Errorf("backup: sicherungsdatei ist beschaedigt oder unvollstaendig")
-
-// Verify prüft, dass base.tar.gz im gegebenen Sicherungsverzeichnis
-// vollständig lesbar ist — öffnet gzip- UND tar-Stream und liest JEDEN
-// Eintrag bis zum Ende durch (nicht nur die Kopfdaten), damit ein
-// abgeschnittener oder mit kaputten Bytes überschriebener Inhalt
-// zuverlässig auffällt, nicht nur ein defekter Tar-Header.
-func Verify(backupDir string) error {
-	path := filepath.Join(backupDir, BaseTarGzFile)
-	f, err := os.Open(path)
-	if err != nil {
-		return fmt.Errorf("%w: %s nicht lesbar: %v", ErrCorrupted, path, err)
-	}
-	defer func() { _ = f.Close() }()
-
-	gz, err := gzip.NewReader(f)
-	if err != nil {
-		return fmt.Errorf("%w: gzip-header ungueltig: %v", ErrCorrupted, err)
-	}
-	defer func() { _ = gz.Close() }()
-
-	tr := tar.NewReader(gz)
-	entries := 0
-	for {
-		hdr, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("%w: tar-eintrag ungueltig: %v", ErrCorrupted, err)
-		}
-		if _, err := io.Copy(io.Discard, tr); err != nil {
-			return fmt.Errorf("%w: inhalt von %q nicht vollstaendig lesbar: %v", ErrCorrupted, hdr.Name, err)
-		}
-		entries++
-	}
-	if entries == 0 {
-		return fmt.Errorf("%w: archiv enthaelt keine eintraege", ErrCorrupted)
-	}
-	return nil
-}
@@ -1,156 +0,0 @@
-// Package objectbackup implementiert BAK-02: automatisierte, inkrementelle,
-// deduplizierende Sicherung des Objekt-Storage-Bestands. Nutzt restic
-// (Content-defined Chunking, verschlüsseltes Repository ab Werk) statt
-// Eigenbau — restic erfüllt alle Akzeptanzkriterien mit ausgereiftem,
-// geprüftem Tooling statt einer weniger robusten Neuimplementierung.
-//
-// Backup-Quelle ist ein lokaler Verzeichnisbaum — für den LocalDriver aus
-// FDN-03 direkt dessen Basisverzeichnis, für S3-gestützte Produktions-
-// Deployments ein vorgelagerter Sync-Schritt (z.B. rclone) auf einen
-// lokalen Spiegel, bevor restic ihn sichert (nicht Bestandteil dieser
-// Kachel — restic selbst sichert Dateibäume, keine S3-Buckets direkt).
-package objectbackup
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-// Config enthält Repository-Ort und -Passwort — ausschließlich über
-// Umgebungsvariablen befüllt (siehe Ticket-Abschluss-Regel).
-type Config struct {
-	RepoDir    string
-	Password   string
-	ResticPath string // Default "restic", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.ResticPath != "" {
-		return c.ResticPath
-	}
-	return "restic"
-}
-
-func (c Config) env() []string {
-	return append(os.Environ(), "RESTIC_PASSWORD="+c.Password)
-}
-
-func run(ctx context.Context, cfg Config, args ...string) ([]byte, error) {
-	fullArgs := append([]string{"-r", cfg.RepoDir}, args...)
-	cmd := exec.CommandContext(ctx, cfg.binary(), fullArgs...)
-	cmd.Env = cfg.env()
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return output, fmt.Errorf("%s %v fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), args, err, string(output))
-	}
-	return output, nil
-}
-
-// InitRepo legt ein neues restic-Repository an, falls es noch nicht
-// existiert — idempotent, ein bereits initialisiertes Repository ist kein
-// Fehler (Wiederholte Aufrufe durch systemd-Timer nach einem Neustart
-// dürfen nicht fehlschlagen).
-func InitRepo(ctx context.Context, cfg Config) error {
-	output, err := run(ctx, cfg, "init")
-	if err != nil {
-		if strings.Contains(string(output), "config file already exists") {
-			return nil
-		}
-		return fmt.Errorf("objectbackup: repository initialisieren: %w", err)
-	}
-	return nil
-}
-
-// BackupSummary ist der geparste "summary"-Datensatz aus `restic backup --json`.
-type BackupSummary struct {
-	SnapshotID      string `json:"snapshot_id"`
-	FilesNew        int    `json:"files_new"`
-	FilesChanged    int    `json:"files_changed"`
-	FilesUnmodified int    `json:"files_unmodified"`
-	DataBlobs       int    `json:"data_blobs"`
-	TotalBytes      int64  `json:"total_bytes_processed"`
-}
-
-// Backup sichert sourceDir inkrementell (Akzeptanzkriterium 1: unveränderte
-// Objekte werden nicht erneut übertragen — restics Content-defined
-// Chunking erkennt das automatisch, kein manueller Änderungsabgleich
-// nötig).
-func Backup(ctx context.Context, cfg Config, sourceDir string) (BackupSummary, error) {
-	output, err := run(ctx, cfg, "backup", sourceDir, "--json")
-	if err != nil {
-		return BackupSummary{}, fmt.Errorf("objectbackup: sicherung: %w", err)
-	}
-	return parseSummary(output)
-}
-
-// parseSummary sucht in der zeilenweisen JSON-Ausgabe von `restic backup
-// --json` (mehrere Fortschritts-/Statuszeilen, GENAU EINE mit
-// message_type=="summary") die Zusammenfassung.
-func parseSummary(output []byte) (BackupSummary, error) {
-	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-	for i := len(lines) - 1; i >= 0; i-- {
-		var probe struct {
-			MessageType string `json:"message_type"`
-		}
-		if err := json.Unmarshal([]byte(lines[i]), &probe); err != nil {
-			continue
-		}
-		if probe.MessageType == "summary" {
-			var summary BackupSummary
-			if err := json.Unmarshal([]byte(lines[i]), &summary); err != nil {
-				return BackupSummary{}, fmt.Errorf("objectbackup: summary-zeile dekodieren: %w", err)
-			}
-			return summary, nil
-		}
-	}
-	return BackupSummary{}, fmt.Errorf("objectbackup: keine summary-zeile in der restic-ausgabe gefunden")
-}
-
-// Check prüft die Vollständigkeit/Lesbarkeit des Repository
-// (Akzeptanzkriterium 3 / Pflichtprüfung: Vollständigkeitsprüfung erkennt
-// fehlendes/beschädigtes Objekt). readData=true liest jeden gespeicherten
-// Datenblock tatsächlich (teurer, aber die einzige Prüfung, die
-// Bit-Rot in bereits gespeicherten Paketen erkennt — ohne readData prüft
-// restic nur Struktur/Indizes, nicht den tatsächlichen Blockinhalt).
-func Check(ctx context.Context, cfg Config, readData bool) error {
-	args := []string{"check"}
-	if readData {
-		args = append(args, "--read-data")
-	}
-	if _, err := run(ctx, cfg, args...); err != nil {
-		return fmt.Errorf("objectbackup: %w", err)
-	}
-	return nil
-}
-
-// Forget entfernt alte Snapshots nach Rotationsregel und gibt den davon
-// belegten Speicherplatz frei (--prune) — restics Äquivalent zu
-// BAK-01s Rotate.
-func Forget(ctx context.Context, cfg Config, keepLast int) error {
-	if _, err := run(ctx, cfg, "forget", "--keep-last", fmt.Sprintf("%d", keepLast), "--prune"); err != nil {
-		return fmt.Errorf("objectbackup: rotation: %w", err)
-	}
-	return nil
-}
-
-type snapshotEntry struct {
-	ShortID string `json:"short_id"`
-}
-
-// SnapshotCount liefert die Anzahl vorhandener Snapshots — für Tests und
-// Statusabfragen.
-func SnapshotCount(ctx context.Context, cfg Config) (int, error) {
-	output, err := run(ctx, cfg, "snapshots", "--json")
-	if err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshots auflisten: %w", err)
-	}
-	var snapshots []snapshotEntry
-	if err := json.Unmarshal(output, &snapshots); err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshot-liste dekodieren: %w", err)
-	}
-	return len(snapshots), nil
-}
@@ -1,168 +0,0 @@
-package objectbackup
-
-import (
-	"context"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-func requireRestic(t *testing.T) {
-	t.Helper()
-	if _, err := exec.LookPath("restic"); err != nil {
-		t.Skip("restic nicht installiert, Integrationstest uebersprungen")
-	}
-}
-
-func setupTest(t *testing.T) Config {
-	t.Helper()
-	requireRestic(t)
-	cfg := Config{RepoDir: filepath.Join(t.TempDir(), "repo"), Password: "test-passwort-fuer-objectbackup"}
-	if err := InitRepo(context.Background(), cfg); err != nil {
-		t.Fatalf("initrepo: %v", err)
-	}
-	return cfg
-}
-
-func writeFile(t *testing.T, dir, name, content string) {
-	t.Helper()
-	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
-		t.Fatalf("testdatei %q schreiben: %v", name, err)
-	}
-}
-
-// TestBackup_UnchangedSecondRunTransmitsNothingNew ist Pruefung 1:
-// zweiter Sicherungslauf nach unveraendertem Bestand ueberraegt keine
-// Daten erneut.
-func TestBackup_UnchangedSecondRunTransmitsNothingNew(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "dokument.pdf", "unveraenderter inhalt")
-
-	first, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("erste sicherung: %v", err)
-	}
-	if first.FilesNew != 1 {
-		t.Fatalf("erste sicherung: files_new = %d, want 1", first.FilesNew)
-	}
-
-	second, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("zweite sicherung: %v", err)
-	}
-	if second.FilesNew != 0 || second.FilesChanged != 0 {
-		t.Fatalf("zweite sicherung (unveraendert): files_new=%d files_changed=%d, want beide 0", second.FilesNew, second.FilesChanged)
-	}
-	if second.FilesUnmodified != 1 {
-		t.Fatalf("zweite sicherung: files_unmodified = %d, want 1", second.FilesUnmodified)
-	}
-}
-
-// TestBackup_DeduplicatesIdenticalContent ist Pruefung 2: zwei identische
-// Testdateien belegen nachweislich nur einmal Speicherplatz.
-func TestBackup_DeduplicatesIdenticalContent(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	content := "exakt identischer inhalt in beiden dateien fuer den dedup-nachweis"
-	writeFile(t, sourceDir, "original.pdf", content)
-	writeFile(t, sourceDir, "kopie.pdf", content)
-
-	summary, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if summary.FilesNew != 2 {
-		t.Fatalf("erwartet 2 neue dateien, habe %d", summary.FilesNew)
-	}
-	// Zwei Dateien mit IDENTISCHEM Inhalt duerfen nur EINEN data_blob
-	// erzeugen - das ist der Dedup-Nachweis (Akzeptanzkriterium 2).
-	if summary.DataBlobs != 1 {
-		t.Fatalf("data_blobs = %d, want 1 (zwei identische dateien haetten nur einen blob erzeugen duerfen - keine dedup)", summary.DataBlobs)
-	}
-}
-
-// TestCheck_DetectsCorruptedPack ist Pruefung 3: Vollstaendigkeitspruefung
-// erkennt ein beschaedigtes/fehlendes Objekt in der Sicherung.
-func TestCheck_DetectsCorruptedPack(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "wichtig.pdf", "inhalt, der spaeter absichtlich beschaedigt wird")
-
-	if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if err := Check(ctx, cfg, true); err != nil {
-		t.Fatalf("check (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: ein Byte in einer Pack-Datei im
-	// Repository kippen (dieselbe Fundstelle wie beim manuellen
-	// Nachweis waehrend der Recherche zu diesem Ticket).
-	packDir := filepath.Join(cfg.RepoDir, "data")
-	corrupted := false
-	if err := filepath.Walk(packDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil || info.IsDir() || corrupted {
-			return err
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		if len(data) < 20 {
-			return nil
-		}
-		data[10] ^= 0xFF
-		if err := os.WriteFile(path, data, 0o600); err != nil {
-			return err
-		}
-		corrupted = true
-		return nil
-	}); err != nil {
-		t.Fatalf("pack-datei beschaedigen: %v", err)
-	}
-	if !corrupted {
-		t.Fatal("keine pack-datei zum beschaedigen gefunden - testaufbau fehlerhaft")
-	}
-
-	if err := Check(ctx, cfg, true); err == nil {
-		t.Fatal("check haette die beschaedigte pack-datei erkennen muessen")
-	}
-}
-
-// TestForget_KeepsOnlyRequestedSnapshotCount prueft die Rotation.
-func TestForget_KeepsOnlyRequestedSnapshotCount(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-
-	for i := 0; i < 3; i++ {
-		writeFile(t, sourceDir, "f.txt", "version "+string(rune('a'+i)))
-		if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-			t.Fatalf("sicherung %d: %v", i, err)
-		}
-	}
-	before, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (vorher): %v", err)
-	}
-	if before != 3 {
-		t.Fatalf("erwartet 3 snapshots vor rotation, habe %d", before)
-	}
-
-	if err := Forget(ctx, cfg, 1); err != nil {
-		t.Fatalf("forget: %v", err)
-	}
-
-	after, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (nachher): %v", err)
-	}
-	if after != 1 {
-		t.Fatalf("erwartet 1 snapshot nach rotation (keep-last 1), habe %d", after)
-	}
-}
@@ -7,6 +7,8 @@ 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() {
@@ -15,16 +17,38 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}

-	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
+	ctx := context.Background()
+
+	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("db: %v", err)
+		log.Fatalf("registry db: %v", err)
 	}
-	defer pool.Close()
+	defer registryPool.Close()
+
+	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
+	if err != nil {
+		log.Fatalf("admin db: %v", err)
+	}
+	defer adminPool.Close()
+
+	registry := tenant.NewRegistry(registryPool)
+	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)
 	})
+	// 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 {
@@ -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)
+	}
+}
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Vollsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli full
@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Datenbank-Vollsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 02:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Inkrementalsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli incremental
@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Datenbank-Inkrementalsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* *:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Sicherungsgenerationen-Rotation (BAK-01)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli rotate
@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Sicherungsgenerationen-Rotation (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 03:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli backup __OBJECT_SOURCE_DIR__
@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Sicherung (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* *:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Vollstaendigkeitspruefung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli check
@@ -1,9 +0,0 @@
-[Unit]
-Description=Woechentlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Vollstaendigkeitspruefung (BAK-02)
-
-[Timer]
-OnCalendar=Sun *-*-* 04:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Rotation (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli rotate
@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Rotation (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* 03:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target
@@ -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
@@ -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.
@@ -2,4 +2,16 @@ module gitea.perlbach24.de/scripte/nexarch

 go 1.22

-require github.com/jackc/pgx/v5 v5.6.0
+require (
+	github.com/golang-jwt/jwt/v5 v5.3.1
+	github.com/jackc/pgx/v5 v5.6.0
+	golang.org/x/crypto v0.17.0
+)
+
+require (
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
@@ -0,0 +1,30 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+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/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+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.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.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=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -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)
+}
@@ -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"
@@ -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)
+	}
+}
@@ -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
+}
@@ -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
+}
@@ -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")
+	}
+}
@@ -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")
+	}
+}
@@ -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
+}
@@ -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")
+	}
+}
@@ -0,0 +1,88 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2 / Pruefung 2 in diesem Ticket bezieht sich auf die
+// Aenderungsnachvollziehbarkeit — die Cache-Frist selbst folgt demselben
+// Muster wie internal/flag.DefaultCacheTTL).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	value     Value
+	expiresAt time.Time
+}
+
+// Service ist die Leseseite mit Vorrangregel (Akzeptanzkriterium 1:
+// Tenant-Override vor Global-Default) und lokalem TTL-Cache.
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry // Schluessel: key + "\x00" + tenantSlug
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+func cacheKey(key, tenantSlug string) string {
+	return key + "\x00" + tenantSlug
+}
+
+// Resolve liefert den Konfigurationswert fuer einen Tenant: ein
+// Tenant-spezifischer Override hat Vorrang vor dem globalen Default
+// (Akzeptanzkriterium 1 / Pruefung 1). tenantSlug == "" wertet nur den
+// globalen Wert aus.
+func (s *Service) Resolve(ctx context.Context, tenantSlug, key string) (Value, error) {
+	ck := cacheKey(key, tenantSlug)
+
+	s.mu.RLock()
+	entry, exists := s.cache[ck]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.value, nil
+	}
+
+	v, err := s.resolveUncached(ctx, tenantSlug, key)
+	if err != nil {
+		return Value{}, err
+	}
+
+	s.mu.Lock()
+	s.cache[ck] = cacheEntry{value: v, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return v, nil
+}
+
+func (s *Service) resolveUncached(ctx context.Context, tenantSlug, key string) (Value, error) {
+	if tenantSlug != "" {
+		v, err := s.store.Get(ctx, key, tenantSlug)
+		if err == nil {
+			return v, nil
+		}
+		if !errors.Is(err, ErrNotFound) {
+			return Value{}, err
+		}
+	}
+	return s.store.Get(ctx, key, GlobalScope)
+}
+
+// Invalidate erzwingt beim naechsten Resolve-Aufruf ein sofortiges Neuladen
+// fuer einen bestimmten (key, tenantSlug) statt auf den TTL-Ablauf zu warten
+// — analog internal/flag.Service.Invalidate.
+func (s *Service) Invalidate(key, tenantSlug string) {
+	s.mu.Lock()
+	delete(s.cache, cacheKey(key, tenantSlug))
+	s.mu.Unlock()
+}
@@ -0,0 +1,114 @@
+package cfgservice
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: Tenant-Override hat Vorrang vor
+// Global-Default, automatisiert getestet.
+func TestService_TenantOverrideTakesPrecedenceOverGlobal(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_precedence_key", GlobalScope, "global-wert"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if _, err := store.Set(ctx, "test_precedence_key", "test_acme", "tenant-wert"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	svc := NewService(store, time.Hour)
+
+	got, err := svc.Resolve(ctx, "test_acme", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve mit override: %v", err)
+	}
+	if got.Value != "tenant-wert" {
+		t.Fatalf("erwartet tenant-override, habe %q", got.Value)
+	}
+
+	gotOther, err := svc.Resolve(ctx, "test_anderer_tenant", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve ohne override: %v", err)
+	}
+	if gotOther.Value != "global-wert" {
+		t.Fatalf("erwartet global-default fuer tenant ohne override, habe %q", gotOther.Value)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Cache-Invalidierung nach
+// Konfigurationsaenderung innerhalb dokumentierter Zeit gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	v, err := svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("erwartet 'alt', habe %q", v.Value)
+	}
+
+	changedAt := time.Now()
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	v, err = svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve direkt nach aenderung: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("cache haette den alten wert liefern sollen, habe %q", v.Value)
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		v, err := svc.Resolve(ctx, "", "test_ttl_key")
+		if err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+		if v.Value == "neu" {
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", time.Since(changedAt), 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 := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+	_, _ = svc.Resolve(ctx, "", "test_invalidate_key")
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_key", "")
+
+	v, err := svc.Resolve(ctx, "", "test_invalidate_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "neu" {
+		t.Fatalf("erwartet sofort sichtbaren neuen wert nach Invalidate, habe %q", v.Value)
+	}
+}
@@ -0,0 +1,129 @@
+// Package cfgservice implementiert Core CFG-01: den zentralen Dienst fuer
+// globale und tenant-spezifische Konfigurationswerte mit Versionierung und
+// Cache-Invalidierung. Andere Module lesen Konfiguration AUSSCHLIESSLICH
+// ueber dieses Paket (Akzeptanzkriterium 3), niemals ueber eigene Tabellen.
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalScope ist der reservierte Scope-Wert fuer globale Defaults — jeder
+// andere Scope-Wert ist ein Tenant-Slug (Akzeptanzkriterium 1).
+const GlobalScope = "global"
+
+var ErrNotFound = errors.New("cfgservice: kein wert fuer diesen key gefunden")
+
+type Value struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+type HistoryEntry struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+// Store ist die Schreib-/Verwaltungsseite. Set schreibt IMMER sowohl den
+// aktuellen Stand (config_values) als auch einen Historieneintrag
+// (config_value_history) in derselben Transaktion — eine Aenderung ohne
+// Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set schreibt einen neuen Wert fuer (key, scope) und erhoeht die Version um 1
+// (Version 1 bei erstmaligem Setzen).
+func (s *Store) Set(ctx context.Context, key, scope, value string) (Value, error) {
+	if scope == "" {
+		return Value{}, errors.New("cfgservice: scope darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Value{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var currentVersion int
+	err = tx.QueryRow(ctx, `SELECT version FROM config_values WHERE key = $1 AND scope = $2`, key, scope).Scan(&currentVersion)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return Value{}, fmt.Errorf("aktuelle version lesen: %w", err)
+	}
+	newVersion := currentVersion + 1
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_values (key, scope, value, version, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key, scope) DO UPDATE SET value = $3, version = $4, updated_at = now()
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("wert speichern: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_value_history (key, scope, value, version, changed_at)
+		VALUES ($1, $2, $3, $4, now())
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Value{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Value{Key: key, Scope: scope, Value: value, Version: newVersion}, nil
+}
+
+// Get liefert den Wert fuer GENAU EINEN Scope (kein Vorrang-Fallback) — die
+// Vorrangregel (Tenant vor Global) lebt bewusst in Service.Resolve, damit
+// Store rein CRUD bleibt.
+func (s *Store) Get(ctx context.Context, key, scope string) (Value, error) {
+	var v Value
+	v.Key, v.Scope = key, scope
+	err := s.pool.QueryRow(ctx, `
+		SELECT value, version FROM config_values WHERE key = $1 AND scope = $2
+	`, key, scope).Scan(&v.Value, &v.Version)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Value{}, ErrNotFound
+		}
+		return Value{}, fmt.Errorf("wert lesen: %w", err)
+	}
+	return v, nil
+}
+
+// History liefert die vollstaendige Versionshistorie eines (key, scope) in
+// aufsteigender Reihenfolge (Akzeptanzkriterium 2 / Pruefung 3).
+func (s *Store) History(ctx context.Context, key, scope string) ([]HistoryEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, scope, value, version FROM config_value_history
+		WHERE key = $1 AND scope = $2 ORDER BY version
+	`, key, scope)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []HistoryEntry
+	for rows.Next() {
+		var h HistoryEntry
+		if err := rows.Scan(&h.Key, &h.Scope, &h.Value, &h.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, h)
+	}
+	return out, rows.Err()
+}
@@ -0,0 +1,119 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStoreTest(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 config_values (
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL CHECK (scope <> ''),
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (key, scope)
+		);
+		CREATE TABLE IF NOT EXISTS config_value_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL,
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM config_value_history WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM config_values WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+func TestStore_SetIncrementsVersion(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	v1, err := store.Set(ctx, "test_key", GlobalScope, "erster-wert")
+	if err != nil {
+		t.Fatalf("set 1: %v", err)
+	}
+	if v1.Version != 1 {
+		t.Fatalf("erwartet version 1, habe %d", v1.Version)
+	}
+
+	v2, err := store.Set(ctx, "test_key", GlobalScope, "zweiter-wert")
+	if err != nil {
+		t.Fatalf("set 2: %v", err)
+	}
+	if v2.Version != 2 {
+		t.Fatalf("erwartet version 2, habe %d", v2.Version)
+	}
+
+	got, err := store.Get(ctx, "test_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Value != "zweiter-wert" || got.Version != 2 {
+		t.Fatalf("aktueller wert unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Versionierungshistorie ueber mehrere
+// Aenderungen hinweg nachvollzogen.
+func TestStore_HistoryTracksAllChanges(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	values := []string{"v1", "v2", "v3"}
+	for _, v := range values {
+		if _, err := store.Set(ctx, "test_history_key", GlobalScope, v); err != nil {
+			t.Fatalf("set %q: %v", v, err)
+		}
+	}
+
+	history, err := store.History(ctx, "test_history_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 3 {
+		t.Fatalf("erwartet 3 historieneintraege, habe %d", len(history))
+	}
+	for i, h := range history {
+		if h.Version != i+1 || h.Value != values[i] {
+			t.Fatalf("historieneintrag[%d] unerwartet: %+v", i, h)
+		}
+	}
+}
+
+func TestStore_GetUnknownKeyReturnsNotFound(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Get(ctx, "test_nie_gesetzt", GlobalScope); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound, habe %v", err)
+	}
+}
@@ -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)
+	}
+}
@@ -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
+}
@@ -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
+}
@@ -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
+}
@@ -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)
+}
@@ -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
+}
@@ -10,8 +10,15 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr  string
+	ListenAddr string
+	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
+	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
+	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
+	AdminDSN string
+	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
+	TenantDSNTemplate string
 }

 func Load() (Config, error) {
@@ -20,10 +27,25 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}

+	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
+	if adminDSN == "" {
+		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
+	}
+
+	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
+	if dsnTemplate == "" {
+		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
+	}
+
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}

-	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
+	return Config{
+		ListenAddr:        addr,
+		RegistryDSN:       dsn,
+		AdminDSN:          adminDSN,
+		TenantDSNTemplate: dsnTemplate,
+	}, nil
 }
@@ -0,0 +1,81 @@
+// Package notify implementiert Core CFG-02: den zentralen Benachrichtigungs-
+// Dispatcher, ueber den beliebige Module Benachrichtigungen ausloesen —
+// Warteschlange, Wiederholungslogik, Kanal-Abstraktion. Die tatsaechlichen
+// Kanaele (E-Mail/In-App) sind CFG-03, hier gibt es nur die Sender-
+// Schnittstelle als Vorbereitung.
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultMaxAttempts begrenzt Wiederholungsversuche (Akzeptanzkriterium 2) —
+// nach dieser Anzahl gibt der Dispatcher kontrolliert auf (status=failed)
+// statt endlos zu wiederholen.
+const DefaultMaxAttempts = 5
+
+// DefaultRetryBackoff ist die Basis-Wartezeit zwischen Wiederholungen,
+// linear mit der Versuchsnummer skaliert.
+const DefaultRetryBackoff = 200 * time.Millisecond
+
+type Notification struct {
+	ID        string
+	Channel   string
+	Recipient string
+	Payload   map[string]any
+	Attempts  int
+}
+
+// Sender ist die schmale Schnittstelle, die ein konkreter Kanal (CFG-03)
+// implementiert. Der Dispatcher selbst weiss nichts ueber E-Mail/In-App.
+type Sender interface {
+	Send(ctx context.Context, n Notification) error
+}
+
+// Dispatcher ist die EINE Schnittstelle, ueber die Module Benachrichtigungen
+// ausloesen — kein Modul baut eigenen Versandcode (Akzeptanzkriterium 1).
+type Dispatcher struct {
+	pool         *pgxpool.Pool
+	maxAttempts  int
+	retryBackoff time.Duration
+}
+
+func NewDispatcher(pool *pgxpool.Pool) *Dispatcher {
+	return &Dispatcher{pool: pool, maxAttempts: DefaultMaxAttempts, retryBackoff: DefaultRetryBackoff}
+}
+
+// WithRetryPolicy erlaubt Tests/Betrieb, Versuchsanzahl und Backoff
+// anzupassen, ohne die Default-Policy im Produktionscode zu veraendern.
+func (d *Dispatcher) WithRetryPolicy(maxAttempts int, backoff time.Duration) *Dispatcher {
+	return &Dispatcher{pool: d.pool, maxAttempts: maxAttempts, retryBackoff: backoff}
+}
+
+// Enqueue reiht eine Benachrichtigung in die Postgres-Warteschlange ein und
+// kehrt sofort zurueck — die Zeile ueberlebt jeden Neustart des Dispatcher-
+// Prozesses unveraendert (Akzeptanzkriterium 3), da sie ausschliesslich in
+// der Datenbank existiert, nicht im Prozessspeicher.
+func (d *Dispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	var id string
+	err = d.pool.QueryRow(ctx, `
+		INSERT INTO notification_jobs (channel, recipient, payload, max_attempts)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, channel, recipient, payloadJSON, d.maxAttempts).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("benachrichtigung einreihen: %w", err)
+	}
+	return id, nil
+}
@@ -0,0 +1,219 @@
+package notify
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*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_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 pool, cleanup
+}
+
+type fakeSender struct {
+	mu        sync.Mutex
+	sentIDs   []string
+	failUntil int
+	calls     int
+}
+
+func (f *fakeSender) Send(ctx context.Context, n Notification) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls++
+	if f.calls <= f.failUntil {
+		return errors.New("simulierter zustellfehler")
+	}
+	f.sentIDs = append(f.sentIDs, n.ID)
+	return nil
+}
+
+func (f *fakeSender) sentCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.sentIDs)
+}
+
+// Akzeptanzkriterium 1: Module loesen ueber Enqueue aus, keine eigene
+// Versandlogik noetig.
+func TestDispatcher_EnqueueAndProcess(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	id, err := d.Enqueue(ctx, "email", "alice@example.com", map[string]any{"subject": "Willkommen"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id == "" {
+		t.Fatal("erwartet nicht-leere id")
+	}
+
+	sender := &fakeSender{}
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 failed=0, habe sent=%d failed=%d", sent, failed)
+	}
+	if sender.sentCount() != 1 {
+		t.Fatalf("erwartet 1 zustellung, habe %d", sender.sentCount())
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Wiederholungslogik greift bei
+// simuliertem Fehler und bricht nach definierter Anzahl kontrolliert ab.
+func TestProcessDue_RetriesThenGivesUpAfterMaxAttempts(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool).WithRetryPolicy(3, time.Millisecond)
+	id, err := d.Enqueue(ctx, "email", "bob@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	sender := &fakeSender{failUntil: 100} // schlaegt bei jedem versuch fehl
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(5 * time.Millisecond) // next_attempt_at abwarten
+		if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, id).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach max_attempts, habe %q", status)
+	}
+	if attempts != 3 {
+		t.Fatalf("erwartet 3 versuche, habe %d", attempts)
+	}
+
+	// Weiteres ProcessDue darf den bereits aufgegebenen job nicht mehr anfassen.
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach abbruch: %v", err)
+	}
+	if sent != 0 || failed != 0 {
+		t.Fatalf("erwartet keine weitere verarbeitung, habe sent=%d failed=%d", sent, failed)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Neustart des Dienstes waehrend offener
+// Zustellung verliert keine Nachricht — simuliert durch eine komplett neue
+// Dispatcher/Pool-Instanz nach dem Enqueue, bevor irgendetwas verarbeitet wurde.
+func TestQueue_SurvivesRestartWithoutMessageLoss(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	firstInstance := NewDispatcher(pool)
+	id, err := firstInstance.Enqueue(ctx, "email", "carol@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	// "Neustart": eine voellig neue Dispatcher-Instanz (repraesentiert einen
+	// neuen Prozess) verbindet sich neu und verarbeitet die Warteschlange —
+	// die Nachricht existiert ausschliesslich in Postgres, nicht im
+	// Prozessspeicher der ersten Instanz.
+	restartedInstance := NewDispatcher(pool)
+	sender := &fakeSender{}
+	sent, failed, err := restartedInstance.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach neustart: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 nach neustart, habe sent=%d failed=%d", sent, failed)
+	}
+	if len(sender.sentIDs) != 1 || sender.sentIDs[0] != id {
+		t.Fatalf("erwartet zustellung der urspruenglichen nachricht %q, habe %v", id, sender.sentIDs)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: zwei gleichzeitig ausloesende Module,
+// beide Nachrichten werden korrekt (und nicht doppelt) zugestellt.
+func TestProcessDue_ConcurrentDispatchBothDelivered(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	idA, err := d.Enqueue(ctx, "email", "modul-a@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue a: %v", err)
+	}
+	idB, err := d.Enqueue(ctx, "email", "modul-b@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue b: %v", err)
+	}
+
+	sender := &fakeSender{}
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+				t.Errorf("process: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if sender.sentCount() != 2 {
+		t.Fatalf("erwartet genau 2 zustellungen, habe %d: %v", sender.sentCount(), sender.sentIDs)
+	}
+	seen := map[string]bool{}
+	for _, id := range sender.sentIDs {
+		if seen[id] {
+			t.Fatalf("nachricht %q wurde doppelt zugestellt", id)
+		}
+		seen[id] = true
+	}
+	if !seen[idA] || !seen[idB] {
+		t.Fatalf("erwartet beide nachrichten zugestellt, habe %v", sender.sentIDs)
+	}
+}
@@ -0,0 +1,102 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// ProcessDue holt bis zu limit faellige Benachrichtigungen und versucht sie
+// ueber sender zuzustellen. FOR UPDATE SKIP LOCKED serialisiert konkurrierende
+// Aufrufe (Akzeptanzkriterium 3 / Pruefung 3: zwei gleichzeitig ausloesende
+// Module duerfen sich nicht gegenseitig blockieren oder Nachrichten doppelt
+// zustellen) — dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions.
+func (d *Dispatcher) ProcessDue(ctx context.Context, sender Sender, limit int) (sent, failed int, err error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT id, channel, recipient, payload, attempts, max_attempts
+		FROM notification_jobs
+		WHERE status = 'pending' AND next_attempt_at <= now()
+		ORDER BY created_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return 0, 0, fmt.Errorf("faellige benachrichtigungen abfragen: %w", err)
+	}
+
+	type due struct {
+		id, channel, recipient string
+		payload                []byte
+		attempts, maxAttempts  int
+	}
+	var candidates []due
+	for rows.Next() {
+		var c due
+		if err := rows.Scan(&c.id, &c.channel, &c.recipient, &c.payload, &c.attempts, &c.maxAttempts); err != nil {
+			rows.Close()
+			return 0, 0, fmt.Errorf("faellige benachrichtigung lesen: %w", err)
+		}
+		candidates = append(candidates, c)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, 0, err
+	}
+
+	for _, c := range candidates {
+		var payload map[string]any
+		if err := json.Unmarshal(c.payload, &payload); err != nil {
+			payload = map[string]any{}
+		}
+
+		sendErr := sender.Send(ctx, Notification{
+			ID: c.id, Channel: c.channel, Recipient: c.recipient, Payload: payload, Attempts: c.attempts,
+		})
+
+		if sendErr == nil {
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs SET status = 'sent', updated_at = now() WHERE id = $1
+			`, c.id); err != nil {
+				return sent, failed, fmt.Errorf("erfolg speichern: %w", err)
+			}
+			sent++
+			continue
+		}
+
+		newAttempts := c.attempts + 1
+		if newAttempts >= c.maxAttempts {
+			// Akzeptanzkriterium 2: kontrollierter Abbruch nach definierter
+			// Anzahl Versuche, kein endloses Wiederholen.
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs
+				SET status = 'failed', attempts = $2, last_error = $3, updated_at = now()
+				WHERE id = $1
+			`, c.id, newAttempts, sendErr.Error()); err != nil {
+				return sent, failed, fmt.Errorf("fehlschlag speichern: %w", err)
+			}
+			failed++
+			continue
+		}
+
+		nextAttempt := time.Now().Add(time.Duration(newAttempts) * d.retryBackoff)
+		if _, err := tx.Exec(ctx, `
+			UPDATE notification_jobs
+			SET attempts = $2, next_attempt_at = $3, last_error = $4, updated_at = now()
+			WHERE id = $1
+		`, c.id, newAttempts, nextAttempt, sendErr.Error()); err != nil {
+			return sent, failed, fmt.Errorf("wiederholung planen: %w", err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return sent, failed, nil
+}
@@ -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)
+}
@@ -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))
+	}
+}
@@ -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
+}
@@ -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))
+	}
+}
@@ -0,0 +1,45 @@
+package tenant
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
+// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
+// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
+// TEN-01 und werden dort nachgezogen.
+type Handler struct {
+	provisioner *Provisioner
+}
+
+func NewHandler(p *Provisioner) *Handler {
+	return &Handler{provisioner: p}
+}
+
+type createTenantRequest struct {
+	Slug string `json:"slug"`
+	Name string `json:"name"`
+}
+
+func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
+	var req createTenantRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
+	if err != nil {
+		if err == ErrInvalidSlug {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(t)
+}
@@ -0,0 +1,78 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
+// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
+// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
+// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
+type Provisioner struct {
+	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
+	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
+	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
+	adminPool *pgxpool.Pool
+	registry  *Registry
+	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
+	dsnTemplate string
+}
+
+func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
+	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
+}
+
+// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
+// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
+// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
+func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
+	if err := ValidateSlug(slug); err != nil {
+		return Tenant{}, err
+	}
+
+	dbName := dbNameForSlug(slug)
+
+	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
+	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
+	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
+	}
+
+	t := Tenant{
+		Slug:   slug,
+		Name:   name,
+		DBName: dbName,
+		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
+		Status: StatusActive,
+	}
+
+	tx, err := p.registry.pool.Begin(ctx)
+	if err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
+	}
+
+	created, err := p.registry.insertTx(ctx, tx, t)
+	if err != nil {
+		_ = tx.Rollback(ctx)
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
+	}
+
+	return created, nil
+}
+
+// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
+// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
+func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
+	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+}
@@ -0,0 +1,105 @@
+package tenant
+
+import (
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
+// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
+// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
+//
+// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
+//
+//	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
+func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
+	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)
+	}
+	defer adminPool.Close()
+
+	registryPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+	defer registryPool.Close()
+
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("registry-schema: %v", err)
+	}
+
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	registry := NewRegistry(registryPool)
+	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
+
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
+	})
+
+	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
+	if err != nil {
+		t.Fatalf("provision acme: %v", err)
+	}
+	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
+	if err != nil {
+		t.Fatalf("provision globex: %v", err)
+	}
+
+	if tenantA.DBName == tenantB.DBName {
+		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
+	}
+
+	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
+	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
+	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
+	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
+	if err != nil {
+		t.Fatalf("connect tenant a: %v", err)
+	}
+	defer poolA.Close()
+
+	var globexVisible bool
+	err = poolA.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
+		)
+	`, tenantB.DBName).Scan(&globexVisible)
+	if err != nil {
+		t.Fatalf("pruefung tenant-trennung: %v", err)
+	}
+	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
+	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
+	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
+	var currentDB string
+	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
+		t.Fatalf("current_database: %v", err)
+	}
+	if currentDB != tenantA.DBName {
+		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
+	}
+	if currentDB == tenantB.DBName {
+		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
+	}
+}
@@ -0,0 +1,69 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
+// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
+// niemals Geschaeftsdaten eines Mandanten.
+type Registry struct {
+	pool *pgxpool.Pool
+}
+
+func NewRegistry(pool *pgxpool.Pool) *Registry {
+	return &Registry{pool: pool}
+}
+
+// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
+// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
+func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
+	row := tx.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, created_at
+	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
+
+	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
+	var t Tenant
+	row := r.pool.QueryRow(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants WHERE slug = $1
+	`, slug)
+
+	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
+	rows, err := r.pool.Query(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("tenants auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Tenant
+	for rows.Next() {
+		var t Tenant
+		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("tenant lesen: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}
@@ -0,0 +1,42 @@
+// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
+// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
+package tenant
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive Status = "active"
+)
+
+type Tenant struct {
+	ID        string
+	Slug      string
+	Name      string
+	DBName    string
+	DBDSN     string
+	Status    Status
+	CreatedAt time.Time
+}
+
+// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
+// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
+var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
+
+var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
+
+func ValidateSlug(slug string) error {
+	if !slugPattern.MatchString(slug) {
+		return ErrInvalidSlug
+	}
+	return nil
+}
+
+func dbNameForSlug(slug string) string {
+	return "tenant_" + slug
+}
@@ -0,0 +1,35 @@
+package tenant
+
+import "testing"
+
+func TestValidateSlug(t *testing.T) {
+	cases := []struct {
+		slug    string
+		wantErr bool
+	}{
+		{"acme", false},
+		{"acme_gmbh", false},
+		{"a1", false},
+		{"", true},
+		{"a", true},
+		{"1acme", true},
+		{"Acme", true},
+		{"acme-gmbh", true},
+		{"acme;drop table tenants", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateSlug(c.slug)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
+		}
+	}
+}
+
+func TestDBNameForSlug(t *testing.T) {
+	got := dbNameForSlug("acme")
+	want := "tenant_acme"
+	if got != want {
+		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
+	}
+}
@@ -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)
+}
@@ -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)
+	}
+}
@@ -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))
+}
@@ -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)
+}
@@ -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
+}
@@ -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)
+		}
+	}
+}
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenants;
@@ -1,10 +0,0 @@
-- Control-plane registry: tenant list + connection info (Modell C).
-- Core TEN-01 (siehe core-kanban).
-CREATE TABLE tenants (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    slug         TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    db_dsn       TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -0,0 +1,14 @@
+-- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
+-- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
+-- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE tenants (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug         TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    db_name      TEXT NOT NULL UNIQUE,
+    db_dsn       TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS superadmins;
@@ -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()
+);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS config_value_history;
+DROP TABLE IF EXISTS config_values;
@@ -0,0 +1,23 @@
+-- Zentraler Konfigurationsdienst (CFG-01, siehe core-kanban/tickets/CFG-01.md).
+-- scope = 'global' fuer globale Defaults, sonst der Tenant-Slug. config_values
+-- haelt den AKTUELLEN Stand je (key, scope); config_value_history haelt JEDE
+-- Aenderung fest (Akzeptanzkriterium 2: versioniert nachvollziehbar).
+CREATE TABLE config_values (
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL CHECK (scope <> ''),
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (key, scope)
+);
+
+CREATE TABLE config_value_history (
+    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    key        TEXT NOT NULL,
+    scope      TEXT NOT NULL,
+    value      TEXT NOT NULL,
+    version    INT NOT NULL,
+    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX config_value_history_key_scope_idx ON config_value_history (key, scope, version);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS notification_jobs;
@@ -0,0 +1,20 @@
+-- Benachrichtigungs-Dispatcher-Warteschlange (CFG-02, siehe
+-- core-kanban/tickets/CFG-02.md). Postgres-basiert statt Redis/AMQP
+-- (Projekt-Konvention, siehe nexarch-state.json techstack.job_queue) —
+-- Zeilen ueberleben einen Neustart des Dispatcher-Prozesses unveraendert
+-- (Akzeptanzkriterium 3).
+CREATE TABLE 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()
+);
+
+CREATE INDEX notification_jobs_due_idx ON notification_jobs (status, next_attempt_at);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS in_app_notifications;
+DROP TABLE IF EXISTS notification_templates;
@@ -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);
@@ -0,0 +1 @@
+DROP TABLE notification_preferences;
@@ -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);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;
@@ -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()
+);
@@ -0,0 +1 @@
+ALTER TABLE users DROP COLUMN password_hash;
@@ -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 '';
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
+ROLE="nexarch_test"
+export PGPASSWORD="$PASS"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
+for db in $dbs; do
+	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
+done
+echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
+cd "$(dirname "$0")/.."
+NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
+export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
+echo "== go build =="
+go build ./...
+echo "== go vet =="
+go vet ./...
+echo "== go test (-p 1) =="
+go test ./... -p 1 -count=1
@@ -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>
+  );
+}
@@ -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>
+  );
+}
@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function IndexPage() {
+  redirect("/settings");
+}
@@ -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>
+  );
+}
@@ -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");
+}
@@ -0,0 +1,5 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;
@@ -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"
+  }
+}
@@ -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"]
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
sysops	4be7853611	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	2026-08-30 21:48:09 +02:00
sysops	b1601c578a	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 23:54:01 +02:00
sysops	1e1a8359cb	CFG-04: go.sum neu erzeugen (go mod tidy nach IAM-02-Merge)	2026-08-28 23:53:39 +02:00
sysops	b27a640116	CFG-04: benachrichtigungs-einstellungen-oberflaeche (handler+tests fuer notifyprefs, web/notifications next.js-frontend auf shl-01)	2026-08-28 23:50:54 +02:00
sysops	81ff8c18c3	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche # Conflicts: # DEVLOG.md	2026-08-28 23:48:23 +02:00
sysops	22b3349b8e	Merge branch 'feature/iam-02-login-session-jwt-grundgeruest' into feature/cfg-04-benachrichtigungs-einstellungen-oberflaeche # Conflicts: # go.mod # go.sum	2026-08-28 23:48:13 +02:00
sysops	2df3f93373	CFG-04: backend teil 1 — internal/notifyprefs (praeferenz-store + enqueueifallowed-filter vor dispatcher)	2026-08-28 23:47:46 +02:00
sysops	bfa5c61db5	SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)	2026-08-28 22:01:56 +02:00
sysops	3c226dab12	SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)	2026-08-28 21:55:34 +02:00
sysops	584cefa388	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 21:45:55 +02:00
sysops	00665592f6	SHL-01: ui-shell-design-system-zentral (tokens, theming, i18n-rahmen, basis-komponenten)	2026-08-28 21:41:56 +02:00
sysopsandClaude Sonnet 5	034865f5a0	CFG-03: benachrichtigungs-kanaele-e-mail-in-app internal/channels: konkrete Zustellkanaele fuer CFG-02s Dispatcher. TemplateStore.Resolve loest Vorlagen pro Tenant auf und faellt auf GlobalTemplateScope zurueck, wenn ein Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3). Render nutzt text/template mit Option("missingkey=error") — ein fehlender Platzhalter bricht das Rendering MIT FEHLER ab, statt eine unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1). EmailSender implementiert notify.Sender: rendert ZUERST die Vorlage, bevor ueberhaupt eine SMTP-Verbindung aufgebaut wird — schlaegt das Rendering fehl, wird nie ein Netzwerkzugriff versucht. Ein anschliessend fehl- schlagender SMTP-Versand liefert einen Fehler, den CFG-02s bereits getestete Wiederholungslogik verarbeitet (kein zweiter Retry-Mechanismus hier). InAppSender persistiert In-App-Nachrichten ueber InAppStore (Akzeptanzkriterium 2, ueber API abrufbar/als gelesen markierbar). Router waehlt den Kanal anhand Notification.Channel — ein neuer Kanal wird per Register() ergaenzt, ohne Dispatcher oder Router umzubauen. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Vorlagenrendering mit fehlenden Platzhaltern bricht kontrolliert ab — TestRender_MissingPlaceholderAborts und TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing (Fehler kommt von der Vorlagenaufloesung, kein SMTP-Verbindungsversuch). PASS. 2. In-App-Benachrichtigung nach Markierung als gelesen korrekt gefuehrt — TestInAppStore_MarkReadIsReflectedCorrectly. PASS. 3. E-Mail-Versand bei nicht erreichbarem SMTP-Server loest dokumentiertes Retry-Verhalten ueber CFG-02 aus — TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP: echter EmailSender gegen unerreichbaren Host, ueber notify.Dispatcher eingereiht, nach ausgeschoepften Wiederholungen status=failed mit korrekter Versuchszahl. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 23:23:45 +02:00
sysopsandClaude Sonnet 5	6f532d8350	CFG-02: benachrichtigungs-dispatcher-core-service-fuer-module internal/notify: Dispatcher.Enqueue ist die EINE schmale Schnittstelle, ueber die Module Benachrichtigungen ausloesen (Akzeptanzkriterium 1) — kein Modul baut eigenen Versandcode. Warteschlange ist die Postgres-Tabelle notification_jobs (Projekt-Konvention statt Redis/AMQP), existiert ausschliesslich in der Datenbank, nicht im Prozessspeicher. Dispatcher.ProcessDue holt faellige Jobs per FOR UPDATE SKIP LOCKED (dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions) — serialisiert konkurrierende Worker/Module, verhindert doppelte Zustellung. Fehlschlag erhoeht attempts und plant next_attempt_at mit linearem Backoff; nach max_attempts wird der Job kontrolliert auf status=failed gesetzt statt endlos wiederholt zu werden (Akzeptanzkriterium 2). Sender ist eine schmale Schnittstelle fuer die eigentlichen Kanaele (E-Mail/In-App = CFG-03, nicht Teil dieser Kachel) — der Dispatcher kennt nur "zustellen oder nicht", keine Kanal-Details. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Neustart waehrend offener Zustellung verliert keine Nachricht — TestQueue_SurvivesRestartWithoutMessageLoss: Enqueue durch eine Dispatcher-Instanz, Verarbeitung durch eine komplett neue (simulierter Neustart), Nachricht wird trotzdem zugestellt. PASS. 2. Wiederholungslogik greift bei simuliertem Fehler und bricht kontrolliert ab — TestProcessDue_RetriesThenGivesUpAfterMaxAttempts: 3 Versuche bei max_attempts=3, danach status=failed, keine weitere Verarbeitung. PASS. 3. Zwei Module loesen gleichzeitig aus, beide korrekt zugestellt — TestProcessDue_ConcurrentDispatchBothDelivered: zwei parallele ProcessDue-Aufrufe, beide Nachrichten je genau einmal zugestellt, keine Doppelzustellung. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:06:36 +02:00
sysopsandClaude Sonnet 5	4180a26c6e	CFG-01: zentraler-konfigurationsdienst internal/cfgservice: Store (Schreiben/Historie) + Service (Lesen mit Vorrangregel + TTL-Cache, Default 5s, analog internal/flag). Genannt "cfgservice" statt "config", da internal/config bereits die Bootstrap- Konfiguration des Core-Prozesses selbst belegt. Store.Set schreibt aktuellen Stand (config_values) und Historieneintrag (config_value_history) atomar in einer Transaktion — eine Aenderung ohne Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2). Version wird pro (key, scope) monoton hochgezaehlt. Service.Resolve wendet die Vorrangregel an: Tenant-spezifischer Override (scope = Tenant-Slug) hat Vorrang vor globalem Default (scope = 'global'), faellt sauber zurueck wenn kein Override existiert (Akzeptanzkriterium 1). Invalidate erzwingt sofortiges Neuladen fuer den Schreiber, andere Instanzen sehen Aenderungen spaetestens nach der TTL. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Vorrangregel automatisiert getestet — TestService_TenantOverrideTakesPrecedenceOverGlobal: Tenant mit Override bekommt Tenant-Wert, Tenant ohne Override bekommt Global-Default. PASS. 2. Cache-Invalidierung nach Aenderung innerhalb dokumentierter Zeit gemessen — TestService_CacheInvalidationTiming: wirksam nach 154ms bei TTL=150ms (innerhalb Ziel+Toleranz), vorher nachweislich noch alter Stand. PASS. 3. Versionierungshistorie ueber mehrere Aenderungen nachvollzogen — TestStore_HistoryTracksAllChanges: 3 aufeinanderfolgende Aenderungen, Historie liefert alle 3 in korrekter Reihenfolge mit korrekten Versionsnummern. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:26:14 +02:00
sysopsandClaude Sonnet 5	3d20d86a4f	IAM-02: login-session-jwt-grundgeruest internal/auth: Login/Logout ueber httpOnly/Secure/SameSite=Strict-Cookie mit HS256-JWT (30min TTL), bcrypt-Passwort-Hashing (Cost 12, explizit begruendet und benchmarkt statt DefaultCost uebernommen), RequireAuth-Middleware fuer geschuetzte Routen. LoginService ist strukturell auf einen Tenant gescopt (nutzt user.TenantUserStore, dessen Pool = eine Tenant-DB — derselbe Mechanismus wie in TEN-01/TEN-02), liefert bei falscher E-Mail und falschem Passwort denselben Fehler (User-Enumeration-Schutz) inkl. Dummy-bcrypt- Vergleich gegen Timing-Seitenkanal bei unbekannter E-Mail. user.TenantUserStore erweitert um SetPasswordHash/GetByEmailForAuth (password_hash bleibt ausserhalb des regulaeren User-Typs/JSON-Pfads). Migration 0002 fuegt password_hash-Spalte hinzu (Default '', da IAM-01 User ohne Passwort anlegt). Login-Handler ist wie IAM-01/TEN-02 aus denselben Gruenden (Tenant- Connection-Routing = TEN-06, noch nicht gebaut) nicht in cmd/core/main.go verdrahtet — Package ist eigenstaendig nutzbar/getestet. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Login-Query tenant-gescopt — TestLoginService_NoCrossTenantLogin: gleiche E-Mail in zwei Tenant-DBs mit unterschiedlichem Passwort, Login gegen Tenant A mit Tenant-B-Passwort schlaegt fehl. PASS. 2. Session-Fixation/Token-Manipulation — TestTokenVerify_RejectsManipulatedPayload und TestTokenVerify_RejectsWrongSecret: manipuliertes/falsch signiertes Token wird abgelehnt. PASS. 3. Abgelaufenes Token erzwingt Neuanmeldung — TestTokenVerify_RejectsExpiredToken und TestRequireAuth_BlocksWithoutValidCookie. PASS. 4. Login-Latenz mit Kostenfaktor 12 gemessen: 294ms (Ziel < 400ms) — TestBcryptCostAgainstLatencyTarget. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 18:26:00 +02:00
sysopsandClaude Sonnet 5	e4793303fc	IAM-01: benutzer-datenmodell-crud Benutzer-Datenmodell + CRUD fuer Tenant-User (tenant-scoped, keine tenant_id-Spalte noetig, Tenant ergibt sich aus der DB-Verbindung, Modell C) und getrennt dafuer SuperadminStore fuer mandantenuebergreifende Konten in der Registry-DB — First-Class-Typ statt tenant_id-NULL-Sonderfall im Tenant-User-Code (bekannter archivdms-Fehler vermieden). E-Mail-Eindeutigkeit: tenant-scoped fuer normale Benutzer (UNIQUE-Constraint gilt nur innerhalb der jeweiligen Tenant-DB), global fuer Superadmins (eine Registry-DB, ein UNIQUE-Constraint). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. CRUD automatisiert getestet inkl. Negativfaellen — TestTenantUserStore_CRUD deckt doppelte E-Mail (ErrEmailTaken) und unbekannte ID ab. PASS. 2. Superadmin-Anlage ohne Tenant-Kontext — TestSuperadminStore_CreateWithoutTenantContext: SuperadminStore.Create hat syntaktisch keinen Tenant-Parameter, kein if-Zweig fuer "kein Tenant" im Code. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Tenant-User-Handler ist im Code vorhanden, aber in cmd/core/main.go noch nicht geroutet — braucht Connection-Routing pro Mandant (TEN-06), das nicht Teil dieser Kachel ist. Nur der Superadmin-Endpunkt ist verdrahtet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:57:49 +02:00
sysopsandClaude Sonnet 5	8da9c67d08	TEN-01: tenant-registry-datenbank-provisioning Registry-DB (nur Tenant-Metadaten), Provisioning-Routine legt pro Mandant eine physisch isolierte Postgres-DB an und registriert sie transaktional (Rollback der DB bei fehlgeschlagener Registrierung). Schlanker HTTP-Handler als Schnittstellen-Vorbereitung fuer API-01/TEN-02, kein eigenes REST-Grundgerüst. Pruefungen: 1. Migration up/down geschrieben (0001_tenant_registry.{up,down}.sql) — nicht gegen echte DB ausgefuehrt, da auf dieser Maschine kein Go/Postgres-Test- Setup verfuegbar ist. Offen zur Ausfuehrung. 2. Integrationstest TestProvision_CreatesIsolatedDatabases geschrieben (zwei Mandanten, prueft unterschiedliche db_name und current_database()) — ebenfalls nicht ausgefuehrt, guarded per TEST_ADMIN_DSN env var. Offen. 3. Slug-Validierung (unit test TestValidateSlug) deckt SQL-Injection-Versuch im Datenbanknamen ab — ebenfalls nicht lokal ausgefuehrt, da kein Go Compiler auf dieser Maschine vorhanden ist. Offen. Alle drei Pruefungen sind vorbereitet, aber NICHT durchgefuehrt worden — zaehlen laut Vorgabe als offen bis auf einer Maschine mit Go+Postgres verifiziert. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:40:35 +02:00
				`@@ -0,0 +1 @@`
				`ALTER TABLE users DROP COLUMN password_hash;`