deploy: installer + systemd-units, Core auf 192.168.1.131 in Betrieb

deploy/install.sh: idempotenter Installer fuer Debian/systemd. Legt Systembenutzer 'nexarch', Postgres-Rolle+Registry-DB an, baut alle 7 Core-Binaries (cmd/core + *-devserver), wendet Registry-Migrationen an (nur bei leerer DB), generiert Secrets (Audit-Admin-Token, Ed25519- Lizenzschluesselpaar) nach /etc/nexarch/core.env (0600), installiert und startet je Dienst einen systemd-Service. Tatsaechlich auf 192.168.1.131 ausgefuehrt und verifiziert: alle 7 Dienste laufen (systemctl active), alle Health-Endpunkte antworten 200. Zweiter Installer-Lauf bestaetigt Idempotenz (ueberspringt bestehende Rolle/DB/ Secrets/Migrationen, Dienste bleiben durchgehend aktiv). Hinweis: kein unified Server (siehe QA-05/AUD-06-Befund) - weiterhin 7 getrennte Binaries/Ports, dieser Installer deployt sie so wie sie sind. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ
AUD-06: audit-log-verdrahtung-in-sicherheitsrelevante-core-handler
2026-08-29 19:03:20 +02:00 · 2026-08-29 17:24:26 +02:00 · 2026-08-29 17:16:08 +02:00 · 2026-08-29 17:09:22 +02:00 · 2026-08-29 17:09:04 +02:00 · 2026-08-29 17:08:42 +02:00
97 changed files with 6553 additions and 33 deletions
@@ -0,0 +1,22 @@
 name: Core-Schnittstellen-Vertragstests
 on:
  push:
    paths:
      - "internal/contracttest/**"
      - "internal/apiserver/**"
      - "internal/moduletrust/**"
      - "internal/moduleregistry/**"
      - "internal/webhook/**"
  pull_request: {}
 jobs:
  contract-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: "1.22"
      - name: Vertragstests ausfuehren
        run: go test ./internal/contracttest/... -v
@@ -0,0 +1,38 @@
 name: Supply-Chain-Scan (Go)
 on:
  push:
    paths:
      - "**/*.go"
      - "go.mod"
      - "go.sum"
  pull_request: {}
 jobs:
  govulncheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: "1.22"
      - name: govulncheck installieren
        # @latest kann eine govulncheck-Version verlangen, die neuer ist als
        # die hier verwendete Go-Toolchain (z.B. "requires go >= 1.25.0") —
        # feste, bekannt kompatible Version statt @latest (siehe
        # scripts/verify-supply-chain-gate.sh, Fund vom 2026-08-28 auf dem Testhost).
        run: go install golang.org/x/vuln/cmd/govulncheck@v1.1.3
      - name: Go-Module auf bekannte Schwachstellen pruefen
        shell: bash
        run: |
          # pipefail ist Pflicht: sonst liefert "govulncheck | tee" den Exit-Code
          # von tee (immer 0) statt den von govulncheck zurueck — der Gate-Zweck
          # (Akzeptanzkriterium 3: Fund blockiert den Merge) waere sonst wirkungslos.
          set -o pipefail
          govulncheck ./... | tee govulncheck-report.txt
      - name: Scan-Bericht als Artefakt ablegen
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: govulncheck-report
          path: govulncheck-report.txt
@@ -0,0 +1,32 @@
 name: Supply-Chain-Scan (npm)
 on:
  push:
    paths:
      - "web/**/package.json"
      - "web/**/package-lock.json"
  pull_request: {}
 jobs:
  npm-audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "22"
      - name: Alle Next.js-Frontends auf bekannte Schwachstellen pruefen
        shell: bash
        run: |
          set -o pipefail
          status=0
          for pkg in $(find web -maxdepth 2 -name package.json); do
            dir=$(dirname "$pkg")
            echo "=== npm audit: $dir ==="
            (cd "$dir" && npm install --package-lock-only --no-audit --no-fund \
              && npm audit --audit-level=high) || status=1
          done
          # Erst nach Durchlauf ALLER Frontends fehlschlagen (Akzeptanzkriterium 2/3):
          # ein einzelner Fund darf nicht verhindern, dass die uebrigen Frontends
          # ebenfalls geprueft und im Bericht sichtbar werden.
          exit $status
@@ -97,6 +97,50 @@ Keine Commits in dieser Session.
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 ---
 ## 2026-08-28 23:00 – 23:01 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - .gitea/workflows/govulncheck.yml       | 32 ++++++++++++++++++++++++++++++++
 - .gitea/workflows/npm-audit.yml         | 28 ++++++++++++++++++++++++++++
 - scripts/verify-supply-chain-gate.sh    | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - testdata/vulnfixture-go/go.mod         |  8 ++++++++
 - testdata/vulnfixture-go/main.go        | 12 ++++++++++++
 - testdata/vulnfixture-npm/package.json  | 10 ++++++++++
 ---
 ## 2026-08-28 23:02 – 23:03 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 - ab7a033 OPS-06: fix — fixture ruft tatsaechlich verwundbaren symbolpfad auf (ParseAcceptLanguage statt Parse, GO-2022-1059 statt falscher advisory-id)
 - 77ecf42 OPS-06: fix — verify-supply-chain-gate.sh unterscheidet jetzt echten Fund von Werkzeugfehler (pruefte vorher nur exit-code, 'command not found' galt faelschlich als bestanden)
 ### Geänderte Dateien
 - testdata/vulnfixture-go/go.mod       | 8 +++++---
 - testdata/vulnfixture-go/main.go      | 7 +++++--
 - DEVLOG.md                            | 12 ++++++++++++
 - scripts/verify-supply-chain-gate.sh  | 52 +++++++++++++++++++++++++++++++++++++---------------
 ---
 ## 2026-08-28 23:04 – 23:05 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 - 9de84f6 OPS-06: fix — fehlendes fail=1 im govulncheck-unavailable-zweig, govulncheck-version gepinnt statt @latest (Go-Versionskonflikt auf 131 gefunden)
 ### Geänderte Dateien
 - .gitea/workflows/govulncheck.yml    |  6 +++++-
 - DEVLOG.md                           | 12 ++++++++++++
 - scripts/verify-supply-chain-gate.sh | 13 +++++++++++--
 ---
 ## 2026-08-27 17:36 – 17:36 (0m)
 **Beschreibung:** Claude Code Session
@@ -186,6 +230,51 @@ Keine Commits in dieser Session.
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 - 369a40a OPS-05: alerting-bei-schwellwert-ueberschreitung (internal/alerting: regel-store, evaluator gegen ops-03-metriken, cfg-02-zustellung, drosselung je regel+zeitreihe)
 - 06dbd52 Merge branch 'feature/cfg-02-benachrichtigungs-dispatcher-core-service-fuer-module' into feature/ops-05-alerting-bei-schwellwert-ueberschreitung
 ### Geänderte Dateien
 - internal/alerting/evaluator.go       | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/alerting/evaluator_test.go  | 233 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/alerting/rules.go           | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - migrations/0006_alert_rules.down.sql |   2 ++
 - migrations/0006_alert_rules.up.sql   |  24 ++++++++++++++++++++++
 ---
 ## 2026-08-29 00:00 – 00:00 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - internal/alerting/evaluator.go       | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/alerting/evaluator_test.go  | 233 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - internal/alerting/rules.go           | 132 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - migrations/0006_alert_rules.down.sql |   2 ++
 - migrations/0006_alert_rules.up.sql   |  24 ++++++++++++++++++++++
 ---
 ## 2026-08-29 00:03 – 00:06 (3m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ### Commits
 Keine Commits in dieser Session.
 ### Geänderte Dateien
 - DEVLOG.md                  | 31 +++++++++++++++++++++++++++++++
 - go.mod                     | 19 +++++++++++++++----
 - go.sum                     | 36 ++++++++++++++++++++++++++++++------
 - internal/alerting/rules.go |  2 +-
 ---
 ## 2026-08-29 00:06 – 00:07 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 - fbcc9db RBAC-05: web/rbac-admin next.js-frontend (rollen+gruppen-verwaltung, audit-verlauf) auf shl-01
 - bd80f0c Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/rbac-05-rechte-administrationsoberflaeche
@@ -0,0 +1,43 @@
 // metrics-devserver stellt den OPS-03-Metrics-Aggregator (internal/metrics)
 // unter /metrics bereit, damit ein echter Prometheus-Scrape-Vorgang gegen
 // den Core-Dienst geprueft werden kann (Pruefung 3). Getrennt von cmd/core
 // aus demselben Grund wie die anderen *-devserver.
 package main
 import (
 	"context"
 	"log"
 	"net/http"
 	"os"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/metrics"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	addr := os.Getenv("NEXARCH_METRICS_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8085"
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	sourceStore := metrics.NewSourceStore(pool)
 	agg := metrics.NewAggregator(metrics.NewCoreRegistry(), sourceStore.Provide)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/metrics", agg.Handler())
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("metrics-devserver listening on %s", addr)
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
@@ -0,0 +1,22 @@
 // gen-ed25519-keypair erzeugt ein Ed25519-Schluesselpaar fuer die
 // Lizenzsignatur (LIC-01/LIC-04) und gibt beide Teile base64-raw-url-
 // kodiert aus — dasselbe Format, das internal/license.NewIssuer/NewValidator
 // erwarten. Nur vom Installer (deploy/install.sh) verwendet.
 package main
 import (
 	"crypto/ed25519"
 	"crypto/rand"
 	"encoding/base64"
 	"fmt"
 	"log"
 )
 func main() {
 	pub, priv, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Printf("PUBLIC=%s\n", base64.RawURLEncoding.EncodeToString(pub))
 	fmt.Printf("PRIVATE=%s\n", base64.RawURLEncoding.EncodeToString(priv))
 }
@@ -0,0 +1,150 @@
 #!/usr/bin/env bash
 # NEXARCH Core – Installer/Deployer fuer eine Debian/systemd-Zielumgebung.
 #
 # Baut alle Core-Binaries (cmd/core + die *-devserver), legt Postgres-Rolle
 # und Registry-Datenbank an (falls nicht vorhanden), wendet die
 # Registry-Migrationen an, generiert Secrets (falls nicht vorhanden) und
 # installiert+startet jeden Dienst als eigenen systemd-Service.
 #
 # Idempotent: mehrfacher Aufruf ist sicher — vorhandene Rolle/DB/Secrets
 # werden nicht ueberschrieben, Migrationen nur angewendet, wenn die
 # Registry-DB noch leer ist (siehe Abschnitt "Migrationen" unten).
 #
 # Aufruf (als root): ./deploy/install.sh
 #
 # Ueberschreibbar per Umgebungsvariable:
 #   NEXARCH_INSTALL_DIR      (Default: /opt/nexarch-core)
 #   NEXARCH_PG_ROLE          (Default: nexarch_core)
 #   NEXARCH_PG_REGISTRY_DB   (Default: nexarch_registry)
 #   NEXARCH_BRANCH           (Default: aktueller Branch dieses Checkouts)
 set -euo pipefail
 INSTALL_DIR="${NEXARCH_INSTALL_DIR:-/opt/nexarch-core}"
 PG_ROLE="${NEXARCH_PG_ROLE:-nexarch_core}"
 PG_DB="${NEXARCH_PG_REGISTRY_DB:-nexarch_registry}"
 ENV_FILE=/etc/nexarch/core.env
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 if [ "$(id -u)" -ne 0 ]; then
 	echo "Bitte als root ausfuehren (legt Systembenutzer, systemd-Units und Postgres-Rolle an)." >&2
 	exit 1
 fi
 echo "== 1. Systembenutzer =="
 if ! id nexarch >/dev/null 2>&1; then
 	useradd --system --no-create-home --shell /usr/sbin/nologin nexarch
 	echo "Benutzer 'nexarch' angelegt."
 else
 	echo "Benutzer 'nexarch' existiert bereits."
 fi
 echo "== 2. Postgres-Rolle und Registry-Datenbank =="
 if ! sudo -u postgres psql -tAc "SELECT 1 FROM pg_roles WHERE rolname = '${PG_ROLE}'" | grep -q 1; then
 	PG_PASSWORD="$(openssl rand -hex 24)"
 	sudo -u postgres psql -v ON_ERROR_STOP=1 -c "CREATE ROLE ${PG_ROLE} WITH LOGIN PASSWORD '${PG_PASSWORD}';"
 	echo "Rolle '${PG_ROLE}' angelegt."
 else
 	echo "Rolle '${PG_ROLE}' existiert bereits — Passwort wird NICHT neu gesetzt (siehe ${ENV_FILE} fuer das vorhandene)."
 	PG_PASSWORD=""
 fi
 if ! sudo -u postgres psql -tAc "SELECT 1 FROM pg_database WHERE datname = '${PG_DB}'" | grep -q 1; then
 	sudo -u postgres psql -v ON_ERROR_STOP=1 -c "CREATE DATABASE ${PG_DB} OWNER ${PG_ROLE};"
 	echo "Datenbank '${PG_DB}' angelegt."
 else
 	echo "Datenbank '${PG_DB}' existiert bereits."
 fi
 # Fuer Tenant-Provisioning (CREATE DATABASE pro Mandant, Modell C) braucht
 # die Rolle CREATEDB-Recht auf der physischen Postgres-Instanz.
 sudo -u postgres psql -v ON_ERROR_STOP=1 -c "ALTER ROLE ${PG_ROLE} WITH CREATEDB;" >/dev/null
 echo "== 3. Secrets/Konfiguration =="
 mkdir -p /etc/nexarch
 if [ ! -f "$ENV_FILE" ]; then
 	if [ -z "${PG_PASSWORD}" ]; then
 		echo "FEHLER: Rolle existierte bereits, aber ${ENV_FILE} fehlt — Passwort kann nicht rekonstruiert werden." >&2
 		echo "Entweder ${ENV_FILE} von Hand mit dem bekannten Passwort anlegen, oder die Rolle droppen und erneut installieren." >&2
 		exit 1
 	fi
 	AUDIT_ADMIN_TOKEN="$(openssl rand -hex 32)"
 	# Ed25519-Schluesselpaar fuer die Lizenzsignatur (LIC-01/LIC-04):
 	# licadmin-devserver prueft Lizenzen nur mit dem OEFFENTLICHEN Schluessel,
 	# der private Schluessel wird NICHT deployt, sondern separat fuer das
 	# (noch zu bauende) offline Lizenz-Ausstellungswerkzeug aufbewahrt.
 	KEYPAIR_DIR=/etc/nexarch/license-signing
 	mkdir -p "$KEYPAIR_DIR"
 	chmod 700 "$KEYPAIR_DIR"
 	if [ ! -f "$KEYPAIR_DIR/private.b64" ]; then
 		go run "$SCRIPT_DIR/gen-ed25519-keypair.go" > "$KEYPAIR_DIR/keypair.txt"
 		grep '^PRIVATE=' "$KEYPAIR_DIR/keypair.txt" | cut -d= -f2 > "$KEYPAIR_DIR/private.b64"
 		grep '^PUBLIC=' "$KEYPAIR_DIR/keypair.txt" | cut -d= -f2 > "$KEYPAIR_DIR/public.b64"
 		chmod 600 "$KEYPAIR_DIR"/*.b64 "$KEYPAIR_DIR/keypair.txt"
 		rm -f "$KEYPAIR_DIR/keypair.txt"
 	fi
 	LICENSE_PUBLIC_KEY="$(cat "$KEYPAIR_DIR/public.b64")"
 	cat > "$ENV_FILE" <<EOF
 # Automatisch generiert von deploy/install.sh am $(date -Iseconds).
 # NICHT ins Repository committen — enthaelt Zugangsdaten/Secrets.
 NEXARCH_REGISTRY_DSN=postgresql://${PG_ROLE}:${PG_PASSWORD}@localhost:5432/${PG_DB}?sslmode=disable
 NEXARCH_ADMIN_DSN=postgresql://${PG_ROLE}:${PG_PASSWORD}@localhost:5432/postgres?sslmode=disable
 NEXARCH_TENANT_DSN_TEMPLATE=postgresql://${PG_ROLE}:${PG_PASSWORD}@localhost:5432/%s?sslmode=disable
 NEXARCH_TENANT_SCHEMA_PATH=${INSTALL_DIR}/migrations/tenant
 NEXARCH_LISTEN_ADDR=:8080
 NEXARCH_AUDIT_ADMIN_TOKEN=${AUDIT_ADMIN_TOKEN}
 NEXARCH_LICENSE_PUBLIC_KEY=${LICENSE_PUBLIC_KEY}
 EOF
 	chmod 600 "$ENV_FILE"
 	chown nexarch:nexarch "$ENV_FILE"
 	echo "${ENV_FILE} angelegt (Secrets generiert)."
 else
 	echo "${ENV_FILE} existiert bereits — wird nicht ueberschrieben."
 fi
 echo "== 4. Build =="
 mkdir -p "$INSTALL_DIR/bin"
 cd "$REPO_ROOT"
 for svc in core auditlog-devserver licadmin-devserver metrics-devserver secheaders-devserver statuspage-devserver tenantadmin-devserver; do
 	go build -o "$INSTALL_DIR/bin/${svc}" "./cmd/${svc}"
 	echo "gebaut: ${svc}"
 done
 cp -r migrations "$INSTALL_DIR/migrations"
 chown -R nexarch:nexarch "$INSTALL_DIR"
 echo "== 5. Registry-Migrationen =="
 # shellcheck disable=SC1090
 source "$ENV_FILE"
 ALREADY_MIGRATED=$(sudo -u postgres psql -tAc "SELECT to_regclass('public.tenants') IS NOT NULL" -d "${PG_DB}")
 if [ "$ALREADY_MIGRATED" = "t" ]; then
 	echo "Registry-Datenbank hat bereits Tabellen — Migrationen werden uebersprungen (nicht idempotent, siehe Skript-Kommentar)."
 else
 	for f in $(find "$INSTALL_DIR/migrations" -maxdepth 1 -name '*.up.sql' | sort); do
 		sudo -u postgres psql -v ON_ERROR_STOP=1 -d "${PG_DB}" -f "$f" >/dev/null
 		echo "angewendet: $(basename "$f")"
 	done
 fi
 echo "== 6. systemd-Units =="
 for tmpl in "$SCRIPT_DIR"/systemd/*.service.tmpl; do
 	name="$(basename "$tmpl" .service.tmpl)"
 	sed "s#__INSTALL_DIR__#${INSTALL_DIR}#g" "$tmpl" > "/etc/systemd/system/${name}.service"
 done
 systemctl daemon-reload
 for tmpl in "$SCRIPT_DIR"/systemd/*.service.tmpl; do
 	name="$(basename "$tmpl" .service.tmpl)"
 	systemctl enable --now "${name}.service"
 done
 echo "== Fertig =="
 echo "Status pruefen mit: systemctl status 'nexarch-*'"
 echo "Health-Checks:"
 echo "  curl -s http://localhost:8080/healthz"
 echo "  curl -s http://localhost:8081/healthz  # licadmin"
 echo "  curl -s http://localhost:8082/healthz  # tenantadmin"
 echo "  curl -s http://localhost:8083/healthz  # auditlog"
 echo "  curl -s http://localhost:8084/healthz  # statuspage"
 echo "  curl -s http://localhost:8085/healthz  # metrics"
 echo "  curl -s http://localhost:8086/unprotected  # secheaders (kein /healthz)"
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH auditlog-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/auditlog-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH Core
 After=network.target postgresql.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/core
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH licadmin-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/licadmin-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH metrics-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/metrics-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH secheaders-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/secheaders-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH statuspage-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/statuspage-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,17 @@
 [Unit]
 Description=NEXARCH tenantadmin-devserver
 After=network.target postgresql.service nexarch-core.service
 Wants=postgresql.service
 [Service]
 Type=simple
 User=nexarch
 Group=nexarch
 EnvironmentFile=/etc/nexarch/core.env
 ExecStart=__INSTALL_DIR__/bin/tenantadmin-devserver
 Restart=on-failure
 RestartSec=3
 WorkingDirectory=__INSTALL_DIR__
 [Install]
 WantedBy=multi-user.target
@@ -0,0 +1,74 @@
 # AUD-06 – Audit-Log-Verdrahtung in sicherheitsrelevante Core-Handler
 Welle 8. Voraussetzung: AUD-01, AUD-02, RBAC-02, TEN-04, IAM-07, API-10 (alle
 Status "Fertig"). Branch:
 `feature/aud-06-audit-log-verdrahtung-in-sicherheitsrelevante-core-handler`,
 aufbauend auf dem gemergten Stand von QA-05.
 Entstanden aus einem Befund des QA-05-Abnahmegates
 (`docs/QA-05-ABNAHME-COMPLIANCE-PRUEFUNG.md` Abschnitt 2): der zentrale
 Audit-Log (AUD-01/AUD-02) existierte und war getestet, wurde aber von
 keinem Produktions-Handler tatsächlich befüllt.
 ## Umsetzung
 Additive `WithAudit(...)`-Methode je betroffenem Store (Konvention aus
 `internal/lockout.Store.WithPolicy` übernommen) — bestehende Konstruktoren
 (`NewStore`/`NewRegistry`) bleiben unverändert, `audit == nil` bleibt gültig
 und verhält sich exakt wie vorher (kein Verhaltensbruch für bestehende
 Aufrufer/Tests):
 | Bereich | Datei | Verdrahtete Methode(n) | Audit-Action |
 |---|---|---|---|
 | Policy (RBAC-02) | `internal/policy/store.go` | `Grant`, `Revoke` | `policy.grant` / `policy.revoke` |
 | Tenant-Lifecycle (TEN-04) | `internal/tenant/registry.go`, `lifecycle.go` | `transition` (genutzt von `Suspend`/`Reactivate`/`ScheduleDeletion`/`CancelDeletion`) | `tenant.transition` |
 | Lockout (IAM-07) | `internal/lockout/lockout.go` | `RecordFailure`, `Unlock` | `auth.login_failed` / `auth.account_locked` / `auth.account_unlocked` |
 | KEK-Rotation (API-10) | `internal/kek/store.go` | `RotateTenantKEK`, `RotateMasterKey` | `kek.tenant_rotated` / `kek.master_rotated` |
 `login_attempts` (Lockout) liegt in der Tenant-Datenbank, `audit_events` in
 der Registry-Datenbank — `lockout.Store.WithAudit` nimmt daher zusätzlich
 zum `*audit.Log` den Tenant-Slug entgegen, damit das Event den korrekten
 Tenant-Bezug trägt (`audit.Event.TenantSlug`).
 ## Prüfung 1: reale Aktion je Bereich, Nachweis per direkter Abfrage von `audit_events`
 Neues Testpaket `internal/audit/wiring_test.go`, vier Tests, jeweils: reale
 Aktion über den öffentlichen Store-API ausführen, anschließend
 `SELECT count(*) FROM audit_events WHERE action = ... AND target = ...`
 direkt abfragen — derselbe Nachweisstil wie der QA-05-Stichprobenabgleich.
 | Test | Ergebnis |
 |---|---|
 | `TestWiring_PolicyGrantRevokeAreAudited` | **bestanden** — je 1 Eintrag für `policy.grant`/`policy.revoke` |
 | `TestWiring_TenantLifecycleTransitionIsAudited` | **bestanden** — Eintrag für `tenant.transition` → `suspended` |
 | `TestWiring_LockoutFailuresAndUnlockAreAudited` | **bestanden** — je 1 Eintrag für `auth.login_failed`, `auth.account_locked`, `auth.account_unlocked` |
 | `TestWiring_KEKRotationIsAudited` | **bestanden** — je 1 Eintrag für `kek.tenant_rotated`, `kek.master_rotated` |
 ## Prüfung 2: bestehende Tests aller vier Pakete bleiben grün
 `internal/policy`, `internal/tenant`, `internal/lockout`, `internal/kek` —
 alle bestehenden Tests unverändert grün (rein additive Verdrahtung, siehe
 Tabelle oben zu `audit == nil`).
 ## Prüfung 3: QA-05-Stichprobenabgleich wiederholt
 Derselbe Stichprobenabgleich wie in QA-05 (`policy.Store.Grant`/`Revoke`
 über `internal/pentest`) erneut ausgeführt — jetzt mit Treffer statt 0
 Zeilen (siehe `TestWiring_PolicyGrantRevokeAreAudited`, welche exakt diesen
 Fall abdeckt).
 ## Build/Test-Ergebnis
 ```
 go build ./... / go vet ./...  -> clean
 go test ./... -p 1 -count=1     -> 51/51 Pakete ok, 0 Fehlschläge
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 erfüllt. Die in QA-05 als Auflage vor QA-06 vermerkte Audit-Log-Lücke ist
 für die vier dort konkret benannten Bereiche geschlossen. Weiterhin nicht
 Bestandteil (siehe QA-05 „Nicht Bestandteil"): Vereinheitlichung der
 `*-devserver`-Binaries zu einer zentralen Server-Topologie, sowie
 Verdrahtung außerhalb Core.
@@ -0,0 +1,73 @@
 # NEXARCH Core – Projektweite Sicherheits-Coding-Konventionen
 Stand: 2026-08-28. Ticket: IAM-15. Ergänzt `docs/TESTSTRATEGIE-CORE.md` (QA-01) um Coding-Regeln,
 die als Code-Review-Checkliste gelten — keine dieser Regeln ist optional oder "nur für ein Modul".
 ## 1. Warum dieses Dokument existiert
 Eine sicherheitsrelevante Coding-Regel, die nur einmal an einer Stelle vorgemacht statt projektweit
 verankert wird, wird beim nächsten neuen Vergleich vergessen. Das gilt für jede Regel in diesem
 Dokument gleichermaßen — die erste Regel (SQL) ist bereits als Konvention etabliert, die zweite
 (timing-safe Vergleich, IAM-15) macht sie hier zum ersten Mal explizit schriftlich.
 ## 2. Regel: Kein `fmt.Sprintf` für SQL-Bestandteile aus Nutzereingabe
 **Spalten-/Tabellennamen ausschließlich aus statischen Konstanten bzw. einem geschlossenen
 Enum/Switch-Typ, nie aus Nutzereingabe oder generischem String-Zusammenbau — auch nicht hinter
 einer Whitelist-Funktion.** Werte (nicht Bezeichner) gehören als Parameter (`$1`, `$2`, …) in die
 Query, niemals interpoliert.
 Lehre aus beiden Altsystemen (`known-issues-archivdms.md` Punkt 10, `known-issues-archivmail.md`
 Punkt 12): dynamische Tabellennamen via `fmt.Sprintf`, nur durch eine fragile Whitelist-Funktion
 abgesichert. Siehe DMS/Mail `SRC-11` für die board-spezifische Umsetzung dieser Regel im
 Suchindex-Kontext.
 **Referenzbeispiel (korrekt):** `internal/tenant/lifecycle.go`, `ProcessDueDeletions` — Statuswerte
 und IDs ausschließlich als Parameter (`$1`, `$2`, …), niemals interpoliert; der einzige Einsatz von
 `fmt.Sprintf` im Package baut einen **Datenbanknamen aus einem bereits validierten Slug**
 (`dbNameForSlug`, `slugPattern` in `tenant.go` erzwingt `^[a-z][a-z0-9_]{1,48}$` vor jeder
 Verwendung) — keine ungeprüfte Nutzereingabe erreicht die Query.
 ## 3. Regel: Timing-safe Vergleich für jede sicherheitsrelevante Zugriffsentscheidung (IAM-15)
 **Jeder Vergleich, der eine sicherheitsrelevante Zugriffsentscheidung trifft — Passwort-Hash, Token,
 Signatur, 2FA-Code/-Wiederherstellungscode — nutzt einen timing-safe/constant-time Vergleich, nie
 den regulären `==`-Operator.** Ein naiver `==`-Vergleich zweier Byte-Folgen bricht bei der ersten
 abweichenden Stelle ab; die dadurch messbare Laufzeitdifferenz lässt sich aus der Ferne ausmessen und
 erlaubt ein Byte-für-Byte-Erraten des korrekten Werts (Timing-Angriff).
 **So wird es gemacht:** `internal/timingsafe` (dieses Ticket) bündelt die kanonische Implementierung
 (`crypto/subtle.ConstantTimeCompare`) für neue Vergleichsstellen:
 ```go
 import "gitea.perlbach24.de/scripte/nexarch/internal/timingsafe"
 if !timingsafe.EqualString(providedCode, expectedCode) {
    return ErrInvalid
 }
 ```
 Ausnahme: `bcrypt.CompareHashAndPassword` (Passwort-Hashes) ist bereits von Haus aus timing-safe —
 hier ist kein zusätzlicher Wrapper nötig.
 ### 3.1 Audit bestehender Vergleichsstellen (Prüfung 2)
 Durchgeführt 2026-08-28, Ergebnis: **alle bestehenden sicherheitsrelevanten Vergleichsstellen
 implementierten die Regel bereits korrekt**, unabhängig voneinander mit `crypto/subtle` — nichts
 musste korrigiert werden (Akzeptanzkriterium 3, „ggf.").
 | Ort | Was wird verglichen | Fundstelle |
 |---|---|---|
 | `internal/totp/totp.go`, `Validate` | TOTP-Code (2FA) | nutzte bereits `subtle.ConstantTimeCompare` direkt, in diesem Ticket auf `timingsafe.EqualString` umgestellt (erster Verwender des neuen Packages) |
 | `internal/webhook/dispatcher.go`, `VerifySignature` | HMAC-Webhook-Signatur | `subtle.ConstantTimeCompare(expectedBytes, gotBytes)` |
 | `internal/moduleregistry/credentials.go`, `Authenticate` | Service-Credential-Secret-Hash | eigene `timingSafeEqual`-Hilfsfunktion, gleiches Muster |
 | `internal/authtoken/token.go`, `Consume` (Passwort-Reset/Einladung) | Einmal-Token | Hash-Lookup über DB-Index (`WHERE token_hash = $1`), kein manueller Byte-Vergleich nötig — bei zufälligen, hochentropischen Token ist der indexierte Hash-Abgleich gleichwertig sicher |
 Neue Vergleichsstellen sollen `internal/timingsafe` verwenden, statt das Muster erneut inline zu
 duplizieren — bestehende Stellen müssen dafür nicht umgebaut werden (kein Umbau angrenzender
 Bereiche über Board-Branch-Grenzen hinweg).
 ## 4. Wie diese Liste wächst
 Neue projektweite Sicherheits-Coding-Regeln werden hier ergänzt, sobald sie (wie SQL-Sprintf und
 timing-safe Vergleich) mehr als einmal unabhängig als Lehre auftauchen — nicht vorab spekulativ.
@@ -0,0 +1,205 @@
 # NEXARCH Incident-Response-Plan (inkl. DSGVO-Meldefristen)
 **Kachel:** Core OPS-04 | **Stand:** 2026-08-28 | **Geltungsbereich:** NEXARCH Core und alle Fachmodule (DMS, Mail, Archive, Workflow, AI, Connect)
 > Dieses Dokument ist eine **auszufüllende Vorlage**. Felder in eckigen Klammern
 > (`[AUSZUFÜLLEN: ...]`) müssen vom jeweiligen Betreiber (SaaS-Anbieter oder
 > On-Premise-Kunde, siehe `SAAS-BETRIEBSMODELL.md`) mit echten Namen,
 > Telefonnummern und E-Mail-Adressen befüllt werden, bevor der Plan
 > betrieblich wirksam ist. Ohne befüllte Kontaktliste (Abschnitt 7) ist
 > dieser Plan nicht einsatzbereit — siehe Prüfung 3.
 ## 1. Zweck
 Ablaufplan für Sicherheitsvorfälle (Datenleck, kompromittiertes
 Service-Credential, kompromittierter Core-Signaturschlüssel, unbefugter
 Zugriff, Ransomware, Ausfall mit Datenverlust): Erkennung, Klassifizierung,
 Eskalation, Sofortmaßnahmen, DSGVO-Meldefristen, Kommunikation,
 Nachbereitung. Ergänzt `SICHERHEITSKONZEPT.md` (dort: präventive
 Architekturentscheidungen) um den reaktiven Ablauf im Ernstfall.
 ## 2. Erkennung — technische Quellen
 Ein Vorfall wird über eine oder mehrere dieser Quellen bemerkt:
 | Quelle | Was sie zeigt | Code-Anknüpfung |
 |---|---|---|
 | Zentrale Statusseite | Ausfall/Fehlverhalten eines Moduls | Core `OPS-02` |
 | Metrics-Aggregation | Anomale Kennzahlen (z.B. Anstieg von 401/403, ungewöhnliche Zugriffszahlen) | Core `OPS-03` |
 | Health-/Readiness-Endpunkte | Abhängigkeitsausfall (DB, Queue) | Core `OPS-01` (`internal/health`) |
 | **Audit-Log** | Wer hat wann was getan — die primäre forensische Quelle für JEDEN Vorfall mit Personenbezug oder Rechteänderung | Core `AUD-01` (`internal/audit/audit.go`, `Log.Record`), Export/Filter über `AUD-03` (`internal/audit/export.go`, `StreamCSV`/`StreamJSON` nach Zeitraum/Akteur/Aktion/Tenant) |
 | Aufbewahrungs-/Löschprotokoll | Ungewöhnliche oder unautorisierte Löschvorgänge | Archive `RET-03`/`CMP-06` (geplant, noch nicht gebaut) |
 | Meldung durch Dritte | Kunde, Mitarbeiter, externer Sicherheitsforscher meldet einen Verdacht | — |
 Das Audit-Log (`AUD-01`) ist laut `SICHERHEITSKONZEPT.md` **append-only**
 (`AUD-02`, DB-Trigger-Schutz gegen UPDATE/DELETE) — es ist damit die
 vertrauenswürdigste Quelle für die Rekonstruktion eines Vorfalls, weil ein
 Angreifer es nicht nachträglich manipulieren kann.
 ## 3. Klassifizierung
 | Schweregrad | Beispiel | Meldepflichtig nach Art. 33 DSGVO? |
 |---|---|---|
 | **Kritisch** | Personenbezogene Daten mehrerer Mandanten abgeflossen; Master-Key (`API-10`) kompromittiert | Ja, mit hoher Wahrscheinlichkeit |
 | **Hoch** | Ein Mandant betroffen, personenbezogene Daten eingesehen/exfiltriert | Ja, sofern Risiko für Betroffene nicht auszuschließen ist |
 | **Mittel** | Kompromittiertes Service-Credential (`API-02`) ohne nachweisbaren Datenzugriff | Einzelfallprüfung durch Datenschutzbeauftragten |
 | **Niedrig** | Fehlkonfiguration ohne Datenzugriff, rechtzeitig erkannt | Nein, aber intern dokumentieren |
 Die Einstufung "meldepflichtig" ist IMMER eine rechtliche Bewertung durch
 den Datenschutzbeauftragten (Rolle, siehe Abschnitt 7) — diese Tabelle ist
 eine Ersteinschätzungshilfe für die technische Eskalation, kein Ersatz für
 die rechtliche Prüfung.
 ## 4. Eskalationskette (Rollen)
 | Rolle | Verantwortlich für | Wird informiert |
 |---|---|---|
 | **Incident Commander** | Koordiniert die gesamte Reaktion, trifft operative Entscheidungen | Sofort bei Erkennung (Schweregrad Mittel/Hoch/Kritisch) |
 | **Technischer Verantwortlicher** | Eindämmung, Beweissicherung (Audit-Log-Export), technische Ursachenanalyse | Sofort bei Erkennung |
 | **Datenschutzbeauftragter (DSB)** | Rechtliche Einstufung, DSGVO-Meldung an Aufsichtsbehörde, Betroffenen-Benachrichtigung (Art. 34) | Innerhalb 1 Stunde ab Schweregrad Mittel |
 | **Geschäftsführung/Betreiber** | Externe Kommunikation, Kundenbenachrichtigung, AVV-Pflichten (siehe `SAAS-BETRIEBSMODELL.md`) | Innerhalb 4 Stunden ab Schweregrad Hoch/Kritisch |
 Jede dieser Rollen benötigt Stellvertretung (Urlaub/Krankheit) — siehe
 Kontaktliste Abschnitt 7.
 ## 5. Sofortmaßnahmen (Eindämmung)
 1. Betroffene Zugänge/Credentials sperren (Service-Credential-Widerruf,
   `API-02`; Session-Widerruf, `IAM-12`; bei kompromittiertem
   Core-Signaturschlüssel: sofortige Schlüsselrotation ohne Ausfallzeit,
   `API-05`/`API-09`/`API-10` — alle drei unterstützen rotationsfähige
   Schlüssel/Zertifikate ohne Downtime).
 2. Beweissicherung: Audit-Log-Export für den betroffenen Zeitraum/Tenant/
   Akteur **vor** jeder Aufräumaktion (`internal/audit.Log.StreamCSV`/
   `StreamJSON`, `AUD-03`) — unveränderlich, daher jederzeit nachträglich
   exportierbar.
 3. Betroffenen Mandanten identifizieren (Tenant-Registry, `TEN-01`) — dank
   physischer Modell-C-Trennung ist ein Vorfall bei einem Mandanten
   technisch strukturell auf diesen einen begrenzt (siehe
   `SICHERHEITSKONZEPT.md` Abschnitt zu TEN-01).
 4. Zeitpunkt der Kenntniserlangung dokumentieren (Startpunkt der
   72-Stunden-Frist, siehe Abschnitt 6).
 ## 6. DSGVO-Meldefrist-Prozess (Art. 33/34 DSGVO)
 1. **Start der Frist**: Zeitpunkt, an dem der Betreiber (nicht der
   Entdecker im technischen Team) hinreichend sichere Kenntnis vom Vorfall
   hat — dokumentiert vom Incident Commander.
 2. **Verantwortlich für die Meldung**: Datenschutzbeauftragter.
 3. **Frist**: 72 Stunden ab Kenntniserlangung, an die zuständige
   Aufsichtsbehörde — auch wenn die Untersuchung noch nicht abgeschlossen
   ist (Art. 33 Abs. 4 erlaubt eine gestaffelte Meldung).
 4. **Inhalt der Meldung** (Art. 33 Abs. 3): Art der Verletzung, betroffene
   Kategorien/ungefähre Anzahl Betroffener und Datensätze, Kontakt des DSB,
   wahrscheinliche Folgen, ergriffene/vorgeschlagene Maßnahmen.
 5. **Betroffenen-Benachrichtigung** (Art. 34): zusätzlich erforderlich, wenn
   ein VORAUSSICHTLICH HOHES Risiko für die Rechte der betroffenen Personen
   besteht — Entscheidung durch DSB, unverzüglich.
 6. **Keine Meldung nötig**: nur wenn nachweislich kein Risiko für
   Betroffene besteht (z.B. Daten waren durch API-10-Envelope-Encryption
   wirksam verschlüsselt und der Schlüssel selbst nicht kompromittiert) —
   diese Einschätzung UND ihre Begründung wird dennoch dokumentiert
   (Art. 33 Abs. 5: Dokumentationspflicht besteht unabhängig von der
   Meldepflicht).
 7. **Vertragliche Ebene**: bei SaaS-/Private-Cloud-Betrieb regelt der AVV
   (Art. 28 DSGVO) zusätzlich, in welcher (kürzeren) Frist der
   Auftragsverarbeiter den Verantwortlichen (Kunde) informieren muss, BEVOR
   die 72-Stunden-Frist gegenüber der Behörde zu laufen beginnt — siehe
   `SAAS-BETRIEBSMODELL.md`.
 ## 7. Kontaktliste (auszufüllen vom Betreiber)
 | Rolle | Name | Telefon | E-Mail | Stellvertretung |
 |---|---|---|---|---|
 | Incident Commander | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] |
 | Technischer Verantwortlicher | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] |
 | Datenschutzbeauftragter | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] |
 | Geschäftsführung/Betreiber | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] | [AUSZUFÜLLEN] |
 | Zuständige Aufsichtsbehörde | [AUSZUFÜLLEN, abhängig vom Sitz des Betreibers] | — | [AUSZUFÜLLEN] | — |
 **Zuletzt bestätigt (Erreichbarkeitstest durchgeführt am):** [AUSZUFÜLLEN —
 noch nicht durchgeführt, siehe Prüfung 3]
 ## 8. Kommunikation
 - **Intern**: Eskalationskette (Abschnitt 4) zuerst, keine Information nach
  außen vor Freigabe durch Geschäftsführung.
 - **Extern (Kunden)**: bei SaaS-/Private-Cloud-Betrieb gemäß AVV-Frist,
  spätestens mit/vor der Behördenmeldung.
 - **Extern (Betroffene)**: nur bei hohem Risiko, siehe Abschnitt 6.5, Text
  in verständlicher, nicht-technischer Sprache.
 - **Presse/Öffentlichkeit**: ausschließlich durch Geschäftsführung.
 ## 9. Nachbereitung
 1. Lessons-Learned-Sitzung mit allen beteiligten Rollen (spätestens 2
   Wochen nach Abschluss).
 2. Vollständige Audit-Log-Auswertung des Vorfallszeitraums archivieren
   (separat vom laufenden Audit-Log, als Vorfallsakte).
 3. Prüfen, ob eine Schlüssel-Notfallrotation nötig ist/war (`API-05` JWT-
   Signaturschlüssel, `API-09` mTLS-Zertifikate, `API-10` Master-/
   Tenant-KEK) — alle drei sind so gebaut, dass Rotation ohne Ausfallzeit
   möglich ist.
 4. Diesen Plan aktualisieren, wenn die Übung/der echte Vorfall eine Lücke
   aufgezeigt hat.
 ## 10. Durchgeführte Prüfungen
 ### Prüfung 1 — Simulierte Vorfallsübung (Tabletop), durchgeführt 2026-08-28
 **Szenario**: Ein kompromittiertes Service-Credential des DMS-Moduls wird
 festgestellt (ungewöhnliche Anfragemuster in der Metrics-Aggregation,
 `OPS-03`).
 **Durchgespielter Ablauf**:
 1. *Erkennung*: Anomalie fällt in der Metrics-Aggregation auf (Abschnitt 2)
   → Technischer Verantwortlicher prüft das Audit-Log für den betroffenen
   Zeitraum (`AUD-03`-Export, gefiltert nach `actor` = Service-Credential
   des DMS-Moduls).
 2. *Klassifizierung*: Kompromittiertes Service-Credential ohne
   nachgewiesenen Datenzugriff → Schweregrad **Mittel** (Abschnitt 3).
 3. *Eskalation*: Incident Commander + Technischer Verantwortlicher sofort,
   DSB innerhalb 1 Stunde (Abschnitt 4).
 4. *Sofortmaßnahme*: Service-Credential des DMS-Moduls über `API-02`
   widerrufen und neu provisioniert; betroffene Tenant-Verbindungen
   (`TEN-01`) identifiziert.
 5. *Beweissicherung*: Vollständiger Audit-Log-Export für den Zeitraum vor
   dem Widerruf (`AUD-03`).
 6. *DSGVO-Bewertung*: DSB prüft anhand des Audit-Log-Exports, ob
   tatsächlich personenbezogene Daten abgerufen wurden. Ergebnis im
   simulierten Szenario: kein nachweisbarer Datenzugriff über die normale
   Nutzung des Moduls hinaus → keine Meldepflicht, aber Dokumentation
   gemäß Art. 33 Abs. 5.
 7. *Nachbereitung*: Ursache (wie kam das Credential abhanden) klären,
   Rotationsintervall für Service-Credentials als offenen Punkt vermerkt.
 **Ergebnis**: Der Ablauf war anhand des Dokuments ohne Lücke durchspielbar
 — jeder Schritt hatte eine konkrete technische Anknüpfung. **PASS.**
 ### Prüfung 2 — Meldefrist-Prozess auf Vollständigkeit geprüft, 2026-08-28
 Abgleich von Abschnitt 6 gegen Art. 33/34 DSGVO, Punkt für Punkt:
 | Anforderung (Art. 33/34) | Im Plan enthalten? |
 |---|---|
 | Fristbeginn = Kenntniserlangung, nicht Entdeckung durch Einzelperson | Ja (6.1) |
 | 72-Stunden-Frist an Aufsichtsbehörde | Ja (6.3) |
 | Gestaffelte Meldung erlaubt | Ja (6.3) |
 | Pflichtinhalt der Meldung | Ja (6.4) |
 | Betroffenen-Benachrichtigung bei hohem Risiko | Ja (6.5) |
 | Dokumentationspflicht auch ohne Meldepflicht | Ja (6.6) |
 | Verantwortliche Rolle benannt | Ja (6.2, DSB) |
 | Vertragliche AVV-Frist ggü. Kunde vor Behördenfrist | Ja (6.7) |
 **Ergebnis: vollständig. PASS.**
 ### Prüfung 3 — Kontaktliste aktuell und erreichbar bestätigt
 **Status: OFFEN.** Abschnitt 7 enthält ausschließlich Platzhalter
 (`[AUSZUFÜLLEN]`), da dieses Projekt noch keine reale Betreiber-Organisation
 mit benannten Personen/Telefonnummern hat. Diese Prüfung kann nicht durch
 Code oder Dokumentation allein bestanden werden — sie erfordert, dass der
 tatsächliche Betreiber Abschnitt 7 mit echten Kontakten befüllt UND einen
 Erreichbarkeitstest durchführt (z.B. Testanruf/Test-E-Mail an jede Rolle).
 **Bleibt nicht durchgeführt, bis diese Angaben vorliegen — wird hier
 transparent als offen dokumentiert statt fälschlich als erledigt markiert.**
@@ -0,0 +1,68 @@
 # QA-03 – Prüfprotokoll: Prüfgate Rechte & Policy
 Stand: 2026-08-29. Branch `feature/qa-03-pruefgate-rechte-policy` (RBAC-05 + RBAC-04 gemergt).
 ## 1. Akzeptanzkriterien RBAC-01 bis RBAC-05 — Testabdeckung
 | Ticket | Titel | Abdeckende Tests |
 |---|---|---|
 | RBAC-01 | Rollenmodell & Grundrechte | `internal/rbac/role_test.go`: `TestEffectivePermissions_Inheritance`, `TestHasPermission` |
 | RBAC-01 | Rollenzuweisung | `internal/rbac/store_test.go`: `TestStore_AssignAndGet`, `TestStore_RejectsSuperadminOutsideAllowedMatrix`, `TestStore_RejectsUnknownRole`, `TestStore_HistoryTracksWhoAndWhen` |
 | RBAC-02 | Policy-Enforcement-Schicht (zentral) | `internal/policy` — kein eigenes `*_test.go` in diesem Merge gefunden für `enforcer.go`/`store.go` direkt (siehe Abweichungen unten); Verhalten indirekt über `TestBypass_PolicyEnforcerItselfRespectsRevocation` (dieser Branch) nachgewiesen |
 | RBAC-03 | Gruppen & Abteilungen | `internal/rbac/group_test.go`: `TestGroup_CreateAndAddMember`, `TestGroup_RoleAffectsAllCurrentMembers`, `TestGroup_RemoveMemberRevokesRightsImmediately`, `TestGroup_DeleteGroupRevokesRightsWithoutDeletingUser`, `TestGroup_TenantIsolation` |
 | RBAC-04 | Modul-scoped Berechtigungen | `internal/policy/module_scope_test.go`: `TestAuthorizeForTenant_DeniesWhenModuleNotActivated`, `TestAuthorizeForTenant_BecomesActiveWithoutRestart`, `TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope` |
 | RBAC-05 | Rechte-Administrationsoberfläche | `internal/rbac/handler_test.go`: `TestListRoles`, `TestAssignRole_RejectsSelfEscalation`, `TestAssignRole_AdminCanPromoteOtherUser`, `TestAssignRole_AdminCanDemoteOtherUser` (neu, dieser Branch), `TestRoleHistory_TracksAssignments`, `TestGroupWorkflow`, `TestRequireManageUsers_RejectsPlainUser` |
 **Ergebnis Abschnitt 1:** alle 5 Tickets haben automatisierte Tests, die ihre dokumentierten Akzeptanzkriterien abdecken. RBAC-02 selbst hat keine eigene Testdatei im gemergten Stand — abgedeckt nur indirekt über den in diesem Branch neu geschriebenen `TestBypass_PolicyEnforcerItselfRespectsRevocation`. Als Abweichung festgehalten (Abschnitt 4).
 ## 2. Umgehungsversuch der zentralen Policy-Schicht (Akzeptanzkriterium 2 / Prüfung 1)
 Getestet in `internal/rbac/bypass_test.go`:
 - **`TestBypass_NoDirectWriteAPIOutsideStore`**: bestanden. `role_assignments` hat keine Schreib-API außerhalb von `Store.Assign` — Umgehungsversuch scheitert strukturell (Typsystem, kein exportierter DB-Pool).
 - **`TestBypass_PolicyEnforcerItselfRespectsRevocation`**: bestanden. RBAC-02s eigentliche Policy-Tabelle (`policy_rules`) reagiert sofort auf `Revoke` — kein Cache, keine verzögerte Wirkung.
 - **`TestBypass_HandlerIgnoresCentralPolicyRevocation`**: **deckt einen echten Fund auf**, siehe Abschnitt 4.
 ## 3. Rollenwechsel-Szenario (Akzeptanzkriterium 2 / Prüfung 2)
 - Hochstufung (user → tenant_admin): `TestAssignRole_AdminCanPromoteOtherUser` — bestanden.
 - Rückstufung (tenant_admin → user): `TestAssignRole_AdminCanDemoteOtherUser` (neu, dieser Branch) — bestanden, inklusive Prüfung, dass `role_assignment_history` beide Richtungen (erst `tenant_admin`, dann `user`) korrekt in chronologischer Reihenfolge festhält.
 - Selbst-Eskalation bleibt weiterhin gesperrt (`TestAssignRole_RejectsSelfEscalation`, aus RBAC-05).
 **Ergebnis Abschnitt 3:** bestanden, beide Richtungen automatisiert nachgewiesen.
 ## 4. Abweichungen (Akzeptanzkriterium 3: nicht stillschweigend ignoriert)
 ### 4.1 RBAC-05-Handler prüfen nicht gegen die zentrale Policy-Schicht (RBAC-02) — Schweregrad: Mittel
 **Fund:** `internal/rbac/handler.go` (`requireManageUsers`) entscheidet Zugriff über `HasPermission(role, PermManageUsers)` — die **statische**, hartcodierte Rollenhierarchie aus `role.go`. Es ruft nirgends `internal/policy.Enforcer.Authorize`/`Guard` auf, die eigentliche zentrale, DB-gestützte Durchsetzungsschicht aus RBAC-02 (`policy_rules`-Tabelle, per `Store.Grant`/`Revoke` administrierbar, versioniert in `policy_rule_changes`).
 **Konsequenz:** ein Administrator, der über die RBAC-02-Policy-Schicht das Recht `tenant.manage_users` von `tenant_admin` entzieht (`policy.Store.Revoke`), sperrt die RBAC-05-Endpunkte **nicht** aus — sie fragen `policy_rules` nie ab. Zwei parallele Enforcement-Pfade statt einer zentralen Schicht, verletzt die Ticket-Produkt-DNA "Rechte werden zentral entschieden, nicht in jedem Handler neu erfunden" (RBAC-05-Ticket) UND RBAC-02s eigenen Anspruch ("keine Tenant- oder Rechteprüfung verstreut in einzelnen Handlern").
 **Nachweis:** `TestBypass_HandlerIgnoresCentralPolicyRevocation` in `internal/rbac/bypass_test.go`.
 **Nicht in dieser Kachel behoben** (QA-03-Arbeitsweise: kein Umbau angrenzender Bereiche, RBAC-05 ist nicht Vorbedingung von QA-03) — Empfehlung: eigenes Folgeticket, das `requireManageUsers` auf `internal/policy.Guard`/`Enforcer.Authorize` umstellt.
 ### 4.2 RBAC-02 hat keine eigene Testdatei im gemergten Stand — Schweregrad: Niedrig
 `internal/policy/enforcer.go` und `store.go` (RBAC-02 selbst) haben keine `enforcer_test.go`/`store_test.go` im Merge-Ergebnis dieses Branches — nur `module_scope_test.go` (RBAC-04) prüft sie indirekt über `AuthorizeForTenant`. Die in diesem Branch neu geschriebenen Bypass-Tests schließen die Lücke teilweise, ersetzen aber keine dedizierten RBAC-02-Unit-Tests. Empfehlung: bei Gelegenheit nachziehen, kein blockierender Fund.
 ## 5. RBAC-04-Zusammenspiel mit Lizenz-/Flag-Zustand (Akzeptanzkriterium 3)
 `internal/flag` (aus RBAC-04-Merge) ist vorhanden. `internal/policy.Enforcer.AuthorizeForTenant` verknüpft eine Policy-Regel optional mit einem `flag.Service`-Eintrag (`ModuleScope.FlagKey`): eine sonst erlaubte Regel greift nicht, wenn das zugehörige Modul für den Tenant nicht aktiviert ist. `TestAuthorizeForTenant_DeniesWhenModuleNotActivated` und `TestAuthorizeForTenant_BecomesActiveWithoutRestart` beweisen das bereits (aus RBAC-04, unverändert übernommen).
 **Ergebnis Abschnitt 5:** bestanden, Zusammenspiel vorhanden und getestet.
 ## 6. Gesamtergebnis
 Bestanden mit einem dokumentierten Mittel-Schweregrad-Fund (4.1) und einem Niedrig-Schweregrad-Hinweis (4.2). Build-/Test-Ergebnis auf dem Testhost: siehe Abschnitt 7.
 ## 7. Build/Test-Ergebnis auf 131
 Durchgeführt 2026-08-29 auf root@192.168.1.131 (`/root/nexarch-code-qa03`, isolierter Sync, kein Konflikt mit parallelem QA-02-Testlauf):
 - `go mod tidy`, `go build ./...`, `go vet ./...` — alle sauber, keine Fehler.
 - `go test ./... -v -p 1` gegen frisch zurückgesetzte Testumgebung — **alle 30 Tests grün**, über alle betroffenen Pakete (`internal/auth`, `internal/policy`, `internal/rbac`, `internal/tenant`, `internal/user`), inklusive `TestBypass_HandlerIgnoresCentralPolicyRevocation` (bestätigt den Fund aus Abschnitt 4.1 als reproduzierbar, nicht nur behauptet) und `TestAssignRole_AdminCanDemoteOtherUser` (neuer Rückstufungs-Test aus Abschnitt 3).
 - Keine Regressionen in RBAC-01/02/03/04/05 durch den Merge.
 **QA-03 Gesamtergebnis: bestanden**, mit einem dokumentierten Mittel-Schweregrad-Fund (4.1, Empfehlung: Folgeticket) und einem Niedrig-Schweregrad-Hinweis (4.2).
@@ -0,0 +1,125 @@
 # QA-05 – Abnahme- & Compliance-Prüfung Core
 Welle 7. Voraussetzung: QA-02, QA-03, QA-04, QA-07, QA-08, QA-09, TEN-08,
 AUD-02, API-04, OPS-03, API-06, AUD-05, API-07, LIC-05, OPS-04, OPS-05,
 OPS-06, IAM-15 (alle Status "Fertig"). Branch:
 `feature/qa-05-abnahme-compliance-pruefung-core`, alle 15 zusätzlichen
 Vorbedingungs-Branches real gemergt (auf den bereits gemergten Ständen von
 QA-02/QA-04/QA-09, die selbst schon TEN-01..08/IAM-01..15/RBAC-01..05/
 API-01..10/AUD-01..05/OPS-01..06/LIC-01..05/CFG-01..04/SHL-01/TEN-01..08
 enthalten).
 ## 1. Konsolidierung der vorgelagerten Prüfgates (Akzeptanzkriterium 1)
 | Gate | Ergebnis | Fund(e) | Referenz |
 |---|---|---|---|
 | QA-02 (Identität & Mandanten) | bestanden | IAM-12/IAM-13-Typkollision (Hoch, behoben) | `docs/QA-02-PRUEFPROTOKOLL.md` |
 | QA-03 (Rechte & Policy) | bestanden | RBAC-05-Bypass-Fund (dokumentiert) | `docs/QA-03-PRUEFPROTOKOLL.md` |
 | QA-04 (Sicherheit/Pentest) | bestanden | 4 Testinfrastruktur-Bugs (Hoch/Mittel, alle behoben) | `docs/QA-04-PRUEFPROTOKOLL.md` |
 | QA-07 (Vertragstests) | bestanden | — | `internal/contracttest` |
 | QA-08 (Last-/Leistungstest) | bestanden | — | `internal/loadtest` |
 | QA-09 (Barrierefreiheit) | bestanden, 1 Restbefund terminiert | 4 WCAG-Verstöße (behoben), Testinfra-Bug (behoben) | `docs/QA-09-BARRIEREFREIHEITS-AUDIT.md` |
 Kein Widerspruch zwischen den Ergebnissen der sechs Gates festgestellt — alle
 betreffen unterschiedliche, nicht überlappende Prüfdimensionen (Identität,
 Rechte, Pentest, Verträge, Last, Barrierefreiheit) und keines widerruft ein
 Ergebnis eines anderen.
 ## 2. Prüfung 1: Stichprobenartiger Abgleich Audit-Log gegen tatsächlich durchgeführte Testaktionen
 **Durchgeführt, mit kritischem Befund.** Stichprobe: `internal/pentest`s
 `TestPentest_Policy_PrivilegeEscalationViaWrongRole` (führt reale
 `policy.Store.Grant`/`Revoke`-Aufrufe mit Actor `pentest-setup`/
 `pentest-cleanup` aus) auf 192.168.1.131 ausgeführt, anschließend
 `audit_events`-Tabelle direkt abgefragt:
 ```sql
 SELECT actor FROM audit_events WHERE actor LIKE '%pentest%' OR actor LIKE '%tenant_e2e%';
 -- 0 Zeilen
 ```
 **Befund (Schweregrad Hoch, NICHT in dieser Kachel behoben — siehe Begründung
 unten):** `internal/policy.Store.Grant`/`Revoke` (RBAC-02) schreiben
 ausschließlich in die modul-lokale `policy_rule_changes`-Tabelle, niemals in
 `internal/audit.Log` (AUD-01/AUD-02, `audit_events`-Tabelle). Dieselbe Lücke
 gilt für weitere sicherheitsrelevante Vorgänge, die geprüft wurden:
 Tenant-Lebenszyklus-Übergänge (`internal/tenant.Registry.transition`),
 Login-Fehlversuche/Sperren (`internal/lockout.Store`), Tenant-KEK-Rotation
 (`internal/kek.Store.RotateTenantKEK`) — keiner dieser Aufrufer ruft
 `internal/audit.Log.Record` auf. Der zentrale, unveränderliche Audit-Log
 (AUD-01/AUD-02) existiert, ist eigenständig getestet (`internal/audit/*_test.go`)
 und wird korrekt exportiert (AUD-03/AUD-04/AUD-05) — er wird nur bislang von
 keinem der produktiven Handler tatsächlich **befüllt**. Das passt zum
 architektonischen Zwischenstand: Core läuft noch als mehrere getrennte
 `*-devserver`-Binaries statt einer vereinheitlichten Server-Topologie (siehe
 Kommentar in `cmd/auditlog-devserver/main.go`: „echte Auth/RBAC ist noch
 nicht in die zentrale Server-Topologie verdrahtet"); dieselbe fehlende
 zentrale Verdrahtung betrifft die Audit-Log-Anbindung.
 **Warum nicht in dieser Kachel behoben:** Das Ticket verlangt „die kleinste
 Lösung, die alle Akzeptanzkriterien erfüllt. Kein Umbau angrenzender
 Bereiche." Das Verdrahten von `audit.Log.Record`-Aufrufen in JEDEN
 sicherheitsrelevanten Handler über RBAC-02/IAM-04/IAM-07/API-10 hinweg ist
 ein Umbau vieler bestehender Pakete, kein punktueller Fix — explizit nicht
 Bestandteil eines Abnahme-Gates, sondern eigener Entwicklungsaufwand.
 ## 3. Prüfung 2: Konsolidiertes Abnahmeprotokoll von zweiter Person gegengelesen
 **Nicht durchgeführt — Methodik-Abweichung, siehe unten.** In dieser
 autonomen Sitzung stand keine zweite Person zum Gegenlesen zur Verfügung.
 Ersatzweise wurde dieses Protokoll gegen die Originaldaten (Testergebnisse
 auf 192.168.1.131, `audit_events`-Abfrageergebnisse, Merge-Historie)
 zurückverifiziert, was ein Vier-Augen-Prinzip nicht ersetzt.
 ## 4. Prüfung 3: Freigabeentscheidung schriftlich mit Datum und Verantwortlicher
 **Freigabeentscheidung:** Bedingte Freigabe („bestanden mit Auflage").
 - **Datum:** 2026-08-29
 - **Verantwortlicher (dieser Durchlauf):** Claude (Sonnet 5), im Auftrag des
  Projektinhabers, autonome NEXARCH-Core-Sitzung
 - **Entscheidung:** Die sechs vorgelagerten Prüfgates (QA-02/03/04/07/08/09)
  sind konsolidiert und widerspruchsfrei bestanden (Akzeptanzkriterium 1
  erfüllt). Der Audit-Log-Abgleich (Prüfung 1) deckt einen echten,
  Schweregrad-Hoch-Befund auf: sicherheitsrelevante Vorgänge werden vom
  zentralen Audit-Log noch nicht erfasst (Akzeptanzkriterium 2 **nicht**
  erfüllt). Dieser Befund wird bewusst zurückgestellt statt in dieser Kachel
  behoben (Begründung siehe Abschnitt 2) — Akzeptanzkriterium 3 dadurch im
  Sinne von „bewusst mit Begründung zurückgestellt" erfüllt, nicht im Sinne
  von „behoben".
 - **Auflage vor QA-06 (finaler Pentest, Welle 8):** (a) Audit-Log-Verdrahtung
  in die sicherheitsrelevanten Handler von RBAC-02/IAM-04/IAM-07/API-10
  nachholen (eigenes Ticket, z. B. „AUD-06: Audit-Log-Verdrahtung in
  Core-Handler"), (b) dieses Protokoll von einer zweiten Person gegenlesen
  lassen (Prüfung 2 nachholen, analog zum QA-09-Restbefund „echter
  Bildschirmleser-Durchlauf").
 ## 5. Build/Test-Ergebnis
 ```
 go mod tidy / go build ./... / go vet ./...  -> clean
 go test ./... -p 1 -count=1                  -> 51/51 Pakete ok, 0 Fehlschläge
 ```
 Zwei reale Testinfrastruktur-Fehler beim vollen Merge+Testlauf gefunden und
 behoben (kein Produktionscode betroffen):
 - `internal/e2e`/`internal/pentest`: Migrationsanwendung tolerierte
  PostgreSQL-Fehlercode `42723` (`duplicate_function`, von AUD-02s
  `CREATE FUNCTION audit_events_prevent_mutation` bei zweiter Migrationsanwendung
  im selben Prozess) noch nicht — Codeliste um `42723` ergänzt.
 - `internal/loadtest`: dieselbe defer/`t.Cleanup`-Reihenfolge-Fehlerklasse wie
  in QA-04 gefunden — `TestLoad_ConnectionPoolingStaysUnderLimitWithManySimulatedTenants`
  schloss den Pool per `defer` VOR seiner `t.Cleanup`-Löschung von 200
  synthetischen Tenant-Zeilen, wodurch diese liegen blieben und
  `internal/migrate` im Volllauf mit 203 statt 3 erwarteten Ergebnissen
  fehlschlug. Behoben durch Umstellung auf `t.Cleanup` (wie in QA-04).
 ## 6. Gesamtergebnis
 **Bedingt bestanden.** Alle drei Pflichtprüfungen durchgeführt und
 protokolliert. Akzeptanzkriterium 1 (Konsolidierung) erfüllt.
 Akzeptanzkriterium 2 (Audit-Log-Abdeckung) **nicht erfüllt** — echter,
 dokumentierter Befund mit Schweregrad Hoch, bewusst zurückgestellt statt in
 dieser Kachel behoben (Begründung Abschnitt 2, Auflage Abschnitt 4).
 Akzeptanzkriterium 3 im Sinne „begründet zurückgestellt" erfüllt. Vor QA-06
 sind die beiden in Abschnitt 4 genannten Auflagen zu erfüllen.
@@ -1,17 +1,26 @@
 module gitea.perlbach24.de/scripte/nexarch
-go 1.22
+go 1.25.0
 require (
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/jackc/pgx/v5 v5.6.0
 	github.com/prometheus/client_golang v1.24.1
 	github.com/prometheus/client_model v0.6.2
 	github.com/prometheus/common v0.70.1
 	golang.org/x/crypto v0.17.0
 )
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
-	golang.org/x/sync v0.1.0 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	golang.org/x/text v0.14.0 // indirect
+	github.com/prometheus/procfs v0.21.1 // indirect
 	golang.org/x/sync v0.22.0 // indirect
 	golang.org/x/sys v0.47.0 // indirect
 	golang.org/x/text v0.40.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
 )
@@ -1,8 +1,14 @@
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/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/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 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=
@@ -11,19 +17,37 @@ github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
 github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU=
 github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY=
 github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc=
 github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
 github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
 go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
 golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
 golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
 golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
@@ -0,0 +1,194 @@
 package alerting
 import (
 	"context"
 	"fmt"
 	"sort"
 	"strings"
 	"time"
 	dto "github.com/prometheus/client_model/go"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
 )
 // DefaultDebounceInterval: wiederholte Alarmierung für denselben
 // anhaltenden Zustand ist gedrosselt (Akzeptanzkriterium 3) — 15 Minuten
 // ist ein üblicher Kompromiss zwischen "schnell genug informiert" und
 // "kein Alarm-Spam bei dauerhaft überschrittenem Wert".
 const DefaultDebounceInterval = 15 * time.Minute
 // AlertChannel ist der CFG-02-Kanal, über den Schwellwert-Alarme zugestellt
 // werden — ein eigener Kanalname, damit Zustellregeln/-vorlagen (CFG-03)
 // unabhängig von anderen Benachrichtigungsarten konfiguriert werden können.
 const AlertChannel = "alert"
 // Evaluator prüft konfigurierte Regeln gegen aktuell gesammelte Metriken
 // (aus internal/metrics.Aggregator.Gather) und löst bei Überschreitung eine
 // Benachrichtigung über CFG-02 aus (Akzeptanzkriterium 2), gedrosselt je
 // Regel+Zeitreihe (Akzeptanzkriterium 3).
 type Evaluator struct {
 	rules      *RuleStore
 	debounce   *debounceStore
 	dispatcher *notify.Dispatcher
 	interval   time.Duration
 }
 func NewEvaluator(rules *RuleStore, dispatcher *notify.Dispatcher, debouncePool *pgxpool.Pool, interval time.Duration) *Evaluator {
 	if interval <= 0 {
 		interval = DefaultDebounceInterval
 	}
 	return &Evaluator{
 		rules:      rules,
 		debounce:   &debounceStore{pool: debouncePool},
 		dispatcher: dispatcher,
 		interval:   interval,
 	}
 }
 // FiredAlert beschreibt einen tatsächlich ausgelösten (nicht gedrosselten)
 // Alarm — fürs Testen/Logging, nicht Teil des öffentlichen Zustellwegs.
 type FiredAlert struct {
 	RuleID     string
 	MetricName string
 	Value      float64
 	Threshold  float64
 	Labels     map[string]string
 	Skipped    bool // true, wenn wegen Drosselung NICHT tatsaechlich zugestellt
 }
 // Evaluate prüft alle konfigurierten Regeln gegen families (Akzeptanzkriterium 1).
 // Für jede Zeitreihe, die eine Regel verletzt, wird — sofern nicht gedrosselt
 // — eine Benachrichtigung mit Metrik/Wert/Schwellwert/Labels (Tenant/Modul,
 // falls als Label vorhanden) über CFG-02 eingereiht (Akzeptanzkriterium 2).
 func (e *Evaluator) Evaluate(ctx context.Context, families []*dto.MetricFamily) ([]FiredAlert, error) {
 	rules, err := e.rules.ListRules(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("regeln laden: %w", err)
 	}
 	if len(rules) == 0 {
 		return nil, nil
 	}
 	byName := make(map[string]*dto.MetricFamily, len(families))
 	for _, f := range families {
 		if f.Name != nil {
 			byName[*f.Name] = f
 		}
 	}
 	var fired []FiredAlert
 	for _, rule := range rules {
 		family, ok := byName[rule.MetricName]
 		if !ok {
 			continue // Metrik (noch) nicht vorhanden -> keine Aussage moeglich, kein Fehler.
 		}
 		for _, m := range family.Metric {
 			labels := labelMap(m)
 			if !matchesFilter(labels, rule.LabelFilters) {
 				continue
 			}
 			value, ok := metricValue(m)
 			if !ok {
 				continue
 			}
 			if !violates(rule, value) {
 				continue
 			}
 			ruleKey := ruleKeyFor(rule.ID, labels)
 			allowed, err := e.debounce.shouldFire(ctx, ruleKey, e.interval.Seconds())
 			if err != nil {
 				return fired, fmt.Errorf("drosselung pruefen: %w", err)
 			}
 			alert := FiredAlert{
 				RuleID: rule.ID, MetricName: rule.MetricName, Value: value,
 				Threshold: rule.Threshold, Labels: labels, Skipped: !allowed,
 			}
 			fired = append(fired, alert)
 			if !allowed {
 				continue
 			}
 			payload := map[string]any{
 				"metric":      rule.MetricName,
 				"value":       value,
 				"threshold":   rule.Threshold,
 				"comparison":  string(rule.Comparison),
 				"description": rule.Description,
 				"labels":      labels,
 			}
 			if _, err := e.dispatcher.Enqueue(ctx, AlertChannel, rule.Recipient, payload); err != nil {
 				return fired, fmt.Errorf("alarm einreihen: %w", err)
 			}
 		}
 	}
 	return fired, nil
 }
 func violates(rule Rule, value float64) bool {
 	switch rule.Comparison {
 	case ComparisonGreaterThan:
 		return value > rule.Threshold
 	case ComparisonLessThan:
 		return value < rule.Threshold
 	default:
 		return false
 	}
 }
 func labelMap(m *dto.Metric) map[string]string {
 	out := make(map[string]string, len(m.Label))
 	for _, l := range m.Label {
 		if l.Name != nil && l.Value != nil {
 			out[*l.Name] = *l.Value
 		}
 	}
 	return out
 }
 func matchesFilter(labels, filter map[string]string) bool {
 	for k, v := range filter {
 		if labels[k] != v {
 			return false
 		}
 	}
 	return true
 }
 func metricValue(m *dto.Metric) (float64, bool) {
 	switch {
 	case m.Gauge != nil && m.Gauge.Value != nil:
 		return *m.Gauge.Value, true
 	case m.Counter != nil && m.Counter.Value != nil:
 		return *m.Counter.Value, true
 	case m.Untyped != nil && m.Untyped.Value != nil:
 		return *m.Untyped.Value, true
 	default:
 		return 0, false
 	}
 }
 // ruleKeyFor macht die Drosselung unabhaengig je Regel UND je konkreter
 // Zeitreihe (z. B. verschiedene Tenants/Module derselben Metrik loesen
 // unabhaengig voneinander aus, siehe Migrationskommentar).
 func ruleKeyFor(ruleID string, labels map[string]string) string {
 	keys := make([]string, 0, len(labels))
 	for k := range labels {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 	var b strings.Builder
 	b.WriteString(ruleID)
 	for _, k := range keys {
 		b.WriteString("|")
 		b.WriteString(k)
 		b.WriteString("=")
 		b.WriteString(labels[k])
 	}
 	return b.String()
 }
@@ -0,0 +1,233 @@
 package alerting
 import (
 	"context"
 	"os"
 	"strings"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	dto "github.com/prometheus/client_model/go"
 	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
 )
 func setupTest(t *testing.T) (*RuleStore, *notify.Dispatcher, *pgxpool.Pool, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS alert_rules (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), metric_name TEXT NOT NULL,
 			comparison TEXT NOT NULL CHECK (comparison IN ('gt','lt')), threshold DOUBLE PRECISION NOT NULL,
 			label_filters JSONB NOT NULL DEFAULT '{}'::jsonb, recipient TEXT NOT NULL,
 			description TEXT NOT NULL DEFAULT '', created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS alert_debounce_state (
 			rule_key TEXT PRIMARY KEY, last_fired_at TIMESTAMPTZ NOT NULL
 		);
 		CREATE TABLE IF NOT EXISTS notification_jobs (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
 			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending', attempts INT NOT NULL DEFAULT 0,
 			max_attempts INT NOT NULL DEFAULT 5, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM alert_rules`)
 		_, _ = pool.Exec(ctx, `DELETE FROM alert_debounce_state`)
 		_, _ = pool.Exec(ctx, `DELETE FROM notification_jobs`)
 		pool.Close()
 	}
 	return NewRuleStore(pool), notify.NewDispatcher(pool), pool, cleanup
 }
 func gaugeFamily(name string, labels map[string]string, value float64) *dto.MetricFamily {
 	pairs := make([]*dto.LabelPair, 0, len(labels))
 	for k, v := range labels {
 		k, v := k, v
 		pairs = append(pairs, &dto.LabelPair{Name: &k, Value: &v})
 	}
 	n := name
 	return &dto.MetricFamily{
 		Name: &n,
 		Metric: []*dto.Metric{
 			{Label: pairs, Gauge: &dto.Gauge{Value: &value}},
 		},
 	}
 }
 // Akzeptanzkriterium 1 + 2 / Pruefung 1 + 2: Überschreitung löst eine
 // Benachrichtigung mit vollständigem Inhalt (Metrik/Tenant/Modul) aus.
 func TestEvaluate_FiresAlertOnThresholdExceeded(t *testing.T) {
 	rules, dispatcher, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	rule, err := rules.CreateRule(ctx, Rule{
 		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
 		Recipient: "ops@acme.example", Description: "Fehlerrate zu hoch",
 	})
 	if err != nil {
 		t.Fatalf("create rule: %v", err)
 	}
 	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
 	families := []*dto.MetricFamily{
 		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme", "module": "dms"}, 0.12),
 	}
 	fired, err := eval.Evaluate(ctx, families)
 	if err != nil {
 		t.Fatalf("evaluate: %v", err)
 	}
 	if len(fired) != 1 || fired[0].Skipped {
 		t.Fatalf("erwartet genau 1 tatsaechlich ausgeloesten alarm, habe %+v", fired)
 	}
 	if fired[0].RuleID != rule.ID {
 		t.Fatalf("rule id = %q, want %q", fired[0].RuleID, rule.ID)
 	}
 	// Pruefung 2: Benachrichtigungsinhalt vollstaendig (Metrik/Tenant/Modul).
 	var payloadJSON []byte
 	if err := pool.QueryRow(ctx, `SELECT payload FROM notification_jobs LIMIT 1`).Scan(&payloadJSON); err != nil {
 		t.Fatalf("notification_jobs lesen: %v", err)
 	}
 	payload := string(payloadJSON)
 	for _, want := range []string{`"metric"`, `nexarch_core_error_rate`, `"tenant"`, `"acme"`, `"module"`, `"dms"`} {
 		if !strings.Contains(payload, want) {
 			t.Errorf("payload enthaelt nicht %q: %s", want, payload)
 		}
 	}
 }
 func TestEvaluate_DoesNotFireBelowThreshold(t *testing.T) {
 	rules, dispatcher, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := rules.CreateRule(ctx, Rule{
 		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
 		Recipient: "ops@acme.example",
 	}); err != nil {
 		t.Fatalf("create rule: %v", err)
 	}
 	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
 	families := []*dto.MetricFamily{
 		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme"}, 0.01),
 	}
 	fired, err := eval.Evaluate(ctx, families)
 	if err != nil {
 		t.Fatalf("evaluate: %v", err)
 	}
 	if len(fired) != 0 {
 		t.Fatalf("erwartet keinen alarm unterhalb des schwellwerts, habe %+v", fired)
 	}
 }
 // Akzeptanzkriterium 3 / Pruefung 3: anhaltende Überschreitung erzeugt NICHT
 // bei jeder Messung eine neue Benachrichtigung.
 func TestEvaluate_DebouncesRepeatedFiring(t *testing.T) {
 	rules, dispatcher, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := rules.CreateRule(ctx, Rule{
 		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
 		Recipient: "ops@acme.example",
 	}); err != nil {
 		t.Fatalf("create rule: %v", err)
 	}
 	// Langes Debounce-Intervall: der zweite Evaluate-Lauf (simuliert die
 	// naechste Messung bei anhaltend ueberschrittenem Wert) darf keinen
 	// weiteren Job einreihen.
 	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
 	families := []*dto.MetricFamily{
 		gaugeFamily("nexarch_core_error_rate", map[string]string{"tenant": "acme"}, 0.5),
 	}
 	first, err := eval.Evaluate(ctx, families)
 	if err != nil {
 		t.Fatalf("erster evaluate-lauf: %v", err)
 	}
 	if len(first) != 1 || first[0].Skipped {
 		t.Fatalf("erster lauf haette feuern muessen, habe %+v", first)
 	}
 	second, err := eval.Evaluate(ctx, families)
 	if err != nil {
 		t.Fatalf("zweiter evaluate-lauf: %v", err)
 	}
 	if len(second) != 1 || !second[0].Skipped {
 		t.Fatalf("zweiter lauf haette gedrosselt werden muessen, habe %+v", second)
 	}
 	var count int
 	if err := pool.QueryRow(ctx, `SELECT count(*) FROM notification_jobs`).Scan(&count); err != nil {
 		t.Fatalf("notification_jobs zaehlen: %v", err)
 	}
 	if count != 1 {
 		t.Fatalf("erwartet genau 1 eingereihten job trotz zwei ueberschreitenden messungen, habe %d", count)
 	}
 }
 // Verschiedene Zeitreihen derselben Regel (unterschiedlicher Tenant) werden
 // unabhaengig voneinander gedrosselt.
 func TestEvaluate_DebouncesIndependentlyPerLabelSet(t *testing.T) {
 	rules, dispatcher, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	if _, err := rules.CreateRule(ctx, Rule{
 		MetricName: "nexarch_core_error_rate", Comparison: ComparisonGreaterThan, Threshold: 0.05,
 		Recipient: "ops@acme.example",
 	}); err != nil {
 		t.Fatalf("create rule: %v", err)
 	}
 	eval := NewEvaluator(rules, dispatcher, pool, time.Hour)
 	families := []*dto.MetricFamily{
 		{
 			Name: strPtr("nexarch_core_error_rate"),
 			Metric: []*dto.Metric{
 				metricWithLabel("tenant", "acme", 0.5),
 				metricWithLabel("tenant", "beta", 0.6),
 			},
 		},
 	}
 	fired, err := eval.Evaluate(ctx, families)
 	if err != nil {
 		t.Fatalf("evaluate: %v", err)
 	}
 	if len(fired) != 2 {
 		t.Fatalf("erwartet 2 unabhaengige alarme (verschiedene tenants), habe %d", len(fired))
 	}
 	for _, a := range fired {
 		if a.Skipped {
 			t.Fatalf("beide tenants sollten beim ersten mal feuern, habe %+v", a)
 		}
 	}
 }
 func metricWithLabel(name, value string, gaugeValue float64) *dto.Metric {
 	n, v := name, value
 	return &dto.Metric{Label: []*dto.LabelPair{{Name: &n, Value: &v}}, Gauge: &dto.Gauge{Value: &gaugeValue}}
 }
 func strPtr(s string) *string { return &s }
@@ -0,0 +1,132 @@
 // Package alerting implementiert Core OPS-05: schwellwertbasierte
 // Alarmierung auf den aus OPS-03 aggregierten Metriken, Zustellung über den
 // Core-Benachrichtigungs-Dispatcher (CFG-02). Der Alertmanager-Gedanke von
 // Prometheus/Grafana, aber auf das Nötigste reduziert (Schwellwert, Ziel,
 // Drosselung) — keine eigene Ausdruckssprache.
 package alerting
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Comparison legt fest, ob ein Schwellwert nach oben oder unten überwacht
 // wird — bewusst nur zwei Operatoren, keine eigene Ausdruckssprache
 // (Ticket-Produkt-DNA).
 type Comparison string
 const (
 	ComparisonGreaterThan Comparison = "gt"
 	ComparisonLessThan    Comparison = "lt"
 )
 // Rule ist eine Schwellwert-Regel auf einer beliebigen aggregierten Metrik
 // (Akzeptanzkriterium 1). LabelFilters schränkt optional auf bestimmte
 // Label-Werte ein (z. B. tenant/module), leer = alle Zeitreihen der Metrik.
 type Rule struct {
 	ID           string
 	MetricName   string
 	Comparison   Comparison
 	Threshold    float64
 	LabelFilters map[string]string
 	Recipient    string
 	Description  string
 }
 // RuleStore verwaltet Alert-Regeln in der zentralen Registry-DB.
 type RuleStore struct {
 	pool *pgxpool.Pool
 }
 func NewRuleStore(pool *pgxpool.Pool) *RuleStore {
 	return &RuleStore{pool: pool}
 }
 // CreateRule legt eine neue Schwellwert-Regel an (Akzeptanzkriterium 1).
 func (s *RuleStore) CreateRule(ctx context.Context, r Rule) (Rule, error) {
 	if r.MetricName == "" || r.Recipient == "" {
 		return Rule{}, errors.New("alerting: metricName und recipient duerfen nicht leer sein")
 	}
 	if r.Comparison != ComparisonGreaterThan && r.Comparison != ComparisonLessThan {
 		return Rule{}, fmt.Errorf("alerting: unbekannter comparison-operator %q", r.Comparison)
 	}
 	if r.LabelFilters == nil {
 		r.LabelFilters = map[string]string{}
 	}
 	filtersJSON, err := json.Marshal(r.LabelFilters)
 	if err != nil {
 		return Rule{}, fmt.Errorf("label-filter serialisieren: %w", err)
 	}
 	err = s.pool.QueryRow(ctx, `
 		INSERT INTO alert_rules (metric_name, comparison, threshold, label_filters, recipient, description)
 		VALUES ($1, $2, $3, $4, $5, $6)
 		RETURNING id
 	`, r.MetricName, string(r.Comparison), r.Threshold, filtersJSON, r.Recipient, r.Description).Scan(&r.ID)
 	if err != nil {
 		return Rule{}, fmt.Errorf("regel speichern: %w", err)
 	}
 	return r, nil
 }
 // ListRules liefert alle konfigurierten Regeln — Grundlage für Evaluate.
 func (s *RuleStore) ListRules(ctx context.Context) ([]Rule, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT id, metric_name, comparison, threshold, label_filters, recipient, description
 		FROM alert_rules ORDER BY created_at
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("regeln auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Rule
 	for rows.Next() {
 		var r Rule
 		var comparison string
 		var filtersJSON []byte
 		if err := rows.Scan(&r.ID, &r.MetricName, &comparison, &r.Threshold, &filtersJSON, &r.Recipient, &r.Description); err != nil {
 			return nil, fmt.Errorf("regel lesen: %w", err)
 		}
 		r.Comparison = Comparison(comparison)
 		if err := json.Unmarshal(filtersJSON, &r.LabelFilters); err != nil {
 			return nil, fmt.Errorf("label-filter lesen: %w", err)
 		}
 		out = append(out, r)
 	}
 	return out, rows.Err()
 }
 // DeleteRule entfernt eine Regel.
 func (s *RuleStore) DeleteRule(ctx context.Context, id string) error {
 	_, err := s.pool.Exec(ctx, `DELETE FROM alert_rules WHERE id = $1`, id)
 	if err != nil {
 		return fmt.Errorf("regel loeschen: %w", err)
 	}
 	return nil
 }
 // debounceStore kapselt die Drosselungs-Zustandstabelle (Akzeptanzkriterium 3).
 type debounceStore struct {
 	pool *pgxpool.Pool
 }
 // shouldFire prueft, ob seit dem letzten Alarm fuer ruleKey mindestens
 // interval vergangen ist — atomar ueber eine bedingte UPDATE/INSERT-
 // Sequenz, damit zwei gleichzeitige Evaluate-Laeufe (z. B. bei mehreren
 // Core-Instanzen) nicht beide gleichzeitig alarmieren.
 func (d *debounceStore) shouldFire(ctx context.Context, ruleKey string, intervalSeconds float64) (bool, error) {
 	tag, err := d.pool.Exec(ctx, `
 		INSERT INTO alert_debounce_state (rule_key, last_fired_at) VALUES ($1, now())
 		ON CONFLICT (rule_key) DO UPDATE SET last_fired_at = now()
 		WHERE alert_debounce_state.last_fired_at <= now() - ($2 * interval '1 second')
 	`, ruleKey, intervalSeconds)
 	if err != nil {
 		return false, fmt.Errorf("drosselungszustand pruefen: %w", err)
 	}
 	return tag.RowsAffected() == 1, nil
 }
@@ -12,6 +12,7 @@ import (
 type Server struct {
 	mux    *http.ServeMux
 	issuer *auth.TokenIssuer
 	routes []string
 }
 func NewServer(issuer *auth.TokenIssuer) *Server {
@@ -24,9 +25,20 @@ func NewServer(issuer *auth.TokenIssuer) *Server {
 // bestehende nicht (Akzeptanzkriterium 1 / Pruefung 3).
 func (s *Server) Handle(version, pattern string, h http.HandlerFunc) {
 	full := "/api/" + version + pattern
 	s.routes = append(s.routes, full)
 	s.mux.HandleFunc(full, loggingMiddleware(authAndTenantContext(s.issuer, h)))
 }
 // RegisteredPaths liefert alle ueber Handle/HandleV1 tatsaechlich
 // registrierten Pfade — die einzige Quelle der Wahrheit fuer den
 // Drift-Abgleich mit dem OpenAPI-Dokument (API-04, siehe internal/openapi).
 // Rein additive Buchfuehrung, keine Verhaltensaenderung von Handle.
 func (s *Server) RegisteredPaths() []string {
 	out := make([]string, len(s.routes))
 	copy(out, s.routes)
 	return out
 }
 // HandleV1 ist die Kurzform fuer die aktuelle Hauptversion.
 func (s *Server) HandleV1(pattern string, h http.HandlerFunc) {
 	s.Handle("v1", pattern, h)
@@ -0,0 +1,97 @@
 package audit
 import (
 	"context"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupAppendOnlyTest(t *testing.T) (*Log, *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 audit_events (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
 			actor TEXT NOT NULL CHECK (actor <> ''),
 			action TEXT NOT NULL CHECK (action <> ''),
 			target TEXT NOT NULL,
 			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
 		);
 		CREATE OR REPLACE FUNCTION audit_events_prevent_mutation() RETURNS TRIGGER AS $$
 		BEGIN
 			RAISE EXCEPTION 'audit_events ist append-only: % ist nicht erlaubt', TG_OP;
 		END;
 		$$ LANGUAGE plpgsql;
 		DROP TRIGGER IF EXISTS audit_events_no_update ON audit_events;
 		CREATE TRIGGER audit_events_no_update
 			BEFORE UPDATE ON audit_events
 			FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
 		DROP TRIGGER IF EXISTS audit_events_no_delete ON audit_events;
 		CREATE TRIGGER audit_events_no_delete
 			BEFORE DELETE ON audit_events
 			FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		pool.Close()
 	}
 	return NewLog(pool), pool, cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 1: direkter UPDATE/DELETE-Versuch wird von
 // der Datenbank abgewiesen.
 func TestAppendOnly_RejectsUpdateAndDelete(t *testing.T) {
 	log, pool, cleanup := setupAppendOnlyTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	// Append-only bedeutet: dieser Testeintrag kann NIE wieder geloescht
 	// werden, auch nicht vom Test selbst. Eindeutiger Tenant-Slug pro Lauf,
 	// damit wiederholte Testlaeufe sich nicht gegenseitig die Zaehlung
 	// verfaelschen.
 	tenantSlug := fmt.Sprintf("test_appendonly_%d", time.Now().UnixNano())
 	if err := log.Record(ctx, Event{
 		TenantSlug: tenantSlug,
 		Actor:      "alice",
 		Action:     "test.event",
 		Target:     "x",
 	}); err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	_, err := pool.Exec(ctx, `UPDATE audit_events SET actor = 'mallory' WHERE tenant_slug = $1`, tenantSlug)
 	if err == nil {
 		t.Fatal("erwartet fehler bei UPDATE auf audit_events, habe nil")
 	}
 	_, err = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug = $1`, tenantSlug)
 	if err == nil {
 		t.Fatal("erwartet fehler bei DELETE auf audit_events, habe nil")
 	}
 	count, err := log.CountByTenant(ctx, tenantSlug)
 	if err != nil {
 		t.Fatalf("count: %v", err)
 	}
 	if count != 1 {
 		t.Fatalf("eintrag haette trotz fehlgeschlagener update/delete-versuche erhalten bleiben muessen, count=%d", count)
 	}
 }
@@ -3,8 +3,10 @@ package audit
 import (
 	"context"
 	"errors"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
@@ -48,8 +50,13 @@ func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
 	defer cleanup()
 	ctx := context.Background()
 	// Seit AUD-02 ist audit_events append-only — Zeilen koennen nie wieder
 	// geloescht werden (auch nicht vom Test-Cleanup). Eindeutiger Slug pro
 	// Lauf, damit wiederholte Testlaeufe die Zaehlung nicht verfaelschen.
 	tenantSlug := "test_acme_" + fmt.Sprint(time.Now().UnixNano())
 	err := log.Record(ctx, Event{
-		TenantSlug: "test_acme",
+		TenantSlug: tenantSlug,
 		Actor:      "alice@example.com",
 		Action:     "iam.login_failed",
 		Target:     "user:alice@example.com",
@@ -59,7 +66,7 @@ func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
 		t.Fatalf("record: %v", err)
 	}
-	count, err := log.CountByTenant(ctx, "test_acme")
+	count, err := log.CountByTenant(ctx, tenantSlug)
 	if err != nil {
 		t.Fatalf("count: %v", err)
 	}
@@ -69,8 +76,8 @@ func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
 	var actor, action, target string
 	if err := pool.QueryRow(ctx, `
-		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
+		SELECT actor, action, target FROM audit_events WHERE tenant_slug = $1
-	`).Scan(&actor, &action, &target); err != nil {
+	`, tenantSlug).Scan(&actor, &action, &target); err != nil {
 		t.Fatalf("eintrag lesen: %v", err)
 	}
 	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
@@ -0,0 +1,120 @@
 package audit
 import (
 	"context"
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var (
 	ErrConfirmationNotFound = errors.New("audit: bestaetigungsvorgang nicht gefunden")
 	ErrAlreadyDecided       = errors.New("audit: bestaetigungsvorgang wurde bereits entschieden")
 	ErrSameActor            = errors.New("audit: bestaetigung muss von einer anderen person als der anfordernden erfolgen")
 	ErrInvalidCode          = errors.New("audit: bestaetigungscode ungueltig")
 )
 type ConfirmationStatus string
 const (
 	StatusPending   ConfirmationStatus = "pending"
 	StatusConfirmed ConfirmationStatus = "confirmed"
 )
 // FourEyes implementiert das Vier-Augen-Prinzip fuer sicherheitskritische
 // Entscheidungen (Akzeptanzkriterium 2) nach dem archivdms-Vorbild:
 // FOR-UPDATE-Lock gegen Race-Bedingungen bei paralleler Bestaetigung,
 // Timing-safe Vergleich des Bestaetigungscodes (Akzeptanzkriterium 3).
 type FourEyes struct {
 	pool *pgxpool.Pool
 }
 func NewFourEyes(pool *pgxpool.Pool) *FourEyes {
 	return &FourEyes{pool: pool}
 }
 // Request legt einen neuen, zu bestaetigenden Vorgang an (z.B. Loeschbestaetigung,
 // Rechtevergabe) und liefert einen einmaligen Klartext-Code, der ausserhalb
 // dieses Systems (z.B. per E-Mail) an eine ZWEITE Person uebermittelt wird —
 // niemals der anfordernden Person selbst.
 func (f *FourEyes) Request(ctx context.Context, action, target, requestedBy string) (id, code string, err error) {
 	code, err = generateCode()
 	if err != nil {
 		return "", "", fmt.Errorf("bestaetigungscode erzeugen: %w", err)
 	}
 	hash := hashCode(code)
 	err = f.pool.QueryRow(ctx, `
 		INSERT INTO security_confirmations (action, target, requested_by, code_hash, status)
 		VALUES ($1, $2, $3, $4, 'pending')
 		RETURNING id
 	`, action, target, requestedBy, hash).Scan(&id)
 	if err != nil {
 		return "", "", fmt.Errorf("bestaetigungsvorgang anlegen: %w", err)
 	}
 	return id, code, nil
 }
 // Confirm bestaetigt einen Vorgang. confirmedBy MUSS sich von der
 // anfordernden Person unterscheiden (echtes Vier-Augen-Prinzip). Der Zugriff
 // auf die Zeile erfolgt mit FOR UPDATE, damit zwei gleichzeitige
 // Bestaetigungsversuche serialisiert werden und niemals beide durchgehen
 // (Akzeptanzkriterium 2 / Pruefung 2).
 func (f *FourEyes) Confirm(ctx context.Context, id, confirmedBy, code string) error {
 	tx, err := f.pool.Begin(ctx)
 	if err != nil {
 		return fmt.Errorf("transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	var requestedBy, status string
 	var codeHash []byte
 	err = tx.QueryRow(ctx, `
 		SELECT requested_by, status, code_hash FROM security_confirmations
 		WHERE id = $1 FOR UPDATE
 	`, id).Scan(&requestedBy, &status, &codeHash)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ErrConfirmationNotFound
 		}
 		return fmt.Errorf("bestaetigungsvorgang lesen: %w", err)
 	}
 	if status != string(StatusPending) {
 		return ErrAlreadyDecided
 	}
 	if confirmedBy == requestedBy {
 		return ErrSameActor
 	}
 	if !timingSafeEqual(hashCode(code), codeHash) {
 		return ErrInvalidCode
 	}
 	if _, err := tx.Exec(ctx, `
 		UPDATE security_confirmations
 		SET status = 'confirmed', confirmed_by = $2, confirmed_at = now()
 		WHERE id = $1
 	`, id, confirmedBy); err != nil {
 		return fmt.Errorf("bestaetigung speichern: %w", err)
 	}
 	return tx.Commit(ctx)
 }
 func generateCode() (string, error) {
 	buf := make([]byte, 16)
 	if _, err := rand.Read(buf); err != nil {
 		return "", err
 	}
 	return hex.EncodeToString(buf), nil
 }
 func hashCode(code string) []byte {
 	sum := sha256.Sum256([]byte(code))
 	return sum[:]
 }
@@ -0,0 +1,128 @@
 package audit
 import (
 	"context"
 	"errors"
 	"os"
 	"sync"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupFourEyesTest(t *testing.T) (*FourEyes, 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 security_confirmations (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 			action TEXT NOT NULL,
 			target TEXT NOT NULL,
 			requested_by TEXT NOT NULL,
 			code_hash BYTEA NOT NULL,
 			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'confirmed', 'rejected')),
 			confirmed_by TEXT,
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			confirmed_at TIMESTAMPTZ
 		)`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM security_confirmations WHERE action LIKE 'test.%'`)
 		pool.Close()
 	}
 	return NewFourEyes(pool), cleanup
 }
 func TestFourEyes_RequestAndConfirm(t *testing.T) {
 	fe, cleanup := setupFourEyesTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
 	if err != nil {
 		t.Fatalf("request: %v", err)
 	}
 	if err := fe.Confirm(ctx, id, "bob@example.com", code); err != nil {
 		t.Fatalf("confirm: %v", err)
 	}
 }
 func TestFourEyes_RejectsSameActor(t *testing.T) {
 	fe, cleanup := setupFourEyesTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
 	if err != nil {
 		t.Fatalf("request: %v", err)
 	}
 	if err := fe.Confirm(ctx, id, "alice@example.com", code); !errors.Is(err, ErrSameActor) {
 		t.Fatalf("erwartet ErrSameActor, habe %v", err)
 	}
 }
 func TestFourEyes_RejectsWrongCode(t *testing.T) {
 	fe, cleanup := setupFourEyesTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	id, _, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
 	if err != nil {
 		t.Fatalf("request: %v", err)
 	}
 	if err := fe.Confirm(ctx, id, "bob@example.com", "falscher-code"); !errors.Is(err, ErrInvalidCode) {
 		t.Fatalf("erwartet ErrInvalidCode, habe %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: FOR-UPDATE-Lock unter parallelen
 // Anfragen race-frei — von zwei gleichzeitigen Bestaetigungsversuchen fuer
 // denselben Vorgang darf genau einer durchgehen.
 func TestFourEyes_ConcurrentConfirmIsRaceFree(t *testing.T) {
 	fe, cleanup := setupFourEyesTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	id, code, err := fe.Request(ctx, "test.tenant_delete", "tenant:acme", "alice@example.com")
 	if err != nil {
 		t.Fatalf("request: %v", err)
 	}
 	var wg sync.WaitGroup
 	results := make([]error, 2)
 	confirmers := []string{"bob@example.com", "carol@example.com"}
 	for i := 0; i < 2; i++ {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
 			results[i] = fe.Confirm(ctx, id, confirmers[i], code)
 		}(i)
 	}
 	wg.Wait()
 	successCount := 0
 	for _, err := range results {
 		if err == nil {
 			successCount++
 		} else if !errors.Is(err, ErrAlreadyDecided) {
 			t.Fatalf("unerwarteter fehler: %v", err)
 		}
 	}
 	if successCount != 1 {
 		t.Fatalf("erwartet genau eine erfolgreiche bestaetigung, habe %d", successCount)
 	}
 }
@@ -0,0 +1,41 @@
 package audit
 import "context"
 // AuditLogObjectType ist der Objekttyp-Bezeichner, unter dem Audit-Log-
 // Eintraege bei der Archive-Retention-Engine registriert werden
 // (Akzeptanzkriterium 1).
 const AuditLogObjectType = "audit_log_entry"
 // DefaultAuditRetentionYears ist die GoBD-Buchungsbeleg-Frist (Akzeptanz-
 // kriterium 2) — Default, pro Tenant ueberschreibbar sofern rechtlich
 // zulaessig. Die eigentliche Ueberschreibung/Durchsetzung liegt vollstaendig
 // bei Archive, siehe AuditRetentionTenantOverridable.
 const DefaultAuditRetentionYears = 10
 // AuditRetentionTenantOverridable erlaubt Archive, die Default-Frist pro
 // Tenant zu ueberschreiben — Core trifft dabei keine rechtliche Entscheidung,
 // sondern erlaubt Archive lediglich, so eine Entscheidung zuzulassen.
 const AuditRetentionTenantOverridable = true
 // RetentionRegistrar ist der Modul-Adapter-Vertrag aus Archive RET-05, wie
 // Core ihn konsumiert. Die tatsaechliche Implementierung lebt im
 // Archive-Modul (RET-01/RET-02/RET-05) und existiert zum Zeitpunkt dieser
 // Kachel noch nicht als Code — Core kennt nur diese Schnittstelle.
 //
 // WICHTIG: Core implementiert absichtlich KEINE eigene Loeschlogik fuer
 // Audit-Eintraege (Akzeptanzkriterium 3). Dieses Paket enthaelt keinen
 // Delete-Codepfad fuer audit_events ausser dem durch AUD-02 technisch
 // unterbundenen — die tatsaechliche Loeschung/Aufbewahrungssperre erfolgt
 // ausschliesslich innerhalb von Archive, ausserhalb dieses Prozesses.
 type RetentionRegistrar interface {
 	RegisterObjectType(ctx context.Context, objectType string, defaultRetentionYears int, tenantOverridable bool) error
 }
 // RegisterWithArchive meldet den Audit-Log-Objekttyp bei der Archive-
 // Retention-Engine an. Dies ist die EINZIGE Beruehrung dieses Pakets mit
 // Retention ueberhaupt — kein zweites, Core-eigenes Retention-System
 // (siehe "Bekannte Fehler vermeiden" im AUD-05-Ticket).
 func RegisterWithArchive(ctx context.Context, registrar RetentionRegistrar) error {
 	return registrar.RegisterObjectType(ctx, AuditLogObjectType, DefaultAuditRetentionYears, AuditRetentionTenantOverridable)
 }
@@ -0,0 +1,49 @@
 package audit
 import (
 	"context"
 	"testing"
 )
 // fakeRegistrar simuliert den RET-05-Modul-Adapter-Vertrag, da Archive
 // (RET-01/RET-02/RET-05) zum Zeitpunkt dieser Kachel noch nicht als Code
 // existiert (nur geplant in archive-kanban). Belegt NUR, dass Core mit den
 // richtigen Parametern registriert — ersetzt KEINE Integrationspruefung
 // gegen die echte Archive-Engine, siehe Pruefungen-Abschnitt im Commit.
 type fakeRegistrar struct {
 	objectType            string
 	defaultRetentionYears int
 	tenantOverridable     bool
 	called                bool
 }
 func (f *fakeRegistrar) RegisterObjectType(ctx context.Context, objectType string, defaultRetentionYears int, tenantOverridable bool) error {
 	f.called = true
 	f.objectType = objectType
 	f.defaultRetentionYears = defaultRetentionYears
 	f.tenantOverridable = tenantOverridable
 	return nil
 }
 // Akzeptanzkriterium 1 + 2: Registrierung mit korrektem Objekttyp und
 // GoBD-Default-Frist von 10 Jahren, tenant-ueberschreibbar.
 func TestRegisterWithArchive_UsesCorrectObjectTypeAndRetention(t *testing.T) {
 	fake := &fakeRegistrar{}
 	if err := RegisterWithArchive(context.Background(), fake); err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	if !fake.called {
 		t.Fatal("erwartet aufruf von RegisterObjectType")
 	}
 	if fake.objectType != AuditLogObjectType {
 		t.Fatalf("objectType = %q, want %q", fake.objectType, AuditLogObjectType)
 	}
 	if fake.defaultRetentionYears != 10 {
 		t.Fatalf("defaultRetentionYears = %d, want 10 (GoBD-Frist)", fake.defaultRetentionYears)
 	}
 	if !fake.tenantOverridable {
 		t.Fatal("erwartet tenantOverridable = true")
 	}
 }
@@ -0,0 +1,15 @@
 package audit
 import "crypto/subtle"
 // timingSafeEqual ist die projektweite Referenzimplementierung fuer
 // Timing-safe-Vergleiche sicherheitsrelevanter Geheimnisse (Bestaetigungs-
 // codes hier, spaeter Freigabelinks in Archive CMP-06 — siehe IAM-02-Ticket-
 // Konvention). subtle.ConstantTimeCompare vergleicht in konstanter Zeit
 // bezogen auf die Laenge von a, unabhaengig vom Inhalt.
 func timingSafeEqual(a, b []byte) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	return subtle.ConstantTimeCompare(a, b) == 1
 }
@@ -0,0 +1,62 @@
 package audit
 import (
 	"testing"
 	"time"
 )
 func TestTimingSafeEqual_Correctness(t *testing.T) {
 	a := hashCode("geheimnis-a")
 	b := hashCode("geheimnis-a")
 	c := hashCode("geheimnis-b")
 	if !timingSafeEqual(a, b) {
 		t.Fatal("identische hashes sollten gleich sein")
 	}
 	if timingSafeEqual(a, c) {
 		t.Fatal("unterschiedliche hashes sollten ungleich sein")
 	}
 	if timingSafeEqual(a, []byte("kuerzer")) {
 		t.Fatal("unterschiedliche laenge sollte ungleich sein")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Timing-safe Vergleich stichprobenartig
 // per Laufzeitmessung verifiziert — ein Mismatch am Anfang darf nicht
 // messbar schneller sein als ein Mismatch am Ende (klassisches Merkmal
 // eines NICHT timing-safen Vergleichs wie bytes.Equal mit Short-Circuit).
 func TestTimingSafeEqual_NoEarlyExitTiming(t *testing.T) {
 	reference := hashCode("referenzwert-fuer-timing-test")
 	mismatchAtStart := make([]byte, len(reference))
 	copy(mismatchAtStart, reference)
 	mismatchAtStart[0] ^= 0xFF
 	mismatchAtEnd := make([]byte, len(reference))
 	copy(mismatchAtEnd, reference)
 	mismatchAtEnd[len(mismatchAtEnd)-1] ^= 0xFF
 	const iterations = 20000
 	startDur := measure(iterations, func() { timingSafeEqual(reference, mismatchAtStart) })
 	endDur := measure(iterations, func() { timingSafeEqual(reference, mismatchAtEnd) })
 	t.Logf("mismatch am anfang: %s, mismatch am ende: %s (%d iterationen)", startDur, endDur, iterations)
 	ratio := float64(startDur) / float64(endDur)
 	// Grosszuegige Toleranz (Faktor 3), da es ein Stichprobentest auf einer
 	// geteilten Testmaschine ist, kein isolierter Benchmark — es geht darum,
 	// eine grobe Short-Circuit-Implementierung zuverlaessig aufzudecken
 	// (die haette typischerweise eine Groessenordnung Unterschied), nicht um
 	// kryptographisch praezise Constant-Time-Beweise.
 	if ratio > 3.0 || ratio < 1.0/3.0 {
 		t.Fatalf("timing-unterschied zu gross (verdacht auf short-circuit-vergleich): ratio=%.2f", ratio)
 	}
 }
 func measure(iterations int, fn func()) time.Duration {
 	start := time.Now()
 	for i := 0; i < iterations; i++ {
 		fn()
 	}
 	return time.Since(start)
 }
@@ -0,0 +1,252 @@
 // wiring_test.go ist der Nachweis fuer AUD-06: fuer jeden der vier
 // sicherheitsrelevanten Bereiche (Policy, Tenant-Lifecycle, Lockout,
 // KEK-Rotation) wird eine reale Aktion ausgefuehrt und per direkter Abfrage
 // der audit_events-Tabelle nachgewiesen, dass ein passender Eintrag
 // entstanden ist - derselbe Nachweisstil wie der QA-05-Stichprobenabgleich
 // (docs/QA-05-ABNAHME-COMPLIANCE-PRUEFUNG.md Abschnitt 2), der die Luecke
 // ursprünglich aufdeckte.
 package audit_test
 import (
 	"context"
 	"crypto/rand"
 	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"sort"
 	"strings"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgconn"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/kek"
 	"gitea.perlbach24.de/scripte/nexarch/internal/lockout"
 	"gitea.perlbach24.de/scripte/nexarch/internal/policy"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 )
 func requireAdminDSN(t *testing.T) string {
 	t.Helper()
 	dsn := os.Getenv("TEST_ADMIN_DSN")
 	if dsn == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	return dsn
 }
 func repoRoot(t *testing.T) string {
 	t.Helper()
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("getwd: %v", err)
 	}
 	return filepath.Join(wd, "..", "..")
 }
 func applyAllUpSQL(t *testing.T, ctx context.Context, pool *pgxpool.Pool, dir string) {
 	t.Helper()
 	entries, err := os.ReadDir(dir)
 	if err != nil {
 		t.Fatalf("migrationsverzeichnis %q lesen: %v", dir, err)
 	}
 	var names []string
 	for _, e := range entries {
 		if !e.IsDir() && strings.HasSuffix(e.Name(), ".up.sql") {
 			names = append(names, e.Name())
 		}
 	}
 	sort.Strings(names)
 	for _, name := range names {
 		sqlBytes, err := os.ReadFile(filepath.Join(dir, name))
 		if err != nil {
 			t.Fatalf("migration %q lesen: %v", name, err)
 		}
 		if _, err := pool.Exec(ctx, string(sqlBytes)); err != nil {
 			var pgErr *pgconn.PgError
 			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710" || pgErr.Code == "42723") {
 				continue
 			}
 			t.Fatalf("migration %q anwenden: %v", name, err)
 		}
 	}
 }
 func countAuditEvents(t *testing.T, ctx context.Context, pool *pgxpool.Pool, action, target string) int {
 	t.Helper()
 	var n int
 	if err := pool.QueryRow(ctx, `
 		SELECT count(*) FROM audit_events WHERE action = $1 AND target = $2
 	`, action, target).Scan(&n); err != nil {
 		t.Fatalf("audit_events abfragen: %v", err)
 	}
 	return n
 }
 func setupWiringTest(t *testing.T) (*pgxpool.Pool, *audit.Log) {
 	t.Helper()
 	adminDSN := requireAdminDSN(t)
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	root := repoRoot(t)
 	applyAllUpSQL(t, ctx, pool, filepath.Join(root, "migrations"))
 	// login_attempts liegt in Produktion in der Tenant-Datenbank - fuer diesen
 	// Verdrahtungsnachweis genuegt dieselbe physische Datenbank, da es nur um
 	// den Audit-Log-Schreibpfad geht, nicht um Tenant-Isolation (die ist
 	// bereits durch TEN-01/QA-02 nachgewiesen).
 	applyAllUpSQL(t, ctx, pool, filepath.Join(root, "migrations", "tenant"))
 	return pool, audit.NewLog(pool)
 }
 // TestWiring_PolicyGrantRevokeAreAudited ist der Nachweis fuer
 // Akzeptanzkriterium 1: internal/policy.Store.Grant/Revoke schreiben einen
 // Audit-Log-Eintrag.
 func TestWiring_PolicyGrantRevokeAreAudited(t *testing.T) {
 	pool, log := setupWiringTest(t)
 	ctx := context.Background()
 	store := policy.NewStore(pool).WithAudit(log)
 	target := "user:self.read"
 	if err := store.Grant(ctx, rbac.RoleUser, rbac.PermSelfRead, "aud06-actor"); err != nil {
 		t.Fatalf("grant: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "policy.grant", target); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer policy.grant %q, habe %d", target, n)
 	}
 	if err := store.Revoke(ctx, rbac.RoleUser, rbac.PermSelfRead, "aud06-actor"); err != nil {
 		t.Fatalf("revoke: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "policy.revoke", target); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer policy.revoke %q, habe %d", target, n)
 	}
 }
 // TestWiring_TenantLifecycleTransitionIsAudited ist der Nachweis fuer
 // Akzeptanzkriterium 2: internal/tenant.Registry-Uebergaenge schreiben einen
 // Audit-Log-Eintrag.
 func TestWiring_TenantLifecycleTransitionIsAudited(t *testing.T) {
 	pool, log := setupWiringTest(t)
 	ctx := context.Background()
 	registry := tenant.NewRegistry(pool).WithAudit(log)
 	dsnTemplate := strings.Replace(requireAdminDSN(t), "/postgres?", "/%s?", 1)
 	provisioner := tenant.NewProvisioner(pool, tenant.NewRegistry(pool), dsnTemplate)
 	slug := uniqueSlug("aud06_lifecycle")
 	tn, err := provisioner.Provision(ctx, slug, "AUD-06 Lifecycle GmbH")
 	if err != nil {
 		t.Fatalf("provision: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE slug = $1`, slug)
 		_, _ = pool.Exec(ctx, `DROP DATABASE IF EXISTS "tenant_`+slug+`"`)
 	})
 	_ = tn
 	if _, err := registry.Suspend(ctx, slug); err != nil {
 		t.Fatalf("suspend: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "tenant.transition", "suspended"); n == 0 {
 		t.Fatal("erwartet mindestens 1 audit-eintrag fuer tenant.transition -> suspended, habe 0")
 	}
 }
 // TestWiring_LockoutFailuresAndUnlockAreAudited ist der Nachweis fuer
 // Akzeptanzkriterium 3 (Teil Lockout): internal/lockout.Store.RecordFailure
 // und Unlock schreiben je einen Audit-Log-Eintrag.
 func TestWiring_LockoutFailuresAndUnlockAreAudited(t *testing.T) {
 	pool, log := setupWiringTest(t)
 	ctx := context.Background()
 	email := fmt.Sprintf("aud06-%d@example.test", time.Now().UnixNano())
 	store := lockout.NewStore(pool).WithPolicy(2, time.Minute).WithAudit(log, "aud06-tenant")
 	t.Cleanup(func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM login_attempts WHERE email = $1`, email)
 	})
 	if _, _, err := store.RecordFailure(ctx, email); err != nil {
 		t.Fatalf("fehlversuch 1: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "auth.login_failed", email); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer auth.login_failed %q, habe %d", email, n)
 	}
 	locked, _, err := store.RecordFailure(ctx, email)
 	if err != nil {
 		t.Fatalf("fehlversuch 2 (sperrt): %v", err)
 	}
 	if !locked {
 		t.Fatal("konto haette nach 2 fehlversuchen (policy maxFailed=2) gesperrt sein muessen")
 	}
 	if n := countAuditEvents(t, ctx, pool, "auth.account_locked", email); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer auth.account_locked %q, habe %d", email, n)
 	}
 	if err := store.Unlock(ctx, email); err != nil {
 		t.Fatalf("entsperren: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "auth.account_unlocked", email); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer auth.account_unlocked %q, habe %d", email, n)
 	}
 }
 // TestWiring_KEKRotationIsAudited ist der Nachweis fuer Akzeptanzkriterium 3
 // (Teil KEK): internal/kek.Store.RotateTenantKEK/RotateMasterKey schreiben
 // je einen Audit-Log-Eintrag.
 func TestWiring_KEKRotationIsAudited(t *testing.T) {
 	pool, log := setupWiringTest(t)
 	ctx := context.Background()
 	store := kek.NewStore(pool).WithAudit(log)
 	var tenantID string
 	slug := uniqueSlug("aud06_kek")
 	if err := pool.QueryRow(ctx, `
 		INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ($1, $1, $1, 'unused') RETURNING id
 	`, slug).Scan(&tenantID); err != nil {
 		t.Fatalf("tenant-zeile anlegen: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM tenant_keks WHERE tenant_id = $1`, tenantID)
 		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
 	})
 	masterKey := randomMasterKey(t)
 	if _, err := store.CreateForTenant(ctx, tenantID, masterKey); err != nil {
 		t.Fatalf("tenant-kek anlegen: %v", err)
 	}
 	if _, err := store.RotateTenantKEK(ctx, tenantID, masterKey); err != nil {
 		t.Fatalf("tenant-kek rotieren: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "kek.tenant_rotated", tenantID); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer kek.tenant_rotated %q, habe %d", tenantID, n)
 	}
 	newMasterKey := randomMasterKey(t)
 	if _, _, err := store.RotateMasterKey(ctx, masterKey, newMasterKey); err != nil {
 		t.Fatalf("master-key rotieren: %v", err)
 	}
 	if n := countAuditEvents(t, ctx, pool, "kek.master_rotated", audit.SystemTenant); n != 1 {
 		t.Fatalf("erwartet 1 audit-eintrag fuer kek.master_rotated, habe %d", n)
 	}
 }
 func randomMasterKey(t *testing.T) kek.MasterKey {
 	t.Helper()
 	buf := make([]byte, kek.MasterKeySize)
 	if _, err := rand.Read(buf); err != nil {
 		t.Fatalf("master-key erzeugen: %v", err)
 	}
 	return kek.MasterKey(buf)
 }
 func uniqueSlug(prefix string) string {
 	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
 }
@@ -0,0 +1,57 @@
 // Package contracttest implementiert Core QA-07: Vertragstests fuer die
 // Core-Schnittstellen, die von den Fachmodulen (DMS/Mail/Archive/Workflow/
 // AI/Connect) konsumiert werden — REST-Fehlerschema (API-01), JWKS-/Rechte-
 // Cache-Kontrakt (API-05), Modul-Registry (API-02) und Webhook-Zustellung
 // (API-07). Jeder Test prueft die TATSAECHLICHE Antwort einer echten
 // Core-Komponente gegen ihr dokumentiertes Schema — eine entfernte oder
 // umbenannte Pflichteigenschaft laesst den jeweiligen Test fehlschlagen,
 // BEVOR sie ein konsumierendes Modul bricht (Akzeptanzkriterium 2).
 package contracttest
 import (
 	"encoding/json"
 	"fmt"
 )
 // RequireJSONFields dekodiert data als JSON-Objekt und prueft, dass ALLE
 // angegebenen Top-Level-Schluessel vorhanden sind. Liefert die fehlenden
 // Schluessel zurueck — leer bedeutet: Vertrag eingehalten.
 func RequireJSONFields(data []byte, required []string) (missing []string, err error) {
 	var decoded map[string]any
 	if err := json.Unmarshal(data, &decoded); err != nil {
 		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
 	}
 	for _, field := range required {
 		if _, ok := decoded[field]; !ok {
 			missing = append(missing, field)
 		}
 	}
 	return missing, nil
 }
 // RequireJSONArrayItemFields prueft, dass data ein JSON-Objekt mit einem
 // Array-Feld arrayField ist, dessen ERSTES Element alle itemFields enthaelt
 // — Vertrag fuer Listen-Antworten wie JWKS ("keys": [{...}]).
 func RequireJSONArrayItemFields(data []byte, arrayField string, itemFields []string) (missing []string, err error) {
 	var decoded map[string]json.RawMessage
 	if err := json.Unmarshal(data, &decoded); err != nil {
 		return nil, fmt.Errorf("contracttest: antwort ist kein json-objekt: %w", err)
 	}
 	raw, ok := decoded[arrayField]
 	if !ok {
 		return itemFields, nil // das array-feld selbst fehlt bereits -> alles "fehlend"
 	}
 	var items []map[string]any
 	if err := json.Unmarshal(raw, &items); err != nil {
 		return nil, fmt.Errorf("contracttest: feld %q ist kein array: %w", arrayField, err)
 	}
 	if len(items) == 0 {
 		return nil, fmt.Errorf("contracttest: feld %q ist leer, kann nicht gegen kontrakt geprueft werden", arrayField)
 	}
 	for _, field := range itemFields {
 		if _, ok := items[0][field]; !ok {
 			missing = append(missing, field)
 		}
 	}
 	return missing, nil
 }
@@ -0,0 +1,193 @@
 package contracttest
 import (
 	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
 	"gitea.perlbach24.de/scripte/nexarch/internal/webhook"
 )
 // --- Vertrag 1: API-01 REST-Fehlerschema ---
 // Akzeptanzkriterium 1/2 + Pruefung 1/2.
 func TestContract_API01_ErrorEnvelope(t *testing.T) {
 	rec := httptest.NewRecorder()
 	apiserver.WriteError(rec, http.StatusUnauthorized, "unauthenticated", "nicht angemeldet")
 	if missing, err := RequireJSONFields(rec.Body.Bytes(), []string{"error"}); err != nil {
 		t.Fatalf("antwort nicht lesbar: %v", err)
 	} else if len(missing) != 0 {
 		t.Fatalf("erwartet top-level feld 'error', fehlt: %v", missing)
 	}
 	var decoded map[string]json.RawMessage
 	_ = json.Unmarshal(rec.Body.Bytes(), &decoded)
 	if missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"}); err != nil {
 		t.Fatalf("error-objekt nicht lesbar: %v", err)
 	} else if len(missing) != 0 {
 		t.Fatalf("error-objekt fehlen pflichtfelder: %v", missing)
 	}
 }
 // Pruefung 2: absichtlich simulierter Breaking Change (Feld "message"
 // entfernt) laesst den Vertragstest fehlschlagen.
 func TestContract_API01_DetectsBreakingChange_RemovedField(t *testing.T) {
 	brokenResponse := []byte(`{"error":{"code":"unauthenticated"}}`) // "message" fehlt absichtlich
 	var decoded map[string]json.RawMessage
 	if err := json.Unmarshal(brokenResponse, &decoded); err != nil {
 		t.Fatalf("fixture nicht lesbar: %v", err)
 	}
 	missing, err := RequireJSONFields(decoded["error"], []string{"code", "message"})
 	if err != nil {
 		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
 	}
 	if len(missing) != 1 || missing[0] != "message" {
 		t.Fatalf("erwartet erkanntes fehlendes feld 'message', habe: %v", missing)
 	}
 }
 // --- Vertrag 2: API-05 JWKS / Rechte-Cache-Kontrakt ---
 // Akzeptanzkriterium 1/2 + Pruefung 1/2.
 func TestContract_API05_JWKS(t *testing.T) {
 	km, err := moduletrust.NewKeyManager()
 	if err != nil {
 		t.Fatalf("keymanager: %v", err)
 	}
 	if _, err := km.Rotate(); err != nil {
 		t.Fatalf("rotate: %v", err)
 	}
 	rec := httptest.NewRecorder()
 	km.ServeJWKS(rec, httptest.NewRequest(http.MethodGet, "/jwks", nil))
 	missing, err := RequireJSONArrayItemFields(rec.Body.Bytes(), "keys", []string{"kid", "public_key"})
 	if err != nil {
 		t.Fatalf("jwks-antwort verletzt vertrag: %v", err)
 	}
 	if len(missing) != 0 {
 		t.Fatalf("jwks-eintrag fehlen pflichtfelder: %v", missing)
 	}
 }
 // Pruefung 2: simulierter Breaking Change — Feld "public_key" umbenannt
 // (z.B. faelschlich zu "publicKey"), Vertragstest erkennt das fehlende
 // Originalfeld zuverlaessig.
 func TestContract_API05_DetectsBreakingChange_RenamedField(t *testing.T) {
 	brokenJWKS := []byte(`{"keys":[{"kid":"abc","publicKey":"base64..."}]}`)
 	missing, err := RequireJSONArrayItemFields(brokenJWKS, "keys", []string{"kid", "public_key"})
 	if err != nil {
 		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
 	}
 	if len(missing) != 1 || missing[0] != "public_key" {
 		t.Fatalf("erwartet erkanntes umbenanntes feld 'public_key', habe: %v", missing)
 	}
 }
 // --- Vertrag 3: API-02 Modul-Registry ---
 // Akzeptanzkriterium 1/2 + Pruefung 1/2.
 func setupModuleRegistryTest(t *testing.T) (*moduleregistry.Registry, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS modules (
 			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
 			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
 	return moduleregistry.NewRegistry(pool, flagService), func() { pool.Close() }
 }
 func TestContract_API02_ModuleInfo(t *testing.T) {
 	registry, cleanup := setupModuleRegistryTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	m, err := registry.Register(ctx, "contracttest-dms", "1.0.0", []string{"some-flag"})
 	if err != nil {
 		t.Fatalf("register: %v", err)
 	}
 	data, err := json.Marshal(m)
 	if err != nil {
 		t.Fatalf("marshal: %v", err)
 	}
 	missing, err := RequireJSONFields(data, []string{"Name", "Version", "RequiredFlags"})
 	if err != nil {
 		t.Fatalf("modul-antwort nicht lesbar: %v", err)
 	}
 	if len(missing) != 0 {
 		t.Fatalf("modul-info fehlen pflichtfelder: %v", missing)
 	}
 }
 // Pruefung 2: simulierter Breaking Change — Feld "RequiredFlags" entfernt.
 func TestContract_API02_DetectsBreakingChange_RemovedField(t *testing.T) {
 	brokenModuleJSON := []byte(`{"Name":"dms","Version":"1.0.0"}`)
 	missing, err := RequireJSONFields(brokenModuleJSON, []string{"Name", "Version", "RequiredFlags"})
 	if err != nil {
 		t.Fatalf("pruefung selbst fehlgeschlagen: %v", err)
 	}
 	if len(missing) != 1 || missing[0] != "RequiredFlags" {
 		t.Fatalf("erwartet erkanntes fehlendes feld 'RequiredFlags', habe: %v", missing)
 	}
 }
 // --- Vertrag 4: API-07 Webhook-Zustellung (HMAC-Signaturheader) ---
 // Akzeptanzkriterium 1/2 + Pruefung 1/2.
 func TestContract_API07_WebhookSignatureHeader(t *testing.T) {
 	if webhook.SignatureHeader != "X-Nexarch-Signature-256" {
 		t.Fatalf("signaturheader-name = %q, want stabilen vertrag 'X-Nexarch-Signature-256' — konsumierende module lesen genau diesen namen", webhook.SignatureHeader)
 	}
 	secret := "vertragstest-secret"
 	payload := []byte(`{"event":"test"}`)
 	signature := webhook.Sign(secret, payload)
 	if !webhook.VerifySignature(secret, payload, signature) {
 		t.Fatal("konsumentenseitige signaturpruefung schlaegt fuer eine korrekte core-signatur fehl")
 	}
 }
 // Pruefung 2: simulierter Breaking Change — eine Zustellung, die den
 // Signaturheader unter einem ANDEREN Namen sendet (wie es ein
 // hypothetischer, den Vertrag brechender Core-Umbau taete). Ein
 // konsumierendes Modul, das nach dem DOKUMENTIERTEN Namen sucht, findet in
 // diesem Fall nichts — der Vertragstest erkennt das zuverlaessig.
 func TestContract_API07_DetectsBreakingChange_RenamedHeader(t *testing.T) {
 	brokenHeaders := http.Header{}
 	brokenHeaders.Set("X-Signature", webhook.Sign("secret", []byte("payload"))) // falscher name, simuliert breaking change
 	if got := brokenHeaders.Get(webhook.SignatureHeader); got != "" {
 		t.Fatalf("erwartet leeren wert unter dem dokumentierten headernamen bei simuliertem breaking change, habe: %q", got)
 	}
 }
@@ -86,7 +86,7 @@ func applyAllUpSQL(t *testing.T, ctx context.Context, pool *pgxpool.Pool, dir st
 			// Registry-Datenbank, daher ist "schon vorhanden" hier kein
 			// Fehler, sondern der Normalfall beim zweiten Testlauf.
 			var pgErr *pgconn.PgError
-			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710") {
+			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710" || pgErr.Code == "42723") {
 				continue
 			}
 			t.Fatalf("migration %q anwenden: %v", name, err)
@@ -7,6 +7,8 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 )
 var ErrNoTenantKEK = errors.New("kek: kein tenant-kek fuer diesen mandanten hinterlegt")
@@ -17,13 +19,21 @@ var ErrNoTenantKEK = errors.New("kek: kein tenant-kek fuer diesen mandanten hint
 // unabhaengiger Store, um TEN-01 nicht um schluesselfremde Belange zu
 // erweitern, demselben Muster wie internal/license.Store).
 type Store struct {
-	pool *pgxpool.Pool
+	pool  *pgxpool.Pool
 	audit *audit.Log
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // WithAudit liefert einen Store, der jede Schluessel-Rotation zusaetzlich im
 // zentralen, unveraenderlichen Audit-Log protokolliert (AUD-06) — rein
 // additiv, log == nil bleibt gueltig (z.B. bestehende Tests).
 func (s *Store) WithAudit(log *audit.Log) *Store {
 	return &Store{pool: s.pool, audit: log}
 }
 // CreateForTenant erzeugt einen NEUEN, zufaelligen Tenant-KEK und speichert
 // ihn mit dem Master-Key verpackt (Akzeptanzkriterium 2: JEDER Tenant
 // erhaelt einen EIGENEN Schluessel, niemals ein gemeinsamer). Wird von der
@@ -88,6 +98,14 @@ func (s *Store) RotateTenantKEK(ctx context.Context, tenantID string, masterKey
 	if tag.RowsAffected() == 0 {
 		return nil, ErrNoTenantKEK
 	}
 	if s.audit != nil {
 		_ = s.audit.Record(ctx, audit.Event{
 			TenantSlug: audit.SystemTenant,
 			Actor:      "system",
 			Action:     "kek.tenant_rotated",
 			Target:     tenantID,
 		})
 	}
 	return newPlainKEK, nil
 }
@@ -140,5 +158,14 @@ func (s *Store) RotateMasterKey(ctx context.Context, oldKey, newKey MasterKey) (
 		}
 		rotated++
 	}
 	if s.audit != nil {
 		_ = s.audit.Record(ctx, audit.Event{
 			TenantSlug: audit.SystemTenant,
 			Actor:      "system",
 			Action:     "kek.master_rotated",
 			Target:     audit.SystemTenant,
 			Metadata:   map[string]any{"rotated": rotated, "failed": failedTenantIDs},
 		})
 	}
 	return rotated, failedTenantIDs, nil
 }
@@ -0,0 +1,262 @@
 // Package loadtest implementiert Core QA-08: Last- und Leistungstests fuer
 // die drei Mechanismen, die unter realistischer Mehrmodul-Last (sechs
 // gleichzeitig zugreifende Fachmodule: DMS/Mail/Archive/Workflow/AI/Connect)
 // am ehesten unter Druck geraten — JWT-Verifikationspfad (API-05),
 // Tenant-Connection-Pooling (TEN-06) und Rate-Limiting (API-03). Jeder Test
 // dokumentiert einen Zielwert UND das tatsaechlich gemessene Ergebnis
 // (Ticket-Vorgabe: "Pruefen heisst messen. Behauptungen ohne Messprotokoll
 // gelten nicht als erledigt.").
 package loadtest
 import (
 	"context"
 	"crypto/ed25519"
 	"fmt"
 	"os"
 	"sort"
 	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduletrust"
 	"gitea.perlbach24.de/scripte/nexarch/internal/ratelimit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 )
 const simulatedModuleCount = 6 // DMS, Mail, Archive, Workflow, AI, Connect
 // Akzeptanzkriterium 1 + Pruefung 1: definierte Ziel-Latenz fuer
 // JWT-Verifikation unter Last aus sechs gleichzeitig zugreifenden Modulen.
 //
 // Zielwert: p95 < 10ms je Verify()-Aufruf. Begruendung des Zielwerts:
 // Verify() ist eine rein lokale Operation gegen einen bereits im Speicher
 // zwischengespeicherten Schluesselsatz (StaleCache, siehe API-05) — es
 // findet kein Netzwerk-Roundtrip zu Core statt, daher ist ein niedriger
 // Millisekunden-Zielwert realistisch, nicht willkuerlich hoch angesetzt.
 func TestLoad_JWTVerificationLatencyUnderSixModuleLoad(t *testing.T) {
 	km, err := moduletrust.NewKeyManager()
 	if err != nil {
 		t.Fatalf("keymanager: %v", err)
 	}
 	if _, err := km.Rotate(); err != nil {
 		t.Fatalf("rotate: %v", err)
 	}
 	verifier := moduletrust.NewVerifier(time.Minute, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
 		return km.PublicKeySet(), nil
 	})
 	const requestsPerModule = 200
 	totalRequests := simulatedModuleCount * requestsPerModule
 	tokens := make([]string, totalRequests)
 	for i := 0; i < totalRequests; i++ {
 		tok, err := km.Issue("user-1", fmt.Sprintf("tenant-%d", i%50), 5*time.Minute)
 		if err != nil {
 			t.Fatalf("issue: %v", err)
 		}
 		tokens[i] = tok
 	}
 	latencies := make([]time.Duration, totalRequests)
 	var wg sync.WaitGroup
 	for module := 0; module < simulatedModuleCount; module++ {
 		wg.Add(1)
 		go func(moduleIdx int) {
 			defer wg.Done()
 			for i := 0; i < requestsPerModule; i++ {
 				idx := moduleIdx*requestsPerModule + i
 				start := time.Now()
 				if _, err := verifier.Verify(context.Background(), tokens[idx]); err != nil {
 					t.Errorf("verify: %v", err)
 					return
 				}
 				latencies[idx] = time.Since(start)
 			}
 		}(module)
 	}
 	wg.Wait()
 	sort.Slice(latencies, func(i, j int) bool { return latencies[i] < latencies[j] })
 	p95 := latencies[int(float64(len(latencies))*0.95)]
 	max := latencies[len(latencies)-1]
 	t.Logf("JWT-Verifikation unter Last: %d module x %d anfragen = %d gesamt. p95=%s, max=%s, ziel=p95<10ms",
 		simulatedModuleCount, requestsPerModule, totalRequests, p95, max)
 	if p95 >= 10*time.Millisecond {
 		t.Fatalf("p95-latenz = %s, ziel war unter 10ms", p95)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Connection-Pooling bleibt unter der
 // Postgres-Verbindungsobergrenze bei simulierter Vielzahl an Mandanten.
 //
 // Zielwert: bei 200 simulierten Mandanten, auf die sechs Module gleichzeitig
 // zugreifen, bleiben NIE mehr als maxOpen=20 Pools gleichzeitig offen (LRU-
 // Verdraengung greift) — weit unter einer typischen Postgres
 // max_connections-Grenze (Default 100).
 func TestLoad_ConnectionPoolingStaysUnderLimitWithManySimulatedTenants(t *testing.T) {
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	// Ueber t.Cleanup statt defer geschlossen: t.Cleanup-Funktionen laufen
 	// erst NACH allen defer-Aufrufen der Testfunktion, daher muss diese
 	// Registrierung vor der Loesch-Cleanup unten stehen, damit der Pool
 	// beim Aufraeumen noch offen ist (dieselbe Fehlerklasse wie in QA-04,
 	// siehe internal/e2e/*_test.go und internal/kek/kek_test.go).
 	t.Cleanup(func() { pool.Close() })
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS tenants (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), slug TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
 			db_name TEXT NOT NULL UNIQUE, db_dsn TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'active',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	registry := tenant.NewRegistry(pool)
 	const simulatedTenants = 200
 	const maxOpen = 20
 	prefix := fmt.Sprintf("qa08_%d", time.Now().UnixNano())
 	slugs := make([]string, simulatedTenants)
 	for i := 0; i < simulatedTenants; i++ {
 		slug := fmt.Sprintf("%s_%d", prefix, i)
 		slugs[i] = slug
 		// DSN muss nur SYNTAKTISCH gueltig sein — pgxpool.New verbindet
 		// erst lazy bei tatsaechlicher Nutzung, fuer diesen Lasttest zaehlt
 		// ausschliesslich die Zahl offener *Pool-Objekte*, nicht ob die
 		// referenzierte Datenbank real existiert.
 		dsn := fmt.Sprintf("postgresql://nexarch_test:unused@localhost:5432/%s?sslmode=disable", slug)
 		if _, err := pool.Exec(ctx, `
 			INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ($1, $1, $1, $2)
 		`, slug, dsn); err != nil {
 			t.Fatalf("tenant %s anlegen: %v", slug, err)
 		}
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug LIKE $1`, prefix+"%")
 	})
 	router := tenant.NewRouter(registry, maxOpen)
 	defer router.Close()
 	var maxObservedOpen int64
 	var wg sync.WaitGroup
 	for module := 0; module < simulatedModuleCount; module++ {
 		wg.Add(1)
 		go func(moduleIdx int) {
 			defer wg.Done()
 			for i := 0; i < simulatedTenants; i++ {
 				slug := slugs[(i+moduleIdx*37)%simulatedTenants] // module-uebergreifend gemischter zugriff
 				if _, err := router.Resolve(context.Background(), slug); err != nil {
 					t.Errorf("resolve %s: %v", slug, err)
 					return
 				}
 				if current := int64(router.OpenCount()); current > atomic.LoadInt64(&maxObservedOpen) {
 					atomic.StoreInt64(&maxObservedOpen, current)
 				}
 			}
 		}(module)
 	}
 	wg.Wait()
 	t.Logf("connection-pooling unter last: %d simulierte mandanten, %d module, max. gleichzeitig beobachtete offene pools = %d (ziel: <= %d)",
 		simulatedTenants, simulatedModuleCount, maxObservedOpen, maxOpen)
 	if maxObservedOpen > int64(maxOpen) {
 		t.Fatalf("max. beobachtete offene pools = %d, ziel war <= %d", maxObservedOpen, maxOpen)
 	}
 	if router.OpenCount() > maxOpen {
 		t.Fatalf("finale offene pools = %d, ziel war <= %d", router.OpenCount(), maxOpen)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Rate-Limiting funktioniert korrekt
 // unter Mehrinstanz-Last (mehrere "Core-Instanzen" mit geteiltem Postgres-
 // Zustand) aus sechs gleichzeitig zugreifenden Modulen, nicht nur im
 // Einzelinstanz-Test (der bereits in API-03 abgedeckt ist).
 //
 // Zielwert: bei konfiguriertem Limit=500 und insgesamt 1200 Anfragen ueber
 // DREI simulierte Core-Instanzen (separate Pools/Store-Objekte) hinweg
 // werden EXAKT 500 Anfragen erlaubt — kein Overcounting durch fehlende
 // Koordination zwischen den Instanzen, kein Undercounting durch verlorene
 // Updates.
 func TestLoad_RateLimitingCorrectAcrossMultipleInstancesUnderSixModuleLoad(t *testing.T) {
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	const instanceCount = 3
 	pools := make([]*pgxpool.Pool, instanceCount)
 	stores := make([]*ratelimit.Store, instanceCount)
 	for i := 0; i < instanceCount; i++ {
 		p, err := pgxpool.New(ctx, adminDSN)
 		if err != nil {
 			t.Fatalf("pool %d: %v", i, err)
 		}
 		defer p.Close()
 		if i == 0 {
 			if _, err := p.Exec(ctx, `
 				CREATE TABLE IF NOT EXISTS rate_limit_configs (
 					key TEXT PRIMARY KEY, limit_value INT NOT NULL, window_seconds INT NOT NULL
 				);
 				CREATE TABLE IF NOT EXISTS rate_limit_counters (
 					key TEXT NOT NULL, window_start TIMESTAMPTZ NOT NULL, count INT NOT NULL DEFAULT 0,
 					PRIMARY KEY (key, window_start)
 				);
 			`); err != nil {
 				t.Fatalf("schema: %v", err)
 			}
 		}
 		pools[i] = p
 		stores[i] = ratelimit.NewStore(p)
 	}
 	key := fmt.Sprintf("qa08-key-%d", time.Now().UnixNano())
 	const limit = 500
 	if err := stores[0].SetLimit(ctx, key, limit, time.Minute); err != nil {
 		t.Fatalf("setlimit: %v", err)
 	}
 	const totalRequests = 1200 // simulierte last aus sechs modulen ueber drei instanzen, deutlich ueber dem limit von 500
 	var allowedCount int64
 	var wg sync.WaitGroup
 	for i := 0; i < totalRequests; i++ {
 		wg.Add(1)
 		instance := stores[i%instanceCount] // request "kommt" reihum von einer der drei core-instanzen
 		go func(s *ratelimit.Store) {
 			defer wg.Done()
 			res, err := s.Allow(ctx, key)
 			if err != nil {
 				t.Errorf("allow: %v", err)
 				return
 			}
 			if res.Allowed {
 				atomic.AddInt64(&allowedCount, 1)
 			}
 		}(instance)
 	}
 	wg.Wait()
 	t.Logf("rate-limiting unter mehrinstanz-last: %d anfragen ueber %d instanzen, limit=%d, tatsaechlich erlaubt=%d",
 		totalRequests, instanceCount, limit, allowedCount)
 	if allowedCount != limit {
 		t.Fatalf("erlaubte anfragen ueber alle instanzen = %d, ziel war exakt %d (geteilter, korrekter zustand)", allowedCount, limit)
 	}
 }
@@ -11,6 +11,8 @@ import (
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 )
 // DefaultMaxFailedAttempts/DefaultLockoutDuration sind explizit benannte
@@ -24,6 +26,8 @@ type Store struct {
 	pool            *pgxpool.Pool
 	maxFailed       int
 	lockoutDuration time.Duration
 	audit           *audit.Log
 	tenantSlug      string
 }
 func NewStore(pool *pgxpool.Pool) *Store {
@@ -31,7 +35,17 @@ func NewStore(pool *pgxpool.Pool) *Store {
 }
 func (s *Store) WithPolicy(maxFailed int, lockoutDuration time.Duration) *Store {
-	return &Store{pool: s.pool, maxFailed: maxFailed, lockoutDuration: lockoutDuration}
+	return &Store{pool: s.pool, maxFailed: maxFailed, lockoutDuration: lockoutDuration, audit: s.audit, tenantSlug: s.tenantSlug}
 }
 // WithAudit liefert einen Store, der Fehlversuche sowie Sperrung/Entsperrung
 // zusaetzlich im zentralen, unveraenderlichen Audit-Log protokolliert
 // (AUD-06) — login_attempts liegt in der Tenant-Datenbank, audit_events in
 // der Registry-Datenbank, daher ein eigener, an die Registry gebundener
 // audit.Log UND der Tenant-Slug (fuer den Tenant-Bezug im Event) noetig.
 // Rein additiv, log == nil bleibt gueltig (z.B. bestehende Tests).
 func (s *Store) WithAudit(log *audit.Log, tenantSlug string) *Store {
 	return &Store{pool: s.pool, maxFailed: s.maxFailed, lockoutDuration: s.lockoutDuration, audit: log, tenantSlug: tenantSlug}
 }
 // IsLocked prueft, ob ein Konto aktuell gesperrt ist. Eine abgelaufene
@@ -71,8 +85,22 @@ func (s *Store) RecordFailure(ctx context.Context, email string) (locked bool, l
 		return false, time.Time{}, fmt.Errorf("fehlversuch erfassen: %w", err)
 	}
 	locked = lockedUntilPtr != nil && time.Now().Before(*lockedUntilPtr)
 	if s.audit != nil {
 		action := "auth.login_failed"
 		if locked {
 			action = "auth.account_locked"
 		}
 		_ = s.audit.Record(ctx, audit.Event{
 			TenantSlug: s.tenantSlug,
 			Actor:      email,
 			Action:     action,
 			Target:     email,
 			Metadata:   map[string]any{"failed_count": failedCount},
 		})
 	}
 	if lockedUntilPtr != nil {
-		return time.Now().Before(*lockedUntilPtr), *lockedUntilPtr, nil
+		return locked, *lockedUntilPtr, nil
 	}
 	return false, time.Time{}, nil
 }
@@ -99,5 +127,13 @@ func (s *Store) Unlock(ctx context.Context, email string) error {
 	if err != nil {
 		return fmt.Errorf("konto entsperren: %w", err)
 	}
 	if s.audit != nil {
 		_ = s.audit.Record(ctx, audit.Event{
 			TenantSlug: s.tenantSlug,
 			Actor:      "admin",
 			Action:     "auth.account_unlocked",
 			Target:     email,
 		})
 	}
 	return nil
 }
@@ -0,0 +1,19 @@
 package metrics
 import "github.com/prometheus/client_golang/prometheus"
 // NewCoreRegistry liefert das Prometheus-Registry fuer die EIGENEN
 // Kennzahlen des Core-Dienstes (Akzeptanzkriterium 1) — alle Namen tragen
 // das Praefix "nexarch_core_" gemaess der im Paketkommentar dokumentierten
 // Namenskonvention (Akzeptanzkriterium 3). Ein eigenes Registry statt des
 // globalen DefaultRegisterer, damit Tests unabhaengig voneinander sind.
 func NewCoreRegistry() *prometheus.Registry {
 	reg := prometheus.NewRegistry()
 	reg.MustRegister(
 		prometheus.NewGaugeFunc(prometheus.GaugeOpts{
 			Name: "nexarch_core_up",
 			Help: "1, solange der Core-Dienst laeuft und Metriken liefern kann.",
 		}, func() float64 { return 1 }),
 	)
 	return reg
 }
@@ -0,0 +1,168 @@
 // Package metrics implementiert Core OPS-03: einen zentralen /metrics-
 // Endpunkt im Prometheus-Textformat, der Kennzahlen des Core-Dienstes UND
 // aggregierte Kennzahlen aller registrierten Module bereitstellt — offenes
 // Pull-Modell nach Prometheus-Vorbild, kein proprietaerer Push-Mechanismus.
 //
 // Namenskonvention (Akzeptanzkriterium 3, modulübergreifend konsistent):
 //
 //	nexarch_core_<name>            — Kennzahlen des Core-Dienstes selbst
 //	nexarch_module_<modul>_<name>  — von einem Modul gescrapte Kennzahl
 //	                                  <name>, umbenannt mit dem
 //	                                  Modulnamen als Praefix
 //
 // Ein Modul liefert seine eigenen Kennzahlen unter EIGENEM Namen (z.B.
 // "requests_total") unter seinem eigenen /metrics-Endpunkt — dieses Paket
 // benennt sie beim Einsammeln konsistent um, damit im aggregierten Core-
 // Endpunkt niemals zwei Module denselben Metrik-Namen kollidieren lassen.
 package metrics
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
 	"github.com/prometheus/common/expfmt"
 	"github.com/prometheus/common/model"
 )
 // init erzwingt das klassische Prometheus-Namensschema (a-z, A-Z, 0-9, _)
 // fuer die Namensvalidierung von expfmt/model — ohne diese explizite
 // Festlegung liefert die Bibliothek "Invalid name validation scheme
 // requested: unset" beim Parsen/Kodieren, da sie den globalen Default in
 // dieser Version nicht mehr implizit setzt.
 func init() {
 	model.NameValidationScheme = model.LegacyValidation
 }
 // Source ist EIN registriertes Modul mit seinem eigenen /metrics-Endpunkt
 // (siehe internal/health fuer das analoge Muster bei Readiness-Checks).
 type Source struct {
 	ModuleName string
 	MetricsURL string
 }
 // SourceProvider liefert die aktuell registrierten Module — typischerweise
 // rueckgebunden an internal/moduleregistry.Registry.List (API-02) ueber
 // einen kleinen Adapter im aufrufenden Code, damit dieses Paket
 // internal/moduleregistry nicht direkt importieren muss (Kein Umbau
 // angrenzender Bereiche). Ein NEU registriertes Modul erscheint automatisch
 // beim naechsten Aufruf von Aggregator.Handler, OHNE Codeaenderung an diesem
 // Paket (Akzeptanzkriterium 2 / Pruefung 2).
 type SourceProvider func(ctx context.Context) ([]Source, error)
 // FetchTimeout begrenzt, wie lange EIN Modul-Scrape maximal dauern darf —
 // ein haengendes Modul darf den gesamten Aggregations-Request nicht
 // verzoegern (Pruefung 1: Antwort unter Last innerhalb definierter Zeit).
 const FetchTimeout = 2 * time.Second
 // Aggregator sammelt Core-eigene Metriken (coreGatherer) und die Metriken
 // aller ueber sourceProvider gemeldeten Module in EINER Antwort ein.
 type Aggregator struct {
 	coreGatherer   prometheus.Gatherer
 	sourceProvider SourceProvider
 	client         *http.Client
 }
 func NewAggregator(coreGatherer prometheus.Gatherer, sourceProvider SourceProvider) *Aggregator {
 	return &Aggregator{
 		coreGatherer:   coreGatherer,
 		sourceProvider: sourceProvider,
 		client:         &http.Client{Timeout: FetchTimeout},
 	}
 }
 // Gather implementiert prometheus.Gatherer: liefert Core-Metriken PLUS alle
 // erreichbaren Modul-Metriken (umbenannt gemaess Namenskonvention) in einer
 // gemeinsamen Liste von MetricFamilies.
 func (a *Aggregator) Gather(ctx context.Context) ([]*dto.MetricFamily, error) {
 	families, err := a.coreGatherer.Gather()
 	if err != nil {
 		return nil, fmt.Errorf("core-metriken einsammeln: %w", err)
 	}
 	sources, err := a.sourceProvider(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("modul-quellen ermitteln: %w", err)
 	}
 	// Module werden NEBENLAEUFIG gescrapt (dasselbe Muster wie
 	// internal/health.Registry.CheckAll) — ein langsames/nicht erreichbares
 	// Modul haelt weder andere Module noch den Gesamt-Request auf.
 	type fetchResult struct {
 		families []*dto.MetricFamily
 	}
 	resultCh := make(chan fetchResult, len(sources))
 	for _, src := range sources {
 		go func(src Source) {
 			fetchCtx, cancel := context.WithTimeout(ctx, FetchTimeout)
 			defer cancel()
 			mf, err := a.fetchAndRename(fetchCtx, src)
 			if err != nil {
 				resultCh <- fetchResult{} // Fehlerfall: einfach nichts beitragen, Aggregation laeuft weiter
 				return
 			}
 			resultCh <- fetchResult{families: mf}
 		}(src)
 	}
 	for range sources {
 		r := <-resultCh
 		families = append(families, r.families...)
 	}
 	return families, nil
 }
 // fetchAndRename ruft die /metrics-URL eines Moduls ab, parst das
 // Prometheus-Textformat und benennt jede Metrik gemaess der
 // Namenskonvention um (Akzeptanzkriterium 2 + 3).
 func (a *Aggregator) fetchAndRename(ctx context.Context, src Source) ([]*dto.MetricFamily, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, src.MetricsURL, nil)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := a.client.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("modul %s: unerwarteter status %d", src.ModuleName, resp.StatusCode)
 	}
 	parser := expfmt.NewTextParser(model.LegacyValidation)
 	parsed, err := parser.TextToMetricFamilies(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("modul %s: metrik-text nicht parsebar: %w", src.ModuleName, err)
 	}
 	out := make([]*dto.MetricFamily, 0, len(parsed))
 	for name, mf := range parsed {
 		renamed := fmt.Sprintf("nexarch_module_%s_%s", src.ModuleName, name)
 		mf.Name = &renamed
 		out = append(out, mf)
 	}
 	return out, nil
 }
 // Handler liefert einen HTTP-Handler, der Gather aufruft und das Ergebnis im
 // Prometheus-Textformat ausgibt (Akzeptanzkriterium 1).
 func (a *Aggregator) Handler() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		families, err := a.Gather(r.Context())
 		if err != nil {
 			http.Error(w, "metriken konnten nicht eingesammelt werden", http.StatusInternalServerError)
 			return
 		}
 		w.Header().Set("Content-Type", string(expfmt.NewFormat(expfmt.TypeTextPlain)))
 		enc := expfmt.NewEncoder(w, expfmt.NewFormat(expfmt.TypeTextPlain))
 		for _, mf := range families {
 			if err := enc.Encode(mf); err != nil {
 				return
 			}
 		}
 	}
 }
@@ -0,0 +1,179 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 	"github.com/prometheus/common/expfmt"
 	"github.com/prometheus/common/model"
 )
 func fakeModuleServer(metricName string) *httptest.Server {
 	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/plain; version=0.0.4")
 		fmt.Fprintf(w, "# HELP %s ein test-zaehler\n# TYPE %s counter\n%s 42\n", metricName, metricName, metricName)
 	}))
 }
 // Akzeptanzkriterium 1: Core liefert unter dem Handler valides
 // Prometheus-Textformat mit den eigenen Kennzahlen.
 func TestHandler_ServesCoreMetricsInPrometheusFormat(t *testing.T) {
 	agg := NewAggregator(NewCoreRegistry(), func(ctx context.Context) ([]Source, error) { return nil, nil })
 	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
 	rec := httptest.NewRecorder()
 	agg.Handler()(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200", rec.Code)
 	}
 	parser := expfmt.NewTextParser(model.LegacyValidation)
 	families, err := parser.TextToMetricFamilies(strings.NewReader(rec.Body.String()))
 	if err != nil {
 		t.Fatalf("antwort ist kein valides prometheus-textformat: %v", err)
 	}
 	if _, ok := families["nexarch_core_up"]; !ok {
 		t.Fatalf("erwartet 'nexarch_core_up' unter den core-metriken, habe: %v", keysOf(families))
 	}
 }
 func keysOf[V any](m map[string]V) []string {
 	out := make([]string, 0, len(m))
 	for k := range m {
 		out = append(out, k)
 	}
 	return out
 }
 // Akzeptanzkriterium 2 + Pruefung 2: ein NEU registriertes Modul erscheint
 // in der Aggregation, OHNE dass dieses Paket oder der Aufrufer Code
 // aendern muss — die Quelle kommt ausschliesslich aus sourceProvider.
 func TestHandler_NewlyRegisteredModuleAppearsWithoutCodeChange(t *testing.T) {
 	moduleServer := fakeModuleServer("requests_total")
 	defer moduleServer.Close()
 	// Simuliert eine sich zur Laufzeit aendernde Modul-Liste (z.B. aus
 	// SourceStore.Provide) — zunaechst LEER, dann mit einem Eintrag.
 	var sources []Source
 	var mu sync.Mutex
 	provider := func(ctx context.Context) ([]Source, error) {
 		mu.Lock()
 		defer mu.Unlock()
 		out := make([]Source, len(sources))
 		copy(out, sources)
 		return out, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	// Vor der Registrierung: Modul-Metrik nicht vorhanden.
 	rec1 := httptest.NewRecorder()
 	agg.Handler()(rec1, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	if strings.Contains(rec1.Body.String(), "requests_total") {
 		t.Fatal("modul-metrik haette vor registrierung nicht erscheinen duerfen")
 	}
 	// Modul wird "registriert" (kein Code hier oder in metrics.go aendert sich).
 	mu.Lock()
 	sources = append(sources, Source{ModuleName: "dms", MetricsURL: moduleServer.URL})
 	mu.Unlock()
 	rec2 := httptest.NewRecorder()
 	agg.Handler()(rec2, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	body := rec2.Body.String()
 	if !strings.Contains(body, "nexarch_module_dms_requests_total") {
 		t.Fatalf("erwartet umbenannte modul-metrik 'nexarch_module_dms_requests_total' nach registrierung, body:\n%s", body)
 	}
 }
 // Akzeptanzkriterium 3: Namenskonvention "nexarch_module_<modul>_<name>"
 // wird tatsaechlich angewendet.
 func TestFetchAndRename_AppliesNamingConvention(t *testing.T) {
 	moduleServer := fakeModuleServer("queue_depth")
 	defer moduleServer.Close()
 	agg := NewAggregator(NewCoreRegistry(), nil)
 	families, err := agg.fetchAndRename(context.Background(), Source{ModuleName: "mail", MetricsURL: moduleServer.URL})
 	if err != nil {
 		t.Fatalf("fetchAndRename: %v", err)
 	}
 	if len(families) != 1 || families[0].GetName() != "nexarch_module_mail_queue_depth" {
 		t.Fatalf("erwartet genau 1 metrik 'nexarch_module_mail_queue_depth', habe: %+v", families)
 	}
 }
 // Ein nicht erreichbares Modul darf die Aggregation der uebrigen und die
 // Gesamtantwort nicht verhindern (dieselbe Resilienz wie OPS-02).
 func TestHandler_UnreachableModuleDoesNotBreakAggregation(t *testing.T) {
 	reachable := fakeModuleServer("healthy_metric")
 	defer reachable.Close()
 	unreachable := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
 	unreachableURL := unreachable.URL
 	unreachable.Close() // sofort schliessen -> Verbindung schlaegt fehl
 	provider := func(ctx context.Context) ([]Source, error) {
 		return []Source{
 			{ModuleName: "ok", MetricsURL: reachable.URL},
 			{ModuleName: "kaputt", MetricsURL: unreachableURL},
 		}, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	rec := httptest.NewRecorder()
 	agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200 trotz einem nicht erreichbaren modul", rec.Code)
 	}
 	body := rec.Body.String()
 	if !strings.Contains(body, "nexarch_module_ok_healthy_metric") {
 		t.Fatal("erreichbares modul haette trotz ausfall des anderen aggregiert werden sollen")
 	}
 	if strings.Contains(body, "kaputt") {
 		t.Fatal("nicht erreichbares modul haette keine metrik beitragen duerfen")
 	}
 }
 // Pruefung 1: Endpunkt antwortet unter mehreren gleichzeitigen Anfragen
 // innerhalb definierter Zeit — kein unbeschraenktes Blockieren durch
 // langsame Module (FetchTimeout begrenzt jeden Scrape).
 func TestHandler_RespondsWithinBoundedTimeUnderLoad(t *testing.T) {
 	hangingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		time.Sleep(10 * time.Second) // wuerde ohne timeout jede anfrage blockieren
 	}))
 	defer hangingServer.Close()
 	provider := func(ctx context.Context) ([]Source, error) {
 		return []Source{{ModuleName: "haengend", MetricsURL: hangingServer.URL}}, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	const concurrentRequests = 10
 	var wg sync.WaitGroup
 	start := time.Now()
 	for i := 0; i < concurrentRequests; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			rec := httptest.NewRecorder()
 			agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 			if rec.Code != http.StatusOK {
 				t.Errorf("status = %d, want 200", rec.Code)
 			}
 		}()
 	}
 	wg.Wait()
 	elapsed := time.Since(start)
 	if elapsed > FetchTimeout+3*time.Second {
 		t.Fatalf("%d gleichzeitige anfragen brauchten %s, erwartet deutlich unter %s durch FetchTimeout",
 			concurrentRequests, elapsed, FetchTimeout+3*time.Second)
 	}
 }
@@ -0,0 +1,52 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SourceStore persistiert, welche Module ihre Metriken unter welcher URL
 // bereitstellen — dieselbe Postgres-basierte "kein Code-Deploy noetig"-
 // Konvention wie internal/statuspage.Store.RegisterTarget (OPS-02): ein neu
 // registriertes Modul erscheint automatisch in der Aggregation, sobald es
 // hier eingetragen ist (Akzeptanzkriterium 2 / Pruefung 2).
 type SourceStore struct {
 	pool *pgxpool.Pool
 }
 func NewSourceStore(pool *pgxpool.Pool) *SourceStore {
 	return &SourceStore{pool: pool}
 }
 func (s *SourceStore) RegisterSource(ctx context.Context, moduleName, metricsURL string) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO metrics_sources (module_name, metrics_url)
 		VALUES ($1, $2)
 		ON CONFLICT (module_name) DO UPDATE SET metrics_url = $2
 	`, moduleName, metricsURL)
 	if err != nil {
 		return fmt.Errorf("metrik-quelle speichern: %w", err)
 	}
 	return nil
 }
 // Provide implementiert SourceProvider direkt aus der Datenbank.
 func (s *SourceStore) Provide(ctx context.Context) ([]Source, error) {
 	rows, err := s.pool.Query(ctx, `SELECT module_name, metrics_url FROM metrics_sources ORDER BY module_name`)
 	if err != nil {
 		return nil, fmt.Errorf("metrik-quellen auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Source
 	for rows.Next() {
 		var src Source
 		if err := rows.Scan(&src.ModuleName, &src.MetricsURL); err != nil {
 			return nil, fmt.Errorf("metrik-quelle lesen: %w", err)
 		}
 		out = append(out, src)
 	}
 	return out, rows.Err()
 }
@@ -0,0 +1,60 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupSourceStoreTest(t *testing.T) (*SourceStore, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS metrics_sources (module_name TEXT PRIMARY KEY, metrics_url TEXT NOT NULL)
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewSourceStore(pool), cleanup
 }
 // Akzeptanzkriterium 2 / Pruefung 2 auf Persistenz-Ebene: eine ueber die
 // Datenbank registrierte Quelle ist sofort ueber Provide() sichtbar — genau
 // der Mechanismus, der ein neues Modul ohne Core-Codeaenderung erscheinen
 // laesst.
 func TestSourceStore_RegisterSourceAppearsInProvide(t *testing.T) {
 	store, cleanup := setupSourceStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := fmt.Sprintf("modul-%d", time.Now().UnixNano())
 	if err := store.RegisterSource(ctx, name, "http://example.invalid/metrics"); err != nil {
 		t.Fatalf("registersource: %v", err)
 	}
 	sources, err := store.Provide(ctx)
 	if err != nil {
 		t.Fatalf("provide: %v", err)
 	}
 	found := false
 	for _, s := range sources {
 		if s.ModuleName == name {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("erwartet %s in provide()-ergebnis, habe: %+v", name, sources)
 	}
 }
@@ -71,6 +71,17 @@ func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error
 	return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
 }
 // Invalidate erzwingt beim naechsten Get-Aufruf einen sofortigen Refresh
 // statt auf den TTL-Ablauf zu warten (API-06, Akzeptanzkriterium 1: ein
 // Health-Check-getriggerter Wiederanlauf soll den Cache SOFORT aktualisieren,
 // nicht die reguläre TTL abwarten) — rein additiv, aendert nichts an
 // Get/RequireFresh (dasselbe Muster wie internal/flag.Service.Invalidate).
 func (c *StaleCache[T]) Invalidate() {
 	c.mu.Lock()
 	c.hasValue = false
 	c.mu.Unlock()
 }
 // RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
 // Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
 func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
@@ -0,0 +1,42 @@
 package openapi
 import (
 	"encoding/json"
 	"fmt"
 	"net/http"
 )
 // DocumentHandler liefert das OpenAPI-Dokument als JSON — der Endpunkt, den
 // Swagger UI/Postman/etc. importieren (Akzeptanzkriterium 3).
 func DocumentHandler(doc Document) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(doc)
 	}
 }
 // SwaggerUIHandler liefert eine minimale HTML-Seite, die Swagger UI ueber
 // ein CDN laedt und gegen docURL rendert — Standardmuster fuer
 // "in gaengigen Tools darstellbar" (Akzeptanzkriterium 3), ohne eine eigene
 // Swagger-UI-Distribution einzubetten.
 func SwaggerUIHandler(docURL string) http.HandlerFunc {
 	page := fmt.Sprintf(`<!doctype html>
 <html>
 <head>
  <title>NEXARCH Core API</title>
  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist/swagger-ui.css" />
 </head>
 <body>
  <div id="swagger-ui"></div>
  <script src="https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js"></script>
  <script>
    window.onload = () => SwaggerUIBundle({ url: %q, dom_id: "#swagger-ui" });
  </script>
 </body>
 </html>`, docURL)
 	return func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
 		_, _ = w.Write([]byte(page))
 	}
 }
@@ -0,0 +1,158 @@
 // Package openapi implementiert Core API-04: eine OpenAPI-3.x-Beschreibung
 // der Core-API, die automatisiert gegen die tatsaechlich registrierten
 // Routen von internal/apiserver.Server geprueft wird (Akzeptanzkriterium 2)
 // — kein manuell gepflegtes Dokument, das unbemerkt vom Code abweichen kann.
 package openapi
 import (
 	"fmt"
 	"sort"
 	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
 )
 // Entry beschreibt EINEN dokumentierten Endpunkt inklusive eines
 // Beispielaufrufs (Akzeptanzkriterium 2 / Pruefung 2: "Beispielaufrufe aus
 // dem Dokument gegen die echte API erfolgreich ausgefuehrt").
 type Entry struct {
 	// Path ist der VOLLSTAENDIGE, versionierte Pfad (z.B. "/api/v1/things"),
 	// identisch zu dem, was apiserver.Server.RegisteredPaths() liefert.
 	Path        string
 	Method      string
 	Summary     string
 	Description string
 	// ExampleRequest wird von CheckExamples tatsaechlich gegen den Server
 	// ausgefuehrt (Cookie, Body etc. sind Sache des Aufrufers, siehe
 	// openapi_test.go) — dieses Paket fuehrt nur die HTTP-Anfrage aus und
 	// prueft ExpectStatus.
 	ExampleRequest ExampleRequest
 	ExpectStatus   int
 }
 // ExampleRequest ist minimal genug, um sowohl in das OpenAPI-Dokument als
 // auch als tatsaechliche HTTP-Anfrage verwendet zu werden — EIN Beispiel,
 // zwei Verwendungen, damit Dokument und Test nie auseinanderlaufen koennen.
 type ExampleRequest struct {
 	Method      string
 	Path        string
 	Description string
 }
 // Document ist eine bewusst schlanke OpenAPI-3.0-Repraesentation — genug,
 // um valide zu sein und von Swagger UI/Postman importiert zu werden
 // (Akzeptanzkriterium 3), ohne eine vollstaendige OpenAPI-Bibliothek zu
 // integrieren.
 type Document struct {
 	OpenAPI string                `json:"openapi"`
 	Info    Info                  `json:"info"`
 	Paths   map[string]PathItem   `json:"paths"`
 }
 type Info struct {
 	Title   string `json:"title"`
 	Version string `json:"version"`
 }
 type PathItem map[string]Operation
 type Operation struct {
 	Summary     string `json:"summary"`
 	Description string `json:"description,omitempty"`
 	Responses   map[string]Response `json:"responses"`
 }
 type Response struct {
 	Description string `json:"description"`
 }
 // BuildDocument erzeugt das OpenAPI-Dokument AUS denselben Entries, die auch
 // fuer den Drift-Abgleich (CheckNoDrift) und die Beispielausfuehrung
 // (siehe openapi_test.go) verwendet werden — eine einzige Quelle statt
 // eines separat gepflegten Dokuments.
 func BuildDocument(title, version string, entries []Entry) Document {
 	paths := make(map[string]PathItem)
 	for _, e := range entries {
 		item, ok := paths[e.Path]
 		if !ok {
 			item = PathItem{}
 		}
 		item[toLowerMethod(e.Method)] = Operation{
 			Summary:     e.Summary,
 			Description: e.Description,
 			Responses: map[string]Response{
 				fmt.Sprintf("%d", e.ExpectStatus): {Description: "Beispielhafte Antwort"},
 			},
 		}
 		paths[e.Path] = item
 	}
 	return Document{
 		OpenAPI: "3.0.3",
 		Info:    Info{Title: title, Version: version},
 		Paths:   paths,
 	}
 }
 func toLowerMethod(m string) string {
 	switch m {
 	case "GET", "get":
 		return "get"
 	case "POST", "post":
 		return "post"
 	case "PUT", "put":
 		return "put"
 	case "DELETE", "delete":
 		return "delete"
 	case "PATCH", "patch":
 		return "patch"
 	default:
 		return "get"
 	}
 }
 // ErrDrift wird von CheckNoDrift geliefert, wenn dokumentierte und
 // tatsaechlich registrierte Pfade auseinanderlaufen (Akzeptanzkriterium 2 /
 // Pruefung 1).
 type ErrDrift struct {
 	MissingInDocument []string // registriert, aber nicht dokumentiert
 	MissingAsRoute    []string // dokumentiert, aber nicht (mehr) registriert
 }
 func (e *ErrDrift) Error() string {
 	return fmt.Sprintf("openapi: drift erkannt — nicht dokumentiert: %v, nicht (mehr) registriert: %v",
 		e.MissingInDocument, e.MissingAsRoute)
 }
 // CheckNoDrift vergleicht die tatsaechlich registrierten Pfade eines
 // Servers mit den in entries dokumentierten Pfaden — vollstaendige
 // Uebereinstimmung der PATH-Menge (nicht Methode je Pfad, da
 // apiserver.Server.Handle methodenunabhaengig registriert). Ein absichtlich
 // entfernter Eintrag auf beiden Seiten (siehe Tests) macht diese Funktion
 // fehlschlagen, das ist der geforderte Drift-Nachweis.
 func CheckNoDrift(server *apiserver.Server, entries []Entry) error {
 	registered := make(map[string]bool)
 	for _, p := range server.RegisteredPaths() {
 		registered[p] = true
 	}
 	documented := make(map[string]bool)
 	for _, e := range entries {
 		documented[e.Path] = true
 	}
 	var missingInDoc, missingAsRoute []string
 	for p := range registered {
 		if !documented[p] {
 			missingInDoc = append(missingInDoc, p)
 		}
 	}
 	for p := range documented {
 		if !registered[p] {
 			missingAsRoute = append(missingAsRoute, p)
 		}
 	}
 	if len(missingInDoc) == 0 && len(missingAsRoute) == 0 {
 		return nil
 	}
 	sort.Strings(missingInDoc)
 	sort.Strings(missingAsRoute)
 	return &ErrDrift{MissingInDocument: missingInDoc, MissingAsRoute: missingAsRoute}
 }
@@ -0,0 +1,142 @@
 package openapi
 import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 	"gitea.perlbach24.de/scripte/nexarch/internal/apiserver"
 	"gitea.perlbach24.de/scripte/nexarch/internal/auth"
 )
 func newTestServerWithRoutes() (*apiserver.Server, *auth.TokenIssuer) {
 	issuer := auth.NewTokenIssuer("test-secret-nur-fuer-tests")
 	srv := apiserver.NewServer(issuer)
 	srv.HandleV1("/things", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	srv.HandleV1("/other", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 	return srv, issuer
 }
 func testEntries() []Entry {
 	return []Entry{
 		{Path: "/api/v1/things", Method: "GET", Summary: "Dinge auflisten", ExpectStatus: http.StatusOK},
 		{Path: "/api/v1/other", Method: "GET", Summary: "Anderes abrufen", ExpectStatus: http.StatusOK},
 	}
 }
 // Akzeptanzkriterium 1: das Dokument deckt alle tatsaechlich registrierten
 // Endpunkte ab.
 func TestCheckNoDrift_PassesWhenDocumentMatchesRoutes(t *testing.T) {
 	srv, _ := newTestServerWithRoutes()
 	if err := CheckNoDrift(srv, testEntries()); err != nil {
 		t.Fatalf("erwartet keinen drift, habe: %v", err)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1: automatisierter Abgleich schlaegt bei
 // Drift fehl — hier absichtlich eine Route aus dem Dokument entfernt, waehrend
 // der Server sie weiterhin registriert hat.
 func TestCheckNoDrift_FailsWhenRouteMissingFromDocument(t *testing.T) {
 	srv, _ := newTestServerWithRoutes()
 	entries := []Entry{testEntries()[0]} // "/api/v1/other" absichtlich entfernt
 	err := CheckNoDrift(srv, entries)
 	if err == nil {
 		t.Fatal("erwartet drift-fehler, da eine registrierte route nicht dokumentiert ist")
 	}
 	driftErr, ok := err.(*ErrDrift)
 	if !ok {
 		t.Fatalf("erwartet *ErrDrift, habe %T", err)
 	}
 	if len(driftErr.MissingInDocument) != 1 || driftErr.MissingInDocument[0] != "/api/v1/other" {
 		t.Fatalf("erwartet '/api/v1/other' als nicht dokumentiert, habe: %v", driftErr.MissingInDocument)
 	}
 }
 // Symmetrischer Fall: Dokument nennt eine Route, die es beim Server gar
 // nicht (mehr) gibt (z.B. nach Entfernen eines Endpunkts im Code).
 func TestCheckNoDrift_FailsWhenDocumentedRouteNoLongerExists(t *testing.T) {
 	srv, _ := newTestServerWithRoutes()
 	entries := append(testEntries(), Entry{Path: "/api/v1/entfernt", Method: "GET", ExpectStatus: http.StatusOK})
 	err := CheckNoDrift(srv, entries)
 	if err == nil {
 		t.Fatal("erwartet drift-fehler fuer dokumentierte, aber nicht registrierte route")
 	}
 	driftErr := err.(*ErrDrift)
 	if len(driftErr.MissingAsRoute) != 1 || driftErr.MissingAsRoute[0] != "/api/v1/entfernt" {
 		t.Fatalf("erwartet '/api/v1/entfernt' als nicht (mehr) registriert, habe: %v", driftErr.MissingAsRoute)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Beispielaufrufe aus dem Dokument
 // werden GEGEN DIE ECHTE API (httptest, echte Middleware-Kette) ausgefuehrt.
 func TestExamples_ExecuteSuccessfullyAgainstRealServer(t *testing.T) {
 	srv, issuer := newTestServerWithRoutes()
 	token, err := issuer.Issue("user-1", "acme")
 	if err != nil {
 		t.Fatalf("issue: %v", err)
 	}
 	for _, e := range testEntries() {
 		req := httptest.NewRequest(e.Method, e.Path, nil)
 		req.AddCookie(&http.Cookie{Name: auth.CookieName, Value: token})
 		rec := httptest.NewRecorder()
 		srv.Handler().ServeHTTP(rec, req)
 		if rec.Code != e.ExpectStatus {
 			t.Fatalf("beispielaufruf %s %s: status = %d, want %d", e.Method, e.Path, rec.Code, e.ExpectStatus)
 		}
 	}
 }
 // Akzeptanzkriterium 3: Dokument ist ueber einen Endpunkt abrufbar und
 // valides JSON, das Tools wie Swagger UI importieren koennen.
 func TestDocumentHandler_ServesValidJSONWithAllPaths(t *testing.T) {
 	doc := BuildDocument("NEXARCH Core API", "v1", testEntries())
 	req := httptest.NewRequest(http.MethodGet, "/api/v1/openapi.json", nil)
 	rec := httptest.NewRecorder()
 	DocumentHandler(doc)(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200", rec.Code)
 	}
 	var decoded Document
 	if err := json.Unmarshal(rec.Body.Bytes(), &decoded); err != nil {
 		t.Fatalf("dokument nicht als json lesbar: %v", err)
 	}
 	if decoded.OpenAPI == "" {
 		t.Fatal("erwartet gesetztes openapi-versionsfeld")
 	}
 	for _, e := range testEntries() {
 		if _, ok := decoded.Paths[e.Path]; !ok {
 			t.Fatalf("pfad %s fehlt im dekodierten dokument", e.Path)
 		}
 	}
 }
 func TestSwaggerUIHandler_ServesHTMLReferencingDocumentURL(t *testing.T) {
 	req := httptest.NewRequest(http.MethodGet, "/api/v1/docs", nil)
 	rec := httptest.NewRecorder()
 	SwaggerUIHandler("/api/v1/openapi.json")(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200", rec.Code)
 	}
 	ct := rec.Header().Get("Content-Type")
 	if ct == "" {
 		t.Fatal("erwartet gesetzten Content-Type-Header")
 	}
 	body := rec.Body.String()
 	if !strings.Contains(body, "/api/v1/openapi.json") {
 		t.Fatal("erwartet referenz auf das openapi-dokument in der swagger-ui-seite")
 	}
 }
@@ -0,0 +1,9 @@
 // Package opsdocs enthaelt keine Laufzeitlogik — es haelt ausschliesslich
 // den Pfad zum Incident-Response-Plan (Core OPS-04) fest, damit ein
 // automatisierter Test (siehe opsdocs_test.go) pruefen kann, dass die
 // darin geforderten Pflichtinhalte (Meldefrist, Verantwortlichkeiten,
 // Audit-Log-Anknuepfung) nicht versehentlich aus dem Dokument verschwinden.
 package opsdocs
 // IncidentResponsePlanPath ist der Pfad relativ zum Repository-Root.
 const IncidentResponsePlanPath = "docs/INCIDENT-RESPONSE-PLAN.md"
@@ -0,0 +1,68 @@
 package opsdocs
 import (
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 )
 func readPlan(t *testing.T) string {
 	t.Helper()
 	// Test laeuft aus internal/opsdocs/ heraus, Repo-Root ist zwei Ebenen hoeher.
 	path := filepath.Join("..", "..", IncidentResponsePlanPath)
 	data, err := os.ReadFile(path)
 	if err != nil {
 		t.Fatalf("incident-response-plan nicht lesbar (%s): %v", path, err)
 	}
 	return string(data)
 }
 func requireContains(t *testing.T, content, substr, why string) {
 	t.Helper()
 	if !strings.Contains(content, substr) {
 		t.Fatalf("erwartet %q im incident-response-plan (%s), nicht gefunden", substr, why)
 	}
 }
 // Akzeptanzkriterium 1: Ablaufplan dokumentiert Erkennung/Eskalation/
 // Meldefristen/Verantwortlichkeiten.
 func TestPlan_DocumentsDetectionEscalationAndResponsibilities(t *testing.T) {
 	content := readPlan(t)
 	requireContains(t, content, "Erkennung", "Abschnitt Erkennung fehlt")
 	requireContains(t, content, "Eskalationskette", "Abschnitt Eskalation fehlt")
 	requireContains(t, content, "Incident Commander", "Verantwortlichkeits-Rolle fehlt")
 	requireContains(t, content, "Datenschutzbeauftragter", "DSB-Rolle fehlt")
 }
 // Akzeptanzkriterium 2: DSGVO-72-Stunden-Meldefrist ist als Prozessschritt
 // mit Verantwortlichem hinterlegt.
 func TestPlan_Documents72HourGDPRDeadlineWithResponsibleRole(t *testing.T) {
 	content := readPlan(t)
 	requireContains(t, content, "72 Stunden", "72-Stunden-Frist fehlt")
 	requireContains(t, content, "Art. 33", "Verweis auf Art. 33 DSGVO fehlt")
 	requireContains(t, content, "Verantwortlich für die Meldung", "Zuständigkeit für die Meldung fehlt")
 }
 // Akzeptanzkriterium 3: Plan verweist konkret auf die Audit-Log-Quellen
 // (Core AUD-01/AUD-03/AUD-05), die im Vorfall herangezogen werden.
 func TestPlan_ReferencesConcreteAuditLogSources(t *testing.T) {
 	content := readPlan(t)
 	requireContains(t, content, "AUD-01", "Verweis auf AUD-01 fehlt")
 	requireContains(t, content, "AUD-03", "Verweis auf AUD-03 (Export) fehlt")
 	requireContains(t, content, "internal/audit", "konkreter Code-Pfad zum Audit-Log fehlt")
 	requireContains(t, content, "StreamCSV", "konkrete Export-Funktion fehlt")
 }
 // Zusaetzliche Absicherung: die drei geforderten Pruefungen sind im
 // Dokument tatsaechlich mit einem Ergebnis (PASS/OFFEN) festgehalten,
 // nicht nur als Vorhaben erwaehnt — verhindert, dass "durchgefuehrt"
 // behauptet wird, ohne das Ergebnis schriftlich festzuhalten (Ticket-
 // Vorgabe: "Nicht durchgefuehrte Pruefungen zaehlen als offen").
 func TestPlan_RecordsAllThreeRequiredCheckResults(t *testing.T) {
 	content := readPlan(t)
 	requireContains(t, content, "Prüfung 1", "Ergebnis der Tabletop-Übung fehlt")
 	requireContains(t, content, "Prüfung 2", "Ergebnis der Meldefrist-Vollständigkeitsprüfung fehlt")
 	requireContains(t, content, "Prüfung 3", "Ergebnis der Kontaktlisten-Prüfung fehlt")
 	requireContains(t, content, "Status: OFFEN", "ehrlicher Offen-Status fuer die nicht durchfuehrbare Kontaktlisten-Pruefung fehlt")
 }
@@ -76,7 +76,7 @@ func applyAllUpSQL(t *testing.T, ctx context.Context, pool *pgxpool.Pool, dir st
 		}
 		if _, err := pool.Exec(ctx, string(sqlBytes)); err != nil {
 			var pgErr *pgconn.PgError
-			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710") {
+			if errors.As(err, &pgErr) && (pgErr.Code == "42P07" || pgErr.Code == "42701" || pgErr.Code == "42710" || pgErr.Code == "42723") {
 				continue
 			}
 			t.Fatalf("migration %q anwenden: %v", name, err)
@@ -0,0 +1,90 @@
 package policy
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
 // ModuleScope verknuepft eine Policy-Regel mit einem Feature-Flag: existiert
 // ein ModuleScope fuer (role, permission), gilt die Regel nur zusaetzlich zur
 // Grundberechtigung, wenn FlagKey fuer den jeweiligen Tenant aktiv ist
 // (Akzeptanzkriterium 1: Rechte folgen der Lizenz).
 type ModuleScope struct {
 	Role       rbac.Role
 	Permission rbac.Permission
 	Module     string
 	FlagKey    string
 }
 // SetModuleScope verknuepft eine bestehende Policy-Regel mit einem Modul/
 // Feature-Flag. Die Regel selbst (Store.Grant) muss unabhaengig davon
 // existieren — ModuleScope schraenkt sie nur zusaetzlich ein.
 func (s *Store) SetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission, module, flagKey string) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO policy_module_scopes (role, permission, module, flag_key)
 		VALUES ($1, $2, $3, $4)
 		ON CONFLICT (role, permission) DO UPDATE SET module = $3, flag_key = $4
 	`, string(role), string(perm), module, flagKey)
 	if err != nil {
 		return fmt.Errorf("modul-scope setzen: %w", err)
 	}
 	return nil
 }
 func (s *Store) GetModuleScope(ctx context.Context, role rbac.Role, perm rbac.Permission) (ModuleScope, bool, error) {
 	var ms ModuleScope
 	ms.Role, ms.Permission = role, perm
 	err := s.pool.QueryRow(ctx, `
 		SELECT module, flag_key FROM policy_module_scopes WHERE role = $1 AND permission = $2
 	`, string(role), string(perm)).Scan(&ms.Module, &ms.FlagKey)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return ModuleScope{}, false, nil
 		}
 		return ModuleScope{}, false, fmt.Errorf("modul-scope lesen: %w", err)
 	}
 	return ms, true, nil
 }
 // AuthorizeForTenant ist dieselbe zentrale Entscheidungsfunktion wie
 // Authorize (Akzeptanzkriterium 3: keine zweite Enforcement-Schicht),
 // erweitert um die Modul-Scoping-Pruefung: eine sonst passende Regel greift
 // NICHT, wenn das zugehoerige Modul fuer den Tenant nicht aktiviert ist
 // (Akzeptanzkriterium 1). Feature-Flag-Aenderungen wirken ohne Neustart
 // (Akzeptanzkriterium 2), da flag.Service dieselbe TTL-Cache-Instanz der
 // aufrufenden Core-Instanz nutzt.
 func (e *Enforcer) AuthorizeForTenant(ctx context.Context, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission) error {
 	if err := e.Authorize(ctx, role, perm); err != nil {
 		return err
 	}
 	scope, found, err := e.store.GetModuleScope(ctx, role, perm)
 	if err != nil {
 		return err
 	}
 	if !found {
 		return nil // keine Modul-Bindung fuer diese Regel — Grundberechtigung reicht.
 	}
 	if !flags.IsEnabled(ctx, tenantSlug, scope.FlagKey) {
 		return fmt.Errorf("%w: modul %q ist fuer diesen mandanten nicht aktiviert", ErrDenied, scope.Module)
 	}
 	return nil
 }
 // GuardModuleScoped ist Guard mit zusaetzlicher Modul-Scoping-Pruefung —
 // dieselbe zentrale Enforcement-Funktion, kein paralleler Mechanismus
 // (Akzeptanzkriterium 3).
 func GuardModuleScoped[T any](ctx context.Context, e *Enforcer, flags *flag.Service, tenantSlug string, role rbac.Role, perm rbac.Permission, query func(ctx context.Context) (T, error)) (T, error) {
 	var zero T
 	if err := e.AuthorizeForTenant(ctx, flags, tenantSlug, role, perm); err != nil {
 		return zero, err
 	}
 	return query(ctx)
 }
@@ -0,0 +1,170 @@
 package policy
 import (
 	"context"
 	"errors"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
 func setupModuleScopeTest(t *testing.T) (*Store, *Enforcer, *flag.Store, *flag.Service, 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 policy_rules (
 			role TEXT NOT NULL, permission TEXT NOT NULL,
 			granted_by TEXT NOT NULL, granted_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			PRIMARY KEY (role, permission)
 		);
 		CREATE TABLE IF NOT EXISTS policy_rule_changes (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
 			action TEXT NOT NULL CHECK (action IN ('grant','revoke')), actor TEXT NOT NULL,
 			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS policy_module_scopes (
 			role TEXT NOT NULL, permission TEXT NOT NULL, module TEXT NOT NULL, flag_key TEXT NOT NULL,
 			PRIMARY KEY (role, permission)
 		);
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	store := NewStore(pool)
 	flagStore := flag.NewStore(pool)
 	flagService := flag.NewService(flagStore, 10*time.Millisecond) // kurze TTL fuer testbare invalidierung
 	cleanup := func() {
 		_, _ = pool.Exec(ctx, `DELETE FROM policy_module_scopes WHERE role LIKE 'test\_%' ESCAPE '\'`)
 		_, _ = pool.Exec(ctx, `DELETE FROM policy_rule_changes WHERE role LIKE 'test\_%' ESCAPE '\'`)
 		_, _ = pool.Exec(ctx, `DELETE FROM policy_rules WHERE role LIKE 'test\_%' ESCAPE '\'`)
 		_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
 		pool.Close()
 	}
 	return store, NewEnforcer(store), flagStore, flagService, cleanup
 }
 // Akzeptanzkriterium 1 + Pruefung 1: Berechtigung fuer nicht aktiviertes
 // Modul greift nicht, selbst bei sonst passender Rolle.
 func TestAuthorizeForTenant_DeniesWhenModuleNotActivated(t *testing.T) {
 	store, enforcer, _, flagService, cleanup := setupModuleScopeTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	role := rbac.Role("test_dms_nutzer")
 	perm := rbac.Permission("test_dokumente_lesen")
 	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
 		t.Fatalf("grant: %v", err)
 	}
 	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled"); err != nil {
 		t.Fatalf("set module scope: %v", err)
 	}
 	// Flag existiert nicht/ist nicht gesetzt -> IsEnabled liefert false (Fail-Safe-Default).
 	queryCalled := false
 	_, err := GuardModuleScoped(ctx, enforcer, flagService, "acme", role, perm, func(ctx context.Context) (string, error) {
 		queryCalled = true
 		return "daten", nil
 	})
 	if !errors.Is(err, ErrDenied) {
 		t.Fatalf("erwartet ErrDenied bei deaktiviertem modul, habe %v", err)
 	}
 	if queryCalled {
 		t.Fatal("query haette bei deaktiviertem modul nicht aufgerufen werden duerfen")
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: Aktivierung des Moduls macht die
 // Berechtigung ohne Neustart wirksam.
 func TestAuthorizeForTenant_BecomesActiveWithoutRestart(t *testing.T) {
 	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	role := rbac.Role("test_dms_nutzer2")
 	perm := rbac.Permission("test_dokumente_schreiben")
 	if err := store.Grant(ctx, role, perm, "admin@example.com"); err != nil {
 		t.Fatalf("grant: %v", err)
 	}
 	if err := store.SetModuleScope(ctx, role, perm, "dms", "test_dms_enabled2"); err != nil {
 		t.Fatalf("set module scope: %v", err)
 	}
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); !errors.Is(err, ErrDenied) {
 		t.Fatalf("vor aktivierung: erwartet ErrDenied, habe %v", err)
 	}
 	// Modul "im laufenden Betrieb" aktivieren — derselbe Prozess, kein Neustart.
 	if err := flagStore.Set(ctx, flag.Flag{Key: "test_dms_enabled2", Enabled: true}); err != nil {
 		t.Fatalf("flag setzen: %v", err)
 	}
 	time.Sleep(20 * time.Millisecond) // TTL abwarten statt Neustart
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", role, perm); err != nil {
 		t.Fatalf("nach aktivierung sollte erlaubt sein: %v", err)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Zusammenspiel Modul-Scope + Rollenscope
 // in Kombinationsfaellen.
 func TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope(t *testing.T) {
 	store, enforcer, flagStore, flagService, cleanup := setupModuleScopeTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	scopedRole := rbac.Role("test_scoped_rolle")
 	unscopedRole := rbac.Role("test_unscoped_rolle")
 	perm := rbac.Permission("test_kombiniert")
 	// Fall 1: Rolle ohne jegliche Regel -> verboten, unabhaengig vom Flag.
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", rbac.Role("test_unbekannt"), perm); !errors.Is(err, ErrDenied) {
 		t.Fatalf("fall 1: erwartet ErrDenied (keine regel), habe %v", err)
 	}
 	// Fall 2: Regel vorhanden, KEIN Modul-Scope -> immer erlaubt (Grundrecht ohne Lizenzbindung).
 	if err := store.Grant(ctx, unscopedRole, perm, "admin@example.com"); err != nil {
 		t.Fatalf("grant unscoped: %v", err)
 	}
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", unscopedRole, perm); err != nil {
 		t.Fatalf("fall 2: erwartet erlaubt ohne modul-scope, habe %v", err)
 	}
 	// Fall 3: Regel + Modul-Scope, Flag aus -> verboten.
 	if err := store.Grant(ctx, scopedRole, perm, "admin@example.com"); err != nil {
 		t.Fatalf("grant scoped: %v", err)
 	}
 	if err := store.SetModuleScope(ctx, scopedRole, perm, "mail", "test_mail_enabled"); err != nil {
 		t.Fatalf("set module scope: %v", err)
 	}
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); !errors.Is(err, ErrDenied) {
 		t.Fatalf("fall 3: erwartet ErrDenied (modul aus), habe %v", err)
 	}
 	// Fall 4: Regel + Modul-Scope, Flag an -> erlaubt.
 	if err := flagStore.Set(ctx, flag.Flag{Key: "test_mail_enabled", Enabled: true}); err != nil {
 		t.Fatalf("flag setzen: %v", err)
 	}
 	time.Sleep(20 * time.Millisecond)
 	if err := enforcer.AuthorizeForTenant(ctx, flagService, "acme", scopedRole, perm); err != nil {
 		t.Fatalf("fall 4: erwartet erlaubt (modul an), habe %v", err)
 	}
 }
@@ -11,6 +11,7 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 	"gitea.perlbach24.de/scripte/nexarch/internal/rbac"
 )
@@ -33,13 +34,22 @@ type RuleChange struct {
 // Datenbank — es gibt keinen hartcodierten Go-Fallback, ein Regelwechsel
 // wirkt sich ohne Codeaenderung sofort aus (Akzeptanzkriterium 2 / 3).
 type Store struct {
-	pool *pgxpool.Pool
+	pool  *pgxpool.Pool
 	audit *audit.Log
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // WithAudit liefert einen Store, der jede Regelaenderung zusaetzlich im
 // zentralen, unveraenderlichen Audit-Log (AUD-01/AUD-02) protokolliert
 // (AUD-06) — rein additiv, aendert nichts am Verhalten ohne gesetzten
 // Audit-Log (log == nil bleibt gueltig, z.B. in bestehenden Tests).
 func (s *Store) WithAudit(log *audit.Log) *Store {
 	return &Store{pool: s.pool, audit: log}
 }
 // IsAllowed prueft, ob role das Recht permission besitzt. Default-Deny:
 // existiert keine passende Regel, ist der Zugriff verboten
 // (Akzeptanzkriterium 2 / Pruefung 2) — es gibt keinen impliziten
@@ -97,7 +107,25 @@ func (s *Store) change(ctx context.Context, role rbac.Role, perm rbac.Permission
 		return fmt.Errorf("historie schreiben: %w", err)
 	}
-	return tx.Commit(ctx)
+	if err := tx.Commit(ctx); err != nil {
 		return err
 	}
 	// Audit-Log-Eintrag NACH dem Commit (AUD-06): die Regelaenderung selbst
 	// ist bereits dauerhaft, ein Fehler beim Audit-Log darf die eigentliche
 	// Aktion nicht rueckgaengig machen oder blockieren — nur protokolliert,
 	// nicht scharf gemacht (dasselbe Prinzip wie bei den anderen hier
 	// verdrahteten Stellen).
 	if s.audit != nil {
 		_ = s.audit.Record(ctx, audit.Event{
 			TenantSlug: audit.SystemTenant,
 			Actor:      actor,
 			Action:     "policy." + action,
 			Target:     fmt.Sprintf("%s:%s", role, perm),
 		})
 	}
 	return nil
 }
 // History liefert die vollstaendige, versionierte Aenderungshistorie einer
@@ -0,0 +1,125 @@
 package rbac
 import (
 	"context"
 	"testing"
 )
 // QA-03 Akzeptanzkriterium 2 / Pruefung 1: gezielter Umgehungsversuch der
 // zentralen Policy-Schicht (RBAC-02, internal/policy.Enforcer) — direkter
 // Zugriff auf role_assignments ohne den Store/Handler-Umweg.
 //
 // Ergebnis: erfolglos abgewiesen. Store.Assign ist die einzige Schreib-API,
 // es gibt keine andere exportierte Funktion, die role_assignments direkt
 // beschreibt — ein Aufrufer ausserhalb dieses Packages kann die Tabelle
 // nicht ohne SQL-Zugriff auf den Pool selbst manipulieren, und dieser Pool
 // ist nicht exportiert (Store.pool ist ein unexportiertes Feld).
 func TestBypass_NoDirectWriteAPIOutsideStore(t *testing.T) {
 	// Kompilierzeit-Beleg: es gibt keinen Weg, role_assignments ausserhalb
 	// dieser Datei zu schreiben, ohne *Store zu benutzen — der Test dient
 	// als dokumentierter Nachweis, dass dieser Umgehungsversuch bereits am
 	// Typsystem scheitert, nicht erst zur Laufzeit.
 	var _ = (*Store)(nil)
 }
 // QA-03 Akzeptanzkriterium 2 (Kern-Fund, siehe docs/QA-03-PRUEFPROTOKOLL.md
 // "Abweichungen"): internal/rbac/handler.go (RBAC-05) entscheidet
 // Zugriffsrechte ueber requireManageUsers() -> HasPermission() — die
 // STATISCHE, hartcodierte Rollenhierarchie aus role.go. Es ruft NICHT
 // internal/policy.Enforcer.Authorize()/Guard() auf, die eigentliche
 // zentrale, DB-gestuetzte Policy-Durchsetzungsschicht aus RBAC-02
 // (policy_rules-Tabelle, per Store.Grant/Revoke administrierbar).
 //
 // Konsequenz: ein Tenant-Admin, der ueber policy.Store.Revoke() das Recht
 // tenant.manage_users von der Rolle tenant_admin entzieht, sperrt die
 // RBAC-05-Handler NICHT aus — sie fragen diese Tabelle nie ab. Dieser Test
 // beweist die tatsaechliche (fehlerhafte) Realitaet, NICHT das gewuenschte
 // Verhalten — siehe Pruefprotokoll fuer die Einordnung als Abweichung statt
 // stillschweigend behoben (Arbeitsweise-Regel: kein Umbau angrenzender
 // Bereiche in dieser Kachel, RBAC-05 gehoert nicht zu QA-03s Vorbedingungen).
 func TestBypass_HandlerIgnoresCentralPolicyRevocation(t *testing.T) {
 	_, roles, users, _ := setupHandlerTest(t, "qa03_bypass_policy_ignored")
 	ctx := context.Background()
 	admin, err := users.Create(ctx, "admin-bypass@acme.example", "Admin")
 	if err != nil {
 		t.Fatalf("admin anlegen: %v", err)
 	}
 	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
 		t.Fatalf("admin-rolle setzen: %v", err)
 	}
 	// Simuliert: ueber die zentrale Policy-Schicht (RBAC-02) wuerde
 	// tenant.manage_users der Rolle tenant_admin entzogen. Da RBAC-05s
 	// Handler diese Tabelle nie liest, hat der Entzug HIER keine Wirkung —
 	// requireManageUsers() erlaubt weiterhin, weil es nur HasPermission()
 	// (statische Hierarchie) fragt, nicht policy.Store.IsAllowed()
 	// (dynamische, gerade entzogene Regel).
 	stillAllowedByStaticHierarchy := HasPermission(RoleTenantAdmin, PermManageUsers)
 	if !stillAllowedByStaticHierarchy {
 		t.Fatal("erwartungsgemaess (fuer den Beweis): statische Hierarchie erlaubt weiterhin tenant.manage_users fuer tenant_admin")
 	}
 	// requireManageUsers() nutzt ausschliesslich diese statische Pruefung —
 	// ein Entzug ueber policy.Store haette hier KEINE Wirkung. Das ist der
 	// dokumentierte Fund: zwei parallele Enforcement-Pfade statt einer
 	// zentralen Schicht (verletzt die Ticket-Produkt-DNA "Rechte werden
 	// zentral entschieden, nicht in jedem Handler neu erfunden").
 	t.Log("FUND: internal/rbac/handler.go prueft HasPermission() (statisch), nicht internal/policy.Enforcer (RBAC-02, dynamisch) — ein Entzug ueber policy.Store.Revoke() wuerde RBAC-05-Endpunkte nicht sperren. Siehe docs/QA-03-PRUEFPROTOKOLL.md.")
 }
 // Gegenprobe: RBAC-02s eigene Enforcer/Guard-Schicht IST korrekt
 // zentralisiert und respektiert Revoke sofort — der Fund oben betrifft
 // ausschliesslich RBAC-05s Handler, nicht RBAC-02 selbst.
 func TestBypass_PolicyEnforcerItselfRespectsRevocation(t *testing.T) {
 	_, roles, users, pool := setupHandlerTest(t, "qa03_bypass_enforcer_ok")
 	ctx := context.Background()
 	_ = roles
 	_ = users
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS policy_rules (
 			role TEXT NOT NULL, permission TEXT NOT NULL, granted_by TEXT NOT NULL,
 			granted_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (role, permission)
 		);
 		CREATE TABLE IF NOT EXISTS policy_rule_changes (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), role TEXT NOT NULL, permission TEXT NOT NULL,
 			action TEXT NOT NULL, actor TEXT NOT NULL, version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("policy-schema: %v", err)
 	}
 	// Diese Tabellen/Typen leben im Package internal/policy — hier nur
 	// strukturell nachgebaut, um den Unterschied zu belegen, ohne einen
 	// Importzyklus zu riskieren (internal/policy importiert bereits
 	// internal/rbac, nicht umgekehrt).
 	if _, err := pool.Exec(ctx, `
 		INSERT INTO policy_rules (role, permission, granted_by) VALUES ('tenant_admin', 'tenant.manage_users', 'system')
 	`); err != nil {
 		t.Fatalf("regel gewaehren: %v", err)
 	}
 	var allowedBefore bool
 	if err := pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users')`).Scan(&allowedBefore); err != nil {
 		t.Fatalf("pruefen vor entzug: %v", err)
 	}
 	if !allowedBefore {
 		t.Fatal("erwartet: regel ist zunaechst gewaehrt")
 	}
 	if _, err := pool.Exec(ctx, `DELETE FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users'`); err != nil {
 		t.Fatalf("regel entziehen: %v", err)
 	}
 	var allowedAfter bool
 	if err := pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM policy_rules WHERE role='tenant_admin' AND permission='tenant.manage_users')`).Scan(&allowedAfter); err != nil {
 		t.Fatalf("pruefen nach entzug: %v", err)
 	}
 	if allowedAfter {
 		t.Fatal("regel haette nach entzug nicht mehr existieren duerfen")
 	}
 	// RBAC-02s Enforcer.Authorize fragt exakt diese Tabelle live ab (siehe
 	// internal/policy/store.go IsAllowed) — der Entzug wirkt dort sofort,
 	// im Gegensatz zu RBAC-05s Handler (siehe Test oben).
 }
@@ -178,6 +178,55 @@ func TestAssignRole_AdminCanPromoteOtherUser(t *testing.T) {
 	}
 }
 // QA-03 Akzeptanzkriterium 2: Rueckstufung (tenant_admin -> user) durch
 // einen Admin funktioniert ebenso wie die bereits getestete Hochstufung —
 // Rollenwechsel-Szenario in beide Richtungen, History haelt beide fest.
 func TestAssignRole_AdminCanDemoteOtherUser(t *testing.T) {
 	h, roles, users, _ := setupHandlerTest(t, "qa03_demote_other")
 	ctx := context.Background()
 	admin, err := users.Create(ctx, "admin-demote@acme.example", "Admin")
 	if err != nil {
 		t.Fatalf("admin anlegen: %v", err)
 	}
 	if _, err := roles.Assign(ctx, admin.ID, RoleTenantAdmin, "system"); err != nil {
 		t.Fatalf("admin-rolle setzen: %v", err)
 	}
 	other, err := users.Create(ctx, "wird-zurueckgestuft@acme.example", "Wird zurueckgestuft")
 	if err != nil {
 		t.Fatalf("anderen nutzer anlegen: %v", err)
 	}
 	if _, err := roles.Assign(ctx, other.ID, RoleTenantAdmin, admin.ID); err != nil {
 		t.Fatalf("ausgangsrolle (tenant_admin) setzen: %v", err)
 	}
 	issuer := auth.NewTokenIssuer("test-secret")
 	body, _ := json.Marshal(assignRoleRequest{UserID: other.ID, Role: RoleUser})
 	req := httptest.NewRequest(http.MethodPost, "/rbac/users/role", bytes.NewReader(body))
 	req.AddCookie(sessionCookieFor(t, issuer, admin.ID))
 	rec := httptest.NewRecorder()
 	auth.RequireAuth(issuer, h.AssignRole)(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
 	}
 	assignment, err := roles.Get(ctx, other.ID)
 	if err != nil {
 		t.Fatalf("rolle laden: %v", err)
 	}
 	if assignment.Role != RoleUser {
 		t.Fatalf("rolle = %q, want user (rueckgestuft)", assignment.Role)
 	}
 	history, err := roles.History(ctx, other.ID)
 	if err != nil {
 		t.Fatalf("history laden: %v", err)
 	}
 	if len(history) != 2 || history[0].Role != RoleTenantAdmin || history[1].Role != RoleUser {
 		t.Fatalf("erwartet history [tenant_admin, user] (hoch- dann rueckgestuft), habe %+v", history)
 	}
 }
 // Akzeptanzkriterium 3: Aenderungen an Rechten sind nachvollziehbar.
 func TestRoleHistory_TracksAssignments(t *testing.T) {
 	h, roles, users, _ := setupHandlerTest(t, "rbac05_history")
@@ -0,0 +1,155 @@
 // Package resync implementiert Core API-06: Wiederanlauf & Nachsynchro-
 // nisierung nach einem Core-Ausfall.
 //
 //   - Ein Modul puffert Audit-Events und Nutzungszaehler-Deltas LOKAL in
 //     Postgres (NICHT im Speicher — siehe "Bekannte Fehler vermeiden" im
 //     Ticket: ein erneuter Ausfall waehrend der Nachlieferung darf keine
 //     Daten verlieren, eine In-Memory-Queue wuerde das riskieren).
 //   - Ein Health-Check-getriggerter Worker erkennt die Core-Wiedererreich-
 //     barkeit SOFORT (nicht erst nach TTL-Ablauf, siehe StaleCache.Invalidate)
 //     und liefert die gepufferten Daten in ORIGINALER Reihenfolge, authenti-
 //     fiziert ueber das Service-Credential aus API-02
 //     (internal/moduleregistry.Registry.Authenticate).
 //
 // Dieses Paket dupliziert weder internal/audit (AUD-01) noch internal/usage
 // (LIC-03) — es liefert nur den Puffer- und Nachlieferungs-Mechanismus
 // DAVOR bzw. DANACH.
 package resync
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // BufferedAuditEvent ist ein lokal gepuffertes Audit-Ereignis. Seq
 // garantiert die Wiederherstellung der urspruenglichen Reihenfolge
 // (Akzeptanzkriterium 2) unabhaengig von eventuellen Uhrzeit-Ungenauigkeiten.
 type BufferedAuditEvent struct {
 	ID         int64
 	Seq        int64
 	TenantSlug string
 	Actor      string
 	Action     string
 	Target     string
 	Metadata   map[string]any
 	CreatedAt  time.Time
 }
 // BufferedUsageDelta ist ein lokal gepuffertes Nutzungszaehler-Inkrement.
 type BufferedUsageDelta struct {
 	ID         int64
 	Seq        int64
 	TenantSlug string
 	Metric     string
 	Delta      int64
 	CreatedAt  time.Time
 }
 // Buffer ist die lokale, persistente Pufferqueue eines Moduls.
 type Buffer struct {
 	pool *pgxpool.Pool
 }
 func NewBuffer(pool *pgxpool.Pool) *Buffer {
 	return &Buffer{pool: pool}
 }
 // EnqueueAuditEvent puffert EIN Audit-Ereignis lokal — wird von einem
 // Fachmodul aufgerufen, wenn Core gerade nicht erreichbar ist (die
 // Erkennung "Core erreichbar oder nicht" ist NICHT Teil dieses Aufrufs,
 // siehe Worker).
 func (b *Buffer) EnqueueAuditEvent(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any) error {
 	if metadata == nil {
 		metadata = map[string]any{}
 	}
 	metadataJSON, err := json.Marshal(metadata)
 	if err != nil {
 		return fmt.Errorf("metadata serialisieren: %w", err)
 	}
 	_, err = b.pool.Exec(ctx, `
 		INSERT INTO resync_audit_buffer (tenant_slug, actor, action, target, metadata)
 		VALUES ($1, $2, $3, $4, $5)
 	`, tenantSlug, actor, action, target, metadataJSON)
 	if err != nil {
 		return fmt.Errorf("audit-ereignis puffern: %w", err)
 	}
 	return nil
 }
 // EnqueueUsageDelta puffert EIN Nutzungszaehler-Inkrement lokal.
 func (b *Buffer) EnqueueUsageDelta(ctx context.Context, tenantSlug, metric string, delta int64) error {
 	_, err := b.pool.Exec(ctx, `
 		INSERT INTO resync_usage_buffer (tenant_slug, metric, delta)
 		VALUES ($1, $2, $3)
 	`, tenantSlug, metric, delta)
 	if err != nil {
 		return fmt.Errorf("nutzungsdelta puffern: %w", err)
 	}
 	return nil
 }
 // PendingAuditEvents liefert ALLE noch nicht zugestellten Audit-Events in
 // ORIGINALER Reihenfolge (Akzeptanzkriterium 2 / Pruefung 1).
 func (b *Buffer) PendingAuditEvents(ctx context.Context) ([]BufferedAuditEvent, error) {
 	rows, err := b.pool.Query(ctx, `
 		SELECT id, seq, tenant_slug, actor, action, target, metadata, created_at
 		FROM resync_audit_buffer ORDER BY seq
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("gepufferte audit-events abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []BufferedAuditEvent
 	for rows.Next() {
 		var e BufferedAuditEvent
 		var metadataJSON []byte
 		if err := rows.Scan(&e.ID, &e.Seq, &e.TenantSlug, &e.Actor, &e.Action, &e.Target, &metadataJSON, &e.CreatedAt); err != nil {
 			return nil, fmt.Errorf("gepuffertes audit-event lesen: %w", err)
 		}
 		_ = json.Unmarshal(metadataJSON, &e.Metadata)
 		out = append(out, e)
 	}
 	return out, rows.Err()
 }
 // PendingUsageDeltas liefert ALLE noch nicht zugestellten Nutzungsdeltas.
 func (b *Buffer) PendingUsageDeltas(ctx context.Context) ([]BufferedUsageDelta, error) {
 	rows, err := b.pool.Query(ctx, `
 		SELECT id, seq, tenant_slug, metric, delta, created_at
 		FROM resync_usage_buffer ORDER BY seq
 	`)
 	if err != nil {
 		return nil, fmt.Errorf("gepufferte nutzungsdeltas abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []BufferedUsageDelta
 	for rows.Next() {
 		var d BufferedUsageDelta
 		if err := rows.Scan(&d.ID, &d.Seq, &d.TenantSlug, &d.Metric, &d.Delta, &d.CreatedAt); err != nil {
 			return nil, fmt.Errorf("gepuffertes nutzungsdelta lesen: %w", err)
 		}
 		out = append(out, d)
 	}
 	return out, rows.Err()
 }
 // RemoveAuditEvent entfernt EIN Audit-Event aus dem Puffer — wird NUR nach
 // von Core BESTAETIGTER Zustellung aufgerufen (Akzeptanzkriterium 2/3: erst
 // entfernen, wenn sicher zugestellt, sonst bleibt es fuer den naechsten
 // Versuch erhalten — kein Datenverlust bei erneutem Ausfall waehrend der
 // Nachlieferung).
 func (b *Buffer) RemoveAuditEvent(ctx context.Context, id int64) error {
 	_, err := b.pool.Exec(ctx, `DELETE FROM resync_audit_buffer WHERE id = $1`, id)
 	return err
 }
 func (b *Buffer) RemoveUsageDelta(ctx context.Context, id int64) error {
 	_, err := b.pool.Exec(ctx, `DELETE FROM resync_usage_buffer WHERE id = $1`, id)
 	return err
 }
@@ -0,0 +1,132 @@
 package resync
 import (
 	"context"
 	"encoding/json"
 	"net/http"
 	"time"
 )
 // AuditRecorder ist die schmale Schnittstelle, ueber die Core empfangene
 // Audit-Events tatsaechlich persistiert. In Produktion durch internal/audit
 // (AUD-01, nicht Abhaengigkeit dieser Kachel) implementiert — dieses Paket
 // dupliziert dessen Validierungs-/Speicherlogik NICHT, sondern ruft sie nur
 // auf. Die Events werden vom Aufrufer sequenziell in PendingAuditEvents-
 // Reihenfolge uebergeben (Akzeptanzkriterium 2).
 type AuditRecorder interface {
 	Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error
 }
 // UsageIncrementer ist die schmale Schnittstelle zu Core's Nutzungszaehler
 // (in Produktion internal/usage, LIC-03 — nicht Abhaengigkeit dieser
 // Kachel). Jedes gepufferte Delta wird GENAU EINMAL angewendet.
 type UsageIncrementer interface {
 	Increment(ctx context.Context, tenantSlug, metric string, delta int64) error
 }
 // CredentialAuthenticator ist die schmale Schnittstelle zu API-02s
 // Service-Credential-Pruefung (internal/moduleregistry.Registry.Authenticate).
 type CredentialAuthenticator interface {
 	Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error)
 }
 // Handler nimmt nachgelieferte Audit-Events/Nutzungsdeltas auf der
 // Core-Seite entgegen — authentifiziert ueber dasselbe Service-Credential
 // wie jeder andere Modul-Core-Aufruf (Akzeptanzkriterium 2/3, "authentifiziert
 // ueber das in API-02 definierte Service-Credential").
 type Handler struct {
 	auth  CredentialAuthenticator
 	audit AuditRecorder
 	usage UsageIncrementer
 }
 func NewHandler(auth CredentialAuthenticator, audit AuditRecorder, usage UsageIncrementer) *Handler {
 	return &Handler{auth: auth, audit: audit, usage: usage}
 }
 type credentialHeader struct {
 	ClientID string `json:"client_id"`
 	Secret   string `json:"secret"`
 }
 func (h *Handler) authenticate(w http.ResponseWriter, r *http.Request) bool {
 	clientID := r.Header.Get("X-Nexarch-Client-Id")
 	secret := r.Header.Get("X-Nexarch-Client-Secret")
 	_, ok, err := h.auth.Authenticate(r.Context(), clientID, secret)
 	if err != nil || !ok {
 		http.Error(w, "ungueltiges service-credential", http.StatusUnauthorized)
 		return false
 	}
 	return true
 }
 type auditEventDTO struct {
 	TenantSlug string         `json:"tenant_slug"`
 	Actor      string         `json:"actor"`
 	Action     string         `json:"action"`
 	Target     string         `json:"target"`
 	Metadata   map[string]any `json:"metadata"`
 	OccurredAt time.Time      `json:"occurred_at"`
 }
 // AuditHandler nimmt EINE Liste gepufferter Audit-Events entgegen und
 // schreibt sie SEQUENZIELL in der gegebenen Reihenfolge fort
 // (Akzeptanzkriterium 2 / Pruefung 1: Vollstaendigkeit + Reihenfolge).
 // Bricht die Verarbeitung bei einem Fehler ab und meldet, wie viele Events
 // bereits sicher geschrieben wurden — der Aufrufer (Worker) entfernt aus
 // seinem lokalen Puffer NUR die bestaetigt geschriebenen Events.
 func (h *Handler) AuditHandler(w http.ResponseWriter, r *http.Request) {
 	if !h.authenticate(w, r) {
 		return
 	}
 	var events []auditEventDTO
 	if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
 		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
 		return
 	}
 	written := 0
 	for _, e := range events {
 		if err := h.audit.Record(r.Context(), e.TenantSlug, e.Actor, e.Action, e.Target, e.Metadata, e.OccurredAt); err != nil {
 			break
 		}
 		written++
 	}
 	writeJSON(w, map[string]int{"written": written})
 }
 type usageDeltaDTO struct {
 	TenantSlug string `json:"tenant_slug"`
 	Metric     string `json:"metric"`
 	Delta      int64  `json:"delta"`
 }
 // UsageHandler wendet JEDES gepufferte Delta GENAU EINMAL an
 // (Akzeptanzkriterium 3 / Pruefung 2: keine Doppelzaehlung) — der Aufrufer
 // entfernt aus seinem lokalen Puffer nur die bestaetigt uebernommenen Deltas.
 func (h *Handler) UsageHandler(w http.ResponseWriter, r *http.Request) {
 	if !h.authenticate(w, r) {
 		return
 	}
 	var deltas []usageDeltaDTO
 	if err := json.NewDecoder(r.Body).Decode(&deltas); err != nil {
 		http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
 		return
 	}
 	applied := 0
 	for _, d := range deltas {
 		if err := h.usage.Increment(r.Context(), d.TenantSlug, d.Metric, d.Delta); err != nil {
 			break
 		}
 		applied++
 	}
 	writeJSON(w, map[string]int{"applied": applied})
 }
 func writeJSON(w http.ResponseWriter, body any) {
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(body)
 }
@@ -0,0 +1,320 @@
 package resync
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"sync"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/flag"
 	"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
 )
 // fakeAudit steht fuer internal/audit.Log (AUD-01, nicht Abhaengigkeit
 // dieser Kachel) — zeichnet Aufrufe in Empfangsreihenfolge auf, damit
 // Vollstaendigkeit UND Reihenfolge geprueft werden koennen.
 type fakeAudit struct {
 	mu     sync.Mutex
 	events []auditEventDTO
 	failAt int // -1 = nie fehlschlagen; sonst: ab diesem Index (0-basiert) schlaegt Record fehl
 }
 func (f *fakeAudit) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	if f.failAt >= 0 && len(f.events) == f.failAt {
 		return fmt.Errorf("simulierter core-ausfall waehrend der nachlieferung")
 	}
 	f.events = append(f.events, auditEventDTO{TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target, Metadata: metadata, OccurredAt: occurredAt})
 	return nil
 }
 // fakeUsage steht fuer internal/usage.Store (LIC-03, nicht Abhaengigkeit
 // dieser Kachel) — summiert Deltas wie der echte Store.
 type fakeUsage struct {
 	mu     sync.Mutex
 	totals map[string]int64
 }
 func newFakeUsage() *fakeUsage { return &fakeUsage{totals: map[string]int64{}} }
 func (f *fakeUsage) Increment(ctx context.Context, tenantSlug, metric string, delta int64) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.totals[tenantSlug+"|"+metric] += delta
 	return nil
 }
 func setupTest(t *testing.T) (*Buffer, *pgxpool.Pool, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS resync_audit_buffer (
 			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, actor TEXT NOT NULL,
 			action TEXT NOT NULL, target TEXT NOT NULL DEFAULT '', metadata JSONB NOT NULL DEFAULT '{}',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS resync_usage_buffer (
 			id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, metric TEXT NOT NULL,
 			delta BIGINT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS feature_flags (
 			key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
 			rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
 			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS modules (
 			name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
 			required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS module_credentials (
 			module_name TEXT PRIMARY KEY REFERENCES modules(name),
 			client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
 			issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewBuffer(pool), pool, cleanup
 }
 func uniqueModuleName() string {
 	return fmt.Sprintf("resync-test-%d", time.Now().UnixNano())
 }
 // setupModuleCredential registriert ein echtes Modul + Service-Credential
 // ueber internal/moduleregistry (API-02) — dieselbe Authentifizierung wird
 // vom Handler tatsaechlich geprueft, kein Mock.
 func setupModuleCredential(t *testing.T, pool *pgxpool.Pool) (registry *moduleregistry.Registry, clientID, secret string) {
 	t.Helper()
 	ctx := context.Background()
 	flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
 	registry = moduleregistry.NewRegistry(pool, flagService)
 	name := uniqueModuleName()
 	if _, err := registry.Register(ctx, name, "1.0.0", nil); err != nil {
 		t.Fatalf("modul registrieren: %v", err)
 	}
 	clientID, secret, err := registry.Provision(ctx, name)
 	if err != nil {
 		t.Fatalf("credential provisionieren: %v", err)
 	}
 	return registry, clientID, secret
 }
 // Akzeptanzkriterium 2 + Pruefung 1: waehrend eines simulierten Ausfalls
 // lokal gepufferte Audit-Events sind nach Wiederanlauf vollstaendig und in
 // korrekter Reihenfolge in Core's Audit-Log vorhanden.
 func TestFlushAll_DeliversBufferedAuditEventsCompleteAndInOrder(t *testing.T) {
 	buffer, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	registry, clientID, secret := setupModuleCredential(t, pool)
 	tenantSlug := "acme"
 	// Ereignisse "waehrend core down" lokal puffern.
 	actions := []string{"login", "upload", "delete", "logout"}
 	for _, action := range actions {
 		if err := buffer.EnqueueAuditEvent(ctx, tenantSlug, "user-1", action, "res-1", nil); err != nil {
 			t.Fatalf("enqueue %s: %v", action, err)
 		}
 	}
 	audit := &fakeAudit{failAt: -1}
 	usage := newFakeUsage()
 	handler := NewHandler(registry, audit, usage)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
 	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	server := httptest.NewServer(mux)
 	defer server.Close()
 	client := NewCoreClient(server.URL, clientID, secret)
 	worker := NewWorker(buffer, client)
 	if err := worker.FlushAll(ctx); err != nil {
 		t.Fatalf("flushall: %v", err)
 	}
 	audit.mu.Lock()
 	defer audit.mu.Unlock()
 	if len(audit.events) != len(actions) {
 		t.Fatalf("erwartet %d zugestellte events, habe %d", len(actions), len(audit.events))
 	}
 	for i, e := range audit.events {
 		if e.Action != actions[i] {
 			t.Fatalf("reihenfolge falsch: position %d = %q, want %q", i, e.Action, actions[i])
 		}
 	}
 	// Puffer muss nach bestaetigter Zustellung leer sein.
 	remaining, err := buffer.PendingAuditEvents(ctx)
 	if err != nil {
 		t.Fatalf("pending: %v", err)
 	}
 	if len(remaining) != 0 {
 		t.Fatalf("erwartet leeren puffer nach bestaetigter zustellung, habe %d verbleibende", len(remaining))
 	}
 }
 // Bekannter-Fehler-Praevention: bricht die Zustellung waehrend der
 // Nachlieferung erneut ab (Core faellt wieder aus), bleiben die NICHT
 // bestaetigten Events sicher im Puffer erhalten statt verloren zu gehen.
 func TestFlushAll_KeepsUnconfirmedEventsInBufferOnPartialFailure(t *testing.T) {
 	buffer, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	registry, clientID, secret := setupModuleCredential(t, pool)
 	for i := 0; i < 5; i++ {
 		if err := buffer.EnqueueAuditEvent(ctx, "acme", "user-1", fmt.Sprintf("action-%d", i), "", nil); err != nil {
 			t.Fatalf("enqueue %d: %v", i, err)
 		}
 	}
 	// Core-Fake schlaegt AB dem 3. Event fehl -> simuliert erneuten Ausfall
 	// mitten in der Nachlieferung.
 	audit := &fakeAudit{failAt: 3}
 	handler := NewHandler(registry, audit, newFakeUsage())
 	mux := http.NewServeMux()
 	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
 	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
 	server := httptest.NewServer(mux)
 	defer server.Close()
 	client := NewCoreClient(server.URL, clientID, secret)
 	worker := NewWorker(buffer, client)
 	if err := worker.FlushAll(ctx); err == nil {
 		t.Fatal("erwartet fehler, da core nur teilweise bestaetigt hat")
 	}
 	remaining, err := buffer.PendingAuditEvents(ctx)
 	if err != nil {
 		t.Fatalf("pending: %v", err)
 	}
 	if len(remaining) != 2 {
 		t.Fatalf("erwartet 2 verbleibende (nicht bestaetigte) events im puffer, habe %d", len(remaining))
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 2: Nutzungszaehler-Differenz aus der
 // Ausfallzeit wird korrekt nachgebucht, ein wiederholter (fehlerhafter)
 // Flush-Versuch fuehrt NICHT zu Doppelzaehlung, weil bereits bestaetigte
 // Deltas aus dem Puffer entfernt sind.
 func TestFlushAll_AppliesUsageDeltasWithoutDoubleCounting(t *testing.T) {
 	buffer, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	registry, clientID, secret := setupModuleCredential(t, pool)
 	deltas := []int64{3, 5, 2}
 	var want int64
 	for _, d := range deltas {
 		want += d
 		if err := buffer.EnqueueUsageDelta(ctx, "acme", "api_calls", d); err != nil {
 			t.Fatalf("enqueue delta %d: %v", d, err)
 		}
 	}
 	usage := newFakeUsage()
 	handler := NewHandler(registry, &fakeAudit{failAt: -1}, usage)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
 	mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
 	server := httptest.NewServer(mux)
 	defer server.Close()
 	client := NewCoreClient(server.URL, clientID, secret)
 	worker := NewWorker(buffer, client)
 	if err := worker.FlushAll(ctx); err != nil {
 		t.Fatalf("flushall 1: %v", err)
 	}
 	usage.mu.Lock()
 	got := usage.totals["acme|api_calls"]
 	usage.mu.Unlock()
 	if got != want {
 		t.Fatalf("nutzungsstand nach nachbuchung = %d, want %d", got, want)
 	}
 	// Ein zweiter Flush-Versuch (z.B. redundanter Retry) darf NICHTS mehr
 	// nachbuchen, da der Puffer bereits geleert wurde.
 	if err := worker.FlushAll(ctx); err != nil {
 		t.Fatalf("flushall 2: %v", err)
 	}
 	usage.mu.Lock()
 	got2 := usage.totals["acme|api_calls"]
 	usage.mu.Unlock()
 	if got2 != want {
 		t.Fatalf("nutzungsstand nach redundantem zweiten flush = %d, want unveraendert %d (keine doppelzaehlung)", got2, want)
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 3: bei erkannter Core-Wiedererreichbarkeit
 // wird der Cache SOFORT invalidiert (naechster Zugriff refetcht), nicht
 // erst nach TTL-Ablauf — Latenz wird gemessen und liegt weit unter einer
 // langen TTL.
 func TestCheckAndSync_InvalidatesCacheImmediatelyOnRecovery(t *testing.T) {
 	buffer, pool, cleanup := setupTest(t)
 	defer cleanup()
 	registry, clientID, secret := setupModuleCredential(t, pool)
 	_ = registry
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	server := httptest.NewServer(mux)
 	defer server.Close()
 	client := NewCoreClient(server.URL, clientID, secret)
 	worker := NewWorker(buffer, client)
 	invalidated := false
 	var mu sync.Mutex
 	worker.OnReachable(func() {
 		mu.Lock()
 		invalidated = true
 		mu.Unlock()
 	})
 	start := time.Now()
 	becameReachable, err := worker.CheckAndSync(context.Background())
 	elapsed := time.Since(start)
 	if err != nil {
 		t.Fatalf("checkandsync: %v", err)
 	}
 	if !becameReachable {
 		t.Fatal("erwartet erkannten uebergang zu 'erreichbar' beim ersten erfolgreichen check")
 	}
 	mu.Lock()
 	defer mu.Unlock()
 	if !invalidated {
 		t.Fatal("erwartet sofortigen cache-invalidierungs-callback bei core-wiedererreichbarkeit")
 	}
 	// Zielwert: deutlich unter einer typischen TTL (z.B. 5s beim
 	// Feature-Flag-Cache, LIC-02) — hier im Millisekundenbereich, da rein
 	// lokal ohne Netzwerk-Overhead.
 	if elapsed > time.Second {
 		t.Fatalf("cache-invalidierung brauchte %s, erwartet deutlich unter 1s", elapsed)
 	}
 }
@@ -0,0 +1,220 @@
 package resync
 import (
 	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 )
 // CoreClient ist der modul-seitige HTTP-Client fuer die Nachlieferung,
 // authentifiziert ueber dasselbe Service-Credential wie jeder andere
 // Modul-Core-Aufruf (API-02).
 type CoreClient struct {
 	BaseURL  string
 	ClientID string
 	Secret   string
 	HTTP     *http.Client
 }
 func NewCoreClient(baseURL, clientID, secret string) *CoreClient {
 	return &CoreClient{BaseURL: baseURL, ClientID: clientID, Secret: secret, HTTP: &http.Client{Timeout: 5 * time.Second}}
 }
 func (c *CoreClient) post(ctx context.Context, path string, body any) (*http.Response, error) {
 	payload, err := json.Marshal(body)
 	if err != nil {
 		return nil, fmt.Errorf("payload serialisieren: %w", err)
 	}
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+path, bytes.NewReader(payload))
 	if err != nil {
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Nexarch-Client-Id", c.ClientID)
 	req.Header.Set("X-Nexarch-Client-Secret", c.Secret)
 	return c.HTTP.Do(req)
 }
 // HealthCheck prueft, ob Core erreichbar ist — dieselbe Konvention wie
 // internal/health (OPS-01): HTTP 200 auf einem Health-Endpunkt.
 func (c *CoreClient) HealthCheck(ctx context.Context) bool {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL+"/healthz", nil)
 	if err != nil {
 		return false
 	}
 	resp, err := c.HTTP.Do(req)
 	if err != nil {
 		return false
 	}
 	defer resp.Body.Close()
 	return resp.StatusCode == http.StatusOK
 }
 // Worker erkennt Core-Wiedererreichbarkeit und stoesst DANN sofort
 // (Akzeptanzkriterium 1) sowohl registrierte Cache-Invalidierungen als auch
 // das Nachliefern des lokalen Puffers an.
 type Worker struct {
 	buffer      *Buffer
 	client      *CoreClient
 	onReachable []func()
 	wasDown     bool
 }
 func NewWorker(buffer *Buffer, client *CoreClient) *Worker {
 	return &Worker{buffer: buffer, client: client, wasDown: true} // Start pessimistisch: erster erfolgreicher Check zaehlt als "Wiedererreichbarkeit".
 }
 // OnReachable registriert einen Callback, der bei jeder erkannten
 // Core-Wiedererreichbarkeit sofort ausgefuehrt wird — z.B.
 // moduletrust.StaleCache[T].Invalidate, damit der naechste Zugriff sofort
 // neu abruft statt auf TTL-Ablauf zu warten (Akzeptanzkriterium 1).
 func (w *Worker) OnReachable(fn func()) {
 	w.onReachable = append(w.onReachable, fn)
 }
 // CheckAndSync fuehrt EINEN Zyklus aus: Erreichbarkeit pruefen, bei
 // erkanntem UEBERGANG "nicht erreichbar -> erreichbar" sofort die
 // registrierten Callbacks ausloesen und den Puffer nachliefern. Gibt
 // zurueck, ob ein Wiederanlauf in diesem Aufruf erkannt wurde (fuer
 // Latenzmessung in Tests, Pruefung 3).
 func (w *Worker) CheckAndSync(ctx context.Context) (becameReachable bool, err error) {
 	reachable := w.client.HealthCheck(ctx)
 	if !reachable {
 		w.wasDown = true
 		return false, nil
 	}
 	justRecovered := w.wasDown
 	w.wasDown = false
 	if !justRecovered {
 		return false, nil
 	}
 	for _, fn := range w.onReachable {
 		fn()
 	}
 	if err := w.FlushAll(ctx); err != nil {
 		return true, err
 	}
 	return true, nil
 }
 // FlushAll liefert ZUERST alle gepufferten Audit-Events (in Reihenfolge),
 // DANN alle gepufferten Nutzungsdeltas nach. Jedes Element wird aus dem
 // lokalen Puffer NUR entfernt, wenn Core es bestaetigt hat — bricht die
 // Uebertragung vorzeitig ab (Core faellt waehrend der Nachlieferung erneut
 // aus), bleibt der Rest sicher im Postgres-Puffer erhalten
 // (Akzeptanzkriterium 2/3, "Bekannte Fehler vermeiden").
 func (w *Worker) FlushAll(ctx context.Context) error {
 	if err := w.flushAuditEvents(ctx); err != nil {
 		return err
 	}
 	return w.flushUsageDeltas(ctx)
 }
 func (w *Worker) flushAuditEvents(ctx context.Context) error {
 	events, err := w.buffer.PendingAuditEvents(ctx)
 	if err != nil {
 		return err
 	}
 	if len(events) == 0 {
 		return nil
 	}
 	dtos := make([]auditEventDTO, len(events))
 	for i, e := range events {
 		dtos[i] = auditEventDTO{
 			TenantSlug: e.TenantSlug, Actor: e.Actor, Action: e.Action, Target: e.Target,
 			Metadata: e.Metadata, OccurredAt: e.CreatedAt,
 		}
 	}
 	resp, err := w.client.post(ctx, "/internal/resync/audit", dtos)
 	if err != nil {
 		return fmt.Errorf("audit-nachlieferung: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("audit-nachlieferung: unerwarteter status %d", resp.StatusCode)
 	}
 	var ack struct {
 		Written int `json:"written"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
 		return fmt.Errorf("audit-bestaetigung lesen: %w", err)
 	}
 	// NUR die von Core bestaetigt geschriebenen Events entfernen — sie sind
 	// nach PendingAuditEvents-Reihenfolge sortiert, die ersten `Written`
 	// Eintraege entsprechen also genau den bestaetigten.
 	for i := 0; i < ack.Written; i++ {
 		if err := w.buffer.RemoveAuditEvent(ctx, events[i].ID); err != nil {
 			return fmt.Errorf("bestaetigtes audit-event aus puffer entfernen: %w", err)
 		}
 	}
 	if ack.Written < len(events) {
 		return fmt.Errorf("core hat nur %d von %d audit-events bestaetigt", ack.Written, len(events))
 	}
 	return nil
 }
 func (w *Worker) flushUsageDeltas(ctx context.Context) error {
 	deltas, err := w.buffer.PendingUsageDeltas(ctx)
 	if err != nil {
 		return err
 	}
 	if len(deltas) == 0 {
 		return nil
 	}
 	dtos := make([]usageDeltaDTO, len(deltas))
 	for i, d := range deltas {
 		dtos[i] = usageDeltaDTO{TenantSlug: d.TenantSlug, Metric: d.Metric, Delta: d.Delta}
 	}
 	resp, err := w.client.post(ctx, "/internal/resync/usage", dtos)
 	if err != nil {
 		return fmt.Errorf("nutzungs-nachlieferung: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("nutzungs-nachlieferung: unerwarteter status %d", resp.StatusCode)
 	}
 	var ack struct {
 		Applied int `json:"applied"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
 		return fmt.Errorf("nutzungs-bestaetigung lesen: %w", err)
 	}
 	for i := 0; i < ack.Applied; i++ {
 		if err := w.buffer.RemoveUsageDelta(ctx, deltas[i].ID); err != nil {
 			return fmt.Errorf("bestaetigtes nutzungsdelta aus puffer entfernen: %w", err)
 		}
 	}
 	if ack.Applied < len(deltas) {
 		return fmt.Errorf("core hat nur %d von %d nutzungsdeltas bestaetigt", ack.Applied, len(deltas))
 	}
 	return nil
 }
 // Run fuehrt CheckAndSync in festen Abstaenden aus — die "kurze, definierte
 // Zeitspanne" aus Akzeptanzkriterium 1 ist dieses Poll-Intervall.
 func (w *Worker) Run(ctx context.Context, interval time.Duration) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
 			_, _ = w.CheckAndSync(ctx)
 		}
 	}
 }
@@ -9,6 +9,8 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 )
 var (
@@ -24,7 +26,8 @@ var (
 func scanTenantWithLifecycle(row pgx.Row) (Tenant, error) {
 	var t Tenant
 	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status,
-		&t.CreatedAt, &t.PreviousStatus, &t.DeletionScheduledAt); err != nil {
+		&t.CreatedAt, &t.PreviousStatus, &t.DeletionScheduledAt,
 		&t.RetentionBlockReason, &t.RetentionCheckedAt); err != nil {
 		return Tenant{}, err
 	}
 	return t, nil
@@ -46,11 +49,24 @@ func (r *Registry) transition(ctx context.Context, slug string, allowedFrom []St
 		UPDATE tenants
 		SET status = $2, previous_status = $3, deletion_scheduled_at = $4
 		WHERE slug = $1 AND status = ANY($5)
-		RETURNING id, slug, name, db_name, db_dsn, status, created_at, previous_status, deletion_scheduled_at
+		RETURNING id, slug, name, db_name, db_dsn, status, created_at, previous_status, deletion_scheduled_at,
 		          retention_block_reason, retention_checked_at
 	`, slug, string(to), previousStatus, deletionAt, from)
 	t, err := scanTenantWithLifecycle(row)
 	if err == nil {
 		// AUD-06: Lebenszyklus-Uebergaenge sind sicherheitsrelevant (z.B.
 		// Suspendierung, Loeschvormerkung) — nach dem bereits dauerhaften
 		// UPDATE protokolliert, ein Audit-Fehler blockiert den Uebergang
 		// selbst nicht.
 		if r.audit != nil {
 			_ = r.audit.Record(ctx, audit.Event{
 				TenantSlug: t.Slug,
 				Actor:      "system",
 				Action:     "tenant.transition",
 				Target:     string(to),
 			})
 		}
 		return t, nil
 	}
 	if !errors.Is(err, pgx.ErrNoRows) {
@@ -111,10 +127,21 @@ func (r *Registry) CancelDeletion(ctx context.Context, slug string) (Tenant, err
 type Lifecycle struct {
 	registry  *Registry
 	adminPool *pgxpool.Pool
 	// retention ist die Pruef-Schnittstelle gegen Archive RET-03/CMP-06 (TEN-08).
 	// Default NoRetentionCheck{}, bis Archive angebunden ist — siehe retention.go.
 	retention RetentionChecker
 }
 func NewLifecycle(registry *Registry, adminPool *pgxpool.Pool) *Lifecycle {
-	return &Lifecycle{registry: registry, adminPool: adminPool}
+	return &Lifecycle{registry: registry, adminPool: adminPool, retention: NoRetentionCheck{}}
 }
 // WithRetentionChecker ersetzt den Retention-Checker (z.B. im Test durch einen
 // Fake, oder in Produktion durch den echten Archive-RET-03-Client). Gibt
 // dasselbe *Lifecycle zurueck, um Verkettung beim Aufbau zu erlauben.
 func (l *Lifecycle) WithRetentionChecker(checker RetentionChecker) *Lifecycle {
 	l.retention = checker
 	return l
 }
 // CheckActive verweigert Zugriff fuer jeden Nicht-aktiv-Zustand und loggt den
@@ -145,7 +172,7 @@ func (l *Lifecycle) ProcessDueDeletions(ctx context.Context) (int, error) {
 	defer func() { _ = tx.Rollback(ctx) }()
 	rows, err := tx.Query(ctx, `
-		SELECT id, db_name FROM tenants
+		SELECT id, slug, db_name FROM tenants
 		WHERE status = $1 AND deletion_scheduled_at <= now()
 		FOR UPDATE SKIP LOCKED
 	`, string(StatusPendingDeletion))
@@ -153,11 +180,11 @@ func (l *Lifecycle) ProcessDueDeletions(ctx context.Context) (int, error) {
 		return 0, fmt.Errorf("faellige loeschungen abfragen: %w", err)
 	}
-	type due struct{ id, dbName string }
+	type due struct{ id, slug, dbName string }
 	var candidates []due
 	for rows.Next() {
 		var d due
-		if err := rows.Scan(&d.id, &d.dbName); err != nil {
+		if err := rows.Scan(&d.id, &d.slug, &d.dbName); err != nil {
 			rows.Close()
 			return 0, fmt.Errorf("faellige loeschung lesen: %w", err)
 		}
@@ -170,11 +197,35 @@ func (l *Lifecycle) ProcessDueDeletions(ctx context.Context) (int, error) {
 	processed := 0
 	for _, c := range candidates {
 		// TEN-08: vor der physischen Loeschung gegen Archive RET-03/CMP-06 pruefen.
 		// Solange eine Sperre besteht, bleibt der Tenant in pending_deletion
 		// ("zur Loeschung vorgemerkt, aber gesperrt") — der Grund wird
 		// festgehalten (Akzeptanzkriterium 2), die naechste Sweeper-Runde
 		// prueft automatisch erneut (Akzeptanzkriterium 3), ohne dass ein
 		// manueller Re-Trigger noetig waere.
 		result, err := l.retention.CheckTenantRetention(ctx, c.id)
 		if err != nil {
 			return processed, fmt.Errorf("retention-pruefung fuer tenant %q: %w", c.id, err)
 		}
 		if result.Blocked {
 			slog.Warn("tenant-loeschung wegen aufbewahrungspflicht/legal-hold zurueckgehalten",
 				"tenant_slug", c.slug, "reason", result.Reason)
 			if _, err := tx.Exec(ctx, `
 				UPDATE tenants SET retention_block_reason = $2, retention_checked_at = now()
 				WHERE id = $1
 			`, c.id, result.Reason); err != nil {
 				return processed, fmt.Errorf("retention-sperrgrund fuer tenant %q speichern: %w", c.id, err)
 			}
 			continue
 		}
 		if _, err := l.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, c.dbName)); err != nil {
 			return processed, fmt.Errorf("tenant-datenbank %q loeschen: %w", c.dbName, err)
 		}
 		if _, err := tx.Exec(ctx, `
-			UPDATE tenants SET status = $2, previous_status = NULL, deletion_scheduled_at = NULL
+			UPDATE tenants
 			SET status = $2, previous_status = NULL, deletion_scheduled_at = NULL,
 			    retention_block_reason = NULL, retention_checked_at = now()
 			WHERE id = $1
 		`, c.id, string(StatusDeleted)); err != nil {
 			return processed, fmt.Errorf("tenant %q als geloescht markieren: %w", c.id, err)
@@ -38,7 +38,9 @@ func newLifecycleTestSetup(t *testing.T) (*Registry, *Lifecycle, *pgxpool.Pool,
 			status TEXT NOT NULL DEFAULT 'active',
 			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			previous_status TEXT,
-			deletion_scheduled_at TIMESTAMPTZ
+			deletion_scheduled_at TIMESTAMPTZ,
 			retention_block_reason TEXT,
 			retention_checked_at TIMESTAMPTZ
 		)`); err != nil {
 		t.Fatalf("registry-schema: %v", err)
 	}
@@ -6,19 +6,29 @@ import (
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
 )
 // 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
+	pool  *pgxpool.Pool
 	audit *audit.Log
 }
 func NewRegistry(pool *pgxpool.Pool) *Registry {
 	return &Registry{pool: pool}
 }
 // WithAudit liefert eine Registry, die jeden Lebenszyklus-Uebergang
 // zusaetzlich im zentralen, unveraenderlichen Audit-Log protokolliert
 // (AUD-06) — rein additiv, log == nil bleibt gueltig (z.B. bestehende Tests).
 func (r *Registry) WithAudit(log *audit.Log) *Registry {
 	return &Registry{pool: r.pool, audit: log}
 }
 // 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) {
@@ -38,8 +48,11 @@ func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
 	// previous_status/deletion_scheduled_at werden mitgelesen, damit TEN-04
 	// (internal/tenant/lifecycle.go) den vollstaendigen Lebenszyklus-Zustand
 	// ueber GetBySlug ansehen kann, statt eine eigene Abfrage zu duplizieren.
 	// retention_block_reason/retention_checked_at (TEN-08) aus demselben Grund
 	// fuer die Admin-Einsehbarkeit des Sperrgrunds (Akzeptanzkriterium 2).
 	row := r.pool.QueryRow(ctx, `
-		SELECT id, slug, name, db_name, db_dsn, status, created_at, previous_status, deletion_scheduled_at
+		SELECT id, slug, name, db_name, db_dsn, status, created_at, previous_status, deletion_scheduled_at,
 		       retention_block_reason, retention_checked_at
 		FROM tenants WHERE slug = $1
 	`, slug)
@@ -62,7 +75,8 @@ func (r *Registry) Delete(ctx context.Context, id string) error {
 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, previous_status, deletion_scheduled_at
+		SELECT id, slug, name, db_name, db_dsn, status, created_at, previous_status, deletion_scheduled_at,
 		       retention_block_reason, retention_checked_at
 		FROM tenants ORDER BY created_at
 	`)
 	if err != nil {
@@ -0,0 +1,34 @@
 package tenant
 import "context"
 // RetentionResult ist das Ergebnis einer Pruefung gegen Archive RET-03/CMP-06
 // vor einer endgueltigen Tenant-Loeschung (TEN-08).
 type RetentionResult struct {
 	// Blocked ist true, solange GoBD-relevante Daten des Tenants unter
 	// Aufbewahrungspflicht oder Legal Hold stehen (Akzeptanzkriterium 1).
 	Blocked bool
 	// Reason beschreibt Aufbewahrungsklasse/Frist oder Legal-Hold-Grund,
 	// fuer Admins einsehbar (Akzeptanzkriterium 2). Nur aussagekraeftig, wenn Blocked true ist.
 	Reason string
 }
 // RetentionChecker ist die Schnittstelle zu Archive RET-03 (Loeschworkflow &
 // Aufbewahrungssperre) / CMP-06 (Vier-Augen-Freigabe fuer Loeschungen).
 // Core kennt bewusst keine Retention-Logik selbst — diese Kachel ruft nur auf,
 // siehe TEN-08 "Nicht Bestandteil dieser Kachel". Solange Archive RET-03 noch
 // nicht implementiert ist, wird ein no-op-Checker verwendet (siehe
 // NoRetentionCheck), der niemals blockiert — Core faellt damit auf das
 // TEN-04-Verhalten vor diesem Ticket zurueck, statt fehlzuschlagen.
 type RetentionChecker interface {
 	CheckTenantRetention(ctx context.Context, tenantID string) (RetentionResult, error)
 }
 // NoRetentionCheck ist der Platzhalter-Checker, solange Archive RET-03 noch
 // nicht angebunden ist — blockiert nie. Wird in Produktion durch den echten
 // HTTP-Client gegen Archive ersetzt, sobald RET-03 existiert.
 type NoRetentionCheck struct{}
 func (NoRetentionCheck) CheckTenantRetention(context.Context, string) (RetentionResult, error) {
 	return RetentionResult{Blocked: false}, nil
 }
@@ -0,0 +1,164 @@
 package tenant
 import (
 	"context"
 	"testing"
 	"time"
 )
 // fakeRetentionChecker simuliert Archive RET-03/CMP-06 in Tests — echte
 // Anbindung existiert noch nicht (siehe retention.go), diese Kachel ruft nur auf.
 type fakeRetentionChecker struct {
 	blocked map[string]string // tenantID -> Grund
 }
 func (f fakeRetentionChecker) CheckTenantRetention(_ context.Context, tenantID string) (RetentionResult, error) {
 	if reason, ok := f.blocked[tenantID]; ok {
 		return RetentionResult{Blocked: true, Reason: reason}, nil
 	}
 	return RetentionResult{Blocked: false}, nil
 }
 // Akzeptanzkriterium 1 + Pruefung 1: Loeschung eines Tenants mit aktiver
 // GoBD-Aufbewahrungspflicht wird abgewiesen, Grund wird protokolliert
 // (Akzeptanzkriterium 2).
 func TestLifecycle_ProcessDueDeletions_BlockedByRetention(t *testing.T) {
 	registry, lifecycle, adminPool, cleanup := newLifecycleTestSetup(t)
 	defer cleanup()
 	provisionTestTenant(t, registry, adminPool, "lc_retention_blocked")
 	ctx := context.Background()
 	tenantBeforeSchedule, err := registry.GetBySlug(ctx, "lc_retention_blocked")
 	if err != nil {
 		t.Fatalf("get tenant: %v", err)
 	}
 	if _, err := registry.ScheduleDeletion(ctx, "lc_retention_blocked", -time.Minute); err != nil {
 		t.Fatalf("schedule deletion: %v", err)
 	}
 	lifecycle.WithRetentionChecker(fakeRetentionChecker{
 		blocked: map[string]string{
 			tenantBeforeSchedule.ID: "GoBD-Aufbewahrungsfrist bis 2034-01-01 (Buchungsbeleg-Klasse)",
 		},
 	})
 	processed, err := lifecycle.ProcessDueDeletions(ctx)
 	if err != nil {
 		t.Fatalf("process due deletions: %v", err)
 	}
 	if processed != 0 {
 		t.Fatalf("erwartet 0 tatsaechlich verarbeitete loeschungen, habe %d", processed)
 	}
 	after, err := registry.GetBySlug(ctx, "lc_retention_blocked")
 	if err != nil {
 		t.Fatalf("get tenant nach sweep: %v", err)
 	}
 	if after.Status != StatusPendingDeletion {
 		t.Fatalf("status = %q, want pending_deletion (gesperrt, nicht geloescht)", after.Status)
 	}
 	if after.RetentionBlockReason == nil || *after.RetentionBlockReason == "" {
 		t.Fatal("erwartet gesetzten retention_block_reason (Akzeptanzkriterium 2)")
 	}
 	if after.RetentionCheckedAt == nil {
 		t.Fatal("erwartet gesetzten retention_checked_at")
 	}
 	var exists bool
 	if err := adminPool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = $1)`,
 		dbNameForSlug("lc_retention_blocked")).Scan(&exists); err != nil {
 		t.Fatalf("pg_database pruefen: %v", err)
 	}
 	if !exists {
 		t.Fatal("tenant-datenbank haette NICHT geloescht werden duerfen (retention-sperre)")
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Loeschung eines Tenants mit Legal Hold
 // wird ebenfalls abgewiesen — derselbe Mechanismus wie GoBD-Frist, nur anderer Grund.
 func TestLifecycle_ProcessDueDeletions_BlockedByLegalHold(t *testing.T) {
 	registry, lifecycle, adminPool, cleanup := newLifecycleTestSetup(t)
 	defer cleanup()
 	provisionTestTenant(t, registry, adminPool, "lc_legal_hold")
 	ctx := context.Background()
 	tenant, err := registry.GetBySlug(ctx, "lc_legal_hold")
 	if err != nil {
 		t.Fatalf("get tenant: %v", err)
 	}
 	if _, err := registry.ScheduleDeletion(ctx, "lc_legal_hold", -time.Minute); err != nil {
 		t.Fatalf("schedule deletion: %v", err)
 	}
 	lifecycle.WithRetentionChecker(fakeRetentionChecker{
 		blocked: map[string]string{
 			tenant.ID: "Legal Hold: laufendes Gerichtsverfahren, Aktenzeichen XY-2026-042",
 		},
 	})
 	if _, err := lifecycle.ProcessDueDeletions(ctx); err != nil {
 		t.Fatalf("process due deletions: %v", err)
 	}
 	after, err := registry.GetBySlug(ctx, "lc_legal_hold")
 	if err != nil {
 		t.Fatalf("get tenant nach sweep: %v", err)
 	}
 	if after.Status != StatusPendingDeletion {
 		t.Fatalf("status = %q, want pending_deletion", after.Status)
 	}
 	if after.RetentionBlockReason == nil || *after.RetentionBlockReason == "" {
 		t.Fatal("erwartet gesetzten retention_block_reason")
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: nach Aufhebung aller Sperren wird die
 // Loeschung bei der naechsten Sweep-Runde automatisch ausgefuehrt — kein
 // manueller Re-Trigger noetig, derselbe Sweeper-Aufruf greift erneut.
 func TestLifecycle_ProcessDueDeletions_ExecutesAfterRetentionCleared(t *testing.T) {
 	registry, lifecycle, adminPool, cleanup := newLifecycleTestSetup(t)
 	defer cleanup()
 	provisionTestTenant(t, registry, adminPool, "lc_retention_cleared")
 	ctx := context.Background()
 	tenant, err := registry.GetBySlug(ctx, "lc_retention_cleared")
 	if err != nil {
 		t.Fatalf("get tenant: %v", err)
 	}
 	if _, err := registry.ScheduleDeletion(ctx, "lc_retention_cleared", -time.Minute); err != nil {
 		t.Fatalf("schedule deletion: %v", err)
 	}
 	blockingChecker := fakeRetentionChecker{blocked: map[string]string{tenant.ID: "Aufbewahrungsfrist laeuft noch"}}
 	lifecycle.WithRetentionChecker(blockingChecker)
 	if _, err := lifecycle.ProcessDueDeletions(ctx); err != nil {
 		t.Fatalf("erster sweep (blockiert): %v", err)
 	}
 	blockedState, err := registry.GetBySlug(ctx, "lc_retention_cleared")
 	if err != nil {
 		t.Fatalf("get tenant nach erstem sweep: %v", err)
 	}
 	if blockedState.Status != StatusPendingDeletion {
 		t.Fatalf("status nach erstem sweep = %q, want pending_deletion", blockedState.Status)
 	}
 	// Sperre aufgehoben: naechster Checker blockiert nicht mehr (fakeRetentionChecker.blocked leer).
 	lifecycle.WithRetentionChecker(fakeRetentionChecker{})
 	processed, err := lifecycle.ProcessDueDeletions(ctx)
 	if err != nil {
 		t.Fatalf("zweiter sweep (unblockiert): %v", err)
 	}
 	if processed != 1 {
 		t.Fatalf("erwartet genau 1 verarbeitete loeschung im zweiten sweep, habe %d", processed)
 	}
 	final, err := registry.GetBySlug(ctx, "lc_retention_cleared")
 	if err != nil {
 		t.Fatalf("get tenant nach zweitem sweep: %v", err)
 	}
 	if final.Status != StatusDeleted {
 		t.Fatalf("status = %q, want deleted", final.Status)
 	}
 }
@@ -31,6 +31,11 @@ type Tenant struct {
 	// Zustand CancelDeletion zurueckkehrt und wann die Karenzzeit ablaeuft.
 	PreviousStatus      *string
 	DeletionScheduledAt *time.Time
 	// RetentionBlockReason ist nur gesetzt, wenn eine faellige Loeschung wegen
 	// GoBD-Aufbewahrungspflicht oder Legal Hold zurueckgehalten wurde (TEN-08,
 	// siehe internal/tenant/retention.go) — fuer Admins einsehbar (Akzeptanzkriterium 2).
 	RetentionBlockReason *string
 	RetentionCheckedAt   *time.Time
 }
 // slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
@@ -0,0 +1,30 @@
 // Package timingsafe stellt die kanonische Implementierung der projektweiten
 // Coding-Konvention aus IAM-15 bereit: jeder Vergleich, der eine
 // sicherheitsrelevante Zugriffsentscheidung trifft (Passwort-Hash, Token,
 // Signatur, 2FA-Wiederherstellungscode), nutzt einen timing-safe/constant-time
 // Vergleich, nie den regulaeren ==-Operator. Siehe docs/CODING-GUIDELINES-CORE.md.
 //
 // Bestehende Vergleichsstellen (internal/totp, internal/webhook,
 // internal/moduleregistry) implementieren dasselbe Muster bereits inline mit
 // crypto/subtle direkt — dieses Package buendelt es fuer neue Vergleichsstellen,
 // ersetzt die bestehenden nicht zwangsweise (kein Umbau angrenzender Bereiche).
 package timingsafe
 import "crypto/subtle"
 // Equal vergleicht zwei Byte-Slices timing-safe. Unterschiedliche Laenge gilt
 // als "nicht gleich", ohne dass die Laufzeit dabei die Laenge verraet, die
 // zum Ergebnis gefuehrt hat, mehr als durch den Laengenunterschied ohnehin
 // unvermeidbar waere.
 func Equal(a, b []byte) bool {
 	if len(a) != len(b) {
 		return false
 	}
 	return subtle.ConstantTimeCompare(a, b) == 1
 }
 // EqualString ist die String-Variante von Equal fuer den haeufigen Fall,
 // dass beide Seiten bereits als string vorliegen (z. B. TOTP-Codes).
 func EqualString(a, b string) bool {
 	return Equal([]byte(a), []byte(b))
 }
@@ -0,0 +1,36 @@
 package timingsafe
 import "testing"
 func TestEqual_SameBytes(t *testing.T) {
 	if !Equal([]byte("geheimnis"), []byte("geheimnis")) {
 		t.Fatal("identische Byte-Slices sollten gleich sein")
 	}
 }
 func TestEqual_DifferentBytes(t *testing.T) {
 	if Equal([]byte("geheimnis"), []byte("anders123")) {
 		t.Fatal("unterschiedliche Byte-Slices sollten ungleich sein")
 	}
 }
 func TestEqual_DifferentLength(t *testing.T) {
 	if Equal([]byte("kurz"), []byte("laengererstring")) {
 		t.Fatal("unterschiedliche Laenge sollte immer ungleich sein")
 	}
 }
 func TestEqual_EmptyVsEmpty(t *testing.T) {
 	if !Equal([]byte(""), []byte("")) {
 		t.Fatal("zwei leere Slices sollten gleich sein")
 	}
 }
 func TestEqualString_MatchesEqual(t *testing.T) {
 	if !EqualString("abc123", "abc123") {
 		t.Fatal("identische Strings sollten gleich sein")
 	}
 	if EqualString("abc123", "xyz789") {
 		t.Fatal("unterschiedliche Strings sollten ungleich sein")
 	}
 }
@@ -7,12 +7,13 @@ import (
 	"crypto/hmac"
 	"crypto/rand"
 	"crypto/sha1"
 	"crypto/subtle"
 	"encoding/base32"
 	"encoding/binary"
 	"fmt"
 	"net/url"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/internal/timingsafe"
 )
 // StepSeconds ist das TOTP-Zeitfenster (RFC-6238-Standard: 30 Sekunden).
@@ -70,7 +71,7 @@ func Validate(secret, code string, t time.Time) (bool, error) {
 	for delta := -DefaultSkewSteps; delta <= DefaultSkewSteps; delta++ {
 		candidate := hotp(key, uint64(counter+int64(delta)))
-		if subtle.ConstantTimeCompare([]byte(candidate), []byte(code)) == 1 {
+		if timingsafe.EqualString(candidate, code) {
 			return true, nil
 		}
 	}
@@ -0,0 +1,47 @@
 package usage
 import (
 	"context"
 	"errors"
 	"fmt"
 )
 // StorageBytesMetric ist der feste Metrikname, unter dem der belegte
 // Speicherplatz je Tenant gefuehrt wird (LIC-05, siehe
 // core-kanban/tickets/LIC-05.md). LIC-03 fragt genau diese Metrik ueber
 // Store.Get/Store.Check ab — kein zweiter, paralleler Speicher-Zaehler.
 const StorageBytesMetric = "storage_bytes"
 // ReportStorageWrite wird von den Objekt-Storage-Treibern der Module (DMS
 // FDN-03, Mail ARC-01 — existieren als Code noch nicht) bei jedem
 // Schreibvorgang aufgerufen. Nutzt Store.Increment, das bereits atomar ist
 // (Akzeptanzkriterium 2, siehe LIC-03) — kein zweiter Inkrement-Mechanismus
 // nur fuer Speicher.
 func (s *Store) ReportStorageWrite(ctx context.Context, tenantID string, sizeBytes int64) error {
 	if sizeBytes < 0 {
 		return errors.New("usage: sizeBytes darf bei einem schreibvorgang nicht negativ sein")
 	}
 	if err := s.Increment(ctx, tenantID, StorageBytesMetric, sizeBytes); err != nil {
 		return fmt.Errorf("speicherverbrauch (schreiben) melden: %w", err)
 	}
 	return nil
 }
 // ReportStorageDelete wird bei jedem Loeschvorgang aufgerufen — dekrementiert
 // denselben Zaehler ueber ein negatives Delta desselben atomaren UPSERT.
 func (s *Store) ReportStorageDelete(ctx context.Context, tenantID string, sizeBytes int64) error {
 	if sizeBytes < 0 {
 		return errors.New("usage: sizeBytes darf bei einem loeschvorgang nicht negativ sein")
 	}
 	if err := s.Increment(ctx, tenantID, StorageBytesMetric, -sizeBytes); err != nil {
 		return fmt.Errorf("speicherverbrauch (loeschen) melden: %w", err)
 	}
 	return nil
 }
 // CurrentStorageUsage liefert den aktuellen Speicherverbrauch eines Tenants
 // (Akzeptanzkriterium 3) — ein einfaches Get auf den bereits gefuehrten
 // Zaehler, kein Scan des Objekt-Storage.
 func (s *Store) CurrentStorageUsage(ctx context.Context, tenantID string) (int64, error) {
 	return s.Get(ctx, tenantID, StorageBytesMetric)
 }
@@ -0,0 +1,130 @@
 package usage
 import (
 	"context"
 	"sync"
 	"testing"
 )
 // Akzeptanzkriterium 1 + 2 + Pruefung 1: paralleler Schreib-Test (viele
 // gleichzeitige Uploads) ergibt korrekten Endstand ohne verlorene Updates.
 func TestReportStorageWrite_ConcurrentUploadsSumCorrectly(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	sizes := []int64{1024, 2048, 4096, 8192, 512, 256, 1000, 999, 1, 7000}
 	var wg sync.WaitGroup
 	for _, size := range sizes {
 		wg.Add(1)
 		go func(sz int64) {
 			defer wg.Done()
 			if err := store.ReportStorageWrite(ctx, tenant, sz); err != nil {
 				t.Errorf("report write: %v", err)
 			}
 		}(size)
 	}
 	wg.Wait()
 	var expected int64
 	for _, s := range sizes {
 		expected += s
 	}
 	got, err := store.CurrentStorageUsage(ctx, tenant)
 	if err != nil {
 		t.Fatalf("current usage: %v", err)
 	}
 	if got != expected {
 		t.Fatalf("erwartet %d bytes (unabhaengige kontrollsumme), habe %d — hinweis auf verlorene updates", expected, got)
 	}
 }
 // Akzeptanzkriterium 1 + Pruefung 2: Loeschvorgang dekrementiert korrekt.
 func TestReportStorageDelete_Decrements(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	if err := store.ReportStorageWrite(ctx, tenant, 10_000); err != nil {
 		t.Fatalf("write: %v", err)
 	}
 	if err := store.ReportStorageDelete(ctx, tenant, 3_000); err != nil {
 		t.Fatalf("delete: %v", err)
 	}
 	got, err := store.CurrentStorageUsage(ctx, tenant)
 	if err != nil {
 		t.Fatalf("current usage: %v", err)
 	}
 	if got != 7_000 {
 		t.Fatalf("erwartet 7000 nach schreiben(10000)+loeschen(3000), habe %d", got)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Abfrage liefert konsistenten Wert mit
 // einer unabhaengigen Kontrollzaehlung ueber gemischte Schreib-/Loeschvorgaenge.
 func TestCurrentStorageUsage_MatchesIndependentTally(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	type op struct {
 		write bool
 		size  int64
 	}
 	ops := []op{
 		{true, 5000}, {true, 3000}, {false, 1000}, {true, 2000}, {false, 4000}, {true, 500},
 	}
 	var tally int64
 	for _, o := range ops {
 		if o.write {
 			if err := store.ReportStorageWrite(ctx, tenant, o.size); err != nil {
 				t.Fatalf("write: %v", err)
 			}
 			tally += o.size
 		} else {
 			if err := store.ReportStorageDelete(ctx, tenant, o.size); err != nil {
 				t.Fatalf("delete: %v", err)
 			}
 			tally -= o.size
 		}
 	}
 	got, err := store.CurrentStorageUsage(ctx, tenant)
 	if err != nil {
 		t.Fatalf("current usage: %v", err)
 	}
 	if got != tally {
 		t.Fatalf("erwartet %d (unabhaengige kontrollzaehlung), habe %d", tally, got)
 	}
 }
 // Akzeptanzkriterium 3: LIC-03s generischer Store.Get liefert denselben Wert
 // wie CurrentStorageUsage — kein zweiter, abweichender Zaehlmechanismus.
 func TestCurrentStorageUsage_MatchesGenericStoreGet(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	tenant := newTenantID()
 	if err := store.ReportStorageWrite(ctx, tenant, 42); err != nil {
 		t.Fatalf("write: %v", err)
 	}
 	viaStorage, err := store.CurrentStorageUsage(ctx, tenant)
 	if err != nil {
 		t.Fatalf("current usage: %v", err)
 	}
 	viaGeneric, err := store.Get(ctx, tenant, StorageBytesMetric)
 	if err != nil {
 		t.Fatalf("generic get: %v", err)
 	}
 	if viaStorage != viaGeneric || viaStorage != 42 {
 		t.Fatalf("erwartet beide wege liefern 42, habe storage=%d generic=%d", viaStorage, viaGeneric)
 	}
 }
@@ -0,0 +1,177 @@
 package webhook
 import (
 	"bytes"
 	"context"
 	"crypto/subtle"
 	"encoding/hex"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/jackc/pgx/v5"
 )
 // DefaultMaxAttempts ist die konfigurierbare Obergrenze, ab der eine
 // Zustellung endgueltig als fehlgeschlagen gilt (Akzeptanzkriterium 2).
 const DefaultMaxAttempts = 5
 // DefaultBaseBackoff ist die Basisdauer fuer exponentielles Backoff:
 // naechster Versuch nach BaseBackoff * 2^attempt (Akzeptanzkriterium 2).
 const DefaultBaseBackoff = 2 * time.Second
 // Dispatcher liefert faellige Zustellungen aus. Konfigurierbar in Tests
 // (kleine BaseBackoff, kleine MaxAttempts), damit Retry/Backoff/Obergrenze
 // ohne minutenlange Wartezeit real durchlaufen werden koennen.
 type Dispatcher struct {
 	pool        pgxIface
 	client      *http.Client
 	MaxAttempts int
 	BaseBackoff time.Duration
 }
 // pgxIface ist die schmale Teilmenge von *pgxpool.Pool, die der Dispatcher
 // braucht — als Interface, damit Tests keine echte Verbindung fuer reine
 // Signatur-/Backoff-Logik brauchen (wird hier aber durchgehend mit echten
 // Integrationstests gegen Postgres verwendet, siehe dispatcher_test.go).
 type pgxIface interface {
 	Begin(ctx context.Context) (pgx.Tx, error)
 }
 func NewDispatcher(pool pgxIface, client *http.Client) *Dispatcher {
 	if client == nil {
 		client = &http.Client{Timeout: 5 * time.Second}
 	}
 	return &Dispatcher{pool: pool, client: client, MaxAttempts: DefaultMaxAttempts, BaseBackoff: DefaultBaseBackoff}
 }
 // backoffFor berechnet die Wartezeit vor dem naechsten Versuch: exponentiell
 // wachsend mit der Anzahl bereits unternommener Versuche.
 func (d *Dispatcher) backoffFor(attempt int) time.Duration {
 	return d.BaseBackoff * time.Duration(1<<uint(attempt))
 }
 // ProcessDue liefert ALLE derzeit faelligen Zustellungen aus — dasselbe
 // SELECT ... FOR UPDATE SKIP LOCKED-Muster wie
 // internal/tenant.Lifecycle.ProcessDueDeletions, damit mehrere Dispatcher-
 // Instanzen dieselbe Zustellung nie doppelt bearbeiten.
 func (d *Dispatcher) ProcessDue(ctx context.Context) (int, error) {
 	tx, err := d.pool.Begin(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	rows, err := tx.Query(ctx, `
 		SELECT wd.id, wd.payload, wd.attempt, ws.target_url, ws.secret
 		FROM webhook_deliveries wd
 		JOIN webhook_subscriptions ws ON ws.id = wd.subscription_id
 		WHERE wd.status = $1 AND wd.next_attempt_at <= now()
 		FOR UPDATE OF wd SKIP LOCKED
 	`, StatusPending)
 	if err != nil {
 		return 0, fmt.Errorf("faellige zustellungen abfragen: %w", err)
 	}
 	var deliveries []delivery
 	for rows.Next() {
 		var del delivery
 		if err := rows.Scan(&del.ID, &del.Payload, &del.Attempt, &del.TargetURL, &del.Secret); err != nil {
 			rows.Close()
 			return 0, fmt.Errorf("zustellung lesen: %w", err)
 		}
 		deliveries = append(deliveries, del)
 	}
 	rows.Close()
 	if err := rows.Err(); err != nil {
 		return 0, err
 	}
 	for _, del := range deliveries {
 		d.attemptOne(ctx, tx, del)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return 0, fmt.Errorf("transaktion committen: %w", err)
 	}
 	return len(deliveries), nil
 }
 // attemptOne fuehrt GENAU EINEN Zustellversuch aus und aktualisiert den
 // Zustellungsdatensatz entsprechend — Erfolg (Akzeptanzkriterium 1/Pruefung
 // 1), erneuter Fehlversuch mit Backoff, oder endgueltiges Scheitern nach
 // DefaultMaxAttempts (Akzeptanzkriterium 2/Pruefung 2). Ein Fehler bei
 // GENAU EINER Zustellung darf die anderen in diesem Batch nicht verhindern.
 func (d *Dispatcher) attemptOne(ctx context.Context, tx pgx.Tx, del delivery) {
 	signature := Sign(del.Secret, del.Payload)
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, del.TargetURL, bytes.NewReader(del.Payload))
 	deliveryErr := err
 	var statusCode int
 	if err == nil {
 		req.Header.Set("Content-Type", "application/json")
 		req.Header.Set(SignatureHeader, signature)
 		resp, err := d.client.Do(req)
 		if err != nil {
 			deliveryErr = err
 		} else {
 			statusCode = resp.StatusCode
 			resp.Body.Close()
 			if statusCode < 200 || statusCode >= 300 {
 				deliveryErr = fmt.Errorf("unerwarteter statuscode %d", statusCode)
 			}
 		}
 	}
 	if deliveryErr == nil {
 		_, _ = tx.Exec(ctx, `
 			UPDATE webhook_deliveries SET status = $2, delivered_at = now(), attempt = attempt + 1
 			WHERE id = $1
 		`, del.ID, StatusDelivered)
 		return
 	}
 	nextAttempt := del.Attempt + 1
 	if nextAttempt >= d.MaxAttempts {
 		_, _ = tx.Exec(ctx, `
 			UPDATE webhook_deliveries SET status = $2, attempt = $3, last_error = $4
 			WHERE id = $1
 		`, del.ID, StatusFailed, nextAttempt, deliveryErr.Error())
 		return
 	}
 	nextAttemptAt := time.Now().Add(d.backoffFor(nextAttempt))
 	_, _ = tx.Exec(ctx, `
 		UPDATE webhook_deliveries SET attempt = $2, next_attempt_at = $3, last_error = $4
 		WHERE id = $1
 	`, del.ID, nextAttempt, nextAttemptAt, deliveryErr.Error())
 }
 // Run ruft ProcessDue in festen Abstaenden auf, bis ctx beendet wird —
 // dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
 func (d *Dispatcher) Run(ctx context.Context, interval time.Duration) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
 			_, _ = d.ProcessDue(ctx)
 		}
 	}
 }
 // VerifySignature prueft empfaengerseitig, ob signature zu payload und
 // secret passt — timing-safe (dasselbe Muster wie internal/audit.timingsafe),
 // damit ein Empfaenger die Authentizitaet einer Zustellung pruefen kann
 // (Akzeptanzkriterium 3).
 func VerifySignature(secret string, payload []byte, signature string) bool {
 	expected := Sign(secret, payload)
 	expectedBytes, err1 := hex.DecodeString(expected)
 	gotBytes, err2 := hex.DecodeString(signature)
 	if err1 != nil || err2 != nil {
 		return false
 	}
 	return subtle.ConstantTimeCompare(expectedBytes, gotBytes) == 1
 }
@@ -0,0 +1,131 @@
 // Package webhook implementiert Core API-07: eine zentrale Webhook-Registry
 // und Zustellungs-Engine fuer alle Fachmodule (DMS/Mail/Archive/Workflow/AI).
 // Module reichen Ereignisse EINMAL zur Zustellung ein und implementieren
 // selbst KEINE eigene Retry-/Signatur-Logik — das ist der zentrale Zweck
 // dieser Kachel ("Bewusst vermeiden: jedes Modul baut seine eigene
 // Webhook-Zustellungs-Engine"). Zustellung laeuft ueber dieselbe
 // Postgres-Jobqueue-Konvention (SELECT ... FOR UPDATE SKIP LOCKED) wie
 // internal/tenant.Lifecycle.ProcessDueDeletions (TEN-04) und
 // internal/notify.Dispatcher (CFG-02) — kein Redis/AMQP.
 package webhook
 import (
 	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 const (
 	StatusPending   = "pending"
 	StatusDelivered = "delivered"
 	StatusFailed    = "failed"
 )
 // Subscription ist EIN externer Abonnent fuer einen Ereignistyp
 // (Akzeptanzkriterium 1: Module registrieren Ereignistypen, externe
 // Abonnenten registrieren Ziel-URLs — dieses Paket modelliert die
 // Abonnenten-Seite; welche Ereignistypen ein Modul anbietet, ist bewusst
 // NICHT Teil dieser Kachel).
 type Subscription struct {
 	ID         string
 	EventType  string
 	TargetURL  string
 	Secret     string
 	CreatedAt  time.Time
 }
 // Store persistiert Abonnements und Zustellversuche.
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // Subscribe registriert einen Abonnenten fuer einen Ereignistyp. secret wird
 // spaeter zur HMAC-Signierung jeder Zustellung an diesen Abonnenten
 // verwendet (Akzeptanzkriterium 3).
 func (s *Store) Subscribe(ctx context.Context, eventType, targetURL, secret string) (Subscription, error) {
 	var sub Subscription
 	sub.EventType, sub.TargetURL, sub.Secret = eventType, targetURL, secret
 	row := s.pool.QueryRow(ctx, `
 		INSERT INTO webhook_subscriptions (event_type, target_url, secret)
 		VALUES ($1, $2, $3)
 		RETURNING id, created_at
 	`, eventType, targetURL, secret)
 	if err := row.Scan(&sub.ID, &sub.CreatedAt); err != nil {
 		return Subscription{}, fmt.Errorf("abonnement anlegen: %w", err)
 	}
 	return sub, nil
 }
 // Enqueue reicht EIN Ereignis zur Zustellung an ALLE Abonnenten des
 // angegebenen Ereignistyps ein — dies ist die EINZIGE Schnittstelle, die
 // ein Fachmodul braucht (Akzeptanzkriterium 1). Jeder Abonnent erhaelt
 // einen eigenen, unabhaengigen Zustellversuch-Datensatz.
 func (s *Store) Enqueue(ctx context.Context, eventType string, payload any) (int, error) {
 	payloadJSON, err := json.Marshal(payload)
 	if err != nil {
 		return 0, fmt.Errorf("payload serialisieren: %w", err)
 	}
 	rows, err := s.pool.Query(ctx, `
 		SELECT id FROM webhook_subscriptions WHERE event_type = $1
 	`, eventType)
 	if err != nil {
 		return 0, fmt.Errorf("abonnenten ermitteln: %w", err)
 	}
 	var subscriptionIDs []string
 	for rows.Next() {
 		var id string
 		if err := rows.Scan(&id); err != nil {
 			rows.Close()
 			return 0, fmt.Errorf("abonnent lesen: %w", err)
 		}
 		subscriptionIDs = append(subscriptionIDs, id)
 	}
 	rows.Close()
 	if err := rows.Err(); err != nil {
 		return 0, err
 	}
 	for _, subID := range subscriptionIDs {
 		if _, err := s.pool.Exec(ctx, `
 			INSERT INTO webhook_deliveries (subscription_id, event_type, payload, status, next_attempt_at)
 			VALUES ($1, $2, $3, $4, now())
 		`, subID, eventType, payloadJSON, StatusPending); err != nil {
 			return 0, fmt.Errorf("zustellung einreihen: %w", err)
 		}
 	}
 	return len(subscriptionIDs), nil
 }
 // delivery ist ein interner Datensatz fuer EINEN Zustellversuch, inklusive
 // der zugehoerigen Abonnentendaten (per JOIN geladen).
 type delivery struct {
 	ID        string
 	TargetURL string
 	Secret    string
 	Payload   []byte
 	Attempt   int
 }
 // Sign berechnet die HMAC-SHA256-Signatur des Payloads (Akzeptanzkriterium
 // 3) — hex-kodiert, damit sie problemlos als HTTP-Header uebertragen werden
 // kann.
 func Sign(secret string, payload []byte) string {
 	mac := hmac.New(sha256.New, []byte(secret))
 	mac.Write(payload)
 	return hex.EncodeToString(mac.Sum(nil))
 }
 // SignatureHeader ist der HTTP-Header, unter dem die Signatur uebertragen
 // wird — dokumentierter Vertrag fuer Empfaenger (Akzeptanzkriterium 3).
 const SignatureHeader = "X-Nexarch-Signature-256"
@@ -0,0 +1,205 @@
 package webhook
 import (
 	"context"
 	"encoding/json"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"sync/atomic"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupTest(t *testing.T) (*Store, *pgxpool.Pool, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS webhook_subscriptions (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), event_type TEXT NOT NULL,
 			target_url TEXT NOT NULL, secret TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 		CREATE TABLE IF NOT EXISTS webhook_deliveries (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), subscription_id UUID NOT NULL REFERENCES webhook_subscriptions(id),
 			event_type TEXT NOT NULL, payload JSONB NOT NULL, status TEXT NOT NULL DEFAULT 'pending',
 			attempt INT NOT NULL DEFAULT 0, next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
 			last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), delivered_at TIMESTAMPTZ
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), pool, cleanup
 }
 func uniqueEventType(prefix string) string {
 	return prefix + "-" + time.Now().Format("150405.000000000")
 }
 // Akzeptanzkriterium 1 + Pruefung 1: ein Modul reicht ein Ereignis ein
 // (Enqueue) ohne eigene Zustellungslogik, der zentrale Dispatcher liefert
 // zuverlaessig aus.
 func TestEnqueueAndProcessDue_DeliversSuccessfully(t *testing.T) {
 	store, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	var receivedBody []byte
 	var receivedSignature string
 	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		body, _ := io.ReadAll(r.Body)
 		receivedBody = body
 		receivedSignature = r.Header.Get(SignatureHeader)
 		w.WriteHeader(http.StatusOK)
 	}))
 	defer target.Close()
 	eventType := uniqueEventType("dms.file.created")
 	sub, err := store.Subscribe(ctx, eventType, target.URL, "geheimes-secret")
 	if err != nil {
 		t.Fatalf("subscribe: %v", err)
 	}
 	n, err := store.Enqueue(ctx, eventType, map[string]string{"file_id": "42"})
 	if err != nil {
 		t.Fatalf("enqueue: %v", err)
 	}
 	if n != 1 {
 		t.Fatalf("erwartet 1 eingereihte zustellung, habe %d", n)
 	}
 	dispatcher := NewDispatcher(pool, target.Client())
 	processed, err := dispatcher.ProcessDue(ctx)
 	if err != nil {
 		t.Fatalf("processdue: %v", err)
 	}
 	if processed != 1 {
 		t.Fatalf("erwartet 1 verarbeitete zustellung, habe %d", processed)
 	}
 	var status string
 	if err := pool.QueryRow(ctx, `SELECT status FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status); err != nil {
 		t.Fatalf("status lesen: %v", err)
 	}
 	if status != StatusDelivered {
 		t.Fatalf("status = %q, want %q", status, StatusDelivered)
 	}
 	// Postgres' JSONB-Spalte kann die Byte-Repraesentation des Payloads
 	// gegenueber dem urspruenglichen json.Marshal kanonisieren (z.B.
 	// Leerzeichen) — das ist unschaedlich, denn der Dispatcher signiert
 	// IMMER exakt die Bytes, die er auch sendet. Die Pruefung vergleicht
 	// deshalb Signatur gegen tatsaechlich empfangene Bytes (Selbstkonsistenz),
 	// nicht gegen eine unabhaengig neu marshalte Referenz.
 	if !VerifySignature("geheimes-secret", receivedBody, receivedSignature) {
 		t.Fatalf("empfangene signatur %q passt nicht zum empfangenen payload %q", receivedSignature, receivedBody)
 	}
 	var decoded map[string]string
 	if err := json.Unmarshal(receivedBody, &decoded); err != nil {
 		t.Fatalf("empfangener payload nicht als json lesbar: %v", err)
 	}
 	if decoded["file_id"] != "42" {
 		t.Fatalf("empfangener payload = %v, want file_id=42", decoded)
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 2: fehlschlagendes Ziel loest Retry mit
 // wachsendem Backoff aus und endet nach der konfigurierten Obergrenze in
 // "failed".
 func TestProcessDue_RetriesWithBackoffThenMarksFailed(t *testing.T) {
 	store, pool, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	var callCount int32
 	target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		atomic.AddInt32(&callCount, 1)
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
 	defer target.Close()
 	eventType := uniqueEventType("mail.send.failed")
 	sub, err := store.Subscribe(ctx, eventType, target.URL, "secret")
 	if err != nil {
 		t.Fatalf("subscribe: %v", err)
 	}
 	if _, err := store.Enqueue(ctx, eventType, map[string]string{"x": "y"}); err != nil {
 		t.Fatalf("enqueue: %v", err)
 	}
 	dispatcher := NewDispatcher(pool, target.Client())
 	dispatcher.MaxAttempts = 2
 	dispatcher.BaseBackoff = 30 * time.Millisecond
 	// 1. Versuch: schlaegt fehl, ist aber noch nicht die Obergrenze.
 	if _, err := dispatcher.ProcessDue(ctx); err != nil {
 		t.Fatalf("processdue 1: %v", err)
 	}
 	var status string
 	var attempt int
 	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
 		t.Fatalf("status lesen 1: %v", err)
 	}
 	if status != StatusPending || attempt != 1 {
 		t.Fatalf("nach 1. fehlschlag: status=%q attempt=%d, want pending/1", status, attempt)
 	}
 	// Sofort erneut verarbeiten: Backoff ist noch nicht abgelaufen -> nichts faellig.
 	processedTooEarly, err := dispatcher.ProcessDue(ctx)
 	if err != nil {
 		t.Fatalf("processdue (zu frueh): %v", err)
 	}
 	if processedTooEarly != 0 {
 		t.Fatal("erwartet 0 verarbeitete zustellungen, solange backoff nicht abgelaufen ist")
 	}
 	time.Sleep(dispatcher.backoffFor(1) + 20*time.Millisecond)
 	// 2. Versuch: erreicht MaxAttempts=2 -> endgueltig fehlgeschlagen.
 	if _, err := dispatcher.ProcessDue(ctx); err != nil {
 		t.Fatalf("processdue 2: %v", err)
 	}
 	if err := pool.QueryRow(ctx, `SELECT status, attempt FROM webhook_deliveries WHERE subscription_id = $1`, sub.ID).Scan(&status, &attempt); err != nil {
 		t.Fatalf("status lesen 2: %v", err)
 	}
 	if status != StatusFailed || attempt != 2 {
 		t.Fatalf("nach 2. fehlschlag: status=%q attempt=%d, want failed/2", status, attempt)
 	}
 	if atomic.LoadInt32(&callCount) != 2 {
 		t.Fatalf("erwartet genau 2 tatsaechliche zustellversuche, habe %d", callCount)
 	}
 }
 // Akzeptanzkriterium 3 + Pruefung 3: Signaturpruefung erkennt eine
 // manipulierte Payload zuverlaessig.
 func TestVerifySignature_DetectsTamperedPayload(t *testing.T) {
 	secret := "geteiltes-geheimnis"
 	payload := []byte(`{"file_id":"42"}`)
 	signature := Sign(secret, payload)
 	if !VerifySignature(secret, payload, signature) {
 		t.Fatal("erwartet gueltige signatur fuer unveraenderte payload")
 	}
 	tampered := []byte(`{"file_id":"99"}`)
 	if VerifySignature(secret, tampered, signature) {
 		t.Fatal("erwartet ungueltige signatur fuer manipulierte payload")
 	}
 	if VerifySignature("falsches-secret", payload, signature) {
 		t.Fatal("erwartet ungueltige signatur bei falschem secret")
 	}
 }
@@ -0,0 +1,2 @@
 DROP TABLE webhook_deliveries;
 DROP TABLE webhook_subscriptions;
@@ -0,0 +1,27 @@
 -- Zentrale Webhook-Registry & Zustellung (API-07, siehe
 -- core-kanban/tickets/API-07.md) — Postgres-basierte Jobqueue, kein
 -- Redis/AMQP (Ticket-Vorgabe).
 CREATE TABLE webhook_subscriptions (
    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    event_type  TEXT NOT NULL,
    target_url  TEXT NOT NULL,
    secret      TEXT NOT NULL,
    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE INDEX webhook_subscriptions_event_type_idx ON webhook_subscriptions (event_type);
 CREATE TABLE webhook_deliveries (
    id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    subscription_id  UUID NOT NULL REFERENCES webhook_subscriptions(id),
    event_type       TEXT NOT NULL,
    payload          JSONB NOT NULL,
    status           TEXT NOT NULL DEFAULT 'pending', -- pending|delivered|failed
    attempt          INT NOT NULL DEFAULT 0,
    next_attempt_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
    last_error       TEXT,
    created_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
    delivered_at     TIMESTAMPTZ
 );
 CREATE INDEX webhook_deliveries_due_idx ON webhook_deliveries (status, next_attempt_at);
@@ -0,0 +1,2 @@
 ALTER TABLE tenants DROP COLUMN retention_block_reason;
 ALTER TABLE tenants DROP COLUMN retention_checked_at;
@@ -0,0 +1,6 @@
 -- TEN-08: Haelt fest, warum eine faellige Tenant-Loeschung zurueckgehalten wurde
 -- (GoBD-Aufbewahrungspflicht oder Legal Hold aus Archive RET-03), damit Admins
 -- den Grund einsehen koennen (Akzeptanzkriterium 2), ohne dass die Registry
 -- selbst modulspezifische Retention-Logik kennen muss — nur den Grund-Text.
 ALTER TABLE tenants ADD COLUMN retention_block_reason TEXT;
 ALTER TABLE tenants ADD COLUMN retention_checked_at TIMESTAMPTZ;
@@ -0,0 +1,3 @@
 DROP TRIGGER IF EXISTS audit_events_no_delete ON audit_events;
 DROP TRIGGER IF EXISTS audit_events_no_update ON audit_events;
 DROP FUNCTION IF EXISTS audit_events_prevent_mutation();
@@ -0,0 +1,17 @@
 -- Audit-Log technisch gegen Aenderung/Loeschung absichern (AUD-02, siehe
 -- core-kanban/tickets/AUD-02.md). Ein Trigger statt nur GRANT/REVOKE, damit
 -- der Schutz unabhaengig davon greift, mit welcher Rolle verbunden wird
 -- (Akzeptanzkriterium 1: "auf Datenbankebene technisch unterbunden").
 CREATE FUNCTION audit_events_prevent_mutation() RETURNS TRIGGER AS $$
 BEGIN
    RAISE EXCEPTION 'audit_events ist append-only: % ist nicht erlaubt', TG_OP;
 END;
 $$ LANGUAGE plpgsql;
 CREATE TRIGGER audit_events_no_update
    BEFORE UPDATE ON audit_events
    FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
 CREATE TRIGGER audit_events_no_delete
    BEFORE DELETE ON audit_events
    FOR EACH ROW EXECUTE FUNCTION audit_events_prevent_mutation();
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS policy_module_scopes;
@@ -0,0 +1,11 @@
 -- Modul-Scoping fuer Policy-Regeln (RBAC-04, siehe core-kanban/tickets/RBAC-04.md).
 -- Existiert fuer eine (role, permission)-Regel ein Eintrag hier, gilt sie
 -- NUR, wenn zusaetzlich das verknuepfte Feature-Flag (LIC-02) fuer den
 -- Tenant aktiv ist — Rechte folgen der Lizenz, nicht umgekehrt.
 CREATE TABLE policy_module_scopes (
    role       TEXT NOT NULL,
    permission TEXT NOT NULL,
    module     TEXT NOT NULL,
    flag_key   TEXT NOT NULL,
    PRIMARY KEY (role, permission)
 );
@@ -0,0 +1,2 @@
 DROP TABLE alert_debounce_state;
 DROP TABLE alert_rules;
@@ -0,0 +1,24 @@
 -- OPS-05: Schwellwert-Regeln fuer Alerting auf den aus OPS-03 aggregierten
 -- Metriken. Lebt wie config_values/notification_jobs (CFG-01/02) in der
 -- zentralen Registry-DB — modulübergreifende Betriebskonfiguration, keine
 -- Mandanten-Geschaeftsdaten.
 CREATE TABLE alert_rules (
    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    metric_name   TEXT NOT NULL,
    comparison    TEXT NOT NULL CHECK (comparison IN ('gt', 'lt')),
    threshold     DOUBLE PRECISION NOT NULL,
    label_filters JSONB NOT NULL DEFAULT '{}'::jsonb,
    recipient     TEXT NOT NULL,
    description   TEXT NOT NULL DEFAULT '',
    created_at    TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 -- Haelt fest, wann eine Regel zuletzt tatsaechlich einen Alarm ausgeloest
 -- hat (Akzeptanzkriterium 3: Drosselung wiederholter Alarmierung fuer
 -- denselben anhaltenden Zustand). rule_key kombiniert Regel-ID mit den
 -- tatsaechlichen Label-Werten der ausloesenden Zeitreihe, damit dieselbe
 -- Regel fuer unterschiedliche Tenants/Module unabhaengig gedrosselt wird.
 CREATE TABLE alert_debounce_state (
    rule_key      TEXT PRIMARY KEY,
    last_fired_at TIMESTAMPTZ NOT NULL
 );
@@ -0,0 +1 @@
 DROP TABLE metrics_sources;
@@ -0,0 +1,7 @@
 -- Metrics-Aggregation ueber Module hinweg (OPS-03, siehe
 -- core-kanban/tickets/OPS-03.md) — welches Modul liefert seine Kennzahlen
 -- unter welcher /metrics-URL.
 CREATE TABLE metrics_sources (
    module_name TEXT PRIMARY KEY,
    metrics_url TEXT NOT NULL
 );
@@ -0,0 +1,2 @@
 DROP TABLE resync_usage_buffer;
 DROP TABLE resync_audit_buffer;
@@ -0,0 +1,22 @@
 -- Wiederanlauf & Nachsynchronisierung nach Core-Ausfall (API-06, siehe
 -- core-kanban/tickets/API-06.md) — lokale, PERSISTENTE Pufferqueue (kein
 -- In-Memory) fuer Audit-Events und Nutzungszaehler-Deltas eines Moduls.
 CREATE TABLE resync_audit_buffer (
    id          BIGSERIAL PRIMARY KEY,
    seq         BIGSERIAL,
    tenant_slug TEXT NOT NULL,
    actor       TEXT NOT NULL,
    action      TEXT NOT NULL,
    target      TEXT NOT NULL DEFAULT '',
    metadata    JSONB NOT NULL DEFAULT '{}',
    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE TABLE resync_usage_buffer (
    id          BIGSERIAL PRIMARY KEY,
    seq         BIGSERIAL,
    tenant_slug TEXT NOT NULL,
    metric      TEXT NOT NULL,
    delta       BIGINT NOT NULL,
    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
 );
@@ -0,0 +1 @@
 DROP TABLE IF EXISTS security_confirmations;
@@ -0,0 +1,14 @@
 -- Vier-Augen-Prinzip fuer sicherheitskritische Entscheidungen (AUD-02
 -- Akzeptanzkriterium 2), Vorbild: archivdms FOR-UPDATE-Lock + Timing-safe
 -- Vergleich. code_hash speichert NIEMALS den Bestaetigungscode im Klartext.
 CREATE TABLE security_confirmations (
    id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    action        TEXT NOT NULL,
    target        TEXT NOT NULL,
    requested_by  TEXT NOT NULL,
    code_hash     BYTEA NOT NULL,
    status        TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'confirmed', 'rejected')),
    confirmed_by  TEXT,
    created_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
    confirmed_at  TIMESTAMPTZ
 );
@@ -1,4 +1,11 @@
 #!/usr/bin/env bash
 # Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
 # Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
 # tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
 # unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
 # Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
@@ -33,9 +40,11 @@ psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EX
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS config_values CASCADE;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS status_history CASCADE;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS status_targets CASCADE;"
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS alert_rules CASCADE;"
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -1,12 +1,24 @@
 #!/usr/bin/env bash
 # Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
 # Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
 # -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
 # dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
 #
 # Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
 echo "== go build =="
 go build ./...
 echo "== go vet =="
 go vet ./...
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1
@@ -0,0 +1,79 @@
 #!/usr/bin/env bash
 # OPS-06 Pruefung 1: beweist, dass govulncheck und npm audit eine absichtlich
 # verwundbare Testabhaengigkeit tatsaechlich ERKENNEN (nicht nur irgendeinen
 # Fehler werfen) und mit Exit-Code != 0 enden (= wuerden den Merge blockieren).
 # Laeuft auf dem Testhost (Go/npm noetig), nicht auf der Entwicklungsmaschine.
 #
 # Wichtig: ein Exit-Code != 0 allein ist KEIN Beweis — ein fehlendes Tool
 # ("command not found", exit 127) sieht fuer ein reines Exit-Code-Gate genauso
 # aus wie ein echter Fund. Deshalb prueft dieses Skript zusaetzlich, dass die
 # erwartete Advisory-Kennung tatsaechlich in der Ausgabe steht.
 set -uo pipefail
 # "go install" legt Binaries in $(go env GOPATH)/bin ab — auf frischen Hosts
 # ist das nicht zwangslaeufig im PATH (gefunden 2026-08-28 auf dem Testhost:
 # govulncheck installierte erfolgreich, "command -v govulncheck" schlug danach
 # trotzdem fehl, weil /root/go/bin nicht im PATH stand). Defensiv ergaenzen,
 # statt stillschweigend als "Werkzeug fehlt" fehlzuschlagen.
 export PATH="$PATH:$(go env GOPATH 2>/dev/null)/bin"
 fail=0
 echo "=== Go-Fixture: golang.org/x/text v0.3.7, GO-2022-1059 (Symbolpfad language.ParseAcceptLanguage) ==="
 if ! command -v govulncheck >/dev/null 2>&1; then
  echo "govulncheck fehlt, installiere..."
  # @latest kann eine govulncheck-Version verlangen, die neuer ist als die
  # lokal installierte Go-Toolchain (z. B. "requires go >= 1.25.0"). Feste,
  # bekannt kompatible Version statt @latest, damit die Installation nicht
  # von der jeweiligen Go-Version des Hosts abhaengt.
  if ! go install golang.org/x/vuln/cmd/govulncheck@v1.1.3; then
    echo "FEHLER: govulncheck konnte nicht installiert werden — Pruefung nicht durchfuehrbar, kein Ersatz-'OK'."
    fail=1
  fi
 fi
 if command -v govulncheck >/dev/null 2>&1; then
  go_output=$(cd testdata/vulnfixture-go && go mod tidy && govulncheck ./... 2>&1)
  go_exit=$?
  echo "$go_output"
  if [ "$go_exit" -eq 0 ]; then
    echo "FEHLER: govulncheck hat die bekannte Schwachstelle NICHT erkannt (exit 0 erwartet != 0)"
    fail=1
  elif ! grep -q "GO-2022-1059" <<<"$go_output"; then
    echo "FEHLER: exit code $go_exit ist != 0, aber die erwartete Advisory GO-2022-1059 steht NICHT in der Ausgabe — das ist vermutlich ein Werkzeugfehler (z. B. fehlendes govulncheck, Netzwerkproblem), kein echter Fund. Kein 'OK'."
    fail=1
  else
    echo "OK: govulncheck hat GO-2022-1059 tatsaechlich als Fund gemeldet, exit code $go_exit (!= 0, Gate wuerde blockieren)"
  fi
 else
  # Bug (gefunden 2026-08-28): dieser Zweig druckte vorher nur eine Meldung,
  # setzte aber "fail" NICHT — das Skript endete trotzdem mit Exit-Code 0 und
  # "PRUEFUNG 1 BESTANDEN", obwohl der Go-Teil real nicht lief. Exakt derselbe
  # Fehlerklasse (Werkzeugfehler zaehlt als Erfolg), nur eine Ebene hoeher.
  echo "FEHLER: govulncheck weiterhin nicht verfuegbar — Go-Teil der Pruefung nicht durchgefuehrt, kein Ersatz-'OK'."
  fail=1
 fi
 echo
 echo "=== npm-Fixture: lodash 4.17.4 (mehrere bekannte kritische CVEs) ==="
 npm_output=$(cd testdata/vulnfixture-npm && npm install --package-lock-only --no-audit --no-fund 2>&1 \
  && npm audit --audit-level=high 2>&1)
 npm_exit=$?
 echo "$npm_output"
 if [ "$npm_exit" -eq 0 ]; then
  echo "FEHLER: npm audit hat die bekannte Schwachstelle NICHT erkannt (exit 0 erwartet != 0)"
  fail=1
 elif ! grep -qiE "severity|vulnerabilit" <<<"$npm_output"; then
  echo "FEHLER: exit code $npm_exit ist != 0, aber die Ausgabe enthaelt keinen erkennbaren Schwachstellen-Hinweis — vermutlich ein Werkzeugfehler (z. B. fehlendes npm, Netzwerkproblem), kein echter Fund. Kein 'OK'."
  fail=1
 else
  echo "OK: npm audit hat die Schwachstelle tatsaechlich gemeldet, exit code $npm_exit (!= 0, Gate wuerde blockieren)"
 fi
 echo
 if [ "$fail" -eq 0 ]; then
  echo "PRUEFUNG 1 BESTANDEN: beide Gates erkennen eine absichtlich verwundbare Testabhaengigkeit inhaltlich (nicht nur per Exit-Code) und wuerden blockieren."
 else
  echo "PRUEFUNG 1 FEHLGESCHLAGEN: siehe FEHLER oben."
 fi
 exit $fail
@@ -0,0 +1,14 @@
 // Absichtlich verwundbares Fixture-Modul fuer OPS-06 Pruefung 1: beweist, dass
 // der govulncheck-CI-Schritt eine bekannte Schwachstelle tatsaechlich erkennt
 // und den Lauf mit Exit-Code != 0 beendet. Eigenes go.mod, damit die
 // veraltete, verwundbare Abhaengigkeit NICHT im Hauptmodul landet.
 module gitea.perlbach24.de/scripte/nexarch/testdata/vulnfixture-go
 go 1.22
 // golang.org/x/text v0.3.7: GO-2022-1059 — Denial of Service durch
 // uebermaessigen Ressourcenverbrauch beim Parsen von Accept-Language-Headern
 // (language.ParseAcceptLanguage). Bewusst auf dieser verwundbaren Version
 // gepinnt, siehe scripts/verify-supply-chain-gate.sh — main.go ruft gezielt
 // den verwundbaren Symbolpfad auf, nicht nur irgendeine Funktion des Pakets.
 require golang.org/x/text v0.3.7
@@ -0,0 +1,22 @@
 // Fixture fuer OPS-06 Pruefung 1 — ruft tatsaechlich in die verwundbare
 // Funktion hinein, damit govulncheck den Aufrufpfad (nicht nur die
 // Modul-Abhaengigkeit) als erreichbar erkennt.
 package main
 import (
 	"fmt"
 	"golang.org/x/text/language"
 )
 func main() {
 	// ParseAcceptLanguage ist der tatsaechlich verwundbare Aufrufpfad
 	// (GO-2022-1059), im Unterschied zu Parse() — govulncheck bewertet
 	// Erreichbarkeit auf Symbol-, nicht nur Paket-Ebene.
 	tags, _, err := language.ParseAcceptLanguage("de-DE,de;q=0.9,en;q=0.8")
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 	fmt.Println(tags)
 }
@@ -0,0 +1,8 @@
 {
  "name": "nexarch-vulnfixture-npm",
  "private": true,
  "description": "Absichtlich verwundbares Fixture-Paket fuer OPS-06 Pruefung 1 — beweist, dass npm audit eine bekannte Schwachstelle erkennt und den Lauf blockiert. Nicht Teil eines echten NEXARCH-Frontends.",
  "dependencies": {
    "lodash": "4.17.4"
  }
 }
Author	SHA1	Message	Date
sysopsandClaude Sonnet 5	278d26f7bd	deploy: installer + systemd-units, Core auf 192.168.1.131 in Betrieb Supply-Chain-Scan (Go) / govulncheck (push) Canceled after 0s Details deploy/install.sh: idempotenter Installer fuer Debian/systemd. Legt Systembenutzer 'nexarch', Postgres-Rolle+Registry-DB an, baut alle 7 Core-Binaries (cmd/core + *-devserver), wendet Registry-Migrationen an (nur bei leerer DB), generiert Secrets (Audit-Admin-Token, Ed25519- Lizenzschluesselpaar) nach /etc/nexarch/core.env (0600), installiert und startet je Dienst einen systemd-Service. Tatsaechlich auf 192.168.1.131 ausgefuehrt und verifiziert: alle 7 Dienste laufen (systemctl active), alle Health-Endpunkte antworten 200. Zweiter Installer-Lauf bestaetigt Idempotenz (ueberspringt bestehende Rolle/DB/ Secrets/Migrationen, Dienste bleiben durchgehend aktiv). Hinweis: kein unified Server (siehe QA-05/AUD-06-Befund) - weiterhin 7 getrennte Binaries/Ports, dieser Installer deployt sie so wie sie sind. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ	2026-08-29 19:03:20 +02:00
sysopsandClaude Sonnet 5	4de9310213	AUD-06: audit-log-verdrahtung-in-sicherheitsrelevante-core-handler Supply-Chain-Scan (Go) / govulncheck (push) Canceled after 0s Details Schliesst die in QA-05 gefundene Luecke: der zentrale Audit-Log (AUD-01/02) existierte und war getestet, wurde aber von keinem Produktions-Handler befuellt. Additive WithAudit(...)-Methode je Store (Konvention aus lockout.Store.WithPolicy uebernommen, audit==nil bleibt gueltig, kein Verhaltensbruch fuer bestehende Aufrufer): - internal/policy.Store.Grant/Revoke -> policy.grant/policy.revoke - internal/tenant.Registry (Suspend/Reactivate/ScheduleDeletion/ CancelDeletion via transition) -> tenant.transition - internal/lockout.Store.RecordFailure/Unlock -> auth.login_failed/ auth.account_locked/auth.account_unlocked - internal/kek.Store.RotateTenantKEK/RotateMasterKey -> kek.tenant_rotated/ kek.master_rotated Neues Testpaket internal/audit/wiring_test.go: fuer jeden der vier Bereiche eine reale Aktion ausgefuehrt und per direkter audit_events-Abfrage nachgewiesen (derselbe Nachweisstil wie der QA-05-Stichprobenabgleich, der die Luecke fand). Alle bestehenden Tests der vier Pakete bleiben gruen. 51/51 Pakete gruen auf 192.168.1.131. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ	2026-08-29 17:24:26 +02:00
sysopsandClaude Sonnet 5	d8d5aaf3bc	QA-05: abnahme-compliance-pruefung-core Supply-Chain-Scan (Go) / govulncheck (push) Canceled after 0s Details Voller Merge der 15 verbleibenden Vorbedingungen (QA-07/QA-08/TEN-08/AUD-02/ API-04/OPS-03/API-06/AUD-05/API-07/LIC-05/OPS-04/OPS-05/OPS-06/IAM-15 plus QA-03) auf den bereits gemergten Staenden von QA-02/QA-04/QA-09. Konsolidiert alle sechs vorgelagerten Pruefgates (QA-02/03/04/07/08/09) - widerspruchsfrei, Akzeptanzkriterium 1 erfuellt. Echter, substanzieller Befund beim Audit-Log-Stichprobenabgleich (Pruefung 1): internal/policy.Store.Grant/Revoke, Tenant-Lifecycle-Uebergaenge, Lockout und KEK-Rotation rufen internal/audit.Log.Record nirgends auf - der zentrale, unveraenderliche Audit-Log (AUD-01/02) existiert und ist getestet, wird aber von keinem Produktions-Handler tatsaechlich befuellt. Bewusst NICHT in dieser Kachel behoben (waere Umbau vieler bestehender Pakete, kein punktueller Fix) - dokumentiert mit Begruendung und Auflage vor QA-06. Pruefung 2 (Vier-Augen-Gegenlesen) mangels zweiter Person nicht durchgefuehrt, ebenfalls als Auflage vermerkt. Siehe docs/QA-05-ABNAHME-COMPLIANCE-PRUEFUNG.md. Zwei reale Testinfrastruktur-Fehler gefunden und behoben (kein Produktions- code): fehlender PG-Fehlercode 42723 (duplicate_function, AUD-02s CREATE FUNCTION bei zweiter Migrationsanwendung) in der Toleranzliste der E2E-/Pentest-Testhelfer; internal/loadtest wiederholte die aus QA-04 bekannte defer-vor-t.Cleanup-Reihenfolge-Fehlerklasse (200 liegen gebliebene synthetische Tenant-Zeilen verfaelschten internal/migrate). 51/51 Pakete gruen auf 192.168.1.131. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ	2026-08-29 17:16:08 +02:00
sysops	251657bab5	Merge branch 'feature/qa-08-last-leistungstest' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # internal/apiserver/server.go	2026-08-29 17:09:22 +02:00
sysops	767a2584ee	Merge branch 'feature/qa-07-schnittstellen-vertragstests' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # internal/apiserver/server.go # internal/flag/flag.go	2026-08-29 17:09:04 +02:00
sysops	aeef711e91	Merge branch 'feature/iam-15-timing-safe-vergleich-als-projektweite-coding-konvention' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:08:42 +02:00
sysops	e39fb6f237	Merge branch 'feature/ops-06-automatisiertes-schwachstellen-scanning-supply-chain' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # DEVLOG.md # go.sum	2026-08-29 17:08:37 +02:00
sysops	53af28d928	Merge branch 'feature/ops-05-alerting-bei-schwellwert-ueberschreitung' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # DEVLOG.md # go.mod # go.sum # scripts/reset-test-env.sh # scripts/run-checks.sh	2026-08-29 17:06:55 +02:00
sysops	f442f07a27	Merge branch 'feature/ops-04-incident-response-plan-inkl-dsgvo-meldefristen' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:25 +02:00
sysops	33ed699dac	Merge branch 'feature/lic-05-speicherverbrauch-metrik-je-tenant' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:25 +02:00
sysops	a70f439846	Merge branch 'feature/api-07-zentrale-webhook-registry-zustellung' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:24 +02:00
sysops	1589fd31cb	Merge branch 'feature/aud-05-audit-log-registrierung-bei-archive-retention-engine' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:24 +02:00
sysops	33a73bb64c	Merge branch 'feature/api-06-wiederanlauf-nachsynchronisierung-nach-core-ausfall' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # go.mod # internal/moduletrust/cache.go	2026-08-29 17:05:18 +02:00
sysops	b347efed52	Merge branch 'feature/ops-03-metrics-aggregation-ueber-module-hinweg' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:03 +02:00
sysops	19548d6d6d	Merge branch 'feature/api-04-openapi-schnittstellenbeschreibung' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:03 +02:00
sysops	8d8266a2fd	Merge branch 'feature/aud-02-unveraenderliches-protokoll-append-only' into feature/qa-05-abnahme-compliance-pruefung-core	2026-08-29 17:05:03 +02:00
sysops	37edf98618	Merge branch 'feature/ten-08-tenant-loeschung-unter-retention-vorbehalt-gobd' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # internal/tenant/registry.go	2026-08-29 17:04:55 +02:00
sysops	c7ff26d857	Merge branch 'feature/qa-03-pruefgate-rechte-policy' into feature/qa-05-abnahme-compliance-pruefung-core # Conflicts: # internal/flag/flag.go	2026-08-29 17:03:56 +02:00
sysops	aecfcdf702	QA-03: build/test-ergebnis auf 131 ergaenzt (30/30 tests gruen, bypass-fund bestaetigt)	2026-08-29 09:24:42 +02:00
sysops	073e61664f	QA-03: pruefgate-rechte-policy (rbac-04 gemergt, umgehungsversuch+rollenwechsel-tests, pruefprotokoll)	2026-08-29 00:15:57 +02:00
sysops	ba23d4d90d	Merge branch 'feature/rbac-04-modul-scoped-berechtigungen' into feature/qa-03-pruefgate-rechte-policy	2026-08-29 00:10:21 +02:00
sysops	55872c96da	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-29 00:08:05 +02:00
sysops	5fcae51aac	OPS-05: fix — go.mod auf go 1.25.0 (prometheus/client_golang benoetigt es), sql-typfehler in shouldFire (interval-multiplikation statt string-konkatenation)	2026-08-29 00:02:11 +02:00
sysops	369a40af10	OPS-05: alerting-bei-schwellwert-ueberschreitung (internal/alerting: regel-store, evaluator gegen ops-03-metriken, cfg-02-zustellung, drosselung je regel+zeitreihe)	2026-08-28 23:59:09 +02:00
sysops	06dbd52d4c	Merge branch 'feature/cfg-02-benachrichtigungs-dispatcher-core-service-fuer-module' into feature/ops-05-alerting-bei-schwellwert-ueberschreitung # Conflicts: # scripts/reset-test-env.sh # scripts/run-checks.sh	2026-08-28 23:56:40 +02:00
sysops	bf8f905767	DEVLOG: Sessionlog-Eintrag (Auto-Hook) Supply-Chain-Scan (Go) / govulncheck (push) Has been cancelled Details	2026-08-28 23:07:16 +02:00
sysops	f02de2b6c8	OPS-06: fix — PATH um $(go env GOPATH)/bin ergaenzen (govulncheck installierte erfolgreich, war aber nicht im PATH auffindbar); go.sum ergaenzen	2026-08-28 23:07:11 +02:00
sysops	9de84f6994	OPS-06: fix — fehlendes fail=1 im govulncheck-unavailable-zweig, govulncheck-version gepinnt statt @latest (Go-Versionskonflikt auf 131 gefunden)	2026-08-28 23:04:49 +02:00
sysops	77ecf42365	OPS-06: fix — verify-supply-chain-gate.sh unterscheidet jetzt echten Fund von Werkzeugfehler (pruefte vorher nur exit-code, 'command not found' galt faelschlich als bestanden)	2026-08-28 23:03:05 +02:00
sysops	ab7a03386c	OPS-06: fix — fixture ruft tatsaechlich verwundbaren symbolpfad auf (ParseAcceptLanguage statt Parse, GO-2022-1059 statt falscher advisory-id)	2026-08-28 23:01:19 +02:00
sysops	87f5fe20f9	OPS-06: automatisiertes-schwachstellen-scanning-supply-chain (govulncheck+npm-audit CI-Gates, verwundbare Fixtures + Verifikationsskript fuer Pruefung 1) Supply-Chain-Scan (Go) / govulncheck (push) Has been cancelled Details	2026-08-28 22:58:27 +02:00
sysops	e46b8ed133	IAM-15: timing-safe-vergleich-als-projektweite-coding-konvention (internal/timingsafe, coding-guideline, audit bestehender vergleichsstellen)	2026-08-28 22:56:23 +02:00
sysops	c344dea218	TEN-08: tenant-loeschung-unter-retention-vorbehalt-gobd (RetentionChecker-Schnittstelle gegen Archive RET-03/CMP-06, ProcessDueDeletions haelt gesperrte Tenants zurueck)	2026-08-28 22:51:05 +02:00
sysops	218971824b	OPS-04: incident-response-plan-inkl-dsgvo-meldefristen	2026-08-28 10:58:46 +02:00
sysops	14516b4adf	QA-08: last-leistungstest (jwt-verifikation, connection-pooling, rate-limiting unter mehrmodul-last)	2026-08-28 10:54:05 +02:00
sysops	3ea2489f45	QA-08: tenant-router (TEN-06) + ratelimit (API-03) + apiserver (API-01) auf api-05-basis portiert	2026-08-28 10:52:27 +02:00
sysops	196b48ce09	QA-07: schnittstellen-vertragstests fuer api-01/api-05/api-02/api-07 + gitea-actions-workflow Core-Schnittstellen-Vertragstests / contract-tests (push) Successful in 2m13s Details	2026-08-28 10:34:25 +02:00
sysops	e0c82b5d63	QA-07: apiserver+moduleregistry+flag+webhook auf api-05-basis portiert (fuer vertragstests benoetigt)	2026-08-28 10:30:12 +02:00
sysops	ec9bb27bb3	API-06: go.sum/go.mod aktualisieren (golang-jwt/jwt/v5 fuer moduletrust)	2026-08-28 09:22:56 +02:00
sysops	0fd9856b10	API-06: wiederanlauf-nachsynchronisierung-nach-core-ausfall (postgres-puffer, service-credential, sofort-invalidate)	2026-08-28 09:22:08 +02:00
sysops	c4840ca55b	API-07: fix — unbenutzten pgx-import entfernen (build-fehler, nur auf testhost gepatcht gewesen)	2026-08-28 09:08:06 +02:00
sysops	34a705390c	API-07: test-fix — signaturvergleich gegen tatsaechlich empfangene bytes (jsonb-kanonisierung)	2026-08-28 09:06:05 +02:00
sysops	627961b972	API-07: zentrale-webhook-registry-zustellung (postgres-jobqueue, hmac-signatur, backoff)	2026-08-28 09:03:06 +02:00
sysops	da80643564	OPS-03: dev-server fuer live-scrape-verifikation; expfmt-namensvalidierung fixen	2026-08-28 08:43:18 +02:00
sysops	814a7fda0a	OPS-03: metrics-aggregation-ueber-module-hinweg (prometheus-textformat, dynamische quellen)	2026-08-28 08:39:54 +02:00
sysops	8085f39142	API-04: openapi-schnittstellenbeschreibung (drift-check + beispielausfuehrung)	2026-08-28 08:17:11 +02:00
sysopsandClaude Sonnet 5	3d5f53f103	RBAC-04: modul-scoped-berechtigungen internal/policy/module_scope.go: policy_module_scopes verknuepft optional eine (role, permission)-Regel mit einem LIC-02-Feature-Flag. Enforcer. AuthorizeForTenant ist DIESELBE zentrale Entscheidungsfunktion wie Authorize (Akzeptanzkriterium 3, kein zweiter Enforcement-Mechanismus) — prueft zusaetzlich zur Grundregel, ob das verknuepfte Modul fuer den Tenant aktiv ist. Existiert kein ModuleScope-Eintrag, bleibt eine Regel wie bisher ohne Lizenzbindung gueltig (Kombinationsfall). GuardModuleScoped erweitert policy.Guard um dieselbe Pruefung. internal/flag (LIC-02) wurde 1:1 aus dem lic-02-Branch uebernommen (git show aus derselben Repo-Historie, keine Aenderung) — RBAC-04 haengt sowohl an RBAC-01/02 als auch an LIC-02, aber diese leben auf getrennten, noch nicht gemergten Feature-Branches ohne gemeinsame Historie. Fail-Safe-Verhalten aus LIC-02 greift automatisch: ein nicht konfiguriertes oder nicht erreichbares Feature-Flag gilt als deaktiviert, nie als aktiviert (sicherer Default fuer Modul-Aktivierungspruefungen). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Zugriff auf deaktiviertes Modul trotz passender Rolle abgewiesen — TestAuthorizeForTenant_DeniesWhenModuleNotActivated: GuardModuleScoped ruft die Query-Funktion nachweislich nicht auf. PASS. 2. Reaktivierung macht Berechtigung im laufenden Betrieb wirksam, kein Neustart — TestAuthorizeForTenant_BecomesActiveWithoutRestart: derselbe Enforcer/Service-Prozess, Flag per Store.Set aktiviert, TTL abgewartet, danach erlaubt. PASS. 3. Zusammenspiel Modul-Scope + Rollenscope in Kombinationsfaellen — TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope: keine Regel -> verboten; Regel ohne Modul-Scope -> immer erlaubt; Regel mit Modul-Scope und Flag aus -> verboten; Flag an -> erlaubt. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 22:04:58 +02:00
sysopsandClaude Sonnet 5	b6184b67aa	LIC-05: speicherverbrauch-metrik-je-tenant internal/usage/storage.go: ReportStorageWrite/ReportStorageDelete sind duenne Spezialisierungen von LIC-03s bereits atomarem Store.Increment auf die feste Metrik "storage_bytes" — Loeschung nutzt einfach ein negatives Delta desselben UPSERT-Mechanismus, kein zweiter Zaehl-Codepfad. Damit uebernehmen Akzeptanzkriterium 2 (atomar, race-frei) und die zugehoerigen LIC-03-Garantien direkt, ohne Duplikat. CurrentStorageUsage ist ein einfaches Store.Get auf dieselbe Metrik — LIC-03 kann denselben Wert ueber Store.Get(tenant, StorageBytesMetric) abfragen (Akzeptanzkriterium 3, per Test TestCurrentStorageUsage_MatchesGenericStoreGet belegt: kein zweiter, abweichender Zaehlmechanismus). Die Objekt-Storage-Treiber der Module (DMS FDN-03, Mail ARC-01), die diese Funktionen bei jedem Schreib-/Loeschvorgang aufrufen wuerden, existieren als Code noch nicht (nur geplant in dms-kanban/mail-kanban) — diese Kachel implementiert nur die Core-seitige Zaehl-Schnittstelle, analog zum AUD-05/RetentionRegistrar-Muster. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Paralleler Schreib-Test (viele gleichzeitige Uploads) ergibt korrekten Endstand ohne verlorene Updates — TestReportStorageWrite_ConcurrentUploadsSumCorrectly: 10 parallele Schreibvorgaenge unterschiedlicher Groesse, Endstand exakt gleich der in Go unabhaengig berechneten Summe. PASS. 2. Loeschvorgang dekrementiert korrekt — TestReportStorageDelete_Decrements. PASS. 3. Abfrage liefert konsistenten Wert mit unabhaengiger Kontrollzaehlung — TestCurrentStorageUsage_MatchesIndependentTally (gemischte Schreib-/ Loeschfolge, in Go parallel mitgezaehlt) und TestCurrentStorageUsage_MatchesGenericStoreGet. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 21:13:26 +02:00
sysopsandClaude Sonnet 5	3376cf99dc	AUD-05: audit-log-registrierung bei archive-retention-engine internal/audit/retention.go: RegisterWithArchive meldet audit_log_entry als Objekttyp bei Archives Retention-Engine an (Default-Frist 10 Jahre, GoBD- Buchungsbeleg-Frist, tenant-ueberschreibbar). RetentionRegistrar ist der RET-05-Modul-Adapter-Vertrag, wie Core ihn konsumiert — die eigentliche Implementierung lebt im Archive-Modul. WICHTIGER HINWEIS: Archive (RET-01 Retention-Objektmodell, RET-02 Fristen- Engine, RET-05 Modul-Adapter) existiert zum Zeitpunkt dieser Kachel NICHT als Code — nur als Planung in archive-kanban/. Diese Kachel implementiert ausschliesslich die Core-Seite (Registrierungsaufruf gegen die Schnittstelle) und testet sie gegen einen lokalen Fake, der den RET-05-Vertrag simuliert. Das ist KEIN Ersatz fuer eine echte Integrationspruefung gegen Archive. Core implementiert bewusst keine eigene Loeschlogik fuer Audit-Eintraege (Akzeptanzkriterium 3) — es gibt in diesem Paket keinen Delete-Codepfad ausser dem durch AUD-02 technisch unterbundenen. Pruefungen: 1. Registrierung bei Archive erfolgreich getestet, Objekttyp taucht in Archives Retention-Konfiguration auf — NICHT durchfuehrbar, da Archive nicht existiert. Stattdessen TestRegisterWithArchive_UsesCorrectObjectTypeAndRetention gegen Fake: bestaetigt korrekten Aufruf mit objectType=audit_log_entry, 10 Jahre, tenantOverridable=true. Ausgefuehrt, PASS — aber die eigentliche Pruefung bleibt OFFEN bis Archive RET-05 existiert. 2. Audit-Eintrag mit abgelaufener Frist wird von Archive korrekt als loeschfaellig markiert, Core greift nicht ein — NICHT durchfuehrbar ohne Archive RET-02. Offen. 3. Legal Hold aus Archive verhindert Loeschung trotz abgelaufener Frist — NICHT durchfuehrbar ohne Archive RET-01/02. Offen. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 20:56:48 +02:00
sysopsandClaude Sonnet 5	1bfb2efd94	AUD-02: unveraenderliches-protokoll-append-only Append-only per Trigger (nicht nur GRANT/REVOKE): audit_events_prevent_mutation() wirft bei jedem UPDATE/DELETE auf audit_events eine Exception, unabhaengig von der verbindenden Rolle (Akzeptanzkriterium 1). internal/audit/four_eyes.go: Vier-Augen-Prinzip fuer sicherheitskritische Entscheidungen (Loeschbestaetigung, Rechtevergabe), 1:1 nach archivdms- Vorbild. Request erzeugt einen Klartext-Code (wird ausserhalb des Systems an eine ZWEITE Person uebermittelt) und speichert nur dessen SHA-256-Hash. Confirm sperrt die Zeile mit FOR UPDATE (Akzeptanzkriterium 2 — serialisiert zwei gleichzeitige Bestaetigungsversuche, verhindert doppelte Ausfuehrung), weist eine Bestaetigung durch dieselbe Person wie die anfordernde ab (ErrSameActor, echtes Vier-Augen-Prinzip statt nur Code-Pruefung), und vergleicht den Code timing-safe (Akzeptanzkriterium 3). internal/audit/timingsafe.go: timingSafeEqual als projektweite Referenz- implementierung (subtle.ConstantTimeCompare) fuer sicherheitsrelevante Vergleiche — andere Module (z.B. Archive CMP-06 Freigabelinks) uebernehmen dasselbe Muster laut IAM-02-Konvention. Nebenbei behoben: AUD-01s eigener Test nutzte einen festen Tenant-Slug mit DELETE-basiertem Cleanup — seit dem neuen Append-only-Trigger schlaegt dieses Cleanup lautlos fehl, wodurch Zeilen sich ueber Testlaeufe hinweg summierten und die Zaehl-Assertion brach. Auf eindeutigen Slug pro Lauf umgestellt (direkte, notwendige Folge dieser Kachel, keine Umgestaltung von AUD-01 selbst). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Direkter UPDATE/DELETE-Versuch von der Datenbank abgewiesen — TestAppendOnly_RejectsUpdateAndDelete: beide Operationen scheitern, Eintrag bleibt unveraendert erhalten. PASS. 2. Vier-Augen-Prinzip mit FOR-UPDATE-Lock race-frei unter parallelen Anfragen — TestFourEyes_ConcurrentConfirmIsRaceFree: zwei gleichzeitige Bestaetigungsversuche fuer denselben Vorgang, genau einer erfolgreich, der andere ErrAlreadyDecided. PASS. 3. Timing-safe Vergleich per Laufzeitmessung stichprobenartig verifiziert — TestTimingSafeEqual_NoEarlyExitTiming: Mismatch am Anfang (603µs) vs. am Ende (574µs) ueber 20000 Iterationen, kein Hinweis auf Short-Circuit- Vergleich (Ratio innerhalb Faktor 3 Toleranz). PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:57:51 +02:00
		`@@ -0,0 +1,2 @@`
							`DROP TABLE webhook_deliveries;`
							`DROP TABLE webhook_subscriptions;`
		`@@ -0,0 +1,2 @@`
							`ALTER TABLE tenants DROP COLUMN retention_block_reason;`
							`ALTER TABLE tenants DROP COLUMN retention_checked_at;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE alert_debounce_state;`
							`DROP TABLE alert_rules;`
		`@@ -0,0 +1,2 @@`
							`DROP TABLE resync_usage_buffer;`
							`DROP TABLE resync_audit_buffer;`
		`@@ -0,0 +1 @@`
							`DROP TABLE IF EXISTS security_confirmations;`