SRC-01: manticore-suchindex-fuer-mails

Manticore-RT-Index für Mail-Suchdokumente (Betreff, Text, Anhangstext,
Metadaten), statisches versioniertes Schema.

- fields.go: statische Feld-/Index-Namen-Whitelist, einzige Quelle für
  Feldnamen im Paket (vermeidet known-issues-archivmail.md #11/#12:
  Sprintf/Join-basierte SQL-Klauselbildung).
- migrations/0001_mail_documents.sql: statisches Schema, per go:embed
  eingebettet, über /sql?mode=raw angelegt (kein String-Zusammenbau).
- client.go: Index/Search über die strukturierte Manticore-HTTP-JSON-API,
  Tenant-Filter über strukturiertes equals-Feld statt WHERE-Interpolation.

Prüfungen (alle real durchgeführt, siehe mail/docs/SRC-01-PRUEFPROTOKOLL.md):
1. TestNoDynamicSQLClauseBuilding: automatisierter Quelltext-Scan bestätigt
   keine Sprintf/Join-SQL-Klauselbildung.
2. TestSearch_MaliciousInputDoesNotAlterFieldNames: Injection-artige
   Eingaben verändern nachweislich keine Feldnamen im gesendeten Payload.
3. TestSearch_FindsExpectedDocument: Funktionstest gegen echtes Manticore
   auf 192.168.1.131 liefert erwartete Treffer.
Zusätzlich TestSearch_TenantIsolation für Akzeptanzkriterium 3.

Kein Umbau: storage/crypto/encstorage/dedup unverändert.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HhgFcLS8tYMhDJpP74C6AQ

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

@@ -0,0 +1,23 @@
+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,4 +1,2 @@
 *.log
 .env
-web/*/node_modules/
-web/*/.next/

DEVLOG.md

@@ -44,41 +44,3 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 
 ---
-## 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 ++
-- 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 +
-
----

mail/cmd/pflichttestgate/main.go

@@ -0,0 +1,39 @@
+// 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

@@ -0,0 +1,54 @@
+# 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

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,53 @@
+# 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

@@ -0,0 +1,65 @@
+# 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/SRC-01-PRUEFPROTOKOLL.md

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

mail/docs/TESTSTRATEGIE-MAIL.md

@@ -0,0 +1,110 @@
+# 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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,118 @@
+// 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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,35 @@
+// 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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,94 @@
+// 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

@@ -0,0 +1,93 @@
+// 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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,26 @@
+// 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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,69 @@
+// 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

@@ -0,0 +1,206 @@
+// 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

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,72 @@
+// 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

@@ -0,0 +1,33 @@
+// 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/search/client.go

@@ -0,0 +1,181 @@
+package search
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// 0001_mail_documents.sql: statisches, versioniertes Schema
+// (Akzeptanzkriterium 1). Feldnamen hier UND in fields.go müssen
+// deckungsgleich bleiben — die Konstanten in fields.go sind die einzige
+// Stelle, aus der Go-Code Feldnamen für Schreib-/Lesezugriffe bezieht.
+// Manticores SQL-Parser unterstützt keine "--"-Kommentare, daher bleibt
+// die eingebettete Datei selbst kommentarfrei.
+//
+//go:embed migrations/0001_mail_documents.sql
+var schemaMigration string
+
+// Client spricht ausschließlich über die strukturierte Manticore-HTTP-
+// JSON-API (kein String-Zusammenbau von SQL-Klauseln, siehe fields.go).
+// Die SQL-Schnittstelle wird nur für EnsureSchema verwendet, und dort
+// ausschließlich mit dem statischen, eingebetteten Migrationstext —
+// niemals mit zur Laufzeit zusammengesetzten Werten.
+type Client struct {
+	baseURL string
+	http    *http.Client
+}
+
+func NewClient(baseURL string) *Client {
+	return &Client{
+		baseURL: strings.TrimRight(baseURL, "/"),
+		http:    &http.Client{Timeout: 10 * time.Second},
+	}
+}
+
+// EnsureSchema legt den Index gemäß dem versionierten, statischen
+// Migrationstext an (Akzeptanzkriterium 1). Idempotent (CREATE TABLE
+// IF NOT EXISTS im Migrationstext).
+func (c *Client) EnsureSchema(ctx context.Context) error {
+	form := "query=" + schemaMigration
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/sql?mode=raw", strings.NewReader(form))
+	if err != nil {
+		return fmt.Errorf("search: schema-anfrage bauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return fmt.Errorf("search: schema anlegen: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("search: schema anlegen, status %d: %s", resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+// Document ist ein Mail-Suchdokument. Feldnamen im JSON-Tag entsprechen
+// exakt den Konstanten in fields.go.
+type Document struct {
+	ID              uint64 `json:"-"`
+	TenantSlug      string `json:"tenant_slug"`
+	MessageID       string `json:"message_id"`
+	Subject         string `json:"subject"`
+	Body            string `json:"body"`
+	AttachmentText  string `json:"attachment_text"`
+	SentAtUnixEpoch int64  `json:"sent_at"`
+}
+
+// Index legt/ersetzt ein Suchdokument (Akzeptanzkriterium 2: Schreibzugriff
+// ausschließlich über statische, vordefinierte Feldnamen aus dem
+// Document-Struct — kein dynamischer Feldname möglich).
+func (c *Client) Index(ctx context.Context, doc Document) error {
+	payload := map[string]any{
+		"index": IndexName,
+		"id":    doc.ID,
+		"doc":   doc,
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("search: dokument serialisieren: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/replace", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("search: index-anfrage bauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return fmt.Errorf("search: dokument indexieren: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	respBody, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("search: dokument indexieren, status %d: %s", resp.StatusCode, string(respBody))
+	}
+	return nil
+}
+
+// Result ist ein Suchtreffer.
+type Result struct {
+	MessageID string
+	Subject   string
+}
+
+// Search sucht queryText innerhalb der Volltextfelder, strikt begrenzt auf
+// den Mandanten tenantSlug (Akzeptanzkriterium 3: mandantengetrennt
+// abfragbar) — der Tenant-Filter läuft über ein strukturiertes "equals"-
+// Match-Feld der JSON-API, niemals über eine interpolierte WHERE-Klausel.
+func (c *Client) Search(ctx context.Context, tenantSlug, queryText string) ([]Result, error) {
+	matchFields := strings.Join(searchableTextFields, ",")
+
+	payload := map[string]any{
+		"index": IndexName,
+		"query": map[string]any{
+			"bool": map[string]any{
+				"must": []map[string]any{
+					{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
+					{"match": map[string]any{matchFields: queryText}},
+				},
+			},
+		},
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("search: suchanfrage serialisieren: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/search", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("search: suchanfrage bauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("search: suche ausführen: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("search: antwort lesen: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("search: suche, status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var parsed searchResponse
+	if err := json.Unmarshal(respBody, &parsed); err != nil {
+		return nil, fmt.Errorf("search: antwort parsen: %w", err)
+	}
+
+	results := make([]Result, 0, len(parsed.Hits.Hits))
+	for _, hit := range parsed.Hits.Hits {
+		results = append(results, Result{
+			MessageID: hit.Source.MessageID,
+			Subject:   hit.Source.Subject,
+		})
+	}
+	return results, nil
+}
+
+type searchResponse struct {
+	Hits struct {
+		Hits []struct {
+			Source struct {
+				MessageID string `json:"message_id"`
+				Subject   string `json:"subject"`
+			} `json:"_source"`
+		} `json:"hits"`
+	} `json:"hits"`
+}

mail/internal/search/client_test.go

@@ -0,0 +1,73 @@
+package search
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// TestSearch_MaliciousInputDoesNotAlterFieldNames ist die geforderte
+// Pflichtprüfung 2: eine Abfrage mit manipulierten Eingabewerten
+// (SQL-/Injection-artige Zeichen in tenantSlug und queryText) darf keine
+// Spalten-/Tabellennamen in der an Manticore gesendeten Anfrage verändern
+// — Werte landen ausschließlich als JSON-String-Werte, niemals als
+// Feld-/Tabellenname.
+func TestSearch_MaliciousInputDoesNotAlterFieldNames(t *testing.T) {
+	var captured map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&captured); err != nil {
+			t.Fatal(err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"hits":{"hits":[]}}`))
+	}))
+	defer srv.Close()
+
+	client := NewClient(srv.URL)
+	maliciousTenant := `acme"; DROP TABLE mail_documents; --`
+	maliciousQuery := `x' OR '1'='1`
+
+	if _, err := client.Search(context.Background(), maliciousTenant, maliciousQuery); err != nil {
+		t.Fatalf("search: %v", err)
+	}
+
+	query, ok := captured["query"].(map[string]any)
+	if !ok {
+		t.Fatal("erwartetes 'query'-Objekt fehlt in gesendetem Payload")
+	}
+	boolQuery, ok := query["bool"].(map[string]any)
+	if !ok {
+		t.Fatal("erwartetes 'bool'-Objekt fehlt")
+	}
+	must, ok := boolQuery["must"].([]any)
+	if !ok || len(must) != 2 {
+		t.Fatal("erwartete 'must'-Liste mit 2 Klauseln fehlt")
+	}
+
+	equalsClause, ok := must[0].(map[string]any)["equals"].(map[string]any)
+	if !ok {
+		t.Fatal("erwartete 'equals'-Klausel fehlt")
+	}
+	// Feldname bleibt statisch "tenant_slug" — nur der Wert enthält die
+	// böswillige Eingabe, unverändert als String.
+	if _, hasStaticField := equalsClause[FieldTenantSlug]; !hasStaticField {
+		t.Fatalf("erwartetes statisches Feld %q nicht gefunden, habe: %v", FieldTenantSlug, equalsClause)
+	}
+	if equalsClause[FieldTenantSlug] != maliciousTenant {
+		t.Fatalf("wert wurde verändert: %v", equalsClause[FieldTenantSlug])
+	}
+
+	matchClause, ok := must[1].(map[string]any)["match"].(map[string]any)
+	if !ok {
+		t.Fatal("erwartete 'match'-Klausel fehlt")
+	}
+	expectedMatchKey := "subject,body,attachment_text"
+	if _, hasStaticKey := matchClause[expectedMatchKey]; !hasStaticKey {
+		t.Fatalf("erwarteter statischer match-feld-schlüssel %q nicht gefunden, habe: %v", expectedMatchKey, matchClause)
+	}
+	if matchClause[expectedMatchKey] != maliciousQuery {
+		t.Fatalf("suchwert wurde verändert: %v", matchClause[expectedMatchKey])
+	}
+}

mail/internal/search/fields.go

@@ -0,0 +1,29 @@
+// Package search implementiert SRC-01: den Manticore-RT-Suchindex für
+// Mail-Inhalte. Bekannter Fehler vermeiden (siehe known-issues-archivmail.md
+// #11/#12): archivmail baute WHERE-Klauseln und teils Spalten-/Tabellennamen
+// dynamisch über fmt.Sprintf/strings.Join zusammen. Für dieses Paket gilt
+// verbindlich: Spalten- und Tabellennamen kommen AUSSCHLIESSLICH aus den
+// Konstanten dieser Datei, nirgendwo sonst im Paket wird ein Feld- oder
+// Tabellenname zur Laufzeit zusammengesetzt. Suchanfragen laufen über die
+// strukturierte Manticore-HTTP-JSON-API (Query/Insert-Sub, kein
+// String-Zusammenbau von SQL), nicht über die SQL-Schnittstelle.
+package search
+
+// IndexName ist der einzige Ort, an dem der Manticore-Indexname als
+// Literal steht.
+const IndexName = "mail_documents"
+
+// Statische Feld-Whitelist des mail_documents-Index (muss deckungsgleich
+// mit migrations/0001_mail_documents.sql bleiben).
+const (
+	FieldTenantSlug     = "tenant_slug"
+	FieldMessageID      = "message_id"
+	FieldSubject        = "subject"
+	FieldBody           = "body"
+	FieldAttachmentText = "attachment_text"
+	FieldSentAt         = "sent_at"
+)
+
+// searchableTextFields sind die Volltextfelder, über die eine Suchanfrage
+// läuft (Akzeptanzprüfung 3: Volltextsuche liefert erwartete Treffer).
+var searchableTextFields = []string{FieldSubject, FieldBody, FieldAttachmentText}

mail/internal/search/integration_test.go

@@ -0,0 +1,98 @@
+// Integrationstest (SRC-01): echte Manticore-Instanz auf dem Testhost.
+// Folgt derselben TEST_*-Env-Konvention wie mail/internal/example und
+// mail/internal/dedup — TEST_MANTICORE_URL.
+package search
+
+import (
+	"context"
+	"os"
+	"testing"
+)
+
+func setupClient(t *testing.T) *Client {
+	t.Helper()
+	baseURL := os.Getenv("TEST_MANTICORE_URL")
+	if baseURL == "" {
+		t.Skip("TEST_MANTICORE_URL nicht gesetzt, Integrationstest übersprungen")
+	}
+	client := NewClient(baseURL)
+	if err := client.EnsureSchema(context.Background()); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	return client
+}
+
+// TestSearch_FindsExpectedDocument ist die geforderte Pflichtprüfung 3:
+// Funktionstest bestätigt, dass die Volltextsuche erwartete Treffer für
+// einen Testkorpus liefert.
+func TestSearch_FindsExpectedDocument(t *testing.T) {
+	client := setupClient(t)
+	ctx := context.Background()
+	tenant := "mandant-src01-funktionstest"
+
+	if err := client.Index(ctx, Document{
+		ID:         910001,
+		TenantSlug: tenant,
+		MessageID:  "msg-funktionstest-1",
+		Subject:    "Quartalsbericht Q3",
+		Body:       "Anbei der vollständige Quartalsbericht mit Umsatzzahlen.",
+	}); err != nil {
+		t.Fatalf("index: %v", err)
+	}
+	if err := client.Index(ctx, Document{
+		ID:         910002,
+		TenantSlug: tenant,
+		MessageID:  "msg-funktionstest-2",
+		Subject:    "Mittagessen morgen",
+		Body:       "Wollen wir zusammen essen gehen?",
+	}); err != nil {
+		t.Fatalf("index: %v", err)
+	}
+
+	results, err := client.Search(ctx, tenant, "Quartalsbericht")
+	if err != nil {
+		t.Fatalf("search: %v", err)
+	}
+	found := false
+	for _, r := range results {
+		if r.MessageID == "msg-funktionstest-1" {
+			found = true
+		}
+		if r.MessageID == "msg-funktionstest-2" {
+			t.Fatal("unerwarteter treffer für nicht passende nachricht")
+		}
+	}
+	if !found {
+		t.Fatalf("erwarteten treffer msg-funktionstest-1 nicht gefunden, habe: %+v", results)
+	}
+}
+
+// TestSearch_TenantIsolation ist Akzeptanzkriterium 3 (mandantengetrennt
+// abfragbar): identischer Inhalt bei zwei Mandanten, Suche bei Mandant A
+// darf keinen Treffer bei Mandant B liefern.
+func TestSearch_TenantIsolation(t *testing.T) {
+	client := setupClient(t)
+	ctx := context.Background()
+	tenantA := "mandant-src01-iso-a"
+	tenantB := "mandant-src01-iso-b"
+
+	if err := client.Index(ctx, Document{
+		ID:         910101,
+		TenantSlug: tenantA,
+		MessageID:  "msg-iso-a",
+		Subject:    "Vertraulicher Betreff Alpha",
+		Body:       "Inhalt nur für Mandant A.",
+	}); err != nil {
+		t.Fatalf("index mandant a: %v", err)
+	}
+
+	results, err := client.Search(ctx, tenantB, "Vertraulicher")
+	if err != nil {
+		t.Fatalf("search mandant b: %v", err)
+	}
+	for _, r := range results {
+		if r.MessageID == "msg-iso-a" {
+			t.Fatal("mandant b hat treffer aus mandant a gesehen — mandantentrennung verletzt")
+		}
+	}
+}

mail/internal/search/migrations/0001_mail_documents.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS mail_documents (
+    tenant_slug     string attribute indexed,
+    message_id      string attribute indexed,
+    subject         text,
+    body            text,
+    attachment_text text,
+    sent_at         timestamp
+)

mail/internal/search/no_dynamic_sql_test.go

@@ -0,0 +1,37 @@
+package search
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestNoDynamicSQLClauseBuilding ist die geforderte Pflichtprüfung 1:
+// Codereview bestätigt automatisiert, dass client.go keine Sprintf/Join-
+// basierte SQL-Klauselbildung enthält (Bekannter Fehler #11/#12 aus
+// known-issues-archivmail.md). Die einzige SQL-Anfrage des Pakets
+// (EnsureSchema, /sql-Endpunkt) darf ausschließlich den statisch
+// eingebetteten Migrationstext verwenden — kein fmt.Sprintf, kein
+// String-Concat/Join zum Bau von SQL-Text.
+func TestNoDynamicSQLClauseBuilding(t *testing.T) {
+	src, err := os.ReadFile("client.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	code := string(src)
+
+	if strings.Contains(code, "fmt.Sprintf") {
+		t.Fatal("client.go darf kein fmt.Sprintf verwenden (SQL-Klauselbildung verboten, siehe known-issues #11/#12)")
+	}
+	_, after, found := strings.Cut(code, `"/sql?mode=raw"`)
+	if !found {
+		t.Fatal("erwarteter /sql-Aufruf nicht gefunden")
+	}
+	window := after
+	if len(window) > 200 {
+		window = window[:200]
+	}
+	if strings.Contains(window, "+") {
+		t.Fatal("kein '+'-String-Zusammenbau in der Nähe des /sql-Aufrufs erlaubt")
+	}
+}

mail/internal/storage/driver.go

@@ -0,0 +1,49 @@
+// 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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,75 @@
+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
+}

web/shl/README.md

@@ -1,45 +0,0 @@
-# @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

@@ -1,38 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-// 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

@@ -1,88 +0,0 @@
-"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

@@ -1,98 +0,0 @@
-// 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

@@ -1,62 +0,0 @@
-"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

@@ -1,83 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-"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

@@ -1,75 +0,0 @@
-"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

@@ -1,25 +0,0 @@
-// Ö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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,81 +0,0 @@
-"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

@@ -1,96 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-{
-  "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

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

web/shl/vitest.setup.ts

@@ -1,9 +0,0 @@
-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();
-});