QA-01: go.sum ergaenzen (fehlte, go mod tidy auf Testhost verifiziert)

QA-01: teststrategie-core (pflichttest-gate, testdb-isolationsnachweis, ci-workflow)
2026-08-28 22:43:57 +02:00 · 2026-08-28 22:41:06 +02:00
36 changed files with 462 additions and 2257 deletions
@@ -1,9 +1,7 @@
-name: Mail-Pflichttest-Gate
+name: Core-Pflichttest-Gate

 on:
-  pull_request:
-    paths:
-      - "mail/**"
+  pull_request: {}

 jobs:
  pflichttest-gate:
@@ -16,8 +14,7 @@ jobs:
        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
+      - name: Geänderte Dateien gegen Pflichttest-Regel pruefen
        run: |
          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate
@@ -44,3 +44,20 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.

 ---
+## 2026-08-28 22:37 – 22:41 (3m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- 5a0d074 QA-01: teststrategie-core (pflichttest-gate, testdb-isolationsnachweis, ci-workflow)
+
+### Geänderte Dateien
+- .gitea/workflows/pflichttest-gate.yml      | 20 ++++++++++++++++++++
+- cmd/pflichttestgate/main.go                | 41 +++++++++++++++++++++++++++++++++++++++++
+- docs/TESTSTRATEGIE-CORE.md                 | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/pflichttestgate/gate.go           | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/pflichttestgate/gate_test.go      | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/testdbisolation/isolation.go      | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/testdbisolation/isolation_test.go | 99 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+---
@@ -1,5 +1,7 @@
-// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-MAIL.md
-// Abschnitt 4. Aufruf: pflichttestgate < geänderte-dateien.txt
+// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-CORE.md Abschnitt 5.
+// Aufruf: pflichttestgate <geänderte-Dateien-getrennt-durch-Zeilenumbruch-via-stdin>
+// Beendet sich mit Exit-Code 1 und einer Liste der Verstöße, wenn ein sicherheitskritisches
+// Package ohne begleitende Testdatei geändert wurde.
 package main

 import (
@@ -7,7 +9,7 @@ import (
 	"fmt"
 	"os"

-	"gitea.perlbach24.de/scripte/nexarch/mail/internal/pflichttestgate"
+	"gitea.perlbach24.de/scripte/nexarch/internal/pflichttestgate"
 )

 func main() {
@@ -20,7 +22,7 @@ func main() {
 		}
 	}
 	if err := scanner.Err(); err != nil {
-		fmt.Fprintf(os.Stderr, "pflichttestgate: eingabe konnte nicht gelesen werden: %v\n", err)
+		fmt.Fprintf(os.Stderr, "pflichttestgate: Eingabe konnte nicht gelesen werden: %v\n", err)
 		os.Exit(2)
 	}

@@ -34,6 +36,6 @@ func main() {
 	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.")
+	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-CORE.md Abschnitt 3.")
 	os.Exit(1)
 }
@@ -0,0 +1,81 @@
+# NEXARCH Core – Teststrategie
+
+Stand: 2026-08-28. Ticket: QA-01.
+
+## 1. Warum dieses Dokument existiert
+
+archivdms hatte zur Zeit der Bestandsaufnahme nur 2 `_test.go`-Dateien in ganz `internal/`, davon 0 für
+`auth`/`storage`/`permissions.go`. archivmail testete 2 von 18 Modulen. Beide Lücken wurden erst im
+Betrieb entdeckt, nicht vor dem Merge. NEXARCH Core übernimmt daraus einen Grundsatz: **Testpflicht für
+Auth, Tenant-Scoping und Policy-Enforcement 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) |
+| Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Policy-Enforcement |
+| Vertragstests | `internal/contracttest` (siehe QA-07) | Öffentliche API-Verträge zwischen Core und Modulen |
+| Last-/Leistungstests | `internal/loadtest` (siehe QA-08) | Mehrmodul-Last, JWT-Verifikation, Connection-Pooling |
+| Extern | Core `QA-06` Penetrationstest | Vor Produktivbetrieb, außerhalb dieses CI-Gates |
+
+Diese Kachel (QA-01) legt die Pflichtebenen fest und erzwingt sie technisch für die drei sicherheitskritischsten Bereiche; sie ersetzt nicht QA-07/QA-08, die eigene, bereits umgesetzte CI-Gates haben.
+
+## 3. Pflichttests als Merge-Gate
+
+Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
+
+- **Auth** (`internal/auth/`, `internal/iam/`, Login/Session/2FA/SSO-Pakete)
+- **Tenant-Scoping** (`internal/tenant/`, jede Repository-Schicht mit `tenant_id`-Filterung)
+- **Policy-Enforcement** (`internal/rbac/`, `internal/policy/`, jede Autorisierungsprüfung)
+
+Regel: **jede geänderte `.go`-Datei in einem dieser Bereiche muss von einer geänderten oder neuen
+`_test.go`-Datei im selben Package begleitet sein.** Das CI-Gate (Abschnitt 5) prüft das automatisiert
+und blockiert den Merge, wenn die Regel verletzt ist — analog zum bereits etablierten Sprintf-Verbot für
+SQL (siehe `SICHERHEITSKONZEPT.md`), nur als technisch erzwungene statt nur dokumentierte Regel.
+
+Diese Regel gilt projektweit für alle sieben Boards, nicht nur Core — siehe die entsprechenden
+Akzeptanzkriterien in den `QA-01`-Tickets von DMS, Mail, Archive, Workflow, AI, Connect
+(`SICHERHEITSKONZEPT.md` Abschnitt 11, Punkt 8, 2026-08-28 geklärt).
+
+## 4. Testdatenbank-Strategie
+
+Isolation zwischen parallelen Testläufen ist die zentrale Lehre aus dem bisherigen Testbetrieb
+(siehe Projekt-Testinfrastruktur): mehrere Go-Testpakete teilen sich dieselbe physische PostgreSQL-Instanz
+auf dem Testhost, aber jedes Paket braucht einen isolierten Datenbestand.
+
+- **Rolle `nexarch_test`**: `CREATEDB`, kein Superuser, einmalig eingerichtet über `scripts/setup-test-env.sh`.
+- **Reset vor jedem Testlauf**: `scripts/reset-test-env.sh` droppt die geteilte `tenants`-Registry-Tabelle
+  und alle `tenant_*`-Datenbanken in der `postgres`-Wartungs-DB. Nötig, weil verschiedene Branches
+  unterschiedliche Registry-Schemata erwarten, aber dieselbe physische Instanz teilen.
+- **`-p 1` ist Pflicht** für `go test ./...`, sobald mehrere Pakete gegen die geteilte Registry-Tabelle
+  testen (z. B. `internal/tenant` + `internal/migrate`). Ohne `-p 1` laufen Paket-Testbinaries parallel
+  gegen dieselbe physische PostgreSQL-Instanz, ihre Registry-Einträge/DBs kollidieren
+  (falsche Tenant-Zählungen, „database already exists"-Fehler).
+- **Isolation innerhalb eines Testlaufs**: jeder Test, der eine Tenant-Datenbank braucht, provisioniert
+  seine eigene, eindeutig benannte `tenant_*`-DB über dieselbe Provisionierungs-Logik wie die
+  Anwendung selbst (`TEN-01`) und räumt sie in einem `t.Cleanup()` wieder ab — keine geteilten
+  Fixture-Datenbanken zwischen Testfällen.
+
+Siehe `internal/testdbisolation/isolation_test.go` (dieses Ticket) für den automatisierten Nachweis,
+dass zwei parallel laufende Tenant-Provisionierungen sich nicht gegenseitig sehen.
+
+## 5. CI-Gate
+
+`.gitea/workflows/pflichttest-gate.yml` führt `cmd/pflichttestgate` gegen den PR-Diff aus
+(`git diff --name-only origin/<base>...HEAD`). Das Programm:
+
+1. Filtert die geänderten Dateien auf die in Abschnitt 3 genannten Pfad-Muster.
+2. Prüft je betroffenem Go-Package, ob mindestens eine `_test.go`-Datei desselben Packages ebenfalls
+   im Diff enthalten ist.
+3. Beendet sich mit Exit-Code 1 und einer Liste der betroffenen Packages ohne Teständerung, wenn die
+   Regel verletzt ist — der CI-Job schlägt dann fehl, der Merge ist blockiert.
+
+Negativtest des Gates selbst: `internal/pflichttestgate/gate_test.go` enthält einen Testfall, der einen
+Diff mit geänderter `internal/auth/login.go` ohne begleitende Testdatei simuliert und erwartet, dass das
+Gate das als Verstoß erkennt (Prüfung 1 dieses Tickets).
+
+## 6. Dokumentation & Gegenlesen
+
+Dieses Dokument ist von einer zweiten Person gegenzulesen, bevor die Kachel als abgeschlossen gilt
+(Akzeptanzkriterium 3 / Prüfung 3). Fund/Freigabe wird im Pull Request vermerkt.
@@ -0,0 +1,28 @@
+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/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,67 @@
+// Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-CORE.md Abschnitt 3 festgelegte Regel:
+// jede geänderte Go-Datei in einem sicherheitskritischen Bereich (Auth, Tenant-Scoping, Policy)
+// muss von einer geänderten oder neuen _test.go-Datei im selben Package begleitet sein.
+package pflichttestgate
+
+import (
+	"path"
+	"regexp"
+	"strings"
+)
+
+// sensitivePathPatterns beschreibt die Bereiche aus TESTSTRATEGIE-CORE.md Abschnitt 3.
+var sensitivePathPatterns = []*regexp.Regexp{
+	regexp.MustCompile(`(^|/)internal/auth/`),
+	regexp.MustCompile(`(^|/)internal/iam/`),
+	regexp.MustCompile(`(^|/)internal/tenant/`),
+	regexp.MustCompile(`(^|/)internal/rbac/`),
+	regexp.MustCompile(`(^|/)internal/policy/`),
+}
+
+// Violation beschreibt ein Package mit sicherheitskritischer Änderung ohne begleitende Testdatei.
+type Violation struct {
+	Package     string
+	ChangedFile string
+}
+
+// isSensitive meldet, ob eine geänderte Datei in einen der Pflichttest-Bereiche fällt.
+func isSensitive(file string) bool {
+	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
+		return false
+	}
+	for _, re := range sensitivePathPatterns {
+		if re.MatchString(file) {
+			return true
+		}
+	}
+	return false
+}
+
+// CheckDiff prüft eine Liste geänderter Dateipfade (z. B. aus `git diff --name-only`) gegen die
+// Pflichttest-Regel und gibt für jedes betroffene Package ohne begleitende Testdatei eine Violation
+// zurück. Ein leeres Ergebnis bedeutet: Gate besteht.
+func CheckDiff(changedFiles []string) []Violation {
+	sensitiveByPkg := map[string]string{}  // package -> erste sensible Datei (fürs Reporting)
+	testTouchedPkgs := map[string]bool{}
+
+	for _, f := range changedFiles {
+		pkg := path.Dir(f)
+		if strings.HasSuffix(f, "_test.go") {
+			testTouchedPkgs[pkg] = true
+			continue
+		}
+		if isSensitive(f) {
+			if _, seen := sensitiveByPkg[pkg]; !seen {
+				sensitiveByPkg[pkg] = f
+			}
+		}
+	}
+
+	var violations []Violation
+	for pkg, file := range sensitiveByPkg {
+		if !testTouchedPkgs[pkg] {
+			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
+		}
+	}
+	return violations
+}
@@ -0,0 +1,84 @@
+package pflichttestgate
+
+import "testing"
+
+// Prüfung 1 (QA-01): CI-Lauf mit absichtlich fehlendem Pflichttest schlägt kontrolliert fehl —
+// Negativtest des Gates selbst.
+func TestCheckDiff_BlocksAuthChangeWithoutTest(t *testing.T) {
+	changed := []string{
+		"internal/auth/login.go",
+		"internal/apiserver/handler.go", // unkritisch, keine Testpflicht
+	}
+
+	violations := CheckDiff(changed)
+
+	if len(violations) != 1 {
+		t.Fatalf("erwartet 1 Verstoß, bekommen %d: %+v", len(violations), violations)
+	}
+	if violations[0].Package != "internal/auth" {
+		t.Errorf("erwartetes Package internal/auth, bekommen %q", violations[0].Package)
+	}
+	if violations[0].ChangedFile != "internal/auth/login.go" {
+		t.Errorf("erwartete Datei internal/auth/login.go, bekommen %q", violations[0].ChangedFile)
+	}
+}
+
+func TestCheckDiff_PassesWhenTestFileAccompaniesChange(t *testing.T) {
+	changed := []string{
+		"internal/auth/login.go",
+		"internal/auth/login_test.go",
+	}
+
+	violations := CheckDiff(changed)
+
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keinen Verstoß, bekommen %+v", violations)
+	}
+}
+
+func TestCheckDiff_PassesForNewTestFileEvenWithoutSourceChange(t *testing.T) {
+	// Nachtraeglich ergaenzter Test fuer bestehenden Code ist erlaubt/erwuenscht.
+	changed := []string{"internal/tenant/registry_test.go"}
+
+	violations := CheckDiff(changed)
+
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keinen Verstoß, bekommen %+v", violations)
+	}
+}
+
+func TestCheckDiff_IgnoresUnrelatedPackages(t *testing.T) {
+	changed := []string{"internal/config/config.go", "internal/db/db.go"}
+
+	violations := CheckDiff(changed)
+
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keinen Verstoß fuer unkritische Pakete, bekommen %+v", violations)
+	}
+}
+
+func TestCheckDiff_CoversAllSensitiveAreas(t *testing.T) {
+	cases := []string{
+		"internal/auth/session.go",
+		"internal/iam/user.go",
+		"internal/tenant/provisioner.go",
+		"internal/rbac/enforcer.go",
+		"internal/policy/decision.go",
+	}
+	for _, f := range cases {
+		violations := CheckDiff([]string{f})
+		if len(violations) != 1 {
+			t.Errorf("Datei %q sollte als sensibel erkannt werden, Verstöße: %+v", f, violations)
+		}
+	}
+}
+
+func TestCheckDiff_IgnoresNonGoFiles(t *testing.T) {
+	changed := []string{"internal/auth/README.md"}
+
+	violations := CheckDiff(changed)
+
+	if len(violations) != 0 {
+		t.Fatalf("Nicht-Go-Dateien duerfen keine Testpflicht ausloesen, bekommen %+v", violations)
+	}
+}
@@ -0,0 +1,76 @@
+// Package testdbisolation demonstriert und prüft die in docs/TESTSTRATEGIE-CORE.md Abschnitt 4
+// beschriebene Testdatenbank-Isolation: jeder Test, der eine Tenant-Datenbank braucht,
+// provisioniert seine eigene, eindeutig benannte DB und räumt sie über Cleanup wieder ab —
+// keine geteilten Fixture-Datenbanken zwischen parallelen Testläufen.
+package testdbisolation
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ProvisionEphemeralDB legt unter dem gegebenen Admin-DSN eine neue, eindeutig benannte Datenbank an
+// und liefert eine Cleanup-Funktion, die sie wieder droppt. adminDSN muss auf eine Wartungs-DB
+// (z. B. "postgres") zeigen, name muss ein gültiger, bereits eindeutiger Bezeichner sein.
+func ProvisionEphemeralDB(ctx context.Context, adminDSN, name string) (cleanup func(context.Context) error, err error) {
+	conn, err := pgx.Connect(ctx, adminDSN)
+	if err != nil {
+		return nil, fmt.Errorf("verbindung zur wartungs-db fehlgeschlagen: %w", err)
+	}
+	defer conn.Close(ctx)
+
+	if _, err := conn.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{name}.Sanitize())); err != nil {
+		return nil, fmt.Errorf("datenbank %q konnte nicht angelegt werden: %w", name, err)
+	}
+
+	cleanup = func(cleanupCtx context.Context) error {
+		adminConn, err := pgx.Connect(cleanupCtx, adminDSN)
+		if err != nil {
+			return fmt.Errorf("cleanup: verbindung fehlgeschlagen: %w", err)
+		}
+		defer adminConn.Close(cleanupCtx)
+		_, err = adminConn.Exec(cleanupCtx, fmt.Sprintf("DROP DATABASE IF EXISTS %s", pgx.Identifier{name}.Sanitize()))
+		return err
+	}
+	return cleanup, nil
+}
+
+// WriteMarker schreibt einen eindeutigen Beleg-Datensatz in die angegebene Datenbank (verbindet
+// per dsnForDB), um im Test nachzuweisen, dass zwei parallele Provisionierungen sich nicht sehen.
+func WriteMarker(ctx context.Context, dsn, table, value string) error {
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		return err
+	}
+	defer pool.Close()
+
+	if _, err := pool.Exec(ctx, fmt.Sprintf(
+		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
+	)); err != nil {
+		return err
+	}
+	_, err = pool.Exec(ctx, fmt.Sprintf("INSERT INTO %s (value) VALUES ($1)", pgx.Identifier{table}.Sanitize()), value)
+	return err
+}
+
+// CountMarkers zählt die Belegzeilen in der angegebenen Datenbank/Tabelle.
+func CountMarkers(ctx context.Context, dsn, table string) (int, error) {
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		return 0, err
+	}
+	defer pool.Close()
+
+	if _, err := pool.Exec(ctx, fmt.Sprintf(
+		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
+	)); err != nil {
+		return 0, err
+	}
+
+	var n int
+	err = pool.QueryRow(ctx, fmt.Sprintf("SELECT count(*) FROM %s", pgx.Identifier{table}.Sanitize())).Scan(&n)
+	return n, err
+}
@@ -0,0 +1,99 @@
+package testdbisolation
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// TestParallelProvisioning_AreIsolated ist der automatisierte Nachweis für QA-01 Prüfung 2:
+// Testdatenbank-Isolation zwischen parallelen Testläufen. Zwei Provisionierungen laufen
+// gleichzeitig, jede schreibt einen Beleg-Datensatz in ihre eigene DB — keine darf den
+// Beleg der jeweils anderen sehen.
+//
+// Braucht TEST_ADMIN_DSN (siehe Projekt-Testinfrastruktur), läuft auf dem Testhost, nicht lokal
+// auf der Entwicklungsmaschine (siehe "no installs"-Regel) — wird ohne gesetzte Variable übersprungen.
+func TestParallelProvisioning_AreIsolated(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt — Test läuft nur auf dem Testhost, siehe docs/TESTSTRATEGIE-CORE.md")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	const numParallel = 2
+	dbNames := make([]string, numParallel)
+	for i := range dbNames {
+		dbNames[i] = fmt.Sprintf("qa01_isolation_%d_%d", time.Now().UnixNano(), i)
+	}
+
+	var wg sync.WaitGroup
+	errs := make([]error, numParallel)
+	cleanups := make([]func(context.Context) error, numParallel)
+
+	for i, name := range dbNames {
+		wg.Add(1)
+		go func(idx int, dbName string) {
+			defer wg.Done()
+
+			cleanup, err := ProvisionEphemeralDB(ctx, adminDSN, dbName)
+			if err != nil {
+				errs[idx] = fmt.Errorf("provisionierung %d fehlgeschlagen: %w", idx, err)
+				return
+			}
+			cleanups[idx] = cleanup
+
+			dbDSN := dsnForDB(adminDSN, dbName)
+			// Jede Goroutine schreibt einen für sie eindeutigen Beleg.
+			if err := WriteMarker(ctx, dbDSN, "isolation_marker", fmt.Sprintf("marker-von-goroutine-%d", idx)); err != nil {
+				errs[idx] = fmt.Errorf("markierung %d fehlgeschlagen: %w", idx, err)
+			}
+		}(i, name)
+	}
+	wg.Wait()
+
+	t.Cleanup(func() {
+		for _, cleanup := range cleanups {
+			if cleanup != nil {
+				_ = cleanup(context.Background())
+			}
+		}
+	})
+
+	for i, err := range errs {
+		if err != nil {
+			t.Fatalf("goroutine %d: %v", i, err)
+		}
+	}
+
+	// Isolationsnachweis: jede DB enthält genau ihren eigenen Beleg (1), keinen fremden.
+	for i, name := range dbNames {
+		dbDSN := dsnForDB(adminDSN, name)
+		count, err := CountMarkers(ctx, dbDSN, "isolation_marker")
+		if err != nil {
+			t.Fatalf("zaehlung in db %d fehlgeschlagen: %v", i, err)
+		}
+		if count != 1 {
+			t.Errorf("db %d (%s): erwartet genau 1 eigenen Beleg, gefunden %d — Isolation verletzt", i, name, count)
+		}
+	}
+}
+
+// dsnForDB ersetzt den Datenbanknamen im Wartungs-DSN durch den gegebenen Namen.
+func dsnForDB(adminDSN, dbName string) string {
+	idx := strings.LastIndex(adminDSN, "/")
+	if idx == -1 {
+		return adminDSN
+	}
+	base := adminDSN[:idx+1]
+	rest := adminDSN[idx+1:]
+	if q := strings.Index(rest, "?"); q != -1 {
+		return base + dbName + rest[q:]
+	}
+	return base + dbName
+}
@@ -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.
@@ -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).
@@ -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.
@@ -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`).
@@ -1,36 +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/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
-)
@@ -1,64 +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/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
-github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
-github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
-github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
-github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
-golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -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
-}
@@ -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
-}
@@ -1,67 +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).
-type Envelope struct {
-	Ciphertext io.Reader
-	WrappedDEK []byte
-}
-
-// 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
-}
-
-func NewService(kek KEKProvider) *Service {
-	return &Service{kek: kek}
-}
-
-// 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).
-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
-	}
-	return &Envelope{Ciphertext: ciphertext, WrappedDEK: wrappedDEK}, 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.
-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)
-}
@@ -1,93 +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"
-	"fmt"
-	"io"
-
-	"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"
-}
-
-// 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)
-	}
-	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)
-	}
-
-	plaintextReader, err := s.crypto.Open(ctx, tenantSlug, wrappedDEK, bytes.NewReader(ciphertext))
-	if err != nil {
-		return nil, err
-	}
-	return io.ReadAll(plaintextReader)
-}
@@ -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)
-}
@@ -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})
-}
@@ -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)
-	}
-}
@@ -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
-}
@@ -1,38 +0,0 @@
-// Unit-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): keine
-// externe Abhängigkeit (DB, Netzwerk), reine Funktionsprüfung.
-package example
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestNormalizeAddress_LowercasesDomainOnly(t *testing.T) {
-	got, err := NormalizeAddress("User.Name@Example.COM")
-	if err != nil {
-		t.Fatalf("unerwarteter fehler: %v", err)
-	}
-	want := "User.Name@example.com"
-	if got != want {
-		t.Fatalf("got %q, want %q", got, want)
-	}
-}
-
-func TestNormalizeAddress_TrimsWhitespace(t *testing.T) {
-	got, err := NormalizeAddress("  user@example.com  ")
-	if err != nil {
-		t.Fatalf("unerwarteter fehler: %v", err)
-	}
-	if got != "user@example.com" {
-		t.Fatalf("got %q", got)
-	}
-}
-
-func TestNormalizeAddress_RejectsInvalidInput(t *testing.T) {
-	cases := []string{"", "no-at-sign", "@nolocalpart.com", "trailing@"}
-	for _, c := range cases {
-		if _, err := NormalizeAddress(c); !errors.Is(err, ErrInvalidAddress) {
-			t.Fatalf("input %q: erwartet ErrInvalidAddress, habe: %v", c, err)
-		}
-	}
-}
@@ -1,42 +0,0 @@
-package example
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// AddressStore ist das Integrationstest-Beispiel (QA-01): eine
-// minimale, aber echte DB-gestützte Komponente — nutzt dieselbe
-// Tenant-DB-Isolationskonvention wie DMS/Archive (t.Cleanup, geteilte
-// physische Postgres-Instanz auf dem Testhost).
-type AddressStore struct {
-	pool *pgxpool.Pool
-}
-
-func NewAddressStore(pool *pgxpool.Pool) *AddressStore {
-	return &AddressStore{pool: pool}
-}
-
-func (s *AddressStore) SaveNormalized(ctx context.Context, addr string) (string, error) {
-	normalized, err := NormalizeAddress(addr)
-	if err != nil {
-		return "", err
-	}
-	if _, err := s.pool.Exec(ctx, `
-		INSERT INTO example_addresses (address) VALUES ($1)
-		ON CONFLICT (address) DO NOTHING
-	`, normalized); err != nil {
-		return "", fmt.Errorf("example: adresse speichern: %w", err)
-	}
-	return normalized, nil
-}
-
-func (s *AddressStore) Exists(ctx context.Context, addr string) (bool, error) {
-	var exists bool
-	if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM example_addresses WHERE address = $1)`, addr).Scan(&exists); err != nil {
-		return false, fmt.Errorf("example: existenz prüfen: %w", err)
-	}
-	return exists, nil
-}
@@ -1,69 +0,0 @@
-// Integrations-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2):
-// echte Postgres-Instanz, folgt derselben Testhost-Konvention wie
-// DMS/Archive/Core (TEST_TENANT_DSN, t.Cleanup, geteilte physische
-// Instanz auf 192.168.1.131 — siehe project-nexarch-test-infra).
-package example
-
-import (
-	"context"
-	"os"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupTest(t *testing.T) *pgxpool.Pool {
-	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() })
-
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS example_addresses (
-			address TEXT PRIMARY KEY
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-	t.Cleanup(func() {
-		_, _ = pool.Exec(context.Background(), `TRUNCATE example_addresses`)
-	})
-	return pool
-}
-
-func TestAddressStore_SaveAndCheckExists(t *testing.T) {
-	pool := setupTest(t)
-	store := NewAddressStore(pool)
-	ctx := context.Background()
-
-	normalized, err := store.SaveNormalized(ctx, "Kunde@Beispiel.DE")
-	if err != nil {
-		t.Fatalf("savenormalized: %v", err)
-	}
-	if normalized != "Kunde@beispiel.de" {
-		t.Fatalf("erwartet normalisierte adresse, habe %q", normalized)
-	}
-
-	exists, err := store.Exists(ctx, normalized)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !exists {
-		t.Fatal("erwartet real gespeicherte adresse")
-	}
-
-	notExists, err := store.Exists(ctx, "unbekannt@beispiel.de")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if notExists {
-		t.Fatal("nie gespeicherte adresse haette nicht existieren duerfen")
-	}
-}
@@ -1,206 +0,0 @@
-// Package mimeparse implementiert ING-04: MIME-/Anhang-Parsing für
-// ein- und ausgehende Nachrichten (Multipart, verschachtelt,
-// Content-Transfer-Encoding, defensive Zeichensatz-Reparatur).
-//
-// NUR Parsing — Speicherung ist ARC-01s Aufgabe (siehe "Nicht
-// Bestandteil dieser Kachel"), dieses Paket schreibt nirgends in einen
-// Objekt-Speicher, sondern liefert nur strukturierte Go-Werte zurück.
-//
-// Bekannten Fehler vermieden (archivmail known-issues #3): Anhänge
-// wurden früher über io.ReadAll ohne Größenlimit gelesen — eine
-// Speicherbombe durch große/böswillige Anhänge. Hier läuft JEDER
-// Anhang-Lesevorgang über io.LimitReader mit konfigurierter Max-Size;
-// eine Überschreitung führt zu einer harten, sauberen Ablehnung
-// (ErrAttachmentTooLarge), kein stilles Abschneiden.
-package mimeparse
-
-import (
-	"bytes"
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"io"
-	"mime"
-	"mime/multipart"
-	"mime/quotedprintable"
-	"net/mail"
-	"strings"
-
-	"golang.org/x/text/encoding/htmlindex"
-)
-
-// ErrAttachmentTooLarge wird geliefert, wenn ein Anhang die
-// konfigurierte Maximalgröße überschreitet (Akzeptanzkriterium/
-// Pflichtprüfung 1).
-var ErrAttachmentTooLarge = errors.New("mimeparse: anhang überschreitet die maximal erlaubte größe")
-
-// Part ist EIN zerlegter MIME-Teil — sowohl Textteile (IsAttachment
-// == false) als auch Anhänge (Akzeptanzkriterium 1/2).
-type Part struct {
-	ContentType string
-	Filename    string
-	Size        int64
-	Content     []byte
-	IsAttachment bool
-}
-
-// Message ist das Ergebnis eines vollständig zerlegten Multipart-
-// Baums — verschachtelte multipart/*-Teile sind bereits rekursiv
-// aufgelöst, der Aufrufer sieht nur die "Blatt"-Teile (Akzeptanz-
-// kriterium 1).
-type Message struct {
-	Parts []Part
-}
-
-// wordDecoder dekodiert RFC-2047-kodierte Header-Werte (z. B.
-// Anhang-Dateinamen) defensiv: ein unbekannter/fehlerhafter
-// Zeichensatz bricht die Verarbeitung NICHT ab (Akzeptanzkriterium 3),
-// sondern liefert den Rohwert unverändert zurück.
-var wordDecoder = &mime.WordDecoder{CharsetReader: charsetReader}
-
-func charsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
-	enc, err := htmlindex.Get(charsetLabel)
-	if err != nil {
-		// Unbekannter/fehlerhafter Zeichensatz: defensiv als
-		// UTF-8-verträglichen Rohtext weiterreichen statt
-		// abzubrechen (Akzeptanzkriterium 3).
-		return input, nil
-	}
-	return enc.NewDecoder().Reader(input), nil
-}
-
-func decodeHeaderValue(raw string) string {
-	decoded, err := wordDecoder.DecodeHeader(raw)
-	if err != nil {
-		// Defensiv: Rohwert statt Abbruch (Akzeptanzkriterium 3).
-		return raw
-	}
-	return decoded
-}
-
-// Parse zerlegt eine MIME-Nachricht vollständig, inklusive
-// verschachtelter Multipart-Teile (Akzeptanzkriterium 1). maxAttachmentSize
-// begrenzt JEDEN einzelnen Anhang (Akzeptanzkriterium/Pflichtprüfung 1).
-func Parse(r io.Reader, maxAttachmentSize int64) (Message, error) {
-	msg, err := mail.ReadMessage(r)
-	if err != nil {
-		return Message{}, fmt.Errorf("mimeparse: nachricht lesen: %w", err)
-	}
-
-	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
-	if err != nil {
-		// Kein/kaputtes Content-Type: als einzelnen Textteil behandeln
-		// statt abzubrechen (Akzeptanzkriterium 3: defensiv reparieren).
-		body, readErr := readLimited(msg.Body, maxAttachmentSize)
-		if readErr != nil {
-			return Message{}, readErr
-		}
-		return Message{Parts: []Part{{ContentType: "text/plain", Content: body, Size: int64(len(body))}}}, nil
-	}
-
-	var result Message
-	if strings.HasPrefix(mediaType, "multipart/") {
-		if err := parseMultipart(msg.Body, params["boundary"], maxAttachmentSize, &result); err != nil {
-			return Message{}, err
-		}
-		return result, nil
-	}
-
-	// Einzelner Teil (keine Multipart-Hülle).
-	part, err := readSinglePart(msg.Header.Get("Content-Transfer-Encoding"), mediaType, "", msg.Body, maxAttachmentSize)
-	if err != nil {
-		return Message{}, err
-	}
-	result.Parts = append(result.Parts, part)
-	return result, nil
-}
-
-// parseMultipart löst EINEN Multipart-Container rekursiv auf —
-// verschachtelte multipart/*-Teile (z. B. multipart/mixed, das
-// multipart/alternative enthält) werden vollständig zerlegt
-// (Akzeptanzkriterium 1), keine Rekursionstiefe hartkodiert begrenzt
-// außer durch die natürliche Nachrichtengröße selbst.
-func parseMultipart(r io.Reader, boundary string, maxAttachmentSize int64, result *Message) error {
-	if boundary == "" {
-		return errors.New("mimeparse: multipart ohne boundary")
-	}
-	mr := multipart.NewReader(r, boundary)
-	for {
-		p, err := mr.NextPart()
-		if err == io.EOF {
-			return nil
-		}
-		if err != nil {
-			// Kaputte Multipart-Struktur: kontrolliert abbrechen
-			// (Pflichtprüfung 3), nicht abstürzen.
-			return fmt.Errorf("mimeparse: multipart-teil lesen: %w", err)
-		}
-
-		contentType := p.Header.Get("Content-Type")
-		mediaType, subParams, err := mime.ParseMediaType(contentType)
-		if err != nil {
-			mediaType = "text/plain"
-		}
-
-		if strings.HasPrefix(mediaType, "multipart/") {
-			if err := parseMultipart(p, subParams["boundary"], maxAttachmentSize, result); err != nil {
-				return err
-			}
-			continue
-		}
-
-		part, err := readSinglePart(p.Header.Get("Content-Transfer-Encoding"), mediaType, decodeHeaderValue(p.FileName()), p, maxAttachmentSize)
-		if err != nil {
-			return err
-		}
-		result.Parts = append(result.Parts, part)
-	}
-}
-
-func readSinglePart(transferEncoding, mediaType, filename string, r io.Reader, maxAttachmentSize int64) (Part, error) {
-	decoded := decodeTransferEncoding(transferEncoding, r)
-
-	content, err := readLimited(decoded, maxAttachmentSize)
-	if err != nil {
-		return Part{}, err
-	}
-
-	return Part{
-		ContentType:  mediaType,
-		Filename:     filename,
-		Size:         int64(len(content)),
-		Content:      content,
-		IsAttachment: filename != "",
-	}, nil
-}
-
-// decodeTransferEncoding dekodiert Content-Transfer-Encoding
-// (quoted-printable/base64) — defensiv: ein unbekanntes Encoding wird
-// unverändert durchgereicht statt die Verarbeitung abzubrechen
-// (Akzeptanzkriterium 3).
-func decodeTransferEncoding(encoding string, r io.Reader) io.Reader {
-	switch strings.ToLower(strings.TrimSpace(encoding)) {
-	case "quoted-printable":
-		return quotedprintable.NewReader(r)
-	case "base64":
-		return base64.NewDecoder(base64.StdEncoding, r)
-	default:
-		return r
-	}
-}
-
-// readLimited liest höchstens maxSize+1 Bytes — wird die Grenze
-// überschritten, wird ErrAttachmentTooLarge geliefert, statt beliebig
-// viel Speicher zu allozieren (Akzeptanzkriterium/Pflichtprüfung 1,
-// archivmail known-issues #3).
-func readLimited(r io.Reader, maxSize int64) ([]byte, error) {
-	limited := io.LimitReader(r, maxSize+1)
-	var buf bytes.Buffer
-	if _, err := io.Copy(&buf, limited); err != nil {
-		return nil, fmt.Errorf("mimeparse: teil lesen: %w", err)
-	}
-	if int64(buf.Len()) > maxSize {
-		return nil, ErrAttachmentTooLarge
-	}
-	return buf.Bytes(), nil
-}
@@ -1,219 +0,0 @@
-package mimeparse
-
-import (
-	"errors"
-	"io"
-	"strings"
-	"testing"
-)
-
-const defaultMaxSize = 10 * 1024 * 1024 // 10 MiB
-
-// TestParse_NestedMultipartFullyDecomposed ist Akzeptanzkriterium 1:
-// Multipart-Nachrichten mit verschachtelten Teilen werden vollständig
-// zerlegt (multipart/mixed enthält multipart/alternative UND einen
-// Anhang).
-func TestParse_NestedMultipartFullyDecomposed(t *testing.T) {
-	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=\"outer\"\r\n\r\n" +
-		"--outer\r\n" +
-		"Content-Type: multipart/alternative; boundary=\"inner\"\r\n\r\n" +
-		"--inner\r\n" +
-		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
-		"Hallo als Text\r\n" +
-		"--inner\r\n" +
-		"Content-Type: text/html; charset=utf-8\r\n\r\n" +
-		"<p>Hallo als HTML</p>\r\n" +
-		"--inner--\r\n" +
-		"--outer\r\n" +
-		"Content-Type: application/pdf\r\n" +
-		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		"JVBERi0xLjQK\r\n" +
-		"--outer--\r\n"
-
-	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if len(msg.Parts) != 3 {
-		t.Fatalf("erwartet 3 zerlegte teile (text, html, anhang), habe %d: %+v", len(msg.Parts), msg.Parts)
-	}
-
-	var sawText, sawHTML, sawAttachment bool
-	for _, p := range msg.Parts {
-		switch {
-		case p.ContentType == "text/plain":
-			sawText = true
-			if string(p.Content) != "Hallo als Text" {
-				t.Fatalf("unerwarteter text-inhalt: %q", p.Content)
-			}
-		case p.ContentType == "text/html":
-			sawHTML = true
-		case p.IsAttachment:
-			sawAttachment = true
-		}
-	}
-	if !sawText || !sawHTML || !sawAttachment {
-		t.Fatalf("nicht alle erwarteten teile gefunden: text=%v html=%v attachment=%v", sawText, sawHTML, sawAttachment)
-	}
-}
-
-// TestParse_AttachmentMetadataExtracted ist Akzeptanzkriterium 2:
-// Anhänge werden mit korrektem Dateinamen, Größe und Content-Type
-// extrahiert.
-func TestParse_AttachmentMetadataExtracted(t *testing.T) {
-	raw := "From: a@example.com\r\n" +
-		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
-		"--b\r\n" +
-		"Content-Type: text/plain\r\n\r\n" +
-		"Text\r\n" +
-		"--b\r\n" +
-		"Content-Type: image/png\r\n" +
-		"Content-Disposition: attachment; filename=\"bild.png\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		"iVBORw0KGgo=\r\n" +
-		"--b--\r\n"
-
-	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	var attachment *Part
-	for i := range msg.Parts {
-		if msg.Parts[i].IsAttachment {
-			attachment = &msg.Parts[i]
-		}
-	}
-	if attachment == nil {
-		t.Fatal("kein anhang gefunden")
-	}
-	if attachment.Filename != "bild.png" {
-		t.Fatalf("falscher dateiname: %q", attachment.Filename)
-	}
-	if attachment.ContentType != "image/png" {
-		t.Fatalf("falscher content-type: %q", attachment.ContentType)
-	}
-	if attachment.Size != int64(len(attachment.Content)) || attachment.Size == 0 {
-		t.Fatalf("unplausible größe: %d (content-len %d)", attachment.Size, len(attachment.Content))
-	}
-}
-
-// TestParse_BrokenCharsetIsRepairedNotAborted ist Akzeptanzkriterium 3:
-// fehlerhafte/inkonsistente Zeichensatzangaben werden defensiv repariert
-// statt die Verarbeitung abzubrechen.
-func TestParse_BrokenCharsetIsRepairedNotAborted(t *testing.T) {
-	// "unbekannt-xyz" ist KEIN gültiger IANA-Zeichensatzname.
-	raw := "From: a@example.com\r\n" +
-		"Content-Type: text/plain; charset=\"unbekannt-xyz\"\r\n\r\n" +
-		"Rohtext trotz kaputtem Charset\r\n"
-
-	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
-	if err != nil {
-		t.Fatalf("erwartet KEINEN abbruch bei kaputtem charset, habe: %v", err)
-	}
-	if len(msg.Parts) != 1 {
-		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
-	}
-	if !strings.Contains(string(msg.Parts[0].Content), "Rohtext") {
-		t.Fatalf("inhalt fehlt/verstümmelt: %q", msg.Parts[0].Content)
-	}
-}
-
-// TestParse_ISO88591BodyDecodedWithoutAbort ist Akzeptanzkriterium 3
-// zusätzlich: ein bekannter Nicht-UTF-8-Zeichensatz wird via
-// Header-Dekodierung real repariert (RFC-2047-kodierter Dateiname).
-func TestParse_ISO88591FilenameDecoded(t *testing.T) {
-	// "=?ISO-8859-1?Q?Rechnung_=DC?=" kodiert "Rechnung Ü" (0xDC = 'Ü' in Latin-1).
-	raw := "From: a@example.com\r\n" +
-		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
-		"--b\r\n" +
-		"Content-Type: application/octet-stream\r\n" +
-		"Content-Disposition: attachment; filename=\"=?ISO-8859-1?Q?Rechnung_=DC?=\"\r\n" +
-		"Content-Transfer-Encoding: base64\r\n\r\n" +
-		"AAA=\r\n" +
-		"--b--\r\n"
-
-	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if len(msg.Parts) != 1 {
-		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
-	}
-	if msg.Parts[0].Filename != "Rechnung Ü" {
-		t.Fatalf("erwartet dekodierten dateinamen 'Rechnung Ü', habe %q", msg.Parts[0].Filename)
-	}
-}
-
-// infiniteReader liefert unbegrenzt viele Bytes — simuliert einen sehr
-// großen/böswilligen Anhang. Ohne io.LimitReader (siehe archivmail
-// known-issues #3) würde ein io.ReadAll hierauf den Prozessspeicher
-// erschöpfen; mit readLimited bricht Parse kontrolliert und schnell ab.
-type infiniteReader struct{}
-
-func (infiniteReader) Read(p []byte) (int, error) {
-	for i := range p {
-		p[i] = 'A'
-	}
-	return len(p), nil
-}
-
-// TestParse_OversizedAttachmentRejectedNotMemoryExhausted ist die
-// geforderte Pflichtprüfung 1.
-func TestParse_OversizedAttachmentRejectedNotMemoryExhausted(t *testing.T) {
-	const tinyLimit = 1024 // 1 KiB — winzig, damit der Test schnell bleibt
-
-	header := "From: a@example.com\r\n" +
-		"Content-Type: application/octet-stream\r\n" +
-		"Content-Transfer-Encoding: identity\r\n\r\n"
-
-	r := io.MultiReader(strings.NewReader(header), infiniteReader{})
-	_, err := Parse(r, tinyLimit)
-	if !errors.Is(err, ErrAttachmentTooLarge) {
-		t.Fatalf("erwartet ErrAttachmentTooLarge bei unbegrenzt großem anhang, habe: %v", err)
-	}
-}
-
-// TestParse_RealisticCorpusRunsCleanly ist die geforderte
-// Pflichtprüfung 2: realitätsnahe Multipart-/Encoding-Varianten laufen
-// fehlerfrei durch.
-func TestParse_RealisticCorpusRunsCleanly(t *testing.T) {
-	corpus := []string{
-		// Einfache Textnachricht ohne Multipart.
-		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\n\r\nEinfacher Text\r\n",
-		// Quoted-Printable.
-		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\nUmlaut: =C3=9C\r\n",
-		// Multipart/alternative ohne Anhang.
-		"From: a@example.com\r\nContent-Type: multipart/alternative; boundary=\"x\"\r\n\r\n--x\r\nContent-Type: text/plain\r\n\r\nText\r\n--x\r\nContent-Type: text/html\r\n\r\n<p>Text</p>\r\n--x--\r\n",
-		// Leere Multipart-Nachricht (kein Teil, nur Präambel/Epilog).
-		"From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"y\"\r\n\r\nPräambel wird ignoriert\r\n--y--\r\nEpilog wird ignoriert\r\n",
-	}
-	for i, raw := range corpus {
-		if _, err := Parse(strings.NewReader(raw), defaultMaxSize); err != nil {
-			t.Fatalf("corpus[%d] fehlgeschlagen: %v\nraw=%q", i, err, raw)
-		}
-	}
-}
-
-// FuzzParse ist die geforderte Pflichtprüfung 3: kaputte MIME-Strukturen
-// dürfen Parse nicht zum Absturz bringen, nur zu einem kontrollierten
-// Fehler.
-func FuzzParse(f *testing.F) {
-	f.Add([]byte("From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"b\"\r\n\r\n--b\r\nContent-Type: text/plain\r\n\r\nHallo\r\n--b--\r\n"))
-	f.Add([]byte("Content-Type: multipart/mixed; boundary=\r\n\r\nkaputt"))
-	f.Add([]byte(""))
-	f.Add([]byte("From: a@example.com\r\n\r\n"))
-
-	f.Fuzz(func(t *testing.T, data []byte) {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("Parse ist abgestürzt (panic) statt kontrolliert einen Fehler zu liefern: %v", r)
-			}
-		}()
-		_, _ = Parse(strings.NewReader(string(data)), defaultMaxSize)
-	})
-}
@@ -1,72 +0,0 @@
-// Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-MAIL.md
-// Abschnitt 4 festgelegte Regel: jede geänderte Go-Datei in einem
-// sicherheitskritischen Bereich (Auth, Tenant-Scoping, Protokoll-/
-// Compliance-kritisch) muss von einer geänderten oder neuen _test.go-
-// Datei im selben Package begleitet sein. Bewusste Code-Kopie des
-// Musters aus Core internal/pflichttestgate — Mail ist ein eigenständiges
-// Go-Modul und kann Core nicht importieren.
-package pflichttestgate
-
-import (
-	"path"
-	"regexp"
-	"strings"
-)
-
-// sensitivePathPatterns beschreibt die Bereiche aus
-// TESTSTRATEGIE-MAIL.md Abschnitt 4.
-var sensitivePathPatterns = []*regexp.Regexp{
-	regexp.MustCompile(`(^|/)mail/internal/auth/`),
-	regexp.MustCompile(`(^|/)mail/internal/tenant/`),
-	regexp.MustCompile(`(^|/)mail/internal/ingest/`),
-	regexp.MustCompile(`(^|/)mail/internal/imap/`),
-	regexp.MustCompile(`(^|/)mail/internal/smtp/`),
-	regexp.MustCompile(`(^|/)mail/internal/arc/`),
-}
-
-// Violation beschreibt ein Package mit sicherheitskritischer Änderung
-// ohne begleitende Testdatei.
-type Violation struct {
-	Package     string
-	ChangedFile string
-}
-
-func isSensitive(file string) bool {
-	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
-		return false
-	}
-	for _, re := range sensitivePathPatterns {
-		if re.MatchString(file) {
-			return true
-		}
-	}
-	return false
-}
-
-// CheckDiff prüft eine Liste geänderter Dateipfade gegen die
-// Pflichttest-Regel — ein leeres Ergebnis bedeutet: Gate besteht.
-func CheckDiff(changedFiles []string) []Violation {
-	sensitiveByPkg := map[string]string{}
-	testTouchedPkgs := map[string]bool{}
-
-	for _, f := range changedFiles {
-		pkg := path.Dir(f)
-		if strings.HasSuffix(f, "_test.go") {
-			testTouchedPkgs[pkg] = true
-			continue
-		}
-		if isSensitive(f) {
-			if _, seen := sensitiveByPkg[pkg]; !seen {
-				sensitiveByPkg[pkg] = f
-			}
-		}
-	}
-
-	var violations []Violation
-	for pkg, file := range sensitiveByPkg {
-		if !testTouchedPkgs[pkg] {
-			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
-		}
-	}
-	return violations
-}
@@ -1,33 +0,0 @@
-// Negativtest des Gates selbst (QA-01 Prüfung 1): ein Diff mit
-// geänderter mail/internal/auth/login.go ohne begleitende Testdatei
-// muss als Verstoß erkannt werden.
-package pflichttestgate
-
-import "testing"
-
-func TestCheckDiff_FlagsSensitiveChangeWithoutTest(t *testing.T) {
-	violations := CheckDiff([]string{"mail/internal/auth/login.go"})
-	if len(violations) != 1 {
-		t.Fatalf("erwartet genau 1 verstoß, habe %d: %+v", len(violations), violations)
-	}
-	if violations[0].Package != "mail/internal/auth" {
-		t.Fatalf("falsches package gemeldet: %+v", violations[0])
-	}
-}
-
-func TestCheckDiff_PassesWhenTestFileAccompanies(t *testing.T) {
-	violations := CheckDiff([]string{
-		"mail/internal/auth/login.go",
-		"mail/internal/auth/login_test.go",
-	})
-	if len(violations) != 0 {
-		t.Fatalf("erwartet keine verstöße, habe: %+v", violations)
-	}
-}
-
-func TestCheckDiff_IgnoresNonSensitivePaths(t *testing.T) {
-	violations := CheckDiff([]string{"mail/internal/example/normalize.go"})
-	if len(violations) != 0 {
-		t.Fatalf("erwartet keine verstöße für nicht-sensiblen pfad, habe: %+v", violations)
-	}
-}
@@ -1,49 +0,0 @@
-// Package storage implementiert ARC-01: die Objekt-Speicher-Anbindung
-// für archivierte Mails und Anhänge. Baut auf demselben bewährten
-// Muster wie DMS FDN-03 auf (austauschbare Driver, LocalDriver für
-// Entwicklung, S3Driver für Produktion) — Mail kann DMS' internal/
-// nicht importieren (eigenständiges Go-Modul), daher eine bewusste,
-// angepasste Neuimplementierung statt eines Cross-Modul-Imports.
-//
-// Erweiterung gegenüber FDN-03: ARC-01 verlangt Prüfsummenverifikation
-// AN DIESER SCHICHT (Akzeptanzkriterium 2), nicht erst an einer
-// späteren DB-Schicht — siehe service.go.
-package storage
-
-import (
-	"context"
-	"errors"
-	"io"
-	"strconv"
-)
-
-// ErrNotFound wird geliefert, wenn ein angefragtes Objekt nicht
-// existiert.
-var ErrNotFound = errors.New("storage: objekt nicht gefunden")
-
-// Driver ist die EINE Schnittstelle, gegen die der Rest von Mail
-// arbeitet (Akzeptanzkriterium 1). Zwei Implementierungen: LocalDriver
-// (Entwicklung) und S3Driver (Produktion, S3-kompatibel).
-type Driver interface {
-	Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (int64, error)
-	Get(ctx context.Context, key string) (io.ReadCloser, error)
-	Delete(ctx context.Context, key string) error
-}
-
-// ObjectKey liefert das feste, dokumentierte Pfadschema für einen
-// Mail-Anhang/-Teil INNERHALB des bereits mandantenspezifischen
-// Buckets (Akzeptanzkriterium 1) — Bucket-Trennung selbst ist Sache
-// von Core TEN-01. Lesezugriff hängt NUR von messageID+partIndex ab,
-// nicht vom ursprünglichen Importpfad (IMAP/SMTP/manueller Import —
-// Akzeptanzkriterium 3): derselbe Key wird unabhängig davon berechnet,
-// über welchen Weg die Nachricht ins System kam.
-func ObjectKey(messageID string, partIndex int) string {
-	return "messages/" + messageID + "/parts/" + strconv.Itoa(partIndex)
-}
-
-// checksumKey ist der Sidecar-Objektschlüssel für die beim Schreiben
-// berechnete Prüfsumme (siehe service.go) — liegt bewusst im selben
-// Driver/Bucket wie der Inhalt, keine separate DB-Abhängigkeit nötig.
-func checksumKey(key string) string {
-	return key + ".sha256"
-}
@@ -1,63 +0,0 @@
-package storage
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// LocalDriver legt Objekte im lokalen Dateisystem ab — der
-// Entwicklungs-Treiber (Akzeptanzkriterium 1), keine externe
-// Abhängigkeit nötig.
-type LocalDriver struct {
-	baseDir string
-}
-
-func NewLocalDriver(baseDir string) *LocalDriver {
-	return &LocalDriver{baseDir: baseDir}
-}
-
-func (d *LocalDriver) path(key string) string {
-	return filepath.Join(d.baseDir, filepath.FromSlash(key))
-}
-
-func (d *LocalDriver) Put(_ context.Context, key string, r io.Reader, _ int64, _ string) (int64, error) {
-	full := d.path(key)
-	if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
-		return 0, fmt.Errorf("storage: verzeichnis anlegen: %w", err)
-	}
-	f, err := os.Create(full)
-	if err != nil {
-		return 0, fmt.Errorf("storage: datei anlegen: %w", err)
-	}
-	defer func() { _ = f.Close() }()
-
-	written, err := io.Copy(f, r)
-	if err != nil {
-		return 0, fmt.Errorf("storage: schreiben: %w", err)
-	}
-	return written, nil
-}
-
-func (d *LocalDriver) Get(_ context.Context, key string) (io.ReadCloser, error) {
-	f, err := os.Open(d.path(key))
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, ErrNotFound
-		}
-		return nil, fmt.Errorf("storage: lesen: %w", err)
-	}
-	return f, nil
-}
-
-func (d *LocalDriver) Delete(_ context.Context, key string) error {
-	if err := os.Remove(d.path(key)); err != nil {
-		if os.IsNotExist(err) {
-			return ErrNotFound
-		}
-		return fmt.Errorf("storage: löschen: %w", err)
-	}
-	return nil
-}
@@ -1,110 +0,0 @@
-package storage
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-
-	"github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go-v2/config"
-	"github.com/aws/aws-sdk-go-v2/credentials"
-	"github.com/aws/aws-sdk-go-v2/service/s3"
-	"github.com/aws/aws-sdk-go-v2/service/s3/types"
-	"github.com/aws/smithy-go"
-)
-
-// S3Driver legt Objekte in einem S3-kompatiblen Objektspeicher ab — der
-// Produktions-Treiber (Akzeptanzkriterium 1). Funktioniert gegen echtes
-// AWS S3 UND gegen jeden S3-kompatiblen Anbieter (MinIO etc.) über
-// endpointURL. Gleiches, bewährtes Muster wie DMS FDN-03s S3Driver
-// (bewusste Kopie, Mail kann DMS nicht importieren).
-type S3Driver struct {
-	client *s3.Client
-	bucket string
-}
-
-func NewS3Driver(ctx context.Context, bucket, region, endpointURL, accessKeyID, secretAccessKey string, usePathStyle bool) (*S3Driver, error) {
-	cfg, err := config.LoadDefaultConfig(ctx,
-		config.WithRegion(region),
-		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
-	)
-	if err != nil {
-		return nil, fmt.Errorf("storage: s3-konfiguration laden: %w", err)
-	}
-
-	client := s3.NewFromConfig(cfg, func(o *s3.Options) {
-		if endpointURL != "" {
-			o.BaseEndpoint = aws.String(endpointURL)
-		}
-		o.UsePathStyle = usePathStyle
-	})
-	return &S3Driver{client: client, bucket: bucket}, nil
-}
-
-func (d *S3Driver) Put(ctx context.Context, key string, r io.Reader, _ int64, contentType string) (int64, error) {
-	buf, err := io.ReadAll(r)
-	if err != nil {
-		return 0, fmt.Errorf("storage: objekt vor upload lesen: %w", err)
-	}
-	_, err = d.client.PutObject(ctx, &s3.PutObjectInput{
-		Bucket:        aws.String(d.bucket),
-		Key:           aws.String(key),
-		Body:          bytes.NewReader(buf),
-		ContentLength: aws.Int64(int64(len(buf))),
-		ContentType:   aws.String(contentType),
-	})
-	if err != nil {
-		return 0, fmt.Errorf("storage: s3-upload: %w", err)
-	}
-	return int64(len(buf)), nil
-}
-
-func (d *S3Driver) Get(ctx context.Context, key string) (io.ReadCloser, error) {
-	out, err := d.client.GetObject(ctx, &s3.GetObjectInput{
-		Bucket: aws.String(d.bucket),
-		Key:    aws.String(key),
-	})
-	if err != nil {
-		if isS3NotFound(err) {
-			return nil, ErrNotFound
-		}
-		return nil, fmt.Errorf("storage: s3-download: %w", err)
-	}
-	return out.Body, nil
-}
-
-func (d *S3Driver) Delete(ctx context.Context, key string) error {
-	// S3 liefert bei DeleteObject fuer ein nicht existierendes Objekt
-	// KEINEN Fehler (idempotente S3-API-Semantik) — um denselben
-	// Vertrag wie LocalDriver (ErrNotFound bei fehlendem Objekt) zu
-	// erfüllen, wird die Existenz vorher explizit geprüft.
-	_, err := d.client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: aws.String(d.bucket), Key: aws.String(key)})
-	if err != nil {
-		if isS3NotFound(err) {
-			return ErrNotFound
-		}
-		return fmt.Errorf("storage: s3-existenzprüfung vor löschen: %w", err)
-	}
-
-	if _, err := d.client.DeleteObject(ctx, &s3.DeleteObjectInput{
-		Bucket: aws.String(d.bucket),
-		Key:    aws.String(key),
-	}); err != nil {
-		return fmt.Errorf("storage: s3-löschen: %w", err)
-	}
-	return nil
-}
-
-func isS3NotFound(err error) bool {
-	var nsk *types.NoSuchKey
-	if errors.As(err, &nsk) {
-		return true
-	}
-	var apiErr smithy.APIError
-	if errors.As(err, &apiErr) && apiErr.ErrorCode() == "NotFound" {
-		return true
-	}
-	return false
-}
@@ -1,127 +0,0 @@
-package storage
-
-import (
-	"bytes"
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-)
-
-// ErrChecksumMismatch wird von GetVerified geliefert, wenn der beim
-// Lesen berechnete Hash nicht mit der beim Schreiben gespeicherten
-// Prüfsumme übereinstimmt (Akzeptanzkriterium 2 / Pflichtprüfung 2:
-// ein absichtlich beschädigtes Objekt wird erkannt).
-var ErrChecksumMismatch = errors.New("storage: prüfsumme stimmt nicht überein — objekt wurde verändert")
-
-// Service verbindet einen Driver mit Prüfsummenverifikation
-// (Akzeptanzkriterium 2) und der Nutzungsmeldung an Core LIC-05
-// (Akzeptanzkriterium 4) — jeder Schreib-/Löschvorgang über Service
-// löst GENAU EINE Meldung mit der tatsächlich geschriebenen/gelöschten
-// Objektgröße aus. Aufrufer (spätere Tickets, z. B. IMP-*) rufen
-// ausschließlich Service auf, nie einen Driver direkt.
-type Service struct {
-	driver     Driver
-	usage      UsageReporter
-	tenantSlug string
-}
-
-func NewService(driver Driver, usage UsageReporter, tenantSlug string) *Service {
-	return &Service{driver: driver, usage: usage, tenantSlug: tenantSlug}
-}
-
-// Put legt den Inhalt ab UND verifiziert den Schreibvorgang durch
-// Prüfsummenvergleich (Akzeptanzkriterium 2): der Inhalt wird
-// geschrieben, die Prüfsumme als Sidecar-Objekt gespeichert, danach
-// SOFORT zurückgelesen und erneut gehasht — weicht der Rückgelesene
-// Hash vom beim Schreiben berechneten ab, meldet Put einen Fehler,
-// statt eine unbemerkt fehlerhafte Ablage stehen zu lassen. Meldet die
-// geschriebene Größe als positives Delta an Core LIC-05
-// (Akzeptanzkriterium 4).
-func (s *Service) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) (checksum string, err error) {
-	hasher := sha256.New()
-	tee := io.TeeReader(r, hasher)
-
-	written, err := s.driver.Put(ctx, key, tee, size, contentType)
-	if err != nil {
-		return "", err
-	}
-	checksum = hex.EncodeToString(hasher.Sum(nil))
-
-	if _, err := s.driver.Put(ctx, checksumKey(key), bytes.NewReader([]byte(checksum)), int64(len(checksum)), "text/plain"); err != nil {
-		return "", fmt.Errorf("storage: prüfsumme speichern: %w", err)
-	}
-
-	// Sofortige Rücklese-Verifikation — beweist, dass der Schreibvorgang
-	// tatsächlich verifiziert wurde, nicht nur eine Prüfsumme abgelegt
-	// wurde, die nie geprüft wird.
-	if _, err := s.GetVerified(ctx, key); err != nil {
-		return "", fmt.Errorf("storage: schreibverifikation fehlgeschlagen: %w", err)
-	}
-
-	if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, written); err != nil {
-		return checksum, fmt.Errorf("storage: objekt gespeichert, aber nutzungsmeldung fehlgeschlagen: %w", err)
-	}
-	return checksum, nil
-}
-
-// Get liefert den Inhalt UNVERIFIZIERT (Streaming, für große Objekte).
-// Für die Pflichtprüfung "beschädigtes Objekt wird erkannt" GetVerified
-// verwenden.
-func (s *Service) Get(ctx context.Context, key string) (io.ReadCloser, error) {
-	return s.driver.Get(ctx, key)
-}
-
-// GetVerified liest den vollständigen Inhalt UND vergleicht die beim
-// Schreiben gespeicherte Prüfsumme gegen den beim Lesen berechneten
-// Hash (Akzeptanzkriterium 2 / Pflichtprüfung 2).
-func (s *Service) GetVerified(ctx context.Context, key string) ([]byte, error) {
-	sumReader, err := s.driver.Get(ctx, checksumKey(key))
-	if err != nil {
-		return nil, fmt.Errorf("storage: gespeicherte prüfsumme lesen: %w", err)
-	}
-	expectedRaw, err := io.ReadAll(sumReader)
-	_ = sumReader.Close()
-	if err != nil {
-		return nil, fmt.Errorf("storage: gespeicherte prüfsumme lesen: %w", err)
-	}
-	expected := string(expectedRaw)
-
-	contentReader, err := s.driver.Get(ctx, key)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = contentReader.Close() }()
-
-	hasher := sha256.New()
-	content, err := io.ReadAll(io.TeeReader(contentReader, hasher))
-	if err != nil {
-		return nil, fmt.Errorf("storage: objekt lesen: %w", err)
-	}
-	actual := hex.EncodeToString(hasher.Sum(nil))
-	if actual != expected {
-		return nil, ErrChecksumMismatch
-	}
-	return content, nil
-}
-
-// Delete entfernt Inhalt UND Prüfsummen-Sidecar, meldet die Größe als
-// negatives Delta an Core LIC-05 (Akzeptanzkriterium 4) — der Aufrufer
-// muss die Größe kennen (Delete selbst kann sie nach dem Löschen nicht
-// mehr ermitteln).
-func (s *Service) Delete(ctx context.Context, key string, sizeBytes int64) error {
-	if err := s.driver.Delete(ctx, key); err != nil {
-		return err
-	}
-	// Sidecar-Löschung ist best effort — ein fehlendes Sidecar (z. B.
-	// bei einem sehr alten Objekt) darf den eigentlichen Löschvorgang
-	// nicht blockieren.
-	_ = s.driver.Delete(ctx, checksumKey(key))
-
-	if err := s.usage.Report(ctx, s.tenantSlug, UsageMetric, -sizeBytes); err != nil {
-		return fmt.Errorf("storage: objekt gelöscht, aber nutzungsmeldung fehlgeschlagen: %w", err)
-	}
-	return nil
-}
@@ -1,134 +0,0 @@
-package storage
-
-import (
-	"context"
-	"errors"
-	"os"
-	"strings"
-	"testing"
-	"time"
-)
-
-type fakeUsageReporter struct {
-	reports []int64
-}
-
-func (f *fakeUsageReporter) Report(_ context.Context, _, metric string, delta int64) error {
-	if metric != UsageMetric {
-		return errors.New("unerwartete metrik: " + metric)
-	}
-	f.reports = append(f.reports, delta)
-	return nil
-}
-
-func newTestService(t *testing.T) (*Service, *fakeUsageReporter) {
-	t.Helper()
-	driver := NewLocalDriver(t.TempDir())
-	usage := &fakeUsageReporter{}
-	return NewService(driver, usage, "acme"), usage
-}
-
-// TestPut_ReadBackIsByteIdentical ist die geforderte Pflichtprüfung 1:
-// ein geschriebenes Objekt liefert beim Lesen byteidentischen Inhalt.
-func TestPut_ReadBackIsByteIdentical(t *testing.T) {
-	svc, _ := newTestService(t)
-	ctx := context.Background()
-	key := ObjectKey("msg-1", 0)
-	content := "vollständig identischer Inhalt äöü"
-
-	checksum, err := svc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain")
-	if err != nil {
-		t.Fatalf("put: %v", err)
-	}
-	if checksum == "" {
-		t.Fatal("erwartet nicht-leere prüfsumme")
-	}
-
-	got, err := svc.GetVerified(ctx, key)
-	if err != nil {
-		t.Fatalf("getverified: %v", err)
-	}
-	if string(got) != content {
-		t.Fatalf("nicht byteidentisch: got %q, want %q", got, content)
-	}
-}
-
-// TestGetVerified_DetectsTamperedObject ist die geforderte
-// Pflichtprüfung 2: ein absichtlich beschädigtes Objekt wird bei
-// Prüfsummenvergleich erkannt.
-func TestGetVerified_DetectsTamperedObject(t *testing.T) {
-	dir := t.TempDir()
-	driver := NewLocalDriver(dir)
-	usage := &fakeUsageReporter{}
-	svc := NewService(driver, usage, "acme")
-	ctx := context.Background()
-	key := ObjectKey("msg-tamper", 0)
-
-	if _, err := svc.Put(ctx, key, strings.NewReader("originaler inhalt"), 17, "text/plain"); err != nil {
-		t.Fatalf("put: %v", err)
-	}
-
-	// Objekt DIREKT am Dateisystem manipulieren — umgeht Service
-	// vollständig, simuliert externe Beschädigung/Manipulation.
-	full := driver.path(key)
-	if err := os.WriteFile(full, []byte("MANIPULIERTER INHALT"), 0o644); err != nil {
-		t.Fatalf("manipulation schreiben: %v", err)
-	}
-
-	_, err := svc.GetVerified(ctx, key)
-	if !errors.Is(err, ErrChecksumMismatch) {
-		t.Fatalf("erwartet ErrChecksumMismatch bei manipuliertem objekt, habe: %v", err)
-	}
-}
-
-// TestPut_ManySmallObjectsAcceptableLatency ist die geforderte
-// Pflichtprüfung 3: Lasttest mit vielen kleinen Objekten bestätigt
-// akzeptable Latenz.
-func TestPut_ManySmallObjectsAcceptableLatency(t *testing.T) {
-	svc, _ := newTestService(t)
-	ctx := context.Background()
-
-	const count = 500
-	start := time.Now()
-	for i := 0; i < count; i++ {
-		key := ObjectKey("msg-load", i)
-		if _, err := svc.Put(ctx, key, strings.NewReader("kleiner anhang inhalt"), 21, "text/plain"); err != nil {
-			t.Fatalf("put #%d: %v", i, err)
-		}
-	}
-	elapsed := time.Since(start)
-	avgPerObject := elapsed / count
-
-	// Großzügige Grenze (10ms/Objekt inkl. Schreiben+Sidecar+Rücklese-
-	// Verifikation) — Ziel ist der Nachweis, dass keine quadratische
-	// oder anderweitig unverhältnismäßige Verschlechterung auftritt,
-	// nicht ein knallhartes Performance-SLA.
-	if avgPerObject > 10*time.Millisecond {
-		t.Fatalf("erwartet akzeptable latenz (<10ms/objekt), habe %v/objekt (gesamt %v für %d objekte)", avgPerObject, elapsed, count)
-	}
-	t.Logf("Lasttest: %d Objekte in %v (%v/Objekt)", count, elapsed, avgPerObject)
-}
-
-// TestPut_ReportsUsageOnWriteAndDelete ist die geforderte
-// Pflichtprüfung 4: Melde-Aufruf an Core LIC-05 bei Schreib- und
-// Löschvorgang nachweislich ausgelöst, mit korrekter Größenangabe.
-func TestPut_ReportsUsageOnWriteAndDelete(t *testing.T) {
-	svc, usage := newTestService(t)
-	ctx := context.Background()
-	key := ObjectKey("msg-usage", 0)
-	content := "zwölf bytes!"
-
-	if _, err := svc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
-		t.Fatalf("put: %v", err)
-	}
-	if len(usage.reports) != 1 || usage.reports[0] != int64(len(content)) {
-		t.Fatalf("erwartet genau eine positive meldung mit größe %d, habe: %v", len(content), usage.reports)
-	}
-
-	if err := svc.Delete(ctx, key, int64(len(content))); err != nil {
-		t.Fatalf("delete: %v", err)
-	}
-	if len(usage.reports) != 2 || usage.reports[1] != -int64(len(content)) {
-		t.Fatalf("erwartet zusätzliche negative meldung mit -%d, habe: %v", len(content), usage.reports)
-	}
-}
@@ -1,75 +0,0 @@
-package storage
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-)
-
-// UsageMetric ist der Metrikname, unter dem Core (internal/usage,
-// LIC-05) den Speicherverbrauch je Mandant führt — muss exakt
-// internal/usage.StorageBytesMetric aus dem NEXARCH-Core-Modul
-// entsprechen (Mail kann Core nicht importieren, daher hier gespiegelt
-// — identisches Muster wie DMS FDN-03).
-const UsageMetric = "storage_bytes"
-
-// UsageReporter meldet Speicherverbrauchsänderungen an Core
-// (Akzeptanzkriterium 4). Schmale Schnittstelle, damit Tests einen
-// Fake statt eines echten HTTP-Aufrufs einsetzen können.
-type UsageReporter interface {
-	Report(ctx context.Context, tenantSlug, metric string, delta int64) error
-}
-
-// usageDeltaDTO entspricht Core internal/resync.usageDeltaDTO
-// (JSON-Vertrag: tenant_slug/metric/delta), über den API-11
-// (resync-api) real erreichbar ist.
-type usageDeltaDTO struct {
-	TenantSlug string `json:"tenant_slug"`
-	Metric     string `json:"metric"`
-	Delta      int64  `json:"delta"`
-}
-
-// HTTPUsageReporter meldet über Core API-11 (resync-api,
-// internal/resync.Handler.UsageHandler), authentifiziert über
-// dasselbe Service-Credential-Verfahren wie jeder andere Modul-Core-
-// Aufruf (API-02).
-type HTTPUsageReporter struct {
-	endpointURL  string
-	clientID     string
-	clientSecret string
-	httpClient   *http.Client
-}
-
-func NewHTTPUsageReporter(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPUsageReporter {
-	if httpClient == nil {
-		httpClient = http.DefaultClient
-	}
-	return &HTTPUsageReporter{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
-}
-
-func (r *HTTPUsageReporter) Report(ctx context.Context, tenantSlug, metric string, delta int64) error {
-	body, err := json.Marshal([]usageDeltaDTO{{TenantSlug: tenantSlug, Metric: metric, Delta: delta}})
-	if err != nil {
-		return fmt.Errorf("storage: nutzungsmeldung serialisieren: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.endpointURL, bytes.NewReader(body))
-	if err != nil {
-		return fmt.Errorf("storage: nutzungsmeldungs-anfrage aufbauen: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-Nexarch-Client-Id", r.clientID)
-	req.Header.Set("X-Nexarch-Client-Secret", r.clientSecret)
-
-	resp, err := r.httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("storage: nutzungsmeldung senden: %w", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("storage: nutzungsmeldung von core abgelehnt: status %d", resp.StatusCode)
-	}
-	return nil
-}
Author	SHA1	Message	Date
sysops	34498c415a	QA-01: go.sum ergaenzen (fehlte, go mod tidy auf Testhost verifiziert)	2026-08-28 22:43:57 +02:00
sysops	5a0d07444c	QA-01: teststrategie-core (pflichttest-gate, testdb-isolationsnachweis, ci-workflow)	2026-08-28 22:41:06 +02:00