IAM-06: sso-anmeldung-ueber-oidc

internal/oidc: JWKS-Parser (RSA-Schluessel, RFC 7517) + Verifier prueft ID-Tokens gegen den geparsten Schluesselsatz (Signatur, Ablauf ueber die jwt-Bibliothek, Aussteller) — Akzeptanzkriterium 3. VerifyWithNonce prueft zusaetzlich, dass der nonce-Claim exakt dem beim Redirect ausgestellten Nonce entspricht (Replay-Schutz). StateStore ist der CSRF-/Replay-Schutz (Akzeptanzkriterium/Pruefung 3): Generate stellt state+nonce aus, Consume loest den state ATOMAR und EINMALIG ein (WHERE used_at IS NULL, analog IAM-03/IAM-09-Muster) — ein abgefangener und wiederverwendeter Redirect-Callback schlaegt fehl. CompleteOIDCLogin mappt Rollen aus OIDC-Rollen-Claims ueber DIESELBE Erlaubnis-Matrix wie IAM-05/LDAP (ldapsync.RoleMappingStore.HighestRoleFor, keine zweite parallele Implementierung — Akzeptanzkriterium 2) und stellt bei Erfolg ein normales IAM-02-Sitzungs-Token aus. Lokaler Login (IAM-02 LoginService) bleibt vollstaendig unangetastet und damit als Fallback nutzbar. WICHTIGER HINWEIS: kein registrierter externer OIDC-Provider (Google/Okta/ Azure AD) in dieser Umgebung verfuegbar fuer einen echten Authorization- Code-Redirect (analog IAM-05/AUD-05). ANDERS als dort ist die eigentliche Token-Validierung aber rein kryptographisch und ohne Netzwerkabhaengigkeit zur Testzeit vollstaendig echt geprueft: Tests erzeugen ein eigenes RSA-Schluesselpaar, signieren ID-Tokens selbst und verifizieren sie exakt wie bei einem echten Provider. Nur der Live-Redirect zu einem realen externen IdP bleibt ungeprueft. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Rollen-Erlaubnis-Matrix fuer OIDC-Claims automatisiert getestet (keine Privilege-Escalation) — TestCompleteOIDCLogin_UnmappedRoleGrantsNothing: Claims mit "tenant_admin"/"superadmin" als Rollen-Strings, die NIE gemappt wurden, vergeben keine Rolle. PASS. 2. Token-Signatur- und Ablaufpruefung gegen JWKS automatisiert getestet — TestVerify_RejectsExpiredToken, TestVerify_RejectsWrongSigningKey, TestVerify_RejectsWrongIssuer, TestParseJWKS_RoundTrip. PASS. 3. State/Nonce-Handling gegen CSRF und Replay geprueft — TestStateStore_ConsumeIsSingleUse (State-Replay abgewiesen), TestVerifyWithNonce_RejectsMismatch (Nonce-Mismatch abgewiesen). PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
IAM-05: ldap-active-directory-anbindung
2026-08-27 22:53:42 +02:00 · 2026-08-27 22:39:10 +02:00 · 2026-08-27 18:26:00 +02:00 · 2026-08-27 17:57:49 +02:00 · 2026-08-27 17:40:35 +02:00
104 changed files with 3113 additions and 2870 deletions
@@ -44,3 +44,88 @@ 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
 ### 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 ++++++++++
 ---
@@ -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,55 +0,0 @@
 // reconcile-cli ist der Aufrufpunkt für BAK-05, für systemd-Timer gedacht
 // (siehe deploy/systemd/) — "geplanter Abgleichs-Job" (Ticket-Vorgabe)
 // entsteht durch die Timer-Definition, kein eigener Dauerprozess.
 package main
 import (
 	"context"
 	"encoding/json"
 	"log"
 	"os"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/reconcile"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_RECONCILE_TENANT_DSN")
 	storageDir := os.Getenv("NEXARCH_RECONCILE_STORAGE_DIR")
 	if dsn == "" || storageDir == "" {
 		log.Fatal("NEXARCH_RECONCILE_TENANT_DSN und NEXARCH_RECONCILE_STORAGE_DIR muessen gesetzt sein")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		log.Fatalf("datenbankverbindung: %v", err)
 	}
 	defer pool.Close()
 	dbEntries, err := reconcile.ListDBStorageKeys(ctx, pool)
 	if err != nil {
 		log.Fatalf("datenbank-eintraege lesen: %v", err)
 	}
 	storageKeys, err := reconcile.ListStorageObjects(storageDir)
 	if err != nil {
 		log.Fatalf("objekt-storage durchlaufen: %v", err)
 	}
 	report := reconcile.Reconcile(dbEntries, storageKeys)
 	encoder := json.NewEncoder(os.Stdout)
 	encoder.SetIndent("", "  ")
 	if err := encoder.Encode(report); err != nil {
 		log.Fatalf("bericht ausgeben: %v", err)
 	}
 	// Nicht-null-Exit-Code bei Abweichungen (Akzeptanzkriterium 3:
 	// Abweichungen werden BERICHTET, nicht automatisch behoben — der
 	// Exit-Code macht das fuer systemd/Monitoring sichtbar, OHNE selbst
 	// irgendetwas zu reparieren).
 	if !report.IsClean() {
 		os.Exit(1)
 	}
 }
@@ -1,144 +0,0 @@
 // scrub-cli ist der Aufrufpunkt fuer BAK-08 (systemd-Timer, konfigurierbare
 // Kadenz) — zieht eine Stichprobe existierender Objekte (BAK-05 als
 // Existenz-Quelle), prueft deren Inhalt per SHA-256 gegen
 // file_revisions.checksum_sha256, meldet Abweichungen (kein Auto-Repair)
 // und schreibt den Befund-Zaehler fuer den OPS-05/OPS-03-Metrik-Export.
 package main
 import (
 	"context"
 	"encoding/json"
 	"log"
 	"os"
 	"strconv"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/reconcile"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/scrub"
 )
 type finding struct {
 	StorageKey string `json:"storage_key"`
 	DocumentID string `json:"document_id"`
 	RevisionID string `json:"revision_id"`
 	Expected   string `json:"expected_checksum"`
 	Actual     string `json:"actual_checksum,omitempty"`
 	Error      string `json:"error,omitempty"`
 }
 type report struct {
 	GeneratedAt time.Time `json:"generated_at"`
 	Sampled     int       `json:"sampled"`
 	Findings    []finding `json:"findings"`
 }
 func main() {
 	dsn := os.Getenv("NEXARCH_SCRUB_TENANT_DSN")
 	storageDir := os.Getenv("NEXARCH_SCRUB_STORAGE_DIR")
 	if dsn == "" || storageDir == "" {
 		log.Fatal("NEXARCH_SCRUB_TENANT_DSN und NEXARCH_SCRUB_STORAGE_DIR muessen gesetzt sein")
 	}
 	sampleSize := envInt("NEXARCH_SCRUB_SAMPLE_SIZE", 10)
 	cooldown := envDuration("NEXARCH_SCRUB_COOLDOWN", 24*time.Hour)
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		log.Fatalf("datenbankverbindung: %v", err)
 	}
 	defer pool.Close()
 	dbEntries, err := reconcile.ListDBStorageKeys(ctx, pool)
 	if err != nil {
 		log.Fatalf("datenbank-eintraege lesen: %v", err)
 	}
 	storageKeys, err := reconcile.ListStorageObjects(storageDir)
 	if err != nil {
 		log.Fatalf("objekt-storage durchlaufen: %v", err)
 	}
 	rec := reconcile.Reconcile(dbEntries, storageKeys)
 	lastScrubbed, err := scrub.LoadLastScrubbed(ctx, pool)
 	if err != nil {
 		log.Fatalf("scrub-zustand lesen: %v", err)
 	}
 	now := time.Now().UTC()
 	candidates := scrub.Sample(rec.ExistingInStorage, lastScrubbed, cooldown, sampleSize, now)
 	keys := make([]string, 0, len(candidates))
 	for _, c := range candidates {
 		keys = append(keys, c.StorageKey)
 	}
 	expected, err := scrub.ExpectedChecksums(ctx, pool, keys)
 	if err != nil {
 		log.Fatalf("erwartete pruefsummen lesen: %v", err)
 	}
 	rep := report{GeneratedAt: now, Sampled: len(candidates)}
 	for _, c := range candidates {
 		exp, known := expected[c.StorageKey]
 		if !known {
 			// Objekt in DB nicht (mehr) auffindbar - das ist BAK-05s
 			// Zustaendigkeit (existiert der Datenbankeintrag?), nicht
 			// dieses Jobs; ueberspringen ohne Markierung.
 			continue
 		}
 		actual, readErr := scrub.ActualChecksum(storageDir, c.StorageKey)
 		ok := readErr == nil && actual == exp
 		if err := scrub.MarkScrubbed(ctx, pool, c.StorageKey, ok, now); err != nil {
 			log.Fatalf("scrub-zustand schreiben: %v", err)
 		}
 		if !ok {
 			f := finding{StorageKey: c.StorageKey, DocumentID: c.DocumentID, RevisionID: c.RevisionID, Expected: exp, Actual: actual}
 			if readErr != nil {
 				f.Error = readErr.Error()
 			}
 			rep.Findings = append(rep.Findings, f)
 			if err := scrub.RecordFinding(ctx, pool); err != nil {
 				log.Fatalf("befund-zaehler erhoehen: %v", err)
 			}
 		}
 	}
 	encoder := json.NewEncoder(os.Stdout)
 	encoder.SetIndent("", "  ")
 	if err := encoder.Encode(rep); err != nil {
 		log.Fatalf("bericht ausgeben: %v", err)
 	}
 	// Befund wird gemeldet, nicht automatisch repariert (Akzeptanzkriterium
 	// 3) - der Exit-Code macht das fuer systemd/Monitoring sichtbar, ohne
 	// selbst etwas zu reparieren; die tatsaechliche Meldung an OPS-05
 	// laeuft ueber den separaten /metrics-Export (cmd/scrub-metrics), nicht
 	// ueber diesen Exit-Code.
 	if len(rep.Findings) > 0 {
 		os.Exit(1)
 	}
 }
 func envInt(name string, def int) int {
 	v := os.Getenv(name)
 	if v == "" {
 		return def
 	}
 	n, err := strconv.Atoi(v)
 	if err != nil {
 		log.Fatalf("%s: ungueltiger wert %q: %v", name, v, err)
 	}
 	return n
 }
 func envDuration(name string, def time.Duration) time.Duration {
 	v := os.Getenv(name)
 	if v == "" {
 		return def
 	}
 	d, err := time.ParseDuration(v)
 	if err != nil {
 		log.Fatalf("%s: ungueltiger wert %q: %v", name, v, err)
 	}
 	return d
 }
@@ -1,62 +0,0 @@
 // scrub-metrics stellt BAK-08s Befund-Zaehler unter /metrics bereit — die
 // OPS-05-Anbindung ist Pull-basiert (Core OPS-03 scrapt /metrics-URLs, kein
 // Push-Mechanismus), daher braucht es einen eigenen, dauerhaft laufenden
 // HTTP-Endpunkt getrennt vom Oneshot-scrub-cli (dessen Prozess nach jedem
 // Lauf beendet ist und daher zum Scrape-Zeitpunkt nicht erreichbar waere).
 package main
 import (
 	"context"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/scrub"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_SCRUB_TENANT_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_SCRUB_TENANT_DSN muss gesetzt sein")
 	}
 	addr := os.Getenv("NEXARCH_SCRUB_METRICS_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8090"
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		log.Fatalf("datenbankverbindung: %v", err)
 	}
 	defer pool.Close()
 	mux := http.NewServeMux()
 	mux.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
 		total, err := scrub.FindingsTotal(r.Context(), pool)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 		w.Header().Set("Content-Type", "text/plain; version=0.0.4")
 		// Counter (Akzeptanzkriterium/Nutzervorgabe: monoton steigend, kein
 		// Gauge) - kein Befund => Wert 0, kein Dauer-Alarm ("kein Befund
 		// bedeutet kein Alarm", nicht "kein Wert").
 		body := fmt.Sprintf(
 			"# HELP nexarch_archive_storage_integrity_failures_total Anzahl seit Einrichtung gefundener Pruefsummen-Abweichungen (BAK-08).\n"+
 				"# TYPE nexarch_archive_storage_integrity_failures_total counter\n"+
 				"nexarch_archive_storage_integrity_failures_total %d\n", total)
 		if _, err := w.Write([]byte(body)); err != nil {
 			log.Printf("scrub-metrics: antwort schreiben: %v", err)
 		}
 	})
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("scrub-metrics: listening on %s", addr)
 	if err := http.ListenAndServe(addr, mux); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }
@@ -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,119 +0,0 @@
 # BAK-05 – Prüfprotokoll: Reconciliation / Konsistenzprüfung Storage vs. DB
 Voraussetzung BAK-01, BAK-02 (Welle 1) – erledigt, siehe eigene Protokolle.
 ## Grundsatzentscheidung: reine Funktion + zwei Quell-Adapter
 `internal/reconcile.Reconcile` ist eine reine Funktion ohne DB-/Storage-
 Zugriff (leicht ohne echte Infrastruktur testbar), die Ein- und
 Auslesen echter Systeme ist strikt in `sources.go` getrennt
 (`ListDBStorageKeys` gegen echtes Postgres, `ListStorageObjects` gegen
 echtes Dateisystem). Beide Seiten liefern nur SCHLÜSSEL – niemals Inhalt
 – dadurch bleibt BAK-05 sauber getrennt von BAK-08 (Inhalts-/Prüfsummen-
 verifikation, eigene Fehlerklasse, eigenes Ticket).
 Report-Format bewusst deterministisch: alle drei Ergebnislisten
 (`missing_in_storage`, `orphaned_in_storage`, `existing_in_storage`)
 nach `storage_key` aufsteigend sortiert.
 **Nachtrag (nach Rückfrage vor BAK-08-Start):** Der ursprüngliche Report
 enthielt nur die beiden Abweichungslisten – keine Liste der bestätigt
 existierenden Objekte. Für BAK-08 als Stichprobengrundlage reicht
 "keine Abweichung" nicht, es braucht die tatsächliche, deterministisch
 sortierte Liste. Ergänzt: `Report.ExistingInStorage` – DB-Eintrag UND
 Storage-Objekt beide vorhanden, reine Existenzbestätigung (keine
 Inhaltsprüfung, Scope-Trennung zu BAK-08 bleibt gewahrt), aufsteigend
 nach `storage_key` sortiert. BAK-08 zieht seine Stichprobe daraus, ohne
 selbst zu sortieren/filtern. Neuer Test
 `TestReconcile_ExistingInStorageIsStableSamplingBasis` beweist Inhalt
 und Sortierung. Real neu gebaut, getestet (9/9) und auf 131 erneut
 ausgelöst – Journal zeigt das Feld `existing_in_storage` im Report.
 Meldeweg über OPS-05 (wie später BAK-08) wurde als offene Design-Frage
 aufgeworfen, aber nicht zur Vorbedingung gemacht – hier bewusst noch
 nicht umgesetzt (kein OPS-05-Abhängigkeitseintrag im Board für BAK-05);
 Report wird aktuell nur als JSON auf stdout ausgegeben und per
 Exit-Code (1 bei Abweichungen) für systemd/Monitoring sichtbar gemacht.
 Anbindung an OPS-05 kann bei Bedarf nachgezogen werden, ohne
 `Reconcile` selbst zu ändern.
 ## Umsetzung
 - `internal/reconcile.Reconcile(dbEntries, storageKeys) Report` – reine
  Vergleichsfunktion, liefert `MissingInStorage`/`OrphanedInStorage`,
  `Report.IsClean()` als eindeutiges Sauber-Merkmal.
 - `internal/reconcile.ListDBStorageKeys` – liest `file_revisions`
  (DMS FDN-02) per direktem SQL aus derselben physischen Tenant-DB
  (Modell C, Core TEN-01) – kein Import von DMS-Go-Paketen möglich
  (eigenes Go-Modul), daher reiner SQL-Zugriff gegen das dokumentierte
  Schema.
 - `internal/reconcile.ListStorageObjects` – durchläuft den lokalen
  FDN-03-`LocalDriver`-Basisordner (`filepath.WalkDir`), liefert `nil,
  nil` bei fehlendem Verzeichnis statt Fehler (noch keine Objekte ist
  kein Fehlerzustand).
 - `cmd/reconcile-cli` – liest `NEXARCH_RECONCILE_TENANT_DSN` und
  `NEXARCH_RECONCILE_STORAGE_DIR`, gibt Report als JSON auf stdout aus,
  Exit-Code 1 bei Abweichungen.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Datenbankeintrag ohne Storage-Objekt wird erkannt | **bestanden** — `TestReconcile_DetectsMissingInStorage` |
 | 2 | Storage-Objekt ohne Datenbankeintrag wird erkannt | **bestanden** — `TestReconcile_DetectsOrphanedInStorage` |
 | 3 | Lauf ohne Abweichungen liefert leeren, eindeutig sauberen Bericht | **bestanden** — `TestReconcile_CleanRunProducesEmptyReport` (zusätzlich `IsClean()`-Konsistenzprüfung) |
 Zusätzlich (Nutzervorgaben, nicht explizit im Ticket als Pflichtprüfung
 benannt, aber zentral für die Abgrenzung/Weiterverwendbarkeit):
 - `TestReconcile_ExistingButCorruptedObjectProducesNoFinding` – Nachweis,
  dass Reconcile AUSSCHLIESSLICH Existenz prüft, niemals Inhalt (Trennung
  von BAK-08).
 - `TestReconcile_DeterministicOrdering` – zwei Läufe mit identischer
  Eingabe liefern identische Reihenfolge, aufsteigend nach `storage_key`.
 - `TestListDBStorageKeys_ReadsRealFileRevisions` – liest echt gegen die
  gemeinsame Tenant-Testdatenbank `dms_tenant_test` (reales DMS-FDN-02-
  Schema, kein Mock).
 - `TestListStorageObjects_WalksRealDirectory` /
  `_MissingDirectoryReturnsEmpty` – echtes Dateisystem, kein Mock.
 ## Echte Verdrahtung auf 192.168.1.131
 - `reconcile-cli` gebaut nach `/opt/nexarch-archive/bin/`
 - `/etc/nexarch/archive-reconcile.env` (0600): `NEXARCH_RECONCILE_TENANT_DSN`
  zeigt auf die gemeinsame Tenant-Testdatenbank `dms_tenant_test`
  (DMS selbst läuft auf 192.168.1.131 noch nicht als eigener systemd-
  Dienst mit persistenter Konfiguration – dies ist die real verfügbare
  Tenant-DB mit echtem FDN-02-Schema, dokumentierter bekannter Stand,
  kein stiller Mock); `NEXARCH_RECONCILE_STORAGE_DIR` zeigt auf
  `/var/nexarch-archiv/dms-objects` (persistentes ZFS-Dataset, NICHT
  `/var/nexarch-test/`).
 - Timer `nexarch-archive-reconcile.timer` installiert und aktiviert
  (täglich 05:00 UTC), `systemctl list-timers` bestätigt scharf.
 - `systemctl start nexarch-archive-reconcile.service` real ausgelöst:
  `status=0/SUCCESS`, Journal zeigt echten JSON-Report
  (`missing_in_storage: null, orphaned_in_storage: null` – Tenant-DB
  aktuell leer, daher sauberer Bericht, keine synthetische 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  -> 3/3 Pakete mit Tests ok (internal/backup, internal/objectbackup, internal/reconcile), 0 Fehlschläge
 ```
 `internal/reconcile`-Tests separat mit gesetzter `TEST_TENANT_DSN` gegen
 `dms_tenant_test` verifiziert: 9/9 Tests bestanden (6 reine
 `Reconcile`-Tests + 3 `sources.go`-Integrationstests).
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle Pflicht- sowie
 Nutzervorgaben-Prüfungen real erfüllt (echte Postgres-Instanz, echtes
 Dateisystem, echter systemd-Lauf). Zwei Testfehler während der
 Entwicklung (Schema-Abweichung `revision_number` NOT NULL in der realen
 `dms_tenant_test`-Tabelle; inkonsistente Fixture-Daten in
 `TestReconcile_DeterministicOrdering`) gefunden und korrigiert – beide
 waren Testautorenfehler, keine Fehler in `Reconcile` selbst.
@@ -1,140 +0,0 @@
 # BAK-08 – Prüfprotokoll: Checksum-basierte Objekt-Integritätsprüfung
 Voraussetzungen BAK-05, FDN-04, FDN-09, OPS-05 – alle erledigt, siehe
 eigene Protokolle. Vor Start zwei offene Rückfragen geklärt (siehe unten).
 ## Grundsatzentscheidung: eigener Zustand statt file_revisions.created_at
 `created_at` als Alterskriterium hätte immer dieselben "ältesten" Objekte
 gescrubbt und den Rest nie erreicht — kein echtes Rotationsverhalten.
 Stattdessen eigene Archive-Tabelle `scrub_state` (`storage_key` →
 `last_scrubbed_at`, `last_result`), Migration
 `migrations/0001_scrub_state.up.sql`. `internal/scrub.Sample` ist eine
 reine Funktion: nimmt BAK-05s `existing_in_storage` (deterministisch
 sortiert) entgegen, filtert Objekte innerhalb der konfigurierbaren
 Cooldown-Frist heraus, priorisiert danach nach `last_scrubbed_at`
 aufsteigend (nie geprüft = ältestmöglicher Wert), begrenzt auf die
 konfigurierte Stichprobengröße — kein Voll-Sort über den gesamten
 Bestand bei jedem Lauf (Nutzerhinweis zum Kostenfaktor bei 10⁵+
 Objekten: die WHERE-artige Cooldown-Filterung reduziert die Kandidatenmenge
 VOR der Sortierung, nur die Kandidaten selbst werden sortiert, nicht der
 komplette Bestand).
 ## Nachtrag: zwei Rückfragen vor Implementierungsbeginn geklärt
 1. **OPS-05-Anbindung ist Pull, nicht Push.** OPS-05 (`internal/alerting`,
   Core) ist real implementiert, aber Core OPS-03 scrapt `/metrics`-URLs
   registrierter Module (`metrics_sources`-Tabelle in der Core-Registry-
   DB, `SourceStore.RegisterSource`) — kein Push-API. Für BAK-08 daher
   ein eigener, DAUERHAFT laufender Endpunkt (`cmd/scrub-metrics`,
   getrennt vom Oneshot-`scrub-cli`, dessen Prozess nach jedem Lauf endet
   und zum Scrape-Zeitpunkt nicht erreichbar wäre). Metrik als Counter
   (`nexarch_archive_storage_integrity_failures_total`), monoton
   steigend — kein Gauge, kein Rücksetzen bei behobenem Befund. Kein
   Befund = Wert bleibt unverändert (kein Dauer-Alarm durch andauernden
   "Fehler"-Zustand). Scope-Trennung gewahrt: `scrub-cli`/`scrub-metrics`
   erzeugen selbst KEIN Alert-Objekt — Schwellwert/Drosselung bleiben
   OPS-05-eigene Konfiguration (Alert-Regel wird separat über
   `alerting.RuleStore.CreateRule` angelegt, nicht Teil dieses Tickets).
   **CFG-04 war eine Verwechslung** (das ist die
   Benachrichtigungs-Einstellungen-Oberfläche, ein anderes Ticket) — die
   tatsächlich nötige "Config"-Aktion ist ein `INSERT` in
   `metrics_sources` (Core-Registry-DB), kein UI/Ticket-Abhängigkeit.
   Real ausgeführt (siehe „Echte Verdrahtung" unten).
 2. **Sampling-Kriterium.** Siehe Grundsatzentscheidung oben —
   `scrub_state.last_scrubbed_at` statt `file_revisions.created_at`,
   Cooldown-Filterung vor Sortierung, feste Stichprobengröße (Top-N,
   deterministisch, keine Zufallsstichprobe — Nutzerpräferenz für
   Reproduzierbarkeit im Protokoll).
 ## Umsetzung
 - `migrations/0001_scrub_state.up.sql`/`.down.sql` — `scrub_state`,
  `scrub_counters` (Einzelzeile, monotoner Zähler).
 - `internal/scrub.Sample` — reine Funktion, Cooldown-Filter + Alt-
  Priorisierung + Stichprobenbegrenzung.
 - `internal/scrub.LoadLastScrubbed`/`MarkScrubbed`/`RecordFinding`/
  `FindingsTotal` — DB-Zugriff auf `scrub_state`/`scrub_counters`,
  `MarkScrubbed` idempotent (`ON CONFLICT`) für unterbrechbare Läufe.
 - `internal/scrub.ExpectedChecksums` — eigene, minimale Abfrage gegen
  `file_revisions` (keine Erweiterung von `reconcile.DBEntry` — BAK-05
  bleibt existenz-only).
 - `internal/scrub.ActualChecksum` — echtes Lesen der Datei + SHA-256,
  kein Header-/Größenvergleich.
 - `cmd/scrub-cli` — Oneshot: BAK-05-Reconcile → `Sample` → pro Kandidat
  Checksum-Vergleich → `MarkScrubbed` + bei Abweichung `RecordFinding` →
  JSON-Bericht auf stdout, Exit-Code 1 bei Befunden (gemeldet, nicht
  automatisch repariert).
 - `cmd/scrub-metrics` — dauerhafter `/metrics`-Endpunkt, liest
  `scrub_counters.findings_total`.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Absichtlich veränderter Objektinhalt wird als Abweichung erkannt | **bestanden** — real: Testobjekt mit absichtlich falscher `checksum_sha256` in `dms_tenant_test` angelegt, echte Datei ins Storage-Verzeichnis gelegt, `scrub-cli` real über systemd ausgelöst: Befund im JSON-Bericht, Exit-Code 1, `scrub_counters.findings_total` real von 0 auf 1 erhöht (siehe Journal-Auszug unten) |
 | 2 | Sampling priorisiert alte/nie geprüfte Objekte, nicht neue | **bestanden** — `TestSample_PrioritizesNeverScrubbedAndOldest`: nie geprüftes Objekt kommt vor einem vor 30 Tagen geprüften, dieses vor einem vor 1 Tag geprüften |
 | 3 | Wiederholter Lauf ohne neue Objekte meldet nichts erneut (kein Spam) / idempotent bei Unterbrechung | **bestanden** — real: zweiter `scrub-cli`-Lauf direkt nach dem ersten liefert `sampled: 0` (Cooldown greift), `TestMarkScrubbed_IsIdempotent` beweist wiederholtes Markieren ohne Duplikat |
 Zusätzlich: `TestSample_RespectsCooldown`,
 `TestSample_LimitsToSampleSize`, `TestSample_DeterministicForIdenticalInput`,
 `TestRecordFinding_IsMonotonicallyIncreasing`,
 `TestActualChecksum_MatchesRealFileContent` (echter Dateiinhalt, echtes
 SHA-256), `TestExpectedChecksums_ReadsRealFileRevisions` (echtes
 Postgres, kein Mock).
 ## Echte Verdrahtung auf 192.168.1.131
 - `scrub-cli`, `scrub-metrics` gebaut nach `/opt/nexarch-archive/bin/`
 - `/etc/nexarch/archive-scrub.env`, `/etc/nexarch/archive-scrub-metrics.env`
  (0600)
 - Migration real gegen `dms_tenant_test` angewendet
  (`psql -f migrations/0001_scrub_state.up.sql`)
 - `nexarch-archive-scrub.timer` installiert/aktiviert (täglich 06:00
  UTC), `nexarch-archive-scrub-metrics.service` installiert/aktiviert
  (dauerhaft, `Restart=on-failure`) — beide `systemctl status`: aktiv
 - **Reales `INSERT` in `metrics_sources`** (Core-Registry-DB
  `nexarch_registry`): `('archive', 'http://127.0.0.1:8090/metrics')` —
  bestätigt über `SELECT * FROM metrics_sources`
 - **End-to-End über OPS-03 bestätigt**: `curl http://127.0.0.1:8085/metrics`
  (Core-Aggregator) zeigt `nexarch_module_archive_nexarch_archive_storage_integrity_failures_total`
  — reale Umbenennung gemäß OPS-03-Namenskonvention, kein synthetischer
  Wert
 - Realer Befund-Durchlauf: Testobjekt mit absichtlich falscher Prüfsumme
  angelegt → `scrub-cli` real via `systemctl start` ausgelöst → Befund im
  Journal, `scrub_counters.findings_total` real 0→1, sichtbar sowohl auf
  `scrub-metrics` als auch über den Core-Aggregator → Testdaten
  anschließend bereinigt (`file_revisions`/`documents`/`users`-Zeilen
  gelöscht, `scrub_state`/`scrub_counters` zurückgesetzt, Testdatei
  entfernt)
 ## 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 Pakete mit Tests ok (internal/backup, internal/objectbackup, internal/reconcile, internal/scrub), 0 Fehlschläge
 ```
 `internal/scrub`-Tests separat mit gesetzter `TEST_TENANT_DSN` gegen
 `dms_tenant_test` verifiziert: 8/8 Tests bestanden.
 ## Bekannte Grenze (aus Ticket übernommen, nicht Teil der Abnahme)
 Der Job erkennt Abweichungen nur bei Objekten, die gelesen und erneut
 geprüft werden können. Ersetzt keine storage-seitige WORM-/
 Versionierungsstrategie und keine Zugriffs-/Audit-Logs des
 Storage-Providers (`STORAGE-KONZEPT.md` Abschnitt 6.1) — bei extern
 eingebundenem, nicht-kompatiblem Kunden-Storage (Betriebsmodus 3, ohne
 Versioning/Object Lock/Audit-Logs) bleibt eine Lücke, die BAK-08
 technisch nicht schließen kann.
 ## Gesamtergebnis
 **Bestanden.** Alle sechs Akzeptanzkriterien und alle drei Pflicht-
 prüfungen real erfüllt — inklusive echtem Ende-zu-Ende-Nachweis über
 Core OPS-03/OPS-05 (kein Stub, reale `/metrics`-Registrierung und
 -Aggregation). Beide vor Implementierungsbeginn gestellten Rückfragen
 (OPS-05-Anbindungsmechanismus, Sampling-Kriterium) im Protokoll
 dokumentiert und in der Umsetzung berücksichtigt.
@@ -1,14 +0,0 @@
 module gitea.perlbach24.de/scripte/nexarch/archive
 go 1.22
 require github.com/jackc/pgx/v5 v5.6.0
 require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/text v0.14.0 // indirect
 )
@@ -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)
 	}
 }
@@ -1,106 +0,0 @@
 // Package reconcile implementiert BAK-05: periodischer Abgleich, ob jeder
 // in der Datenbank referenzierte Objekt-Storage-Eintrag tatsächlich
 // existiert und umgekehrt. Prüft AUSSCHLIESSLICH Existenz — niemals
 // Inhalt (das ist Archive BAK-08, eine eigene Fehlerklasse, bewusst nicht
 // hier mit hineingezogen, siehe reconcile_test.go
 // TestReconcile_ExistingButCorruptedObjectProducesNoFinding).
 package reconcile
 import (
 	"sort"
 	"time"
 )
 // Finding ist EIN Abweichungsfund — entweder ein Datenbankeintrag ohne
 // Storage-Objekt oder umgekehrt.
 type Finding struct {
 	StorageKey string `json:"storage_key"`
 	DocumentID string `json:"document_id,omitempty"`
 	RevisionID string `json:"revision_id,omitempty"`
 }
 // Report ist das Ergebnis EINES Abgleichslaufs (Akzeptanzkriterium 3:
 // Abweichungen werden BERICHTET, nicht automatisch behoben — Report ist
 // reine Information, keine Reparaturfunktion existiert in diesem Paket).
 //
 // Beide Listen sind nach StorageKey aufsteigend sortiert — bei gleicher
 // Eingabe liefert Reconcile IMMER dieselbe Reihenfolge (deterministisch),
 // damit ein nachgelagerter Verbraucher (Archive BAK-08: zieht seine
 // Stichprobe aus der Liste der EXISTIERENDEN Objekte) sich auf eine
 // stabile Sortierung verlassen kann, statt bei jedem Lauf neu zu
 // filtern/sortieren.
 type Report struct {
 	GeneratedAt time.Time `json:"generated_at"`
 	// MissingInStorage: Datenbankeintrag vorhanden, Objekt im Storage fehlt
 	// (Akzeptanzkriterium 1).
 	MissingInStorage []Finding `json:"missing_in_storage"`
 	// OrphanedInStorage: Objekt im Storage vorhanden, kein Datenbankeintrag
 	// (Akzeptanzkriterium 2).
 	OrphanedInStorage []Finding `json:"orphaned_in_storage"`
 	// ExistingInStorage: Datenbankeintrag UND Storage-Objekt beide
 	// vorhanden — reine Existenzbestätigung, KEINE Inhaltsprüfung. Dient
 	// Archive BAK-08 als stabile, deterministisch sortierte
 	// Stichprobengrundlage (nach StorageKey aufsteigend, siehe Report-
 	// Dokumentation oben) — BAK-08 muss dafür selbst nicht mehr
 	// sortieren/filtern.
 	ExistingInStorage []Finding `json:"existing_in_storage"`
 }
 // IsClean liefert true, wenn der Lauf keine Abweichungen fand (Pflicht-
 // prüfung 3: "Lauf ohne Abweichungen liefert einen leeren, eindeutig als
 // sauber erkennbaren Bericht" — IsClean ist genau dieses eindeutige
 // Erkennungsmerkmal, statt dass ein Aufrufer beide Listen selbst auf
 // Leere prüfen muss).
 func (r Report) IsClean() bool {
 	return len(r.MissingInStorage) == 0 && len(r.OrphanedInStorage) == 0
 }
 // DBEntry ist ein Datenbankeintrag, wie ihn ListDBStorageKeys liefert.
 type DBEntry struct {
 	StorageKey string
 	DocumentID string
 	RevisionID string
 }
 // Reconcile vergleicht dbEntries (aus file_revisions.storage_key, DMS
 // FDN-02) gegen storageKeys (tatsächlich im Objekt-Storage vorhandene
 // Schlüssel, z.B. per Verzeichnis-Walk des FDN-03-LocalDriver-
 // Basisverzeichnisses) und liefert die Abweichungen in beide Richtungen.
 // Reine Funktion — kein Datenbank-/Storage-Zugriff hier, dadurch ohne
 // echte Infrastruktur testbar (siehe reconcile_test.go).
 func Reconcile(dbEntries []DBEntry, storageKeys []string) Report {
 	storageSet := make(map[string]bool, len(storageKeys))
 	for _, k := range storageKeys {
 		storageSet[k] = true
 	}
 	dbSet := make(map[string]DBEntry, len(dbEntries))
 	for _, e := range dbEntries {
 		dbSet[e.StorageKey] = e
 	}
 	var missing, existing []Finding
 	for _, e := range dbEntries {
 		if !storageSet[e.StorageKey] {
 			missing = append(missing, Finding(e))
 		} else {
 			existing = append(existing, Finding(e))
 		}
 	}
 	var orphaned []Finding
 	for _, k := range storageKeys {
 		if _, ok := dbSet[k]; !ok {
 			orphaned = append(orphaned, Finding{StorageKey: k})
 		}
 	}
 	sort.Slice(missing, func(i, j int) bool { return missing[i].StorageKey < missing[j].StorageKey })
 	sort.Slice(orphaned, func(i, j int) bool { return orphaned[i].StorageKey < orphaned[j].StorageKey })
 	sort.Slice(existing, func(i, j int) bool { return existing[i].StorageKey < existing[j].StorageKey })
 	return Report{
 		GeneratedAt:       time.Now().UTC(),
 		MissingInStorage:  missing,
 		OrphanedInStorage: orphaned,
 		ExistingInStorage: existing,
 	}
 }
@@ -1,169 +0,0 @@
 package reconcile
 import "testing"
 // TestReconcile_DetectsMissingInStorage ist Akzeptanzkriterium 1 / Pruefung
 // 1: ein Datenbankeintrag ohne zugehoeriges Objekt im Storage wird erkannt.
 func TestReconcile_DetectsMissingInStorage(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/d1/revisions/r1", DocumentID: "d1", RevisionID: "r1"},
 		{StorageKey: "documents/d2/revisions/r1", DocumentID: "d2", RevisionID: "r1"},
 	}
 	storage := []string{"documents/d1/revisions/r1"} // d2/r1 fehlt absichtlich
 	report := Reconcile(db, storage)
 	if len(report.MissingInStorage) != 1 {
 		t.Fatalf("erwartet 1 fund in missing_in_storage, habe %d: %+v", len(report.MissingInStorage), report.MissingInStorage)
 	}
 	if report.MissingInStorage[0].StorageKey != "documents/d2/revisions/r1" {
 		t.Fatalf("unerwarteter fund: %+v", report.MissingInStorage[0])
 	}
 	if len(report.OrphanedInStorage) != 0 {
 		t.Fatalf("erwartet 0 funde in orphaned_in_storage, habe %d", len(report.OrphanedInStorage))
 	}
 }
 // TestReconcile_DetectsOrphanedInStorage ist Akzeptanzkriterium 2 /
 // Pruefung 2: ein Storage-Objekt ohne Datenbankeintrag wird erkannt.
 func TestReconcile_DetectsOrphanedInStorage(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/d1/revisions/r1", DocumentID: "d1", RevisionID: "r1"},
 	}
 	storage := []string{
 		"documents/d1/revisions/r1",
 		"documents/verwaist/revisions/r1", // kein DB-Eintrag dafuer
 	}
 	report := Reconcile(db, storage)
 	if len(report.OrphanedInStorage) != 1 {
 		t.Fatalf("erwartet 1 fund in orphaned_in_storage, habe %d: %+v", len(report.OrphanedInStorage), report.OrphanedInStorage)
 	}
 	if report.OrphanedInStorage[0].StorageKey != "documents/verwaist/revisions/r1" {
 		t.Fatalf("unerwarteter fund: %+v", report.OrphanedInStorage[0])
 	}
 	if len(report.MissingInStorage) != 0 {
 		t.Fatalf("erwartet 0 funde in missing_in_storage, habe %d", len(report.MissingInStorage))
 	}
 }
 // TestReconcile_CleanRunProducesEmptyReport ist Pruefung 3: Lauf ohne
 // Abweichungen liefert einen leeren, eindeutig als sauber erkennbaren
 // Bericht.
 func TestReconcile_CleanRunProducesEmptyReport(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/d1/revisions/r1", DocumentID: "d1", RevisionID: "r1"},
 		{StorageKey: "documents/d2/revisions/r1", DocumentID: "d2", RevisionID: "r1"},
 	}
 	storage := []string{"documents/d1/revisions/r1", "documents/d2/revisions/r1"}
 	report := Reconcile(db, storage)
 	if !report.IsClean() {
 		t.Fatalf("erwartet sauberen bericht, habe missing=%v orphaned=%v", report.MissingInStorage, report.OrphanedInStorage)
 	}
 	if len(report.MissingInStorage) != 0 || len(report.OrphanedInStorage) != 0 {
 		t.Fatal("IsClean()==true, aber listen sind nicht leer - widerspruch")
 	}
 }
 // TestReconcile_ExistingButCorruptedObjectProducesNoFinding ist der
 // Nachweis, dass BAK-05 AUSSCHLIESSLICH Existenz prueft, niemals Inhalt
 // (die Fehlerklasse "existiert, aber Inhalt beschaedigt" ist Archive
 // BAK-08, bewusst nicht hier) — Reconcile bekommt nur SCHLUESSEL, hat gar
 // keine Moeglichkeit, auf Inhalt zuzugreifen; dieser Test dokumentiert die
 // Absicht explizit, damit sie nicht versehentlich spaeter aufgeweicht wird.
 func TestReconcile_ExistingButCorruptedObjectProducesNoFinding(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/d1/revisions/r1", DocumentID: "d1", RevisionID: "r1"},
 	}
 	// "korruptes" Objekt hier rein simuliert durch denselben Schluessel -
 	// Reconcile kennt und prueft keinen Inhalt, nur den Schluessel selbst.
 	storage := []string{"documents/d1/revisions/r1"}
 	report := Reconcile(db, storage)
 	if !report.IsClean() {
 		t.Fatalf("ein existierendes (wenn auch inhaltlich korruptes) objekt haette KEINEN befund ausloesen duerfen, habe: %+v", report)
 	}
 }
 // TestReconcile_ExistingInStorageIsStableSamplingBasis ist der Nachweis,
 // dass Reconcile eine deterministisch sortierte Liste ALLER bestaetigt
 // existierenden Objekte liefert (DB-Eintrag UND Storage-Objekt vorhanden)
 // - dies ist die Stichprobengrundlage, die Archive BAK-08 weiterverwendet,
 // ohne selbst neu zu sortieren/filtern.
 func TestReconcile_ExistingInStorageIsStableSamplingBasis(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/z/revisions/r1", DocumentID: "z", RevisionID: "r1"},
 		{StorageKey: "documents/a/revisions/r1", DocumentID: "a", RevisionID: "r1"},
 		{StorageKey: "documents/fehlt/revisions/r1", DocumentID: "fehlt", RevisionID: "r1"},
 	}
 	storage := []string{
 		"documents/z/revisions/r1",
 		"documents/a/revisions/r1",
 	}
 	report := Reconcile(db, storage)
 	want := []string{"documents/a/revisions/r1", "documents/z/revisions/r1"}
 	if len(report.ExistingInStorage) != len(want) {
 		t.Fatalf("erwartet %d bestaetigt existierende objekte, habe %d: %+v", len(want), len(report.ExistingInStorage), report.ExistingInStorage)
 	}
 	for i, w := range want {
 		if report.ExistingInStorage[i].StorageKey != w {
 			t.Fatalf("sortierreihenfolge falsch: %v, want beginnend mit %v", report.ExistingInStorage, want)
 		}
 	}
 	if len(report.MissingInStorage) != 1 || report.MissingInStorage[0].StorageKey != "documents/fehlt/revisions/r1" {
 		t.Fatalf("missing_in_storage unerwartet: %+v", report.MissingInStorage)
 	}
 }
 // TestReconcile_DeterministicOrdering ist der Nachweis fuer die
 // Stabilitaets-Anforderung: gleiche Eingabe liefert bei mehreren Laeufen
 // IMMER dieselbe Reihenfolge (Voraussetzung dafuer, dass Archive BAK-08
 // die Liste der existierenden Objekte stabil weiterverarbeiten kann, ohne
 // selbst neu zu sortieren/filtern).
 func TestReconcile_DeterministicOrdering(t *testing.T) {
 	db := []DBEntry{
 		{StorageKey: "documents/z/revisions/r1", DocumentID: "z", RevisionID: "r1"},
 		{StorageKey: "documents/a/revisions/r1", DocumentID: "a", RevisionID: "r1"},
 		{StorageKey: "documents/m/revisions/r1", DocumentID: "m", RevisionID: "r1"},
 	}
 	storage := []string{
 		"documents/a/revisions/r1", // deckt genau den DB-Eintrag "a" ab
 		"documents/y/revisions/r1",
 		"documents/n/revisions/r1",
 	}
 	first := Reconcile(db, storage)
 	second := Reconcile(db, storage)
 	if len(first.MissingInStorage) != len(second.MissingInStorage) {
 		t.Fatal("unterschiedliche anzahl funde zwischen zwei laeufen mit identischer eingabe")
 	}
 	for i := range first.MissingInStorage {
 		if first.MissingInStorage[i].StorageKey != second.MissingInStorage[i].StorageKey {
 			t.Fatalf("reihenfolge in missing_in_storage nicht deterministisch: lauf1[%d]=%q lauf2[%d]=%q",
 				i, first.MissingInStorage[i].StorageKey, i, second.MissingInStorage[i].StorageKey)
 		}
 	}
 	for i := range first.OrphanedInStorage {
 		if first.OrphanedInStorage[i].StorageKey != second.OrphanedInStorage[i].StorageKey {
 			t.Fatalf("reihenfolge in orphaned_in_storage nicht deterministisch: lauf1[%d]=%q lauf2[%d]=%q",
 				i, first.OrphanedInStorage[i].StorageKey, i, second.OrphanedInStorage[i].StorageKey)
 		}
 	}
 	// Aufsteigend sortiert (a < m < z), nicht Einfuegereihenfolge.
 	wantOrder := []string{"documents/m/revisions/r1", "documents/z/revisions/r1"}
 	if len(first.MissingInStorage) != len(wantOrder) {
 		t.Fatalf("erwartet %d funde, habe %d", len(wantOrder), len(first.MissingInStorage))
 	}
 	for i, w := range wantOrder {
 		if first.MissingInStorage[i].StorageKey != w {
 			t.Fatalf("sortierreihenfolge falsch: %v, want beginnend mit %v", first.MissingInStorage, wantOrder)
 		}
 	}
 }
@@ -1,65 +0,0 @@
 package reconcile
 import (
 	"context"
 	"fmt"
 	"os"
 	"path/filepath"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // ListDBStorageKeys liest alle storage_key-Werte aus file_revisions
 // (DMS FDN-02) — Archive liest direkt aus derselben physischen
 // Tenant-Datenbank (Modell C, Core TEN-01), OHNE DMS-Go-Pakete zu
 // importieren (Archive ist ein eigenes Go-Modul) — reiner SQL-Zugriff
 // gegen das dokumentierte Schema, sortiert nach storage_key für
 // deterministische Reconcile-Ergebnisse.
 func ListDBStorageKeys(ctx context.Context, pool *pgxpool.Pool) ([]DBEntry, error) {
 	rows, err := pool.Query(ctx, `
 		SELECT storage_key, document_id, id FROM file_revisions ORDER BY storage_key
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("reconcile: file_revisions abfragen: %w", err)
 	}
 	defer rows.Close()
 	var entries []DBEntry
 	for rows.Next() {
 		var e DBEntry
 		if err := rows.Scan(&e.StorageKey, &e.DocumentID, &e.RevisionID); err != nil {
 			return nil, fmt.Errorf("reconcile: file_revisions-zeile lesen: %w", err)
 		}
 		entries = append(entries, e)
 	}
 	return entries, rows.Err()
 }
 // ListStorageObjects durchläuft den lokalen FDN-03-LocalDriver-
 // Basisordner und liefert alle vorhandenen Objektschlüssel (Pfad relativ
 // zu baseDir, mit "/" als Trenner — dasselbe Format wie
 // storage.ObjectKey aus FDN-03), sortiert.
 func ListStorageObjects(baseDir string) ([]string, error) {
 	var keys []string
 	err := filepath.WalkDir(baseDir, func(path string, d os.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 		if d.IsDir() {
 			return nil
 		}
 		rel, err := filepath.Rel(baseDir, path)
 		if err != nil {
 			return err
 		}
 		keys = append(keys, filepath.ToSlash(rel))
 		return nil
 	})
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
 		}
 		return nil, fmt.Errorf("reconcile: objekt-storage durchlaufen: %w", err)
 	}
 	return keys, nil
 }
@@ -1,132 +0,0 @@
 package reconcile
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func requireTestPool(t *testing.T) *pgxpool.Pool {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	// Minimalschema, das exakt DMS FDN-02s file_revisions-Spalten spiegelt
 	// (Archive kann DMS' internal/-Pakete als eigenes Go-Modul nicht
 	// importieren, daher hier als Testfixture kopiert statt real migriert).
 	if _, err := pool.Exec(ctx, `
 		CREATE EXTENSION IF NOT EXISTS pgcrypto;
 		CREATE TABLE IF NOT EXISTS users (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS documents (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title TEXT NOT NULL,
 			created_by UUID NOT NULL REFERENCES users(id), created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS file_revisions (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
 			storage_key TEXT NOT NULL, checksum_sha256 TEXT NOT NULL, size_bytes BIGINT NOT NULL,
 			mime_type TEXT NOT NULL, revision_number INTEGER NOT NULL, created_by UUID NOT NULL REFERENCES users(id),
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `TRUNCATE file_revisions, documents, users CASCADE`)
 	})
 	return pool
 }
 // TestListDBStorageKeys_ReadsRealFileRevisions ist der Nachweis, dass
 // ListDBStorageKeys tatsaechlich gegen eine echte Postgres-Instanz mit
 // DMS-FDN-02-Schema liest — kein Mock.
 func TestListDBStorageKeys_ReadsRealFileRevisions(t *testing.T) {
 	pool := requireTestPool(t)
 	ctx := context.Background()
 	var userID, docID string
 	if err := pool.QueryRow(ctx, `INSERT INTO users (email, name) VALUES ('reconcile-test@example.test', 'Test') RETURNING id`).Scan(&userID); err != nil {
 		t.Fatalf("testbenutzer anlegen: %v", err)
 	}
 	if err := pool.QueryRow(ctx, `INSERT INTO documents (title, created_by) VALUES ('doc', $1) RETURNING id`, userID).Scan(&docID); err != nil {
 		t.Fatalf("testdokument anlegen: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		INSERT INTO file_revisions (document_id, storage_key, checksum_sha256, size_bytes, mime_type, revision_number, created_by)
 		VALUES ($1, 'documents/x/revisions/1', 'abc', 10, 'text/plain', 1, $2)
 	`, docID, userID); err != nil {
 		t.Fatalf("testrevision anlegen: %v", err)
 	}
 	entries, err := ListDBStorageKeys(ctx, pool)
 	if err != nil {
 		t.Fatalf("listdbstoragekeys: %v", err)
 	}
 	if len(entries) != 1 {
 		t.Fatalf("erwartet 1 eintrag, habe %d", len(entries))
 	}
 	if entries[0].StorageKey != "documents/x/revisions/1" {
 		t.Fatalf("storage_key = %q, want %q", entries[0].StorageKey, "documents/x/revisions/1")
 	}
 	if entries[0].DocumentID != docID {
 		t.Fatalf("document_id = %q, want %q", entries[0].DocumentID, docID)
 	}
 }
 // TestListStorageObjects_WalksRealDirectory ist der Nachweis, dass
 // ListStorageObjects tatsaechlich das Dateisystem durchlaeuft.
 func TestListStorageObjects_WalksRealDirectory(t *testing.T) {
 	baseDir := t.TempDir()
 	mustWriteFile(t, filepath.Join(baseDir, "documents", "d1", "revisions", "r1"), "inhalt")
 	mustWriteFile(t, filepath.Join(baseDir, "documents", "d2", "revisions", "r1"), "inhalt")
 	keys, err := ListStorageObjects(baseDir)
 	if err != nil {
 		t.Fatalf("liststorageobjects: %v", err)
 	}
 	if len(keys) != 2 {
 		t.Fatalf("erwartet 2 objektschluessel, habe %d: %v", len(keys), keys)
 	}
 	want := []string{"documents/d1/revisions/r1", "documents/d2/revisions/r1"}
 	for i, w := range want {
 		if keys[i] != w {
 			t.Fatalf("schluessel[%d] = %q, want %q (voll: %v)", i, keys[i], w, keys)
 		}
 	}
 }
 // TestListStorageObjects_MissingDirectoryReturnsEmpty prueft das
 // Verhalten, wenn das Basisverzeichnis (noch) gar nicht existiert -
 // sollte als "keine Objekte", nicht als Fehler behandelt werden.
 func TestListStorageObjects_MissingDirectoryReturnsEmpty(t *testing.T) {
 	keys, err := ListStorageObjects("/pfad/der/nicht/existiert/fuer/diesen/test")
 	if err != nil {
 		t.Fatalf("erwartet keinen fehler bei fehlendem verzeichnis, habe: %v", err)
 	}
 	if len(keys) != 0 {
 		t.Fatalf("erwartet 0 schluessel, habe %d", len(keys))
 	}
 }
 func mustWriteFile(t *testing.T, path, content string) {
 	t.Helper()
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		t.Fatalf("verzeichnis anlegen: %v", err)
 	}
 	if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
 		t.Fatalf("datei schreiben: %v", err)
 	}
 }
@@ -1,57 +0,0 @@
 package scrub
 import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // ExpectedChecksums liest file_revisions.checksum_sha256 fuer genau die
 // uebergebenen storage_keys — bewusst eine eigene, minimale Abfrage statt
 // Erweiterung von reconcile.DBEntry (BAK-05 bleibt existenz-only, keine
 // Kopplung an Inhaltspruefungs-Bedarf von BAK-08).
 func ExpectedChecksums(ctx context.Context, pool *pgxpool.Pool, storageKeys []string) (map[string]string, error) {
 	if len(storageKeys) == 0 {
 		return map[string]string{}, nil
 	}
 	rows, err := pool.Query(ctx, `
 		SELECT storage_key, checksum_sha256 FROM file_revisions WHERE storage_key = ANY($1)
 	`, storageKeys)
 	if err != nil {
 		return nil, fmt.Errorf("scrub: erwartete pruefsummen lesen: %w", err)
 	}
 	defer rows.Close()
 	out := make(map[string]string, len(storageKeys))
 	for rows.Next() {
 		var key, checksum string
 		if err := rows.Scan(&key, &checksum); err != nil {
 			return nil, fmt.Errorf("scrub: pruefsummen-zeile lesen: %w", err)
 		}
 		out[key] = checksum
 	}
 	return out, rows.Err()
 }
 // ActualChecksum liest die Datei unter baseDir/storageKey vollstaendig
 // und berechnet ihren SHA-256 — echte Inhaltspruefung, kein
 // Header-/Groessenvergleich (dieselbe Disziplin wie BAK-01s Verify).
 func ActualChecksum(baseDir, storageKey string) (string, error) {
 	f, err := os.Open(filepath.Join(baseDir, filepath.FromSlash(storageKey)))
 	if err != nil {
 		return "", fmt.Errorf("scrub: objekt lesen: %w", err)
 	}
 	defer func() { _ = f.Close() }()
 	h := sha256.New()
 	if _, err := io.Copy(h, f); err != nil {
 		return "", fmt.Errorf("scrub: objekt hashen: %w", err)
 	}
 	return hex.EncodeToString(h.Sum(nil)), nil
 }
@@ -1,94 +0,0 @@
 package scrub
 import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"os"
 	"path/filepath"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func requireFileRevisionsFixture(t *testing.T) (pool *pgxpool.Pool, userID, docID string) {
 	t.Helper()
 	p := requireTestPool(t)
 	ctx := context.Background()
 	if _, err := p.Exec(ctx, `
 		CREATE EXTENSION IF NOT EXISTS pgcrypto;
 		CREATE TABLE IF NOT EXISTS users (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS documents (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title TEXT NOT NULL,
 			created_by UUID NOT NULL REFERENCES users(id), created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS file_revisions (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
 			storage_key TEXT NOT NULL, checksum_sha256 TEXT NOT NULL, size_bytes BIGINT NOT NULL,
 			mime_type TEXT NOT NULL, revision_number INTEGER NOT NULL, created_by UUID NOT NULL REFERENCES users(id),
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("file_revisions-fixture: %v", err)
 	}
 	var uid string
 	if err := p.QueryRow(ctx, `INSERT INTO users (email, name) VALUES ('scrub-test@example.test', 'Test') RETURNING id`).Scan(&uid); err != nil {
 		t.Fatalf("testbenutzer anlegen: %v", err)
 	}
 	var did string
 	if err := p.QueryRow(ctx, `INSERT INTO documents (title, created_by) VALUES ('doc', $1) RETURNING id`, uid).Scan(&did); err != nil {
 		t.Fatalf("testdokument anlegen: %v", err)
 	}
 	t.Cleanup(func() { _, _ = p.Exec(context.Background(), `TRUNCATE file_revisions, documents, users CASCADE`) })
 	return p, uid, did
 }
 // TestActualChecksum_MatchesRealFileContent ist Nachweis, dass
 // ActualChecksum tatsaechlich den Dateiinhalt liest und hasht (kein
 // Header-/Groessenvergleich).
 func TestActualChecksum_MatchesRealFileContent(t *testing.T) {
 	baseDir := t.TempDir()
 	content := []byte("echter dateiinhalt fuer scrub-test")
 	path := filepath.Join(baseDir, "documents", "x", "revisions", "1")
 	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
 		t.Fatal(err)
 	}
 	if err := os.WriteFile(path, content, 0o600); err != nil {
 		t.Fatal(err)
 	}
 	got, err := ActualChecksum(baseDir, "documents/x/revisions/1")
 	if err != nil {
 		t.Fatalf("actualChecksum: %v", err)
 	}
 	sum := sha256.Sum256(content)
 	want := hex.EncodeToString(sum[:])
 	if got != want {
 		t.Fatalf("checksum = %q, want %q", got, want)
 	}
 }
 // TestExpectedChecksums_ReadsRealFileRevisions ist Nachweis gegen echtes
 // Postgres, kein Mock.
 func TestExpectedChecksums_ReadsRealFileRevisions(t *testing.T) {
 	pool, uid, did := requireFileRevisionsFixture(t)
 	ctx := context.Background()
 	if _, err := pool.Exec(ctx, `
 		INSERT INTO file_revisions (document_id, storage_key, checksum_sha256, size_bytes, mime_type, revision_number, created_by)
 		VALUES ($1, 'documents/x/revisions/1', 'abc123', 10, 'text/plain', 1, $2)
 	`, did, uid); err != nil {
 		t.Fatalf("testrevision anlegen: %v", err)
 	}
 	got, err := ExpectedChecksums(ctx, pool, []string{"documents/x/revisions/1", "documents/fehlt/revisions/1"})
 	if err != nil {
 		t.Fatalf("expectedChecksums: %v", err)
 	}
 	if len(got) != 1 || got["documents/x/revisions/1"] != "abc123" {
 		t.Fatalf("unerwartetes ergebnis: %+v", got)
 	}
 }
@@ -1,69 +0,0 @@
 // Package scrub implementiert BAK-08: periodische, checksummenbasierte
 // Integritaetspruefung einer Stichprobe existierender Objekte. Baut auf
 // BAK-05 (internal/reconcile) auf, das die deterministisch sortierte
 // Liste bestaetigt existierender Objekte liefert (existenz-only) — scrub
 // fuegt die INHALTSPRUEFUNG hinzu, die BAK-05 bewusst ausspart.
 package scrub
 import (
 	"sort"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/reconcile"
 )
 // Candidate ist ein fuer den aktuellen Lauf ausgewaehltes Objekt.
 type Candidate struct {
 	StorageKey string
 	DocumentID string
 	RevisionID string
 }
 // Sample waehlt aus existing (BAK-05s existing_in_storage, bereits nach
 // StorageKey sortiert) die naechste Stichprobe: Objekte, die noch nie
 // oder vor mehr als cooldown geprueft wurden (last_scrubbed via
 // storage_key -> last_scrubbed_at aus scrub_state), begrenzt auf
 // sampleSize. Reine Funktion, deterministisch bei gleicher Eingabe (fixe
 // Reihenfolge von existing, kein Zufall) — Akzeptanzkriterium
 // "Sampling priorisiert alte, unveraenderte Objekte": ein nie/am
 // laengsten nicht geprueftes Objekt hat KEINEN last_scrubbed-Eintrag oder
 // den aeltesten, beides erscheint zuerst in "existing", das seinerseits
 // nach StorageKey sortiert ist — daher wird zusaetzlich vor der
 // Groessenbegrenzung nach last_scrubbed_at aufsteigend sortiert (nie
 // geprueft = aeltestmoeglicher Wert), damit tatsaechlich das am laengsten
 // nicht verifizierte Objekt zuerst drankommt, nicht nur alphabetisch nach
 // Schluessel.
 func Sample(existing []reconcile.Finding, lastScrubbed map[string]time.Time, cooldown time.Duration, sampleSize int, now time.Time) []Candidate {
 	type scored struct {
 		f    reconcile.Finding
 		last time.Time
 	}
 	var due []scored
 	for _, f := range existing {
 		last, ok := lastScrubbed[f.StorageKey]
 		if ok && now.Sub(last) < cooldown {
 			continue // erst kuerzlich geprueft, ueberspringen
 		}
 		if !ok {
 			last = time.Time{} // nie geprueft = aeltestmoeglicher Wert, kommt zuerst
 		}
 		due = append(due, scored{f: f, last: last})
 	}
 	sort.SliceStable(due, func(i, j int) bool {
 		if !due[i].last.Equal(due[j].last) {
 			return due[i].last.Before(due[j].last)
 		}
 		return due[i].f.StorageKey < due[j].f.StorageKey // Tie-Break deterministisch
 	})
 	if sampleSize >= 0 && len(due) > sampleSize {
 		due = due[:sampleSize]
 	}
 	out := make([]Candidate, 0, len(due))
 	for _, d := range due {
 		out = append(out, Candidate{StorageKey: d.f.StorageKey, DocumentID: d.f.DocumentID, RevisionID: d.f.RevisionID})
 	}
 	return out
 }
@@ -1,95 +0,0 @@
 package scrub
 import (
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/archive/internal/reconcile"
 )
 var now = time.Date(2026, 8, 29, 12, 0, 0, 0, time.UTC)
 // TestSample_PrioritizesNeverScrubbedAndOldest ist der Nachweis fuer das
 // GoBD-Akzeptanzkriterium: nie geprueft ODER am laengsten nicht geprueft
 // kommt zuerst, nicht bloss alphabetisch nach StorageKey.
 func TestSample_PrioritizesNeverScrubbedAndOldest(t *testing.T) {
 	existing := []reconcile.Finding{
 		{StorageKey: "documents/a/revisions/r1"}, // vor 1 tag geprueft
 		{StorageKey: "documents/b/revisions/r1"}, // nie geprueft
 		{StorageKey: "documents/c/revisions/r1"}, // vor 30 tagen geprueft (aeltest)
 	}
 	lastScrubbed := map[string]time.Time{
 		"documents/a/revisions/r1": now.Add(-24 * time.Hour),
 		"documents/c/revisions/r1": now.Add(-30 * 24 * time.Hour),
 	}
 	got := Sample(existing, lastScrubbed, time.Hour, 2, now)
 	if len(got) != 2 {
 		t.Fatalf("erwartet 2 kandidaten, habe %d: %+v", len(got), got)
 	}
 	// "nie geprueft" (b) zaehlt als aeltestmoeglich, kommt vor "vor 30 tagen" (c).
 	if got[0].StorageKey != "documents/b/revisions/r1" || got[1].StorageKey != "documents/c/revisions/r1" {
 		t.Fatalf("falsche prioritaet, want [b, c], habe %+v", got)
 	}
 }
 // TestSample_RespectsCooldown ist der Nachweis, dass kuerzlich gepruefte
 // Objekte NICHT erneut ausgewaehlt werden — sonst wuerde dieselbe Gruppe
 // dauernd gescrubbt (genau der Fehler, den die Alt-Priorisierung
 // verhindern soll).
 func TestSample_RespectsCooldown(t *testing.T) {
 	existing := []reconcile.Finding{
 		{StorageKey: "documents/a/revisions/r1"},
 		{StorageKey: "documents/b/revisions/r1"},
 	}
 	lastScrubbed := map[string]time.Time{
 		"documents/a/revisions/r1": now.Add(-1 * time.Hour), // innerhalb cooldown
 	}
 	got := Sample(existing, lastScrubbed, 24*time.Hour, 10, now)
 	if len(got) != 1 || got[0].StorageKey != "documents/b/revisions/r1" {
 		t.Fatalf("erwartet nur b (a innerhalb cooldown), habe %+v", got)
 	}
 }
 // TestSample_LimitsToSampleSize ist der Nachweis, dass die
 // Stichprobengroesse tatsaechlich begrenzt (kein Voll-Scrub jeden Lauf).
 func TestSample_LimitsToSampleSize(t *testing.T) {
 	existing := []reconcile.Finding{
 		{StorageKey: "documents/a/revisions/r1"},
 		{StorageKey: "documents/b/revisions/r1"},
 		{StorageKey: "documents/c/revisions/r1"},
 	}
 	got := Sample(existing, map[string]time.Time{}, time.Hour, 1, now)
 	if len(got) != 1 {
 		t.Fatalf("erwartet genau 1 kandidat, habe %d", len(got))
 	}
 }
 // TestSample_DeterministicForIdenticalInput ist der Nachweis, dass zwei
 // Laeufe mit identischer Eingabe dieselbe Reihenfolge liefern (kein
 // Zufall im Sampling).
 func TestSample_DeterministicForIdenticalInput(t *testing.T) {
 	existing := []reconcile.Finding{
 		{StorageKey: "documents/a/revisions/r1"},
 		{StorageKey: "documents/b/revisions/r1"},
 		{StorageKey: "documents/c/revisions/r1"},
 	}
 	lastScrubbed := map[string]time.Time{}
 	first := Sample(existing, lastScrubbed, time.Hour, 2, now)
 	second := Sample(existing, lastScrubbed, time.Hour, 2, now)
 	if len(first) != len(second) {
 		t.Fatal("unterschiedliche anzahl zwischen zwei laeufen mit identischer eingabe")
 	}
 	for i := range first {
 		if first[i].StorageKey != second[i].StorageKey {
 			t.Fatalf("reihenfolge nicht deterministisch: lauf1=%+v lauf2=%+v", first, second)
 		}
 	}
 }
@@ -1,74 +0,0 @@
 package scrub
 import (
 	"context"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // LoadLastScrubbed liefert je storage_key den Zeitpunkt der letzten
 // Pruefung — Grundlage fuer Sample's Cooldown-Filter.
 func LoadLastScrubbed(ctx context.Context, pool *pgxpool.Pool) (map[string]time.Time, error) {
 	rows, err := pool.Query(ctx, `SELECT storage_key, last_scrubbed_at FROM scrub_state`)
 	if err != nil {
 		return nil, fmt.Errorf("scrub: scrub_state lesen: %w", err)
 	}
 	defer rows.Close()
 	out := make(map[string]time.Time)
 	for rows.Next() {
 		var key string
 		var ts time.Time
 		if err := rows.Scan(&key, &ts); err != nil {
 			return nil, fmt.Errorf("scrub: scrub_state-zeile lesen: %w", err)
 		}
 		out[key] = ts
 	}
 	return out, rows.Err()
 }
 // MarkScrubbed vermerkt Ergebnis und Zeitpunkt der Pruefung eines
 // Objekts — idempotent (ON CONFLICT), damit ein unterbrochener und neu
 // gestarteter Lauf keinen inkonsistenten Zustand hinterlaesst
 // (Akzeptanzkriterium: Lauf ist unterbrechbar ohne inkonsistenten
 // Zustand).
 func MarkScrubbed(ctx context.Context, pool *pgxpool.Pool, storageKey string, ok bool, at time.Time) error {
 	result := "ok"
 	if !ok {
 		result = "failed"
 	}
 	_, err := pool.Exec(ctx, `
 		INSERT INTO scrub_state (storage_key, last_scrubbed_at, last_result)
 		VALUES ($1, $2, $3)
 		ON CONFLICT (storage_key) DO UPDATE SET last_scrubbed_at = $2, last_result = $3
 	`, storageKey, at, result)
 	if err != nil {
 		return fmt.Errorf("scrub: scrub_state schreiben: %w", err)
 	}
 	return nil
 }
 // RecordFinding erhoeht den monoton steigenden Befund-Zaehler
 // (scrub_counters.findings_total) um genau 1 — als gueltiger Prometheus-
 // Counter darf dieser Wert nur steigen, niemals sinken, auch wenn ein
 // Befund spaeter behoben wird.
 func RecordFinding(ctx context.Context, pool *pgxpool.Pool) error {
 	_, err := pool.Exec(ctx, `UPDATE scrub_counters SET findings_total = findings_total + 1 WHERE id = 1`)
 	if err != nil {
 		return fmt.Errorf("scrub: befund-zaehler erhoehen: %w", err)
 	}
 	return nil
 }
 // FindingsTotal liest den aktuellen Zaehlerstand — genutzt vom
 // /metrics-Endpunkt (cmd/scrub-metrics).
 func FindingsTotal(ctx context.Context, pool *pgxpool.Pool) (int64, error) {
 	var total int64
 	err := pool.QueryRow(ctx, `SELECT findings_total FROM scrub_counters WHERE id = 1`).Scan(&total)
 	if err != nil {
 		return 0, fmt.Errorf("scrub: befund-zaehler lesen: %w", err)
 	}
 	return total, nil
 }
@@ -1,92 +0,0 @@
 package scrub
 import (
 	"context"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func requireTestPool(t *testing.T) *pgxpool.Pool {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS scrub_state (
 			storage_key TEXT PRIMARY KEY, last_scrubbed_at TIMESTAMPTZ NOT NULL,
 			last_result TEXT NOT NULL CHECK (last_result IN ('ok', 'failed'))
 		);
 		CREATE TABLE IF NOT EXISTS scrub_counters (
 			id INTEGER PRIMARY KEY DEFAULT 1 CHECK (id = 1), findings_total BIGINT NOT NULL DEFAULT 0
 		);
 		INSERT INTO scrub_counters (id, findings_total) VALUES (1, 0) ON CONFLICT (id) DO NOTHING;
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `TRUNCATE scrub_state; UPDATE scrub_counters SET findings_total = 0 WHERE id = 1`)
 	})
 	return pool
 }
 // TestMarkScrubbed_IsIdempotent ist Nachweis fuer "Lauf ist idempotent und
 // unterbrechbar ohne inkonsistenten Zustand": derselbe storage_key kann
 // beliebig oft neu markiert werden, es entsteht kein Duplikat/Fehler.
 func TestMarkScrubbed_IsIdempotent(t *testing.T) {
 	pool := requireTestPool(t)
 	ctx := context.Background()
 	key := "documents/x/revisions/1"
 	if err := MarkScrubbed(ctx, pool, key, true, time.Now().UTC()); err != nil {
 		t.Fatalf("erster markScrubbed: %v", err)
 	}
 	second := time.Now().UTC().Add(time.Hour)
 	if err := MarkScrubbed(ctx, pool, key, false, second); err != nil {
 		t.Fatalf("zweiter markScrubbed (ueberschreibt): %v", err)
 	}
 	last, err := LoadLastScrubbed(ctx, pool)
 	if err != nil {
 		t.Fatalf("loadLastScrubbed: %v", err)
 	}
 	if len(last) != 1 {
 		t.Fatalf("erwartet genau 1 eintrag (kein duplikat), habe %d", len(last))
 	}
 	// Postgres timestamptz rundet auf Mikrosekunden, Go time.Time hat
 	// Nanosekunden-Praezision - Vergleich daher auf Mikrosekunden gerundet.
 	if !last[key].Truncate(time.Microsecond).Equal(second.Truncate(time.Microsecond)) {
 		t.Fatalf("last_scrubbed_at nicht ueberschrieben: %v, want %v", last[key], second)
 	}
 }
 // TestRecordFinding_IsMonotonicallyIncreasing ist Nachweis, dass der
 // Zaehler ein gueltiger Prometheus-Counter ist (steigt nur, sinkt nie).
 func TestRecordFinding_IsMonotonicallyIncreasing(t *testing.T) {
 	pool := requireTestPool(t)
 	ctx := context.Background()
 	for i := 0; i < 3; i++ {
 		if err := RecordFinding(ctx, pool); err != nil {
 			t.Fatalf("recordFinding: %v", err)
 		}
 	}
 	total, err := FindingsTotal(ctx, pool)
 	if err != nil {
 		t.Fatalf("findingsTotal: %v", err)
 	}
 	if total != 3 {
 		t.Fatalf("erwartet 3, habe %d", total)
 	}
 }
@@ -1,2 +0,0 @@
 DROP TABLE IF EXISTS scrub_counters;
 DROP TABLE IF EXISTS scrub_state;
@@ -1,21 +0,0 @@
 -- BAK-08: Zustand des Integritaets-Scrub-Jobs. Getrennt von file_revisions
 -- (DMS-Eigentum, nur lesend zugegriffen) und getrennt von BAK-05s
 -- reconcile-Paket (existenz-only, keine Inhaltspruefung) — eigener,
 -- Archive-eigener Zustand ueber ZULETZT geprueften Zeitpunkt je Objekt,
 -- damit Sampling rotiert statt dieselben "aeltesten" Objekte auf ewig
 -- erneut zu ziehen.
 CREATE TABLE IF NOT EXISTS scrub_state (
    storage_key      TEXT PRIMARY KEY,
    last_scrubbed_at TIMESTAMPTZ NOT NULL,
    last_result      TEXT NOT NULL CHECK (last_result IN ('ok', 'failed'))
 );
 -- Einzelne Zeile, monoton steigender Zaehler fuer den OPS-05/OPS-03-
 -- Metrik-Export (Counter, nie ruecksetzbar — ein behobener Befund darf den
 -- Zaehler nicht wieder senken, sonst waere es kein gueltiger Prometheus-
 -- Counter mehr).
 CREATE TABLE IF NOT EXISTS scrub_counters (
    id             INTEGER PRIMARY KEY DEFAULT 1 CHECK (id = 1),
    findings_total BIGINT NOT NULL DEFAULT 0
 );
 INSERT INTO scrub_counters (id, findings_total) VALUES (1, 0) ON CONFLICT (id) DO NOTHING;
@@ -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 {
@@ -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
@@ -1,10 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Konsistenzpruefung Storage vs. DB (BAK-05)
 After=network.target postgresql.service
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-reconcile.env
 ExecStart=__INSTALL_DIR__/bin/reconcile-cli
 StandardOutput=journal
@@ -1,9 +0,0 @@
 [Unit]
 Description=Taeglicher Zeitplan fuer NEXARCH Archive Konsistenzpruefung (BAK-05)
 [Timer]
 OnCalendar=*-*-* 05:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -1,14 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - /metrics-Export fuer BAK-08 (dauerhaft, Pull-Modell fuer OPS-03)
 After=network.target postgresql.service
 [Service]
 Type=simple
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-scrub-metrics.env
 ExecStart=__INSTALL_DIR__/bin/scrub-metrics
 Restart=on-failure
 StandardOutput=journal
 [Install]
 WantedBy=multi-user.target
@@ -1,10 +0,0 @@
 [Unit]
 Description=NEXARCH Archive - Checksummen-Integritaetspruefung Stichprobe (BAK-08)
 After=network.target postgresql.service
 [Service]
 Type=oneshot
 User=nexarch
 EnvironmentFile=/etc/nexarch/archive-scrub.env
 ExecStart=__INSTALL_DIR__/bin/scrub-cli
 StandardOutput=journal
@@ -1,9 +0,0 @@
 [Unit]
 Description=Zeitplan fuer NEXARCH Archive Checksummen-Stichprobe (BAK-08)
 [Timer]
 OnCalendar=*-*-* 06:00:00
 Persistent=true
 [Install]
 WantedBy=timers.target
@@ -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
 )
@@ -1,6 +1,8 @@
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
 github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
@@ -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")
 	}
 }
@@ -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,27 @@
 // Package ldapsync implementiert Core IAM-05: LDAP/Active-Directory-
 // Anbindung je Tenant fuer Benutzer-Synchronisation, Login-Delegation und
 // Rollenzuordnung aus Gruppen ueber eine explizite Erlaubnis-Matrix.
 //
 // WICHTIGER HINWEIS: In dieser Umgebung steht kein echter LDAP/AD-Server zur
 // Verfuegung (analog zur Archive-Engine bei AUD-05). Client ist deshalb eine
 // Schnittstelle — die Sync-/Rollenzuordnungs-Logik ist gegen einen Fake in
 // den Tests vollstaendig geprueft, eine echte Verbindungspruefung gegen
 // LDAP/AD steht noch aus.
 package ldapsync
 // Entry ist ein aus LDAP gelesener Benutzerdatensatz.
 type Entry struct {
 	Email    string
 	Name     string
 	Groups   []string
 	Disabled bool
 }
 // Client abstrahiert die eigentliche LDAP-Verbindung (Bind + Search).
 type Client interface {
 	// Search liefert alle Benutzer, die dem konfigurierten Filter
 	// entsprechen. Ein Fehler bedeutet "Quelle nicht erreichbar oder
 	// fehlerhaft" — Run() bricht dann komplett und folgenlos ab
 	// (Akzeptanzkriterium 2).
 	Search() ([]Entry, error)
 }
@@ -0,0 +1,204 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 type fakeClient struct {
 	entries []Entry
 	err     error
 }
 func (f *fakeClient) Search() ([]Entry, error) {
 	if f.err != nil {
 		return nil, f.err
 	}
 	return f.entries, nil
 }
 func setupTest(t *testing.T) (*user.TenantUserStore, *rbac.Store, *RoleMappingStore, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS users (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS role_assignments (
 			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS role_assignment_history (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
 			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return user.NewTenantUserStore(pool), rbac.NewStore(pool), NewRoleMappingStore(pool), cleanup
 }
 func uniqueEmail() string {
 	return fmt.Sprintf("ldap-test-%d@example.com", time.Now().UnixNano())
 }
 // Akzeptanzkriterium 3 + Pruefung 1: Rollen-Erlaubnis-Matrix mit Positiv- und
 // Negativfaellen — keine Privilege-Escalation ueber Gruppenmitgliedschaft.
 func TestRoleMapping_PositiveAndNegativeCases(t *testing.T) {
 	_, _, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if err := mappings.SetMapping(ctx, "cn=IT-Admins,ou=groups,dc=example,dc=com", rbac.RoleTenantAdmin); err != nil {
 		t.Fatalf("set mapping: %v", err)
 	}
 	// Positivfall: gemappte Gruppe liefert die konfigurierte Rolle.
 	role, ok, err := mappings.HighestRoleFor(ctx, []string{"cn=IT-Admins,ou=groups,dc=example,dc=com"})
 	if err != nil {
 		t.Fatalf("highest role: %v", err)
 	}
 	if !ok || role != rbac.RoleTenantAdmin {
 		t.Fatalf("erwartet tenant_admin, habe ok=%v role=%q", ok, role)
 	}
 	// Negativfall 1: unbekannte Gruppe vergibt keine Rolle.
 	_, ok, err = mappings.HighestRoleFor(ctx, []string{"cn=Praktikanten,ou=groups,dc=example,dc=com"})
 	if err != nil {
 		t.Fatalf("highest role (unbekannt): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet KEINE rolle fuer nicht gemappte gruppe")
 	}
 	// Negativfall 2 (Privilege-Escalation-Versuch): eine Gruppe, die zufaellig
 	// wie eine interne Rolle heisst, aber NIE explizit gemappt wurde, darf
 	// keine Rolle vergeben.
 	_, ok, err = mappings.HighestRoleFor(ctx, []string{"tenant_admin", "superadmin"})
 	if err != nil {
 		t.Fatalf("highest role (namens-trick): %v", err)
 	}
 	if ok {
 		t.Fatal("erwartet KEINE privilege-escalation ueber gruppennamen, die wie rollen aussehen")
 	}
 }
 // Akzeptanzkriterium 1: Synchronisationslauf legt Benutzer an.
 func TestSyncer_CreatesUsers(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	email := uniqueEmail()
 	client := &fakeClient{entries: []Entry{{Email: email, Name: "LDAP Nutzer"}}}
 	syncer := NewSyncer(client, users, roles, mappings)
 	result, err := syncer.Run(ctx)
 	if err != nil {
 		t.Fatalf("run: %v", err)
 	}
 	if result.Created != 1 {
 		t.Fatalf("erwartet 1 angelegten benutzer, habe %d", result.Created)
 	}
 	if _, err := users.GetByEmailForAuth(ctx, email); err != nil {
 		t.Fatalf("benutzer sollte existieren: %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: fehlerhafte/nicht erreichbare LDAP-
 // Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen.
 func TestSyncer_AbortsCleanlyOnSourceError(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	// Ein bereits bestehendes Konto, das UNBERUEHRT bleiben muss.
 	existingEmail := uniqueEmail()
 	existing, err := users.Create(ctx, existingEmail, "Bestehender Nutzer")
 	if err != nil {
 		t.Fatalf("create existing: %v", err)
 	}
 	client := &fakeClient{err: errors.New("ldap-server nicht erreichbar (simuliert)")}
 	syncer := NewSyncer(client, users, roles, mappings)
 	if _, err := syncer.Run(ctx); err == nil {
 		t.Fatal("erwartet fehler bei nicht erreichbarer ldap-quelle")
 	}
 	// Bestehendes Konto unveraendert (noch aktiv, keine geloeschten/neuen Zeilen).
 	got, err := users.Get(ctx, existing.ID)
 	if err != nil {
 		t.Fatalf("bestehendes konto sollte weiterhin existieren: %v", err)
 	}
 	if got.Status != user.StatusActive {
 		t.Fatalf("bestehendes konto sollte unveraendert aktiv sein, ist %q", got.Status)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Deaktivierung in LDAP wird bei
 // naechster Synchronisation korrekt uebernommen.
 func TestSyncer_AppliesDeactivationOnNextRun(t *testing.T) {
 	users, roles, mappings, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	email := uniqueEmail()
 	client := &fakeClient{entries: []Entry{{Email: email, Name: "Wird Deaktiviert"}}}
 	syncer := NewSyncer(client, users, roles, mappings)
 	if _, err := syncer.Run(ctx); err != nil {
 		t.Fatalf("erster lauf: %v", err)
 	}
 	u, err := users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		t.Fatalf("benutzer nach erstem lauf: %v", err)
 	}
 	if u.User.Status != user.StatusActive {
 		t.Fatalf("erwartet aktiv nach erstem lauf, habe %q", u.User.Status)
 	}
 	// Zweiter Lauf: derselbe Benutzer ist jetzt in LDAP deaktiviert.
 	client.entries[0].Disabled = true
 	result, err := syncer.Run(ctx)
 	if err != nil {
 		t.Fatalf("zweiter lauf: %v", err)
 	}
 	if result.Deactivated != 1 {
 		t.Fatalf("erwartet 1 deaktivierung, habe %d", result.Deactivated)
 	}
 	u, err = users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		t.Fatalf("benutzer nach zweitem lauf: %v", err)
 	}
 	if u.User.Status != user.StatusInactive {
 		t.Fatalf("erwartet inaktiv nach deaktivierung in ldap, habe %q", u.User.Status)
 	}
 }
@@ -0,0 +1,79 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
 // RoleMappingStore verwaltet die Erlaubnis-Matrix LDAP-Gruppe -> Rolle
 // (Akzeptanzkriterium 3). Nur explizit gemappte Gruppen vergeben eine Rolle
 // — der Schutz gegen Privilege-Escalation ist strukturell: es gibt keinen
 // Code-Pfad, der eine unbekannte Gruppe irgendeiner Rolle zuordnet.
 type RoleMappingStore struct {
 	pool *pgxpool.Pool
 }
 func NewRoleMappingStore(pool *pgxpool.Pool) *RoleMappingStore {
 	return &RoleMappingStore{pool: pool}
 }
 // SetMapping ordnet eine LDAP-Gruppe genau einer NEXARCH-Rolle zu. Nur
 // 'user'/'tenant_admin' sind zuweisbar (dieselbe Matrix wie RBAC-01/03) —
 // 'superadmin' bleibt mandantenuebergreifend und nie ueber LDAP erreichbar.
 func (s *RoleMappingStore) SetMapping(ctx context.Context, ldapGroup string, role rbac.Role) error {
 	if role != rbac.RoleUser && role != rbac.RoleTenantAdmin {
 		return fmt.Errorf("ldapsync: rolle %q ist ueber ldap nicht zuweisbar", role)
 	}
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO ldap_group_role_mapping (ldap_group, role) VALUES ($1, $2)
 		ON CONFLICT (ldap_group) DO UPDATE SET role = $2
 	`, ldapGroup, string(role))
 	if err != nil {
 		return fmt.Errorf("gruppenzuordnung speichern: %w", err)
 	}
 	return nil
 }
 // roleFor liefert die einer LDAP-Gruppe zugeordnete Rolle, sofern konfiguriert.
 func (s *RoleMappingStore) roleFor(ctx context.Context, ldapGroup string) (rbac.Role, bool, error) {
 	var role string
 	err := s.pool.QueryRow(ctx, `SELECT role FROM ldap_group_role_mapping WHERE ldap_group = $1`, ldapGroup).Scan(&role)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return "", false, nil
 		}
 		return "", false, fmt.Errorf("gruppenzuordnung lesen: %w", err)
 	}
 	return rbac.Role(role), true, nil
 }
 // HighestRoleFor bestimmt aus einer Liste von LDAP-Gruppen die hoechste
 // zugeordnete Rolle (tenant_admin > user). Gruppen ohne Eintrag in der
 // Matrix tragen NICHTS bei — auch nicht, wenn ihr Name zufaellig wie eine
 // interne Rolle aussieht (Akzeptanzkriterium 3 / Pruefung 1: keine
 // Privilege-Escalation ueber Gruppenmitgliedschaft).
 func (s *RoleMappingStore) HighestRoleFor(ctx context.Context, ldapGroups []string) (rbac.Role, bool, error) {
 	var best rbac.Role
 	found := false
 	for _, g := range ldapGroups {
 		role, ok, err := s.roleFor(ctx, g)
 		if err != nil {
 			return "", false, err
 		}
 		if !ok {
 			continue
 		}
 		if !found || role == rbac.RoleTenantAdmin {
 			best = role
 			found = true
 		}
 	}
 	return best, found, nil
 }
@@ -0,0 +1,93 @@
 package ldapsync
 import (
 	"context"
 	"errors"
 	"fmt"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 // SyncResult fasst das Ergebnis eines Synchronisationslaufs zusammen.
 type SyncResult struct {
 	Created     int
 	Updated     int
 	Deactivated int
 	Failed      []string // Email-Adressen, bei denen die Verarbeitung fehlschlug
 }
 // Syncer fuehrt die Benutzer-/Rollen-Synchronisation aus LDAP aus.
 type Syncer struct {
 	client   Client
 	users    *user.TenantUserStore
 	roles    *rbac.Store
 	mappings *RoleMappingStore
 }
 func NewSyncer(client Client, users *user.TenantUserStore, roles *rbac.Store, mappings *RoleMappingStore) *Syncer {
 	return &Syncer{client: client, users: users, roles: roles, mappings: mappings}
 }
 // Run synchronisiert Benutzer aus LDAP (Akzeptanzkriterium 1). Ist die
 // LDAP-Quelle nicht erreichbar/fehlerhaft, wird SOFORT und OHNE jede
 // Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2 /
 // Pruefung 2) — Search() wird als allererstes aufgerufen, bevor irgendein
 // Schreibzugriff stattfindet.
 func (s *Syncer) Run(ctx context.Context) (SyncResult, error) {
 	entries, err := s.client.Search()
 	if err != nil {
 		return SyncResult{}, fmt.Errorf("ldap-quelle nicht erreichbar, synchronisation abgebrochen: %w", err)
 	}
 	var result SyncResult
 	for _, entry := range entries {
 		if err := s.syncOne(ctx, entry, &result); err != nil {
 			// Ein fehlerhafter Einzeleintrag isoliert sich selbst — er
 			// beschaedigt weder bereits verarbeitete noch nachfolgende
 			// Konten (Akzeptanzkriterium 2).
 			result.Failed = append(result.Failed, entry.Email)
 		}
 	}
 	return result, nil
 }
 func (s *Syncer) syncOne(ctx context.Context, entry Entry, result *SyncResult) error {
 	existing, err := s.users.GetByEmailForAuth(ctx, entry.Email)
 	isNew := errors.Is(err, user.ErrNotFound)
 	if err != nil && !isNew {
 		return err
 	}
 	var userID string
 	if isNew {
 		created, err := s.users.Create(ctx, entry.Email, entry.Name)
 		if err != nil {
 			return err
 		}
 		userID = created.ID
 		result.Created++
 	} else {
 		userID = existing.User.ID
 		result.Updated++
 	}
 	// Deaktivierung in LDAP wird uebernommen (Akzeptanzkriterium 3 / Pruefung 3).
 	if entry.Disabled {
 		if _, err := s.users.Deactivate(ctx, userID); err != nil {
 			return err
 		}
 		result.Deactivated++
 	}
 	role, ok, err := s.mappings.HighestRoleFor(ctx, entry.Groups)
 	if err != nil {
 		return err
 	}
 	if ok {
 		if _, err := s.roles.Assign(ctx, userID, role, "ldap-sync"); err != nil {
 			return err
 		}
 	}
 	return nil
 }
@@ -0,0 +1,78 @@
 // Package oidc implementiert Core IAM-06: SSO-Anmeldung ueber OpenID
 // Connect gegen externe Identity-Provider.
 //
 // WICHTIGER HINWEIS: In dieser Umgebung ist kein registrierter externer
 // OIDC-Provider (Client-ID/Secret bei Google/Okta/Azure AD o.ae.) verfuegbar,
 // gegen den ein echter Authorization-Code-Redirect-Flow end-to-end
 // durchgefuehrt werden koennte (analog AUD-05/Archive, IAM-05/LDAP). ANDERS
 // als bei LDAP/Archive ist die eigentliche Token-VALIDIERUNG (JWKS-
 // Signaturpruefung, Ablauf, Claims, Nonce/State) aber ein rein
 // kryptographischer Vorgang ohne Netzwerkabhaengigkeit zur Testzeit — die
 // Tests unten erzeugen ein eigenes RSA-Schluesselpaar, signieren ein
 // ID-Token selbst und pruefen es exakt so, wie es ein echter Provider
 // liefern wuerde. Nur der Redirect zu einem echten externen Provider bleibt
 // ungeprueft.
 package oidc
 import (
 	"crypto/rsa"
 	"encoding/base64"
 	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
 )
 type jwk struct {
 	Kid string `json:"kid"`
 	Kty string `json:"kty"`
 	N   string `json:"n"`
 	E   string `json:"e"`
 }
 type jwkSet struct {
 	Keys []jwk `json:"keys"`
 }
 var ErrUnsupportedKeyType = errors.New("oidc: nicht unterstuetzter jwk-schluesseltyp")
 // ParseJWKS dekodiert eine JWKS-Antwort (RFC 7517) in kid -> RSA-Public-Key.
 // Nur RSA-Schluessel (kty=RSA, Standard bei allen gaengigen OIDC-Providern
 // fuer ID-Tokens) werden unterstuetzt.
 func ParseJWKS(data []byte) (map[string]*rsa.PublicKey, error) {
 	var set jwkSet
 	if err := json.Unmarshal(data, &set); err != nil {
 		return nil, fmt.Errorf("jwks parsen: %w", err)
 	}
 	out := make(map[string]*rsa.PublicKey, len(set.Keys))
 	for _, k := range set.Keys {
 		if k.Kty != "RSA" {
 			continue
 		}
 		pub, err := decodeRSAKey(k)
 		if err != nil {
 			return nil, fmt.Errorf("schluessel %q dekodieren: %w", k.Kid, err)
 		}
 		out[k.Kid] = pub
 	}
 	return out, nil
 }
 func decodeRSAKey(k jwk) (*rsa.PublicKey, error) {
 	nBytes, err := base64.RawURLEncoding.DecodeString(k.N)
 	if err != nil {
 		return nil, fmt.Errorf("modulus dekodieren: %w", err)
 	}
 	eBytes, err := base64.RawURLEncoding.DecodeString(k.E)
 	if err != nil {
 		return nil, fmt.Errorf("exponent dekodieren: %w", err)
 	}
 	eBuf := make([]byte, 8)
 	copy(eBuf[8-len(eBytes):], eBytes)
 	e := int(binary.BigEndian.Uint64(eBuf))
 	return &rsa.PublicKey{N: new(big.Int).SetBytes(nBytes), E: e}, nil
 }
@@ -0,0 +1,69 @@
 package oidc
 import (
 	"context"
 	"errors"
 	"fmt"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/ldapsync"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 // CompleteOIDCLogin verifiziert das ID-Token (Signatur, Ablauf, Aussteller,
 // Nonce — Akzeptanzkriterium 3), loest den State einmalig ein
 // (Akzeptanzkriterium/Pruefung 3), legt bei Bedarf einen lokalen Benutzer an
 // und mapped Rollen aus den OIDC-Claims ueber DIESELBE Erlaubnis-Matrix wie
 // IAM-05/LDAP (ldapsync.RoleMappingStore — kein zweiter, paralleler
 // Mapping-Mechanismus, Akzeptanzkriterium 2). Bei Erfolg wird ein normales
 // IAM-02-Sitzungs-Token ausgestellt.
 func CompleteOIDCLogin(
 	ctx context.Context,
 	verifier *Verifier,
 	states *StateStore,
 	users *user.TenantUserStore,
 	roles *rbac.Store,
 	roleMapping *ldapsync.RoleMappingStore,
 	issuer *auth.TokenIssuer,
 	tenantSlug, state, idToken string,
 ) (token string, err error) {
 	nonce, err := states.Consume(ctx, state)
 	if err != nil {
 		return "", err
 	}
 	claims, err := verifier.VerifyWithNonce(idToken, nonce)
 	if err != nil {
 		return "", err
 	}
 	if claims.Email == "" {
 		return "", fmt.Errorf("%w: id-token ohne e-mail-claim", ErrInvalidToken)
 	}
 	u, err := findOrCreateUser(ctx, users, claims.Email)
 	if err != nil {
 		return "", err
 	}
 	if role, ok, err := roleMapping.HighestRoleFor(ctx, claims.Roles); err != nil {
 		return "", err
 	} else if ok {
 		if _, err := roles.Assign(ctx, u.ID, role, "oidc-sso"); err != nil {
 			return "", err
 		}
 	}
 	return issuer.Issue(u.ID, tenantSlug)
 }
 func findOrCreateUser(ctx context.Context, users *user.TenantUserStore, email string) (user.User, error) {
 	creds, err := users.GetByEmailForAuth(ctx, email)
 	if err == nil {
 		return creds.User, nil
 	}
 	if !errors.Is(err, user.ErrNotFound) {
 		return user.User{}, err
 	}
 	return users.Create(ctx, email, email)
 }
@@ -0,0 +1,172 @@
 package oidc
 import (
 	"context"
 	"crypto/rsa"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/golang-jwt/jwt/v5"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 	"gitea.perlbach24.de/scripte/nexarch/internal/ldapsync"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )
 func setupLoginTest(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 users (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), email TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'active', password_hash TEXT NOT NULL DEFAULT '',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS role_assignments (
 			user_id UUID PRIMARY KEY REFERENCES users(id), role TEXT NOT NULL CHECK (role IN ('user','tenant_admin')),
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS role_assignment_history (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), user_id UUID NOT NULL, role TEXT NOT NULL,
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS ldap_group_role_mapping (
 			ldap_group TEXT PRIMARY KEY, role TEXT NOT NULL CHECK (role IN ('user','tenant_admin'))
 		);
 		CREATE TABLE IF NOT EXISTS oidc_states (
 			state TEXT PRIMARY KEY, nonce TEXT NOT NULL, expires_at TIMESTAMPTZ NOT NULL,
 			used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return pool, cleanup
 }
 // Akzeptanzkriterium 1 + 3: End-to-End-Login gegen ein (selbst signiertes,
 // aber protokollkorrektes) ID-Token — Signatur, Nonce, State, Rollen-Mapping,
 // Sitzungs-Token-Ausstellung.
 func TestCompleteOIDCLogin_EndToEnd(t *testing.T) {
 	pool, cleanup := setupLoginTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	states := NewStateStore(pool)
 	users := user.NewTenantUserStore(pool)
 	roles := rbac.NewStore(pool)
 	roleMapping := ldapsync.NewRoleMappingStore(pool)
 	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
 	if err := roleMapping.SetMapping(ctx, "sso-admins", rbac.RoleTenantAdmin); err != nil {
 		t.Fatalf("set mapping: %v", err)
 	}
 	state, nonce, err := states.Generate(ctx)
 	if err != nil {
 		t.Fatalf("generate state: %v", err)
 	}
 	email := fmt.Sprintf("oidc-test-%d@example.com", time.Now().UnixNano())
 	claims := Claims{
 		Subject: "idp-subject-123",
 		Email:   email,
 		Nonce:   nonce,
 		Roles:   []string{"sso-admins"},
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	idToken := signTestToken(t, key, "kid-1", claims)
 	token, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken)
 	if err != nil {
 		t.Fatalf("complete oidc login: %v", err)
 	}
 	if token == "" {
 		t.Fatal("erwartet nicht-leeres sitzungs-token")
 	}
 	assignment, err := roles.Get(ctx, mustGetUserID(t, ctx, users, email))
 	if err != nil {
 		t.Fatalf("rollenzuweisung lesen: %v", err)
 	}
 	if assignment.Role != rbac.RoleTenantAdmin {
 		t.Fatalf("erwartet tenant_admin aus sso-admins-mapping, habe %q", assignment.Role)
 	}
 	// Replay desselben state schlaegt fehl.
 	if _, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken); err == nil {
 		t.Fatal("erwartet fehler bei wiederverwendetem state (replay)")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: keine Privilege-Escalation ueber
 // manipulierte/unbekannte Rollen-Claims.
 func TestCompleteOIDCLogin_UnmappedRoleGrantsNothing(t *testing.T) {
 	pool, cleanup := setupLoginTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	states := NewStateStore(pool)
 	users := user.NewTenantUserStore(pool)
 	roles := rbac.NewStore(pool)
 	roleMapping := ldapsync.NewRoleMappingStore(pool)
 	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
 	state, nonce, err := states.Generate(ctx)
 	if err != nil {
 		t.Fatalf("generate state: %v", err)
 	}
 	email := fmt.Sprintf("oidc-test-%d@example.com", time.Now().UnixNano())
 	claims := Claims{
 		Email: email,
 		Nonce: nonce,
 		// Versuch, sich ueber einen manipulierten Rollen-Claim
 		// hochzustufen — diese Gruppen wurden NIE gemappt.
 		Roles: []string{"tenant_admin", "superadmin"},
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	idToken := signTestToken(t, key, "kid-1", claims)
 	if _, err := CompleteOIDCLogin(ctx, verifier, states, users, roles, roleMapping, issuer, "acme", state, idToken); err != nil {
 		t.Fatalf("complete oidc login: %v", err)
 	}
 	userID := mustGetUserID(t, ctx, users, email)
 	if _, err := roles.Get(ctx, userID); err == nil {
 		t.Fatal("erwartet KEINE rollenzuweisung fuer nicht gemappte claims (privilege-escalation-versuch)")
 	}
 }
 func mustGetUserID(t *testing.T, ctx context.Context, users *user.TenantUserStore, email string) string {
 	t.Helper()
 	creds, err := users.GetByEmailForAuth(ctx, email)
 	if err != nil {
 		t.Fatalf("get user by email: %v", err)
 	}
 	return creds.User.ID
 }
@@ -0,0 +1,76 @@
 package oidc
 import (
 	"context"
 	"crypto/rand"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var ErrStateInvalid = errors.New("oidc: state ungueltig, bereits verwendet oder abgelaufen")
 // DefaultStateTTL begrenzt, wie lange ein ausgestellter State/Nonce fuer den
 // Redirect-Umweg zum Identity-Provider gueltig bleibt.
 const DefaultStateTTL = 10 * time.Minute
 type StateStore struct {
 	pool *pgxpool.Pool
 }
 func NewStateStore(pool *pgxpool.Pool) *StateStore {
 	return &StateStore{pool: pool}
 }
 // Generate stellt state+nonce fuer einen neuen Login-Redirect aus. state
 // wird als OAuth2-"state"-Parameter mitgeschickt (CSRF-Schutz), nonce
 // erscheint spaeter im ID-Token und muss exakt uebereinstimmen (Replay-Schutz).
 func (s *StateStore) Generate(ctx context.Context) (state, nonce string, err error) {
 	state, err = randomValue()
 	if err != nil {
 		return "", "", err
 	}
 	nonce, err = randomValue()
 	if err != nil {
 		return "", "", err
 	}
 	_, err = s.pool.Exec(ctx, `
 		INSERT INTO oidc_states (state, nonce, expires_at) VALUES ($1, $2, $3)
 	`, state, nonce, time.Now().Add(DefaultStateTTL))
 	if err != nil {
 		return "", "", fmt.Errorf("state speichern: %w", err)
 	}
 	return state, nonce, nil
 }
 // Consume loest einen State EINMALIG ein (Akzeptanzkriterium/Pruefung 3:
 // Replay-Schutz) — atomar ueber WHERE used_at IS NULL, analog IAM-03/IAM-09.
 // Ein zweiter Callback mit demselben state (z.B. durch einen Angreifer, der
 // die Redirect-URL abgefangen hat) schlaegt fehl.
 func (s *StateStore) Consume(ctx context.Context, state string) (nonce string, err error) {
 	err = s.pool.QueryRow(ctx, `
 		UPDATE oidc_states SET used_at = now()
 		WHERE state = $1 AND used_at IS NULL AND expires_at > now()
 		RETURNING nonce
 	`, state).Scan(&nonce)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return "", ErrStateInvalid
 		}
 		return "", fmt.Errorf("state einloesen: %w", err)
 	}
 	return nonce, nil
 }
 func randomValue() (string, error) {
 	buf := make([]byte, 32)
 	if _, err := rand.Read(buf); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf), nil
 }
@@ -0,0 +1,68 @@
 package oidc
 import (
 	"context"
 	"errors"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupStateTest(t *testing.T) (*StateStore, 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 oidc_states (
 			state TEXT PRIMARY KEY, nonce TEXT NOT NULL, expires_at TIMESTAMPTZ NOT NULL,
 			used_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStateStore(pool), cleanup
 }
 // Akzeptanzkriterium/Pruefung 3: State/Nonce-Handling gegen CSRF und Replay.
 func TestStateStore_ConsumeIsSingleUse(t *testing.T) {
 	store, cleanup := setupStateTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	state, nonce, err := store.Generate(ctx)
 	if err != nil {
 		t.Fatalf("generate: %v", err)
 	}
 	gotNonce, err := store.Consume(ctx, state)
 	if err != nil {
 		t.Fatalf("consume (erste einloesung): %v", err)
 	}
 	if gotNonce != nonce {
 		t.Fatalf("nonce = %q, want %q", gotNonce, nonce)
 	}
 	if _, err := store.Consume(ctx, state); !errors.Is(err, ErrStateInvalid) {
 		t.Fatalf("erwartet ErrStateInvalid bei erneutem einloesen (replay), habe %v", err)
 	}
 }
 func TestStateStore_RejectsUnknownState(t *testing.T) {
 	store, cleanup := setupStateTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := store.Consume(ctx, "niemals-ausgestellter-state"); !errors.Is(err, ErrStateInvalid) {
 		t.Fatalf("erwartet ErrStateInvalid, habe %v", err)
 	}
 }
@@ -0,0 +1,70 @@
 package oidc
 import (
 	"crypto/rsa"
 	"errors"
 	"fmt"
 	"github.com/golang-jwt/jwt/v5"
 )
 var ErrInvalidToken = errors.New("oidc: id-token ungueltig, abgelaufen oder falscher aussteller")
 // Claims sind die fuer NEXARCH relevanten OIDC-ID-Token-Claims.
 type Claims struct {
 	Subject string   `json:"sub"`
 	Email   string   `json:"email"`
 	Nonce   string   `json:"nonce"`
 	Roles   []string `json:"roles"` // providerabhaengiger Claim-Name, hier vereinfacht fest "roles"
 	jwt.RegisteredClaims
 }
 // Verifier prueft ID-Tokens gegen den JWKS-Schluesselsatz eines konfigurierten
 // Providers (Akzeptanzkriterium 3: fehlerhafte/abgelaufene Tokens werden
 // abgewiesen).
 type Verifier struct {
 	keys   map[string]*rsa.PublicKey
 	issuer string
 }
 func NewVerifier(keys map[string]*rsa.PublicKey, issuer string) *Verifier {
 	return &Verifier{keys: keys, issuer: issuer}
 }
 // Verify prueft Signatur (gegen JWKS), Ablauf (jwt-Bibliothek lehnt
 // abgelaufene Tokens automatisch ab) und Aussteller.
 func (v *Verifier) Verify(idToken string) (*Claims, error) {
 	claims := &Claims{}
 	token, err := jwt.ParseWithClaims(idToken, claims, func(t *jwt.Token) (interface{}, error) {
 		if _, ok := t.Method.(*jwt.SigningMethodRSA); !ok {
 			return nil, ErrInvalidToken
 		}
 		kid, _ := t.Header["kid"].(string)
 		key, ok := v.keys[kid]
 		if !ok {
 			return nil, ErrInvalidToken
 		}
 		return key, nil
 	})
 	if err != nil || !token.Valid {
 		return nil, ErrInvalidToken
 	}
 	if claims.Issuer != v.issuer {
 		return nil, fmt.Errorf("%w: unerwarteter aussteller %q", ErrInvalidToken, claims.Issuer)
 	}
 	return claims, nil
 }
 // VerifyWithNonce prueft zusaetzlich, dass der nonce-Claim im Token exakt
 // dem bei der Anfrage ausgestellten Nonce entspricht — verhindert Replay
 // eines fremden, gueltigen ID-Tokens (Akzeptanzkriterium/Pruefung 3).
 func (v *Verifier) VerifyWithNonce(idToken, expectedNonce string) (*Claims, error) {
 	claims, err := v.Verify(idToken)
 	if err != nil {
 		return nil, err
 	}
 	if claims.Nonce == "" || claims.Nonce != expectedNonce {
 		return nil, fmt.Errorf("%w: nonce stimmt nicht ueberein", ErrInvalidToken)
 	}
 	return claims, nil
 }
@@ -0,0 +1,184 @@
 package oidc
 import (
 	"crypto/rand"
 	"crypto/rsa"
 	"encoding/base64"
 	"encoding/binary"
 	"encoding/json"
 	"testing"
 	"time"
 	"github.com/golang-jwt/jwt/v5"
 )
 func generateTestKey(t *testing.T) *rsa.PrivateKey {
 	t.Helper()
 	key, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
 		t.Fatalf("generate rsa key: %v", err)
 	}
 	return key
 }
 func signTestToken(t *testing.T, key *rsa.PrivateKey, kid string, claims Claims) string {
 	t.Helper()
 	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
 	token.Header["kid"] = kid
 	s, err := token.SignedString(key)
 	if err != nil {
 		t.Fatalf("sign token: %v", err)
 	}
 	return s
 }
 func TestVerify_AcceptsValidToken(t *testing.T) {
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	claims := Claims{
 		Subject: "user-123",
 		Email:   "person@example.com",
 		Nonce:   "erwarteter-nonce",
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	tok := signTestToken(t, key, "kid-1", claims)
 	got, err := verifier.Verify(tok)
 	if err != nil {
 		t.Fatalf("verify: %v", err)
 	}
 	if got.Email != "person@example.com" {
 		t.Fatalf("email = %q", got.Email)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 2: Token-Signatur- und Ablaufpruefung.
 func TestVerify_RejectsExpiredToken(t *testing.T) {
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	claims := Claims{
 		Subject: "user-123",
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(-time.Hour)), // abgelaufen
 		},
 	}
 	tok := signTestToken(t, key, "kid-1", claims)
 	if _, err := verifier.Verify(tok); err == nil {
 		t.Fatal("erwartet fehler bei abgelaufenem token")
 	}
 }
 func TestVerify_RejectsWrongSigningKey(t *testing.T) {
 	realKey := generateTestKey(t)
 	attackerKey := generateTestKey(t)
 	// Verifier kennt NUR den echten oeffentlichen Schluessel.
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &realKey.PublicKey}, "https://idp.example.com")
 	claims := Claims{
 		Subject: "user-123",
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	// Mit dem Angreifer-Schluessel signiert, aber unter demselben kid wie der echte.
 	tok := signTestToken(t, attackerKey, "kid-1", claims)
 	if _, err := verifier.Verify(tok); err == nil {
 		t.Fatal("erwartet fehler bei fremd signiertem token")
 	}
 }
 func TestVerify_RejectsWrongIssuer(t *testing.T) {
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	claims := Claims{
 		Subject: "user-123",
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://ganz-anderer-idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	tok := signTestToken(t, key, "kid-1", claims)
 	if _, err := verifier.Verify(tok); err == nil {
 		t.Fatal("erwartet fehler bei unerwartetem aussteller")
 	}
 }
 // Akzeptanzkriterium/Pruefung 3: Nonce-Handling gegen Replay.
 func TestVerifyWithNonce_RejectsMismatch(t *testing.T) {
 	key := generateTestKey(t)
 	verifier := NewVerifier(map[string]*rsa.PublicKey{"kid-1": &key.PublicKey}, "https://idp.example.com")
 	claims := Claims{
 		Subject: "user-123",
 		Nonce:   "nonce-a",
 		RegisteredClaims: jwt.RegisteredClaims{
 			Issuer:    "https://idp.example.com",
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 		},
 	}
 	tok := signTestToken(t, key, "kid-1", claims)
 	if _, err := verifier.VerifyWithNonce(tok, "nonce-b"); err == nil {
 		t.Fatal("erwartet fehler bei nonce-mismatch (moeglicher replay eines fremden tokens)")
 	}
 	if _, err := verifier.VerifyWithNonce(tok, "nonce-a"); err != nil {
 		t.Fatalf("erwartet erfolg bei passendem nonce: %v", err)
 	}
 }
 func TestParseJWKS_RoundTrip(t *testing.T) {
 	key := generateTestKey(t)
 	nBytes := key.PublicKey.N.Bytes()
 	eBuf := make([]byte, 8)
 	binary.BigEndian.PutUint64(eBuf, uint64(key.PublicKey.E))
 	// Fuehrende Nullbytes des Exponenten abschneiden (ueblich bei JWK-Kodierung).
 	eStart := 0
 	for eStart < len(eBuf)-1 && eBuf[eStart] == 0 {
 		eStart++
 	}
 	set := jwkSet{Keys: []jwk{{
 		Kid: "kid-1",
 		Kty: "RSA",
 		N:   base64.RawURLEncoding.EncodeToString(nBytes),
 		E:   base64.RawURLEncoding.EncodeToString(eBuf[eStart:]),
 	}}}
 	data, err := json.Marshal(set)
 	if err != nil {
 		t.Fatalf("marshal: %v", err)
 	}
 	parsed, err := ParseJWKS(data)
 	if err != nil {
 		t.Fatalf("parse jwks: %v", err)
 	}
 	got, ok := parsed["kid-1"]
 	if !ok {
 		t.Fatal("erwartet kid-1 im ergebnis")
 	}
 	if got.E != key.PublicKey.E || got.N.Cmp(key.PublicKey.N) != 0 {
 		t.Fatalf("erwartet identischen oeffentlichen schluessel nach roundtrip")
 	}
 	// Der wiederhergestellte Schluessel muss ein damit signiertes Token auch tatsaechlich verifizieren.
 	verifier := NewVerifier(parsed, "https://idp.example.com")
 	claims := Claims{Subject: "x", RegisteredClaims: jwt.RegisteredClaims{
 		Issuer: "https://idp.example.com", ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
 	}}
 	tok := signTestToken(t, key, "kid-1", claims)
 	if _, err := verifier.Verify(tok); err != nil {
 		t.Fatalf("verify mit aus jwks wiederhergestelltem schluessel: %v", err)
 	}
 }
@@ -0,0 +1,71 @@
 // Package rbac implementiert Core RBAC-01: das Rollenmodell mit
 // Grundrollen/-rechten, Hierarchie und Zuweisung. Die eigentliche
 // Durchsetzung (erlaubt/verboten je Request) ist RBAC-02, dieses Paket
 // liefert nur Modell + Zuweisung (Casbin-Prinzip: Policy-Modell getrennt
 // von der Entscheidungsfunktion).
 package rbac
 // Role ist eine der drei Grundrollen. Superadmin lebt mandantenuebergreifend
 // (siehe internal/user.SuperadminStore aus IAM-01) und wird deshalb NICHT
 // ueber Store (tenant-gescoped) zugewiesen — die Existenz eines Superadmin-
 // Kontos IST die Rollenzuweisung.
 type Role string
 const (
 	RoleSuperadmin  Role = "superadmin"
 	RoleTenantAdmin Role = "tenant_admin"
 	RoleUser        Role = "user"
 )
 type Permission string
 const (
 	PermSelfRead       Permission = "self.read"
 	PermSelfUpdate     Permission = "self.update"
 	PermManageUsers    Permission = "tenant.manage_users"
 	PermManageSettings Permission = "tenant.manage_settings"
 	PermManageTenants  Permission = "platform.manage_tenants"
 )
 // parent bildet die Rollenhierarchie ab (Akzeptanzkriterium 2): eine Rolle
 // erbt alle Rechte ihrer Elternrolle. tenant_admin erbt von user,
 // superadmin erbt von tenant_admin.
 var parent = map[Role]Role{
 	RoleTenantAdmin: RoleUser,
 	RoleSuperadmin:  RoleTenantAdmin,
 }
 // direct sind die einer Rolle direkt (ohne Vererbung) zugeordneten Rechte.
 var direct = map[Role][]Permission{
 	RoleUser:        {PermSelfRead, PermSelfUpdate},
 	RoleTenantAdmin: {PermManageUsers, PermManageSettings},
 	RoleSuperadmin:  {PermManageTenants},
 }
 // EffectivePermissions liefert die vollstaendige, ueber die Hierarchie
 // aufgeloeste Rechtemenge einer Rolle (Akzeptanzkriterium 2 / Pruefung 2).
 func EffectivePermissions(role Role) []Permission {
 	seen := make(map[Permission]bool)
 	var out []Permission
 	for r, ok := role, true; ok; r, ok = parent[r] {
 		for _, p := range direct[r] {
 			if !seen[p] {
 				seen[p] = true
 				out = append(out, p)
 			}
 		}
 	}
 	return out
 }
 // HasPermission prueft, ob eine Rolle (inklusive geerbter Rechte) ein
 // bestimmtes Recht besitzt.
 func HasPermission(role Role, perm Permission) bool {
 	for _, p := range EffectivePermissions(role) {
 		if p == perm {
 			return true
 		}
 	}
 	return false
 }
@@ -0,0 +1,124 @@
 package rbac
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	// ErrRoleNotAssignableInTenantScope wird geliefert, wenn versucht wird,
 	// eine mandantenuebergreifende Rolle (superadmin) ueber den tenant-
 	// gescopten Store zu vergeben — die erlaubte Matrix laesst hier nur
 	// user/tenant_admin zu (Akzeptanzkriterium 1 / Pruefung 1).
 	ErrRoleNotAssignableInTenantScope = errors.New("rbac: rolle ist in diesem geltungsbereich nicht zuweisbar")
 	ErrNotFound                       = errors.New("rbac: keine rollenzuweisung gefunden")
 )
 // assignableRoles ist die erlaubte Matrix fuer Store (tenant-gescoped).
 var assignableRoles = map[Role]bool{
 	RoleUser:        true,
 	RoleTenantAdmin: true,
 }
 type Assignment struct {
 	UserID    string
 	Role      Role
 	GrantedBy string
 }
 // Store verwaltet Rollenzuweisungen innerhalb GENAU EINER Tenant-Datenbank —
 // analog zu internal/user.TenantUserStore (Modell C: der Pool bestimmt den
 // Tenant, keine tenant_id-Spalte noetig).
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // Assign vergibt eine Rolle an einen Benutzer. grantedBy identifiziert den
 // Akteur, der die Zuweisung vorgenommen hat (Akzeptanzkriterium 3). Jede
 // Zuweisung wird zusaetzlich in role_assignment_history festgehalten, auch
 // wenn sie eine vorherige Rolle ersetzt.
 func (s *Store) Assign(ctx context.Context, userID string, role Role, grantedBy string) (Assignment, error) {
 	if !assignableRoles[role] {
 		return Assignment{}, ErrRoleNotAssignableInTenantScope
 	}
 	if grantedBy == "" {
 		return Assignment{}, errors.New("rbac: grantedBy darf nicht leer sein")
 	}
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return Assignment{}, fmt.Errorf("transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO role_assignments (user_id, role, granted_by, granted_at)
 		VALUES ($1, $2, $3, now())
 		ON CONFLICT (user_id) DO UPDATE SET role = $2, granted_by = $3, granted_at = now()
 	`, userID, string(role), grantedBy); err != nil {
 		return Assignment{}, fmt.Errorf("rolle zuweisen: %w", err)
 	}
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO role_assignment_history (user_id, role, granted_by, granted_at)
 		VALUES ($1, $2, $3, now())
 	`, userID, string(role), grantedBy); err != nil {
 		return Assignment{}, fmt.Errorf("historie schreiben: %w", err)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return Assignment{}, fmt.Errorf("transaktion committen: %w", err)
 	}
 	return Assignment{UserID: userID, Role: role, GrantedBy: grantedBy}, nil
 }
 func (s *Store) Get(ctx context.Context, userID string) (Assignment, error) {
 	var a Assignment
 	var role string
 	a.UserID = userID
 	if err := s.pool.QueryRow(ctx, `
 		SELECT role, granted_by FROM role_assignments WHERE user_id = $1
 	`, userID).Scan(&role, &a.GrantedBy); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return Assignment{}, ErrNotFound
 		}
 		return Assignment{}, fmt.Errorf("rollenzuweisung lesen: %w", err)
 	}
 	a.Role = Role(role)
 	return a, nil
 }
 // History liefert jede Rollenzuweisung eines Benutzers in chronologischer
 // Reihenfolge — die Grundlage fuer "wer hat wann welche Rolle vergeben"
 // (Akzeptanzkriterium 3).
 func (s *Store) History(ctx context.Context, userID string) ([]Assignment, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT role, granted_by FROM role_assignment_history
 		WHERE user_id = $1 ORDER BY granted_at
 	`, userID)
 	if err != nil {
 		return nil, fmt.Errorf("historie abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []Assignment
 	for rows.Next() {
 		var role string
 		a := Assignment{UserID: userID}
 		if err := rows.Scan(&role, &a.GrantedBy); err != nil {
 			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
 		}
 		a.Role = Role(role)
 		out = append(out, a)
 	}
 	return out, rows.Err()
 }
@@ -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 @@
 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,2 @@
 DROP TABLE IF EXISTS role_assignment_history;
 DROP TABLE IF EXISTS role_assignments;
@@ -0,0 +1,23 @@
 -- Rollenzuweisung pro Benutzer (RBAC-01, siehe core-kanban/tickets/RBAC-01.md).
 -- Nur 'user' und 'tenant_admin' sind hier zuweisbar — 'superadmin' lebt
 -- mandantenuebergreifend in der Registry (IAM-01 SuperadminStore) und hat
 -- daher bewusst KEINE Zeile in dieser tenant-lokalen Tabelle (Akzeptanz-
 -- kriterium 1: nur Zuweisungen innerhalb der erlaubten Matrix).
 CREATE TABLE role_assignments (
    user_id     UUID PRIMARY KEY REFERENCES users(id),
    role        TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin')),
    granted_by  TEXT NOT NULL,
    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Vollstaendige Historie jeder Rollenaenderung (Akzeptanzkriterium 3: wer
 -- hat wann welche Rolle vergeben).
 CREATE TABLE role_assignment_history (
    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id     UUID NOT NULL,
    role        TEXT NOT NULL,
    granted_by  TEXT NOT NULL,
    granted_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE INDEX role_assignment_history_user_idx ON role_assignment_history (user_id, granted_at);
@@ -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,2 @@
 DROP TABLE IF EXISTS ldap_group_role_mapping;
 DROP TABLE IF EXISTS ldap_config;
@@ -0,0 +1,22 @@
 -- LDAP/Active-Directory-Anbindung (IAM-05, siehe core-kanban/tickets/IAM-05.md).
 -- Bind-Credentials liegen NIE in dieser Tabelle im Klartext — bind_password_env
 -- nennt nur den Namen einer Umgebungsvariable, aus der das Passwort zur
 -- Laufzeit gelesen wird (Projekt-Konvention: Secrets nur ueber Env-Vars).
 CREATE TABLE ldap_config (
    id                 BOOLEAN PRIMARY KEY DEFAULT true CHECK (id),
    url                TEXT NOT NULL,
    bind_dn            TEXT NOT NULL,
    bind_password_env  TEXT NOT NULL,
    base_dn            TEXT NOT NULL,
    user_filter        TEXT NOT NULL DEFAULT '(objectClass=person)',
    updated_at         TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Erlaubnis-Matrix LDAP-Gruppe -> NEXARCH-Rolle (Akzeptanzkriterium 3).
 -- Eine LDAP-Gruppe OHNE Eintrag hier vergibt KEINE Rolle — kein impliziter
 -- Zugriff durch Gruppennamen-Zufall (Privilege-Escalation-Schutz, siehe
 -- "Bekannte Fehler vermeiden" im Ticket).
 CREATE TABLE ldap_group_role_mapping (
    ldap_group TEXT PRIMARY KEY,
    role       TEXT NOT NULL CHECK (role IN ('user', 'tenant_admin'))
 );
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
sysopsandClaude Sonnet 5	e4856dfc9d	IAM-06: sso-anmeldung-ueber-oidc internal/oidc: JWKS-Parser (RSA-Schluessel, RFC 7517) + Verifier prueft ID-Tokens gegen den geparsten Schluesselsatz (Signatur, Ablauf ueber die jwt-Bibliothek, Aussteller) — Akzeptanzkriterium 3. VerifyWithNonce prueft zusaetzlich, dass der nonce-Claim exakt dem beim Redirect ausgestellten Nonce entspricht (Replay-Schutz). StateStore ist der CSRF-/Replay-Schutz (Akzeptanzkriterium/Pruefung 3): Generate stellt state+nonce aus, Consume loest den state ATOMAR und EINMALIG ein (WHERE used_at IS NULL, analog IAM-03/IAM-09-Muster) — ein abgefangener und wiederverwendeter Redirect-Callback schlaegt fehl. CompleteOIDCLogin mappt Rollen aus OIDC-Rollen-Claims ueber DIESELBE Erlaubnis-Matrix wie IAM-05/LDAP (ldapsync.RoleMappingStore.HighestRoleFor, keine zweite parallele Implementierung — Akzeptanzkriterium 2) und stellt bei Erfolg ein normales IAM-02-Sitzungs-Token aus. Lokaler Login (IAM-02 LoginService) bleibt vollstaendig unangetastet und damit als Fallback nutzbar. WICHTIGER HINWEIS: kein registrierter externer OIDC-Provider (Google/Okta/ Azure AD) in dieser Umgebung verfuegbar fuer einen echten Authorization- Code-Redirect (analog IAM-05/AUD-05). ANDERS als dort ist die eigentliche Token-Validierung aber rein kryptographisch und ohne Netzwerkabhaengigkeit zur Testzeit vollstaendig echt geprueft: Tests erzeugen ein eigenes RSA-Schluesselpaar, signieren ID-Tokens selbst und verifizieren sie exakt wie bei einem echten Provider. Nur der Live-Redirect zu einem realen externen IdP bleibt ungeprueft. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Rollen-Erlaubnis-Matrix fuer OIDC-Claims automatisiert getestet (keine Privilege-Escalation) — TestCompleteOIDCLogin_UnmappedRoleGrantsNothing: Claims mit "tenant_admin"/"superadmin" als Rollen-Strings, die NIE gemappt wurden, vergeben keine Rolle. PASS. 2. Token-Signatur- und Ablaufpruefung gegen JWKS automatisiert getestet — TestVerify_RejectsExpiredToken, TestVerify_RejectsWrongSigningKey, TestVerify_RejectsWrongIssuer, TestParseJWKS_RoundTrip. PASS. 3. State/Nonce-Handling gegen CSRF und Replay geprueft — TestStateStore_ConsumeIsSingleUse (State-Replay abgewiesen), TestVerifyWithNonce_RejectsMismatch (Nonce-Mismatch abgewiesen). PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 22:53:42 +02:00
sysopsandClaude Sonnet 5	1a82da211d	IAM-05: ldap-active-directory-anbindung internal/ldapsync: Client ist eine Schnittstelle (Search() liefert Entry- Liste) — in dieser Umgebung steht kein echter LDAP/AD-Server zur Verfuegung (analog AUD-05/Archive), daher ist die Sync-/Rollenzuordnungs-Logik vollstaendig gegen einen Fake getestet, eine echte Verbindungspruefung gegen LDAP/AD steht noch aus. RoleMappingStore (Akzeptanzkriterium 3): explizite Erlaubnis-Matrix LDAP-Gruppe -> Rolle. HighestRoleFor vergibt NUR fuer explizit gemappte Gruppen eine Rolle — eine unbekannte Gruppe, auch wenn ihr Name zufaellig wie eine interne Rolle aussieht ("tenant_admin", "superadmin"), traegt strukturell nichts bei (kein Code-Pfad, der eine ungemappte Gruppe je einer Rolle zuordnet) — behebt die aus archivmail bekannte Privilege-Escalation- Fehlerklasse von Grund auf statt nachtraeglich zu haerten. Syncer.Run ruft Search() als ALLERERSTES auf; schlaegt es fehl, wird ohne jede Aenderung an bestehenden Konten abgebrochen (Akzeptanzkriterium 2). Pro Eintrag isolierte Fehler landen in SyncResult.Failed, ohne andere Eintraege zu beeintraechtigen. Deaktivierung in LDAP wird als users.Deactivate uebernommen (Akzeptanzkriterium 3). ldap_config speichert bewusst nur den NAMEN einer Umgebungsvariable fuer das Bind-Passwort, nie das Passwort selbst. internal/rbac (RBAC-01) wurde 1:1 aus dem rbac-01-Branch uebernommen (git show aus derselben Repo-Historie) — IAM-05 haengt an RBAC-01 fuer die Rollenzuweisung, beide Boards leben aber auf getrennten, noch nicht gemergten Feature-Branches ohne gemeinsame Historie. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Rollen-Erlaubnis-Matrix mit Positiv- und Negativfaellen automatisiert getestet (keine Privilege-Escalation) — TestRoleMapping_PositiveAndNegativeCases: gemappte Gruppe liefert Rolle, unbekannte Gruppe und rollen-aehnlich benannte, aber nie gemappte Gruppen liefern keine. PASS. 2. Synchronisationslauf mit fehlerhafter/nicht erreichbarer LDAP-Quelle bricht kontrolliert ab, ohne bestehende Konten zu beschaedigen — TestSyncer_AbortsCleanlyOnSourceError: bestehendes Konto bleibt nach fehlgeschlagenem Lauf unveraendert aktiv. PASS. 3. Deaktivierung eines Benutzers in LDAP wird bei naechster Synchronisation korrekt uebernommen — TestSyncer_AppliesDeactivationOnNextRun: erster Lauf legt aktiven Benutzer an, zweiter Lauf mit Disabled=true setzt ihn auf inaktiv. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 22:39:10 +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
		`@@ -1,2 +0,0 @@`
			`DROP TABLE IF EXISTS scrub_counters;`
			`DROP TABLE IF EXISTS scrub_state;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE IF EXISTS role_assignment_history;`
							`DROP TABLE IF EXISTS role_assignments;`
		`@@ -0,0 +1 @@`
							`ALTER TABLE users DROP COLUMN password_hash;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE IF EXISTS ldap_group_role_mapping;`
							`DROP TABLE IF EXISTS ldap_config;`