Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/aud-04-audit-log-ansicht

# Conflicts:
#	DEVLOG.md

.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

.gitignore

@@ -1,2 +1,4 @@
 *.log
 .env
+web/*/node_modules/
+web/*/.next/

DEVLOG.md

@@ -44,3 +44,118 @@ 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
+## 2026-08-28 21:44 – 21:44 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### 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 ++++++++++
+- web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
+- web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/index.ts                    | 25 +++++++++++++++++++++++++
+- web/shl/package.json                | 23 +++++++++++++++++++++++
+- web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- web/shl/tsconfig.json               | 18 ++++++++++++++++++
+
+---
+## 2026-08-28 21:51 – 21:57 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** nexarch
+
+### Commits
+- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
+
+### Geänderte Dateien
+- web/shl/package.json     | 2 ++
+- web/shl/vitest.config.ts | 8 ++++++++
+- web/shl/vitest.setup.ts  | 1 +
+
+---

cmd/auditlog-devserver/main.go

@@ -0,0 +1,69 @@
+// auditlog-devserver stellt AUD-03s ExportHandler (internal/audit) fuer die
+// Next.js-Audit-Log-Ansicht (AUD-04) bereit. Getrennt von cmd/core aus
+// demselben Grund wie die anderen *-devserver (siehe LIC-04/TEN-05): echte
+// Auth/RBAC ist noch nicht in die zentrale Server-Topologie verdrahtet.
+//
+// Authorize wird hier mit einem geteilten Admin-Token ueber
+// crypto/subtle.ConstantTimeCompare umgesetzt — demselben Timing-safe-Muster
+// wie internal/audit.timingsafe (AUD-02), NICHT ueber eine neue
+// Rollen-/Rechteschicht, da diese Kachel ausdruecklich nur von AUD-03
+// abhaengt und keine Rechteverwaltung duplizieren soll.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/audit"
+	"gitea.perlbach24.de/scripte/nexarch/internal/auditadmin"
+	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
+	}
+	adminToken := os.Getenv("NEXARCH_AUDIT_ADMIN_TOKEN")
+	if adminToken == "" {
+		log.Fatal("NEXARCH_AUDIT_ADMIN_TOKEN nicht gesetzt")
+	}
+	addr := os.Getenv("NEXARCH_AUDITLOG_LISTEN_ADDR")
+	if addr == "" {
+		addr = ":8083"
+	}
+
+	ctx := context.Background()
+	pool, err := db.Connect(ctx, dsn)
+	if err != nil {
+		log.Fatalf("db: %v", err)
+	}
+	defer pool.Close()
+
+	auditLog := audit.NewLog(pool)
+	tokenAuthorize := auditadmin.NewTokenAuthorizer(adminToken)
+	authorize := func(_ context.Context, caller string) bool { return tokenAuthorize(caller) }
+	handler := audit.NewExportHandler(auditLog, authorize)
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/audit/export", withCORS(handler.Export))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("auditlog-devserver listening on %s", addr)
+	log.Fatal(http.ListenAndServe(addr, mux))
+}
+
+func withCORS(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next(w, r)
+	}
+}

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

go.sum

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

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/auditadmin/authorize.go

@@ -0,0 +1,23 @@
+// Package auditadmin implementiert Core AUD-04: die Berechtigungspruefung
+// fuer die Audit-Log-Ansicht. Enthaelt bewusst KEINE eigene Filter-/
+// Export-Logik — die Ansicht ist "reiner Konsument der Export-API" (AUD-03,
+// internal/audit.ExportHandler); dieses Paket liefert nur die
+// audit.Authorize-Implementierung, die der Entwicklungs-/Testserver
+// (cmd/auditlog-devserver) einhaengt.
+package auditadmin
+
+import "crypto/subtle"
+
+// NewTokenAuthorizer liefert eine audit.Authorize-Funktion, die den
+// aufrufenden "caller"-Wert timing-safe gegen ein geteiltes Admin-Token
+// vergleicht — dasselbe Muster wie internal/audit.timingsafe (AUD-02),
+// NICHT ueber eine neue Rollen-/Rechteschicht, da AUD-04 ausdruecklich nur
+// von AUD-03 abhaengt.
+func NewTokenAuthorizer(adminToken string) func(caller string) bool {
+	return func(caller string) bool {
+		if caller == "" || adminToken == "" {
+			return false
+		}
+		return subtle.ConstantTimeCompare([]byte(caller), []byte(adminToken)) == 1
+	}
+}

internal/auditadmin/authorize_test.go

@@ -0,0 +1,33 @@
+package auditadmin
+
+import "testing"
+
+// Grundlage fuer Akzeptanzkriterium 1/2: die Oberflaeche darf Daten und den
+// Export nur bei korrektem Admin-Token abrufen.
+func TestNewTokenAuthorizer_AcceptsCorrectToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if !authorize("geheimes-token") {
+		t.Fatal("erwartet true fuer korrektes token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWrongToken(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("falsches-token") {
+		t.Fatal("erwartet false fuer falsches token")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsEmptyCaller(t *testing.T) {
+	authorize := NewTokenAuthorizer("geheimes-token")
+	if authorize("") {
+		t.Fatal("erwartet false fuer leeren aufrufer")
+	}
+}
+
+func TestNewTokenAuthorizer_RejectsWhenNoTokenConfigured(t *testing.T) {
+	authorize := NewTokenAuthorizer("")
+	if authorize("irgendwas") {
+		t.Fatal("erwartet false, wenn kein admin-token konfiguriert ist (fail-safe-default)")
+	}
+}

internal/config/config.go

@@ -11,7 +11,14 @@ import (
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
 	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/ARC-01-PRUEFPROTOKOLL.md

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

mail/docs/ARC-02-PRUEFPROTOKOLL.md

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

mail/docs/ARC-03-PRUEFPROTOKOLL.md

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

mail/docs/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,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
-)

mail/go.sum

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

mail/internal/crypto/envelope.go

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

mail/internal/crypto/kekprovider.go

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

mail/internal/crypto/service.go

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

mail/internal/dedup/hash.go

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

mail/internal/dedup/hash_test.go

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

mail/internal/dedup/store.go

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

mail/internal/dedup/store_integration_test.go

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

mail/internal/encstorage/encstorage.go

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

mail/internal/encstorage/encstorage_test.go

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

mail/internal/example/handler.go

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

mail/internal/example/handler_e2e_test.go

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

mail/internal/example/normalize.go

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

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

mail/internal/storage/driver.go

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

mail/internal/storage/localdriver.go

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

mail/internal/storage/s3driver.go

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

mail/internal/storage/service.go

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

mail/internal/storage/service_test.go

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

mail/internal/storage/usagereport.go

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

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

web/audit-log/app/layout.tsx

@@ -0,0 +1,30 @@
+import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
+
+export const metadata = {
+  title: "NEXARCH Audit-Log",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="de">
+      <body
+        style={{
+          fontFamily: typography.fontFamily,
+          margin: 0,
+          background: "var(--shl-color-background, #ffffff)",
+          color: "var(--shl-color-text-primary, #14181f)",
+        }}
+      >
+        <ThemeProvider>
+          <I18nProvider initialLocale="de">
+            <ToastProvider>{children}</ToastProvider>
+          </I18nProvider>
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}

web/audit-log/app/page.tsx

@@ -0,0 +1,159 @@
+"use client";
+
+import { useState } from "react";
+import { fetchRecords, exportURL, type AuditRecord, type AuditFilter } from "@/lib/api";
+
+const EMPTY_FILTER: AuditFilter = { tenant: "", actor: "", action: "", from: "", to: "" };
+
+export default function Page() {
+  const [caller, setCaller] = useState("");
+  const [filter, setFilter] = useState<AuditFilter>(EMPTY_FILTER);
+  const [records, setRecords] = useState<AuditRecord[] | null>(null);
+  const [selected, setSelected] = useState<AuditRecord | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  async function onSearch() {
+    setError(null);
+    setSelected(null);
+    try {
+      const data = await fetchRecords(caller.trim(), filter);
+      setRecords(data);
+    } catch (e: any) {
+      setError(e.message ?? "Unbekannter Fehler");
+      setRecords(null);
+    }
+  }
+
+  function onExport(format: "csv" | "json") {
+    const url = exportURL(caller.trim(), filter, format);
+    // Echter Datei-Download ueber Browser-Navigation, KEIN erneutes Parsen
+    // im Frontend (Akzeptanzkriterium 2: Export aus AUD-03 direkt ausloesbar).
+    window.open(url, "_blank");
+  }
+
+  return (
+    <main style={{ maxWidth: 1000, margin: "0 auto", padding: "2rem 1rem" }}>
+      <h1>Audit-Log</h1>
+
+      <div style={{ display: "grid", gap: "0.5rem", gridTemplateColumns: "repeat(3, 1fr)", marginBottom: "1rem" }}>
+        <input
+          value={caller}
+          onChange={(e) => setCaller(e.target.value)}
+          placeholder="Admin-Token (Berechtigung)"
+          style={{ padding: "0.5rem", gridColumn: "span 3" }}
+        />
+        <input
+          value={filter.tenant}
+          onChange={(e) => setFilter({ ...filter, tenant: e.target.value })}
+          placeholder="Tenant"
+          style={{ padding: "0.5rem" }}
+        />
+        <input
+          value={filter.actor}
+          onChange={(e) => setFilter({ ...filter, actor: e.target.value })}
+          placeholder="Akteur"
+          style={{ padding: "0.5rem" }}
+        />
+        <input
+          value={filter.action}
+          onChange={(e) => setFilter({ ...filter, action: e.target.value })}
+          placeholder="Aktion"
+          style={{ padding: "0.5rem" }}
+        />
+        <label>
+          Von
+          <input
+            type="datetime-local"
+            value={filter.from}
+            onChange={(e) =>
+              setFilter({ ...filter, from: e.target.value ? new Date(e.target.value).toISOString() : "" })
+            }
+            style={{ width: "100%", padding: "0.4rem" }}
+          />
+        </label>
+        <label>
+          Bis
+          <input
+            type="datetime-local"
+            value={filter.to}
+            onChange={(e) =>
+              setFilter({ ...filter, to: e.target.value ? new Date(e.target.value).toISOString() : "" })
+            }
+            style={{ width: "100%", padding: "0.4rem" }}
+          />
+        </label>
+      </div>
+
+      <div style={{ display: "flex", gap: "0.5rem", marginBottom: "1rem" }}>
+        <button onClick={onSearch}>Suchen</button>
+        <button onClick={() => onExport("csv")}>Export als CSV</button>
+        <button onClick={() => onExport("json")}>Export als JSON</button>
+      </div>
+
+      {error && (
+        <p style={{ color: "#c62828" }} role="alert">
+          Fehler: {error}
+        </p>
+      )}
+
+      {records && (
+        <table style={{ width: "100%", borderCollapse: "collapse", background: "white" }}>
+          <thead>
+            <tr style={{ textAlign: "left", borderBottom: "2px solid #ddd" }}>
+              <th style={{ padding: "0.5rem" }}>Zeitpunkt</th>
+              <th style={{ padding: "0.5rem" }}>Tenant</th>
+              <th style={{ padding: "0.5rem" }}>Akteur</th>
+              <th style={{ padding: "0.5rem" }}>Aktion</th>
+              <th style={{ padding: "0.5rem" }}></th>
+            </tr>
+          </thead>
+          <tbody>
+            {records.map((r, i) => (
+              <tr key={i} style={{ borderBottom: "1px solid #eee" }}>
+                <td style={{ padding: "0.5rem" }}>{new Date(r.occurred_at).toLocaleString("de-DE")}</td>
+                <td style={{ padding: "0.5rem" }}>{r.tenant_slug}</td>
+                <td style={{ padding: "0.5rem" }}>{r.actor}</td>
+                <td style={{ padding: "0.5rem" }}>{r.action}</td>
+                <td style={{ padding: "0.5rem" }}>
+                  <button onClick={() => setSelected(r)}>Details</button>
+                </td>
+              </tr>
+            ))}
+            {records.length === 0 && (
+              <tr>
+                <td colSpan={5} style={{ padding: "0.5rem" }}>
+                  Keine Einträge gefunden.
+                </td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      )}
+
+      {selected && (
+        <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
+          <h2>Eintrag-Details</h2>
+          <dl>
+            <dt>Zeitpunkt</dt>
+            <dd>{new Date(selected.occurred_at).toLocaleString("de-DE")}</dd>
+            <dt>Tenant</dt>
+            <dd>{selected.tenant_slug}</dd>
+            <dt>Akteur</dt>
+            <dd>{selected.actor}</dd>
+            <dt>Aktion</dt>
+            <dd>{selected.action}</dd>
+            <dt>Ziel</dt>
+            <dd>{selected.target}</dd>
+            <dt>Metadaten</dt>
+            <dd>
+              <pre style={{ whiteSpace: "pre-wrap", background: "#f5f6f8", padding: "0.5rem" }}>
+                {JSON.stringify(selected.metadata, null, 2)}
+              </pre>
+            </dd>
+          </dl>
+          <button onClick={() => setSelected(null)}>Schließen</button>
+        </section>
+      )}
+    </main>
+  );
+}

web/audit-log/lib/api.ts

@@ -0,0 +1,63 @@
+// Duenner Client der AUD-03-Export-API (internal/audit.ExportHandler) —
+// keine eigene Aggregations-/Filterlogik im Frontend (Ticket-Vorgabe:
+// "reiner Konsument der Export-API"). Die JSON-Lines-Antwort wird nur
+// dekodiert, nicht neu berechnet oder gefiltert.
+export type AuditRecord = {
+  occurred_at: string;
+  tenant_slug: string;
+  actor: string;
+  action: string;
+  target: string;
+  metadata: unknown;
+};
+
+export type AuditFilter = {
+  tenant: string;
+  actor: string;
+  action: string;
+  from: string; // RFC3339, leer = kein Filter
+  to: string;
+};
+
+function apiBase(): string {
+  const base = process.env.NEXT_PUBLIC_AUDITLOG_API_URL;
+  if (!base) {
+    throw new Error(
+      "NEXT_PUBLIC_AUDITLOG_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
+    );
+  }
+  return base;
+}
+
+function buildParams(caller: string, filter: AuditFilter, format: "json" | "csv"): URLSearchParams {
+  const params = new URLSearchParams({ caller, format });
+  if (filter.tenant) params.set("tenant", filter.tenant);
+  if (filter.actor) params.set("actor", filter.actor);
+  if (filter.action) params.set("action", filter.action);
+  if (filter.from) params.set("from", filter.from);
+  if (filter.to) params.set("to", filter.to);
+  return params;
+}
+
+// exportURL liefert die Adresse desselben Endpunkts, den auch die
+// Export-Datei-Funktion (Akzeptanzkriterium 2) verwendet — Liste und Export
+// sind bewusst DERSELBE API-Aufruf mit unterschiedlichem "format".
+export function exportURL(caller: string, filter: AuditFilter, format: "json" | "csv"): string {
+  return `${apiBase()}/audit/export?${buildParams(caller, filter, format)}`;
+}
+
+// fetchRecords laedt die Liste als JSON-Lines und dekodiert Zeile fuer
+// Zeile — dieselben Filterparameter wie ein direkter API-Aufruf
+// (Akzeptanzkriterium 1 / Pruefung 1).
+export async function fetchRecords(caller: string, filter: AuditFilter): Promise<AuditRecord[]> {
+  const res = await fetch(exportURL(caller, filter, "json"), { cache: "no-store" });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(text || `Anfrage fehlgeschlagen (${res.status})`);
+  }
+  const text = await res.text();
+  return text
+    .split("\n")
+    .filter((line) => line.trim() !== "")
+    .map((line) => JSON.parse(line) as AuditRecord);
+}

web/audit-log/next.config.mjs

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // @nexarch/shl liegt als file:-Dependency mit TS-Quellen in node_modules —
+  // Next.js transpiliert node_modules standardmäßig nicht, siehe web/shl/README.md.
+  transpilePackages: ["@nexarch/shl"],
+};
+export default nextConfig;

web/audit-log/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "nexarch-audit-log",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@nexarch/shl": "file:../shl",
+    "next": "14.2.35",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "20.14.9",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "typescript": "5.5.3"
+  }
+}

web/audit-log/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": { "@/*": ["./*"] }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

web/shl/README.md

@@ -0,0 +1,45 @@
+# @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
+
+Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
+Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
+
+## Enthält
+
+- **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
+- **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
+- **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
+- **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
+
+## Verwendung in einem Modul-Frontend
+
+```tsx
+import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <ThemeProvider>
+      <I18nProvider initialLocale="de">
+        <ToastProvider>
+          <Shell modules={[]} tenantLabel="Mandant XY">
+            {children}
+          </Shell>
+        </ToastProvider>
+      </I18nProvider>
+    </ThemeProvider>
+  );
+}
+```
+
+## Bekannter offener Punkt
+
+Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
+
+## Tests
+
+Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
+
+```bash
+npm install
+npm test
+npm run typecheck
+```

web/shl/__tests__/Dialog.test.tsx

@@ -0,0 +1,38 @@
+// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { Dialog } from "../components/Dialog";
+import { I18nProvider } from "../i18n/i18n";
+
+function renderDialog(onClose: () => void) {
+  return render(
+    <I18nProvider>
+      <Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
+        <button type="button">Erste Aktion</button>
+        <button type="button">Zweite Aktion</button>
+      </Dialog>
+    </I18nProvider>,
+  );
+}
+
+describe("Dialog: Tastaturbedienung", () => {
+  it("schließt sich bei ESC", () => {
+    const onClose = vi.fn();
+    renderDialog(onClose);
+    fireEvent.keyDown(document, { key: "Escape" });
+    expect(onClose).toHaveBeenCalledOnce();
+  });
+
+  it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
+    renderDialog(vi.fn());
+    const closeButton = screen.getByRole("button", { name: /schließen/i });
+    expect(document.activeElement).toBe(closeButton);
+  });
+
+  it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
+    renderDialog(vi.fn());
+    const dialog = screen.getByRole("dialog");
+    expect(dialog).toHaveAttribute("aria-modal", "true");
+    expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
+  });
+});

web/shl/__tests__/tokens.test.ts

@@ -0,0 +1,39 @@
+// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
+import { describe, expect, it } from "vitest";
+import { colorTokens } from "../tokens/tokens";
+
+// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
+function relLuminance(hex: string): number {
+  const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+  const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+function contrastRatio(a: string, b: string): number {
+  const l1 = relLuminance(a);
+  const l2 = relLuminance(b);
+  const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
+  for (const scheme of ["light", "dark"] as const) {
+    const c = colorTokens[scheme];
+
+    it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
+    });
+
+    it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
+      expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
+    });
+  }
+});

web/shl/components/Dialog.tsx

@@ -0,0 +1,88 @@
+"use client";
+
+// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
+
+import { useEffect, useRef } from "react";
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+const FOCUSABLE_SELECTOR =
+  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
+export interface DialogProps {
+  open: boolean;
+  onClose: () => void;
+  titleId: string;
+  title: string;
+  children: ReactNode;
+}
+
+export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
+  const { t } = useI18n();
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const previouslyFocused = useRef<HTMLElement | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    previouslyFocused.current = document.activeElement as HTMLElement | null;
+
+    const node = dialogRef.current;
+    const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
+    focusables?.[0]?.focus();
+
+    function handleKeyDown(event: KeyboardEvent) {
+      if (event.key === "Escape") {
+        onClose();
+        return;
+      }
+      if (event.key !== "Tab" || !node) return;
+
+      const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
+      if (items.length === 0) return;
+      const first = items[0];
+      const last = items[items.length - 1];
+
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    }
+
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+      previouslyFocused.current?.focus();
+    };
+  }, [open, onClose]);
+
+  if (!open) return null;
+
+  return (
+    <div
+      className="shl-dialog-backdrop"
+      role="presentation"
+      onMouseDown={(event) => {
+        if (event.target === event.currentTarget) onClose();
+      }}
+    >
+      <div
+        ref={dialogRef}
+        className="shl-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby={titleId}
+      >
+        <div className="shl-dialog-header">
+          <h2 id={titleId}>{title}</h2>
+          <button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
+            ×
+          </button>
+        </div>
+        <div className="shl-dialog-body">{children}</div>
+      </div>
+    </div>
+  );
+}

web/shl/components/FormElements.tsx

@@ -0,0 +1,98 @@
+// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
+// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
+
+import { useId } from "react";
+import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
+
+interface FieldWrapperProps {
+  label: string;
+  error?: string;
+  hint?: string;
+  children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
+}
+
+function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
+  const inputId = useId();
+  const hintId = hint ? `${inputId}-hint` : undefined;
+  const errorId = error ? `${inputId}-error` : undefined;
+  const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
+
+  return (
+    <div className="shl-field">
+      <label htmlFor={inputId}>{label}</label>
+      {children({ inputId, describedBy })}
+      {hint && (
+        <p id={hintId} className="shl-field-hint">
+          {hint}
+        </p>
+      )}
+      {error && (
+        <p id={errorId} className="shl-field-error" role="alert">
+          {error}
+        </p>
+      )}
+    </div>
+  );
+}
+
+export interface TextFieldProps
+  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
+  label: string;
+  error?: string;
+  hint?: string;
+}
+
+export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
+  return (
+    <FieldWrapper label={label} error={error} hint={hint}>
+      {({ inputId, describedBy }) => (
+        <input
+          id={inputId}
+          aria-describedby={describedBy}
+          aria-invalid={error ? true : undefined}
+          {...inputProps}
+        />
+      )}
+    </FieldWrapper>
+  );
+}
+
+export interface SelectFieldProps
+  extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
+  label: string;
+  error?: string;
+  hint?: string;
+  children: ReactNode;
+}
+
+export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
+  return (
+    <FieldWrapper label={label} error={error} hint={hint}>
+      {({ inputId, describedBy }) => (
+        <select
+          id={inputId}
+          aria-describedby={describedBy}
+          aria-invalid={error ? true : undefined}
+          {...selectProps}
+        >
+          {children}
+        </select>
+      )}
+    </FieldWrapper>
+  );
+}
+
+export interface CheckboxFieldProps
+  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
+  label: string;
+}
+
+export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
+  const inputId = useId();
+  return (
+    <div className="shl-field shl-field-checkbox">
+      <input id={inputId} type="checkbox" {...inputProps} />
+      <label htmlFor={inputId}>{label}</label>
+    </div>
+  );
+}

web/shl/components/Shell.tsx

@@ -0,0 +1,62 @@
+"use client";
+
+// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
+// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
+
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+import { useTheme } from "../theme/ThemeProvider";
+
+export interface ModuleLink {
+  key: string;
+  label: string;
+  href: string;
+  active?: boolean;
+}
+
+export interface ShellProps {
+  modules: ModuleLink[];
+  tenantLabel: string;
+  children: ReactNode;
+}
+
+export function Shell({ modules, tenantLabel, children }: ShellProps) {
+  const { scheme, toggle } = useTheme();
+  const { t } = useI18n();
+
+  return (
+    <div className="shl-shell">
+      <a className="shl-skip-link" href="#shl-main-content">
+        {t("shl.shell.skipToContent", "Zum Inhalt springen")}
+      </a>
+      <header className="shl-shell-header">
+        <nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
+          <ul>
+            {modules.map((mod) => (
+              <li key={mod.key}>
+                <a href={mod.href} aria-current={mod.active ? "page" : undefined}>
+                  {mod.label}
+                </a>
+              </li>
+            ))}
+          </ul>
+        </nav>
+        <div className="shl-shell-context">
+          <span className="shl-tenant-context">{tenantLabel}</span>
+          <button
+            type="button"
+            onClick={toggle}
+            aria-label={
+              scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
+            }
+          >
+            {scheme === "light" ? "🌙" : "☀️"}
+          </button>
+        </div>
+      </header>
+      <main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
+        {children}
+      </main>
+    </div>
+  );
+}

web/shl/components/Table.tsx

@@ -0,0 +1,83 @@
+// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
+
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+export interface TableColumn<Row> {
+  key: string;
+  header: string;
+  render: (row: Row) => ReactNode;
+  sortable?: boolean;
+}
+
+export interface TableProps<Row> {
+  columns: TableColumn<Row>[];
+  rows: Row[];
+  rowKey: (row: Row) => string;
+  sortKey?: string;
+  sortDirection?: "asc" | "desc";
+  onSort?: (key: string) => void;
+  caption?: string;
+}
+
+export function Table<Row>({
+  columns,
+  rows,
+  rowKey,
+  sortKey,
+  sortDirection,
+  onSort,
+  caption,
+}: TableProps<Row>) {
+  const { t } = useI18n();
+
+  return (
+    <table className="shl-table">
+      {caption && <caption>{caption}</caption>}
+      <thead>
+        <tr>
+          {columns.map((column) => {
+            const isSorted = column.key === sortKey;
+            const ariaSort = column.sortable
+              ? isSorted
+                ? sortDirection === "asc"
+                  ? "ascending"
+                  : "descending"
+                : "none"
+              : undefined;
+            return (
+              <th key={column.key} scope="col" aria-sort={ariaSort}>
+                {column.sortable ? (
+                  <button
+                    type="button"
+                    onClick={() => onSort?.(column.key)}
+                    className="shl-table-sort-button"
+                  >
+                    {column.header}
+                  </button>
+                ) : (
+                  column.header
+                )}
+              </th>
+            );
+          })}
+        </tr>
+      </thead>
+      <tbody>
+        {rows.length === 0 ? (
+          <tr>
+            <td colSpan={columns.length}>{t("shl.table.noRows")}</td>
+          </tr>
+        ) : (
+          rows.map((row) => (
+            <tr key={rowKey(row)}>
+              {columns.map((column) => (
+                <td key={column.key}>{column.render(row)}</td>
+              ))}
+            </tr>
+          ))
+        )}
+      </tbody>
+    </table>
+  );
+}

web/shl/components/Toast.tsx

@@ -0,0 +1,67 @@
+"use client";
+
+// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
+
+import { createContext, useCallback, useContext, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import { useI18n } from "../i18n/i18n";
+
+export type ToastVariant = "info" | "success" | "danger" | "warning";
+
+export interface ToastMessage {
+  id: string;
+  text: string;
+  variant: ToastVariant;
+}
+
+interface ToastContextValue {
+  toasts: ToastMessage[];
+  push: (text: string, variant?: ToastVariant) => void;
+  dismiss: (id: string) => void;
+}
+
+const ToastContext = createContext<ToastContextValue | null>(null);
+
+export function ToastProvider({ children }: { children: ReactNode }) {
+  const [toasts, setToasts] = useState<ToastMessage[]>([]);
+  const { t } = useI18n();
+
+  const dismiss = useCallback((id: string) => {
+    setToasts((current) => current.filter((toast) => toast.id !== id));
+  }, []);
+
+  const push = useCallback((text: string, variant: ToastVariant = "info") => {
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    setToasts((current) => [...current, { id, text, variant }]);
+  }, []);
+
+  const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
+
+  return (
+    <ToastContext.Provider value={value}>
+      {children}
+      <div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
+        {toasts.map((toast) => (
+          <div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
+            <span>{toast.text}</span>
+            <button
+              type="button"
+              onClick={() => dismiss(toast.id)}
+              aria-label={t("shl.toast.dismiss")}
+            >
+              ×
+            </button>
+          </div>
+        ))}
+      </div>
+    </ToastContext.Provider>
+  );
+}
+
+export function useToast(): ToastContextValue {
+  const ctx = useContext(ToastContext);
+  if (!ctx) {
+    throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
+  }
+  return ctx;
+}

web/shl/i18n/i18n.tsx

@@ -0,0 +1,75 @@
+"use client";
+
+// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
+// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
+// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
+// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
+
+import { createContext, useContext, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+
+export type Locale = "de" | "en";
+
+type MessageDict = Record<string, string>;
+type MessageBundle = Record<Locale, MessageDict>;
+
+const baseMessages: MessageBundle = {
+  de: {
+    "shl.dialog.close": "Schließen",
+    "shl.toast.dismiss": "Meldung schließen",
+    "shl.table.noRows": "Keine Einträge vorhanden",
+    "shl.theme.toggleToLight": "Helles Erscheinungsbild",
+    "shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
+  },
+  en: {
+    "shl.dialog.close": "Close",
+    "shl.toast.dismiss": "Dismiss message",
+    "shl.table.noRows": "No entries",
+    "shl.theme.toggleToLight": "Switch to light theme",
+    "shl.theme.toggleToDark": "Switch to dark theme",
+  },
+};
+
+// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
+const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
+
+export function registerMessages(locale: Locale, messages: MessageDict): void {
+  registry[locale] = { ...registry[locale], ...messages };
+}
+
+interface I18nContextValue {
+  locale: Locale;
+  setLocale: (locale: Locale) => void;
+  t: (key: string, fallback?: string) => string;
+}
+
+const I18nContext = createContext<I18nContextValue | null>(null);
+
+export function I18nProvider({
+  initialLocale = "de",
+  children,
+}: {
+  initialLocale?: Locale;
+  children: ReactNode;
+}) {
+  const [locale, setLocale] = useState<Locale>(initialLocale);
+
+  const value = useMemo<I18nContextValue>(
+    () => ({
+      locale,
+      setLocale,
+      t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
+    }),
+    [locale],
+  );
+
+  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
+}
+
+export function useI18n(): I18nContextValue {
+  const ctx = useContext(I18nContext);
+  if (!ctx) {
+    throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
+  }
+  return ctx;
+}

web/shl/index.ts

@@ -0,0 +1,25 @@
+// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
+// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
+
+export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
+export type { ColorScheme, ColorTokens } from "./tokens/tokens";
+
+export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
+
+export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
+export type { Locale } from "./i18n/i18n";
+
+export { Shell } from "./components/Shell";
+export type { ShellProps, ModuleLink } from "./components/Shell";
+
+export { Dialog } from "./components/Dialog";
+export type { DialogProps } from "./components/Dialog";
+
+export { Table } from "./components/Table";
+export type { TableProps, TableColumn } from "./components/Table";
+
+export { TextField, SelectField, CheckboxField } from "./components/FormElements";
+export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
+
+export { ToastProvider, useToast } from "./components/Toast";
+export type { ToastMessage, ToastVariant } from "./components/Toast";

web/shl/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@nexarch/shl",
+  "version": "0.1.0",
+  "private": true,
+  "description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
+  "main": "index.ts",
+  "types": "index.ts",
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.4.8",
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "jsdom": "^24.1.1",
+    "typescript": "5.5.3",
+    "vitest": "^2.0.0"
+  }
+}

web/shl/theme/ThemeProvider.tsx

@@ -0,0 +1,81 @@
+"use client";
+
+// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
+// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
+
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
+
+const STORAGE_KEY = "nexarch-shl-theme";
+
+interface ThemeContextValue {
+  scheme: ColorScheme;
+  setScheme: (scheme: ColorScheme) => void;
+  toggle: () => void;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+function readStoredScheme(): ColorScheme | null {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = window.localStorage.getItem(STORAGE_KEY);
+    return stored === "light" || stored === "dark" ? stored : null;
+  } catch {
+    // localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
+    return null;
+  }
+}
+
+function systemPrefersDark(): boolean {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+  const [scheme, setSchemeState] = useState<ColorScheme>("light");
+
+  useEffect(() => {
+    const stored = readStoredScheme();
+    setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
+  }, []);
+
+  const setScheme = useCallback((next: ColorScheme) => {
+    setSchemeState(next);
+    try {
+      window.localStorage.setItem(STORAGE_KEY, next);
+    } catch {
+      // Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
+    }
+  }, []);
+
+  const toggle = useCallback(() => {
+    setScheme(scheme === "light" ? "dark" : "light");
+  }, [scheme, setScheme]);
+
+  useEffect(() => {
+    const vars = cssVariables(scheme);
+    const root = document.documentElement;
+    for (const [key, value] of Object.entries(vars)) {
+      root.style.setProperty(key, value);
+    }
+    root.dataset.shlTheme = scheme;
+  }, [scheme]);
+
+  const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
+
+  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
+}
+
+export function useTheme(): ThemeContextValue {
+  const ctx = useContext(ThemeContext);
+  if (!ctx) {
+    throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
+  }
+  return ctx;
+}
+
+export function currentColors(scheme: ColorScheme) {
+  return colorTokens[scheme];
+}

web/shl/tokens/tokens.ts

@@ -0,0 +1,96 @@
+// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
+// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
+// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
+
+export type ColorScheme = "light" | "dark";
+
+export interface ColorTokens {
+  background: string;
+  surface: string;
+  surfaceRaised: string;
+  border: string;
+  textPrimary: string;
+  textSecondary: string;
+  accent: string;
+  accentContrast: string;
+  danger: string;
+  dangerContrast: string;
+  success: string;
+  warning: string;
+  focusRing: string;
+}
+
+// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
+// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
+export const colorTokens: Record<ColorScheme, ColorTokens> = {
+  light: {
+    background: "#FFFFFF",
+    surface: "#F5F6F8",
+    surfaceRaised: "#FFFFFF",
+    border: "#D7DBE0",
+    textPrimary: "#14181F",
+    textSecondary: "#4B5563",
+    accent: "#1D4ED8",
+    accentContrast: "#FFFFFF",
+    danger: "#B91C1C",
+    dangerContrast: "#FFFFFF",
+    success: "#15803D",
+    warning: "#B45309",
+    focusRing: "#1D4ED8",
+  },
+  dark: {
+    background: "#0F1115",
+    surface: "#181B21",
+    surfaceRaised: "#20242C",
+    border: "#333944",
+    textPrimary: "#F2F4F7",
+    textSecondary: "#B4BAC4",
+    accent: "#5B8DEF",
+    accentContrast: "#0F1115",
+    danger: "#F87171",
+    dangerContrast: "#0F1115",
+    success: "#4ADE80",
+    warning: "#FBBF24",
+    focusRing: "#5B8DEF",
+  },
+};
+
+export const spacing = {
+  xs: "4px",
+  sm: "8px",
+  md: "16px",
+  lg: "24px",
+  xl: "32px",
+  xxl: "48px",
+} as const;
+
+export const breakpoints = {
+  mobile: "0px",
+  tablet: "768px",
+  desktop: "1200px",
+} as const;
+
+export const typography = {
+  fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
+  fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
+  sizeSm: "13px",
+  sizeMd: "15px",
+  sizeLg: "18px",
+  sizeXl: "24px",
+  lineHeight: 1.5,
+  weightRegular: 400,
+  weightMedium: 500,
+  weightBold: 600,
+} as const;
+
+export function cssVariables(scheme: ColorScheme): Record<string, string> {
+  const c = colorTokens[scheme];
+  const vars: Record<string, string> = {};
+  for (const [key, value] of Object.entries(c)) {
+    vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
+  }
+  for (const [key, value] of Object.entries(spacing)) {
+    vars[`--shl-spacing-${key}`] = value;
+  }
+  return vars;
+}

web/shl/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}

web/shl/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    setupFiles: ["./vitest.setup.ts"],
+  },
+});

web/shl/vitest.setup.ts

@@ -0,0 +1,9 @@
+import "@testing-library/jest-dom/vitest";
+import { afterEach } from "vitest";
+import { cleanup } from "@testing-library/react";
+
+// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
+// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
+afterEach(() => {
+  cleanup();
+});