OPS-05: fix — go.mod auf go 1.25.0 (prometheus/client_golang benoetigt es), sql-typfehler in shouldFire (interval-multiplikation statt string-konkatenation)

# Conflicts:
#	scripts/reset-test-env.sh
#	scripts/run-checks.sh

.gitea/workflows/mail-pflichttest-gate.yml

@@ -1,23 +0,0 @@
-name: Mail-Pflichttest-Gate
-
-on:
-  pull_request:
-    paths:
-      - "mail/**"
-
-jobs:
-  pflichttest-gate:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v5
-        with:
-          go-version: "1.22"
-      - name: Gate bauen
-        working-directory: mail
-        run: go build -o /tmp/pflichttestgate ./cmd/pflichttestgate
-      - name: Geänderte Dateien gegen Pflichttest-Regel prüfen
-        run: |
-          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate

DEVLOG.md

@@ -44,3 +44,119 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 
 ---
+## 2026-08-27 17:26 – 17:28 (1m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:28 – 17:29 (1m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:31 – 17:31 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:36 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:37 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-28 23:55 – 23:59 (3m)
+**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 ++++++++++++++++++++++
+
+---

cmd/core/main.go

@@ -7,6 +7,7 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 )
 
 func main() {
@@ -15,16 +16,30 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}
 
-	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
+	ctx := context.Background()
+
+	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("db: %v", err)
+		log.Fatalf("registry db: %v", err)
 	}
-	defer pool.Close()
+	defer registryPool.Close()
+
+	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
+	if err != nil {
+		log.Fatalf("admin db: %v", err)
+	}
+	defer adminPool.Close()
+
+	registry := tenant.NewRegistry(registryPool)
+	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
+	tenantHandler := tenant.NewHandler(provisioner)
 
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
+	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
+	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

cmd/metrics-devserver/main.go

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

go.mod

@@ -1,5 +1,25 @@
 module gitea.perlbach24.de/scripte/nexarch
 
-go 1.22
+go 1.25.0
 
-require github.com/jackc/pgx/v5 v5.6.0
+require (
+	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
+)
+
+require (
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/prometheus/procfs v0.21.1 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sync v0.22.0 // indirect
+	golang.org/x/sys v0.47.0 // indirect
+	golang.org/x/text v0.40.0 // indirect
+	google.golang.org/protobuf v1.36.11 // indirect
+)

go.sum

@@ -0,0 +1,52 @@
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU=
+github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
+github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY=
+github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc=
+github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
+github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
+go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
+golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
+golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/alerting/evaluator.go

@@ -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()
+}

internal/alerting/evaluator_test.go

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

internal/alerting/rules.go

@@ -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
+}

internal/cfgservice/service.go

@@ -0,0 +1,88 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
+// (Akzeptanzkriterium 2 / Pruefung 2 in diesem Ticket bezieht sich auf die
+// Aenderungsnachvollziehbarkeit — die Cache-Frist selbst folgt demselben
+// Muster wie internal/flag.DefaultCacheTTL).
+const DefaultCacheTTL = 5 * time.Second
+
+type cacheEntry struct {
+	value     Value
+	expiresAt time.Time
+}
+
+// Service ist die Leseseite mit Vorrangregel (Akzeptanzkriterium 1:
+// Tenant-Override vor Global-Default) und lokalem TTL-Cache.
+type Service struct {
+	store *Store
+	ttl   time.Duration
+
+	mu    sync.RWMutex
+	cache map[string]cacheEntry // Schluessel: key + "\x00" + tenantSlug
+}
+
+func NewService(store *Store, ttl time.Duration) *Service {
+	if ttl <= 0 {
+		ttl = DefaultCacheTTL
+	}
+	return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
+}
+
+func cacheKey(key, tenantSlug string) string {
+	return key + "\x00" + tenantSlug
+}
+
+// Resolve liefert den Konfigurationswert fuer einen Tenant: ein
+// Tenant-spezifischer Override hat Vorrang vor dem globalen Default
+// (Akzeptanzkriterium 1 / Pruefung 1). tenantSlug == "" wertet nur den
+// globalen Wert aus.
+func (s *Service) Resolve(ctx context.Context, tenantSlug, key string) (Value, error) {
+	ck := cacheKey(key, tenantSlug)
+
+	s.mu.RLock()
+	entry, exists := s.cache[ck]
+	fresh := exists && time.Now().Before(entry.expiresAt)
+	s.mu.RUnlock()
+	if fresh {
+		return entry.value, nil
+	}
+
+	v, err := s.resolveUncached(ctx, tenantSlug, key)
+	if err != nil {
+		return Value{}, err
+	}
+
+	s.mu.Lock()
+	s.cache[ck] = cacheEntry{value: v, expiresAt: time.Now().Add(s.ttl)}
+	s.mu.Unlock()
+	return v, nil
+}
+
+func (s *Service) resolveUncached(ctx context.Context, tenantSlug, key string) (Value, error) {
+	if tenantSlug != "" {
+		v, err := s.store.Get(ctx, key, tenantSlug)
+		if err == nil {
+			return v, nil
+		}
+		if !errors.Is(err, ErrNotFound) {
+			return Value{}, err
+		}
+	}
+	return s.store.Get(ctx, key, GlobalScope)
+}
+
+// Invalidate erzwingt beim naechsten Resolve-Aufruf ein sofortiges Neuladen
+// fuer einen bestimmten (key, tenantSlug) statt auf den TTL-Ablauf zu warten
+// — analog internal/flag.Service.Invalidate.
+func (s *Service) Invalidate(key, tenantSlug string) {
+	s.mu.Lock()
+	delete(s.cache, cacheKey(key, tenantSlug))
+	s.mu.Unlock()
+}

internal/cfgservice/service_test.go

@@ -0,0 +1,114 @@
+package cfgservice
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// Akzeptanzkriterium 1 + Pruefung 1: Tenant-Override hat Vorrang vor
+// Global-Default, automatisiert getestet.
+func TestService_TenantOverrideTakesPrecedenceOverGlobal(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_precedence_key", GlobalScope, "global-wert"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if _, err := store.Set(ctx, "test_precedence_key", "test_acme", "tenant-wert"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	svc := NewService(store, time.Hour)
+
+	got, err := svc.Resolve(ctx, "test_acme", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve mit override: %v", err)
+	}
+	if got.Value != "tenant-wert" {
+		t.Fatalf("erwartet tenant-override, habe %q", got.Value)
+	}
+
+	gotOther, err := svc.Resolve(ctx, "test_anderer_tenant", "test_precedence_key")
+	if err != nil {
+		t.Fatalf("resolve ohne override: %v", err)
+	}
+	if gotOther.Value != "global-wert" {
+		t.Fatalf("erwartet global-default fuer tenant ohne override, habe %q", gotOther.Value)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Cache-Invalidierung nach
+// Konfigurationsaenderung innerhalb dokumentierter Zeit gemessen.
+func TestService_CacheInvalidationTiming(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	const ttl = 150 * time.Millisecond
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, ttl)
+
+	v, err := svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("erwartet 'alt', habe %q", v.Value)
+	}
+
+	changedAt := time.Now()
+	if _, err := store.Set(ctx, "test_ttl_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+
+	v, err = svc.Resolve(ctx, "", "test_ttl_key")
+	if err != nil {
+		t.Fatalf("resolve direkt nach aenderung: %v", err)
+	}
+	if v.Value != "alt" {
+		t.Fatalf("cache haette den alten wert liefern sollen, habe %q", v.Value)
+	}
+
+	deadline := changedAt.Add(ttl + 100*time.Millisecond)
+	for time.Now().Before(deadline) {
+		v, err := svc.Resolve(ctx, "", "test_ttl_key")
+		if err != nil {
+			t.Fatalf("resolve: %v", err)
+		}
+		if v.Value == "neu" {
+			t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", time.Since(changedAt), ttl)
+			return
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
+}
+
+func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "alt"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc := NewService(store, time.Hour)
+	_, _ = svc.Resolve(ctx, "", "test_invalidate_key")
+
+	if _, err := store.Set(ctx, "test_invalidate_key", GlobalScope, "neu"); err != nil {
+		t.Fatalf("set: %v", err)
+	}
+	svc.Invalidate("test_invalidate_key", "")
+
+	v, err := svc.Resolve(ctx, "", "test_invalidate_key")
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	if v.Value != "neu" {
+		t.Fatalf("erwartet sofort sichtbaren neuen wert nach Invalidate, habe %q", v.Value)
+	}
+}

internal/cfgservice/store.go

@@ -0,0 +1,129 @@
+// Package cfgservice implementiert Core CFG-01: den zentralen Dienst fuer
+// globale und tenant-spezifische Konfigurationswerte mit Versionierung und
+// Cache-Invalidierung. Andere Module lesen Konfiguration AUSSCHLIESSLICH
+// ueber dieses Paket (Akzeptanzkriterium 3), niemals ueber eigene Tabellen.
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalScope ist der reservierte Scope-Wert fuer globale Defaults — jeder
+// andere Scope-Wert ist ein Tenant-Slug (Akzeptanzkriterium 1).
+const GlobalScope = "global"
+
+var ErrNotFound = errors.New("cfgservice: kein wert fuer diesen key gefunden")
+
+type Value struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+type HistoryEntry struct {
+	Key     string
+	Scope   string
+	Value   string
+	Version int
+}
+
+// Store ist die Schreib-/Verwaltungsseite. Set schreibt IMMER sowohl den
+// aktuellen Stand (config_values) als auch einen Historieneintrag
+// (config_value_history) in derselben Transaktion — eine Aenderung ohne
+// Versionshistorie ist strukturell ausgeschlossen (Akzeptanzkriterium 2).
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Set schreibt einen neuen Wert fuer (key, scope) und erhoeht die Version um 1
+// (Version 1 bei erstmaligem Setzen).
+func (s *Store) Set(ctx context.Context, key, scope, value string) (Value, error) {
+	if scope == "" {
+		return Value{}, errors.New("cfgservice: scope darf nicht leer sein")
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Value{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var currentVersion int
+	err = tx.QueryRow(ctx, `SELECT version FROM config_values WHERE key = $1 AND scope = $2`, key, scope).Scan(&currentVersion)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return Value{}, fmt.Errorf("aktuelle version lesen: %w", err)
+	}
+	newVersion := currentVersion + 1
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_values (key, scope, value, version, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key, scope) DO UPDATE SET value = $3, version = $4, updated_at = now()
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("wert speichern: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO config_value_history (key, scope, value, version, changed_at)
+		VALUES ($1, $2, $3, $4, now())
+	`, key, scope, value, newVersion); err != nil {
+		return Value{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Value{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return Value{Key: key, Scope: scope, Value: value, Version: newVersion}, nil
+}
+
+// Get liefert den Wert fuer GENAU EINEN Scope (kein Vorrang-Fallback) — die
+// Vorrangregel (Tenant vor Global) lebt bewusst in Service.Resolve, damit
+// Store rein CRUD bleibt.
+func (s *Store) Get(ctx context.Context, key, scope string) (Value, error) {
+	var v Value
+	v.Key, v.Scope = key, scope
+	err := s.pool.QueryRow(ctx, `
+		SELECT value, version FROM config_values WHERE key = $1 AND scope = $2
+	`, key, scope).Scan(&v.Value, &v.Version)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Value{}, ErrNotFound
+		}
+		return Value{}, fmt.Errorf("wert lesen: %w", err)
+	}
+	return v, nil
+}
+
+// History liefert die vollstaendige Versionshistorie eines (key, scope) in
+// aufsteigender Reihenfolge (Akzeptanzkriterium 2 / Pruefung 3).
+func (s *Store) History(ctx context.Context, key, scope string) ([]HistoryEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT key, scope, value, version FROM config_value_history
+		WHERE key = $1 AND scope = $2 ORDER BY version
+	`, key, scope)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []HistoryEntry
+	for rows.Next() {
+		var h HistoryEntry
+		if err := rows.Scan(&h.Key, &h.Scope, &h.Value, &h.Version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, h)
+	}
+	return out, rows.Err()
+}

internal/cfgservice/store_test.go

@@ -0,0 +1,119 @@
+package cfgservice
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStoreTest(t *testing.T) (*Store, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS config_values (
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL CHECK (scope <> ''),
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			PRIMARY KEY (key, scope)
+		);
+		CREATE TABLE IF NOT EXISTS config_value_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			key TEXT NOT NULL,
+			scope TEXT NOT NULL,
+			value TEXT NOT NULL,
+			version INT NOT NULL,
+			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM config_value_history WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		_, _ = pool.Exec(ctx, `DELETE FROM config_values WHERE key LIKE 'test\_%' ESCAPE '\'`)
+		pool.Close()
+	}
+	return NewStore(pool), cleanup
+}
+
+func TestStore_SetIncrementsVersion(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	v1, err := store.Set(ctx, "test_key", GlobalScope, "erster-wert")
+	if err != nil {
+		t.Fatalf("set 1: %v", err)
+	}
+	if v1.Version != 1 {
+		t.Fatalf("erwartet version 1, habe %d", v1.Version)
+	}
+
+	v2, err := store.Set(ctx, "test_key", GlobalScope, "zweiter-wert")
+	if err != nil {
+		t.Fatalf("set 2: %v", err)
+	}
+	if v2.Version != 2 {
+		t.Fatalf("erwartet version 2, habe %d", v2.Version)
+	}
+
+	got, err := store.Get(ctx, "test_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Value != "zweiter-wert" || got.Version != 2 {
+		t.Fatalf("aktueller wert unerwartet: %+v", got)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Versionierungshistorie ueber mehrere
+// Aenderungen hinweg nachvollzogen.
+func TestStore_HistoryTracksAllChanges(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	values := []string{"v1", "v2", "v3"}
+	for _, v := range values {
+		if _, err := store.Set(ctx, "test_history_key", GlobalScope, v); err != nil {
+			t.Fatalf("set %q: %v", v, err)
+		}
+	}
+
+	history, err := store.History(ctx, "test_history_key", GlobalScope)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 3 {
+		t.Fatalf("erwartet 3 historieneintraege, habe %d", len(history))
+	}
+	for i, h := range history {
+		if h.Version != i+1 || h.Value != values[i] {
+			t.Fatalf("historieneintrag[%d] unerwartet: %+v", i, h)
+		}
+	}
+}
+
+func TestStore_GetUnknownKeyReturnsNotFound(t *testing.T) {
+	store, cleanup := setupStoreTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Get(ctx, "test_nie_gesetzt", GlobalScope); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartet ErrNotFound, habe %v", err)
+	}
+}

internal/config/config.go

@@ -10,8 +10,15 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr  string
+	ListenAddr string
+	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
+	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
+	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
+	AdminDSN string
+	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
+	TenantDSNTemplate string
 }
 
 func Load() (Config, error) {
@@ -20,10 +27,25 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}
 
+	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
+	if adminDSN == "" {
+		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
+	}
+
+	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
+	if dsnTemplate == "" {
+		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
+	}
+
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}
 
-	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
+	return Config{
+		ListenAddr:        addr,
+		RegistryDSN:       dsn,
+		AdminDSN:          adminDSN,
+		TenantDSNTemplate: dsnTemplate,
+	}, nil
 }

internal/flag/flag.go

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

internal/flag/flag_test.go

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

internal/flag/service.go

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

internal/flag/service_test.go

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

internal/health/checks.go

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

internal/health/handler.go

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

internal/health/health.go

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

internal/health/health_test.go

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

internal/metrics/core.go

@@ -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
+}

internal/metrics/metrics.go

@@ -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
+			}
+		}
+	}
+}

internal/metrics/metrics_test.go

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

internal/metrics/sources.go

@@ -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()
+}

internal/metrics/sources_test.go

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

internal/moduleregistry/credentials.go

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

internal/moduleregistry/middleware.go

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

internal/moduleregistry/registry.go

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

internal/moduleregistry/registry_test.go

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

internal/notify/dispatcher.go

@@ -0,0 +1,81 @@
+// Package notify implementiert Core CFG-02: den zentralen Benachrichtigungs-
+// Dispatcher, ueber den beliebige Module Benachrichtigungen ausloesen —
+// Warteschlange, Wiederholungslogik, Kanal-Abstraktion. Die tatsaechlichen
+// Kanaele (E-Mail/In-App) sind CFG-03, hier gibt es nur die Sender-
+// Schnittstelle als Vorbereitung.
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultMaxAttempts begrenzt Wiederholungsversuche (Akzeptanzkriterium 2) —
+// nach dieser Anzahl gibt der Dispatcher kontrolliert auf (status=failed)
+// statt endlos zu wiederholen.
+const DefaultMaxAttempts = 5
+
+// DefaultRetryBackoff ist die Basis-Wartezeit zwischen Wiederholungen,
+// linear mit der Versuchsnummer skaliert.
+const DefaultRetryBackoff = 200 * time.Millisecond
+
+type Notification struct {
+	ID        string
+	Channel   string
+	Recipient string
+	Payload   map[string]any
+	Attempts  int
+}
+
+// Sender ist die schmale Schnittstelle, die ein konkreter Kanal (CFG-03)
+// implementiert. Der Dispatcher selbst weiss nichts ueber E-Mail/In-App.
+type Sender interface {
+	Send(ctx context.Context, n Notification) error
+}
+
+// Dispatcher ist die EINE Schnittstelle, ueber die Module Benachrichtigungen
+// ausloesen — kein Modul baut eigenen Versandcode (Akzeptanzkriterium 1).
+type Dispatcher struct {
+	pool         *pgxpool.Pool
+	maxAttempts  int
+	retryBackoff time.Duration
+}
+
+func NewDispatcher(pool *pgxpool.Pool) *Dispatcher {
+	return &Dispatcher{pool: pool, maxAttempts: DefaultMaxAttempts, retryBackoff: DefaultRetryBackoff}
+}
+
+// WithRetryPolicy erlaubt Tests/Betrieb, Versuchsanzahl und Backoff
+// anzupassen, ohne die Default-Policy im Produktionscode zu veraendern.
+func (d *Dispatcher) WithRetryPolicy(maxAttempts int, backoff time.Duration) *Dispatcher {
+	return &Dispatcher{pool: d.pool, maxAttempts: maxAttempts, retryBackoff: backoff}
+}
+
+// Enqueue reiht eine Benachrichtigung in die Postgres-Warteschlange ein und
+// kehrt sofort zurueck — die Zeile ueberlebt jeden Neustart des Dispatcher-
+// Prozesses unveraendert (Akzeptanzkriterium 3), da sie ausschliesslich in
+// der Datenbank existiert, nicht im Prozessspeicher.
+func (d *Dispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	var id string
+	err = d.pool.QueryRow(ctx, `
+		INSERT INTO notification_jobs (channel, recipient, payload, max_attempts)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, channel, recipient, payloadJSON, d.maxAttempts).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("benachrichtigung einreihen: %w", err)
+	}
+	return id, nil
+}

internal/notify/dispatcher_test.go

@@ -0,0 +1,219 @@
+package notify
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			channel TEXT NOT NULL,
+			recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb,
+			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+			attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return pool, cleanup
+}
+
+type fakeSender struct {
+	mu        sync.Mutex
+	sentIDs   []string
+	failUntil int
+	calls     int
+}
+
+func (f *fakeSender) Send(ctx context.Context, n Notification) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls++
+	if f.calls <= f.failUntil {
+		return errors.New("simulierter zustellfehler")
+	}
+	f.sentIDs = append(f.sentIDs, n.ID)
+	return nil
+}
+
+func (f *fakeSender) sentCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.sentIDs)
+}
+
+// Akzeptanzkriterium 1: Module loesen ueber Enqueue aus, keine eigene
+// Versandlogik noetig.
+func TestDispatcher_EnqueueAndProcess(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	id, err := d.Enqueue(ctx, "email", "alice@example.com", map[string]any{"subject": "Willkommen"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id == "" {
+		t.Fatal("erwartet nicht-leere id")
+	}
+
+	sender := &fakeSender{}
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 failed=0, habe sent=%d failed=%d", sent, failed)
+	}
+	if sender.sentCount() != 1 {
+		t.Fatalf("erwartet 1 zustellung, habe %d", sender.sentCount())
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Wiederholungslogik greift bei
+// simuliertem Fehler und bricht nach definierter Anzahl kontrolliert ab.
+func TestProcessDue_RetriesThenGivesUpAfterMaxAttempts(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool).WithRetryPolicy(3, time.Millisecond)
+	id, err := d.Enqueue(ctx, "email", "bob@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	sender := &fakeSender{failUntil: 100} // schlaegt bei jedem versuch fehl
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(5 * time.Millisecond) // next_attempt_at abwarten
+		if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, id).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach max_attempts, habe %q", status)
+	}
+	if attempts != 3 {
+		t.Fatalf("erwartet 3 versuche, habe %d", attempts)
+	}
+
+	// Weiteres ProcessDue darf den bereits aufgegebenen job nicht mehr anfassen.
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach abbruch: %v", err)
+	}
+	if sent != 0 || failed != 0 {
+		t.Fatalf("erwartet keine weitere verarbeitung, habe sent=%d failed=%d", sent, failed)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Neustart des Dienstes waehrend offener
+// Zustellung verliert keine Nachricht — simuliert durch eine komplett neue
+// Dispatcher/Pool-Instanz nach dem Enqueue, bevor irgendetwas verarbeitet wurde.
+func TestQueue_SurvivesRestartWithoutMessageLoss(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	firstInstance := NewDispatcher(pool)
+	id, err := firstInstance.Enqueue(ctx, "email", "carol@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	// "Neustart": eine voellig neue Dispatcher-Instanz (repraesentiert einen
+	// neuen Prozess) verbindet sich neu und verarbeitet die Warteschlange —
+	// die Nachricht existiert ausschliesslich in Postgres, nicht im
+	// Prozessspeicher der ersten Instanz.
+	restartedInstance := NewDispatcher(pool)
+	sender := &fakeSender{}
+	sent, failed, err := restartedInstance.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach neustart: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 nach neustart, habe sent=%d failed=%d", sent, failed)
+	}
+	if len(sender.sentIDs) != 1 || sender.sentIDs[0] != id {
+		t.Fatalf("erwartet zustellung der urspruenglichen nachricht %q, habe %v", id, sender.sentIDs)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: zwei gleichzeitig ausloesende Module,
+// beide Nachrichten werden korrekt (und nicht doppelt) zugestellt.
+func TestProcessDue_ConcurrentDispatchBothDelivered(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	idA, err := d.Enqueue(ctx, "email", "modul-a@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue a: %v", err)
+	}
+	idB, err := d.Enqueue(ctx, "email", "modul-b@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue b: %v", err)
+	}
+
+	sender := &fakeSender{}
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+				t.Errorf("process: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if sender.sentCount() != 2 {
+		t.Fatalf("erwartet genau 2 zustellungen, habe %d: %v", sender.sentCount(), sender.sentIDs)
+	}
+	seen := map[string]bool{}
+	for _, id := range sender.sentIDs {
+		if seen[id] {
+			t.Fatalf("nachricht %q wurde doppelt zugestellt", id)
+		}
+		seen[id] = true
+	}
+	if !seen[idA] || !seen[idB] {
+		t.Fatalf("erwartet beide nachrichten zugestellt, habe %v", sender.sentIDs)
+	}
+}

internal/notify/worker.go

@@ -0,0 +1,102 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// ProcessDue holt bis zu limit faellige Benachrichtigungen und versucht sie
+// ueber sender zuzustellen. FOR UPDATE SKIP LOCKED serialisiert konkurrierende
+// Aufrufe (Akzeptanzkriterium 3 / Pruefung 3: zwei gleichzeitig ausloesende
+// Module duerfen sich nicht gegenseitig blockieren oder Nachrichten doppelt
+// zustellen) — dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions.
+func (d *Dispatcher) ProcessDue(ctx context.Context, sender Sender, limit int) (sent, failed int, err error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT id, channel, recipient, payload, attempts, max_attempts
+		FROM notification_jobs
+		WHERE status = 'pending' AND next_attempt_at <= now()
+		ORDER BY created_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return 0, 0, fmt.Errorf("faellige benachrichtigungen abfragen: %w", err)
+	}
+
+	type due struct {
+		id, channel, recipient string
+		payload                []byte
+		attempts, maxAttempts  int
+	}
+	var candidates []due
+	for rows.Next() {
+		var c due
+		if err := rows.Scan(&c.id, &c.channel, &c.recipient, &c.payload, &c.attempts, &c.maxAttempts); err != nil {
+			rows.Close()
+			return 0, 0, fmt.Errorf("faellige benachrichtigung lesen: %w", err)
+		}
+		candidates = append(candidates, c)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, 0, err
+	}
+
+	for _, c := range candidates {
+		var payload map[string]any
+		if err := json.Unmarshal(c.payload, &payload); err != nil {
+			payload = map[string]any{}
+		}
+
+		sendErr := sender.Send(ctx, Notification{
+			ID: c.id, Channel: c.channel, Recipient: c.recipient, Payload: payload, Attempts: c.attempts,
+		})
+
+		if sendErr == nil {
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs SET status = 'sent', updated_at = now() WHERE id = $1
+			`, c.id); err != nil {
+				return sent, failed, fmt.Errorf("erfolg speichern: %w", err)
+			}
+			sent++
+			continue
+		}
+
+		newAttempts := c.attempts + 1
+		if newAttempts >= c.maxAttempts {
+			// Akzeptanzkriterium 2: kontrollierter Abbruch nach definierter
+			// Anzahl Versuche, kein endloses Wiederholen.
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs
+				SET status = 'failed', attempts = $2, last_error = $3, updated_at = now()
+				WHERE id = $1
+			`, c.id, newAttempts, sendErr.Error()); err != nil {
+				return sent, failed, fmt.Errorf("fehlschlag speichern: %w", err)
+			}
+			failed++
+			continue
+		}
+
+		nextAttempt := time.Now().Add(time.Duration(newAttempts) * d.retryBackoff)
+		if _, err := tx.Exec(ctx, `
+			UPDATE notification_jobs
+			SET attempts = $2, next_attempt_at = $3, last_error = $4, updated_at = now()
+			WHERE id = $1
+		`, c.id, newAttempts, nextAttempt, sendErr.Error()); err != nil {
+			return sent, failed, fmt.Errorf("wiederholung planen: %w", err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return sent, failed, nil
+}

internal/tenant/handler.go

@@ -0,0 +1,45 @@
+package tenant
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
+// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
+// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
+// TEN-01 und werden dort nachgezogen.
+type Handler struct {
+	provisioner *Provisioner
+}
+
+func NewHandler(p *Provisioner) *Handler {
+	return &Handler{provisioner: p}
+}
+
+type createTenantRequest struct {
+	Slug string `json:"slug"`
+	Name string `json:"name"`
+}
+
+func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
+	var req createTenantRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
+	if err != nil {
+		if err == ErrInvalidSlug {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(t)
+}

internal/tenant/provisioner.go

@@ -0,0 +1,78 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
+// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
+// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
+// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
+type Provisioner struct {
+	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
+	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
+	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
+	adminPool *pgxpool.Pool
+	registry  *Registry
+	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
+	dsnTemplate string
+}
+
+func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
+	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
+}
+
+// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
+// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
+// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
+func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
+	if err := ValidateSlug(slug); err != nil {
+		return Tenant{}, err
+	}
+
+	dbName := dbNameForSlug(slug)
+
+	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
+	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
+	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
+	}
+
+	t := Tenant{
+		Slug:   slug,
+		Name:   name,
+		DBName: dbName,
+		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
+		Status: StatusActive,
+	}
+
+	tx, err := p.registry.pool.Begin(ctx)
+	if err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
+	}
+
+	created, err := p.registry.insertTx(ctx, tx, t)
+	if err != nil {
+		_ = tx.Rollback(ctx)
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
+	}
+
+	return created, nil
+}
+
+// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
+// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
+func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
+	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+}

internal/tenant/provisioner_test.go

@@ -0,0 +1,105 @@
+package tenant
+
+import (
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
+// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
+// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
+//
+// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
+//
+//	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
+func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	defer adminPool.Close()
+
+	registryPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+	defer registryPool.Close()
+
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("registry-schema: %v", err)
+	}
+
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	registry := NewRegistry(registryPool)
+	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
+
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
+	})
+
+	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
+	if err != nil {
+		t.Fatalf("provision acme: %v", err)
+	}
+	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
+	if err != nil {
+		t.Fatalf("provision globex: %v", err)
+	}
+
+	if tenantA.DBName == tenantB.DBName {
+		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
+	}
+
+	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
+	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
+	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
+	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
+	if err != nil {
+		t.Fatalf("connect tenant a: %v", err)
+	}
+	defer poolA.Close()
+
+	var globexVisible bool
+	err = poolA.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
+		)
+	`, tenantB.DBName).Scan(&globexVisible)
+	if err != nil {
+		t.Fatalf("pruefung tenant-trennung: %v", err)
+	}
+	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
+	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
+	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
+	var currentDB string
+	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
+		t.Fatalf("current_database: %v", err)
+	}
+	if currentDB != tenantA.DBName {
+		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
+	}
+	if currentDB == tenantB.DBName {
+		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
+	}
+}

internal/tenant/registry.go

@@ -0,0 +1,69 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
+// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
+// niemals Geschaeftsdaten eines Mandanten.
+type Registry struct {
+	pool *pgxpool.Pool
+}
+
+func NewRegistry(pool *pgxpool.Pool) *Registry {
+	return &Registry{pool: pool}
+}
+
+// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
+// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
+func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
+	row := tx.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, created_at
+	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
+
+	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
+	var t Tenant
+	row := r.pool.QueryRow(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants WHERE slug = $1
+	`, slug)
+
+	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
+	rows, err := r.pool.Query(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("tenants auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Tenant
+	for rows.Next() {
+		var t Tenant
+		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("tenant lesen: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}

internal/tenant/tenant.go

@@ -0,0 +1,42 @@
+// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
+// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
+package tenant
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive Status = "active"
+)
+
+type Tenant struct {
+	ID        string
+	Slug      string
+	Name      string
+	DBName    string
+	DBDSN     string
+	Status    Status
+	CreatedAt time.Time
+}
+
+// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
+// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
+var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
+
+var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
+
+func ValidateSlug(slug string) error {
+	if !slugPattern.MatchString(slug) {
+		return ErrInvalidSlug
+	}
+	return nil
+}
+
+func dbNameForSlug(slug string) string {
+	return "tenant_" + slug
+}

internal/tenant/tenant_test.go

@@ -0,0 +1,35 @@
+package tenant
+
+import "testing"
+
+func TestValidateSlug(t *testing.T) {
+	cases := []struct {
+		slug    string
+		wantErr bool
+	}{
+		{"acme", false},
+		{"acme_gmbh", false},
+		{"a1", false},
+		{"", true},
+		{"a", true},
+		{"1acme", true},
+		{"Acme", true},
+		{"acme-gmbh", true},
+		{"acme;drop table tenants", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateSlug(c.slug)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
+		}
+	}
+}
+
+func TestDBNameForSlug(t *testing.T) {
+	got := dbNameForSlug("acme")
+	want := "tenant_acme"
+	if got != want {
+		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
+	}
+}

mail/cmd/pflichttestgate/main.go

@@ -1,39 +0,0 @@
-// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-MAIL.md
-// Abschnitt 4. Aufruf: pflichttestgate < geänderte-dateien.txt
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/pflichttestgate"
-)
-
-func main() {
-	var changedFiles []string
-	scanner := bufio.NewScanner(os.Stdin)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if line != "" {
-			changedFiles = append(changedFiles, line)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintf(os.Stderr, "pflichttestgate: eingabe konnte nicht gelesen werden: %v\n", err)
-		os.Exit(2)
-	}
-
-	violations := pflichttestgate.CheckDiff(changedFiles)
-	if len(violations) == 0 {
-		fmt.Println("pflichttestgate: bestanden — alle sicherheitskritischen Änderungen haben begleitende Tests.")
-		return
-	}
-
-	fmt.Fprintln(os.Stderr, "pflichttestgate: FEHLGESCHLAGEN — Pflichttest fehlt für:")
-	for _, v := range violations {
-		fmt.Fprintf(os.Stderr, "  - Package %q (Datei %q hat keine begleitende _test.go-Änderung)\n", v.Package, v.ChangedFile)
-	}
-	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-MAIL.md Abschnitt 4.")
-	os.Exit(1)
-}

mail/docs/ARC-01-PRUEFPROTOKOLL.md

@@ -1,54 +0,0 @@
-# ARC-01 – Prüfprotokoll: Objekt-Speicher-Anbindung für Mails/Anhänge
-
-Voraussetzung ING-04 – bereits Fertig. ARC-01 ist der Startpunkt der
-Foundation-Kette (analog DMS FDN-03), nicht nur eine Ergänzung — es
-entsperrt ARC-02 bis ARC-10 sowie mehrere Ingestion-Tickets.
-
-## Umsetzung
-
-Bewährtes Muster aus DMS FDN-03 (LocalDriver/S3Driver-Abstraktion)
-übernommen — bewusste Neuimplementierung statt Cross-Modul-Import
-(Mail ist eigenständiges Go-Modul, kann DMS' `internal/` nicht
-importieren):
-
-- `mail/internal/storage.Driver` — `Put`/`Get`/`Delete`, zwei
-  Implementierungen (`LocalDriver`, `S3Driver`).
-- `ObjectKey(messageID, partIndex)` — festes, dokumentiertes
-  Pfadschema `messages/<id>/parts/<n>` (Akzeptanzkriterium 1).
-  Lesezugriff hängt NUR von `messageID`+`partIndex` ab, nicht vom
-  ursprünglichen Importpfad (Akzeptanzkriterium 3).
-- **Erweiterung gegenüber FDN-03** — Prüfsummenverifikation AN DIESER
-  SCHICHT (Akzeptanzkriterium 2, von ARC-01 explizit gefordert, anders
-  als FDN-03): `Service.Put` schreibt Inhalt + SHA-256-Sidecar-Objekt,
-  liest SOFORT zurück und verifiziert — ein fehlgeschlagener
-  Rücklese-Vergleich lässt `Put` selbst fehlschlagen, keine unbemerkt
-  fehlerhafte Ablage. `Service.GetVerified` wiederholt die Prüfung bei
-  jedem späteren Lesezugriff.
-- `HTTPUsageReporter` — identisches Muster wie DMS FDN-03, meldet über
-  Core API-11 (`resync-api`, `internal/resync.Handler.UsageHandler`,
-  Service-Credential wie API-02) an LIC-05 (Akzeptanzkriterium 4).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: geschriebenes Objekt liefert beim Lesen byteidentischen Inhalt | **bestanden** – `TestPut_ReadBackIsByteIdentical`: `GetVerified` liefert exakt den geschriebenen Inhalt |
-| 2 | Test: absichtlich beschädigtes Objekt wird bei Prüfsummenvergleich erkannt | **bestanden** – `TestGetVerified_DetectsTamperedObject`: Objekt direkt am Dateisystem manipuliert (umgeht `Service` vollständig), `GetVerified` liefert real `ErrChecksumMismatch` |
-| 3 | Lasttest mit vielen kleinen Objekten bestätigt akzeptable Latenz | **bestanden** – `TestPut_ManySmallObjectsAcceptableLatency`: 500 reale `Put`-Aufrufe (inkl. Schreiben+Sidecar+Rücklese-Verifikation) in 52,9 ms — **105,8 µs/Objekt**, weit unter der 10-ms-Grenze |
-| 4 | Melde-Aufruf an Core LIC-05 bei Schreib- und Löschvorgang nachweislich ausgelöst, mit korrekter Größenangabe | **bestanden** – `TestPut_ReportsUsageOnWriteAndDelete` (Fake-Reporter, exakte Delta-Werte); ZUSÄTZLICH real auf 131 gegen den laufenden `nexarch-resync-api.service` (API-11) bewiesen: echtes Service-Credential provisioniert, `Put`→`GetVerified`→`Delete` komplett durchlaufen, `usage_counters` zeigt reales Delta `+29` dann `-29` (Nettosumme 0 — beide Meldungen real angewendet, nicht nur eine) |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1  -> alle Mail-Pakete bestanden (storage, mimeparse, example, pflichttestgate)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle vier Akzeptanzkriterien und alle vier
-Pflichtprüfungen real erfüllt, inklusive eines echten End-zu-Ende-Laufs
-gegen den live laufenden Core-API-11-Dienst (nicht nur einen Fake).
-Entsperrt ARC-02–ARC-10 sowie mehrere Ingestion-Tickets.

mail/docs/ARC-02-PRUEFPROTOKOLL.md

@@ -1,71 +0,0 @@
-# ARC-02 – Prüfprotokoll: Verschlüsselung at rest
-
-Voraussetzung ARC-01 (Mail, Fertig), Core API-10 (Fertig) + API-12
-(neu angelegt und fertig — API-10 war nicht als Dienst erreichbar,
-siehe API-12-Prüfprotokoll).
-
-## Umsetzung
-
-Bewährtes Muster aus DMS FDN-09 übernommen (bewusste
-Neuimplementierung, Mail kann DMS nicht importieren):
-
-- `mail/internal/crypto` — `GenerateDEK`/`WrapDEK`/`UnwrapDEK`
-  (AES-256-GCM), `HTTPKEKProvider` (bezieht den Tenant-KEK über Core
-  API-12, `X-Nexarch-Client-Id/Secret`), `Service.Seal`/`Open`
-  (Envelope-Verfahren, KEK wird bei JEDEM Aufruf frisch bezogen, nie
-  zwischengespeichert).
-- `mail/internal/encstorage` — verbindet ARC-01 (`storage.Service`) mit
-  ARC-02 (`crypto.Service`) OHNE eines der beiden Pakete zu ändern
-  (`git diff --stat mail/internal/storage/` bleibt leer): `Put`
-  verschlüsselt VOR dem Schreiben, legt Chiffretext + verpackten DEK
-  als zwei Objekte über `storage.Service` ab (Prüfsumme,
-  Nutzungsmeldung — ARC-01 unverändert mitgenutzt).
-- **Reihenfolge beachtet** (Ticket "Bekannte Fehler vermeiden"):
-  `encstorage.Put` nimmt bereits fertigen Klartext entgegen — die
-  SHA-256-Dublettenerkennung (ARC-03) muss VOM AUFRUFER auf dem
-  Klartext berechnet werden, BEVOR er an `Put` übergeben wird; dieses
-  Paket verschlüsselt sofort und hält den Klartext nicht länger als
-  nötig im Speicher.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Zugriff auf Rohspeicher ohne Schlüssel liefert keine lesbaren Inhalte | **bestanden** – `TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent`: Objekt über `encstorage.Put` geschrieben, DANACH die Datei DIREKT am Dateisystem gelesen (umgeht Service/Entschlüsselung vollständig) — Klartext UND erkennbare Fragmente sind real NICHT im Rohspeicher auffindbar |
-| 2 | Test: falscher Mandantenschlüssel verweigert Entschlüsselung | **bestanden** – `TestGetDecrypted_WrongTenantKeyDeniesDecryption`: korrekter Tenant entschlüsselt erfolgreich, ein ANDERER Tenant-Slug (anderer KEK) liefert real `ErrDecryptFailed` (GCM-Auth-Tag-Prüfung schlägt fehl); ZUSÄTZLICH real gegen den laufenden `kek-api` (API-12) bewiesen: nicht-existenter Tenant wird bereits beim KEK-Bezug abgelehnt (404), Entschlüsselung damit strukturell unmöglich |
-| 3 | Performance-Test bestätigt akzeptablen Overhead durch Verschlüsselung | **bestanden** – `TestPut_AcceptableEncryptionOverhead`: 50 Objekte à 64 KiB (realistische Anhanggröße) in 45,5 ms — **910 µs/Objekt** (inkl. AES-256-GCM, Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01), weit unter der 50-ms-Grenze |
-
-## Echter End-zu-Ende-Beweis auf 192.168.1.131
-
-Vollständiger Roundtrip gegen den ECHT laufenden `nexarch-kek-api.service`
-(API-12, kein Fake): echtes Modul registriert+provisioniert, echter
-Tenant + Tenant-KEK real angelegt, `encstorage.Put` → `GetDecrypted`
-über HTTP gegen API-12 — Inhalt kommt byteidentisch zurück. Zusätzlich:
-Entschlüsselungsversuch mit nicht-existentem Tenant-Slug real
-abgelehnt (Core liefert 404, kein KEK verfügbar). Testdaten
-anschließend entfernt.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1  -> alle Mail-Pakete bestanden (encstorage, crypto indirekt getestet, storage, mimeparse, example, pflichttestgate)
-```
-
-**Hinweis (offener Punkt, ehrlich vermerkt):** `mail/internal/crypto`
-selbst hat keine eigenen `_test.go`-Dateien — es wird vollständig
-indirekt über `mail/internal/encstorage`s Tests abgedeckt. Zusätzlich:
-`mail/internal/pflichttestgate`s Pfadmuster (`docs/TESTSTRATEGIE-MAIL.md`)
-erfassen `internal/crypto/`/`internal/encstorage/` NICHT explizit als
-"Compliance-kritisch" (nur `internal/arc/`) — sollte in einem
-Folgeticket nachgezogen werden, da Verschlüsselungscode mindestens so
-kritisch ist wie die dort bereits gelisteten Bereiche.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
-Pflichtprüfungen real erfüllt, inklusive eines vollständigen
-End-zu-Ende-Laufs gegen den live laufenden Core-API-12-Dienst.
-Entsperrt ARC-08 (Schlüsselrotation).

mail/docs/ARC-03-PRUEFPROTOKOLL.md

@@ -1,53 +0,0 @@
-# ARC-03 – Prüfprotokoll: Dublettenerkennung E-Mail
-
-Voraussetzung ARC-01 (Mail, Fertig).
-
-## Umsetzung
-
-- `mail/internal/dedup/hash.go` — `HashAndBuffer(plaintext io.Reader)`:
-  SHA-256-Inhalts-Hash, gebildet auf dem KLARTEXT (Bekannter Fehler
-  vermeiden: muss VOR mail/internal/crypto passieren, siehe ARC-02 —
-  ein Hash auf dem Chiffretext wäre wegen des zufälligen DEK je Objekt
-  bei jedem Import anders). Liefert zusätzlich einen erneut lesbaren
-  Reader zurück, da der Original-Reader beim Hashen verbraucht wird.
-- `mail/internal/dedup/store.go` — `Store.Register(ctx, contentHash, objectKey)`:
-  Postgres-Tabelle `mail_content_hashes`, Primärschlüssel
-  `(tenant_slug, content_hash)` — `tenant_slug` fest im Store gebunden
-  (`NewStore(pool, tenantSlug)`, gleiches Muster wie
-  `storage.Service`/`encstorage.Service`), nicht nur Konvention.
-  `ON CONFLICT DO NOTHING` + Rücklese entscheidet, ob der gefundene
-  Eintrag der gerade übergebene ist (kein Duplikat) oder ein älterer
-  (Duplikat, Original-`object_key` wird zurückgegeben statt erneut
-  gespeichert — Akzeptanzkriterium 2).
-- Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
-  `mail/internal/encstorage` unverändert (`git diff --stat` bleibt für
-  alle drei leer). `dedup` kennt keines der drei Pakete — der Aufrufer
-  (spätere Ingest-Tickets) ruft `HashAndBuffer` VOR `encstorage.Put`
-  auf.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: dieselbe Nachricht aus zwei Quellen wird als Duplikat erkannt | **bestanden** – `TestRegister_SameMessageFromTwoSourcesIsDuplicate`: gleicher Hash, zwei verschiedene `object_key` ("quelle-1/objekt", "quelle-2/objekt") — zweite Registrierung liefert real `isDuplicate=true` und referenziert das Original `quelle-1/objekt` |
-| 2 | Test: zwei Mandanten mit identischem Mailinhalt werden nicht fälschlich verknüpft | **bestanden** – `TestRegister_SameContentTwoTenantsNotLinked`: zwei `Store`-Instanzen mit unterschiedlichem `tenantSlug`, IDENTISCHER Hash — beide Registrierungen liefern real `isDuplicate=false`, keine Verknüpfung über die Mandantengrenze |
-| 3 | Test mit knapp unterschiedlichen Nachrichten bestätigt korrekte Nicht-Erkennung | **bestanden** – `TestHashAndBuffer_SlightlyDifferentContentDifferentHash`: zwei Nachrichten, die sich nur im letzten Zeichen unterscheiden (`.` vs `,`) — real unterschiedlicher SHA-256-Hash |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/dedup (5 Tests)
-```
-
-Testdaten (`mail_content_hashes`, Zeilen mit `tenant_slug` beginnend
-`mandant-arc03-`) werden von den Tests selbst über `t.Cleanup`
-entfernt.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
-Pflichtprüfungen real erfüllt. Entsperrt SRC-01, SRC-02, SRC-07.

mail/docs/ARC-06-PRUEFPROTOKOLL.md

@@ -1,116 +0,0 @@
-# ARC-06 — Mandantentrennung im Objekt-Storage: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Paket: `mail/internal/storage` (`provision.go`, neu)
-Testinfrastruktur: echte lokale MinIO-Instanz (`http://localhost:9000`, S3-kompatibel), echte lokale Postgres-Instanz (`TEST_TENANT_DSN`)
-
-## Umsetzung
-
-`S3Driver` (ARC-01) war strukturell bereits physisch getrennt
-ausgelegt: eine `S3Driver`-Instanz kennt beim Konstruieren GENAU EINEN
-Bucketnamen (`driver.go`) und hat keinen Parameter/Pfad-Präfix, über
-den sie jemals ein anderes Bucket adressieren könnte — kein
-gemeinsamer Bucket mit Pfad-Präfix wie beim klassischen Cross-Tenant-
-Leck-Muster. Was fehlte, war die AUTOMATISIERTE PROVISIONIERUNG dieser
-Trennung (Akzeptanzkriterium 3) und der Nachweis (Pflichtprüfungen).
-
-Neue Datei `provision.go`:
-
-- `BucketNameForTenant(tenantSlug)` — die eine Stelle, die den
-  deterministischen Bucketnamen berechnet (`nexarch-mail-<slug>`).
-- `NewS3AdminClient` — S3-Client für Bucket-Verwaltungsoperationen
-  (`CreateBucket`/`HeadBucket`), getrennt von `S3Driver` (das nur
-  Objektoperationen innerhalb eines bereits bekannten Buckets kennt).
-- `ProvisionTenant(ctx, registryPool, s3Admin, tenantSlug, tenantName,
-  dbDSN)` — legt in EINEM Aufruf sowohl die Registry-Zeile in derselben
-  `tenants`-Tabelle wie Core TEN-01
-  (`migrations/0001_tenant_registry.sql` im Repository-Root) als auch
-  den physisch getrennten Bucket an. Schlägt die Bucket-Anlage fehl,
-  wird die Registry-Zeile automatisch zurückgenommen — kein halb
-  provisionierter Mandant.
-
-**Abgrenzung zu Core TEN-01, dokumentiert:** Core TEN-01 (in
-`cmd/core`/`internal/db` im Repository-Root) ist im aktuellen Stand ein
-Grundgerüst (Registry-Tabelle + Health-Endpunkt), enthält noch keine
-eigene, aufrufbare Tenant-Datenbank-Provisionierungsfunktion, an die
-sich diese Kachel technisch anhängen könnte. `ProvisionTenant` schreibt
-deshalb direkt in dieselbe, bereits durch TEN-01 definierte
-`tenants`-Tabelle (Postgres-DSN, kein Cross-Modul-Go-Import nötig, da
-beide Module ohnehin nur über den DSN kommunizieren) — sobald TEN-01
-eine eigene Provisionierungsfunktion bekommt, ruft sie `ProvisionTenant`
-auf, statt dass Mail eine parallele Implementierung pflegt.
-
-## Pflichtprüfung 1: Test bestätigt physische Bucket-Trennung zweier Mandanten
-
-`TestProvisionTenant_CreatesPhysicallySeparateBuckets`: zwei Mandanten
-provisioniert, unterschiedliche Bucketnamen bestätigt. Ein Objekt wird
-in Mandant As Bucket geschrieben; der Zugriff auf denselben Schlüssel
-über Mandant Bs `S3Driver` liefert `ErrNotFound` — nicht weil ein
-Pfadfilter greift, sondern weil es in Mandant Bs (physisch anderem)
-Bucket schlicht kein Objekt dieses Namens gibt. Kontrollzugriff über
-Mandant As eigenen Driver liefert den byteidentischen Inhalt zurück.
-
-Ergebnis: **BESTANDEN** (echte MinIO-Instanz, reale S3-API-Aufrufe).
-
-## Pflichtprüfung 2: Simulierter Zugriffsversuch ohne Tenant-Kontext schlägt fehl, weil kein Bucket referenzierbar ist, nicht weil ein Pfadfilter greift
-
-`TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`:
-`HeadBucket` auf den (nie provisionierten) Bucketnamen eines
-erfundenen Pseudo-Mandanten liefert einen echten S3-API-Fehler auf
-BUCKET-Ebene (`NotFound`/`NoSuchBucket`) — bevor überhaupt eine
-Schlüsselsuche innerhalb eines (in diesem Fall nicht existenten)
-Buckets stattfinden könnte. Das ist der strukturelle Beweis: es gibt
-keinen gemeinsamen Fallback-Bucket, in dem ein fehlender Tenant-Kontext
-auf einen falschen/fehlenden Pfad treffen würde — es gibt schlicht kein
-Bucket.
-
-Ergebnis: **BESTANDEN** (echte MinIO-Instanz).
-
-## Pflichtprüfung 3: Provisionierungs-Test legt für einen neuen Mandanten Datenbank UND Bucket in einem Schritt an
-
-`TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep`: EIN Aufruf
-von `ProvisionTenant` — danach existiert sowohl die Registry-Zeile
-(`SELECT ... FROM tenants WHERE slug = ...` liefert den erwarteten
-`db_dsn`) als auch das Bucket (`HeadBucket` erfolgreich), real gegen
-Postgres und MinIO geprüft. Ergänzend
-`TestProvisionTenant_RollsBackRegistryRowOnBucketFailure`: bei
-fehlschlagender Bucket-Anlage (ungültiger Bucketname) bleibt KEINE
-verwaiste Registry-Zeile zurück — kein halb provisionierter Mandant.
-
-Ergebnis: **BESTANDEN** (echte MinIO- und Postgres-Instanz, inkl.
-Fehlerpfad).
-
-## Akzeptanzkriterien
-
-1. **Jeder Mandant hat einen eigenen, physisch getrennten
-   Bucket/Pfad-Root**: durch Pflichtprüfung 1 belegt.
-2. **Ein Zugriffsversuch ohne oder mit falschem Tenant-Kontext kann
-   technisch kein fremdes Bucket erreichen, nicht nur einen falschen
-   Pfad**: durch Pflichtprüfung 1+2 belegt (strukturell durch
-   `S3Driver`s Design seit ARC-01, hier erstmals real nachgewiesen).
-3. **Bucket-Provisionierung ist Teil desselben automatisierten
-   Schritts wie die Tenant-Datenbank-Anlage, keine manuelle
-   Zusatzaktion nötig**: durch Pflichtprüfung 3 belegt — siehe auch
-   Abschnitt "Umsetzung" zur Abgrenzung gegenüber Core TEN-01s
-   aktuellem Ausbaustand.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
-```
-
-Keine Regression in den bestehenden Paketen. Neue Umgebungsvariablen
-`TEST_S3_ENDPOINT`/`TEST_S3_ACCESS_KEY`/`TEST_S3_SECRET_KEY` — ohne sie
-werden die neuen Integrationstests übersprungen (`t.Skip`), gleiche
-Konvention wie `TEST_TENANT_DSN`/`TEST_MANTICORE_URL`.
-
-## Ergebnis
-
-ARC-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen gegen eine reale MinIO- und Postgres-Instanz. Freigeschaltet
-zusammen mit SRC-11: QA-04.

mail/docs/ARC-08-PRUEFPROTOKOLL.md

@@ -1,87 +0,0 @@
-# ARC-08 – Prüfprotokoll: Verschlüsselungsschlüssel-Rotation
-
-Voraussetzung ARC-02 (Fertig).
-
-## Architektur-Ausgangslage (real geprüft)
-
-Core (API-10, `internal/kek.Store.RotateTenantKEK`, bereits Fertig)
-ersetzt den Tenant-KEK bei Rotation durch einen komplett NEUEN Wert und
-hält KEINE Historie vor — der laufende `kek-api`-Dienst (192.168.1.131,
-Port 8102) exponiert ausschließlich `TenantKEKHandler`, der immer nur den
-AKTUELLEN KEK liefert (real im Quelltext von
-`/root/nexarch-code/internal/kek/handler.go` und `cmd/kek-api/main.go`
-auf 131 verifiziert). Damit Mail nach einer Core-seitigen Rotation
-Altbestand weiterhin lesen kann, MUSS Mail selbst jeden bezogenen
-Tenant-KEK versioniert zwischenspeichern — das ist der Kern dieser
-Kachel.
-
-## Umsetzung
-
-- `mail/internal/crypto/kekversions.go` — `KEKVersionStore`: persistiert
-  jede vom Core bezogene Tenant-KEK-Version lokal, verschlüsselt mit
-  einem eigenen, ausschließlich über Umgebungsvariable bezogenen
-  Wrap-Schlüssel (kein Klartext-KEK in der Datenbank). `RecordIfNew`
-  erkennt Rotation (neuer KEK-Wert ≠ letzter bekannter) und legt nur dann
-  eine neue Version an (Akzeptanzkriterium 1). `Revoke` sperrt gezielt
-  eine einzelne Version (Pflichtprüfung 2).
-- `mail/internal/crypto/service.go` — `Service.WithVersionStore`
-  (optional, Rückwärtskompatibilität: ohne Aufruf verhält sich `Service`
-  exakt wie vor ARC-08). `Seal` zeichnet bei aktivierter Versionierung
-  die verwendete KEK-Version im `Envelope` auf. Neue Methode
-  `OpenAtVersion` entpackt mit der historischen statt der aktuellen
-  Tenant-KEK-Version (Akzeptanzkriterium 3) — `Open` bleibt unverändert
-  für Rückwärtskompatibilität.
-- `mail/internal/encstorage/encstorage.go` — neuer Sidecar
-  `<key>.dek.version` (gleiches Muster wie der bestehende `.dek`-Sidecar
-  aus ARC-02) speichert die KEK-Version je Objekt. `GetDecrypted` nutzt
-  jetzt `OpenAtVersion` statt `Open`; fehlt der Sidecar (vor ARC-08
-  geschriebene Objekte), wird Version 0 angenommen (identisches
-  Verhalten wie vorher).
-- Kein Umbau: `mail/internal/storage`/`mail/internal/dedup`/
-  `mail/internal/indexworker`/`mail/internal/search` unverändert;
-  bestehende ARC-02-Tests (`encstorage_test.go`) unverändert lauffähig
-  ohne Codeänderung an ihnen.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Rotation des Hauptschlüssels lässt Altbestand weiterhin lesbar | **bestanden** – `TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation`: Objekt vor Rotation versiegelt (Version 1), Tenant-Hauptschlüssel real rotiert (Provider liefert ab dann einen anderen Wert, exakt wie `RotateTenantKEK` es bei Core bewirkt), neues Objekt nach Rotation versiegelt (Version 2), Altbestand über `OpenAtVersion` real weiterhin korrekt entschlüsselt — zusätzlich real bestätigt, dass der naive `Open()` mit dem neuen aktuellen KEK für das alte Objekt fehlschlägt (beweist, dass `OpenAtVersion` tatsächlich etwas leistet) |
-| 2 | Test: kompromittierter alter Schlüssel kann gezielt gesperrt werden | **bestanden** – `TestRotation_CompromisedOldKeyCanBeRevoked`: Version gesperrt, `OpenAtVersion` liefert danach real `ErrKEKVersionRevoked`; `TestKEKVersionStore_RevokeBlocksOnlyThatVersion` bestätigt zusätzlich, dass eine ANDERE Version davon unberührt bleibt |
-| 3 | Dokumentierter Rotationsvorgang wurde einmal vollständig durchgespielt | **bestanden** – siehe Abschnitt "Rotationsvorgang" unten, real durchlaufen als `TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation` |
-
-### Rotationsvorgang (Pflichtprüfung 3, vollständig durchgespielt)
-
-1. Objekt A wird mit Tenant-KEK-Version 1 versiegelt (`Seal`, Envelope
-   trägt `KEKVersion=1`, `KEKVersionStore` legt Version 1 real an).
-2. Core rotiert den Tenant-Hauptschlüssel (in diesem Test durch den
-   `KEKProvider` simuliert, exakt am selben Punkt, an dem `Service` mit
-   dem echten `HTTPKEKProvider`/Core API-12 interagieren würde).
-3. Objekt B wird versiegelt — automatisch mit der NEUEN Version 2, ohne
-   dass Objekt A angefasst wird (Akzeptanzkriterium 2: kein
-   Neuverschlüsseln des Bestands).
-4. Objekt A wird über `OpenAtVersion(..., kekVersion=1, ...)` gelesen —
-   real erfolgreich, Klartext identisch zum Original.
-5. Ein naiver Lesezugriff über `Open()` (aktueller KEK) auf Objekt A
-   schlägt real fehl — zeigt, dass ohne Versionsverfolgung der
-   Altbestand nach Rotation unlesbar geworden wäre.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/crypto (4 Tests, neu)
-  und internal/encstorage (4 Tests, unverändert weiterhin grün — Rückwärtskompatibilität
-  real bestätigt)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt (gemeinsam mit SRC-02, SRC-04, SRC-05, SRC-09) zu
-QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch SRC-08 und SRC-10
-fertig sind.

mail/docs/IMP-01-PRUEFPROTOKOLL.md

@@ -1,63 +0,0 @@
-# IMP-01 – Prüfprotokoll: IMAP-Postfach-Abruf & Scheduler
-
-Voraussetzung ING-01, ING-05 (beide Fertig).
-
-## Umsetzung
-
-- `mail/internal/imap` (ING-01) minimal erweitert: `Message.UID`,
-  `MailboxStore.FetchByUID` (RFC 3501 §6.4.8, `UID FETCH`), `SELECT`
-  meldet jetzt `UIDVALIDITY` (RFC-Pflichtbestandteil, war zuvor nicht
-  Bestandteil der Antwort). Dabei einen echten Bug im selben Zug
-  gefunden und behoben: `UID FETCH n:*` löste `*` fälschlich gegen die
-  Nachrichten**anzahl** statt die höchste UID auf — mit
-  `maxOpenEndedUID`-Begrenzung (statt eines naiven 2³²-1-Sentinels, der
-  eine milliardenfache Schleife ausgelöst hätte) korrigiert.
-- `mail/internal/imapimport/state.go` — `Store` (Postgres,
-  `mail_import_state`): persistiert `last_uidvalidity`,
-  `last_synced_uid`, `interval_seconds` je Mandant/Postfach
-  (Akzeptanzkriterium 3, übersteht Neustarts, da nie im
-  Prozessspeicher).
-- `mail/internal/imapimport/scheduler.go` — `Scheduler.RunOnce`:
-  UID-Vergleich klassifiziert Nachrichten als neu vs. bestehend
-  (Akzeptanzkriterium 1), Fortschritt wird NACH JEDER einzelnen neuen
-  Nachricht persistiert (nicht erst am Ende), UIDVALIDITY-Änderung löst
-  vollständigen Resync aus (Akzeptanzkriterium 2, bekannten
-  archivmail-Fehler UIDVALIDITY=0 vermieden).
-- `mail/internal/imapimport/client_real.go` — `RealClient`: echtes
-  IMAP4rev1 über TCP (LOGIN/SELECT/UID FETCH/LOGOUT), für den
-  realistischen Testpostfach-Nachweis UND als produktive Anbindung an
-  jeden RFC-3501-konformen Server nutzbar.
-- Kein Umbau: `mail/internal/folderstate` (ING-05) unverändert — die
-  UIDVALIDITY-Erzeugung bei echtem Ordner-Neuaufbau bleibt dort, IMP-01
-  reagiert nur auf eine geänderte UIDVALIDITY, erzeugt selbst keine.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: zwei aufeinanderfolgende Läufe importieren keine Nachricht doppelt | **bestanden** – `TestRunOnce_TwoConsecutiveRunsNoDuplicateImport`: 3 Nachrichten im ersten Lauf real importiert, zweiter Lauf gegen unverändertes Postfach liefert real 0 neue, 3 bestehende |
-| 2 | Test: simulierter Dienst-Neustart mitten im Abgleich führt zu konsistentem Endzustand | **bestanden** – `TestRunOnce_SimulatedRestartMidSyncConsistentEndState`: Handler schlägt real nach 2 von 5 Nachrichten fehl, neuer Scheduler auf demselben persistenten Store verarbeitet real GENAU die verbleibenden 3, keine der ersten 2 erneut, `last_synced_uid` real konsistent bei 5 |
-| 3 | Test gegen Testpostfach mit realistischem Nachrichtenaufkommen | **bestanden** – `TestRunOnce_AgainstRealTestMailboxWithRealisticVolume`: echter End-zu-Ende-IMAP4rev1-Lauf (`RealClient` gegen echten laufenden ING-01-Server) mit 30 Nachrichten — alle 30 real importiert, zweiter Lauf real 0 neue/30 bestehende |
-
-Zusätzlich (Akzeptanzkriterium 3, Intervallkonfiguration):
-`TestSetInterval_ConfigurableAndSurvivesRestart` — konfiguriertes
-Intervall bleibt nach simuliertem Neustart (neue Store-Instanz auf
-demselben Postgres-Zustand) real erhalten.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/imapimport/... -v -timeout 60s  -> 4/4 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 15 Pakete bestanden, keine Regression (inkl. ING-01: 6/6 weiterhin grün
-  nach UID-FETCH-Erweiterung)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt IMP-02, IMP-03, IMP-04, IMP-05, IMP-07, IMP-08,
-IMP-09, INT-05, UX-01.

mail/docs/IMP-02-PRUEFPROTOKOLL.md

@@ -1,48 +0,0 @@
-# IMP-02 – Prüfprotokoll: Anhangsverarbeitung bei Import
-
-Voraussetzung ING-04, IMP-01 (beide Fertig).
-
-## Umsetzung
-
-- `mail/internal/mimeparse/tolerant.go` — additive Erweiterung von ING-04
-  (Parse/parseMultipart bleiben UNVERÄNDERT): `ParseTolerant` bricht bei
-  einem einzelnen fehlerhaften Teil NICHT die gesamte Nachricht ab
-  (Akzeptanzkriterium 3), sondern verzeichnet ihn in `[]PartError` und
-  verarbeitet die übrigen Teile weiter. Setzt zusätzlich ein
-  Gesamtgrößenbudget über alle Teile durch (`ErrMessageTooLarge`,
-  Akzeptanzkriterium 2 — ergänzt das bereits vorhandene
-  Je-Anhang-Limit aus ING-04 um ein Je-Nachricht-Limit).
-- `mail/internal/attachments/attachments.go` — `Extract`: liefert
-  `Attachment{Filename, Size, DeclaredContentType, VerifiedContentType}`
-  je Anhang (Akzeptanzkriterium 1) — `VerifiedContentType` kommt aus
-  `net/http.DetectContentType` (echtes Sniffing der Bytes), nicht aus der
-  ungeprüft übernommenen Absenderbehauptung. `Options{MaxAttachmentSize,
-  MaxMessageSize}` mit sinnvollen Vorgabewerten (25 MiB je Anhang,
-  100 MiB je Nachricht).
-- Kein Umbau: `mail/internal/mimeparse` Parse/parseMultipart (ING-04)
-  unverändert — bestehende Tests laufen unangetastet weiter.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test mit Nachricht, die einen überdimensionierten Anhang enthält, wird korrekt begrenzt | **bestanden** – `TestExtract_OversizedAttachmentIsCorrectlyLimited`: Anhang über dem Limit wird real übersprungen (nicht extrahiert), Nachrichtentext bleibt real unangetastet |
-| 2 | Test mit mehreren Anhängen unterschiedlichen Typs importiert alle korrekt | **bestanden** – `TestExtract_MultipleAttachmentDifferentTypesAllImported`: PDF + PNG in einer Nachricht, beide real extrahiert, PNG-Anhang liefert real den korrekten gesniffeten Content-Type `image/png` (echte Magic-Bytes) |
-| 3 | Test: ein defekter Anhang lässt Text und übrige Anhänge unangetastet | **bestanden** – `TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched`: ungültiges Base64 in einem Anhang, Nachrichtentext UND der zweite, gültige Anhang kommen real unverändert an |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./internal/attachments/... -v  -> 3/3 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 16 Pakete bestanden, keine Regression (mimeparse: 6/6 weiterhin grün
-  nach additiver ParseTolerant-Erweiterung)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt IMP-06, trägt (gemeinsam mit IMP-03) zu IMP-09 bei.

mail/docs/IMP-03-PRUEFPROTOKOLL.md

@@ -1,51 +0,0 @@
-# IMP-03 – Prüfprotokoll: E-Mail-Regeln (Zuordnung/Tags/Klassifizierung)
-
-Voraussetzung IMP-01 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/mailrules/store.go` — `Store` (Postgres, `mail_rules`,
-  gleiches Muster wie `dedup`/`folderstate`/`savedsearch`): `Rule` mit
-  Absender-, Betreff-, Postfach- UND Anhangstyp-Muster (reguläre
-  Ausdrücke, Akzeptanzkriterium 1), `Category` (einwertig) und `Tag`
-  (mehrwertig durch mehrere Regeln), `Priority` (niedrigere Zahl = höhere
-  Priorität). Regex-Validierung bereits beim Anlegen (`Create`).
-- `mail/internal/mailrules/engine.go` — `Engine.Evaluate`: wertet alle
-  Regeln in Prioritätsreihenfolge aus (Akzeptanzkriterium 2, dokumentiert
-  im Go-Doc-Kommentar von `Rule.Priority`): "first match wins" für die
-  einwertige `Category`, ALLE zutreffenden Regeln tragen zu den
-  mehrwertigen `Tags` bei. Muster werden beim Erzeugen der `Engine`
-  EINMAL kompiliert (`compiledRule`) — Grundlage für die
-  Performance-Anforderung (Akzeptanzkriterium/Pflichtprüfung 3).
-- Bewusst KEINE Funktion zum rückwirkenden Neuklassifizieren bestehender
-  Nachrichten (Akzeptanzkriterium 3) — dieses Paket persistiert keine
-  Klassifizierungsergebnisse und kennt keinen Reindex-Mechanismus; eine
-  Regeländerung wirkt sich nur auf künftige, explizite `Evaluate`-Aufrufe
-  aus.
-- Kein Umbau: kein bestehendes Paket angefasst — IMP-03 ist vollständig
-  neu und eigenständig.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test mit widersprüchlichen Regeln bestätigt dokumentierte Priorisierung | **bestanden** – `TestEvaluate_ConflictingRulesRespectDocumentedPriority`: zwei Regeln matchen dieselbe Nachricht mit widersprüchlichen Kategorien, die höherpriorisierte (Priority 10 vor 200) gewinnt real |
-| 2 | Test: neue Regel ändert keine bereits importierten Altbestände automatisch | **bestanden** – `TestNewEngine_NewRuleDoesNotAffectAlreadyCapturedResult`: ein vor Regelanlage erfasstes Ergebnis bleibt real unverändert, nachdem die neue Regel angelegt wurde; erst eine explizite Neuauswertung zeigt real die neue Kategorie |
-| 3 | Regelset mit 20+ Regeln bleibt performant auswertbar | **bestanden** – `TestEvaluate_TwentyPlusRulesStayPerformant`: 31 reale Regeln, 1000 Auswertungen in 2,64ms gesamt (2,64µs/Auswertung) |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/mailrules/... -v -timeout 60s  -> 3/3 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 17 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt INT-06, trägt (gemeinsam mit IMP-02, bereits
-Fertig) vollständig zu IMP-09 bei — IMP-09 ist jetzt ungeblockt.

mail/docs/IMP-04-PRUEFPROTOKOLL.md

@@ -1,58 +0,0 @@
-# IMP-04 – Prüfprotokoll: Fehlerbehandlung nicht-konformer Server
-
-Voraussetzung IMP-01 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/imapimport/client_real.go` erweitert:
-  - `resolveUIDValidity`: eine gemeldete `UIDVALIDITY=0` (bekannte
-    Abweichung nicht-konformer Server, known-issues-archivmail.md #5)
-    oder eine ganz fehlende UIDVALIDITY-Angabe löst KEINEN Abbruch mehr
-    aus, sondern einen definierten Fallback (Akzeptanzkriterium 1):
-    `fallbackUIDValidity` leitet deterministisch (FNV-1a, gleiche Technik
-    wie `search.DocumentID`) einen von 0 verschiedenen Ersatzwert aus dem
-    Postfachnamen ab — bei wiederholten Läufen gegen denselben
-    nicht-konformen Server bleibt der Fallback STABIL, kein unnötiger
-    Voll-Resync bei jedem einzelnen Lauf.
-  - `parseFetchLines`/`parseSingleFetchLine`: eine einzelne unerwartete
-    oder kaputte `FETCH`-Zeile wird protokolliert und übersprungen, alle
-    übrigen, korrekt lesbaren Nachrichten werden trotzdem geliefert
-    (Akzeptanzkriterium 2) — der gesamte Lauf bricht dafür nicht ab.
-  - `Logger`/`RealClient.WithLogger`: jede erkannte Abweichung läuft über
-    ein protokollierbares, austauschbares Logging-Ziel mit festem,
-    durchsuchbarem Präfix (Akzeptanzkriterium 3: für Support
-    nachvollziehbar) — Standard ist `log.Printf`.
-- Dabei einen echten, durch die neue Logging-Logik selbst eingeführten
-  Bug gefunden und behoben: die getaggte Kommando-Abschlusszeile (z. B.
-  `"C3 OK UID FETCH completed"`) enthält ebenfalls die Zeichenfolge
-  `"FETCH "` und wurde beim ersten Anlauf fälschlich als "unerwartete
-  Serverantwort" geloggt — behoben, indem nur echte Untagged-Zeilen
-  (Präfix `"* "`) überhaupt als FETCH-Zeile in Betracht gezogen werden.
-- Kein Umbau: `mail/internal/imap` (ING-01)/`folderstate` (ING-05)/
-  `imapimport/scheduler.go` (IMP-01) unverändert — IMP-04 erweitert
-  ausschließlich `client_real.go`.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test simuliert Server mit UIDVALIDITY=0 und bestätigt greifenden Fallback | **bestanden** – `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort`: hand-gesteuerter Fake-Server meldet real `UIDVALIDITY=0`, `Sync` schlägt real NICHT fehl, liefert real einen von 0 verschiedenen, deterministischen Fallback-Wert und alle 3 Nachrichten, Fallback-Hinweis real protokolliert |
-| 2 | Test mit unerwarteter/kaputter Serverantwort bestätigt Weiterlauf für übrige Nachrichten | **bestanden** – `TestParseFetchLines_UnexpectedResponseSkippedRestContinue`: 2 bewusst kaputte Zeilen zwischen 2 korrekten real gesendet — `Sync` liefert real trotzdem beide korrekt lesbaren Nachrichten, beide kaputten Zeilen real protokolliert und übersprungen, kein Abbruch |
-| 3 | Regressionstest verhindert Wiederauftreten des UIDVALIDITY-Bugs | **bestanden** – `TestResolveUIDValidity_RegressionGuardAgainstZeroAbort`: direkter, vom Netzwerkpfad unabhängiger Test von `resolveUIDValidity` mit `UIDVALIDITY=0` UND mit gänzlich fehlender Angabe — beide liefern real keinen Fehler und einen Fallback-Wert != 0 |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/imapimport/... -v -timeout 60s  -> 7/7 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 15 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt IMP-08 (gemeinsam mit QA-02, bleibt weiterhin
-blockiert bis dessen übrige Abhängigkeiten fertig sind).

mail/docs/IMP-05-PRUEFPROTOKOLL.md

@@ -1,57 +0,0 @@
-# IMP-05 – Prüfprotokoll: Hot-Folder/Scanner-Anbindung
-
-Voraussetzung IMP-01 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/hotfolder/store.go` — `Store` (Postgres,
-  `mail_hotfolder_processed`, gleiches Muster wie `dedup`/`folderstate`):
-  verzeichnet bereits importierte Dateien je Mandant/Postfach über den
-  SHA-256-Inhalts-Hash — Grundlage für Akzeptanzkriterium 2 (identischer
-  Inhalt wird nicht doppelt importiert, auch unter neuem Dateinamen).
-- `mail/internal/hotfolder/watcher.go` — `Watcher`:
-  - `ScanOnce`: verarbeitet alle Dateien im Eingangsordner, ordnet sie
-    strukturell dem beim Konfigurieren festgelegten Mandanten/Postfach zu
-    (Akzeptanzkriterium 1 — ein Watcher je Mandant/Postfach-Paar).
-  - Bereits verarbeiteter Inhalt wandert unauffällig in den
-    Verarbeitet-Ordner, ohne den `Handler` erneut aufzurufen.
-  - Ein Verarbeitungsfehler (defekte Datei) verschiebt NUR diese eine
-    Datei in den Fehlerordner, der Scan läuft mit den übrigen Dateien
-    weiter (Akzeptanzkriterium 3).
-  - `Watch`: echte `fsnotify`-Anbindung (Technische Grundlage laut
-    Ticket) — initialer `ScanOnce` beim Start, danach Live-Ereignisse.
-- Kein Umbau: kein bestehendes Paket angefasst — IMP-05 ist vollständig
-  neu und eigenständig. `github.com/fsnotify/fsnotify` als neue,
-  minimale externe Abhängigkeit ergänzt (`go get` auf 192.168.1.131,
-  `go.mod`/`go.sum` aktualisiert).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: gleiche Datei zweimal abgelegt wird nur einmal importiert | **bestanden** – `TestScanOnce_SameFileDroppedTwiceImportedOnce`: identischer Inhalt unter zwei verschiedenen Dateinamen abgelegt, zweiter Scan meldet real 0 Importe/1 Duplikat, Handler real nur 1x aufgerufen |
-| 2 | Test: fehlerhafte Datei landet nachvollziehbar im Fehlerordner | **bestanden** – `TestScanOnce_CorruptFileMovedToErrorFolderTraceably`: defekte Datei real im Fehlerordner, real aus dem Eingang entfernt, die GUTE Nachbardatei wurde real trotzdem verarbeitet |
-| 3 | Dauertest über mehrere Scan-Zyklen ohne Ressourcenleck | **bestanden** – `TestScanOnce_ManyCyclesWithoutResourceLeak`: 50 reale Scan-Zyklen, Goroutine-Anzahl real stabil (Toleranz eingehalten), Verarbeitet-Ordner real konsistent |
-
-Zusätzlich (benannte Technik `fsnotify` real geprüft):
-`TestWatch_RealFsnotifyEventTriggersImport` — eine neu abgelegte Datei
-wird real über ein echtes Dateisystem-Ereignis erkannt und importiert,
-ohne manuellen `ScanOnce`-Aufruf.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/hotfolder/... -v -timeout 60s  -> 4/4 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 20 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt zu QA-02 bei — QA-02 bleibt weiterhin blockiert, bis
-dessen übrige Abhängigkeiten (ING-07, ING-08, ING-10, IMP-06, IMP-07)
-fertig sind.

mail/docs/IMP-06-PRUEFPROTOKOLL.md

@@ -1,62 +0,0 @@
-# IMP-06 – Prüfprotokoll: Anhangs-Virenscan-Anbindung
-
-Voraussetzung IMP-02 (Fertig).
-
-## Architektur-Hinweis
-
-Kein ClamAV-Daemon wurde für diese Kachel auf dem Testhost
-(192.168.1.131) installiert — ein Antivirus-Daemon samt
-Signaturdatenbank ist ein deutlich größerer, sicherheits- und
-ressourcenrelevanter Systemeingriff als ein einzelnes Go-Modul und wird
-nicht unaufgefordert vorgenommen (`clamdscan`/`clamd`/`clamav-daemon`
-real geprüft, nichts davon vorhanden). Stattdessen implementiert
-`ClamdScanner` das reale, dokumentierte clamd-INSTREAM-Protokoll
-(TCP, 4-Byte-Big-Endian-Längenpräfixe je Chunk) vollständig echt; für
-Tests spricht ein protokolltreuer Fake-Server (`fakeClamd`) exakt
-dasselbe Protokoll und erkennt die offizielle EICAR-Testsignatur
-identisch zu einem echten Virenscanner. Die Netzwerk-/Protokollschicht
-ist damit vollständig real getestet, nur die Gegenstelle ist ein
-Test-Double statt eines echten ClamAV-Daemons — gleiches Prinzip wie
-IMP-08s `HTTPNotificationDispatcher`-Tests.
-
-## Umsetzung
-
-- `mail/internal/virusscan/scanner.go` — `ClamdScanner.Scan`: reales
-  INSTREAM-Protokoll, `WithTimeout` begrenzt die Scan-Dauer
-  (Akzeptanzkriterium 3). `ErrScannerUnavailable` bei
-  Verbindungsfehler/Zeitüberschreitung.
-- `mail/internal/virusscan/processor.go` — `Processor.ScanAndDecide`:
-  jeder Anhang wird vor Archivierung gescannt (Akzeptanzkriterium 1);
-  `DecisionQuarantine` bei Fund (mit real persistiertem
-  `QuarantineStore`-Eintrag, Akzeptanzkriterium 2); `DecisionError` bei
-  Scanner-Ausfall statt automatischer Archivierung ODER unbegrenzter
-  Blockade (Akzeptanzkriterium 3).
-- `mail/internal/virusscan/fake_clamd_test.go` — protokolltreuer
-  Test-Server (nur Testcode, kein Produktcode).
-- Kein Umbau: kein bestehendes Paket angefasst — IMP-06 ist vollständig
-  neu und eigenständig.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test mit EICAR-Testdatei bestätigt Quarantäne-Verhalten | **bestanden** – `TestScanAndDecide_EICARTriggersQuarantine`: offizielle EICAR-Testsignatur real über das echte INSTREAM-Protokoll gesendet, `DecisionQuarantine` real geliefert, Fall real in `mail_quarantine` verzeichnet; ein harmloser Anhang liefert zum Vergleich real `DecisionArchive` |
-| 2 | Test: Scanner nicht erreichbar führt zu klar sichtbarem Fehlerzustand statt Hänger | **bestanden** – `TestScan_ScannerUnreachableFailsFastNotHang`: realer, sofort wieder geschlossener Port — Fehler real nach 895,62µs (weit unter der 2s-Frist), `ErrScannerUnavailable` real geliefert; `TestScanAndDecide_ScannerUnavailableYieldsDefinedErrorState` bestätigt zusätzlich real `DecisionError` statt automatischer Archivierung |
-| 3 | Durchsatztest bestätigt akzeptable Verzögerung durch Scan-Schritt | **bestanden** – `TestScan_ThroughputWithManyAttachmentsIsAcceptable`: 50 reale Scans in 12,87ms gesamt (257,44µs/Anhang, Ziel 100ms/Anhang) |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/virusscan/... -v -timeout 60s  -> 4/4 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 21 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt zu QA-02 bei — QA-02 bleibt weiterhin blockiert, bis
-dessen übrige Abhängigkeiten (ING-07, ING-08, ING-10, IMP-07) fertig sind.

mail/docs/IMP-07-PRUEFPROTOKOLL.md

@@ -1,48 +0,0 @@
-# IMP-07 – Prüfprotokoll: Mehrfach-Postfach-Verwaltung pro Tenant
-
-Voraussetzung IMP-01 (Fertig), Core TEN-01/TEN-02 (Fertig,
-Tenant-Datenmodell & Onboarding).
-
-## Umsetzung
-
-- `mail/internal/mailboxconfig/store.go` — `Store` (Postgres,
-  `mail_mailboxes`): `Create` legt beliebig viele, voneinander
-  unabhängige Postfächer je Mandant an (Akzeptanzkriterium 1). Jedes
-  Postfach hat eigene Abrufparameter — Intervall, IMAP-Host/Port/
-  Benutzername, Ordnerauswahl (Akzeptanzkriterium 2).
-- Passwort wird NIE im Klartext gespeichert — Wiederverwendung von
-  `mail/internal/crypto` (ARC-02, unverändert): `Create` verschlüsselt
-  über `crypto.Service.Seal`, `GetDecryptedPassword` entschlüsselt bei
-  Bedarf über `crypto.Service.Open`, als separater, bewusster Aufruf
-  (nicht Bestandteil von `List`, damit Zugangsdaten nicht beiläufig
-  mitgeliefert werden).
-- `List` filtert strikt nach `tenant_slug` (Akzeptanzkriterium 3).
-  `Update`/`Delete` sind streng auf `tenant_slug` + `id` beschränkt.
-- Kein Umbau: `mail/internal/crypto` unverändert wiederverwendet, kein
-  anderes Paket angefasst.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: zwei Mandanten mit je mehreren Postfächern sehen ausschließlich eigene Postfächer | **bestanden** – `TestList_TwoTenantsWithMultipleMailboxesSeeOnlyOwn`: Mandant A mit 2, Mandant B mit 1 Postfach — jeweils real nur die eigenen sichtbar |
-| 2 | Test: Löschen eines Postfachs beeinträchtigt andere Postfächer desselben Mandanten nicht | **bestanden** – `TestDelete_DoesNotAffectSiblingMailboxes`: Postfach „eins" real gelöscht, Postfach „zwei" bleibt real vollständig funktionsfähig (Zugangsdaten weiterhin real entschlüsselbar) |
-| 3 | Konfigurationsänderung an einem Postfach wirkt nicht auf andere | **bestanden** – `TestUpdate_ConfigChangeDoesNotAffectOtherMailboxes`: Änderung an Postfach „eins" (Host/Intervall) real übernommen, Postfach „zwei" real unverändert |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/mailboxconfig/... -v -timeout 60s  -> 3/3 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 22 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt ARC-09, trägt zu QA-02 bei — QA-02 bleibt
-weiterhin blockiert, bis dessen übrige Abhängigkeiten (ING-07, ING-08,
-ING-10) fertig sind.

mail/docs/IMP-08-PRUEFPROTOKOLL.md

@@ -1,73 +0,0 @@
-# IMP-08 – Prüfprotokoll: Fehler-Benachrichtigung bei Postfach-Sync-Ausfall
-
-Voraussetzung IMP-01, IMP-04 (beide Fertig), Core CFG-02 (Fertig,
-Benachrichtigungs-Dispatcher).
-
-## Architektur-Hinweis
-
-Core CFG-02 (`internal/notify.Dispatcher.Enqueue`) ist bislang nur als
-Go-interne Schnittstelle im Core-Modul realisiert — kein dokumentiertes
-HTTP-Interface für modulübergreifende Aufrufe war im Rahmen dieser
-Kachel auffindbar (kein `cmd/notify-api`-Quelltext im Repo, ein
-gleichnamiger, laufender Systemdienst auf 192.168.1.131 existiert zwar,
-sein Vertrag war ohne Quelltext nicht zuverlässig ermittelbar). Statt
-gegen einen unbekannten, möglicherweise falschen Vertrag zu raten,
-implementiert `HTTPNotificationDispatcher` einen selbst dokumentierten,
-in sich konsistenten HTTP-Vertrag (JSON `{channel, recipient, payload}`,
-Service-Credential-Header wie `mail/internal/crypto.HTTPKEKProvider`) und
-wird gegen einen echten, im Test aufgebauten HTTP-Server geprüft (gleiche
-Konvention wie `mail/internal/imapimport`s `RealClient`-Tests gegen einen
-hand-gesteuerten Server). Ein reales Core-`notify-api` mit exakt diesem
-Vertrag zu verdrahten ist Sache eines eigenen, Core-seitigen Tickets,
-nicht Bestandteil von IMP-08.
-
-## Umsetzung
-
-- `mail/internal/syncalert/dispatcher.go` — `NotificationDispatcher`
-  (schmale Schnittstelle zu CFG-02) + `HTTPNotificationDispatcher` (echte
-  HTTP-Anbindung, Service-Credential-Header).
-- `mail/internal/syncalert/monitor.go` — `Monitor` (Postgres,
-  `mail_sync_alert_state`, gleiches Muster wie `dedup`/`folderstate`):
-  - `RecordFailure`: erhöht `consecutive_failures`; löst GENAU EINMAL
-    eine Benachrichtigung aus, wenn die Schwelle erstmalig erreicht wird
-    (Akzeptanzkriterium 1) — danach markiert `alerted=true`, weitere
-    Fehlschläge lösen nichts mehr aus, solange nicht zurückgesetzt.
-  - Payload enthält `mailbox`, `reason`, `last_successful_sync`
-    (Akzeptanzkriterium 2).
-  - `RecordSuccess`: setzt `consecutive_failures=0`, `alerted=false`
-    (Akzeptanzkriterium 3).
-- Kein Umbau: `mail/internal/imapimport` (IMP-01/IMP-04) unverändert —
-  `syncalert` ist eigenständig, ein künftiger Aufrufer (Scheduler-
-  Integration) verdrahtet `RecordFailure`/`RecordSuccess` um
-  `Scheduler.RunOnce`, nicht Bestandteil dieser Kachel.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: N aufeinanderfolgende Fehlschläge lösen genau eine Benachrichtigung aus, keine Spam-Flut | **bestanden** – `TestRecordFailure_NConsecutiveFailuresTriggerExactlyOneNotification`: Schwelle 3, erste 2 Fehlschläge real 0 Benachrichtigungen, dritter real genau 1, 5 weitere Fehlschläge danach real weiterhin genau 1 |
-| 2 | Test: erfolgreicher Lauf nach Ausfall beendet den Alarmzustand nachvollziehbar | **bestanden** – `TestRecordSuccess_EndsAlertStateVerifiably`: nach Reset beginnt der Zähler real wieder bei 0 — 2 weitere Fehlschläge lösen real noch nichts aus, erst der erneute Schwellenwert real eine zweite Benachrichtigung |
-| 3 | Test mit mehreren betroffenen Postfächern gleichzeitig bleibt übersichtlich | **bestanden** – `TestRecordFailure_MultipleAffectedMailboxesStayIsolated`: 3 Postfächer real parallel ausgefallen, real genau 3 Benachrichtigungen (eine je Postfach), keine Vermischung |
-
-Zusätzlich (Akzeptanzkriterium 2, real geprüft): `TestRecordFailure_NotificationContainsRequiredFields`
-und `TestHTTPNotificationDispatcher_SendsCorrectRequestFormat` (echter
-HTTP-Wire-Test: Service-Credential-Header und JSON-Struktur real
-bestätigt).
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/syncalert/... -v -timeout 60s  -> 6/6 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 18 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt zu QA-02 bei (dependsOn: ING-10, IMP-09, IMP-04,
-IMP-05, IMP-06, IMP-07, IMP-08, ING-07, ING-08) — QA-02 bleibt weiterhin
-blockiert, bis dessen übrige Abhängigkeiten fertig sind.

mail/docs/IMP-09-PRUEFPROTOKOLL.md

@@ -1,61 +0,0 @@
-# IMP-09 – Prüfprotokoll: Import-Testsuite
-
-Voraussetzung IMP-01, IMP-02, IMP-03 (alle Fertig).
-
-## Umsetzung
-
-- `mail/internal/imapimport/tenant_scoping_test.go` +
-  `mail/internal/mailrules/tenant_scoping_test.go` — echte Lücke
-  geschlossen: vor IMP-09 bewies KEIN Test explizit, dass zwei Mandanten
-  mit identischem Postfachnamen (Scheduler) bzw. bei fehlender eigener
-  Regel (Regelwerk) sich nicht gegenseitig beeinflussen
-  (Akzeptanzkriterium 2).
-- `mail/internal/importtestgate/gate.go` — echtes, ausführbares Gate
-  (spiegelt `qagate`/QA-03): `RunTestSuites` führt `go test -cover` real
-  über die drei Importpfade aus und liefert einen Testabdeckungsbericht
-  je Paket (Akzeptanzkriterium 1). `ScanForExternalMailboxReferences`
-  prüft alle `*_test.go`-Dateien der Importpfade auf Referenzen zu
-  bekannten echten IMAP-Anbietern (Akzeptanzkriterium 3).
-- Echten Bug beim eigenen Testlauf gefunden und behoben: die
-  `t.Cleanup`-Löschfilter in `imapimport/scheduler_test.go` und
-  `mailrules/engine_test.go` waren TICKET-spezifisch (`mandant-imp01-%`
-  bzw. `mandant-imp03-%`) statt PAKET-spezifisch — die neuen
-  IMP-09-Tenant-Testdaten (`mandant-imp09-...`) wurden dadurch nie
-  aufgeräumt, ein zweiter Testlauf schlug real mit falschen Zählungen
-  fehl (Altdaten aus dem ersten Lauf). Behoben durch Verallgemeinerung
-  auf `mandant-%`.
-- Kein Umbau der geprüften Produktionslogik: `imapimport`/`attachments`/
-  `mailrules` bleiben in ihrem Kernverhalten unverändert, nur zusätzliche
-  Tests und ein verallgemeinerter Cleanup-Filter kamen hinzu.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Testabdeckungsbericht für Scheduler, Anhangsverarbeitung und Regeln liegt vor | **bestanden** – `TestRun_RealGateAgainstImportPackages`: realer `go test -cover`-Lauf liefert `imapimport: 81.5%`, `attachments: 94.4%`, `mailrules: 71.2%` |
-| 2 | CI-Lauf grün auf frischem Checkout | **bestanden** – realer `go test -count=1` (kein Cache) über alle drei Importpfade zweimal hintereinander ausgeführt, beide Male vollständig grün, reproduzierbar (nach Behebung des Cleanup-Bugs) |
-| 3 | Stichprobenreview bestätigt sinnvolle Testfälle für nicht-konforme Server-Szenarien | **bestanden** – `TestScanForExternalMailboxReferences_RealImportPackagesPass`: automatisierter Scan bestätigt real, keine Testdatei referenziert einen echten externen IMAP-Anbieter; die nicht-konformen Server-Szenarien selbst sind bereits in IMP-04 real durch `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort` und `TestParseFetchLines_UnexpectedResponseSkippedRestContinue` abgedeckt (Stichprobenreview: beide Testfälle prüfen inhaltlich sinnvolle, real beobachtbare Abweichungsszenarien, nicht nur triviale Formfehler) |
-
-Zusätzlich (Akzeptanzkriterium 2, real geprüft):
-`TestScheduler_TenantScopingIsolatesSyncState` und
-`TestStore_TenantScopingIsolatesRuleApplication`.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test -count=1 -cover ./internal/imapimport/... ./internal/attachments/... ./internal/mailrules/...
-  -> alle 3 Pakete bestanden (zweimal hintereinander ausgeführt, beide Male grün)
-TEST_TENANT_DSN=... go test ./internal/importtestgate/... -v -timeout 60s  -> 3/3 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 19 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt (gemeinsam mit IMP-04, IMP-05, IMP-06, IMP-07,
-IMP-08, ING-07, ING-08, ING-10) zu QA-02 bei — QA-02 bleibt weiterhin
-blockiert, bis dessen übrige Abhängigkeiten fertig sind.

mail/docs/ING-01-PRUEFPROTOKOLL.md

@@ -1,78 +0,0 @@
-# ING-01 – Prüfprotokoll: IMAP-Server-Grundgerüst
-
-Keine Vorbedingungen im Mail-Board (sofort startbar).
-
-## Umsetzung
-
-- `mail/internal/imap/state.go` — `State` (`NotAuthenticated`,
-  `Authenticated`, `Selected`, RFC 3501 §3).
-- `mail/internal/imap/parser.go` — `parseCommandLine`/`tokenize`: Tag +
-  Kommando + Argumente (Atome und doppelt zitierte Zeichenketten), keine
-  IMAP-Literalsyntax (`{n}CRLF...` — bewusst nicht Bestandteil der
-  kleinsten Lösung, LOGIN/SELECT/FETCH kommen ohne Literale aus).
-- `mail/internal/imap/response.go` — `sanitizeResponseText`: Bekannten
-  Fehler vermieden (archivmail: Header-/Zeilen-Injection durch
-  Stringkonkatenation ohne CRLF-Prüfung) — jede Antwortzeile entfernt
-  eingebettete CR/LF, bevor sie geschrieben wird, keine direkte
-  Interpolation von Nutzereingaben in eine Rohantwort.
-- `mail/internal/imap/session.go`/`commands.go` — Session-
-  Zustandsmaschine mit `CAPABILITY`/`LOGIN`/`SELECT`/`FETCH`/`LOGOUT`,
-  strikte Zustandsprüfung je Kommando (Akzeptanzkriterium 1), fehlerhafte
-  Zeilen/unbekannte Kommandos/verbotene Zustandsübergänge liefern eine
-  `BAD`/`NO`-Antwort statt eines Verbindungsabbruchs (Akzeptanzkriterium
-  3). `maxCommandLineBytes` begrenzt die Puffergröße defensiv (Vorbild
-  Dovecot: defensive Fehlerbehandlung statt optimistischem Parsing).
-- `mail/internal/imap/server.go` — `Server.Serve`: TCP-Accept-Schleife,
-  eine Goroutine je Verbindung.
-- `Authenticator`/`MailboxStore` sind schmale Schnittstellen — echte
-  Benutzerverwaltungs-/Postfach-Anbindung ist Sache von IMP-01 u. a.
-  („Nicht Bestandteil dieser Kachel"), dieses Paket kennt weder Core-IAM
-  noch `mail/internal/storage`.
-- Kein Umbau: alle bestehenden Pakete unverändert — ING-01 fügt
-  ausschließlich das neue `mail/internal/imap`-Paket hinzu.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Manuelle Session mit Standard-IMAP-Client durchgespielt und protokolliert | **bestanden** – echte Session mit Pythons Standardbibliothek `imaplib` gegen den real laufenden Server auf 192.168.1.131 (Port 14300): CAPABILITY→OK, LOGIN→OK, SELECT INBOX→OK (`2` Nachrichten), FETCH 1:2 (FLAGS)→OK mit realen Flags, SELECT eines nicht existierenden Postfachs→NO OHNE Verbindungsabbruch, danach CAPABILITY erneut→OK, LOGOUT→BYE. Vollständiges Protokoll siehe unten |
-| 2 | Automatisierter Test deckt alle drei Zustandsübergänge und deren verbotene Übergänge ab | **bestanden** – `TestSession_StateTransitionsAndForbiddenTransitions`: SELECT/FETCH in NotAuthenticated→BAD, LOGIN→Authenticated, erneutes LOGIN/FETCH in Authenticated→BAD, SELECT→Selected, FETCH in Selected→OK — alle real über echte TCP-Verbindung gegen den echten Server geprüft |
-| 3 | Lasttest mit 50 parallelen Sessions ohne Ressourcenleck | **bestanden** – `TestServer_50ParallelSessionsNoLeak`: 50 reale, gleichzeitige TCP-Verbindungen, je vollständiger LOGIN→SELECT→FETCH→LOGOUT-Durchlauf, 0 Fehler |
-
-### Manuelles Sitzungsprotokoll (Pflichtprüfung 1, real erzeugt)
-
-```
-CAPABILITY -> OK [b'IMAP4rev1']
-LOGIN -> OK [b'LOGIN completed']
-SELECT INBOX -> OK [b'2']
-FETCH 1:2 (FLAGS) -> OK [b'1 (FLAGS (\\Seen))', b'2 (FLAGS ())']
-SELECT NICHT_VORHANDEN (erwartet NO) -> NO [b'SELECT failed: no such mailbox']
-CAPABILITY nach Fehler (Verbindung noch offen) -> OK [b'IMAP4rev1']
-LOGOUT -> BYE [b'IMAP4rev1 Server logging out']
-```
-
-Testserver und Testskript wurden nach der Prüfung wieder entfernt
-(Wegwerf-`cmd/imap-manual-test`, nicht Teil des Produktcodes).
-
-Zusätzlich (AC2/AC3, ergänzend real geprüft):
-`TestCommands_AllBaseCommandsAnswered` (alle fünf Grundbefehle real
-beantwortet) und `TestSession_MalformedLineDoesNotDisconnect`
-(syntaktisch fehlerhafte Zeile → `* BAD`, Verbindung bleibt real
-funktionsfähig).
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./internal/imap/... -v -timeout 60s  -> 5/5 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 12 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt IMP-01, ING-02, ING-05, ING-06, ING-07, ING-08,
-ING-10, QA-07.

mail/docs/ING-02-PRUEFPROTOKOLL.md

@@ -1,90 +0,0 @@
-# ING-02 — POP3-Server: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Paket: `mail/internal/pop3`
-
-## Umsetzung
-
-Vollständiger POP3-Server (RFC 1939) von Grund auf implementiert:
-TCP-Listener, CRLF/Byte-Stuffing-sichere Response-Writer, Session-Zustandsmaschine
-(Authorization / Transaction / Update), Kommandos USER, PASS, STAT, LIST, RETR,
-DELE, QUIT. Architektonisch analog zum bestehenden `mail/internal/imap`-Paket
-(ING-01).
-
-## Pflichtprüfung 1: automatisierter Test für jede Zustandsübergangs-Regel
-
-`TestSession_StateTransitions` (`pop3_test.go`), realer TCP-Client gegen realen
-Server:
-
-- STAT/RETR in Authorization → `-ERR` (verboten)
-- PASS ohne vorheriges USER → `-ERR`
-- USER + PASS korrekt → Authorization → Transaction
-- USER erneut in Transaction → `-ERR` (verboten)
-- STAT in Transaction → `+OK` (erlaubt)
-- QUIT in Transaction → `+OK`, Verbindungsende
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 2: manuelle Session mit Standard-POP3-Client gegen Test-Postfach
-
-Realer Server (`pop3.NewServer`) auf `127.0.0.1:14400` gestartet (Wegwerf-Programm
-`mail/cmd/pop3-manual-test`, danach entfernt), Testpostfach mit 2 Nachrichten
-(fest codiert: `testuser`/`testpass`). Session mit Python-Standardbibliothek
-`poplib` (kein selbstgeschriebener Client) durchgeführt, reales Transkript:
-
-```
-Begruessung: b'+OK POP3 server ready'
-USER -> b'+OK send PASS'
-PASS -> b'+OK maildrop locked and ready'
-STAT -> (2, 45)
-LIST -> b'+OK 2 messages (45 octets)' [b'1 25', b'2 20'] 12
-RETR 1 -> b'+OK 26 octets' [b'Erste Testnachricht Inhalt'] 28
-DELE 1 -> b'+OK message 1 deleted'
-QUIT -> b'+OK goodbye'
-```
-
-Ergebnis: **BESTANDEN** — echter Standard-Client, keine Ausnahme, alle Antworten
-RFC-1939-konform.
-
-## Pflichtprüfung 3: DELE ohne QUIT löscht nichts endgültig
-
-`TestCommands_DeleWithoutQuitDeletesNothing` (`pop3_test.go`): DELE 1 gesendet,
-Verbindung danach OHNE QUIT hart geschlossen, 100ms gewartet, Store-Zustand
-geprüft — weiterhin 2 Nachrichten vorhanden (keine endgültige Löschung).
-
-Strukturell garantiert durch Code-Design: `store.Delete` wird ausschließlich in
-`handleQuit` im Zustand `Transaction → Update` aufgerufen; `handleDele` mutiert
-nur `s.deleted` (sitzungslokal).
-
-Ergebnis: **BESTANDEN**.
-
-## Akzeptanzkriterien
-
-1. **Jede Verbindung eigene Goroutine**: `Server.Serve` startet pro Accept eine
-   neue Goroutine (`server.go`). Zusätzlich belegt: `TestServer_ManyParallelSessions`,
-   20 parallele reale TCP-Sessions, alle erfolgreich.
-2. **RETR liefert vollständige Nachricht, DELE+QUIT löscht endgültig**:
-   `TestCommands_RetrDeleFullCycle` — RETR liefert mehrzeiligen Inhalt
-   vollständig und byte-identisch; nach DELE+QUIT sinkt die Nachrichtenzahl im
-   Store tatsächlich von 2 auf 1.
-3. **Fehlerhafte Anmeldeversuche ohne Informationspreisgabe**:
-   `TestPass_RejectsWithoutInformationLeak` — unbekannter Benutzername und
-   falsches Passwort liefern byte-identischen `-ERR`-Text
-   (`genericAuthFailure = "authentication failed"`).
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/pop3 (0.109s, 5/5 Tests)
-```
-
-Keine Regression in den bestehenden ~23 Paketen.
-
-## Ergebnis
-
-ING-02 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
-ausgeführten Nachweisen. Freigeschaltet: ING-06, ING-07, ING-08, ING-10, QA-07.

mail/docs/ING-03-PRUEFPROTOKOLL.md

@@ -1,116 +0,0 @@
-# ING-03 — SMTP-Server & Mailer: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Pakete: `mail/internal/smtp` (SMTP-Server, neu), `mail/internal/mailer` (Mailer-Komponente, neu)
-
-## Umsetzung
-
-**`mail/internal/smtp`** — SMTP-Server (RFC 5321) für eingehende Mails,
-von Grund auf implementiert, architektonisch analog zu
-`mail/internal/imap`/`pop3`: TCP-Listener mit einer Goroutine pro
-Verbindung, Session-Zustandsmaschine (Greeting → Ready → MailFromSet →
-RcptToSet), Kommandos HELO/EHLO, MAIL FROM, RCPT TO, DATA, RSET, NOOP,
-QUIT. Envelope-Aufbau ist strikt schrittweise: MAIL FROM ohne HELO,
-RCPT TO ohne MAIL FROM und DATA ohne mindestens ein gültiges RCPT TO
-werden jeweils mit `503` zurückgewiesen. Absender-/Empfängeradressen
-werden vor Annahme validiert (`503`/`553` bei ungültiger Syntax bzw.
-Steuerzeichen). Die Nachrichtengröße wird während des DATA-Empfangs
-laufend geprüft; eine Überschreitung führt zu `552` und verworfener
-Nachricht, ohne den Sink zu erreichen. Dot-(Byte-)Stuffing wird beim
-Empfang korrekt rückgängig gemacht (RFC 5321 §4.5.2).
-
-**`mail/internal/mailer`** — Mailer-Komponente für ausgehende
-Nachrichten. `headerWriter` (`header.go`) ist die EINZIGE Stelle, an der
-Header geschrieben werden: jeder Feldwert wird vor dem Schreiben hart
-gegen CR/LF/Steuerzeichen geprüft, `Message.Build()` nutzt
-ausschließlich diese API — keine freie Stringkonkatenation von
-From/To/Subject (behebt den bekannten archivmail-Fehler #1,
-Header-Injection durch ungeprüfte Konkatenation). `Sender.Send`
-überträgt die gebaute Nachricht per echtem `net/smtp`-Client
-(Standardbibliothek, reale TCP-Verbindung) über HELO/MAIL FROM/RCPT
-TO/DATA. Keine Zugangsdaten im Code — die Zieladresse wird als
-Parameter/Umgebungsvariable vom Aufrufer bereitgestellt.
-
-## Pflichtprüfung 1: Steuerzeichen/CRLF in Betreff und Anzeigenamen — kein Header-Bruch möglich
-
-`TestHeaderWriter_RejectsControlCharsAndCRLFInSubjectAndDisplayName`
-(`mailer/mailer_test.go`), vier Fälle: CRLF im Betreff (versuchte
-Bcc-Injection), CRLF im Anzeigenamen des Absenders, nackter LF ohne CR,
-Steuerzeichen NUL im Betreff — `Message.Build()` liefert in allen vier
-Fällen einen Fehler, KEINE gebaute Nachricht. Ergänzend
-`TestHeaderWriter_AcceptsCleanValues`: normale Werte (inkl. Umlaute)
-werden nicht fälschlich abgelehnt.
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 2: automatisierter Test sendet Testmail über Mailpit/MailHog, prüft Header-Integrität
-
-**Abweichung von der wörtlichen Ticketvorgabe, dokumentiert:** Mailpit
-und MailHog sind auf diesem Rechner NICHT installiert — Projektregel
-verbietet das Nachinstallieren zusätzlicher Toolchains/Dienste
-(kein Docker verfügbar, keine Systempaketinstallation). Als echter
-Ersatz — kein Mock, kein fabriziertes Transkript, dieselbe Konvention
-wie die manuellen Client-Tests aus ING-01/ING-02 — läuft
-`TestSender_SendRealMessageOverSMTP_HeaderIntegrity`
-(`mailer/mailer_test.go`) gegen den in dieser Kachel gebauten, echten
-`mail/internal/smtp`-Server: realer TCP-Listener, echter
-`net/smtp`-Standardbibliotheks-Client, reale HELO/MAIL FROM/RCPT
-TO/DATA-Sequenz über das Netzwerk. Geprüft wird:
-
-- Envelope (`From`/`To`) kommt beim Server unverändert an.
-- From-, To-, Subject- und ein zusätzlicher Header (`X-NEXARCH-Test`)
-  kommen byte-identisch als eigene Headerzeilen an.
-- Genau eine Leerzeile trennt Header von Body (`\r\n\r\n`), Body-Text
-  vollständig und unverändert.
-
-Ergebnis: **BESTANDEN** — Header-Integrität über einen echten
-Ende-zu-Ende-SMTP-Dialog bestätigt.
-
-## Pflichtprüfung 3: Lasttest mit gleichzeitigen Verbindungen ohne Verbindungsleck
-
-`TestServer_ConcurrentConnectionsNoLeak` (`smtp/smtp_test.go`): 50
-parallele reale TCP-Verbindungen, jede vollständige
-EHLO/MAIL/RCPT/DATA/QUIT-Sequenz. Alle 50 Nachrichten kommen beim Sink
-an. `runtime.NumGoroutine()` vor und nach dem Lasttest verglichen (mit
-Toleranz für Laufzeit-Jitter und Aufräumzeit).
-
-Ergebnis: **BESTANDEN** — Goroutinezahl kehrt auf den Ausgangswert
-zurück, kein Verbindungs-/Ressourcenleck.
-
-## Akzeptanzkriterien
-
-1. **SMTP-Annahme validiert Envelope und Nachrichtengröße vor der
-   Annahme**: `TestSession_EnvelopeMustBeBuiltBeforeData` (schrittweise
-   Envelope-Prüfung, `503` bei übersprungenen Schritten) und
-   `TestData_MessageSizeCheckedBeforeAcceptance` (Überschreitung der
-   konfigurierten Höchstgröße führt zu `552`, Sink bekommt die
-   Nachricht NICHT, Session danach weiter funktionsfähig).
-2. **Mailer erzeugt Header ausschließlich über strukturierte
-   Writer-API, keine freie Stringkonkatenation**: `header.go`
-   (`headerWriter.WriteField`) ist der einzige Ort, an dem
-   `Message.Build()` Header schreibt; durch Pflichtprüfung 1 belegt.
-3. **Ungültige Empfängerdaten führen zu sauberer SMTP-Fehlermeldung
-   statt Absturz**: `TestRcptTo_InvalidRecipientCleanError` und
-   `TestMailFrom_InvalidSenderCleanError` — `553` bei ungültiger
-   Adresse, Verbindung bleibt danach nutzbar.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuen internal/smtp und internal/mailer
-```
-
-Keine Regression in den bestehenden ~26 Paketen.
-
-## Ergebnis
-
-ING-03 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen. Pflichtprüfung 2 wurde mangels installierbarem
-Mailpit/MailHog gegen den eigenen, in dieser Kachel gebauten
-SMTP-Server durchgeführt (funktional gleichwertig: echter SMTP-Dialog,
-kein Mock) — siehe Abschnitt oben. Freigeschaltet: ING-06, ING-08,
-ING-09, ING-10, QA-04, QA-07.

mail/docs/ING-04-PRUEFPROTOKOLL.md

@@ -1,65 +0,0 @@
-# ING-04 – Prüfprotokoll: MIME- & Anhang-Parsing
-
-Keine Vorbedingungen (Wave 1, sofort startbar). ING-04 ist die
-Voraussetzung für ARC-01 (Objekt-Speicher) — nicht nur eine
-Ergänzung, sondern der direkte Blocker (`ARC-01.dependsOn = ["ING-04"]`).
-
-## Bekannten Fehler vermieden
-
-archivmail (`known-issues-archivmail.md` Punkt 3): Anhänge wurden über
-`io.ReadAll` ohne Größenlimit gelesen — Speicherbombe durch große/
-böswillige Anhänge. Hier läuft JEDER Anhang-Lesevorgang über
-`io.LimitReader(r, maxSize+1)` — eine Überschreitung führt zu
-`ErrAttachmentTooLarge`, nicht zu stillem Abschneiden oder
-unbegrenztem Speicherwachstum.
-
-## Umsetzung
-
-- `mail/internal/mimeparse.Parse` — zerlegt eine MIME-Nachricht
-  vollständig, rekursiv über verschachtelte `multipart/*`-Container.
-- Zeichensatz-Reparatur: `mime.WordDecoder` mit eigenem
-  `CharsetReader` (via `golang.org/x/text/encoding/htmlindex`) — ein
-  unbekannter/kaputter Zeichensatz reicht den Rohtext unverändert
-  durch statt abzubrechen.
-- Content-Transfer-Encoding: `quoted-printable`/`base64` werden
-  dekodiert, unbekannte Encodings unverändert durchgereicht (defensiv).
-- **Nur Parsing, keine Speicherung** — Objekt-Speicher ist explizit
-  ARC-01s Aufgabe (Ticket-"Nicht Bestandteil"), dieses Paket schreibt
-  nirgends in einen Objektspeicher.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test mit sehr großem simuliertem Anhang bestätigt harte Ablehnung statt Speicheranstieg | **bestanden** – `TestParse_OversizedAttachmentRejectedNotMemoryExhausted`: ein UNBEGRENZTER `io.Reader` (liefert endlos Bytes) als Anhang-Body — `Parse` bricht real mit `ErrAttachmentTooLarge` ab, statt (wie ein `io.ReadAll`-basierter Parser) den Prozess durch unbegrenztes Speicherwachstum zum Absturz zu bringen. Test läuft in Millisekunden durch, kein Speicheranstieg |
-| 2 | Testkorpus mit realitätsnahen Multipart-/Encoding-Varianten läuft fehlerfrei durch | **bestanden** – `TestParse_RealisticCorpusRunsCleanly`: 4 realitätsnahe Varianten (einfacher Text, quoted-printable, multipart/alternative, leere Multipart-Hülle mit Präambel/Epilog) laufen alle fehlerfrei durch |
-| 3 | Fuzz-/Grenzwerttest mit kaputten MIME-Strukturen bricht kontrolliert ab, kein Absturz | **bestanden** – `FuzzParse`: ECHTES Go-Fuzzing (`go test -fuzz=FuzzParse -fuzztime=45s`), **728.164 reale Testläufe** mit mutierten/kaputten Byte-Sequenzen, 146 "interessante" (coverage-erweiternde) Eingaben gefunden, KEIN einziger Absturz (jeder `panic` hätte den Test sofort fehlschlagen lassen) |
-
-**Zusätzliche Tests (je Akzeptanzkriterium mindestens ein Test):**
-- `TestParse_NestedMultipartFullyDecomposed` (AC1: verschachtelte
-  Multipart-Teile vollständig zerlegt — `multipart/mixed` enthält
-  `multipart/alternative` UND einen Anhang, alle 3 Blatt-Teile
-  gefunden).
-- `TestParse_AttachmentMetadataExtracted` (AC2: Dateiname,
-  Content-Type, Größe korrekt extrahiert).
-- `TestParse_BrokenCharsetIsRepairedNotAborted`,
-  `TestParse_ISO88591FilenameDecoded` (AC3: kaputter/unbekannter
-  Zeichensatz repariert statt Abbruch; RFC-2047-kodierter,
-  ISO-8859-1-Dateiname real korrekt zu "Rechnung Ü" dekodiert).
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1  -> alle Mail-Pakete bestanden (inkl. mimeparse, example, pflichttestgate)
-go test ./internal/mimeparse/... -fuzz=FuzzParse -fuzztime=45s -> PASS, 728.164 Ausführungen, 0 Abstürze
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
-Pflichtprüfungen real erfüllt, inklusive eines echten, nicht nur
-simulierten Fuzz-Laufs mit über 700.000 Testfällen. Entsperrt ARC-01
-(Objekt-Speicher-Anbindung), IMP-02, ING-10, ARC-10.

mail/docs/ING-05-PRUEFPROTOKOLL.md

@@ -1,57 +0,0 @@
-# ING-05 – Prüfprotokoll: Folder-State & UIDVALIDITY-Handling
-
-Voraussetzung ING-01 (Fertig). ING-05 ist die direkte Vorbedingung für
-IMP-01 (gemeinsam mit ING-01, bereits Fertig) — ohne ING-05 bleibt IMP-01
-weiterhin blockiert.
-
-## Umsetzung
-
-- `mail/internal/folderstate/store.go` — `Store` (Postgres,
-  `mail_folder_state` + `mail_folder_state_events`, gleiches Muster wie
-  `dedup`/`indexworker`/`savedsearch`):
-  - `GetOrCreate`/`CurrentState`: konsistente Sicht bei parallelem Zugriff
-    (Akzeptanzkriterium 2) — `INSERT ... ON CONFLICT DO NOTHING` +
-    Rücklese, kein Lese-dann-Schreib-Fenster.
-  - `NextUID`: vergibt UIDs atomar über `UPDATE ... RETURNING` unter
-    Postgres-Zeilensperre (Akzeptanzkriterium 1/3), protokolliert jede
-    Vergabe als Ereignis in derselben Transaktion.
-  - `Rebuild`: simulierter Ordner-Neuaufbau — `GREATEST(uidvalidity + 1,
-    jetzt_in_ns)` garantiert eine STRENG neue UIDVALIDITY, auch wenn zwei
-    Neuaufbauten innerhalb derselben Nanosekunde laufen; UIDNEXT wird auf
-    1 zurückgesetzt.
-  - `RecordDeletion`/`Events`: Löschungen ändern UIDNEXT nicht (RFC 3501:
-    UIDs werden nie wiederverwendet), alle Zustandsänderungen bleiben
-    nachvollziehbar (Akzeptanzkriterium 3).
-- Bekannten Fehler vermieden (archivmail: UIDVALIDITY=0 bricht Resync bei
-  nicht-konformen Servern): `newUIDValidity` erzeugt den Wert selbst
-  (Unix-Nanosekunden, garantiert > 0), statt einen extern gelieferten
-  Wert unbesehen zu übernehmen.
-- Kein Umbau: `mail/internal/imap` (ING-01) unverändert — `folderstate`
-  ist ein eigenständiges Paket, das ING-01 künftig (IMP-01) als
-  `MailboxStore`-Implementierung nutzen kann, ohne dass ING-01 selbst
-  angefasst werden musste.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Automatisierter Test für UIDVALIDITY-Änderung bei simuliertem Ordner-Neuaufbau | **bestanden** – `TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild`: Ordner angelegt, UID vergeben, `Rebuild` aufgerufen — UIDVALIDITY real geändert, UIDNEXT real auf 1 zurückgesetzt, `rebuilt`-Ereignis real protokolliert |
-| 2 | Nebenläufigkeitstest: zwei Sessions auf demselben Ordner ohne Inkonsistenz | **bestanden** – `TestNextUID_ConcurrentSessionsOnSameFolderNoInconsistency`: 20 reale gleichzeitige `NextUID`-Aufrufe auf demselben Ordner, alle 20 UIDs real eindeutig, keine Dopplung |
-| 3 | Test für UIDNEXT-Monotonie über viele Einfüge-/Löschzyklen | **bestanden** – `TestNextUID_MonotonicAcrossManyInsertDeleteCycles`: 200 Zyklen, jede zweite Nachricht real "gelöscht" — UIDNEXT bleibt real strikt monoton steigend, Löschungen beeinflussen die Vergabe nicht |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... go test ./internal/folderstate/... -v  -> 3/3 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 13 Pakete bestanden, keine Regression
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt IMP-01 (gemeinsam mit ING-01, bereits Fertig) und
-ING-10.

mail/docs/ING-06-PRUEFPROTOKOLL.md

@@ -1,165 +0,0 @@
-# ING-06 — TLS/STARTTLS-Absicherung: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Pakete: `mail/internal/tlscert` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
-
-## Umsetzung
-
-Neues Paket `tlscert` kapselt die für alle drei Protokollserver
-gemeinsame TLS-Grundlage:
-
-- `Store` hält das aktuell aktive Zertifikat hinter `GetCertificate`
-  (wird von `crypto/tls` bei JEDEM neuen Handshake aufgerufen).
-  `Replace`/`ReplaceFromFiles` tauschen es atomar aus — bereits
-  etablierte Verbindungen behalten ihr beim Handshake ausgehandeltes
-  Zertifikat, nur NEUE Handshakes bekommen das neue (Akzeptanzkriterium
-  3).
-- `Store.Config()` liefert eine gehärtete `tls.Config`: `MinVersion:
-  tls.VersionTLS12`, für TLS 1.2 ausschließlich AEAD-Cipher-Suiten
-  (kein CBC, kein RC4, kein 3DES) — TLS 1.3 hat ohnehin nur starke,
-  feste Suiten (Akzeptanzkriterium 2).
-- `UpgradeServer` führt den STARTTLS-Serverhandschlag durch, gemeinsam
-  genutzt von allen drei Protokollen.
-
-**IMAP** (`STARTTLS`, RFC 3501 §6.2.1), **POP3** (`STLS`, RFC 2595 §4)
-und **SMTP** (`STARTTLS`, RFC 3207) bekommen je ein neues Kommando: nur
-vor der Anmeldung erlaubt, Reader/Writer werden nach dem Handschlag
-NEU aufgesetzt (verhindert, dass vor dem Handshake gepufferte
-Klartextdaten als Kommandos nach dem Wechsel verarbeitet werden —
-Command-Injection-Schutz). LOGIN (IMAP) und PASS (POP3) werden
-zurückgewiesen, solange der Server TLS anbietet, aber die Verbindung
-weder implizit (via `tls.Conn`) noch per STARTTLS/STLS verschlüsselt
-ist (Akzeptanzkriterium 1). SMTP hat in der aktuellen minimalen
-Implementierung (ING-03) kein Anmeldekommando (kein AUTH) — dort wird
-STARTTLS strukturell bereitgestellt und geprüft, die
-Anmeldedaten-Kernprüfung erfolgt für IMAP/POP3.
-
-Implizites TLS (z. B. Port 993/995/465) benötigt KEINE Codeänderung:
-`Server.Serve` nimmt jeden `net.Listener` entgegen, ein mit
-`tls.NewListener` gewrapptes Listener liefert bereits `*tls.Conn` aus
-`Accept()` — die Session erkennt das per Typ-Assertion und startet
-direkt mit `tlsActive = true`.
-
-Alle drei Server bleiben ohne TLS-Konfiguration (`tlsConfig == nil`)
-unverändert im bisherigen Klartextverhalten — Rückwärtskompatibilität
-zu ING-01/ING-02/ING-03, bestehende Tests unverändert grün.
-
-## Pflichtprüfung 1: Scan mit Standard-TLS-Prüfwerkzeug bestätigt keine schwachen Suiten
-
-Manuelle Prüfung mit `openssl s_client` (Standardwerkzeug, bereits auf
-dem Zielsystem vorhanden) gegen einen echten, laufenden
-`mail/internal/smtp`-Server mit aktivierter TLS-Konfiguration:
-
-```
-$ printf 'EHLO test\r\nQUIT\r\n' | openssl s_client -connect 127.0.0.1:14425 -starttls smtp -brief
-CONNECTION ESTABLISHED
-Protocol version: TLSv1.3
-Ciphersuite: TLS_AES_128_GCM_SHA256
-...
-250 STARTTLS
-DONE
-```
-
-→ Reguläre Verbindung: TLS 1.3, starke AEAD-Suite. Erzwungener Versuch
-mit ausschließlich schwachen TLS-1.2-CBC-Suiten:
-
-```
-$ openssl s_client -connect 127.0.0.1:14425 -starttls smtp -tls1_2 \
-    -cipher 'ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:AES128-SHA:AES256-SHA'
-...
-New, (NONE), Cipher is (NONE)
-Cipher    : 0000
-```
-
-→ Kein Cipher ausgehandelt = Handshake fehlgeschlagen, Server nimmt
-keine der angebotenen CBC-Suiten an.
-
-**Ergänzung/Abweichung dokumentiert:** Das auf diesem Host installierte
-`openssl 3.5.6` verweigert es, TLS 1.0/1.1 überhaupt CLIENTSEITIG
-anzufordern (`no protocols available`, auch mit `-provider legacy`) —
-das lässt sich mit dem verfügbaren Standardwerkzeug nicht mehr
-erzwingen. Als reproduzierbarer automatisierter Ersatz für den
-Versions-Anteil dieser Prüfung:
-`TestServer_RejectsLegacyTLSVersionAndWeakCiphers` (`smtp/tls_test.go`,
-echter TCP-Client über `crypto/tls`, `MaxVersion: tls.VersionTLS11`)
-gegen den echten Server — Handshake schlägt fehl. Zweiter Subtest
-erzwingt clientseitig ausschließlich `TLS_RSA_WITH_AES_128_CBC_SHA` —
-Handshake schlägt ebenfalls fehl. Zusätzlich
-`TestConfig_HardenedDefaults` (`tlscert/tlscert_test.go`) prüft die
-`tls.Config` direkt gegen eine Liste bekannter schwacher Suiten.
-
-Ergebnis: **BESTANDEN** (openssl-Scan + zwei automatisierte
-Negativtests + Config-Assertion).
-
-## Pflichtprüfung 2: Login-Versuch ohne TLS/STARTTLS wird verweigert
-
-- `TestPass_RequiresTLS` (`pop3/tls_test.go`): PASS ohne vorheriges
-  STLS liefert `-ERR`.
-- `TestLogin_RequiresTLS` (`imap/tls_test.go`): LOGIN ohne vorheriges
-  STARTTLS liefert `NO`.
-- Kehrseite jeweils mitgetestet: `TestStls_UpgradesConnectionAndAllowsLogin`
-  bzw. `TestStartTLS_UpgradesConnectionAndAllowsLogin` — nach echtem
-  STLS/STARTTLS-Handschlag (reale `crypto/tls`-Clientverbindung) wird
-  dieselbe Anmeldung akzeptiert.
-- SMTP: `TestStartTLS_UpgradesConnection` belegt den echten
-  STARTTLS-Handschlag strukturell (kein Anmeldekommando in der
-  aktuellen SMTP-Implementierung vorhanden, siehe Abschnitt
-  "Umsetzung").
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 3: Zertifikatsrotation im laufenden Betrieb ohne Dienstunterbrechung
-
-`TestTLS_CertificateRotationWithoutDroppingExistingSessions` in allen
-drei Protokollpaketen (`pop3`, `imap`, `smtp`): echter Ablauf —
-
-1. Erste TLS-Verbindung (echter Handschlag) aufbauen, bestätigen, dass
-   sie Zertifikat A bekommt, Verbindung OFFEN halten.
-2. `store.Replace(certB)` — Rotation im laufenden Betrieb.
-3. Zweite, NEUE Verbindung aufbauen — bekommt nachweislich Zertifikat
-   B (`PeerCertificates[0].Raw` verglichen).
-4. Erste, bereits etablierte Verbindung wird DANACH weiterbenutzt
-   (POP3: USER/PASS, IMAP: LOGIN, SMTP: NOOP) — funktioniert
-   unterbrechungsfrei weiter.
-
-Zusätzlich `TestStore_ReplaceAffectsOnlyNewHandshakes`
-(`tlscert/tlscert_test.go`) auf Store-Ebene.
-
-Ergebnis: **BESTANDEN** — in allen drei Protokollen: kein
-Verbindungsabriss für die bestehende Session, neue Verbindungen
-bekommen sofort das neue Zertifikat.
-
-## Akzeptanzkriterien
-
-1. **Anmeldedaten werden ausschließlich über TLS oder nach
-   erfolgreichem STARTTLS akzeptiert**: durch Pflichtprüfung 2 belegt
-   (IMAP LOGIN, POP3 PASS).
-2. **Schwache Cipher-Suiten und veraltete TLS-Versionen sind
-   serverseitig deaktiviert**: durch Pflichtprüfung 1 belegt
-   (`tlscert.Store.Config()`: `MinVersion: TLS12`, ausschließlich
-   AEAD-Suiten für TLS 1.2).
-3. **Zertifikatswechsel ist ohne Verbindungsabriss für bestehende
-   Sessions möglich**: durch Pflichtprüfung 3 belegt.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/tlscert
-```
-
-Keine Regression in den bestehenden ~27 Paketen. Manueller
-TLS-Testserver (`cmd/tls-manual-test`) und dessen Hintergrundprozess
-nach den openssl-Prüfungen entfernt/beendet, nicht im Repository
-verblieben.
-
-## Ergebnis
-
-ING-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen. Pflichtprüfung 1 (Versions-Anteil) wurde mangels
-clientseitig erzwingbarem Legacy-TLS im installierten openssl 3.5.6
-zusätzlich durch einen echten automatisierten `crypto/tls`-Negativtest
-gegen den laufenden Server ergänzt — siehe Abschnitt oben. Freigeschaltet: QA-04.

mail/docs/ING-07-PRUEFPROTOKOLL.md

@@ -1,100 +0,0 @@
-# ING-07 — Protokoll-Fehlerbehandlung & Wiederverbindung: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Pakete: `mail/internal/protoguard` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`
-
-## Umsetzung
-
-Neues Paket `protoguard` kapselt Timeout- und Backoff-Logik EINER
-Verbindung (`Guard`), von IMAP- und POP3-Session gleichermaßen genutzt:
-
-- `ApplyReadDeadline(conn, phase)` setzt vor jedem Lesevorgang die
-  Lese-Deadline passend zur aktuellen Protokollphase (POP3:
-  Authorization/Transaction, IMAP: NotAuthenticated/Selected).
-- `RecordAuthFailure()` zählt Anmeldefehlversuche EINER Verbindung,
-  liefert eine sich verdoppelnde Backoff-Wartezeit (`BackoffBase` bis
-  `BackoffMax`) und meldet nach `MaxAuthFailures`, dass die Verbindung
-  zu trennen ist.
-
-`Server.NewServer` verwendet `protoguard.DefaultConfig()` (5 Minuten
-Timeout, max. 5 Fehlversuche, 200ms–5s Backoff); `NewServerWithGuardConfig`
-erlaubt abweichende Werte für Tests/gehärtete Umgebungen. Bestehende
-Aufrufer von `NewServer(auth, store)` sind unverändert kompatibel.
-
-Ressourcenaufräumung bei Verbindungsabbruch war bereits vor ING-07
-durch `defer conn.Close()` in beiden Sessions strukturell gegeben —
-ING-07 sorgt dafür, dass dieser Pfad auch bei hängenden oder böswilligen
-Gegenstellen zuverlässig erreicht wird (Timeout statt endlosem
-Blockieren).
-
-## Pflichtprüfung 1: Chaos-Test — harter Verbindungsabbruch während aktiver Übertragung, kein Ressourcenleck
-
-`TestGuard_ChaosHardCutDuringTransferNoLeak` (`pop3/guard_test.go`,
-`imap/guard_test.go`): 30 reale TCP-Verbindungen, jeweils angemeldet und
-mitten in einer laufenden Anfrage (POP3: RETR-Kopfzeile gelesen, Rest
-nicht konsumiert; IMAP: FETCH gesendet, Antwort nicht abgewartet) hart
-per `conn.Close()` gekappt. `runtime.NumGoroutine()` vor und nach den 30
-Abbrüchen verglichen (mit Toleranz für Laufzeit-Jitter und Wartezeit für
-Server-Aufräumung).
-
-Ergebnis: **BESTANDEN** — Goroutinezahl kehrt in beiden Paketen auf den
-Ausgangswert zurück, kein Leck.
-
-## Pflichtprüfung 2: Test für Timeout-Auslösung in jeder Protokollphase
-
-`TestGuard_TimeoutPerPhase` (beide Pakete), Guard mit 100ms Timeout je
-Phase konfiguriert:
-
-- POP3: Subtest `authorization` (Verbindung offen, nichts gesendet) und
-  `transaction` (nach erfolgreichem USER/PASS nichts weiter gesendet) —
-  beide erwarten Verbindungsende durch Timeout.
-- IMAP: Subtest `not_authenticated` und `selected` (nach LOGIN+SELECT)
-  — gleiche Erwartung.
-
-Ergebnis: **BESTANDEN** — alle vier Subtests bestätigen, dass der
-konfigurierte Timeout in der jeweiligen Phase tatsächlich greift.
-
-## Pflichtprüfung 3: Test für Backoff-Verhalten bei wiederholten Fehlversuchen
-
-`TestGuard_BackoffOnRepeatedAuthFailures` (beide Pakete), Guard mit
-`MaxAuthFailures=3`, `BackoffBase=50ms`, `BackoffMax=500ms`:
-
-- Drei aufeinanderfolgende fehlgeschlagene Anmeldeversuche (POP3:
-  USER+PASS falsch; IMAP: LOGIN falsch) über dieselbe Verbindung.
-  Gemessene Antwortzeit des zweiten Versuchs ist länger als die des
-  ersten (Verdopplung statt konstanter oder fehlender Wartezeit).
-- Nach dem dritten (= `MaxAuthFailures`-ten) Fehlversuch wird die
-  Verbindung serverseitig getrennt — ein weiterer Anmeldeversuch über
-  dieselbe Verbindung schlägt fehl statt in einer Dauerschleife erneut
-  beantwortet zu werden.
-
-Ergebnis: **BESTANDEN**.
-
-## Akzeptanzkriterien
-
-1. **Verbindungsabbrüche räumen serverseitige Session-Ressourcen
-   zuverlässig auf**: durch Pflichtprüfung 1 belegt (kein
-   Goroutine-Leck nach 30 harten Abbrüchen in beiden Protokollen).
-2. **Timeouts sind pro Protokollphase konfigurierbar und greifen
-   nachweislich**: durch Pflichtprüfung 2 belegt (`protoguard.Config.
-   PhaseTimeout` je Phase, vier bestandene Subtests).
-3. **Wiederholte Fehlversuche eines Clients führen zu klar definiertem
-   Backoff statt Dauerschleife**: durch Pflichtprüfung 3 belegt
-   (steigender Backoff, definierte Trennung nach `MaxAuthFailures`).
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/protoguard (indirekt über imap/pop3-Tests abgedeckt)
-```
-
-Keine Regression in den bestehenden ~24 Paketen.
-
-## Ergebnis
-
-ING-07 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
-ausgeführten Nachweisen. Freigeschaltet: QA-02.

mail/docs/ING-08-PRUEFPROTOKOLL.md

@@ -1,130 +0,0 @@
-# ING-08 — Mailserver-Protokoll-Logging & Diagnose: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Pakete: `mail/internal/protolog` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
-
-## Umsetzung
-
-Neues Paket `protolog` (`log/slog`, wie im Ticket vorgegeben) bündelt
-die für alle drei Protokollserver gemeinsame Logging-Grundlage:
-
-- `NewCorrelationID()` erzeugt eine zufällige, session-eindeutige ID.
-- `SessionLogger` loggt strukturierte Ereignisse EINER Verbindung, mit
-  `correlation_id` und `protocol` als festen Feldern auf jedem Eintrag
-  (Akzeptanzkriterium 1). Ein `SessionLogger` mit `logger == nil` ist
-  sicher benutzbar und loggt nichts — Server ohne konfigurierten Logger
-  verhalten sich unverändert wie vor ING-08 (Rückwärtskompatibilität zu
-  ING-01..ING-07).
-- `RedactCommandLine(verb, args)` liefert eine loggbare
-  Kommandodarstellung: bei sensiblen Verben (`PASS`, `LOGIN`, `AUTH`)
-  werden ALLE Argumente vollständig durch `[REDACTED]` ersetzt statt
-  einzeln geparst — verhindert, dass unerwartet platzierte
-  Zugangsdaten durchrutschen (Akzeptanzkriterium 2).
-- `Reconstruct(r, correlationID)` (`diagnose.go`) ist das geforderte
-  Diagnosewerkzeug: liest zeilenweise JSON-Logs und liefert, in
-  Log-Reihenfolge, ausschließlich die Einträge einer Korrelations-ID
-  (Akzeptanzkriterium 3).
-
-**Alle drei Sessions** (IMAP, POP3, SMTP) loggen jetzt:
-`session_start` (mit `remote_addr`) beim Verbindungsaufbau, EIN
-`command`-Ereignis pro empfangener Kommandozeile (Kommandoname +
-via `RedactCommandLine` redigierte Argumente) und `session_end` per
-`defer` — deckt die gesamte Verbindungsdauer ab (Akzeptanzkriterium 1).
-Reader/Writer-Aufsetzung nach STARTTLS/STLS bleibt unverändert (ING-06);
-der Logger wird unabhängig von TLS-Zustand weitergereicht.
-
-**Nachrichteninhalte werden strukturell nie geloggt**: POP3 `RETR`
-liefert Nachrichteninhalt nur in der SMTP-/POP3-Antwort, nicht als
-Log-Attribut; SMTP-`DATA`-Body-Zeilen werden von einer eigenen
-Leseschleife (`handleData`) konsumiert, die NICHT durch den
-Kommando-Logpfad der `Serve`-Hauptschleife läuft — nur das Kommando
-`DATA` selbst erscheint im Log, nie der Body (Akzeptanzkriterium 2).
-
-Neue Konstruktoren `NewServerWithGuardTLSAndLogger` (IMAP/POP3) und
-`NewServerWithMaxMessageBytesTLSAndLogger` (SMTP) — `logger` optional,
-bestehende Konstruktoren (`NewServer`, `NewServerWithGuardConfig`,
-`NewServerWithGuardAndTLSConfig` usw.) unverändert.
-
-## Pflichtprüfung 1: Redaktion sensibler Felder in allen Log-Pfaden
-
-Isoliert: `TestRedactCommandLine_HidesCredentials` und
-`TestSessionLogger_EventNeverContainsRawMessage`
-(`protolog/protolog_test.go`).
-
-Gegen den ECHTEN, laufenden Server (nicht nur die protolog-Bausteine):
-`TestProtolog_RedactsCredentialsInRealSessionLog` in `imap` (LOGIN mit
-Klartextpasswort) und `pop3` (USER/PASS) — vollständige reale Session
-über TCP, Logausgabe geprüft: kein Klartextpasswort, redigierter
-Eintrag vorhanden. `TestProtolog_NeverLogsMessageBodyOrRedactsCredentials`
-in `smtp`: reale Nachricht mit absichtlich eingebettetem
-`Passwort=geheim123` im Betreff/Body per DATA übertragen — weder das
-eingebettete Geheimnis noch der Nachrichtentext erscheinen im Log.
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen.
-
-## Pflichtprüfung 2: Stichprobe — eine komplette Session ist über die Korrelations-ID lückenlos rekonstruierbar
-
-`TestProtolog_SessionFullyReconstructableByCorrelationID` in allen drei
-Protokollpaketen: ZWEI vollständige, nacheinander über denselben Server
-laufende Sessions werden in denselben Logstream geschrieben (Logs
-mischen sich, wie im Betrieb). `protolog.Reconstruct` mit der
-Korrelations-ID der ersten Session liefert exakt deren Einträge, in
-korrekter Reihenfolge, beginnend mit `session_start` und endend mit
-`session_end`, jeder Zwischeneintrag mit passender `correlation_id` —
-keine Vermischung mit der zweiten Session. Zusätzlich
-`TestReconstruct_ReturnsOnlyMatchingSessionInOrder`
-(`protolog/protolog_test.go`) als isolierter Baustein-Test.
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen — Stichprobe
-tatsächlich gezogen und lückenlos rekonstruiert.
-
-## Pflichtprüfung 3: Lasttest bestätigt, dass Logging die Durchsatzrate nicht relevant beeinträchtigt
-
-`TestProtolog_LoggingDoesNotRelevantlyImpactThroughput` in allen drei
-Protokollpaketen: 100 vollständige reale Sessions ohne Logger
-(`logger == nil`, no-op) gegen 100 identische Sessions mit aktivem
-JSON-Logger gemessen, jeweils über echte TCP-Verbindungen gegen den
-laufenden Server. Ergebnis auf 192.168.1.131:
-
-```
-pop3: PASS (0.11s für 100 Sessions mit Logging, im Toleranzfaktor)
-imap: PASS (0.10s für 100 Sessions mit Logging, im Toleranzfaktor)
-smtp: PASS (0.11s für 100 Sessions mit Logging, im Toleranzfaktor)
-```
-
-Toleranzfaktor 3× + 5ms Grundrauschen, um Messschwankungen auf einem
-geteilten Testhost abzufangen — Ziel ist der Ausschluss eines groben
-Regressionsfaktors (z. B. unbuffered/synchrones I/O pro Byte), nicht
-eine exakte Performance-Zusicherung.
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen.
-
-## Akzeptanzkriterien
-
-1. **Jede Session erzeugt strukturierte Logs mit Korrelations-ID über
-   die gesamte Verbindungsdauer**: `session_start`/`command`
-   (mehrfach)/`session_end`, alle mit derselben `correlation_id` —
-   durch Pflichtprüfung 2 belegt.
-2. **Zugangsdaten und Nachrichteninhalte erscheinen nie im Klartext im
-   Log**: durch Pflichtprüfung 1 belegt.
-3. **Diagnosewerkzeug kann eine einzelne Session anhand der
-   Korrelations-ID vollständig nachvollziehen**: `protolog.Reconstruct`,
-   durch Pflichtprüfung 2 belegt.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/protolog
-```
-
-Keine Regression in den bestehenden ~29 Paketen.
-
-## Ergebnis
-
-ING-08 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen — in allen drei Protokollen (IMAP, POP3, SMTP) einzeln
-geprüft. Freigeschaltet: QA-02.

mail/docs/ING-09-PRUEFPROTOKOLL.md

@@ -1,99 +0,0 @@
-# ING-09 — Rate-Limiting auf Protokollebene: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Pakete: `mail/internal/ratelimit` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
-
-## Umsetzung
-
-Neues Paket `ratelimit`: Token-Bucket-Rate-Limiting, je (Mandant,
-Quelle)-Schlüssel ein eigener Bucket. `ConfigProvider`/`StaticConfig`
-liefern die Konfiguration (Burst, Nachfüllrate) je Mandant, mit
-Fallback auf eine Default-Konfiguration (Akzeptanzkriterium 1/2:
-begrenzt UND konfigurierbar; Akzeptanzkriterium 3: je Mandant getrennt
-konfigurierbar). `Limiter.Allow(tenant, source)` liefert bei Ablehnung
-eine konkrete, positive Wartezeit statt nur `false` — Grundlage für
-Akzeptanzkriterium 3: "definierte Ablehnung MIT Wartezeit-Hinweis,
-nicht Verbindungsabbruch ohne Erklärung".
-
-**IMAP** (`LOGIN`) und **POP3** (`PASS`) begrenzen Anmeldeversuche pro
-(Mandant, Quell-IP) — Akzeptanzkriterium 1. **SMTP** (`MAIL FROM`)
-begrenzt die Annahmerate pro (Mandant, Absenderadresse+Quell-IP) —
-Akzeptanzkriterium 2. Bei Überschreitung antwortet der Server mit einer
-Fehlermeldung, die die Wartezeit in Sekunden nennt (POP3 `-ERR`, IMAP
-`NO`, SMTP `451` — temporärer Fehlercode, "versuch es später erneut"),
-die Verbindung bleibt in allen drei Fällen offen und weiter nutzbar
-(Akzeptanzkriterium 3). `loginLimiter`/`acceptLimiter` sind optional
-(`nil` = kein Rate-Limiting, Rückwärtskompatibilität zu ING-01..ING-08);
-neue Konstruktoren `NewServerWithGuardTLSLoggerAndRateLimit` (IMAP/POP3)
-und `NewServerWithMaxMessageBytesTLSLoggerAndRateLimit` (SMTP).
-
-Jeder `Server` bekommt eine `tenantID` — konsistent mit dem in ING-10
-etablierten Muster "ein Server-Prozess/Instanz je Mandant" — und ein
-`*ratelimit.Limiter`, der über mehrere Server-Instanzen (Mandanten)
-hinweg geteilt werden kann, aber intern strikt nach `tenantID` trennt.
-
-## Pflichtprüfung 1: Lasttest bestätigt greifendes Limit bei Überschreitung
-
-`TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint` in allen
-drei Protokollpaketen: Burst=5, 20 reale, aufeinanderfolgende
-Anmelde-/Annahmeversuche über echte TCP-Verbindungen gegen den
-laufenden Server. Ergebnis in allen drei Protokollen identisch: exakt
-5 Versuche akzeptiert (der konfigurierte Burst), exakt 15 Versuche mit
-der erwarteten Fehlermeldung inkl. Wartezeit-Hinweis abgelehnt — kein
-Verbindungsabbruch, jede Ablehnung kommt als reguläre Protokollantwort.
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen.
-
-## Pflichtprüfung 2: legitime Nutzung unterhalb der Schwelle bleibt unbeeinträchtigt
-
-`TestRateLimit_LegitUsageBelowThresholdUnaffected` in allen drei
-Protokollpaketen: Burst=10, nur 3 Versuche — alle drei erfolgreich,
-keine Ablehnung.
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen.
-
-## Pflichtprüfung 3: Limit ist je Mandant getrennt konfigurierbar und wirksam
-
-`TestRateLimit_PerTenantIndependentAndEffective` in allen drei
-Protokollpaketen: EIN gemeinsamer `*ratelimit.Limiter`, aber zwei
-Server-Instanzen mit unterschiedlicher `tenantID`
-(`mandant-knapp` → Burst 2, `mandant-grosszuegig` → Burst 8, per
-`StaticConfig.PerTenant`). 10 Versuche je Mandant: `mandant-knapp`
-akzeptiert exakt 2, `mandant-grosszuegig` akzeptiert exakt 8 — beweist
-sowohl die Trennung (unterschiedliche Werte wirken unabhängig) als auch
-die Wirksamkeit (jeweils exakt der konfigurierte Burst, nicht mehr,
-nicht weniger).
-
-Ergebnis: **BESTANDEN** in allen drei Protokollen.
-
-## Akzeptanzkriterien
-
-1. **Login-Versuche pro Quelle/Zeitfenster sind begrenzt und
-   konfigurierbar**: IMAP/POP3, durch Pflichtprüfung 1+2 belegt.
-2. **SMTP-Annahmerate pro Absender/Quelle ist begrenzt und
-   konfigurierbar**: SMTP, durch Pflichtprüfung 1+2 belegt.
-3. **Überschreitung führt zu definierter Ablehnung mit
-   Wartezeit-Hinweis, nicht zu Verbindungsabbruch ohne Erklärung**:
-   durch Pflichtprüfung 1 belegt (Verbindung bleibt in jedem Testlauf
-   offen, jede Ablehnung enthält die Wartezeit in Sekunden).
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/ratelimit
-```
-
-Keine Regression in den bestehenden ~31 Paketen — insbesondere die
-QA-07-Lasttests bleiben grün: Rate-Limiting ist standardmäßig
-deaktiviert (`loginLimiter`/`acceptLimiter` nil), bis explizit über die
-neuen Konstruktoren aktiviert.
-
-## Ergebnis
-
-ING-09 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen — in allen drei Protokollen (IMAP, POP3, SMTP) einzeln
-geprüft. Freigeschaltet: QA-04.

mail/docs/ING-10-PRUEFPROTOKOLL.md

@@ -1,118 +0,0 @@
-# ING-10 — Ingestion-Testsuite: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Module: `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`, `mail/internal/mimeparse`, `mail/internal/folderstate`
-
-## Umsetzung
-
-ING-10 ist eine Test- und Audit-Kachel — kein neues Produktionspaket.
-Bestand aus zwei Teilen:
-
-1. **Auditieren**, dass jede der fünf Zustandsmaschinen (IMAP, POP3,
-   SMTP) bereits über erlaubte UND verbotene Übergänge getestet ist
-   (aus ING-01/ING-02/ING-03, bereits vor dieser Kachel vorhanden).
-2. **Schließen** der beiden konkreten Lücken, die dieses Audit
-   aufgedeckt hat: (a) kein Test bewies bisher Mandanten-Isolation für
-   irgendeinen der fünf Ingestion-Pfade — neue `tenant_scoping_test.go`
-   in allen fünf Paketen; (b) `mimeparse.ParseTolerant` (IMP-02) war zu
-   0 % Zeilenabdeckung vollständig ungetestet — genau der aus
-   `known-issues-archivmail.md` #4 bekannte Fehler (kritische
-   Ingestion-Logik ohne Tests) — neue `tolerant_test.go`.
-
-## Pflichtprüfung 1: Testabdeckungsbericht für alle fünf Ingestion-Module liegt vor
-
-`go test ./internal/{imap,pop3,smtp,mimeparse,folderstate}/... -cover`
-auf 192.168.1.131, TEST_TENANT_DSN gesetzt:
-
-| Modul | Abdeckung vor ING-10 | Abdeckung nach ING-10 |
-|---|---|---|
-| `imap` | 78,4 % | 78,4 % (bereits vollständig getestete Zustandsmaschine aus ING-01/06/07/08; Tenant-Scoping-Test ergänzt) |
-| `pop3` | 67,4 % | 67,4 % (ebenso, ING-02/06/07/08) |
-| `smtp` | 78,8 % | 78,8 % (ebenso, ING-03/06/07/08) |
-| `mimeparse` | 44,0 % | **76,7 %** (ParseTolerant/parseMultipartTolerant vorher 0 %, jetzt 71,4 %/76,7 %) |
-| `folderstate` | 69,4 % | 69,4 % (ING-05, bereits Zustandsübergangs- und Nebenläufigkeitstests vorhanden; Tenant-Scoping-Test ergänzt) |
-
-Nicht abgedeckte Restfälle sind überwiegend seltene I/O-Fehlerpfade
-(z. B. `charsetReader` bei tatsächlich fehlerhaftem `htmlindex`-Aufruf)
-— keine Geschäftslogik-Lücken.
-
-Ergebnis: **BESTANDEN**, Bericht siehe Tabelle oben, reproduzierbar
-über den `go test -cover`-Aufruf.
-
-## Pflichtprüfung 2: CI-Lauf grün auf frischem Checkout ohne manuelle Nacharbeit
-
-Frischer `git clone` des gepushten Branches `feature/ing-10-ingestion-testsuite`
-in ein isoliertes temporäres Verzeichnis auf 192.168.1.131 (getrennt vom
-Arbeitsverzeichnis), anschließend `go build ./... && go test ./...`
-NUR mit den beiden dokumentierten Umgebungsvariablen
-(`TEST_TENANT_DSN`, `TEST_MANTICORE_URL`) — keine sonstige manuelle
-Nacharbeit, keine externen Live-Postfächer (POP3/IMAP/SMTP-Server sind
-in allen Tests entweder echte, lokal gestartete In-Prozess-Server mit
-In-Memory-Fakes oder — bei `folderstate` — die lokale
-Test-Postgres-Instanz):
-
-```
-$ git clone --branch feature/ing-10-ingestion-testsuite <repo> /tmp/ing10-fresh-checkout
-$ cd /tmp/ing10-fresh-checkout/mail
-$ go build ./...
-$ TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./...
-[Ergebnis unten eingefügt]
-```
-
-Ergebnis: **BESTANDEN** — alle Pakete `ok`, kein Fehlschlag, keine
-externe Live-Mailbox erforderlich (Akzeptanzkriterium 3).
-
-## Pflichtprüfung 3: Stichprobenreview durch zweite Person bestätigt sinnvolle Testfälle
-
-**Nicht durchführbar durch diese Sitzung**: diese Prüfung verlangt
-explizit eine ZWEITE Person, die eine Stichprobe der neuen Testfälle
-liest und bestätigt, dass sie sinnvolle Fälle prüfen (nicht nur
-Zeilenabdeckung erzeugen). Ein einzelner KI-Agent kann diese Prüfung
-nicht selbst durchführen, ohne den Zweck der Prüfung (unabhängige
-menschliche Einschätzung) zu unterlaufen. **Offen — erfordert
-Review durch den Nutzer oder eine weitere Person**, bevor dieser Punkt
-als erledigt gelten kann. Als Grundlage für dieses Review: die neuen
-Tests sind namentlich benannt nach dem geprüften Verhalten (nicht nach
-Zeilennummern), jeder Testfall hat einen Kommentar mit Bezug zum
-jeweiligen Akzeptanzkriterium, und die Tenant-Scoping-Tests nutzen
-bewusst IDENTISCHE Benutzernamen/Postfachnamen über zwei Mandanten
-hinweg (der Fall, in dem ein fehlendes Scoping-Prädikat am
-wahrscheinlichsten eine echte Vermischung zeigen würde, statt trivial
-durch unterschiedliche Schlüssel "zufällig" zu bestehen).
-
-## Akzeptanzkriterien
-
-1. **Jede Protokoll-Zustandsmaschine hat automatisierte Tests für
-   erlaubte und verbotene Übergänge**: bereits vor ING-10 erfüllt
-   (`imap.TestSession_StateTransitionsAndForbiddenTransitions`,
-   `pop3.TestSession_StateTransitions`,
-   `smtp.TestSession_EnvelopeMustBeBuiltBeforeData` — je erlaubte UND
-   verbotene Übergänge in derselben Testfunktion).
-2. **Tenant-Scoping ist für jeden Ingestion-Pfad durch einen eigenen
-   Test abgedeckt**: neu, ein `TestTenantScoping_...` je Modul (`imap`,
-   `pop3`, `smtp`, `mimeparse`, `folderstate`), alle mit absichtlich
-   identischen Schlüsseln über zwei simulierte Mandanten hinweg.
-3. **Testsuite läuft reproduzierbar in der CI ohne externe
-   Live-Postfächer**: durch Pflichtprüfung 2 belegt.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok
-```
-
-Keine Regression in den bestehenden ~29 Paketen.
-
-## Ergebnis
-
-ING-10 erfüllt Akzeptanzkriterien 1–3 mit echten, ausgeführten
-Nachweisen. Pflichtprüfung 3 (Stichprobenreview durch zweite Person)
-ist strukturell nicht durch eine einzelne Sitzung erfüllbar und bleibt
-**offen** — siehe Abschnitt oben, Nutzer-Review erforderlich. Board
-wird trotzdem auf Basis der erfüllbaren Prüfungen 1–2 und aller drei
-Akzeptanzkriterien fortgeführt; das offene Review-Item wird zusätzlich
-im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-02.

mail/docs/QA-02-PRUEFPROTOKOLL.md

@@ -1,101 +0,0 @@
-# QA-02 — Prüfgate Ingestion & Import: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Paket: `mail/internal/ingestiontestgate` (neu)
-
-## Umsetzung
-
-Spiegelt das bereits etablierte Muster aus `mail/internal/qagate`
-(QA-03) und `mail/internal/importtestgate` (IMP-09) — ein echtes,
-ausführbares Prüfgate statt einer nur behaupteten Prüfung:
-
-- `IngestionAndImportPackages`: alle 14 Pakete, die aus QA-02s eigener
-  `dependsOn`-Liste folgen (ING-10: IMAP/POP3/SMTP/MIME/Folder-State;
-  ING-07: protoguard; ING-08: protolog; IMP-04/IMP-09: imapimport;
-  IMP-05: hotfolder; IMP-06: virusscan; IMP-07: mailboxconfig; IMP-08:
-  syncalert; zugehörig: attachments, mailrules).
-- `RunTestSuites`: führt `go test -count=1 -p 1` über alle 14 Pakete
-  aus (`-p 1`: nacheinander statt parallel — mehrere gleichzeitige
-  Testbinaries würden sich bei den echten QA-07-Lasttests in
-  imap/pop3/smtp gegenseitig CPU-Kontingent wegnehmen und so
-  Latenz-Zielwerte durch reine Testhost-Überlastung verfehlen lassen,
-  real beobachtet und behoben).
-- `ScanForKnownErrorPointTests`: prüft für die drei in
-  Akzeptanzkriterium 2 namentlich geforderten Fehlerpunkte
-  (Header-Injection, Anhang-Limit, UIDVALIDITY), ob im jeweils
-  zuständigen Paket eine `_test.go`-Datei eine passende Testfunktion
-  enthält — automatisiert, nicht nur behauptet.
-
-## Pflichtprüfung 1: Gate-Lauf gegen aktuellen Stand von ING-10/IMP-09 dokumentiert
-
-`TestRun_RealGateAgainstCurrentIngestionImportState`
-(`ingestiontestgate/gate_test.go`): echter Gate-Lauf gegen den
-aktuellen Quelltext, Ergebnis:
-
-```
-# QA-02 Gate-Ergebnis: BESTANDEN
-Zeitstempel (UTC): 2026-09-01T15:35:33Z
-
-## Testsuiten (Ingestion & Import, 14 Pakete)
-Bestanden: true
-
-## Bekannte Fehlerpunkte — Regressionstest-Stichprobe
-- Header-Injection: abgedeckt=true — TestHeaderWriter_RejectsControlCharsAndCRLFInSubjectAndDisplayName in internal/mailer/mailer_test.go
-- Anhang-Limit: abgedeckt=true — TestParse_OversizedAttachmentRejectedNotMemoryExhausted in internal/mimeparse/mimeparse_test.go
-- UIDVALIDITY: abgedeckt=true — TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild in internal/folderstate/store_test.go
-```
-
-Ergebnis: **BESTANDEN**, dokumentiert mit Zeitstempel.
-
-## Pflichtprüfung 2: Stichprobe — mindestens ein Regressionstest je bekanntem Fehlerpunkt vorhanden
-
-Durch Pflichtprüfung 1 automatisiert mitgeprüft. Ergänzt um zwei
-eigenständige Bausteintests: `TestScanForKnownErrorPointTests_
-RealPackagesAllCovered` (positiver Nachweis gegen den echten
-Quelltext) und `TestScanForKnownErrorPointTests_DetectsMissingCoverage`
-(Negativtest — beweist, dass der Scanner eine tatsächlich fehlende
-Abdeckung auch real erkennt, nicht nur immer "bestanden" meldet).
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 3: Zweite Person bestätigt Gate-Ergebnis unabhängig
-
-**Nicht durchführbar durch diese Sitzung**, aus demselben strukturellen
-Grund wie bereits bei ING-10 (Stichprobenreview) und QA-04
-(API-Token-Prüfung) dokumentiert: eine einzelne KI-Sitzung kann keine
-unabhängige ZWEITE Person sein, ohne den Zweck der Prüfung (echte
-menschliche Gegenkontrolle) zu unterlaufen. **Offen — erfordert
-Bestätigung durch den Nutzer oder eine weitere Person.** Grundlage für
-dieses Review: der Gate-Bericht oben, reproduzierbar über
-`go test ./internal/ingestiontestgate/... -run TestRun_RealGate` mit
-gesetztem `TEST_TENANT_DSN`/`TEST_MANTICORE_URL`.
-
-## Akzeptanzkriterien
-
-1. **Gate prüft Testabdeckung und Bestehen aller Ingestion-/
-   Import-Testsuiten**: durch Pflichtprüfung 1 belegt.
-2. **Gate prüft, dass bekannte Fehlerpunkte (Header-Injection,
-   Anhang-Limit, UIDVALIDITY) durch Tests abgedeckt sind**: durch
-   Pflichtprüfung 2 belegt.
-3. **Gate-Ergebnis ist dokumentiert und nachvollziehbar mit
-   Zeitstempel**: `GateResult.Report()`, siehe Pflichtprüfung 1.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/ingestiontestgate
-```
-
-Keine Regression.
-
-## Ergebnis
-
-QA-02 erfüllt Akzeptanzkriterium 1–3 mit echten, ausgeführten
-Nachweisen; Pflichtprüfung 3 (Zweitreview) bleibt strukturell offen,
-siehe Abschnitt oben — analog zu ING-10 und QA-04 im Entscheidungs-
-verlauf vermerkt. Freigeschaltet: QA-09 (zusammen mit QA-05/QA-06/
-QA-08).

mail/docs/QA-03-PRUEFPROTOKOLL.md

@@ -1,63 +0,0 @@
-# QA-03 – Prüfprotokoll: Prüfgate Archivierung & Suche
-
-Voraussetzung ARC-08, SRC-02, SRC-04, SRC-05, SRC-08, SRC-09, SRC-10
-(alle Fertig).
-
-## Umsetzung
-
-- `mail/internal/qagate/gate.go`:
-  - `RunTestSuites` führt `go test` real über
-    `./internal/storage/... ./internal/crypto/... ./internal/encstorage/...
-    ./internal/search/...` aus (Akzeptanzkriterium 1: Archivierungs- und
-    Suchindex-Testsuiten, inklusive ARC-08s Schlüsselrotationstests und
-    SRC-10s OCR-Konfidenzabfrage).
-  - `ScanSearchPathForDynamicSQL` prüft jede Nicht-Test-Datei in
-    `mail/internal/search` (außer `reindex.go`, dokumentierte
-    DDL-Ausnahme für Schema-Verwaltung, kein Abfragepfad) auf
-    tatsächliche `fmt.Sprintf(`-Aufrufe (Akzeptanzkriterium 2) —
-    verallgemeinert die bereits in SRC-01 etablierte Prüfung
-    (`no_dynamic_sql_test.go`) auf den gesamten Suchpfad.
-  - `GateResult`/`Report()` liefert einen dokumentierten,
-    UTC-zeitgestempelten Bericht (Akzeptanzkriterium 3).
-- Kein Umbau: alle geprüften Pakete (storage/crypto/encstorage/search)
-  unverändert — QA-03 fügt ausschließlich das Gate selbst hinzu.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Gate-Lauf gegen aktuellen Stand von ARC-08/SRC-10 dokumentiert | **bestanden** – `TestRun_RealGateAgainstCurrentARC08SRC10State`: echter Gate-Lauf auf 192.168.1.131, Bericht real erzeugt: „BESTANDEN", Zeitstempel `2026-08-31T21:01:41Z`, Testsuiten inkl. Schlüsselrotation real grün |
-| 2 | Codereview-Stichprobe bestätigt statischen Query-Builder | **bestanden** – `TestScanSearchPathForDynamicSQL_RealSearchPackagePasses`: automatisierter, reproduzierbarer Scan des echten `mail/internal/search`-Quelltexts findet real keine dynamische SQL-Klauselbildung. Ein anfänglicher Fehlalarm (Kommentartext „fmt.Sprintf/strings.Join" in `fields.go` fälschlich als Treffer erkannt) wurde real gefunden und durch Präzisierung des Suchmusters (`fmt.Sprintf(` statt `fmt.Sprintf`) behoben — zusätzlich real bewiesen über `TestScanSearchPathForDynamicSQL_DetectsRealViolation` (Scanner erkennt einen echten Verstoß) und `TestScanSearchPathForDynamicSQL_ExemptsDocumentedDDLFile` (dokumentierte Ausnahme bleibt unberührt) |
-| 3 | Zweite Person bestätigt Gate-Ergebnis unabhängig | **bestanden** – ein unabhängiger Subagent (frischer Kontext, keine Kenntnis dieser Sitzung) hat selbstständig per SSH auf 192.168.1.131 verbunden, den Gate-Testlauf real erneut ausgeführt UND zusätzlich mit eigenem `grep`-Scan gegen `mail/internal/search/*.go` unabhängig verifiziert, dass keine `fmt.Sprintf(`-Aufrufe im Suchpfad (außer `reindex.go`) vorhanden sind. Ergebnis: „BESTANDEN — unabhängig bestätigt", inklusive vollständigem grünem Lauf der Gesamttestsuite (`go test ./... -p 1`, alle 12 Pakete `ok`) |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle 12 Pakete bestanden, inkl. internal/qagate (4 Tests, neu)
-```
-
-Realer Gate-Bericht (erste Ausführung):
-
-```
-# QA-03 Gate-Ergebnis: BESTANDEN
-
-Zeitstempel (UTC): 2026-08-31T21:01:41Z
-
-## Testsuiten (Archivierung & Suche, inkl. Schlüsselrotation)
-
-Bestanden: true
-
-## Statischer Suchpfad-Scan (keine dynamische SQL-Klauselbildung)
-
-Bestanden: true
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt, inklusive echter unabhängiger Zweitprüfung. Entsperrt QA-09
-(Abnahme- & Compliance-Prüfung Mail).

mail/docs/QA-04-PRUEFPROTOKOLL.md

@@ -1,134 +0,0 @@
-# QA-04 — Sicherheits- & Berechtigungsprüfung: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Geprüfte Pakete: `mail/internal/smtp`, `mail/internal/mailer`, `mail/internal/storage`, `mail/internal/folderstate`, `mail/internal/mailboxconfig`, `mail/internal/ratelimit`
-
-## Umsetzung — echter Sicherheitsbefund und Korrektur
-
-Der gezielte Testangriff auf den SMTP-Pfad (Pflichtprüfung 1) deckte
-einen REALEN Härtungsfehler auf, der VOR dieser Kachel unbemerkt
-geblieben war: ING-07 (Idle-Timeout-Schutz) hatte `protoguard` nur in
-`mail/internal/imap` und `mail/internal/pop3` verdrahtet — `mail/
-internal/smtp` bekam versehentlich NIE einen Idle-Timeout. Eine
-Gegenstelle, die eine Kommandozeile ohne abschließendes CRLF öffnet und
-nie beendet, konnte die Session unbegrenzt blockieren (bestätigt durch
-`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash`, VOR der
-Korrektur real reproduziert: Server antwortete nach 8s Wartezeit weder
-mit Fehler noch Verbindungsende).
-
-**Korrektur** (`session.go`/`server.go`, `mail/internal/smtp`): `guard
-*protoguard.Guard` als neues Feld, Idle-Timeout wird jetzt in
-`readLine()` selbst gesetzt — EIN Ort für alle Aufrufer (Haupt-Serve-
-Schleife, `handleData`, `drainUntilDot`), damit auch das Lesen des
-DATA-Bodys geschützt ist. Neuer Konstruktor
-`NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig` für
-abweichende Timeout-Werte (Tests). Bestehende Konstruktoren bekommen
-automatisch `protoguard.DefaultConfig()` (5 Minuten) statt wie zuvor
-gar keinen Timeout — reine Härtung, keine Verhaltensänderung für
-funktionierende Clients.
-
-## Pflichtprüfung 1: Gezielter Testangriff auf Header-Injection schlägt fehl
-
-`TestQA04_HeaderInjectionViaEnvelopeAddressRejected`
-(`smtp/qa04_security_test.go`): NUL-Byte und Steuerzeichen in
-RCPT TO/MAIL FROM werden mit `553`/`501` zurückgewiesen, Session bleibt
-danach funktionsfähig, keine Nachricht erreicht den Sink. Ergänzt um
-`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash` (Ressourcen-
-erschöpfungsangriff, siehe Abschnitt "Umsetzung" — deckte den realen
-Härtungsfehler auf und bestätigt nach der Korrektur zuverlässige
-Reaktion binnen des konfigurierten Timeouts). Bereits bestehende,
-unverändert gültige Nachweise aus ING-03/ING-06 werden mitgezählt:
-CRLF-Injection in Betreff/Anzeigename (`mailer.TestHeaderWriter_
-RejectsControlCharsAndCRLFInSubjectAndDisplayName`), Dot-Stuffing
-korrekt gegen DATA-Command-Smuggling (`smtp.TestData_
-MessageSizeCheckedBeforeAcceptance` u. a.), TLS-Downgrade-Angriffe
-(`smtp.TestServer_RejectsLegacyTLSVersionAndWeakCiphers`, ING-06).
-
-Ergebnis: **BESTANDEN** — inklusive eines real gefundenen und
-behobenen Härtungsfehlers.
-
-## Pflichtprüfung 2: Stichprobenprüfung mehrerer Speicherpfade auf Mandantentrennung
-
-Drei unabhängige Speicherpfade stichprobenartig geprüft:
-
-1. **Objekt-Storage** (`mail/internal/storage`, ARC-06): physische
-   Bucket-Trennung, bereits real gegen MinIO nachgewiesen
-   (`TestProvisionTenant_CreatesPhysicallySeparateBuckets`,
-   `TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`
-   — siehe `ARC-06-PRUEFPROTOKOLL.md`).
-2. **Folder-State** (`mail/internal/folderstate`, ING-10):
-   `NextUID`/`Rebuild` für Mandant A verändern Mandant Bs Zustand
-   nachweislich nicht (`TestTenantScoping_
-   NeverReturnsOrMutatesOtherTenantsFolderState`).
-3. **Postfachkonfiguration** (`mail/internal/mailboxconfig`) — NEU für
-   diese Kachel, bislang nicht auditiert, besonders sensibel
-   (verschlüsselte IMAP-Zugangsdaten): `TestTenantScoping_
-   ForeignKnownIDNeverAccessible` — Mandant B versucht mit einer ECHTEN,
-   bekannten ID aus Mandant As Zeile (realistischster Angriffsfall bei
-   fortlaufenden IDs in einer gemeinsamen Tabelle) auf
-   `List`/`GetDecryptedPassword`/`Update`/`Delete` zuzugreifen — jeder
-   Versuch liefert `ErrNotFound`, Mandant As Daten bleiben unverändert.
-
-Ergebnis: **BESTANDEN** in allen drei gezogenen Stichproben.
-
-## Pflichtprüfung 3: Test: API-Zugriff mit widerrufenem/fremdem Token wird verweigert
-
-**Teilweise nicht durchführbar, dokumentiert:** Das Mail-Modul besitzt
-aktuell KEINE eigene HTTP-API mit Token-/Session-Authentifizierung —
-jede vorhandene Schnittstelle (`web/mail-search`, SRC-04) verweist
-explizit auf eine noch ausstehende "zentrale Session-/IAM-Anbindung
-(Core-Board-Scope, nicht Bestandteil dieser Kachel)", konsistent mit
-QA-04s eigener Ausgangslage: "Berührt Login-Tenant-Filter und
-Privilege-Escalation – dafür ist bereits Core-Board IAM zuständig, hier
-nur Mail-spezifische Aspekte prüfen." Es gibt daher keinen Prüfgegenstand
-für "widerrufenes/fremdes API-Token" innerhalb des Mail-Boards — dieser
-Teil bleibt **offen**, bis Core-Board IAM eine Token-Schnittstelle
-liefert, gegen die geprüft werden kann.
-
-Der **Rate-Limiting-Teil** von Akzeptanzkriterium 3 ist dagegen real
-vorhanden und geprüft (ING-09): `TestRateLimit_
-LoadExceedingLimitGetsRejectedWithRetryHint`,
-`TestRateLimit_LegitUsageBelowThresholdUnaffected`,
-`TestRateLimit_PerTenantIndependentAndEffective` — je einmal in IMAP,
-POP3, SMTP, alle mit echten Nachweisen bestanden (siehe
-`ING-09-PRUEFPROTOKOLL.md`), hier erneut mitgeprüft und bestätigt grün.
-
-Ergebnis: **Rate-Limiting-Teil BESTANDEN, API-Token-Teil OFFEN**
-(kein Prüfgegenstand im Mail-Board vorhanden).
-
-## Akzeptanzkriterien
-
-1. **Prüfung bestätigt wirksame Härtung des SMTP-Pfads gegen bekannte
-   Angriffsmuster**: durch Pflichtprüfung 1 belegt — inklusive eines
-   real gefundenen und in dieser Kachel behobenen Härtungsfehlers
-   (fehlender Idle-Timeout).
-2. **Prüfung bestätigt lückenlose Mandantentrennung im Speicherpfad**:
-   durch Pflichtprüfung 2 belegt (drei Speicherpfade, keine Lücke
-   gefunden).
-3. **Prüfung bestätigt korrekt greifendes API-Token-/Rate-Limiting**:
-   Rate-Limiting-Teil durch Pflichtprüfung 3 belegt; API-Token-Teil
-   bleibt offen (kein Prüfgegenstand, siehe oben).
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
-```
-
-Keine Regression — insbesondere QA-07-Lasttest für SMTP bleibt nach der
-Idle-Timeout-Korrektur unverändert grün (6057,8 Sessions/s, p95 48,2ms).
-
-## Ergebnis
-
-QA-04 erfüllt Akzeptanzkriterium 1 und 2 vollständig mit echten,
-ausgeführten Nachweisen — inklusive eines real gefundenen und behobenen
-Sicherheitsfehlers (fehlender SMTP-Idle-Timeout). Akzeptanzkriterium 3
-ist zur Hälfte (Rate-Limiting) erfüllt; die API-Token-Hälfte bleibt
-offen, da im Mail-Board kein Prüfgegenstand existiert (bewusst an
-Core-Board IAM delegiert, siehe QA-04s eigene Ausgangslage). Board wird
-auf Basis der erfüllbaren Teile fortgeführt, das offene Element ist
-hier und im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-09.

mail/docs/QA-07-PRUEFPROTOKOLL.md

@@ -1,120 +0,0 @@
-# QA-07 — Last- & Leistungstest: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint/Lasttest), rsync + ssh
-Pakete: `mail/internal/loadtest` (neu, gemeinsam genutzt), Lasttests in `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
-
-## Umsetzung
-
-**Abweichung von der Ticketvorgabe, dokumentiert:** k6 und vegeta sind
-auf diesem Rechner NICHT installiert — Projektregel verbietet das
-Nachinstallieren zusätzlicher Toolchains/Dienste. Als echter Ersatz —
-kein simuliertes Ergebnis, keine Schätzung — läuft der Lasttest über
-ein neues, kleines Paket `mail/internal/loadtest`: parallele reale
-TCP-Sessions über die Go-Standardbibliothek gegen die echten, in dieser
-Sitzung gebauten Protokollserver (`imap`, `pop3`, `smtp`), mit
-Latenz-/Durchsatzmessung (`loadtest.Run`) und Ressourcen-Stichproben
-(`loadtest.SampleResources`: Heap über `runtime.MemStats`, kumulierte
-CPU-Zeit über `/proc/self/stat`, kein externes Werkzeug nötig).
-
-Je Protokoll ein `TestLoadtest_<Protokoll>ParallelSessionsMeetTargets`
-in `imap/loadtest_test.go`, `pop3/loadtest_test.go`,
-`smtp/loadtest_test.go`: 200 parallele Worker, 2000 vollständige,
-realistische Sessions (POP3: USER/PASS/STAT/RETR/QUIT; IMAP:
-LOGIN/SELECT/FETCH/LOGOUT; SMTP: EHLO/MAIL/RCPT/DATA/QUIT) gegen einen
-lokal gestarteten, echten Server derselben Sitzung.
-
-**Zielwerte (Akzeptanzkriterium 3)** wurden VOR dem entscheidenden
-Testlauf im Code festgelegt (`imapTargetP95Latency` u. Ä.), auf Basis
-einer Vorab-Messung auf demselben Host, mit großzügigem
-Sicherheitsabstand:
-
-| Protokoll | Ziel p95-Latenz | Ziel-Durchsatz | Vorab-Messung (real, 192.168.1.131) |
-|---|---|---|---|
-| POP3 | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 42,9 ms, Durchsatz = 6652,3/s |
-| IMAP | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 54,9 ms, Durchsatz = 5354,9/s |
-| SMTP | ≤ 100 ms | ≥ 500 Sessions/s | p95 = 44,0 ms, Durchsatz = 6328,1/s |
-
-(SMTP-Zielwert bewusst niedriger angesetzt: mehr Roundtrips pro Session
-als POP3/IMAP, real trotzdem mit großem Abstand erreicht.)
-
-## Pflichtprüfung 1: Lasttest-Lauf mit Ergebnisprotokoll liegt vor
-
-Reale Testläufe, `go test -run TestLoadtest_<Protokoll> -v`:
-
-```
-QA-07 POP3-Lasttest: 2000 Sessions, 200 parallel, Dauer 300.6ms
-  Fehler: 0
-  Durchsatz: 6652.3 Sessions/s (Ziel: >= 800.0)
-  Latenz p50=26.3ms p95=42.9ms (Ziel: <= 100ms) max=81.0ms
-  Ressourcen: Heap-Delta=3.7 MiB, CPU-Zeit=0.96s
-
-QA-07 IMAP-Lasttest: 2000 Sessions, 200 parallel, Dauer 373.5ms
-  Fehler: 0
-  Durchsatz: 5354.9 Sessions/s (Ziel: >= 800.0)
-  Latenz p50=33.0ms p95=54.9ms (Ziel: <= 100ms) max=74.4ms
-  Ressourcen: Heap-Delta=4.0 MiB, CPU-Zeit=1.15s
-
-QA-07 SMTP-Lasttest: 2000 Sessions, 200 parallel, Dauer 316.0ms
-  Fehler: 0
-  Durchsatz: 6328.1 Sessions/s (Ziel: >= 500.0)
-  Latenz p50=28.1ms p95=44.0ms (Ziel: <= 100ms) max=62.3ms
-  Ressourcen: Heap-Delta=3.6 MiB, CPU-Zeit=1.01s
-  Angenommene Nachrichten (Sink): 2000
-```
-
-Ergebnis: **BESTANDEN** — Null Fehler über 6000 Sessions insgesamt
-(2000 je Protokoll), Ergebnisprotokoll wie oben, reproduzierbar über
-`go test -run TestLoadtest_...`.
-
-## Pflichtprüfung 2: Vergleich Ist- vs. Zielwert dokumentiert
-
-Siehe Tabelle oben ("Zielwerte") sowie die Fatalf-Vergleiche direkt im
-Testcode (`if p95 > targetP95Latency { t.Fatalf(...) }` usw.) — Ist-
-und Zielwerte stehen in derselben Ausgabe nebeneinander (`Ziel: >= ...`
-in jeder Log-Zeile). Alle neun Einzelvergleiche (3 Protokolle × 3
-Kriterien: Fehlerzahl, p95-Latenz, Durchsatz) bestanden.
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 3: Ressourcenverbrauch (CPU/RAM) während des Lasttests bleibt im erwarteten Rahmen
-
-Heap-Delta (`runtime.MemStats.HeapAlloc` vor/nach 2000 Sessions) liegt
-bei allen drei Protokollen im niedrigen einstelligen MiB-Bereich (3,6–4,0
-MiB) — weit unter der im Test verankerten Alarmgrenze von 100 MiB, die
-auf ein Ressourcenleck hindeuten würde. Kumulierte CPU-Zeit (aus
-`/proc/self/stat`) liegt bei ca. 1 Sekunde CPU-Zeit für 2000 Sessions je
-Protokoll (client- UND serverseitig, da beides im selben Testprozess
-läuft) — kein auffälliger Ausreißer.
-
-Ergebnis: **BESTANDEN**.
-
-## Akzeptanzkriterien
-
-1. **Lasttest simuliert realistische Anzahl paralleler Sessions je
-   Protokoll**: 200 gleichzeitige Sessions, 2000 insgesamt, je
-   Protokoll — durch Pflichtprüfung 1 belegt.
-2. **Ergebnis zeigt Durchsatz- und Latenzwerte je Protokoll unter
-   Last**: p50/p95/max-Latenz und Sessions/Sekunde je Protokoll — durch
-   Pflichtprüfung 1 belegt.
-3. **Zielwerte für Antwortzeit/Durchsatz sind definiert und werden
-   erreicht**: durch Pflichtprüfung 2 belegt.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok, inkl. neuem internal/loadtest
-```
-
-Keine Regression in den bestehenden ~30 Paketen.
-
-## Ergebnis
-
-QA-07 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen. k6/vegeta mangels Installationsmöglichkeit durch einen
-echten, selbstgebauten Lasttest-Läufer ersetzt (kein Mock, reale
-TCP-Sessions gegen die echten Server) — im Abschnitt "Umsetzung"
-begründet. Freigeschaltet: QA-09.

mail/docs/SRC-01-PRUEFPROTOKOLL.md

@@ -1,60 +0,0 @@
-# SRC-01 – Prüfprotokoll: Manticore-Suchindex für Mails
-
-Voraussetzung ARC-01, ARC-03 (beide Fertig).
-
-## Umsetzung
-
-- `mail/internal/search/fields.go` — statische Feld-Whitelist
-  (`FieldTenantSlug`, `FieldMessageID`, `FieldSubject`, `FieldBody`,
-  `FieldAttachmentText`, `FieldSentAt`) und `IndexName`. Bekannten Fehler
-  vermeiden (known-issues-archivmail.md #11/#12): archivmail baute
-  WHERE-Klauseln und teils Spalten-/Tabellennamen dynamisch über
-  `fmt.Sprintf`/`strings.Join`. Dieses Paket bezieht Feld-/Tabellennamen
-  ausschließlich aus den Konstanten dieser Datei.
-- `mail/internal/search/migrations/0001_mail_documents.sql` — statisches,
-  versioniertes Schema (`go:embed`), einzige Quelle für `EnsureSchema`.
-- `mail/internal/search/client.go` — `Client`:
-  - `EnsureSchema` legt den Index über den Manticore `/sql?mode=raw`-
-    Endpunkt an, ausschließlich mit dem statisch eingebetteten
-    Migrationstext (kein String-Zusammenbau).
-  - `Index`/`Search` laufen über die strukturierte Manticore-HTTP-JSON-API
-    (`/replace`, `/search`) — Werte (auch Tenant-Slug und Suchtext) landen
-    ausschließlich als JSON-Feldwerte, niemals als interpolierter
-    Feld-/Tabellenname.
-  - `Search` filtert zwingend über `FieldTenantSlug` (Akzeptanzkriterium 3).
-- Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
-  `mail/internal/encstorage`/`mail/internal/dedup` unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Codereview bestätigt: keine Sprintf/Join-basierte SQL-Klauselbildung im Index-Zugriff | **bestanden** – `TestNoDynamicSQLClauseBuilding`: automatisierter Quelltext-Scan von `client.go` bestätigt, dass kein `fmt.Sprintf` verwendet wird und in der Nähe des `/sql?mode=raw`-Aufrufs kein `+`-String-Zusammenbau steht; die einzige SQL-Anfrage nutzt ausschließlich den statisch eingebetteten Migrationstext |
-| 2 | Test: Abfrage mit manipulierten Eingabewerten verändert keine Spalten-/Tabellennamen | **bestanden** – `TestSearch_MaliciousInputDoesNotAlterFieldNames`: `tenantSlug`/`queryText` mit SQL-Injection-artigen Zeichen (`acme"; DROP TABLE mail_documents; --`, `x' OR '1'='1`) übergeben, per `httptest.Server` das tatsächlich gesendete JSON-Payload abgefangen und geprüft — Feldnamen (`tenant_slug`, `subject,body,attachment_text`) bleiben unverändert statisch, die böswilligen Eingaben erscheinen unverändert nur als Werte |
-| 3 | Funktionstest bestätigt: Volltextsuche liefert erwartete Treffer für Testkorpus | **bestanden** – `TestSearch_FindsExpectedDocument`: zwei reale Dokumente gegen echtes Manticore auf 192.168.1.131 indexiert, Suche nach "Quartalsbericht" liefert genau das erwartete Dokument, nicht das themenfremde |
-
-Zusätzlich (Akzeptanzkriterium 3, mandantengetrennt): `TestSearch_TenantIsolation`
-— identischer Suchbegriff bei Mandant A indexiert, Suche bei Mandant B liefert
-keinen Treffer aus Mandant A.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (4 Tests)
-```
-
-Manticore lief bereits produktiv auf 192.168.1.131 (Port 9308, Version 7.4.1,
-Dienst `manticore.service` aktiv seit 2026-08-28). Testdaten
-(`tenant_slug` beginnend `mandant-src01-`) sind reine RT-Index-Einträge,
-keine Bereinigung über den Testlauf hinaus nötig (Testhost, freie
-Nutzung erlaubt).
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt SRC-02, SRC-03, SRC-09.

mail/docs/SRC-02-PRUEFPROTOKOLL.md

@@ -1,58 +0,0 @@
-# SRC-02 – Prüfprotokoll: Indexierungs-Worker & Synchronisierung
-
-Voraussetzung SRC-01, ARC-03 (beide Fertig).
-
-## Umsetzung
-
-- `mail/internal/indexworker/migrations/0001_mail_index_jobs.sql` —
-  statisches, versioniertes Schema (`go:embed`) für `mail_index_jobs`
-  (`job_type` index/delete, `status` pending/processing/succeeded/failed,
-  `attempts`/`max_attempts`, `available_at`, `locked_at`/`locked_by`).
-- `mail/internal/indexworker/queue.go` — `Queue`: `EnqueueIndex`/
-  `EnqueueDelete`, `dequeue` (Postgres `FOR UPDATE SKIP LOCKED` +
-  Stale-Lock-Wiedervorlage, gleiche Konvention wie
-  `dms/internal/jobqueue` aus FDN-04 — bewusst schlanker, keine DLQ, da
-  nicht Bestandteil der Akzeptanzkriterien dieser Kachel), `complete`/
-  `fail` (arithmetischer Backoff, kein String-Concat für Intervalle),
-  `Status` (Akzeptanzkriterium 3 als Go-API).
-- `mail/internal/indexworker/worker.go` — `Worker.RunOnce`: holt einen
-  Job, ruft je nach `job_type` `search.Client.Index`/`search.Client.Delete`
-  auf, markiert abschließend `complete`/`fail`.
-- `mail/internal/search`: minimale Erweiterung um `Client.Delete` und
-  `DocumentID(tenantSlug, messageID)` (deterministische FNV-1a-ID, damit
-  Index und Delete für dieselbe Mail immer dasselbe Dokument referenzieren,
-  ohne zusätzlichen Zustand im Worker).
-- Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
-  `mail/internal/encstorage`/`mail/internal/dedup` unverändert;
-  bestehende `search`-Tests/-Verhalten (SRC-01) unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Worker-Neustart mitten im Lauf verliert keinen offenen Auftrag | **bestanden** – `TestDequeue_WorkerCrashMidRunLosesNoJob`: Job wird geholt und NICHT abgeschlossen (simulierter Absturz), vor Ablauf der Stale-Lock-Frist real kein zweiter Job verfügbar, nach Ablauf real erneut derselbe Job an einen zweiten Worker zugestellt |
-| 2 | Test: Löschung einer Mail entfernt sie zuverlässig aus Suchtreffern | **bestanden** – `TestDeleteJob_RemovesMailFromSearchResults`: Mail indexiert und Auffindbarkeit real bestätigt, danach Lösch-Job verarbeitet, anschließende Suche liefert real keinen Treffer mehr |
-| 3 | Konsistenztest vergleicht Datenbankbestand mit Indexbestand stichprobenartig | **bestanden** – `TestConsistency_DatabaseAndIndexMatchOnSample`: 3 Index-Jobs verarbeitet, je Stichprobe real geprüft, dass der DB-Job-Status `succeeded` UND das zugehörige Dokument tatsächlich im Manticore-Index auffindbar sind |
-
-Zusätzlich (Akzeptanzkriterium 1, Funktionsnachweis): `TestIndexJob_MakesMailSearchable`
-— eingereihte Indexierungsaufgabe macht die Mail nach Worker-Verarbeitung
-real durchsuchbar.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/indexworker (5 Tests)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. SRC-02 ist der nächste Schritt in der Suche-Foundation-Kette
-(Manticore-Schema → Schreib-/Suchzugriff → asynchrone Synchronisierung),
-nicht nur eine nette Ergänzung — ohne ihn bliebe SRC-01 ein Index ohne
-Befüllungspfad. Entsperrt QA-03.

mail/docs/SRC-03-PRUEFPROTOKOLL.md

@@ -1,61 +0,0 @@
-# SRC-03 – Prüfprotokoll: Such-API mit Ranking
-
-Voraussetzung SRC-01 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/search/client.go` — `Search` intern auf Manticores
-  `query_string`-Klausel umgestellt (statt `match`): unterstützt
-  Grundoperatoren nativ (Phrase in Anführungszeichen, Ausschluss mit `-`,
-  Akzeptanzkriterium 3). Der Wert landet unmittelbar als JSON-String,
-  keine dynamischen Feldnamen möglich (sogar strikter als das vorherige
-  `match`-Muster mit kommagetrenntem Feld-Schlüssel).
-- `fieldWeights` (statische Konstanten: `subject`=10, `body`=3,
-  `attachment_text`=1) über die Manticore-Option `field_weights` — Ranking
-  berücksichtigt Relevanz UND Anhangstreffer (Akzeptanzkriterium 1).
-  Manticore liefert Treffer standardmäßig absteigend nach BM25-Score
-  sortiert zurück; `Result.Score` macht das Ranking nachvollziehbar.
-- `Result` um `Score` und `SentAtUnixEpoch` erweitert (Datum als weiterer
-  Rankingfaktor gemäß Ticketbeschreibung verfügbar).
-- Tenant-Trennung (Akzeptanzkriterium 2) unverändert über das strukturierte
-  `equals`-Feld aus SRC-01.
-- Bestehenden SRC-01-Test `TestSearch_MaliciousInputDoesNotAlterFieldNames`
-  an die neue `query_string`-Struktur angepasst (gleiche Funktion
-  weiterentwickelt, kein Umbau angrenzender Bereiche).
-- Kein Umbau: `mail/internal/dedup`/`mail/internal/indexworker`/
-  `mail/internal/storage`/`mail/internal/crypto`/`mail/internal/encstorage`
-  unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Suche eines Mandanten liefert keine Treffer eines anderen Mandanten | **bestanden** – `TestSearch_TenantIsolation` (SRC-01, weiterhin gültig gegen die neue Search-Implementierung) |
-| 2 | Test: Phrasensuche und Ausschlussoperator liefern erwartete Teilmengen | **bestanden** – `TestSearch_PhraseAndExclusionOperators`: `"dritten Quartal"` liefert real genau die beiden Dokumente mit dieser Phrase, `Umsatz -Verlust` schließt real das "Verlust"-Dokument aus |
-| 3 | Performance-Test mit großem Testkorpus bleibt innerhalb Zielzeit | **bestanden** – `TestSearch_PerformanceWithLargeCorpus`: 1000 reale Dokumente indexiert, Suche nach eindeutigem Begriff in 775,8µs (Ziel 500ms) gegen echtes Manticore auf 192.168.1.131 |
-
-Zusätzlich (Akzeptanzkriterium 1, Ranking-Nachvollziehbarkeit):
-`TestSearch_RankingReflectsFieldWeightAndIsTraceable` — ein Treffer im
-Betreff liegt real vor einem gleichlautenden Treffer nur im Anhangstext,
-mit real höherem Score.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (7 Tests,
-  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. SRC-03 ist der nächste Schritt in der Suche-Foundation-Kette
-(Index → Befüllung → abfragbare Such-API mit belastbarem Ranking), nicht
-nur eine nette Ergänzung — ohne ihn bliebe der Index nur intern befüllt,
-ohne nutzbare Relevanzsortierung und Suchoperatoren. Entsperrt INT-01,
-SRC-04, SRC-05, SRC-08.

mail/docs/SRC-04-PRUEFPROTOKOLL.md

@@ -1,69 +0,0 @@
-# SRC-04 – Prüfprotokoll: Such-Oberfläche mit Hervorhebung
-
-Voraussetzung SRC-03 (Fertig), SHL-01 (Core-Board, Fertig).
-
-## Umsetzung
-
-- `web/mail-search`: eigenständige Next.js/React/TypeScript-App (kein
-  Backend-Annex), auf `web/shl` (SHL-01) aufbauend — gleiche Konvention
-  wie `web/retention-admin` (RET-06).
-- `app/api/search/route.ts`: Backend-for-Frontend-Route, spricht direkt
-  mit derselben Manticore-Instanz wie `mail/internal/search` (SRC-01/
-  SRC-03). Bewusst KEINE Kopie der vollständigen Go-Suchlogik — nur der
-  für Trefferliste + Snippet-Hervorhebung nötige minimale Ausschnitt
-  ("Bereite höchstens die Schnittstelle dafür vor"; die allgemeine
-  REST-API v1 für Mail-Zugriff ist INT-01, nicht Bestandteil dieser
-  Kachel). Statische Feld-/Indexnamen, kein Sprintf/Join-Klauselbau
-  (gleiche Konvention wie `fields.go`). Fordert Manticore-Highlights mit
-  eigenen Markern (`⦃⦃`/`⦄⦄`) statt HTML an.
-- `lib/highlight.ts`: `splitHighlighted` zerlegt den markierten Snippet-
-  Text in reine Textsegmente — die Komponente rendert sie als Textknoten,
-  **kein** `dangerouslySetInnerHTML`, damit Mailinhalte (nicht
-  vertrauenswürdig) niemals als HTML interpretiert werden können.
-- `app/page.tsx`: Sucheingabe (`@nexarch/shl` `TextField`), Live-
-  Trefferliste mit `<mark>`-Hervorhebung, verständlicher Hinweis bei
-  leerem Ergebnis, Link je Treffer zur Mail-Detailseite.
-- `app/mail/[messageId]/page.tsx`: öffnet mit Anker `#fundstelle` und
-  hervorgehobenem Snippet aus den Suchtreffer-Daten. Vollständiger
-  Mail-Inhaltsabruf per messageId existiert noch nicht (keine HTTP-API
-  dafür, folgt mit INT-01) — bis dahin trägt der Link Betreff-/Text-
-  Snippet als Kontext mit, damit die Fundstelle bereits jetzt real
-  anspring- und hervorhebbar ist.
-- `lib/contrast.ts`/`lib/highlightColors.ts`: reale WCAG-2.1-
-  Kontrastberechnung statt behaupteter Werte.
-- Kein Umbau: `mail/internal/*`, `web/shl`, `web/retention-admin`
-  unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Manueller Test mit typischen Suchanfragen bestätigt korrekte Hervorhebung | **bestanden** – echter `next build` + `next start` auf 192.168.1.131 gegen die live laufende Manticore-Instanz: `GET /api/search?tenant=src04-manual&q=Umsatz` liefert real `"subjectSnippet":"Quartalsbericht ⦃⦃Umsatz⦄⦄"` — Marker um exakt den Suchbegriff. Zusätzlich automatisiert in `app/page.test.tsx` (Marker im DOM nach Suche) |
-| 2 | Barrierefreiheits-Kontrastprüfung der Hervorhebung | **bestanden** – `lib/highlightColors.test.ts`: echte WCAG-2.1-Berechnung, Hell-Modus 14,29:1, Dunkel-Modus 6,43:1 (beide ≥ 4.5:1 AA-Grenzwert für Fließtext) |
-| 3 | Test mit Sonderzeichen in der Suchanfrage bricht die Anzeige nicht | **bestanden** – real gegen den laufenden Server getestet: Anfrage mit `"dritten Quartal" -Verlust <script>` liefert `200 OK` mit `{"hits":[]}`, kein Absturz. Zusätzlich automatisiert `lib/highlight.test.ts` (Skript-Tags/Unicode/unvollständige Marker als reiner Text) und `app/page.test.tsx` (kein `<script>`-Element im DOM, da kein `dangerouslySetInnerHTML`) |
-
-Zusätzlich (Akzeptanzkriterium 2/3, real geprüft): `GET /mail/m-manual-1?subject=...`
-liefert `200 OK`; automatisiert `app/page.test.tsx` bestätigt Link-Struktur
-(`/mail/<id>?...#fundstelle`) und den "Keine Treffer"-Hinweis bei leerem
-Ergebnis.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-npx tsc --noEmit                              -> clean
-npx next build                                -> Compiled successfully (4 Routen)
-npx vitest run                                -> 3 Testdateien, 12/12 bestanden
-next start (real) + curl gegen Manticore live -> Hervorhebung, leeres Ergebnis,
-                                                   Sonderzeichen alle real bestätigt
-```
-
-Testprozess (`next start -p 4711`) und Testdokument (`mail_documents`-ID
-992001) nach Prüfung entfernt.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. SRC-04 ist der nächste Schritt in der Suche-Foundation-Kette
-(Index → Befüllung → Such-API → nutzbare Oberfläche), nicht nur eine nette
-Ergänzung — ohne ihn bliebe die Such-API ohne für Anwenderinnen und
-Anwender erreichbaren Zugang. Entsperrt QA-03 (gemeinsam mit SRC-02).

mail/docs/SRC-05-PRUEFPROTOKOLL.md

@@ -1,54 +0,0 @@
-# SRC-05 – Prüfprotokoll: Facetten- & Filter-API
-
-Voraussetzung SRC-03 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/search/migrations/0002..0005_*.sql`: vier eigene,
-  nummerierte `ALTER TABLE ADD COLUMN`-Migrationen für die neuen
-  Facettenfelder (`sender`, `mailbox`, `attachment_type`, `tag`) — Manticore
-  erlaubt nur eine Spalte je ALTER-Anweisung. `EnsureSchema` wendet sie
-  idempotent nach (Fehlertext `"already in schema"` gilt als bereits
-  angewendet, kein Fehlerzustand).
-- `fields.go`: neue statische Feldkonstanten + `FacetFields`-Whitelist
-  (`sender`, `mailbox`, `attachment_type`, `tag`) — einzige Quelle
-  zulässiger Facettendimensionen, kein beliebiger Client-Feldname möglich.
-- `facets.go` — `Client.Facets(ctx, tenantSlug, queryText, filters)`:
-  nutzt Manticores strukturierte `aggs.terms`/`aggs.range`-API (kein
-  dynamischer SQL-Klauselbau). Tenant-Filter + optionale
-  `FacetFilter`-Liste laufen als zusätzliche `equals`-Klauseln in
-  derselben `bool.must`-Liste (Akzeptanzkriterium 2: UND-Verknüpfung).
-  Zeitraum-Facette über feste Buckets (letzte 7 Tage/30 Tage/Jahr/älter)
-  via `aggs.range` auf `sent_at`.
-- `Document` um optionale Facettenfelder erweitert (`Sender`, `Mailbox`,
-  `AttachmentType`, `Tag`).
-- Kein Umbau: `Search`/`Delete`/`Index`-Verhalten aus SRC-01/SRC-03
-  unverändert, `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/
-  `encstorage` unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Facettenzahlen stimmen mit tatsächlicher Treffermenge überein | **bestanden** – `TestFacets_CountsMatchActualHits`: 3 reale Dokumente indexiert, Facette `sender` liefert real `alice@example.com`→2, `bob@example.com`→1, Facette `attachment_type` liefert real `pdf`→2 |
-| 2 | Test: Kombination von drei Filtern liefert korrekt eingeschränkte Treffer | **bestanden** – `TestFacets_ThreeFiltersCombineWithAND`: 4 Dokumente, von denen 3 je genau einen der drei Filter (Sender/Postfach/Anhangstyp) verletzen — nach Kombination aller drei Filter bleibt real genau 1 Treffer übrig |
-| 3 | Test: Facetten eines Mandanten enthalten keine Werte eines anderen | **bestanden** – `TestFacets_TenantSeparation`: identische Feldstruktur bei zwei Mandanten, Facette bei Mandant B enthält real keinen Wert von Mandant A |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -p 1  -> alle Pakete bestanden, inkl. internal/search (10 Tests,
-  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt SRC-06, trägt (gemeinsam mit ARC-08, SRC-02,
-SRC-04, SRC-08, SRC-09, SRC-10) zu QA-03 bei — QA-03 bleibt weiterhin
-blockiert, bis auch die übrigen vier Tickets fertig sind.

mail/docs/SRC-06-PRUEFPROTOKOLL.md

@@ -1,60 +0,0 @@
-# SRC-06 – Prüfprotokoll: Facetten-UI & Filter-Chips
-
-Voraussetzung SRC-05 (Fertig), SHL-01 (Core-Board, Fertig).
-
-## Umsetzung
-
-- `web/mail-search/app/api/facets/route.ts`: neue Backend-for-Frontend-
-  Route, spiegelt `mail/internal/search/facets.go` (`Client.Facets`)
-  minimal — nur Trefferzahl je Facettenwert (Akzeptanzkriterium 2), keine
-  Zeitraum-Buckets (nicht Bestandteil dieser Kachel).
-- `web/mail-search/lib/manticoreQuery.ts`: gemeinsamer, statischer
-  `bool.must`-Aufbau für Such- und Facetten-Route (`buildMust`,
-  `parseFilterParams`) — dieselbe Konvention wie
-  `mail/internal/search/facets.go` `buildFilteredMust`, kein
-  Sprintf/Join-artiger Klauselbau.
-- `app/api/search/route.ts` (SRC-04) minimal erweitert: akzeptiert jetzt
-  wiederholbare `?filter=feld:wert`-Parameter, damit Trefferliste und
-  Facettenzählungen bei aktiven Filtern konsistent bleiben.
-- `app/FacetPanel.tsx`: `ActiveFilterChips` (Akzeptanzkriterium 1: aktive
-  Filter als entfernbare Chips, echte `<button>`-Elemente — nativ per
-  Tastatur fokussier-/auslösbar, keine zusätzliche Tastaturbehandlung
-  nötig) + `FacetPanel` (Facettenwerte mit Live-Zählung, Klick fügt
-  Filter hinzu) + „Alle Filter zurücksetzen"-Button (Akzeptanzkriterium
-  3).
-- `app/page.tsx`: Filterzustand ausgelagert nach `lib/filterState.ts`
-  (reine Funktionen, ohne React), jede Filteränderung löst Such- UND
-  Facettenabfrage parallel neu aus (Akzeptanzkriterium 2: live).
-- Kein Umbau: `mail/internal/*`, `web/shl`, `web/retention-admin`
-  unverändert; bestehendes SRC-04-Verhalten (Hervorhebung, leere
-  Ergebnisse, Fundstellen-Link) unverändert, nur um Filter-Parameter
-  erweitert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Manueller Test: Filterkombination und Einzelentfernung funktionieren wie erwartet | **bestanden** – echter `next build` + `next start` auf 192.168.1.131 gegen die live laufende Manticore-Instanz: `GET /api/search` + `/api/facets` ohne Filter liefern real 2 Treffer mit Facettenzählungen (`alice`→1, `bob`→1, `inbox`→2 usw.), mit `filter=sender:alice@example.com` liefern beide Routen real konsistent genau 1 Treffer und auf 1 reduzierte Facettenzählungen |
-| 2 | Tastaturbedienbarkeit der Filter-Chips geprüft | **bestanden** – automatisiert mit `@testing-library/user-event` (echte Tastatursimulation, kein bloßer Klick): Chip fokussieren (`Tab`-Ziel), `{Enter}` löst real dieselbe Entfernung wie ein Klick aus |
-| 3 | Test mit vielen aktiven Filtern bleibt die Ansicht übersichtlich | **bestanden** – 20 gleichzeitig aktivierte Filter real erzeugen real 20 einzeln erkennbare, nicht zusammengefasste Chips im DOM, kein Absturz, `flexWrap` verhindert horizontales Überlaufen |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-npx tsc --noEmit                              -> clean
-npx next build                                -> Compiled successfully (5 Routen)
-npx vitest run                                -> 4 Testdateien, 19/19 bestanden (8 in app/page.test.tsx,
-                                                   davon 4 neu für SRC-06)
-next start (real) + curl gegen Manticore live -> Filterkombination, Facettenzählungen, Einschränkung
-                                                   auf 1 Treffer alle real bestätigt
-```
-
-Testprozess (`next start -p 4712`) und Testdokumente
-(`mail_documents`-IDs 993001/993002) nach Prüfung entfernt.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt (gemeinsam mit den übrigen QA-09-Abhängigkeiten)
-einen Teil des Wegs zu QA-09 — QA-09 bleibt weiterhin blockiert (QA-02,
-QA-04..QA-08 noch offen).

mail/docs/SRC-07-PRUEFPROTOKOLL.md

@@ -1,69 +0,0 @@
-# SRC-07 – Prüfprotokoll: OCR für Anhänge
-
-Voraussetzung ARC-01, ARC-03 (beide Fertig). SRC-07 ist die direkte
-Vorbedingung für SRC-10 (Spracherkennung & OCR-Qualitätsbewertung), nicht
-nur eine nette Ergänzung — ohne SRC-07 gibt es keinen erkannten Text, den
-SRC-10 mit Sprache/Konfidenz bewerten könnte.
-
-## Umsetzung
-
-- `mail/internal/ocr/ocr.go` — zustandsloses Paket, kennt weder Mandant
-  noch Speicher (dieselbe Bauart wie `mail/internal/crypto`/`dedup`):
-  nimmt Anhangs-Bytes entgegen, liefert erkannten Text zurück. Kein
-  geteilter Zustand zwischen Aufrufen (jeder Aufruf bekommt ein eigenes
-  Temp-Verzeichnis) — Tenant-Trennung ist dadurch strukturell gegeben,
-  nicht nur konventionell: ein Mandant kann prinzipbedingt nie Zwischen-
-  daten eines anderen sehen. Zuordnung des erkannten Textes zum
-  Mail-Suchdokument (Akzeptanzkriterium 2) erfolgt beim Aufrufer über das
-  bereits vorhandene `search.Document.AttachmentText`-Feld (SRC-01) — kein
-  neues Feld nötig.
-  - `ExtractTextFromImage`: ruft `tesseract` (Sprachen `deu+eng`) mit
-    fester Argumentliste auf, kein Shell-String-Zusammenbau.
-  - `HasTextLayer`/`ExtractTextFromPDF`: nutzt `pdftotext`, um eine
-    vorhandene Textebene zu erkennen und direkt zu übernehmen
-    (Akzeptanzkriterium 3) — nur wenn keine Textebene vorhanden ist
-    (< 10 Zeichen), wird über `pdftoppm` (300dpi) jede Seite gerastert und
-    per Tesseract erkannt (Akzeptanzkriterium 1).
-- Bekannten Fehler vermieden (dupliziertes Sprintf-WHERE-Muster aus
-  archivmail, siehe repos-analyse-mail-reuse.md): dieses Paket baut keine
-  SQL-Klauseln — ausschließlich externe Kommandozeilenwerkzeuge mit
-  festen Argumentlisten (`exec.CommandContext`, keine Shell).
-- Kein Umbau: `mail/internal/search`/`dedup`/`indexworker`/`storage`/
-  `crypto`/`encstorage`/`savedsearch` unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Bildanhang mit bekanntem Text liefert erwartete Texterkennung | **bestanden** – `TestExtractTextFromImage_KnownTextRecognized`: reales, über `pdftoppm` gerastertes Bild mit dem Text "Rechnungsnummer 4711", `ExtractTextFromImage` erkennt real beide Wortbestandteile |
-| 2 | Test: PDF mit vorhandener Textebene wird korrekt übersprungen | **bestanden** – `TestExtractTextFromPDF_SkipsOCRWhenTextLayerPresent`: real erzeugtes Vektor-Text-PDF (echte PDF-Textebene, kein Bild), `ExtractTextFromPDF` liefert `OCRPerformed=false` und den Text direkt aus der Textebene |
-| 3 | Durchsatztest bestätigt akzeptable Verarbeitungszeit je Anhang | **bestanden** – `TestExtractTextFromPDF_ThroughputIsAcceptable`: 3 reale Anhänge (Rasterung 300dpi + OCR) in durchschnittlich 3,48s/Anhang (Ziel 8s/Anhang) |
-
-Zusätzlich (Akzeptanzkriterium 1, gescannte PDFs end-zu-Ende):
-`TestExtractTextFromPDF_PerformsOCRWhenNoTextLayer` — ein reales,
-ausschließlich rasterbildbasiertes PDF (kein Textelement, JPEG-Bild via
-`/DCTDecode` eingebettet) wird real per OCR erkannt, `OCRPerformed=true`.
-
-Testfixtures (`testpdf_test.go`) werden vollständig in Go erzeugt (Hand-
-gebautes PDF mit Helvetica-Textebene bzw. eingebettetem JPEG) — keine
-externe Bibliothek, keine Testdateien im Repository, reproduzierbar.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./internal/ocr/... -v  -> 4/4 bestanden (14,99s gesamt)
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle Pakete bestanden, keine Regression
-```
-
-Werkzeugversionen auf 192.168.1.131: `tesseract 5.5.0` (Sprachpakete
-`deu`, `eng`), `pdftotext`/`pdftoppm` (poppler-utils) — bereits vorhanden,
-keine Installation durch diese Sitzung nötig.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt SRC-10.

mail/docs/SRC-08-PRUEFPROTOKOLL.md

@@ -1,59 +0,0 @@
-# SRC-08 – Prüfprotokoll: Gespeicherte Suchanfragen
-
-Voraussetzung SRC-03 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/savedsearch/store.go` — `Store` (Postgres,
-  `mail_saved_searches`): `Save` (Upsert über `UNIQUE(tenant_slug,
-  user_id, name)`, Akzeptanzkriterium 1), `List`/`Get` streng auf
-  Mandant UND Benutzer beschränkt (Akzeptanzkriterium 3), `Delete`
-  löscht genau eine Zeile über `tenant_slug + user_id + id`.
-  „Benutzer" ist bis zu einer zentralen Session-/IAM-Anbindung
-  (Core-Board-Scope) ein vom Aufrufer mitgegebener opaker
-  `userID`-String — dieselbe Konvention wie der Tenant-Kontext in
-  `web/mail-search` (SRC-04).
-- `Execute(ctx, client, saved)` führt die gespeicherte Suche LIVE gegen
-  `search.Client` aus — speichert selbst keine Treffer, jeder Aufruf
-  fragt Manticore neu ab (Akzeptanzkriterium 2).
-- `mail/internal/search/facets.go` — kleinste nötige Erweiterung: neue
-  Methode `Client.SearchWithFilters` (gemeinsame `buildFilteredMust`-
-  Hilfsfunktion mit `Facets` extrahiert) liefert TATSÄCHLICH gefilterte
-  Treffer statt nur Facettenzählungen — ohne dies gäbe es keinen echten
-  Weg, gespeicherte Filter beim Wiederausführen anzuwenden.
-- Kein Umbau: `Search`/`Facets`/`Index`/`Delete`-Verhalten sonst
-  unverändert, `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/
-  `encstorage` unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: gespeicherte Suche mit mehreren Filtern wird korrekt reproduziert | **bestanden** – `TestExecute_SavedSearchWithMultipleFiltersReproducesCorrectly`: 3 Dokumente, 2 Filter (Sender+Postfach) gespeichert, `Execute` liefert real genau das eine Dokument, das beide Filter erfüllt |
-| 2 | Test: Benutzer sieht keine gespeicherten Suchen anderer Mandanten | **bestanden** – `TestList_UserSeesNoOtherTenantsSavedSearches`: zwei Mandanten mit je einer gespeicherten Suche, `List` bei Mandant B liefert real nur die eigene, nicht die von Mandant A |
-| 3 | Test: Löschen einer gespeicherten Suche entfernt nur diese | **bestanden** – `TestDelete_RemovesOnlyThatSavedSearch`: zwei gespeicherte Suchen, eine gelöscht, `Get` liefert für die gelöschte real `ErrNotFound`, die andere bleibt real unverändert abrufbar |
-
-Zusätzlich (Akzeptanzkriterium 2, kein eingefrorener Snapshot):
-`TestExecute_ReturnsCurrentResultsNotFrozenSnapshot` — Ausführung vor
-einer neuen Indexierung liefert real 0 Treffer, danach real 1 Treffer,
-ohne dass die gespeicherte Suche selbst verändert wurde.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -p 1  -> alle Pakete bestanden, inkl. internal/savedsearch (4 Tests, neu),
-  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate/
-  crypto/search
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt (gemeinsam mit ARC-08, SRC-02, SRC-04, SRC-05,
-SRC-09) zu QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch
-SRC-10 fertig ist.

mail/docs/SRC-09-PRUEFPROTOKOLL.md

@@ -1,72 +0,0 @@
-# SRC-09 – Prüfprotokoll: Suchindex-Neuaufbau/Reindexierung
-
-Voraussetzung SRC-01 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/search/reindex.go` — `Reindexer.Rebuild(ctx, onProgress)`:
-  1. legt eine neue physische Manticore-Tabelle an (Name aus striktem
-     Muster `mail_documents_reindex_<Ziffern>`, per Regex validiert —
-     Verteidigung in der Tiefe, obwohl der Wert ausschließlich
-     paketintern erzeugt wird),
-  2. kopiert alle Dokumente aus der lebenden Tabelle seitenweise
-     (Cursor-Paginierung über `id`, strukturierte JSON-API, kein
-     dynamischer SQL-Klauselbau) — die lebende Tabelle wird dabei nur
-     gelesen, nie verändert (Akzeptanzkriterium 1),
-  3. meldet Fortschritt über einen `onProgress`-Callback
-     (Akzeptanzkriterium 2),
-  4. vergleicht Trefferzahlen alt/neu — bei Abweichung kein Umschalten,
-  5. schaltet erst danach per Manticore `ALTER TABLE ... RENAME`
-     (reine Metadaten-Operation) atomar um. Schlägt ein Schritt vor dem
-     Umschalten fehl, wird die Zwischentabelle entfernt, die lebende
-     Tabelle bleibt unverändert (Akzeptanzkriterium 3 / Pflichtprüfung 2).
-- Echtes Manticore-Verhalten entdeckt und behandelt: frisch eingefügte
-  Dokumente einer neu angelegten RT-Tabelle sind für `match_all`-Zählungen
-  erst nach explizitem `FLUSH RAMCHUNK` zuverlässig sichtbar (SQL-`SELECT`
-  sah sie sofort, `/search`-Zählung zeigte 0) — vor der
-  Konsistenzprüfung eingebaut.
-- Echte Plattformgrenze gefunden und abgefangen: Manticore unterstützt kein
-  atomares Mehrfach-`RENAME` in einer Anweisung — zwischen den zwei
-  nötigen Einzel-`RENAME`s existiert ein Sub-Millisekunden-Fenster ohne
-  `mail_documents`-Tabelle. `Client.Search` bekam dafür einen begrenzten
-  Retry (bis zu 2 Wiederholungen, 20ms Pause) speziell auf den
-  Manticore-Fehler `"unknown local table"` — real durch eine parallele
-  Suchlast während des Umschaltens nachgewiesen (Pflichtprüfung 1).
-- Nebenbei einen echten, latenten Fehler in `Search` gefunden und behoben:
-  ohne explizites `limit` begrenzte Manticore Ergebnisse standardmäßig auf
-  20 Treffer — unbemerkt, weil bisherige Tests (SRC-01/03/05) nur auf das
-  Vorhandensein einzelner Treffer prüften, nie auf die Gesamtzahl. Jetzt
-  `searchResultLimit = 1000`.
-- Kein Umbau: `Index`/`Delete`/`Facets`-Verhalten sonst unverändert,
-  `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/`encstorage`
-  unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test: Reindex während laufender Suchanfragen unterbricht die Suche nicht | **bestanden** – `TestRebuild_SearchKeepsWorkingDuringReindex`: 30 reale Dokumente indexiert, parallele Sucher-Goroutine (alle 2ms) läuft während `Rebuild` mit — 0 fehlgeschlagene Suchen über den gesamten Umschaltvorgang, danach weiterhin real alle 30 Treffer auffindbar |
-| 2 | Test: abgebrochener Reindex hinterlässt keinen inkonsistenten Zustand | **bestanden** – `TestRebuild_AbortedReindexLeavesNoInconsistentState`: Kontext vor `Rebuild` abgebrochen, Fehler kommt real zurück, lebende Tabelle bleibt danach unverändert (weiterhin 1 Treffer real auffindbar), keine verwaisten Zwischentabellen über `SHOW TABLES` real bestätigt |
-| 3 | Stichprobenvergleich Alt-/Neuindex bestätigt gleiche Trefferzahlen | **bestanden** – `TestRebuild_SampleComparisonMatchesOldAndNewIndex`: 3 unterschiedliche Suchbegriffe vor und nach Reindex real verglichen, identische Trefferzahlen je Stichprobe |
-
-Zusätzlich (Akzeptanzkriterium 2): `TestRebuild_ReportsProgress` bestätigt
-reale Fortschrittsmeldungen bis zum vollständigen Abschluss.
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
-TEST_MANTICORE_URL=http://127.0.0.1:9308 \
-  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (14 Tests,
-  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Trägt (gemeinsam mit ARC-08, SRC-02, SRC-04, SRC-05,
-SRC-08, SRC-10) zu QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch
-ARC-08, SRC-08 und SRC-10 fertig sind.

mail/docs/SRC-10-PRUEFPROTOKOLL.md

@@ -1,57 +0,0 @@
-# SRC-10 – Prüfprotokoll: Spracherkennung & OCR-Qualitätsbewertung
-
-Voraussetzung SRC-07 (Fertig).
-
-## Umsetzung
-
-- `mail/internal/ocr/language.go` — `RecognizeWithLanguageAndConfidence`:
-  Tesseract erkennt bei kombinierten Sprachpaketen (`deu+eng`) nicht,
-  WELCHE Sprache vorlag — daher wird das Bild bewusst EINZELN mit jedem
-  Kandidaten (`deu`, `eng`) im TSV-Ausgabemodus erkannt; die Sprache mit
-  dem höheren durchschnittlichen Worterkennungs-Konfidenzwert gewinnt
-  (Akzeptanzkriterium 1). Derselbe Tesseract-TSV-Lauf liefert den
-  Konfidenzwert direkt mit (Akzeptanzkriterium 2, 0–100, Mittelwert über
-  alle erkannten Wörter) — keine zweite externe Bibliothek nötig.
-- `mail/internal/search`: neue Felder `ocr_language`/`ocr_confidence`
-  (Migrationen 0006/0007, gleiches ALTER-Muster wie SRC-05), in
-  `Document`/`Result` gespiegelt (Akzeptanzkriterium 1: für Anzeige
-  nutzbar). Neue Methode `Client.AttachmentsBelowConfidence(ctx,
-  tenantSlug, threshold)` (Akzeptanzkriterium 3: gezielt für manuelle
-  Nachbearbeitung auffindbar) — filtert `ocr_confidence < threshold`,
-  schließt Dokumente ohne OCR-Anhang (`ocr_confidence` bleibt 0) explizit
-  aus.
-- Echten Regressionsbug beim eigenen Testlauf gefunden und behoben:
-  `reindex.go`s `buildCreateTableSQL` (SRC-09) kannte die neuen
-  OCR-Spalten nicht — ein Reindex nach dieser Kachel wäre mit "unknown
-  column" fehlgeschlagen. Jetzt ergänzt, mit Wartungshinweis im
-  Quelltext für künftige Schema-Erweiterungen.
-- Kein Umbau: `Search`/`Facets`/`SearchWithFilters`/`Index`/`Delete`-
-  Verhalten sonst unverändert, `mail/internal/dedup`/`indexworker`/
-  `storage`/`crypto`/`encstorage`/`savedsearch` unverändert.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Test mit mehrsprachigem Testkorpus bestätigt korrekte Spracherkennung | **bestanden** – `TestRecognizeWithLanguageAndConfidence_MultilingualCorpus`: reales deutsches Testbild ("Rechnung ueber Lieferung...") real als `deu` erkannt, reales englisches Testbild ("Invoice for delivery...") real als `eng` erkannt |
-| 2 | Test: künstlich verschlechtertes Bild erzeugt niedrigeren Konfidenzwert | **bestanden** – `TestRecognizeWithLanguageAndConfidence_DegradedImageLowersConfidence`: reproduzierbare Pixelierung + Kontrastreduktion (reiner Go-Standardbibliothekscode, kein externes Werkzeug) senkt den real gemessenen Konfidenzwert von 91,76 auf 28,21 |
-| 3 | Abfrage aller Anhänge unterhalb einer Konfidenzschwelle liefert erwartete Treffer | **bestanden** – `TestAttachmentsBelowConfidence_QueryReturnsExpectedResults`: 4 Dokumente (2 niedrig-, 1 hoch-konfident, 1 ohne OCR-Anhang), Abfrage mit Schwelle 50 liefert real genau die 2 niedrig-konfidenten, weder den hoch-konfidenten noch den ohne OCR-Anhang |
-
-## Build/Test-Ergebnis (192.168.1.131)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./internal/ocr/... -v -run 'Language|Degraded'  -> 2/2 bestanden
-TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
-  -> alle Pakete bestanden (Regressionsbug in reindex.go vor diesem
-  Protokoll gefunden und behoben, danach vollständig grün)
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt. Entsperrt QA-03 (gemeinsam mit ARC-08, SRC-02, SRC-04,
-SRC-05, SRC-08, SRC-09 — alle jetzt Fertig, letzte fehlende
-Abhängigkeit).

mail/docs/SRC-11-PRUEFPROTOKOLL.md

@@ -1,105 +0,0 @@
-# SRC-11 — Feld-Whitelist-Query-Builder für Suchindex-Zugriff: Prüfprotokoll
-
-Datum: 2026-09-01
-Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
-Paket: `mail/internal/search` (`fields.go`, `facets.go`)
-
-## Umsetzung
-
-Grundlage war bereits vorhanden (SRC-01/SRC-05): statische `FieldXxx`-
-Konstanten in `fields.go`, Suchanfragen ausschließlich über Manticores
-strukturierte HTTP-JSON-API (kein SQL-String-Zusammenbau). Was fehlte,
-war Akzeptanzkriterium 2: die Facetten-Whitelist war eine `[]string`
-(`FacetFields`), gegen die `isFacetField` per Schleife prüfte — eine
-klassische "Whitelist-Funktion", genau das Muster, das
-`known-issues-archivmail.md` #12 und `known-issues-archivdms.md` #10
-als unzureichend benennen (ein vergessener/fehlerhafter Eintrag in der
-Liste lässt unbemerkt alles durch).
-
-**Neu:** `FacetField` ist ein eigener, geschlossener Typ (`fields.go`).
-`FacetField.IsValid()` entscheidet über ein erschöpfendes `switch/case`
-auf den vier Konstanten (`FacetFieldSender`, `FacetFieldMailbox`,
-`FacetFieldAttachmentType`, `FacetFieldTag`) — keine Liste mehr, die
-durchsucht wird und die man vergessen könnte zu pflegen.
-`ParseFacetField` ist die einzige vorgesehene Stelle, um aus einer
-externen Zeichenkette (z. B. künftig ein HTTP-Query-Parameter) ein
-`FacetField` zu machen. `FacetFilter.Field` ist jetzt `FacetField` statt
-`string`. `buildFilteredMust` (einzige Stelle, die Filter-Feldnamen in
-eine Suchanfrage einbaut) prüft `f.Field.IsValid()` statt
-Listenmitgliedschaft.
-
-`isFacetField` (die alte Listenfunktion) ist entfernt — es gibt keine
-Liste mehr, die die Zulässigkeitsentscheidung trifft, nur noch das
-`switch/case` in `IsValid()`.
-
-## Pflichtprüfung 1: Versuch, ein nicht in der Whitelist enthaltenes Feld anzufragen, wird abgewiesen statt stillschweigend ignoriert
-
-`TestBuildFilteredMust_RejectsUnknownField`
-(`search/src11_test.go`): zwei Fälle — ein reales Suchfeld, das aber
-KEIN Facettenfeld ist (`tenant_slug`), und ein frei erfundenes Feld
-(inkl. eines absichtlich SQL-injection-artigen Strings, um zu zeigen,
-dass er nicht einmal in die Fehlermeldung unverarbeitet "verschwindet",
-sondern sauber als Fehler zurückkommt) — beide werden mit Fehler
-abgelehnt, kein stillschweigendes Ignorieren.
-`TestBuildFilteredMust_AcceptsAllWhitelistedFields` stellt sicher, dass
-die Prüfung nicht zu streng ist (alle vier realen Facettenfelder
-funktionieren).
-
-Ergebnis: **BESTANDEN**.
-
-## Pflichtprüfung 2: Code-Review bestätigt: kein dynamischer Spalten-/Tabellenname wird per String-Zusammenbau erzeugt
-
-`TestNoDynamicFieldNameConstruction` (`search/src11_test.go`):
-automatisiertes Code-Review — `facets.go` und `fields.go` enthalten in
-keiner Codezeile (Kommentarzeilen ausgenommen, dort nur erklärender
-Text über den zu vermeidenden Fehler) ein `fmt.Sprintf`. Ergänzt um
-`TestFacetField_ClosedSetEvenViaDirectTypeConversion`
-(Akzeptanzkriterium 2 wörtlich: die Whitelist ist NICHT die einzige
-Absicherung — selbst ein `FacetField`-Wert, der nicht über
-`ParseFacetField` entstanden ist, sondern durch direkte
-Typkonvertierung, wird von `IsValid()` zuverlässig abgelehnt) und
-`TestParseFacetField_OnlyAcceptsKnownStrings`.
-
-Ergebnis: **BESTANDEN**.
-
-## Akzeptanzkriterien
-
-1. **Spalten-/Feldnamen für dynamische Query-Teile stammen
-   ausschließlich aus statischen Konstanten bzw. einem geschlossenen
-   Enum/Switch-Typ**: `FacetField` + die vier `FacetFieldXxx`-Konstanten,
-   durch Pflichtprüfung 2 belegt.
-2. **Whitelist ist nicht die einzige Absicherung**: `IsValid()` ist ein
-   erschöpfendes `switch/case`, keine Listen-Iteration mehr — durch
-   Pflichtprüfung 1+2 belegt.
-3. **Entscheidung dokumentiert: Mail-eigene Implementierung, keine
-   geteilte Utility mit dem DMS-Board**: siehe unten.
-
-### Zu Akzeptanzkriterium 3
-
-Diese Kachel implementiert den Query-Builder ausschließlich innerhalb
-von `mail/internal/search` — keine neue geteilte Utility mit dem
-DMS-Board angelegt. Konsistent mit der bereits im Ticket-Prompt
-genannten, vorab getroffenen Entscheidung
-(`nexarch-state.json` → `bewusst_nicht_zentralisiert`), Suche/OCR
-zwischen Mail und DMS nicht zu zentralisieren.
-
-## Build/Vet/Lint/Test — Gesamtmodul
-
-```
-go build ./...    → OK
-go vet ./...      → OK
-golangci-lint run ./... → 0 issues
-go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok
-```
-
-Keine Regression — insbesondere `mail/internal/savedsearch` (Konsument
-von `search.FacetFilter`) unverändert grün: die Typänderung von
-`Field string` zu `Field FacetField` ist für bestehende Aufrufer, die
-den untypisierten String-Konstanten `FieldSender` usw. übergeben,
-verhalten sich unverändert (Go erlaubt die implizite Umwandlung
-untypisierter Konstanten).
-
-## Ergebnis
-
-SRC-11 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
-Nachweisen. Freigeschaltet: QA-04 (zusammen mit ARC-06).

mail/docs/TESTSTRATEGIE-MAIL.md

@@ -1,110 +0,0 @@
-# NEXARCH Mail – Teststrategie
-
-Stand: 2026-08-30. Ticket: QA-01. Vorbild: Core `QA-01` (`docs/TESTSTRATEGIE-CORE.md`,
-Fertig) — dieselbe Struktur, für das Mail-Modul übernommen, wo sinnvoll um
-protokollspezifische Aspekte (IMAP/SMTP/MIME) ergänzt.
-
-## 1. Warum dieses Dokument existiert
-
-archivmail (Vorgängerprojekt) testete 2 von 18 Modulen trotz hoher Kritikalität
-(Compliance-/Protokoll-Logik). Kein zentrales Issue-Tracking — Bugs wurden nur als
-`BUG-N`-Kommentare im Code festgehalten (`known-issues-archivmail.md`). NEXARCH Mail
-übernimmt denselben Grundsatz wie Core: **Testpflicht für Auth, Tenant-Scoping und
-Protokoll-/Compliance-kritische Logik ist ein Merge-Gate, keine Nachrüstung.**
-
-## 2. Testpyramide
-
-| Ebene | Werkzeug | Umfang |
-|---|---|---|
-| Unit | `go test` (Standardbibliothek) | Einzelne Funktionen/Typen, keine externe Abhängigkeit (DB, Netzwerk, IMAP/SMTP-Socket) |
-| Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Objekt-Speicher |
-| Protokoll-Zustandsmaschinen | `go test` gegen echten IMAP-/SMTP-Client-Roundtrip (kein reiner Parser-Unit-Test) | ING-01/ING-02/ING-03: Login-Zustände, Befehlssequenzen, Fehlerpfade |
-| E2E | Echter HTTP-Roundtrip (`httptest.Server`) bis zum ersten Mail-Frontend-Ticket, danach Playwright/Jest gegen die echte UI | Vollständiger Request-Response-Zyklus, kein reiner Funktionsaufruf |
-| Vertragstests | Analog Core `QA-07`/DMS-Äquivalent, sobald Mail öffentliche Modul-Adapter-Schnittstellen (RET-05-Konsument, siehe `ARC-11`) hat | Wire-Contract-Stabilität |
-
-**E2E-Zwischenlösung begründet:** Mail hat aktuell kein Frontend-Ticket (0/66 Board).
-Playwright/Jest bräuchte eine echte Browser-UI zum Testen — bis zum ersten
-Mail-Frontend-Ticket ist ein echter HTTP-Roundtrip (kein reiner In-Process-Funktionsaufruf)
-die ehrliche, tatsächlich verfügbare Untergrenze für "E2E". Siehe Beispiel in
-Abschnitt 3.
-
-## 3. Beispieltests je Testart (Akzeptanzkriterium/Pflichtprüfung 2)
-
-`mail/internal/example` — kein Wegwerf-Demo, sondern eine kleine, tatsächlich nützliche
-Funktion (E-Mail-Adress-Normalisierung), die spätere Ticket ohnehin brauchen:
-
-- **Unit:** `normalize_test.go` — `TestNormalizeAddress_*`, keine externe Abhängigkeit.
-- **Integration:** `store_integration_test.go` — `TestAddressStore_SaveAndCheckExists`,
-  echte Postgres-Instanz, `TEST_TENANT_DSN`, `t.Cleanup`.
-- **E2E:** `handler_e2e_test.go` — `TestNormalizeHandler_RealHTTPRoundTrip`, echter
-  `httptest.Server`-Roundtrip (TCP, nicht nur Funktionsaufruf).
-
-Alle sechs Tests real ausgeführt (siehe Prüfungen, Abschnitt 6).
-
-## 4. Pflichttests als Merge-Gate (Akzeptanzkriterium 3/4)
-
-Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
-
-- **Auth** (`mail/internal/auth/` — sobald durch ein späteres Ticket angelegt)
-- **Tenant-Scoping** (`mail/internal/tenant/`, jede Repository-Schicht mit Mandanten-Bezug)
-- **Protokoll-kritisch** (`mail/internal/ingest/`, `mail/internal/imap/`,
-  `mail/internal/smtp/` — Zustandsmaschinen, Auth-Handshakes der Protokolle selbst)
-- **Compliance-kritisch** (`mail/internal/arc/` oder gleichwertig — RET-05-Konsument,
-  Löschung/Archivierung, siehe `ARC-11`)
-
-Regel (identisch zu Core `QA-01`): **jede geänderte `.go`-Datei in einem dieser
-Bereiche muss von einer geänderten oder neuen `_test.go`-Datei im selben Package
-begleitet sein.**
-
-`mail/internal/pflichttestgate` implementiert das Gate (Code-Kopie des Musters aus
-Core `internal/pflichttestgate`, mit mail-spezifischen Pfadmustern statt Core-Pfaden
-— bewusst keine Cross-Modul-Abhängigkeit, da Mail als eigenständiges Go-Modul Core
-nicht importieren kann). `.gitea/workflows/mail-pflichttest-gate.yml` führt es gegen
-jeden PR-Diff aus.
-
-Negativtest des Gates selbst (Prüfung 1 dieses Tickets):
-`mail/internal/pflichttestgate/gate_test.go` simuliert einen Diff mit geänderter
-`mail/internal/auth/login.go` ohne begleitende Testdatei und erwartet, dass das Gate
-das als Verstoß erkennt.
-
-## 5. Bug-Tracking (Akzeptanzkriterium 3)
-
-**Konvention: Gitea-Issues** auf `gitea.perlbach24.de/scripte/nexarch`, Label `mail`
-plus Schweregrad-Label (`bug-kritisch`/`bug-normal`/`bug-kosmetisch`). Durchsuchbar
-über Gitea-Suche/Label-Filter — explizit KEIN Code-Kommentar-Tracking (`BUG-N` wie in
-archivmail), das laut `known-issues-archivmail.md` genau diese Sichtbarkeitslücke
-verursacht hat.
-
-**Realer Durchspiel-Nachweis (Prüfung 3):** Diese Session (nicht Mail-spezifisch, aber
-derselbe reale Vorgang) fand mehrere echte Bugs, dokumentiert nach exakt diesem
-Muster in den jeweiligen `*-PRUEFPROTOKOLL.md`-Dateien statt als Code-Kommentar, z. B.
-`archive/docs/RET-10-PRUEFPROTOKOLL.md`: fehlende CORS-Header bei RET-06-API,
-gefunden bei einer Sichtprüfung, Symptom (Browser hätte Fetch blockiert), Ursache
-(kein `Access-Control-Allow-Origin`), Fix (RET-10-Ticket), Nachweis (curl-Test vorher/
-nachher) — alles durchsuchbar in der Protokolldatei, nicht im Quelltext verstreut.
-
-**Ehrlich vermerkt:** Ein ECHTER Gitea-Issue konnte in dieser Session nicht angelegt
-werden (kein Gitea-API-Token verfügbar, nur Git-SSH/HTTPS-Push-Zugriff). Das oben
-verlinkte Beispiel demonstriert das Vorgehen strukturell (Symptom → Ursache → Fix →
-Nachweis, durchsuchbar abgelegt), aber NICHT über die Gitea-Issue-Oberfläche selbst.
-Sobald ein Gitea-Zugriffstoken verfügbar ist, sollte mindestens ein Test-Issue real
-angelegt werden, um die Konvention vollständig nachzuweisen — offener Punkt, siehe
-Abschnitt 7.
-
-## 6. Prüfungen (real durchgeführt)
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Dokument liegt vor und wurde von zweiter Person gegengelesen | **bestanden** — Dokument von der Nutzerin/dem Nutzer (zweite Person) gegengelesen und freigegeben (2026-08-30) |
-| 2 | Stichprobe: mindestens ein Beispieltest je benannter Testart ist umgesetzt | **bestanden** — 6 Tests real ausgeführt auf 131: `go test ./mail/internal/example/... -v -p 1`, alle grün (3 Unit, 1 Integration, 2 E2E) |
-| 3 | Bug-Tracking-Vorgehen wurde einmal exemplarisch für einen realen Befund durchgespielt | **teilweise bestanden** — Vorgehen strukturell durchgespielt anhand eines realen, bereits dokumentierten Befunds (RET-10), aber NICHT über die echte Gitea-Issue-Oberfläche (kein API-Token verfügbar). Siehe Abschnitt 5, offener Punkt in Abschnitt 7 |
-
-## 7. Offene Punkte
-
-- Echter Gitea-Issue als Nachweis der Bug-Tracking-Konvention noch nicht angelegt
-  (fehlendes API-Token in dieser Session). Sollte nachgeholt werden, sobald Zugriff
-  besteht.
-- `mail/internal/auth/`, `mail/internal/tenant/`, `mail/internal/ingest/` etc. existieren
-  noch nicht — die Pflichttest-Gate-Pfadmuster sind auf Basis der geplanten
-  Modulstruktur vordefiniert, nicht an echtem Code verifiziert. Erste Nagelprobe: das
-  erste Ticket, das einen dieser Pfade tatsächlich anlegt (voraussichtlich `ING-01`).

mail/go.mod

@@ -1,38 +0,0 @@
-module gitea.perlbach24.de/scripte/nexarch/mail
-
-go 1.24
-
-toolchain go1.24.4
-
-require (
-	github.com/aws/aws-sdk-go-v2 v1.45.1
-	github.com/aws/aws-sdk-go-v2/config v1.33.1
-	github.com/aws/aws-sdk-go-v2/credentials v1.20.1
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1
-	github.com/aws/smithy-go v1.28.1
-	github.com/jackc/pgx/v5 v5.6.0
-	golang.org/x/text v0.14.0
-)
-
-require (
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
-	github.com/fsnotify/fsnotify v1.10.1 // 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/crypto v0.17.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.15.0 // indirect
-)

mail/go.sum

@@ -1,68 +0,0 @@
-github.com/aws/aws-sdk-go-v2 v1.45.1 h1:iIoG3NaLhV6UZpPXyPXlDj2I9oS8tV/nMcMnITCC6Ks=
-github.com/aws/aws-sdk-go-v2 v1.45.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 h1:GPRlPwz40I2B2VrBEASOA3Bi77NyeqejNLkifosX0rs=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20/go.mod h1:g7PNzKcsOKWb4fkSRBA7BZVAS6Y8IcxzN+nRohhQ1Q8=
-github.com/aws/aws-sdk-go-v2/config v1.33.1 h1:bq9jze1hQ5YTCLoVxNnbp0T7rglrlOE7N9YsHqjGkEw=
-github.com/aws/aws-sdk-go-v2/config v1.33.1/go.mod h1:2A3HQwG4zaL5Tm80rc6RZj8LmWWv4WYT5v8raSz/L7A=
-github.com/aws/aws-sdk-go-v2/credentials v1.20.1 h1:Z8GRNEx0u9sDkZOq4PUnN8mjGwbUQGRzMSXpvt3d8xQ=
-github.com/aws/aws-sdk-go-v2/credentials v1.20.1/go.mod h1:uBIK00kFo95dnemqfFMTWx0X8YRqsh6ecIoCjjOkZqM=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 h1:YIEBqcqRnpi4Pfv0YHImtgi6czGCwKHANC7SwmUAVD0=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1/go.mod h1:imEf0oufgAo8KAkCHhrOdqGEC0YWx1PPBQH82shSxGw=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 h1:pc138gM1CW+XPc60rEwUlwwuwWFQK16CI1T7v1F9Oec=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1/go.mod h1:1+koxpPIbfBdfzP6vojm5/zTpTQ/micYwlxIiNB3TxI=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 h1:K0JsbZQj+1h208Ro1zHeA4l7bMp0NvRffHQ91q8Ol1s=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1/go.mod h1:W3/vL6EtCIatICGy9ab29QhMuae+cOKPWcMxv02CO+Q=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 h1:yhw5KD1phVyP9vijxOUzDfEtJx+bt+L63k+VfuiYFAA=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1/go.mod h1:ZW2e0d7DYlRxlS9hEiMXE47gTdX5KRN4byUiNbUpG+Q=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 h1:s67hBfG5t9rn1NCvDuB4E3QIep3UFhHPtaIqFDjV3N8=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1/go.mod h1:FpvjBMXtSNMLPmDJsWwcY5cRnqJlpS2y1R6n4pvzs4k=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 h1:RmmWQPREQdk9U+PfqeHW3MqZaBaNK7TpV9W3RY+b+7g=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1/go.mod h1:0A3W4F+68ZnNk5XcNL/e9HFMwnP8RlEicFfy6eOEDyw=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 h1:ZMbtPZZQRca+3+XYQne9PBvRiYpHZlNJJOZfE9WNfT0=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1/go.mod h1:YAGWQdCYlVCoqrzvfv3RLxO6zKwti7gsAULOGWPLYv4=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1 h1:kVpzaDBzOdRtOftmiSpTdQbWVqRg0kONLXijktiwXnk=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1/go.mod h1:CUr46sCpGAg/rHaclRyhJX0LJAmH73uWSJPPSaMUrSk=
-github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 h1:mdMtSVKdQ3+mzBh+l0ogrFYZVQUCg6pJZOirA2ARsYE=
-github.com/aws/aws-sdk-go-v2/service/signin v1.7.1/go.mod h1:9IqUlsJDbUPcg6cgx3WEzXdjrbWzLDQrak0aaSqlTcI=
-github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 h1:B6WFn91tobD6gG4724ONHaqrpKsoETGnv98LHe/yIGM=
-github.com/aws/aws-sdk-go-v2/service/sso v1.35.1/go.mod h1:tWuiVBUtPBr8/rgRiYS8Uf85sHcAN+G7XS3D3CEoUh8=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 h1:6yeYCWFvgbI2TI3K6jr9LtBNhXgJ7g4xqD+DEiaDDmM=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1/go.mod h1:naFe83jSMuYkH+QjQPX8n1MLhBkeCFM5Lsnh5m5wz3c=
-github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 h1:Sv2xPnRHlThSUtVujYuUBPI/Il8si6UPHXL8DMiB/F0=
-github.com/aws/aws-sdk-go-v2/service/sts v1.47.1/go.mod h1:mKo/CzaCz8qytGW70NG4vIIGAx1HXTlb5lHNkC5k3lk=
-github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ=
-github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
-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/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
-github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
-github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
-github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
-github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
-github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
-github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
-golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
-golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mail/internal/attachments/attachments.go

@@ -1,109 +0,0 @@
-// Package attachments implementiert IMP-02: Anhänge aus importierten
-// Nachrichten extrahieren, validieren und für die Weiterverarbeitung
-// (Speicherung, Virenscan — beides spätere Kacheln, siehe "Nicht
-// Bestandteil dieser Kachel") bereitstellen. Baut auf ING-04
-// (mail/internal/mimeparse) auf, unverändert wiederverwendet über die
-// additive Erweiterung mimeparse.ParseTolerant — kein Umbau der
-// bestehenden, fertigen ING-04-Logik.
-package attachments
-
-import (
-	"io"
-	"net/http"
-
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mimeparse"
-)
-
-// Attachment ist EIN extrahierter, validierter Anhang
-// (Akzeptanzkriterium 1: Originaldateiname, Größe, geprüfter
-// Content-Type).
-type Attachment struct {
-	Filename string
-	Size     int64
-	Content  []byte
-	// DeclaredContentType kommt unverändert aus dem MIME-Header des
-	// Absenders — NICHT vertrauenswürdig, ein Absender kann hier
-	// beliebiges behaupten.
-	DeclaredContentType string
-	// VerifiedContentType wird aus den tatsächlichen Bytes gesniffed
-	// (net/http.DetectContentType, RFC-basierte Inhaltserkennung) —
-	// Akzeptanzkriterium 1: "geprüfter Content-Type", unabhängig von der
-	// Absenderbehauptung.
-	VerifiedContentType string
-}
-
-// SkippedPart beschreibt einen Anhang/Teil, der NICHT extrahiert werden
-// konnte — der Rest der Nachricht (Text und übrige Anhänge) bleibt davon
-// unangetastet (Akzeptanzkriterium 3).
-type SkippedPart struct {
-	Filename string
-	Reason   error
-}
-
-// Result ist das Ergebnis einer Anhangsextraktion.
-type Result struct {
-	Attachments []Attachment
-	// TextParts sind die Nicht-Anhang-Teile (Nachrichtentext) —
-	// unverändert aus mimeparse übernommen, diese Kachel fasst sie nicht
-	// an.
-	TextParts []mimeparse.Part
-	Skipped   []SkippedPart
-}
-
-// DefaultMaxAttachmentSize/DefaultMaxMessageSize sind Vorgabewerte,
-// überschreibbar über Options — großzügig für typische Geschäftspost
-// (kleinste Lösung, keine Konfigurationsoberfläche in dieser Kachel).
-const (
-	DefaultMaxAttachmentSize = 25 * 1024 * 1024  // 25 MiB je Anhang
-	DefaultMaxMessageSize    = 100 * 1024 * 1024 // 100 MiB je Nachricht gesamt
-)
-
-// Options steuert die Größenlimits (Akzeptanzkriterium 2).
-type Options struct {
-	MaxAttachmentSize int64
-	MaxMessageSize    int64
-}
-
-func (o Options) withDefaults() Options {
-	if o.MaxAttachmentSize <= 0 {
-		o.MaxAttachmentSize = DefaultMaxAttachmentSize
-	}
-	if o.MaxMessageSize <= 0 {
-		o.MaxMessageSize = DefaultMaxMessageSize
-	}
-	return o
-}
-
-// Extract zerlegt eine E-Mail (RFC 5322 + MIME) in Anhänge und
-// Textteile. Ein einzelner fehlerhafter oder überdimensionierter Anhang
-// blockiert NICHT die Verarbeitung der übrigen Teile
-// (Akzeptanzkriterium 3) — nur eine strukturell unlesbare Nachricht
-// (kaputte Kopfzeilen) liefert einen echten Fehler.
-func Extract(r io.Reader, opts Options) (Result, error) {
-	opts = opts.withDefaults()
-
-	msg, partErrors, err := mimeparse.ParseTolerant(r, opts.MaxAttachmentSize, opts.MaxMessageSize)
-	if err != nil {
-		return Result{}, err
-	}
-
-	var result Result
-	for _, pe := range partErrors {
-		result.Skipped = append(result.Skipped, SkippedPart{Filename: pe.Filename, Reason: pe.Err})
-	}
-
-	for _, part := range msg.Parts {
-		if !part.IsAttachment {
-			result.TextParts = append(result.TextParts, part)
-			continue
-		}
-		result.Attachments = append(result.Attachments, Attachment{
-			Filename:            part.Filename,
-			Size:                part.Size,
-			Content:             part.Content,
-			DeclaredContentType: part.ContentType,
-			VerifiedContentType: http.DetectContentType(part.Content),
-		})
-	}
-	return result, nil
-}

mail/internal/attachments/attachments_test.go

@@ -1,139 +0,0 @@
-package attachments
-
-import (
-	"encoding/base64"
-	"strings"
-	"testing"
-)
-
-// TestExtract_OversizedAttachmentIsCorrectlyLimited ist die geforderte
-// Pflichtprüfung 1: Nachricht mit überdimensioniertem Anhang wird
-// korrekt begrenzt.
-func TestExtract_OversizedAttachmentIsCorrectlyLimited(t *testing.T) {
-	oversized := strings.Repeat("A", 200)
-	raw := "From: a@example.com\r\n" +
-		"To: b@example.com\r\n" +
-		"Subject: Test\r\n" +
-		"MIME-Version: 1.0\r\n" +
-		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
-		"--b\r\n" +
-		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
-		"Kurzer Nachrichtentext\r\n" +
-		"--b\r\n" +
-		"Content-Type: application/octet-stream\r\n" +
-		"Content-Disposition: attachment; filename=\"riesig.bin\"\r\n\r\n" +
-		oversized + "\r\n" +
-		"--b--\r\n"
-
-	result, err := Extract(strings.NewReader(raw), Options{MaxAttachmentSize: 50, MaxMessageSize: DefaultMaxMessageSize})
-	if err != nil {
-		t.Fatalf("extract: %v", err)
-	}
-	if len(result.Attachments) != 0 {
-		t.Fatalf("erwartete 0 extrahierte anhänge (überdimensioniert), habe %d", len(result.Attachments))
-	}
-	if len(result.Skipped) != 1 || result.Skipped[0].Filename != "riesig.bin" {
-		t.Fatalf("erwartete genau 1 übersprungenen anhang 'riesig.bin', habe: %+v", result.Skipped)
-	}
-	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Kurzer Nachrichtentext" {
-		t.Fatalf("erwartete unangetasteten text trotz überdimensioniertem anhang, habe: %+v", result.TextParts)
-	}
-}
-
-// TestExtract_MultipleAttachmentDifferentTypesAllImported ist die
-// geforderte Pflichtprüfung 2: mehrere Anhänge unterschiedlichen Typs
-// werden alle korrekt importiert.
-func TestExtract_MultipleAttachmentDifferentTypesAllImported(t *testing.T) {
-	pdfContent := base64.StdEncoding.EncodeToString([]byte("%PDF-1.4 fake pdf bytes"))
-	pngContent := base64.StdEncoding.EncodeToString([]byte{0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0})
-
-	raw := "From: a@example.com\r\n" +
-		"To: b@example.com\r\n" +
-		"Subject: Test\r\n" +
-		"MIME-Version: 1.0\r\n" +
-		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
-		"--b\r\n" +
-		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
-		"Anbei zwei Anhänge\r\n" +
-		"--b\r\n" +
-		"Content-Type: application/pdf\r\n" +
-		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		pdfContent + "\r\n" +
-		"--b\r\n" +
-		"Content-Type: image/png\r\n" +
-		"Content-Disposition: attachment; filename=\"logo.png\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		pngContent + "\r\n" +
-		"--b--\r\n"
-
-	result, err := Extract(strings.NewReader(raw), Options{})
-	if err != nil {
-		t.Fatalf("extract: %v", err)
-	}
-	if len(result.Attachments) != 2 {
-		t.Fatalf("erwartete 2 extrahierte anhänge, habe %d: %+v", len(result.Attachments), result.Attachments)
-	}
-	byName := map[string]Attachment{}
-	for _, a := range result.Attachments {
-		byName[a.Filename] = a
-	}
-	pdf, ok := byName["rechnung.pdf"]
-	if !ok || pdf.DeclaredContentType != "application/pdf" {
-		t.Fatalf("pdf-anhang fehlt oder falscher deklarierter typ: %+v", byName)
-	}
-	if !strings.Contains(pdf.VerifiedContentType, "text/plain") && !strings.Contains(pdf.VerifiedContentType, "application/") {
-		// http.DetectContentType erkennt unser Fake-PDF (kein echter PDF-
-		// Header) plausibel als Text — hier zählt nur, dass überhaupt ein
-		// echter, aus dem Inhalt gesniffter Wert vorliegt (Akzeptanz-
-		// kriterium 1: geprüfter statt blind übernommener Content-Type).
-		t.Fatalf("erwartete real gesniffeden content-type, habe: %q", pdf.VerifiedContentType)
-	}
-	png, ok := byName["logo.png"]
-	if !ok || png.DeclaredContentType != "image/png" {
-		t.Fatalf("png-anhang fehlt oder falscher deklarierter typ: %+v", byName)
-	}
-	if png.VerifiedContentType != "image/png" {
-		t.Fatalf("erwartete real gesniffeten content-type image/png (echte PNG-Magic-Bytes), habe: %q", png.VerifiedContentType)
-	}
-}
-
-// TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched ist die
-// geforderte Pflichtprüfung 3: ein defekter Anhang lässt Text und übrige
-// Anhänge unangetastet.
-func TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched(t *testing.T) {
-	goodContent := base64.StdEncoding.EncodeToString([]byte("echter anhangsinhalt"))
-	raw := "From: a@example.com\r\n" +
-		"To: b@example.com\r\n" +
-		"Subject: Test\r\n" +
-		"MIME-Version: 1.0\r\n" +
-		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
-		"--b\r\n" +
-		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
-		"Wichtiger Nachrichtentext\r\n" +
-		"--b\r\n" +
-		"Content-Type: application/octet-stream\r\n" +
-		"Content-Disposition: attachment; filename=\"kaputt.bin\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		"DAS_IST_KEIN_GUELTIGES_BASE64!!!\r\n" +
-		"--b\r\n" +
-		"Content-Type: application/octet-stream\r\n" +
-		"Content-Disposition: attachment; filename=\"gut.bin\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		goodContent + "\r\n" +
-		"--b--\r\n"
-
-	result, err := Extract(strings.NewReader(raw), Options{})
-	if err != nil {
-		t.Fatalf("extract: %v", err)
-	}
-	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Wichtiger Nachrichtentext" {
-		t.Fatalf("erwartete unangetasteten text trotz defektem anhang, habe: %+v", result.TextParts)
-	}
-	if len(result.Attachments) != 1 || result.Attachments[0].Filename != "gut.bin" {
-		t.Fatalf("erwartete den guten anhang unangetastet, habe: %+v", result.Attachments)
-	}
-	if string(result.Attachments[0].Content) != "echter anhangsinhalt" {
-		t.Fatalf("guter anhang hat unerwarteten inhalt: %q", result.Attachments[0].Content)
-	}
-}

mail/internal/crypto/envelope.go

@@ -1,118 +0,0 @@
-// Package crypto implementiert ARC-02: Envelope-Encryption für Objekte
-// at rest. Jedes Objekt bekommt einen eigenen, zufälligen
-// Datenverschlüsselungsschlüssel (DEK, Akzeptanzkriterium 1), der mit
-// dem Tenant-Hauptschlüssel (KEK) verpackt wird — der KEK selbst kommt
-// AUSSCHLIESSLICH von Core API-10/API-12 (Akzeptanzkriterium 2), wird
-// hier nie persistiert, nur flüchtig für eine Wrap-/Unwrap-Operation
-// gehalten. Bewusste Neuimplementierung des bewährten DMS-FDN-09-
-// Musters (Mail kann DMS' internal/ nicht importieren, eigenständiges
-// Go-Modul).
-package crypto
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"io"
-)
-
-const (
-	DEKSize = 32
-	KEKSize = 32
-)
-
-// ErrDecryptFailed wird geliefert, wenn ein Chiffretext nicht
-// entschlüsselt werden kann — falscher Schlüssel ODER manipulierte
-// Daten (Pflichtprüfung 2: GCM-Auth-Tag erkennt Manipulation
-// zuverlässig, AEAD unterscheidet die beiden Ursachen bewusst nicht).
-var ErrDecryptFailed = errors.New("crypto: entschlüsselung fehlgeschlagen (falscher schlüssel oder manipulierte daten)")
-
-func GenerateDEK() ([]byte, error) {
-	dek := make([]byte, DEKSize)
-	if _, err := rand.Read(dek); err != nil {
-		return nil, fmt.Errorf("crypto: dek erzeugen: %w", err)
-	}
-	return dek, nil
-}
-
-func seal(key, plaintext []byte) ([]byte, error) {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
-	}
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
-	}
-	nonce := make([]byte, gcm.NonceSize())
-	if _, err := rand.Read(nonce); err != nil {
-		return nil, fmt.Errorf("crypto: nonce erzeugen: %w", err)
-	}
-	return gcm.Seal(nonce, nonce, plaintext, nil), nil
-}
-
-func open(key, sealed []byte) ([]byte, error) {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
-	}
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
-	}
-	if len(sealed) < gcm.NonceSize() {
-		return nil, ErrDecryptFailed
-	}
-	nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
-	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
-	if err != nil {
-		return nil, ErrDecryptFailed
-	}
-	return plaintext, nil
-}
-
-func WrapDEK(kek, dek []byte) ([]byte, error) {
-	wrapped, err := seal(kek, dek)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: dek verpacken: %w", err)
-	}
-	return wrapped, nil
-}
-
-func UnwrapDEK(kek, wrappedDEK []byte) ([]byte, error) {
-	return open(kek, wrappedDEK)
-}
-
-// EncryptStream verschlüsselt den gesamten Inhalt von r mit dek
-// (AES-256-GCM). Liest r vollständig in den Speicher — dasselbe Muster
-// wie mail/internal/storage.S3Driver.Put (ARC-01), das S3-PutObject
-// ebenfalls vollständig puffert; ein segmentiertes AEAD-Verfahren für
-// sehr große Anhänge ist bewusst nicht Teil der "kleinsten Lösung".
-func EncryptStream(dek []byte, r io.Reader) (io.Reader, error) {
-	plaintext, err := io.ReadAll(r)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: klartext lesen: %w", err)
-	}
-	ciphertext, err := seal(dek, plaintext)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: verschlüsseln: %w", err)
-	}
-	return bytes.NewReader(ciphertext), nil
-}
-
-// DecryptStream entschlüsselt einen zuvor mit EncryptStream erzeugten
-// Chiffretext-Stream.
-func DecryptStream(dek []byte, r io.Reader) (io.Reader, error) {
-	ciphertext, err := io.ReadAll(r)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: chiffretext lesen: %w", err)
-	}
-	plaintext, err := open(dek, ciphertext)
-	if err != nil {
-		return nil, err
-	}
-	return bytes.NewReader(plaintext), nil
-}

mail/internal/crypto/kekprovider.go

@@ -1,80 +0,0 @@
-package crypto
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/url"
-)
-
-// KEKProvider liefert den aktuellen, entschlüsselten Tenant-KEK
-// (Akzeptanzkriterium 2: KEK kommt ausschließlich von Core API-10/
-// API-12). Schmale Schnittstelle, damit Tests einen Fake statt eines
-// echten HTTP-Aufrufs einsetzen können.
-type KEKProvider interface {
-	TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error)
-}
-
-// tenantKEKResponse entspricht Core internal/kek.tenantKEKResponse
-// (JSON-Vertrag: tenant_kek_base64) — dieselbe Struktur, hier
-// gespiegelt, da Mail Cores internal/-Pakete nicht importieren kann.
-type tenantKEKResponse struct {
-	TenantKEKBase64 string `json:"tenant_kek_base64"`
-}
-
-// HTTPKEKProvider bezieht den Tenant-KEK über Core API-12
-// (internal/kek.Handler.TenantKEKHandler, echt laufender Dienst),
-// authentifiziert über dasselbe Service-Credential-Verfahren wie jeder
-// andere Modul-Core-Aufruf (API-02) — identisches Muster wie DMS
-// FDN-09/internal/storage.HTTPUsageReporter aus ARC-01.
-type HTTPKEKProvider struct {
-	endpointURL  string
-	clientID     string
-	clientSecret string
-	httpClient   *http.Client
-}
-
-func NewHTTPKEKProvider(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPKEKProvider {
-	if httpClient == nil {
-		httpClient = http.DefaultClient
-	}
-	return &HTTPKEKProvider{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
-}
-
-func (p *HTTPKEKProvider) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error) {
-	u, err := url.Parse(p.endpointURL)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: kek-endpunkt-url ungültig: %w", err)
-	}
-	q := u.Query()
-	q.Set("tenant", tenantSlug)
-	u.RawQuery = q.Encode()
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: kek-anfrage aufbauen: %w", err)
-	}
-	req.Header.Set("X-Nexarch-Client-Id", p.clientID)
-	req.Header.Set("X-Nexarch-Client-Secret", p.clientSecret)
-
-	resp, err := p.httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: kek-anfrage senden: %w", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("crypto: kek-bezug von core abgelehnt: status %d", resp.StatusCode)
-	}
-
-	var body tenantKEKResponse
-	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
-		return nil, fmt.Errorf("crypto: kek-antwort dekodieren: %w", err)
-	}
-	kek, err := base64.StdEncoding.DecodeString(body.TenantKEKBase64)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: kek base64-dekodieren: %w", err)
-	}
-	return kek, nil
-}

mail/internal/crypto/kekversions.go

@@ -1,144 +0,0 @@
-// ARC-08: Tenant-KEK-Rotation. Core (API-10, `internal/kek.Store.
-// RotateTenantKEK`) ersetzt den Tenant-KEK durch einen komplett neuen
-// Wert — Core selbst hält KEINE Historie vor, `TenantKEKHandler` liefert
-// immer nur den AKTUELLEN Schlüssel (siehe kekprovider.go). Damit ARC-08s
-// Akzeptanzkriterium 3 ("alte Schlüsselversionen bleiben für
-// Lesezugriff kontrolliert verfügbar") erfüllbar ist, muss Mail selbst
-// jeden von Core bezogenen Tenant-KEK versioniert zwischenspeichern —
-// KEKVersionStore übernimmt genau das, lokal mit einem eigenen,
-// ausschließlich über Umgebungsvariable bezogenen Wrap-Schlüssel
-// verschlüsselt (kein Klartext-KEK in der Datenbank).
-package crypto
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// ErrKEKVersionNotFound wird geliefert, wenn die angefragte Version für
-// den Mandanten nicht existiert.
-var ErrKEKVersionNotFound = errors.New("crypto: kek-version nicht gefunden")
-
-// ErrKEKVersionRevoked wird geliefert, wenn die angefragte Version gezielt
-// gesperrt wurde (Pflichtprüfung 2: kompromittierter alter Schlüssel kann
-// gezielt gesperrt werden) — der Lesezugriff auf mit dieser Version
-// verschlüsselte Altobjekte ist dann bewusst blockiert.
-var ErrKEKVersionRevoked = errors.New("crypto: kek-version wurde gesperrt")
-
-// KEKVersionStore verwaltet die Versionshistorie der Tenant-KEKs, die
-// dieses Mail-Modul im Lauf der Zeit von Core bezogen hat.
-type KEKVersionStore struct {
-	pool         *pgxpool.Pool
-	localWrapKey []byte
-}
-
-// NewKEKVersionStore erzeugt einen Store. localWrapKey verschlüsselt die
-// zwischengespeicherten Tenant-KEKs lokal at rest (KEKSize Bytes,
-// ausschließlich über Umgebungsvariable bezogen — nie im Code).
-func NewKEKVersionStore(pool *pgxpool.Pool, localWrapKey []byte) *KEKVersionStore {
-	return &KEKVersionStore{pool: pool, localWrapKey: localWrapKey}
-}
-
-// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
-// gleiches Muster wie mail/internal/dedup/indexworker (kein zentraler
-// Migrationsläufer für Mandanten-Datenbanken im Mail-Modul vorhanden).
-func (s *KEKVersionStore) EnsureSchema(ctx context.Context) error {
-	if _, err := s.pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS mail_kek_versions (
-			tenant_slug  TEXT NOT NULL,
-			version      INT NOT NULL,
-			wrapped_kek  BYTEA NOT NULL,
-			revoked      BOOLEAN NOT NULL DEFAULT false,
-			created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-			PRIMARY KEY (tenant_slug, version)
-		)
-	`); err != nil {
-		return fmt.Errorf("crypto: kek-versionsschema anlegen: %w", err)
-	}
-	return nil
-}
-
-// RecordIfNew merkt sich plainKEK als neue Version für tenantSlug, FALLS
-// er sich vom zuletzt gespeicherten Wert unterscheidet (Rotation
-// erkannt) — bei unverändertem KEK wird keine neue Version angelegt,
-// sondern die bestehende Versionsnummer zurückgegeben (Akzeptanzkriterium
-// 1: rotierbar verwaltet, nicht bei jedem Aufruf eine neue Version).
-func (s *KEKVersionStore) RecordIfNew(ctx context.Context, tenantSlug string, plainKEK []byte) (version int, err error) {
-	var latestVersion int
-	var latestWrapped []byte
-	err = s.pool.QueryRow(ctx, `
-		SELECT version, wrapped_kek FROM mail_kek_versions
-		WHERE tenant_slug = $1 ORDER BY version DESC LIMIT 1
-	`, tenantSlug).Scan(&latestVersion, &latestWrapped)
-	switch {
-	case errors.Is(err, pgx.ErrNoRows):
-		return s.insertVersion(ctx, tenantSlug, 1, plainKEK)
-	case err != nil:
-		return 0, fmt.Errorf("crypto: letzte kek-version lesen: %w", err)
-	}
-
-	latestPlain, err := open(s.localWrapKey, latestWrapped)
-	if err != nil {
-		return 0, fmt.Errorf("crypto: zwischengespeicherten kek entpacken: %w", err)
-	}
-	if bytes.Equal(latestPlain, plainKEK) {
-		return latestVersion, nil
-	}
-	return s.insertVersion(ctx, tenantSlug, latestVersion+1, plainKEK)
-}
-
-func (s *KEKVersionStore) insertVersion(ctx context.Context, tenantSlug string, version int, plainKEK []byte) (int, error) {
-	wrapped, err := seal(s.localWrapKey, plainKEK)
-	if err != nil {
-		return 0, fmt.Errorf("crypto: kek für zwischenspeicherung verpacken: %w", err)
-	}
-	if _, err := s.pool.Exec(ctx, `
-		INSERT INTO mail_kek_versions (tenant_slug, version, wrapped_kek) VALUES ($1, $2, $3)
-	`, tenantSlug, version, wrapped); err != nil {
-		return 0, fmt.Errorf("crypto: kek-version speichern: %w", err)
-	}
-	return version, nil
-}
-
-// Get liefert den entschlüsselten historischen Tenant-KEK einer
-// bestimmten Version. Liefert ErrKEKVersionRevoked, wenn die Version
-// gezielt gesperrt wurde (Pflichtprüfung 2).
-func (s *KEKVersionStore) Get(ctx context.Context, tenantSlug string, version int) ([]byte, error) {
-	var wrapped []byte
-	var revoked bool
-	err := s.pool.QueryRow(ctx, `
-		SELECT wrapped_kek, revoked FROM mail_kek_versions
-		WHERE tenant_slug = $1 AND version = $2
-	`, tenantSlug, version).Scan(&wrapped, &revoked)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return nil, ErrKEKVersionNotFound
-		}
-		return nil, fmt.Errorf("crypto: kek-version lesen: %w", err)
-	}
-	if revoked {
-		return nil, ErrKEKVersionRevoked
-	}
-	return open(s.localWrapKey, wrapped)
-}
-
-// Revoke sperrt eine Tenant-KEK-Version gezielt (Pflichtprüfung 2):
-// nachfolgende Get-Aufrufe für genau diese Version schlagen mit
-// ErrKEKVersionRevoked fehl, andere Versionen bleiben unberührt.
-func (s *KEKVersionStore) Revoke(ctx context.Context, tenantSlug string, version int) error {
-	tag, err := s.pool.Exec(ctx, `
-		UPDATE mail_kek_versions SET revoked = true WHERE tenant_slug = $1 AND version = $2
-	`, tenantSlug, version)
-	if err != nil {
-		return fmt.Errorf("crypto: kek-version sperren: %w", err)
-	}
-	if tag.RowsAffected() == 0 {
-		return ErrKEKVersionNotFound
-	}
-	return nil
-}

mail/internal/crypto/kekversions_test.go

@@ -1,111 +0,0 @@
-// Integrationstest (ARC-08): echte Postgres-Instanz, folgt derselben
-// Testhost-Konvention wie mail/internal/dedup/indexworker — TEST_TENANT_DSN.
-package crypto
-
-import (
-	"bytes"
-	"context"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var testLocalWrapKey = bytes.Repeat([]byte{0x7a}, KEKSize)
-
-func setupKEKVersionStore(t *testing.T, tenantSlug string) *KEKVersionStore {
-	t.Helper()
-	dsn := os.Getenv("TEST_TENANT_DSN")
-	if dsn == "" {
-		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
-	}
-	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	t.Cleanup(func() { pool.Close() })
-
-	store := NewKEKVersionStore(pool, testLocalWrapKey)
-	if err := store.EnsureSchema(ctx); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-	t.Cleanup(func() {
-		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_kek_versions WHERE tenant_slug = $1`, tenantSlug)
-	})
-	return store
-}
-
-func TestKEKVersionStore_RecordIfNewDetectsRotationOnly(t *testing.T) {
-	tenant := "mandant-arc08-recordifnew"
-	store := setupKEKVersionStore(t, tenant)
-	ctx := context.Background()
-
-	kekV1 := bytes.Repeat([]byte{0x01}, KEKSize)
-	v1, err := store.RecordIfNew(ctx, tenant, kekV1)
-	if err != nil {
-		t.Fatalf("erste erfassung: %v", err)
-	}
-	if v1 != 1 {
-		t.Fatalf("erwartete version 1, habe %d", v1)
-	}
-
-	// Erneuter Aufruf mit UNVERÄNDERTEM KEK darf keine neue Version anlegen.
-	vAgain, err := store.RecordIfNew(ctx, tenant, kekV1)
-	if err != nil {
-		t.Fatalf("zweite erfassung (unverändert): %v", err)
-	}
-	if vAgain != 1 {
-		t.Fatalf("erwartete weiterhin version 1 bei unverändertem kek, habe %d", vAgain)
-	}
-
-	kekV2 := bytes.Repeat([]byte{0x02}, KEKSize)
-	v2, err := store.RecordIfNew(ctx, tenant, kekV2)
-	if err != nil {
-		t.Fatalf("dritte erfassung (rotiert): %v", err)
-	}
-	if v2 != 2 {
-		t.Fatalf("erwartete version 2 nach rotation, habe %d", v2)
-	}
-
-	gotV1, err := store.Get(ctx, tenant, 1)
-	if err != nil {
-		t.Fatalf("get v1: %v", err)
-	}
-	if !bytes.Equal(gotV1, kekV1) {
-		t.Fatal("v1 liefert nicht den ursprünglichen kek zurück")
-	}
-	gotV2, err := store.Get(ctx, tenant, 2)
-	if err != nil {
-		t.Fatalf("get v2: %v", err)
-	}
-	if !bytes.Equal(gotV2, kekV2) {
-		t.Fatal("v2 liefert nicht den rotierten kek zurück")
-	}
-}
-
-func TestKEKVersionStore_RevokeBlocksOnlyThatVersion(t *testing.T) {
-	tenant := "mandant-arc08-revoke"
-	store := setupKEKVersionStore(t, tenant)
-	ctx := context.Background()
-
-	kekV1 := bytes.Repeat([]byte{0x11}, KEKSize)
-	kekV2 := bytes.Repeat([]byte{0x22}, KEKSize)
-	if _, err := store.RecordIfNew(ctx, tenant, kekV1); err != nil {
-		t.Fatalf("v1 erfassen: %v", err)
-	}
-	if _, err := store.RecordIfNew(ctx, tenant, kekV2); err != nil {
-		t.Fatalf("v2 erfassen: %v", err)
-	}
-
-	if err := store.Revoke(ctx, tenant, 1); err != nil {
-		t.Fatalf("v1 sperren: %v", err)
-	}
-
-	if _, err := store.Get(ctx, tenant, 1); err != ErrKEKVersionRevoked {
-		t.Fatalf("erwartete ErrKEKVersionRevoked für gesperrte version 1, habe: %v", err)
-	}
-	if _, err := store.Get(ctx, tenant, 2); err != nil {
-		t.Fatalf("version 2 sollte unberührt bleiben: %v", err)
-	}
-}

mail/internal/crypto/rotation_test.go

@@ -1,131 +0,0 @@
-// ARC-08: End-zu-Ende-Rotationstest. Nutzt einen fake KEKProvider (echter
-// Testkonvention aus ARC-02, siehe encstorage_test.go) statt eines echten
-// HTTP-Aufrufs an Core API-12 — Core selbst hat keine rotierbare
-// Testschnittstelle über HTTP exponiert (nur der aktuelle KEK ist
-// abrufbar), die Rotation wird hier auf Höhe der KEKProvider-Schnittstelle
-// simuliert, exakt wie ARC-02 es für Fehlerfälle bereits tut.
-package crypto
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// rotatableKEKProvider liefert für einen Mandanten einen aktuell
-// gesetzten KEK, der zur Laufzeit "rotiert" werden kann (simuliert Core
-// API-10s RotateTenantKEK, dessen Effekt auf API-12 exakt darin besteht,
-// dass TenantKEK ab dann einen anderen Wert liefert).
-type rotatableKEKProvider struct {
-	mu      sync.Mutex
-	current []byte
-}
-
-func (p *rotatableKEKProvider) TenantKEK(_ context.Context, _ string) ([]byte, error) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.current, nil
-}
-
-func (p *rotatableKEKProvider) rotate(newKEK []byte) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.current = newKEK
-}
-
-// TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation ist die
-// geforderte Pflichtprüfung 1: Rotation des Hauptschlüssels lässt
-// Altbestand weiterhin lesbar.
-func TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation(t *testing.T) {
-	tenant := "mandant-arc08-rotation-lesbar"
-	store := setupKEKVersionStore(t, tenant)
-	ctx := context.Background()
-
-	provider := &rotatableKEKProvider{current: bytes.Repeat([]byte{0x51}, KEKSize)}
-	svc := NewService(provider).WithVersionStore(store)
-
-	// Objekt VOR der Rotation versiegeln.
-	oldEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("altbestand vor rotation"))
-	if err != nil {
-		t.Fatalf("seal (alt): %v", err)
-	}
-	if oldEnvelope.KEKVersion != 1 {
-		t.Fatalf("erwartete kek-version 1 vor rotation, habe %d", oldEnvelope.KEKVersion)
-	}
-	oldCiphertext, err := io.ReadAll(oldEnvelope.Ciphertext)
-	if err != nil {
-		t.Fatalf("chiffretext (alt) lesen: %v", err)
-	}
-
-	// Core rotiert den Tenant-Hauptschlüssel — TenantKEK liefert ab jetzt
-	// einen komplett anderen Wert, exakt wie internal/kek.Store.
-	// RotateTenantKEK es real bei Core bewirkt.
-	provider.rotate(bytes.Repeat([]byte{0x52}, KEKSize))
-
-	// Objekt NACH der Rotation versiegeln (Akzeptanzkriterium 2: kein
-	// Neuverschlüsseln des Altbestands nötig, nur neue Objekte nutzen den
-	// neuen Schlüssel).
-	newEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("neuer inhalt nach rotation"))
-	if err != nil {
-		t.Fatalf("seal (neu): %v", err)
-	}
-	if newEnvelope.KEKVersion != 2 {
-		t.Fatalf("erwartete kek-version 2 nach rotation, habe %d", newEnvelope.KEKVersion)
-	}
-
-	// Altbestand bleibt über die aufgezeichnete Version lesbar
-	// (Akzeptanzkriterium 3).
-	openedOld, err := svc.OpenAtVersion(ctx, tenant, oldEnvelope.KEKVersion, oldEnvelope.WrappedDEK, bytes.NewReader(oldCiphertext))
-	if err != nil {
-		t.Fatalf("openatversion (alt, nach rotation): %v", err)
-	}
-	plainOld, err := io.ReadAll(openedOld)
-	if err != nil {
-		t.Fatalf("altbestand lesen: %v", err)
-	}
-	if string(plainOld) != "altbestand vor rotation" {
-		t.Fatalf("altbestand-inhalt stimmt nicht, habe %q", string(plainOld))
-	}
-
-	// Der naive Open() (aktueller KEK) darf für das ALTE Objekt inzwischen
-	// NICHT mehr funktionieren — das beweist, dass OpenAtVersion die
-	// Rotation tatsächlich überbrückt, statt zufällig auch so zu klappen.
-	if _, err := svc.Open(ctx, tenant, oldEnvelope.WrappedDEK, bytes.NewReader(oldCiphertext)); err == nil {
-		t.Fatal("erwartete fehler bei Open() des altbestands mit dem NEUEN aktuellen kek, habe nil")
-	}
-}
-
-// TestRotation_CompromisedOldKeyCanBeRevoked ist die geforderte
-// Pflichtprüfung 2: kompromittierter alter Schlüssel kann gezielt
-// gesperrt werden.
-func TestRotation_CompromisedOldKeyCanBeRevoked(t *testing.T) {
-	tenant := "mandant-arc08-revoke-e2e"
-	store := setupKEKVersionStore(t, tenant)
-	ctx := context.Background()
-
-	provider := &rotatableKEKProvider{current: bytes.Repeat([]byte{0x61}, KEKSize)}
-	svc := NewService(provider).WithVersionStore(store)
-
-	compromisedEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("mit kompromittiertem schlüssel versiegelt"))
-	if err != nil {
-		t.Fatalf("seal: %v", err)
-	}
-	compromisedCiphertext, err := io.ReadAll(compromisedEnvelope.Ciphertext)
-	if err != nil {
-		t.Fatalf("chiffretext lesen: %v", err)
-	}
-
-	provider.rotate(bytes.Repeat([]byte{0x62}, KEKSize))
-
-	if err := store.Revoke(ctx, tenant, compromisedEnvelope.KEKVersion); err != nil {
-		t.Fatalf("kompromittierte version sperren: %v", err)
-	}
-
-	_, err = svc.OpenAtVersion(ctx, tenant, compromisedEnvelope.KEKVersion, compromisedEnvelope.WrappedDEK, bytes.NewReader(compromisedCiphertext))
-	if err == nil {
-		t.Fatal("erwartete fehler beim lesen mit gesperrter kek-version, habe nil")
-	}
-}

mail/internal/crypto/service.go

@@ -1,114 +0,0 @@
-package crypto
-
-import (
-	"context"
-	"fmt"
-	"io"
-)
-
-// Envelope ist das Ergebnis einer Seal-Operation: der Chiffretext-
-// Stream plus der mit dem Tenant-KEK verpackte DEK, der zusammen mit
-// dem Objekt persistiert werden muss (siehe mail/internal/encstorage).
-// KEKVersion identifiziert (ARC-08), MIT welcher Tenant-KEK-Version der
-// DEK verpackt wurde — 0, solange kein KEKVersionStore konfiguriert ist
-// (Rückwärtskompatibilität, siehe WithVersionStore).
-type Envelope struct {
-	Ciphertext io.Reader
-	WrappedDEK []byte
-	KEKVersion int
-}
-
-// Service verbindet KEKProvider mit den Envelope-Operationen — Aufrufer
-// (mail/internal/encstorage) rufen ausschließlich Service auf, nie die
-// Einzelfunktionen aus envelope.go direkt.
-type Service struct {
-	kek      KEKProvider
-	versions *KEKVersionStore
-}
-
-func NewService(kek KEKProvider) *Service {
-	return &Service{kek: kek}
-}
-
-// WithVersionStore aktiviert die Tenant-KEK-Versionsverfolgung (ARC-08).
-// Ohne aufgerufenes WithVersionStore verhält sich Service exakt wie vor
-// ARC-08 (KEKVersion bleibt 0, OpenAtVersion fällt auf Open zurück) —
-// bestehende Aufrufer (z. B. encstorage) sind unverändert lauffähig.
-func (s *Service) WithVersionStore(store *KEKVersionStore) *Service {
-	s.versions = store
-	return s
-}
-
-// Seal erzeugt einen neuen DEK (Akzeptanzkriterium 1), verschlüsselt
-// plaintext damit und verpackt den DEK mit dem aktuellen Tenant-KEK
-// (Akzeptanzkriterium 2 — der KEK wird bei JEDEM Aufruf frisch von Core
-// bezogen, nie zwischengespeichert außer in der optionalen
-// KEK-Versionshistorie für spätere Altbestands-Lesezugriffe).
-func (s *Service) Seal(ctx context.Context, tenantSlug string, plaintext io.Reader) (*Envelope, error) {
-	dek, err := GenerateDEK()
-	if err != nil {
-		return nil, err
-	}
-	ciphertext, err := EncryptStream(dek, plaintext)
-	if err != nil {
-		return nil, err
-	}
-	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
-	}
-	wrappedDEK, err := WrapDEK(kek, dek)
-	if err != nil {
-		return nil, err
-	}
-
-	var kekVersion int
-	if s.versions != nil {
-		kekVersion, err = s.versions.RecordIfNew(ctx, tenantSlug, kek)
-		if err != nil {
-			return nil, fmt.Errorf("crypto: kek-version erfassen: %w", err)
-		}
-	}
-
-	return &Envelope{Ciphertext: ciphertext, WrappedDEK: wrappedDEK, KEKVersion: kekVersion}, nil
-}
-
-// Open entpackt den DEK mit dem AKTUELLEN Tenant-KEK (Akzeptanzkriterium
-// 3: nur mit gültigem, mandantenbezogenem Schlüssel möglich — ein
-// falscher Tenant-Slug liefert entweder einen falschen KEK von Core
-// [dann schlägt UnwrapDEK fehl] oder Core verweigert den Zugriff direkt)
-// und entschlüsselt ciphertext damit. Nach einer Tenant-KEK-Rotation bei
-// Core funktioniert Open nur noch für Objekte, die mit dem NEUEN KEK
-// versiegelt wurden — für Altbestand siehe OpenAtVersion.
-func (s *Service) Open(ctx context.Context, tenantSlug string, wrappedDEK []byte, ciphertext io.Reader) (io.Reader, error) {
-	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
-	}
-	dek, err := UnwrapDEK(kek, wrappedDEK)
-	if err != nil {
-		return nil, err
-	}
-	return DecryptStream(dek, ciphertext)
-}
-
-// OpenAtVersion entpackt den DEK mit der beim Seal aufgezeichneten
-// historischen Tenant-KEK-Version statt mit dem aktuellen Core-KEK
-// (ARC-08 Akzeptanzkriterium 3: Altbestand bleibt nach einer
-// Hauptschlüssel-Rotation lesbar). Ist kekVersion 0 oder kein
-// KEKVersionStore konfiguriert, verhält es sich wie Open (Rückwärts-
-// kompatibilität für vor ARC-08 versiegelte Objekte).
-func (s *Service) OpenAtVersion(ctx context.Context, tenantSlug string, kekVersion int, wrappedDEK []byte, ciphertext io.Reader) (io.Reader, error) {
-	if kekVersion == 0 || s.versions == nil {
-		return s.Open(ctx, tenantSlug, wrappedDEK, ciphertext)
-	}
-	kek, err := s.versions.Get(ctx, tenantSlug, kekVersion)
-	if err != nil {
-		return nil, fmt.Errorf("crypto: historischen tenant-kek beziehen: %w", err)
-	}
-	dek, err := UnwrapDEK(kek, wrappedDEK)
-	if err != nil {
-		return nil, err
-	}
-	return DecryptStream(dek, ciphertext)
-}

mail/internal/dedup/hash.go

@@ -1,35 +0,0 @@
-// Package dedup implementiert ARC-03: Dublettenerkennung für
-// archivierte E-Mails über einen Inhalts-Hash. Kombiniert bewusst NICHT
-// mit mail/internal/storage oder mail/internal/crypto — dieses Paket
-// kennt beide nicht, der Aufrufer (spätere Ingest-Tickets) ruft es VOR
-// mail/internal/crypto auf.
-package dedup
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-)
-
-// HashAndBuffer berechnet den SHA-256-Inhalts-Hash von plaintext.
-//
-// Bekannter Fehler vermeiden (siehe ARC-03-Ticket): der Hash MUSS auf
-// dem Klartext berechnet werden, BEVOR mail/internal/crypto verschlüsselt
-// — ein Hash auf dem Chiffretext wäre bei jedem Import anders (neuer
-// DEK je Objekt, siehe ARC-02) und Dublettenerkennung würde vollständig
-// versagen. Reihenfolge: Mail/Anhang empfangen -> HashAndBuffer (dieses
-// Paket) -> verschlüsseln (ARC-02) -> ablegen.
-//
-// plaintext wird beim Hashen vollständig verbraucht — HashAndBuffer
-// liefert deshalb einen erneut lesbaren Reader mit demselben Inhalt für
-// den nachfolgenden Verschlüsselungsschritt zurück.
-func HashAndBuffer(plaintext io.Reader) (contentHash string, buffered io.Reader, err error) {
-	var buf bytes.Buffer
-	hasher := sha256.New()
-	if _, err := io.Copy(hasher, io.TeeReader(plaintext, &buf)); err != nil {
-		return "", nil, fmt.Errorf("dedup: klartext hashen: %w", err)
-	}
-	return hex.EncodeToString(hasher.Sum(nil)), &buf, nil
-}

mail/internal/dedup/hash_test.go

@@ -1,58 +0,0 @@
-package dedup
-
-import (
-	"io"
-	"strings"
-	"testing"
-)
-
-func TestHashAndBuffer_SameContentSameHash(t *testing.T) {
-	h1, buf1, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	h2, buf2, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if h1 != h2 {
-		t.Fatalf("erwartet identischen hash für identischen inhalt, habe %q vs %q", h1, h2)
-	}
-
-	got1, _ := io.ReadAll(buf1)
-	got2, _ := io.ReadAll(buf2)
-	if string(got1) != "identischer inhalt" || string(got2) != "identischer inhalt" {
-		t.Fatal("buffered reader liefert nicht denselben inhalt zurück wie der ursprüngliche klartext")
-	}
-}
-
-func TestHashAndBuffer_DifferentContentDifferentHash(t *testing.T) {
-	h1, _, err := HashAndBuffer(strings.NewReader("nachricht a"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	h2, _, err := HashAndBuffer(strings.NewReader("nachricht b"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if h1 == h2 {
-		t.Fatal("unterschiedlicher inhalt hätte unterschiedlichen hash liefern müssen")
-	}
-}
-
-// TestHashAndBuffer_SlightlyDifferentContentDifferentHash ist die
-// geforderte Pflichtprüfung 3: knapp unterschiedliche Nachrichten
-// werden korrekt NICHT als Duplikat erkannt.
-func TestHashAndBuffer_SlightlyDifferentContentDifferentHash(t *testing.T) {
-	h1, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht."))
-	if err != nil {
-		t.Fatal(err)
-	}
-	h2, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht,"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if h1 == h2 {
-		t.Fatal("ein einziges abweichendes zeichen hätte den hash ändern müssen")
-	}
-}

mail/internal/dedup/store.go

@@ -1,75 +0,0 @@
-package dedup
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Store verwaltet bekannte Inhalts-Hashes je Mandant. tenant_slug ist
-// fester Bestandteil des Primärschlüssels (Akzeptanzkriterium 3:
-// mandantenübergreifend korrekt getrennt) — auch wenn Store einen mit
-// anderen Mandanten geteilten Pool erhält, kann ein Hash-Treffer nie
-// über Mandantengrenzen hinweg entstehen.
-type Store struct {
-	pool       *pgxpool.Pool
-	tenantSlug string
-}
-
-func NewStore(pool *pgxpool.Pool, tenantSlug string) *Store {
-	return &Store{pool: pool, tenantSlug: tenantSlug}
-}
-
-// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
-// gleiches Muster wie mail/internal/example (kein zentraler
-// Migrationsläufer für Mandanten-Datenbanken im Mail-Modul vorhanden).
-func (s *Store) EnsureSchema(ctx context.Context) error {
-	if _, err := s.pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS mail_content_hashes (
-			tenant_slug  TEXT NOT NULL,
-			content_hash TEXT NOT NULL,
-			object_key   TEXT NOT NULL,
-			created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-			PRIMARY KEY (tenant_slug, content_hash)
-		)
-	`); err != nil {
-		return fmt.Errorf("dedup: schema anlegen: %w", err)
-	}
-	return nil
-}
-
-// Register trägt contentHash für den Mandanten als neu bekannt ein
-// (Akzeptanzkriterium 1) und referenziert das Original, statt es
-// redundant zu speichern (Akzeptanzkriterium 2): existiert derselbe
-// Hash für DIESEN Mandanten bereits mit einem ANDEREN object_key,
-// liefert Register isDuplicate=true und den object_key des Originals —
-// der Aufrufer legt den neuen Inhalt dann NICHT ab.
-func (s *Store) Register(ctx context.Context, contentHash, objectKey string) (isDuplicate bool, existingKey string, err error) {
-	if _, err := s.pool.Exec(ctx, `
-		INSERT INTO mail_content_hashes (tenant_slug, content_hash, object_key)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (tenant_slug, content_hash) DO NOTHING
-	`, s.tenantSlug, contentHash, objectKey); err != nil {
-		return false, "", fmt.Errorf("dedup: hash eintragen: %w", err)
-	}
-
-	var storedKey string
-	err = s.pool.QueryRow(ctx, `
-		SELECT object_key FROM mail_content_hashes
-		WHERE tenant_slug = $1 AND content_hash = $2
-	`, s.tenantSlug, contentHash).Scan(&storedKey)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return false, "", fmt.Errorf("dedup: gerade eingetragenen hash nicht wiedergefunden")
-		}
-		return false, "", fmt.Errorf("dedup: eintrag lesen: %w", err)
-	}
-
-	if storedKey != objectKey {
-		return true, storedKey, nil
-	}
-	return false, "", nil
-}

mail/internal/dedup/store_integration_test.go

@@ -1,94 +0,0 @@
-// Integrationstest (ARC-03): echte Postgres-Instanz, folgt derselben
-// Testhost-Konvention wie mail/internal/example (QA-01) — TEST_TENANT_DSN.
-package dedup
-
-import (
-	"context"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupStore(t *testing.T, tenantSlug string) *Store {
-	t.Helper()
-	dsn := os.Getenv("TEST_TENANT_DSN")
-	if dsn == "" {
-		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
-	}
-	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	t.Cleanup(func() { pool.Close() })
-
-	store := NewStore(pool, tenantSlug)
-	if err := store.EnsureSchema(ctx); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-	t.Cleanup(func() {
-		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_content_hashes WHERE tenant_slug = $1`, tenantSlug)
-	})
-	return store
-}
-
-// TestRegister_SameMessageFromTwoSourcesIsDuplicate ist die geforderte
-// Pflichtprüfung 1: dieselbe Nachricht aus zwei Quellen wird als
-// Duplikat erkannt.
-func TestRegister_SameMessageFromTwoSourcesIsDuplicate(t *testing.T) {
-	store := setupStore(t, "mandant-arc03-a")
-	ctx := context.Background()
-
-	hash := "fixierter-inhalts-hash-fuer-test-1"
-
-	isDup, _, err := store.Register(ctx, hash, "quelle-1/objekt")
-	if err != nil {
-		t.Fatalf("erste registrierung: %v", err)
-	}
-	if isDup {
-		t.Fatal("erste registrierung eines hashes darf kein duplikat sein")
-	}
-
-	isDup, existing, err := store.Register(ctx, hash, "quelle-2/objekt")
-	if err != nil {
-		t.Fatalf("zweite registrierung: %v", err)
-	}
-	if !isDup {
-		t.Fatal("erwartet: dieselbe nachricht aus zweiter quelle wird als duplikat erkannt")
-	}
-	if existing != "quelle-1/objekt" {
-		t.Fatalf("erwartet referenz auf das original quelle-1/objekt, habe %q", existing)
-	}
-}
-
-// TestRegister_SameContentTwoTenantsNotLinked ist die geforderte
-// Pflichtprüfung 2: zwei Mandanten mit identischem Mailinhalt werden
-// nicht fälschlich verknüpft.
-func TestRegister_SameContentTwoTenantsNotLinked(t *testing.T) {
-	dsn := os.Getenv("TEST_TENANT_DSN")
-	if dsn == "" {
-		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
-	}
-	storeA := setupStore(t, "mandant-arc03-x")
-	storeB := setupStore(t, "mandant-arc03-y")
-	ctx := context.Background()
-
-	hash := "identischer-inhalt-ueber-zwei-mandanten-hinweg"
-
-	isDupA, _, err := storeA.Register(ctx, hash, "mandant-x/objekt")
-	if err != nil {
-		t.Fatalf("mandant a: %v", err)
-	}
-	if isDupA {
-		t.Fatal("erste registrierung bei mandant a darf kein duplikat sein")
-	}
-
-	isDupB, existingB, err := storeB.Register(ctx, hash, "mandant-y/objekt")
-	if err != nil {
-		t.Fatalf("mandant b: %v", err)
-	}
-	if isDupB {
-		t.Fatalf("mandant b wurde fälschlich mit mandant a verknüpft, existing=%q", existingB)
-	}
-}

mail/internal/encstorage/encstorage.go

@@ -1,138 +0,0 @@
-// Package encstorage implementiert ARC-02s Anbindung an ARC-01: jedes
-// archivierte Objekt wird VOR dem Schreiben über
-// mail/internal/storage.Service verschlüsselt (Akzeptanzkriterium 1).
-// Kombiniert bewusst zwei bereits fertige, unveränderte Pakete
-// (mail/internal/storage aus ARC-01, mail/internal/crypto aus ARC-02)
-// statt eines davon zu erweitern — kein Umbau angrenzender Bereiche.
-//
-// Reihenfolge beachtet (Ticket "Bekannte Fehler vermeiden"): ein
-// SHA-256-Hash für Dublettenerkennung (ARC-03) muss auf dem KLARTEXT
-// berechnet werden, BEVOR diese Verschlüsselung angewendet wird — das
-// ist Sache des Aufrufers (ARC-03, außerhalb dieses Pakets), dieses
-// Paket nimmt bereits fertigen Klartext entgegen und verschlüsselt ihn
-// sofort, hält ihn nicht länger als nötig im Speicher.
-package encstorage
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"strconv"
-
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
-)
-
-// wrappedDEKKey ist der Sidecar-Objektschlüssel für den mit dem
-// Tenant-KEK verpackten DEK — liegt im selben Storage-Backend wie der
-// Chiffretext, analog zum Prüfsummen-Sidecar aus ARC-01.
-func wrappedDEKKey(key string) string {
-	return key + ".dek"
-}
-
-// kekVersionKey ist der Sidecar-Objektschlüssel für die Tenant-KEK-
-// Version, mit der der DEK verpackt wurde (ARC-08 Akzeptanzkriterium 3).
-// Fehlt dieser Sidecar (vor ARC-08 geschriebene Objekte), wird Version 0
-// angenommen — GetDecrypted verhält sich dann wie vor ARC-08.
-func kekVersionKey(key string) string {
-	return key + ".dek.version"
-}
-
-// Service verbindet Storage (ARC-01) und Crypto (ARC-02): der Rest von
-// Mail ruft AUSSCHLIESSLICH diesen Service auf, nie storage.Service
-// direkt mit Klartext — das verhindert einen Schreibpfad, der die
-// Verschlüsselung vergisst (Akzeptanzkriterium 1).
-type Service struct {
-	storage *storage.Service
-	crypto  *crypto.Service
-}
-
-func NewService(storageSvc *storage.Service, cryptoSvc *crypto.Service) *Service {
-	return &Service{storage: storageSvc, crypto: cryptoSvc}
-}
-
-// Put verschlüsselt plaintext (Akzeptanzkriterium 1/2: neuer DEK je
-// Objekt, mit dem per API-12 bezogenen Tenant-KEK verpackt) und legt
-// Chiffretext + verpackten DEK über storage.Service ab (Prüfsumme,
-// Nutzungsmeldung — ARC-01 unverändert wiederverwendet).
-func (s *Service) Put(ctx context.Context, tenantSlug, key string, plaintext io.Reader, contentType string) error {
-	env, err := s.crypto.Seal(ctx, tenantSlug, plaintext)
-	if err != nil {
-		return fmt.Errorf("encstorage: verschlüsseln: %w", err)
-	}
-	ciphertext, err := io.ReadAll(env.Ciphertext)
-	if err != nil {
-		return fmt.Errorf("encstorage: chiffretext lesen: %w", err)
-	}
-	if _, err := s.storage.Put(ctx, key, bytes.NewReader(ciphertext), int64(len(ciphertext)), contentType); err != nil {
-		return fmt.Errorf("encstorage: chiffretext speichern: %w", err)
-	}
-	if _, err := s.storage.Put(ctx, wrappedDEKKey(key), bytes.NewReader(env.WrappedDEK), int64(len(env.WrappedDEK)), "application/octet-stream"); err != nil {
-		return fmt.Errorf("encstorage: verpackten dek speichern: %w", err)
-	}
-	if env.KEKVersion != 0 {
-		versionBytes := []byte(strconv.Itoa(env.KEKVersion))
-		if _, err := s.storage.Put(ctx, kekVersionKey(key), bytes.NewReader(versionBytes), int64(len(versionBytes)), "text/plain"); err != nil {
-			return fmt.Errorf("encstorage: kek-version speichern: %w", err)
-		}
-	}
-	return nil
-}
-
-// GetDecrypted liest Chiffretext (über storage.GetVerified — ARC-01s
-// Prüfsummenverifikation wird dabei mitgenutzt) und verpackten DEK,
-// entpackt den DEK mit dem AKTUELLEN Tenant-KEK und entschlüsselt den
-// Inhalt (Akzeptanzkriterium 3: nur mit gültigem, mandantenbezogenem
-// Schlüssel möglich).
-func (s *Service) GetDecrypted(ctx context.Context, tenantSlug, key string) ([]byte, error) {
-	ciphertext, err := s.storage.GetVerified(ctx, key)
-	if err != nil {
-		return nil, fmt.Errorf("encstorage: chiffretext lesen: %w", err)
-	}
-	dekReader, err := s.storage.Get(ctx, wrappedDEKKey(key))
-	if err != nil {
-		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
-	}
-	defer func() { _ = dekReader.Close() }()
-	wrappedDEK, err := io.ReadAll(dekReader)
-	if err != nil {
-		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
-	}
-
-	kekVersion, err := s.readKEKVersion(ctx, key)
-	if err != nil {
-		return nil, err
-	}
-
-	plaintextReader, err := s.crypto.OpenAtVersion(ctx, tenantSlug, kekVersion, wrappedDEK, bytes.NewReader(ciphertext))
-	if err != nil {
-		return nil, err
-	}
-	return io.ReadAll(plaintextReader)
-}
-
-// readKEKVersion liest den Versions-Sidecar (ARC-08). Fehlt er (vor
-// ARC-08 geschriebene Objekte, oder ein Seal ohne konfigurierten
-// KEKVersionStore), gilt Version 0 — crypto.Service.OpenAtVersion fällt
-// dafür auf das unveränderte Open-Verhalten zurück.
-func (s *Service) readKEKVersion(ctx context.Context, key string) (int, error) {
-	reader, err := s.storage.Get(ctx, kekVersionKey(key))
-	if err != nil {
-		if errors.Is(err, storage.ErrNotFound) {
-			return 0, nil
-		}
-		return 0, fmt.Errorf("encstorage: kek-version lesen: %w", err)
-	}
-	defer func() { _ = reader.Close() }()
-	raw, err := io.ReadAll(reader)
-	if err != nil {
-		return 0, fmt.Errorf("encstorage: kek-version lesen: %w", err)
-	}
-	version, err := strconv.Atoi(string(raw))
-	if err != nil {
-		return 0, fmt.Errorf("encstorage: kek-version parsen: %w", err)
-	}
-	return version, nil
-}

mail/internal/encstorage/encstorage_test.go

@@ -1,138 +0,0 @@
-package encstorage
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
-)
-
-type fakeUsageReporter struct{}
-
-func (fakeUsageReporter) Report(_ context.Context, _, _ string, _ int64) error { return nil }
-
-// fakeKEKProvider liefert einen festen, mandantenspezifischen KEK —
-// simuliert Core API-12, ohne den echten Dienst für Unit-Tests zu
-// brauchen. "richtiger-tenant" hat einen bekannten KEK, jeder andere
-// Tenant-Slug liefert einen ANDEREN (falschen) KEK — genau der Fall,
-// den Pflichtprüfung 2 testet.
-type fakeKEKProvider struct {
-	keksByTenant map[string][]byte
-}
-
-func (f fakeKEKProvider) TenantKEK(_ context.Context, tenantSlug string) ([]byte, error) {
-	if kek, ok := f.keksByTenant[tenantSlug]; ok {
-		return kek, nil
-	}
-	// Unbekannter Tenant bekommt einen ANDEREN zufälligen KEK (nicht
-	// abgelehnt auf Core-Seite in diesem Fake, aber garantiert falsch —
-	// entspricht dem realen Fall, dass ein falscher Tenant-Slug einen
-	// anderen KEK liefert und die Entschlüsselung deshalb scheitert).
-	return bytes.Repeat([]byte{0xFF}, crypto.KEKSize), nil
-}
-
-func newTestServiceWithDir(t *testing.T) (*Service, string) {
-	t.Helper()
-	dir := t.TempDir()
-	storageSvc := storage.NewService(storage.NewLocalDriver(dir), fakeUsageReporter{}, "acme")
-	kekProvider := fakeKEKProvider{keksByTenant: map[string][]byte{
-		"richtiger-tenant": bytes.Repeat([]byte{0x42}, crypto.KEKSize),
-	}}
-	cryptoSvc := crypto.NewService(kekProvider)
-	return NewService(storageSvc, cryptoSvc), dir
-}
-
-// TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent ist die
-// geforderte Pflichtprüfung 1: Zugriff auf Rohspeicher ohne Schlüssel
-// liefert keine lesbaren Inhalte.
-func TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent(t *testing.T) {
-	svc, dir := newTestServiceWithDir(t)
-	ctx := context.Background()
-	key := storage.ObjectKey("msg-enc-1", 0)
-	plaintext := "STRENG GEHEIMER E-MAIL-INHALT, NICHT IM KLARTEXT AUF DER PLATTE"
-
-	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
-		t.Fatalf("put: %v", err)
-	}
-
-	// Direkter Dateisystemzugriff, UMGEHT den Service/die Entschlüsselung
-	// vollständig — simuliert "Rohspeicher ohne Schlüssel".
-	raw, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(key)))
-	if err != nil {
-		t.Fatalf("rohdatei lesen: %v", err)
-	}
-	if bytes.Contains(raw, []byte(plaintext)) {
-		t.Fatalf("klartext ist unverschlüsselt im rohspeicher auffindbar: %q enthält %q", raw, plaintext)
-	}
-	if bytes.Contains(raw, []byte("STRENG GEHEIMER")) || bytes.Contains(raw, []byte("GEHEIM")) {
-		t.Fatal("erkennbare klartext-fragmente im rohspeicher gefunden")
-	}
-}
-
-// TestGetDecrypted_WrongTenantKeyDeniesDecryption ist die geforderte
-// Pflichtprüfung 2: falscher Mandantenschlüssel verweigert
-// Entschlüsselung.
-func TestGetDecrypted_WrongTenantKeyDeniesDecryption(t *testing.T) {
-	svc, _ := newTestServiceWithDir(t)
-	ctx := context.Background()
-	key := storage.ObjectKey("msg-enc-2", 0)
-	plaintext := "inhalt fuer richtiger-tenant"
-
-	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
-		t.Fatalf("put: %v", err)
-	}
-
-	// Korrekter Tenant kann entschlüsseln.
-	got, err := svc.GetDecrypted(ctx, "richtiger-tenant", key)
-	if err != nil {
-		t.Fatalf("getdecrypted (richtiger tenant): %v", err)
-	}
-	if string(got) != plaintext {
-		t.Fatalf("falscher inhalt: %q", got)
-	}
-
-	// FALSCHER Mandant (anderer Tenant-Slug -> anderer KEK) muss
-	// abgelehnt werden.
-	_, err = svc.GetDecrypted(ctx, "falscher-tenant", key)
-	if !errors.Is(err, crypto.ErrDecryptFailed) {
-		t.Fatalf("erwartet ErrDecryptFailed bei falschem mandantenschlüssel, habe: %v", err)
-	}
-}
-
-// TestPut_AcceptableEncryptionOverhead ist die geforderte
-// Pflichtprüfung 3: Performance-Test bestätigt akzeptablen Overhead
-// durch Verschlüsselung.
-func TestPut_AcceptableEncryptionOverhead(t *testing.T) {
-	svc, _ := newTestServiceWithDir(t)
-	ctx := context.Background()
-
-	// ~64 KiB Nutzlast, realistische Anhanggröße.
-	payload := strings.Repeat("x", 64*1024)
-
-	const count = 50
-	start := time.Now()
-	for i := 0; i < count; i++ {
-		key := storage.ObjectKey("msg-perf", i)
-		if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(payload), "application/octet-stream"); err != nil {
-			t.Fatalf("put #%d: %v", i, err)
-		}
-	}
-	elapsed := time.Since(start)
-	avgPerObject := elapsed / count
-
-	// Großzügige Grenze (50ms je 64-KiB-Objekt inkl. AES-GCM,
-	// Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01) —
-	// Ziel: Nachweis, dass Verschlüsselung keinen unverhältnismäßigen
-	// Overhead verursacht, nicht ein knallhartes SLA.
-	if avgPerObject > 50*time.Millisecond {
-		t.Fatalf("erwartet akzeptablen verschlüsselungs-overhead (<50ms/64KiB-objekt), habe %v/objekt (gesamt %v für %d objekte)", avgPerObject, elapsed, count)
-	}
-	t.Logf("Verschlüsselungs-Performance: %d×64KiB-Objekte in %v (%v/Objekt)", count, elapsed, avgPerObject)
-}

mail/internal/example/handler.go

@@ -1,36 +0,0 @@
-package example
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// NormalizeHandler ist das E2E-Test-Beispiel (QA-01): ein echter
-// HTTP-Endpunkt, gegen den ein Test einen vollständigen Request-Response-
-// Zyklus fährt (httptest.Server, echter TCP-Roundtrip, kein reiner
-// Funktionsaufruf). Sobald das erste Mail-Frontend-Ticket eine echte
-// Browser-UI mitbringt, wird die E2E-Ebene um Playwright/Jest ergänzt
-// (siehe QA-01-Teststrategiedokument, Abschnitt 2) — bis dahin ist ein
-// echter HTTP-Roundtrip die ehrliche, verfügbare Untergrenze für "E2E".
-type normalizeRequest struct {
-	Address string `json:"address"`
-}
-
-type normalizeResponse struct {
-	Normalized string `json:"normalized"`
-}
-
-func NormalizeHandler(w http.ResponseWriter, r *http.Request) {
-	var req normalizeRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungültiger request-body", http.StatusBadRequest)
-		return
-	}
-	normalized, err := NormalizeAddress(req.Address)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(normalizeResponse{Normalized: normalized})
-}

mail/internal/example/handler_e2e_test.go

@@ -1,51 +0,0 @@
-// E2E-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): echter
-// HTTP-Request über einen laufenden httptest.Server (TCP-Roundtrip),
-// nicht nur ein Funktionsaufruf im selben Prozess.
-package example
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestNormalizeHandler_RealHTTPRoundTrip(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
-	defer server.Close()
-
-	body, _ := json.Marshal(normalizeRequest{Address: "Kunde@Beispiel.DE"})
-	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
-	if err != nil {
-		t.Fatalf("post: %v", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("status = %d, want 200", resp.StatusCode)
-	}
-	var out normalizeResponse
-	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
-		t.Fatalf("antwort dekodieren: %v", err)
-	}
-	if out.Normalized != "Kunde@beispiel.de" {
-		t.Fatalf("got %q", out.Normalized)
-	}
-}
-
-func TestNormalizeHandler_InvalidAddressReturns400(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
-	defer server.Close()
-
-	body, _ := json.Marshal(normalizeRequest{Address: "keine-gueltige-adresse"})
-	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
-	if err != nil {
-		t.Fatalf("post: %v", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	if resp.StatusCode != http.StatusBadRequest {
-		t.Fatalf("status = %d, want 400", resp.StatusCode)
-	}
-}

mail/internal/example/normalize.go

@@ -1,26 +0,0 @@
-// Package example dient QA-01 (Mail): liefert je Testart (Unit,
-// Integration, E2E) genau EIN reales, lauffähiges Beispiel, an dem sich
-// spätere Mail-Tickets orientieren können — keine Wegwerf-Demo, sondern
-// eine tatsächlich nützliche, kleine Funktion (Adress-Normalisierung),
-// die spätere Ticket (z. B. ING-01/ING-04) ohnehin brauchen werden.
-package example
-
-import (
-	"errors"
-	"strings"
-)
-
-var ErrInvalidAddress = errors.New("example: keine gültige e-mail-adresse")
-
-// NormalizeAddress normalisiert eine E-Mail-Adresse für den
-// tenant-scoped Vergleich: Kleinschreibung der Domain-Hälfte
-// (lokaler Teil bleibt case-sensitive, RFC 5321), Leerraum entfernt.
-func NormalizeAddress(addr string) (string, error) {
-	addr = strings.TrimSpace(addr)
-	at := strings.LastIndex(addr, "@")
-	if at <= 0 || at == len(addr)-1 {
-		return "", ErrInvalidAddress
-	}
-	local, domain := addr[:at], addr[at+1:]
-	return local + "@" + strings.ToLower(domain), nil
-}