ING-04: mime-anhang-parsing

- mail/internal/mimeparse.Parse: rekursive Multipart-Zerlegung,
  Zeichensatz-Reparatur (mime.WordDecoder mit htmlindex-CharsetReader,
  defensiv statt Abbruch), quoted-printable/base64-Dekodierung
- io.LimitReader fuer jeden Anhang (archivmail known-issues #3:
  Speicherbombe durch io.ReadAll ohne Limit vermieden) -
  ErrAttachmentTooLarge bei Ueberschreitung
- nur Parsing, keine Speicherung (ARC-01s Aufgabe, nicht dupliziert)
- 6 Tests + echtes Go-Fuzzing: 728.164 reale Fuzz-Durchlaeufe
  (go test -fuzz=FuzzParse -fuzztime=45s), 0 Abstuerze, 146
  coverage-erweiternde Eingaben gefunden
- alle 3 Pflichtpruefungen real bestanden (Speicherbombe abgewehrt,
  realitaetsnaher Testkorpus, Fuzz-Nachweis)

Pruefungen siehe mail/docs/ING-04-PRUEFPROTOKOLL.md

.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

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

mail/go.sum

@@ -0,0 +1,28 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

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