AUD-03: audit-log-export-filter-api

internal/audit/export.go: StreamCSV/StreamJSON filtern nach Tenant, Akteur,
Aktion und Zeitraum (Akzeptanzkriterium 1) und schreiben Zeile fuer Zeile
ueber rows.Next() DIREKT auf den uebergebenen io.Writer — zu keinem
Zeitpunkt wird das komplette Ergebnis im Speicher aufgebaut (Akzeptanz-
kriterium 3). JSON-Export als JSON Lines statt einem grossen Array, um
Streaming ohne Sonderbehandlung von Klammern/Kommas zu ermoeglichen.

ExportHandler (Akzeptanzkriterium 2) schreibt direkt auf http.ResponseWriter
— derselbe Streaming-Pfad wie in Tests, kein Zwischenpuffer nur fuer HTTP.
Authorize ist eine schmale Schnittstelle (Vorbild: AUD-05 RetentionRegistrar-
Muster), da die eigentliche Rollenpruefung RBAC-02 (Policy-Enforcement) ist
und nicht Teil dieser Kachel — der Handler kennt nur "darf dieser Aufrufer
exportieren", nicht wie das entschieden wird.

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Export mit hoher Eintragszahl ohne uebermaessigen Speicherverbrauch —
   TestExport_StreamsLargeResultWithoutExcessiveMemory: 20.000 Eintraege,
   Heap-Wachstum waehrend Export nur ~1.8KB (Schwelle 3MB). PASS.
2. Filterkombinationen automatisiert gegen erwartete Ergebnismengen —
   TestExport_FilterCombinations (Tenant/Actor/Action einzeln und kombiniert)
   und TestExport_TimeRangeFilter (innerhalb/ausserhalb Zeitraum). PASS.
3. Zugriff ohne passende Berechtigung abgewiesen —
   TestExportHandler_RejectsWithoutAuthorization: fehlender/falscher caller
   -> 403, berechtigter caller -> 200. PASS.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

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

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

DEVLOG.md

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

cmd/core/main.go

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

go.mod

@@ -3,3 +3,12 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
 
 require github.com/jackc/pgx/v5 v5.6.0
+
+require (
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)

internal/audit/audit.go

@@ -0,0 +1,96 @@
+// Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
+// Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
+// compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
+// Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
+// — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
+// Schreibpfad (Akzeptanzkriterium 3).
+package audit
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
+// Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
+// Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
+const SystemTenant = "system"
+
+var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
+var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
+var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
+
+// Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
+// Aktion, Zielobjekt, Zeitpunkt, Tenant).
+type Event struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	Target     string
+	Metadata   map[string]any
+	OccurredAt time.Time
+}
+
+// Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
+// bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
+// direkt in audit_events schreibt und dabei die Validierung umgeht
+// (Akzeptanzkriterium 3).
+type Log struct {
+	pool *pgxpool.Pool
+}
+
+func NewLog(pool *pgxpool.Pool) *Log {
+	return &Log{pool: pool}
+}
+
+// Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
+// bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
+// Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
+// zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
+func (l *Log) Record(ctx context.Context, e Event) error {
+	if e.TenantSlug == "" {
+		return ErrMissingTenant
+	}
+	if e.Actor == "" {
+		return ErrMissingActor
+	}
+	if e.Action == "" {
+		return ErrMissingAction
+	}
+	if e.Metadata == nil {
+		e.Metadata = map[string]any{}
+	}
+	metadataJSON, err := json.Marshal(e.Metadata)
+	if err != nil {
+		return fmt.Errorf("metadaten serialisieren: %w", err)
+	}
+	if e.OccurredAt.IsZero() {
+		e.OccurredAt = time.Now()
+	}
+
+	_, err = l.pool.Exec(ctx, `
+		INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
+		VALUES ($1, $2, $3, $4, $5, $6)
+	`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
+	if err != nil {
+		return fmt.Errorf("audit-ereignis schreiben: %w", err)
+	}
+	return nil
+}
+
+// CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
+// eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
+func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
+	var n int
+	if err := l.pool.QueryRow(ctx, `
+		SELECT count(*) FROM audit_events WHERE tenant_slug = $1
+	`, tenantSlug).Scan(&n); err != nil {
+		return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
+	}
+	return n, nil
+}

internal/audit/audit_test.go

@@ -0,0 +1,132 @@
+package audit
+
+import (
+	"context"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupAuditTest(t *testing.T) (*Log, *pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
+		pool.Close()
+	}
+	return NewLog(pool), pool, cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
+// (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
+func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
+	log, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{
+		TenantSlug: "test_acme",
+		Actor:      "alice@example.com",
+		Action:     "iam.login_failed",
+		Target:     "user:alice@example.com",
+		Metadata:   map[string]any{"reason": "falsches passwort"},
+	})
+	if err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	count, err := log.CountByTenant(ctx, "test_acme")
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
+	}
+
+	var actor, action, target string
+	if err := pool.QueryRow(ctx, `
+		SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
+	`).Scan(&actor, &action, &target); err != nil {
+		t.Fatalf("eintrag lesen: %v", err)
+	}
+	if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
+		t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
+// bereits vom zentralen Schreibpfad abgewiesen.
+func TestRecord_RejectsMissingTenant(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
+	if !errors.Is(err, ErrMissingTenant) {
+		t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
+// der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
+// Schutz haengt nicht allein von der Go-Validierung ab.
+func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
+	_, pool, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	_, err := pool.Exec(ctx, `
+		INSERT INTO audit_events (tenant_slug, actor, action, target)
+		VALUES ('', 'alice', 'irgendwas', 'ziel')
+	`)
+	if err == nil {
+		t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
+	}
+}
+
+func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
+		t.Fatalf("erwartet ErrMissingActor, habe %v", err)
+	}
+	if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
+		t.Fatalf("erwartet ErrMissingAction, habe %v", err)
+	}
+}
+
+func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
+	log, _, cleanup := setupAuditTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
+		t.Fatalf("record mit SystemTenant: %v", err)
+	}
+}

internal/audit/export.go

@@ -0,0 +1,122 @@
+package audit
+
+import (
+	"context"
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+)
+
+// Filter grenzt einen Export ein (Akzeptanzkriterium 1). Leere/Nil-Felder
+// bedeuten "kein Filter auf diesem Feld".
+type Filter struct {
+	TenantSlug string
+	Actor      string
+	Action     string
+	From       *time.Time
+	To         *time.Time
+}
+
+func buildFilterQuery(f Filter) (string, []any) {
+	query := `SELECT occurred_at, tenant_slug, actor, action, target, metadata FROM audit_events WHERE 1=1`
+	var args []any
+
+	if f.TenantSlug != "" {
+		args = append(args, f.TenantSlug)
+		query += fmt.Sprintf(" AND tenant_slug = $%d", len(args))
+	}
+	if f.Actor != "" {
+		args = append(args, f.Actor)
+		query += fmt.Sprintf(" AND actor = $%d", len(args))
+	}
+	if f.Action != "" {
+		args = append(args, f.Action)
+		query += fmt.Sprintf(" AND action = $%d", len(args))
+	}
+	if f.From != nil {
+		args = append(args, *f.From)
+		query += fmt.Sprintf(" AND occurred_at >= $%d", len(args))
+	}
+	if f.To != nil {
+		args = append(args, *f.To)
+		query += fmt.Sprintf(" AND occurred_at <= $%d", len(args))
+	}
+	query += " ORDER BY occurred_at"
+	return query, args
+}
+
+// StreamCSV schreibt gefilterte Audit-Eintraege direkt als CSV in w, Zeile
+// fuer Zeile ueber rows.Next() — es wird zu keinem Zeitpunkt das gesamte
+// Ergebnis im Speicher aufgebaut (Akzeptanzkriterium 3 / Pruefung 1).
+func (l *Log) StreamCSV(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	cw := csv.NewWriter(w)
+	if err := cw.Write([]string{"occurred_at", "tenant_slug", "actor", "action", "target", "metadata"}); err != nil {
+		return fmt.Errorf("csv-header schreiben: %w", err)
+	}
+
+	for rows.Next() {
+		var occurredAt time.Time
+		var tenantSlug, actor, action, target string
+		var metadataJSON []byte
+		if err := rows.Scan(&occurredAt, &tenantSlug, &actor, &action, &target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		if err := cw.Write([]string{
+			occurredAt.Format(time.RFC3339), tenantSlug, actor, action, target, string(metadataJSON),
+		}); err != nil {
+			return fmt.Errorf("csv-zeile schreiben: %w", err)
+		}
+	}
+	cw.Flush()
+	if err := rows.Err(); err != nil {
+		return fmt.Errorf("export lesen: %w", err)
+	}
+	return cw.Error()
+}
+
+// exportRecord ist die JSON-Repraesentation einer exportierten Zeile.
+type exportRecord struct {
+	OccurredAt time.Time       `json:"occurred_at"`
+	TenantSlug string          `json:"tenant_slug"`
+	Actor      string          `json:"actor"`
+	Action     string          `json:"action"`
+	Target     string          `json:"target"`
+	Metadata   json.RawMessage `json:"metadata"`
+}
+
+// StreamJSON schreibt gefilterte Audit-Eintraege als JSON Lines (ein
+// JSON-Objekt pro Zeile) — bewusst kein einzelnes grosses JSON-Array, da
+// dessen korrektes Streaming (Kommas/Klammern ohne Zwischenpufferung)
+// unnoetige Komplexitaet fuer denselben Zweck waere. Wie StreamCSV
+// zeilenweise ueber rows.Next(), kein Aufbau im Speicher.
+func (l *Log) StreamJSON(ctx context.Context, filter Filter, w io.Writer) error {
+	query, args := buildFilterQuery(filter)
+	rows, err := l.pool.Query(ctx, query, args...)
+	if err != nil {
+		return fmt.Errorf("export abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	enc := json.NewEncoder(w)
+	for rows.Next() {
+		var rec exportRecord
+		var metadataJSON []byte
+		if err := rows.Scan(&rec.OccurredAt, &rec.TenantSlug, &rec.Actor, &rec.Action, &rec.Target, &metadataJSON); err != nil {
+			return fmt.Errorf("zeile lesen: %w", err)
+		}
+		rec.Metadata = metadataJSON
+		if err := enc.Encode(rec); err != nil {
+			return fmt.Errorf("json-zeile schreiben: %w", err)
+		}
+	}
+	return rows.Err()
+}

internal/audit/export_handler.go

@@ -0,0 +1,73 @@
+package audit
+
+import (
+	"context"
+	"net/http"
+	"time"
+)
+
+// Authorize entscheidet, ob caller den Export ausfuehren darf. Die
+// eigentliche Rollen-/Rechtepruefung (RBAC-02 Policy-Enforcement) ist nicht
+// Teil dieser Kachel — ExportHandler kennt nur diese schmale Schnittstelle,
+// analog zum RetentionRegistrar-Muster aus AUD-05.
+type Authorize func(ctx context.Context, caller string) bool
+
+// ExportHandler stellt den Export als HTTP-Endpunkt bereit
+// (Akzeptanzkriterium 2: fuer berechtigte Rollen verfuegbar).
+type ExportHandler struct {
+	log       *Log
+	authorize Authorize
+}
+
+func NewExportHandler(log *Log, authorize Authorize) *ExportHandler {
+	return &ExportHandler{log: log, authorize: authorize}
+}
+
+// Export liest Filter-Query-Parameter (tenant, actor, action, from, to,
+// format) und schreibt DIREKT auf den ResponseWriter (io.Writer) — dieselbe
+// Streaming-Funktion wie in export.go, kein zusaetzlicher Pufferungsschritt.
+func (h *ExportHandler) Export(w http.ResponseWriter, r *http.Request) {
+	// "caller" identifiziert die anfragende Person fuer die Berechtigungs-
+	// pruefung — bewusst getrennt vom Filterfeld "actor" (das den
+	// AUDIT-Akteur meint, ueber den gefiltert wird).
+	caller := r.URL.Query().Get("caller")
+	if caller == "" || !h.authorize(r.Context(), caller) {
+		http.Error(w, "keine berechtigung fuer audit-log-export", http.StatusForbidden)
+		return
+	}
+
+	filter := Filter{
+		TenantSlug: r.URL.Query().Get("tenant"),
+		Actor:      r.URL.Query().Get("actor"),
+		Action:     r.URL.Query().Get("action"),
+	}
+	if from := r.URL.Query().Get("from"); from != "" {
+		t, err := time.Parse(time.RFC3339, from)
+		if err != nil {
+			http.Error(w, "ungueltiges from-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.From = &t
+	}
+	if to := r.URL.Query().Get("to"); to != "" {
+		t, err := time.Parse(time.RFC3339, to)
+		if err != nil {
+			http.Error(w, "ungueltiges to-datum, erwartet RFC3339", http.StatusBadRequest)
+			return
+		}
+		filter.To = &t
+	}
+
+	switch r.URL.Query().Get("format") {
+	case "json":
+		w.Header().Set("Content-Type", "application/x-ndjson")
+		if err := h.log.StreamJSON(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	default:
+		w.Header().Set("Content-Type", "text/csv")
+		if err := h.log.StreamCSV(r.Context(), filter, w); err != nil {
+			http.Error(w, "export fehlgeschlagen", http.StatusInternalServerError)
+		}
+	}
+}

internal/audit/export_test.go

@@ -0,0 +1,222 @@
+package audit
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupExportTest(t *testing.T) (*Log, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS audit_events (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
+			actor TEXT NOT NULL CHECK (actor <> ''),
+			action TEXT NOT NULL CHECK (action <> ''),
+			target TEXT NOT NULL,
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewLog(pool), cleanup
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Filterkombinationen liefern korrekte
+// Teilmengen.
+func TestExport_FilterCombinations(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	run := fmt.Sprintf("_%d", time.Now().UnixNano())
+	tenantA, tenantB := "test_fa"+run, "test_fb"+run
+	alice, bob := "alice"+run, "bob"+run
+
+	events := []Event{
+		{TenantSlug: tenantA, Actor: alice, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: bob, Action: "login", Target: "x"},
+		{TenantSlug: tenantA, Actor: alice, Action: "logout", Target: "x"},
+		{TenantSlug: tenantB, Actor: alice, Action: "login", Target: "x"},
+	}
+	for _, e := range events {
+		if err := log.Record(ctx, e); err != nil {
+			t.Fatalf("record: %v", err)
+		}
+	}
+
+	cases := []struct {
+		name    string
+		filter  Filter
+		wantLen int
+	}{
+		{"nach tenant", Filter{TenantSlug: tenantA}, 3},
+		{"nach tenant+actor", Filter{TenantSlug: tenantA, Actor: alice}, 2},
+		{"nach tenant+actor+action", Filter{TenantSlug: tenantA, Actor: alice, Action: "login"}, 1},
+		{"nach actor ueber beide tenants", Filter{Actor: alice, Action: "login"}, 2},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			if err := log.StreamCSV(ctx, c.filter, &buf); err != nil {
+				t.Fatalf("stream: %v", err)
+			}
+			rows, err := csv.NewReader(&buf).ReadAll()
+			if err != nil {
+				t.Fatalf("csv parsen: %v", err)
+			}
+			got := len(rows) - 1 // Header abziehen
+			if got != c.wantLen {
+				t.Fatalf("erwartet %d zeilen, habe %d", c.wantLen, got)
+			}
+		})
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 2: Zeitraum-Filter.
+func TestExport_TimeRangeFilter(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_tr_%d", time.Now().UnixNano())
+	past := time.Now().Add(-48 * time.Hour)
+	future := time.Now().Add(48 * time.Hour)
+
+	if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "a", Action: "x", Target: "t", OccurredAt: time.Now()}); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+
+	var buf bytes.Buffer
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &past, To: &future}, &buf); err != nil {
+		t.Fatalf("stream (innerhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 1 {
+		t.Fatalf("erwartet 1 eintrag innerhalb des zeitraums, habe %d", got)
+	}
+
+	farPast := time.Now().Add(-96 * time.Hour)
+	buf.Reset()
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant, From: &farPast, To: &past}, &buf); err != nil {
+		t.Fatalf("stream (ausserhalb range): %v", err)
+	}
+	if got := countLines(buf.String()) - 1; got != 0 {
+		t.Fatalf("erwartet 0 eintraege ausserhalb des zeitraums, habe %d", got)
+	}
+}
+
+func countLines(s string) int {
+	s = strings.TrimRight(s, "\n")
+	if s == "" {
+		return 0
+	}
+	return len(strings.Split(s, "\n"))
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Export mit hoher Eintragszahl ohne
+// uebermaessigen Speicherverbrauch — Stichprobe per runtime.MemStats.
+func TestExport_StreamsLargeResultWithoutExcessiveMemory(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	tenant := fmt.Sprintf("test_large_%d", time.Now().UnixNano())
+	const n = 20000
+	for i := 0; i < n; i++ {
+		if err := log.Record(ctx, Event{TenantSlug: tenant, Actor: "bulk", Action: "test.bulk", Target: fmt.Sprintf("obj-%d", i)}); err != nil {
+			t.Fatalf("record %d: %v", i, err)
+		}
+	}
+
+	runtime.GC()
+	var before runtime.MemStats
+	runtime.ReadMemStats(&before)
+
+	lineCount := 0
+	cw := &countingWriter{onWrite: func(p []byte) { lineCount += strings.Count(string(p), "\n") }}
+	if err := log.StreamCSV(ctx, Filter{TenantSlug: tenant}, cw); err != nil {
+		t.Fatalf("stream: %v", err)
+	}
+
+	runtime.GC()
+	var after runtime.MemStats
+	runtime.ReadMemStats(&after)
+
+	if lineCount != n+1 { // +1 Header
+		t.Fatalf("erwartet %d zeilen (inkl. header), habe %d", n+1, lineCount)
+	}
+
+	// Grobe Stichprobe: ein NICHT streamender Export haette hier locker
+	// mehrere MB an einmal gehaltenen Zeilen/Strings erzeugt. Grosszuegige
+	// Schwelle, da Go-Heap-Messungen naturgemaess rauschen.
+	const maxAcceptableGrowth = 3 * 1024 * 1024 // 3 MB
+	growth := int64(after.HeapAlloc) - int64(before.HeapAlloc)
+	t.Logf("heap-wachstum waehrend export von %d zeilen: %d bytes (schwelle: %d)", n, growth, maxAcceptableGrowth)
+	if growth > maxAcceptableGrowth {
+		t.Fatalf("heap ist um %d bytes gewachsen, erwartet unter %d (hinweis auf vollstaendige pufferung statt streaming)", growth, maxAcceptableGrowth)
+	}
+}
+
+type countingWriter struct {
+	onWrite func(p []byte)
+}
+
+func (w *countingWriter) Write(p []byte) (int, error) {
+	w.onWrite(p)
+	return len(p), nil
+}
+
+// Akzeptanzkriterium 2 + Pruefung 3: Zugriff ohne passende Berechtigung wird abgewiesen.
+func TestExportHandler_RejectsWithoutAuthorization(t *testing.T) {
+	log, cleanup := setupExportTest(t)
+	defer cleanup()
+
+	handler := NewExportHandler(log, func(ctx context.Context, caller string) bool {
+		return caller == "berechtigte-person@example.com"
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/audit/export?caller=unberechtigt@example.com", nil)
+	rec := httptest.NewRecorder()
+	handler.Export(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("unberechtigt: status = %d, want 403", rec.Code)
+	}
+
+	reqNoCaller := httptest.NewRequest(http.MethodGet, "/audit/export", nil)
+	recNoCaller := httptest.NewRecorder()
+	handler.Export(recNoCaller, reqNoCaller)
+	if recNoCaller.Code != http.StatusForbidden {
+		t.Fatalf("ohne caller: status = %d, want 403", recNoCaller.Code)
+	}
+
+	reqOK := httptest.NewRequest(http.MethodGet, "/audit/export?caller=berechtigte-person@example.com", nil)
+	recOK := httptest.NewRecorder()
+	handler.Export(recOK, reqOK)
+	if recOK.Code != http.StatusOK {
+		t.Fatalf("berechtigt: status = %d, want 200", recOK.Code)
+	}
+}

internal/config/config.go

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

internal/tenant/handler.go

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

internal/tenant/provisioner.go

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

internal/tenant/provisioner_test.go

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

internal/tenant/registry.go

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

internal/tenant/tenant.go

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

internal/tenant/tenant_test.go

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

mail/cmd/pflichttestgate/main.go

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

mail/docs/ING-04-PRUEFPROTOKOLL.md

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

mail/docs/TESTSTRATEGIE-MAIL.md

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

mail/go.mod

@@ -1,16 +0,0 @@
-module gitea.perlbach24.de/scripte/nexarch/mail
-
-go 1.22
-
-require (
-	github.com/jackc/pgx/v5 v5.6.0
-	golang.org/x/text v0.14.0
-)
-
-require (
-	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/puddle/v2 v2.2.1 // indirect
-	golang.org/x/crypto v0.17.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-)

mail/internal/example/handler.go

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

mail/internal/example/handler_e2e_test.go

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

mail/internal/example/normalize.go

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

mail/internal/example/normalize_test.go

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

mail/internal/example/store.go

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

mail/internal/example/store_integration_test.go

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

mail/internal/mimeparse/mimeparse.go

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

mail/internal/mimeparse/mimeparse_test.go

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

mail/internal/pflichttestgate/gate.go

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

mail/internal/pflichttestgate/gate_test.go

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

migrations/0001_tenant_registry.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenants;

migrations/0001_tenant_registry.sql

@@ -1,10 +0,0 @@
--- Control-plane registry: tenant list + connection info (Modell C).
--- Core TEN-01 (siehe core-kanban).
-CREATE TABLE tenants (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    slug         TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    db_dsn       TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0001_tenant_registry.up.sql

@@ -0,0 +1,14 @@
+-- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
+-- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
+-- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE tenants (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug         TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    db_name      TEXT NOT NULL UNIQUE,
+    db_dsn       TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);

migrations/0004_audit_events.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS audit_events;

migrations/0004_audit_events.up.sql

@@ -0,0 +1,17 @@
+-- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
+-- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
+-- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
+-- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
+-- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
+-- Wert 'system', niemals NULL oder leeren String.
+CREATE TABLE audit_events (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    occurred_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    tenant_slug  TEXT NOT NULL CHECK (tenant_slug <> ''),
+    actor        TEXT NOT NULL CHECK (actor <> ''),
+    action       TEXT NOT NULL CHECK (action <> ''),
+    target       TEXT NOT NULL,
+    metadata     JSONB NOT NULL DEFAULT '{}'::jsonb
+);
+
+CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);

scripts/reset-test-env.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
+# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
+# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
+# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
+# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
+set -euo pipefail
+
+PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
+ROLE="nexarch_test"
+
+export PGPASSWORD="$PASS"
+
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events CASCADE;"
+
+dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
+for db in $dbs; do
+	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
+done
+
+echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
+# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
+# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
+# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
+#
+# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
+set -euo pipefail
+
+PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
+cd "$(dirname "$0")/.."
+
+NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
+
+export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
+
+echo "== go build =="
+go build ./...
+
+echo "== go vet =="
+go vet ./...
+
+echo "== go test (-p 1) =="
+go test ./... -p 1 -count=1