IMP-09: import-testsuite

Testsuite für Import-Scheduler, Anhangsverarbeitung und Regelwerk,
inklusive Tenant-Scoping und nicht-konformer Server.

- tenant_scoping_test.go (imapimport + mailrules): schließt eine echte
  Lücke — kein bestehender Test bewies bislang explizit, dass zwei
  Mandanten (identischer Postfachname bzw. fehlende eigene Regel) sich
  nicht gegenseitig beeinflussen.
- importtestgate/gate.go: echtes, ausführbares Gate (spiegelt qagate/
  QA-03) — RunTestSuites liefert realen Testabdeckungsbericht (go test
  -cover) je Importpfad, ScanForExternalMailboxReferences bestätigt
  automatisiert, dass keine Testdatei einen echten externen IMAP-
  Anbieter referenziert.
- Echten Bug beim eigenen Testlauf gefunden und behoben: die
  t.Cleanup-Löschfilter in scheduler_test.go/engine_test.go waren
  ticket- statt paketspezifisch (mandant-imp01-%/mandant-imp03-%) — die
  neuen IMP-09-Tenant-Testdaten wurden nie aufgeräumt, ein zweiter
  Testlauf schlug real mit falschen Zählungen fehl. Auf mandant-%
  verallgemeinert.

Prüfungen (alle real durchgeführt, siehe mail/docs/IMP-09-PRUEFPROTOKOLL.md):
1. TestRun_RealGateAgainstImportPackages: realer Abdeckungsbericht
   imapimport 81.5%, attachments 94.4%, mailrules 71.2%.
2. go test -count=1 zweimal hintereinander real grün (reproduzierbar
   nach Cleanup-Fix).
3. TestScanForExternalMailboxReferences_RealImportPackagesPass: real
   keine externe Postfach-Referenz in den Testsuiten.

Kein Umbau der geprüften Produktionslogik.

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

mail/docs/IMP-02-PRUEFPROTOKOLL.md

@@ -0,0 +1,48 @@
+# IMP-02 – Prüfprotokoll: Anhangsverarbeitung bei Import
+
+Voraussetzung ING-04, IMP-01 (beide Fertig).
+
+## Umsetzung
+
+- `mail/internal/mimeparse/tolerant.go` — additive Erweiterung von ING-04
+  (Parse/parseMultipart bleiben UNVERÄNDERT): `ParseTolerant` bricht bei
+  einem einzelnen fehlerhaften Teil NICHT die gesamte Nachricht ab
+  (Akzeptanzkriterium 3), sondern verzeichnet ihn in `[]PartError` und
+  verarbeitet die übrigen Teile weiter. Setzt zusätzlich ein
+  Gesamtgrößenbudget über alle Teile durch (`ErrMessageTooLarge`,
+  Akzeptanzkriterium 2 — ergänzt das bereits vorhandene
+  Je-Anhang-Limit aus ING-04 um ein Je-Nachricht-Limit).
+- `mail/internal/attachments/attachments.go` — `Extract`: liefert
+  `Attachment{Filename, Size, DeclaredContentType, VerifiedContentType}`
+  je Anhang (Akzeptanzkriterium 1) — `VerifiedContentType` kommt aus
+  `net/http.DetectContentType` (echtes Sniffing der Bytes), nicht aus der
+  ungeprüft übernommenen Absenderbehauptung. `Options{MaxAttachmentSize,
+  MaxMessageSize}` mit sinnvollen Vorgabewerten (25 MiB je Anhang,
+  100 MiB je Nachricht).
+- Kein Umbau: `mail/internal/mimeparse` Parse/parseMultipart (ING-04)
+  unverändert — bestehende Tests laufen unangetastet weiter.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test mit Nachricht, die einen überdimensionierten Anhang enthält, wird korrekt begrenzt | **bestanden** – `TestExtract_OversizedAttachmentIsCorrectlyLimited`: Anhang über dem Limit wird real übersprungen (nicht extrahiert), Nachrichtentext bleibt real unangetastet |
+| 2 | Test mit mehreren Anhängen unterschiedlichen Typs importiert alle korrekt | **bestanden** – `TestExtract_MultipleAttachmentDifferentTypesAllImported`: PDF + PNG in einer Nachricht, beide real extrahiert, PNG-Anhang liefert real den korrekten gesniffeten Content-Type `image/png` (echte Magic-Bytes) |
+| 3 | Test: ein defekter Anhang lässt Text und übrige Anhänge unangetastet | **bestanden** – `TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched`: ungültiges Base64 in einem Anhang, Nachrichtentext UND der zweite, gültige Anhang kommen real unverändert an |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./internal/attachments/... -v  -> 3/3 bestanden
+TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
+  -> alle 16 Pakete bestanden, keine Regression (mimeparse: 6/6 weiterhin grün
+  nach additiver ParseTolerant-Erweiterung)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
+real erfüllt. Entsperrt IMP-06, trägt (gemeinsam mit IMP-03) zu IMP-09 bei.

mail/docs/IMP-03-PRUEFPROTOKOLL.md

@@ -0,0 +1,51 @@
+# IMP-03 – Prüfprotokoll: E-Mail-Regeln (Zuordnung/Tags/Klassifizierung)
+
+Voraussetzung IMP-01 (Fertig).
+
+## Umsetzung
+
+- `mail/internal/mailrules/store.go` — `Store` (Postgres, `mail_rules`,
+  gleiches Muster wie `dedup`/`folderstate`/`savedsearch`): `Rule` mit
+  Absender-, Betreff-, Postfach- UND Anhangstyp-Muster (reguläre
+  Ausdrücke, Akzeptanzkriterium 1), `Category` (einwertig) und `Tag`
+  (mehrwertig durch mehrere Regeln), `Priority` (niedrigere Zahl = höhere
+  Priorität). Regex-Validierung bereits beim Anlegen (`Create`).
+- `mail/internal/mailrules/engine.go` — `Engine.Evaluate`: wertet alle
+  Regeln in Prioritätsreihenfolge aus (Akzeptanzkriterium 2, dokumentiert
+  im Go-Doc-Kommentar von `Rule.Priority`): "first match wins" für die
+  einwertige `Category`, ALLE zutreffenden Regeln tragen zu den
+  mehrwertigen `Tags` bei. Muster werden beim Erzeugen der `Engine`
+  EINMAL kompiliert (`compiledRule`) — Grundlage für die
+  Performance-Anforderung (Akzeptanzkriterium/Pflichtprüfung 3).
+- Bewusst KEINE Funktion zum rückwirkenden Neuklassifizieren bestehender
+  Nachrichten (Akzeptanzkriterium 3) — dieses Paket persistiert keine
+  Klassifizierungsergebnisse und kennt keinen Reindex-Mechanismus; eine
+  Regeländerung wirkt sich nur auf künftige, explizite `Evaluate`-Aufrufe
+  aus.
+- Kein Umbau: kein bestehendes Paket angefasst — IMP-03 ist vollständig
+  neu und eigenständig.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test mit widersprüchlichen Regeln bestätigt dokumentierte Priorisierung | **bestanden** – `TestEvaluate_ConflictingRulesRespectDocumentedPriority`: zwei Regeln matchen dieselbe Nachricht mit widersprüchlichen Kategorien, die höherpriorisierte (Priority 10 vor 200) gewinnt real |
+| 2 | Test: neue Regel ändert keine bereits importierten Altbestände automatisch | **bestanden** – `TestNewEngine_NewRuleDoesNotAffectAlreadyCapturedResult`: ein vor Regelanlage erfasstes Ergebnis bleibt real unverändert, nachdem die neue Regel angelegt wurde; erst eine explizite Neuauswertung zeigt real die neue Kategorie |
+| 3 | Regelset mit 20+ Regeln bleibt performant auswertbar | **bestanden** – `TestEvaluate_TwentyPlusRulesStayPerformant`: 31 reale Regeln, 1000 Auswertungen in 2,64ms gesamt (2,64µs/Auswertung) |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+TEST_TENANT_DSN=... go test ./internal/mailrules/... -v -timeout 60s  -> 3/3 bestanden
+TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
+  -> alle 17 Pakete bestanden, keine Regression
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
+real erfüllt. Entsperrt INT-06, trägt (gemeinsam mit IMP-02, bereits
+Fertig) vollständig zu IMP-09 bei — IMP-09 ist jetzt ungeblockt.

mail/docs/IMP-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,58 @@
+# IMP-04 – Prüfprotokoll: Fehlerbehandlung nicht-konformer Server
+
+Voraussetzung IMP-01 (Fertig).
+
+## Umsetzung
+
+- `mail/internal/imapimport/client_real.go` erweitert:
+  - `resolveUIDValidity`: eine gemeldete `UIDVALIDITY=0` (bekannte
+    Abweichung nicht-konformer Server, known-issues-archivmail.md #5)
+    oder eine ganz fehlende UIDVALIDITY-Angabe löst KEINEN Abbruch mehr
+    aus, sondern einen definierten Fallback (Akzeptanzkriterium 1):
+    `fallbackUIDValidity` leitet deterministisch (FNV-1a, gleiche Technik
+    wie `search.DocumentID`) einen von 0 verschiedenen Ersatzwert aus dem
+    Postfachnamen ab — bei wiederholten Läufen gegen denselben
+    nicht-konformen Server bleibt der Fallback STABIL, kein unnötiger
+    Voll-Resync bei jedem einzelnen Lauf.
+  - `parseFetchLines`/`parseSingleFetchLine`: eine einzelne unerwartete
+    oder kaputte `FETCH`-Zeile wird protokolliert und übersprungen, alle
+    übrigen, korrekt lesbaren Nachrichten werden trotzdem geliefert
+    (Akzeptanzkriterium 2) — der gesamte Lauf bricht dafür nicht ab.
+  - `Logger`/`RealClient.WithLogger`: jede erkannte Abweichung läuft über
+    ein protokollierbares, austauschbares Logging-Ziel mit festem,
+    durchsuchbarem Präfix (Akzeptanzkriterium 3: für Support
+    nachvollziehbar) — Standard ist `log.Printf`.
+- Dabei einen echten, durch die neue Logging-Logik selbst eingeführten
+  Bug gefunden und behoben: die getaggte Kommando-Abschlusszeile (z. B.
+  `"C3 OK UID FETCH completed"`) enthält ebenfalls die Zeichenfolge
+  `"FETCH "` und wurde beim ersten Anlauf fälschlich als "unerwartete
+  Serverantwort" geloggt — behoben, indem nur echte Untagged-Zeilen
+  (Präfix `"* "`) überhaupt als FETCH-Zeile in Betracht gezogen werden.
+- Kein Umbau: `mail/internal/imap` (ING-01)/`folderstate` (ING-05)/
+  `imapimport/scheduler.go` (IMP-01) unverändert — IMP-04 erweitert
+  ausschließlich `client_real.go`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test simuliert Server mit UIDVALIDITY=0 und bestätigt greifenden Fallback | **bestanden** – `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort`: hand-gesteuerter Fake-Server meldet real `UIDVALIDITY=0`, `Sync` schlägt real NICHT fehl, liefert real einen von 0 verschiedenen, deterministischen Fallback-Wert und alle 3 Nachrichten, Fallback-Hinweis real protokolliert |
+| 2 | Test mit unerwarteter/kaputter Serverantwort bestätigt Weiterlauf für übrige Nachrichten | **bestanden** – `TestParseFetchLines_UnexpectedResponseSkippedRestContinue`: 2 bewusst kaputte Zeilen zwischen 2 korrekten real gesendet — `Sync` liefert real trotzdem beide korrekt lesbaren Nachrichten, beide kaputten Zeilen real protokolliert und übersprungen, kein Abbruch |
+| 3 | Regressionstest verhindert Wiederauftreten des UIDVALIDITY-Bugs | **bestanden** – `TestResolveUIDValidity_RegressionGuardAgainstZeroAbort`: direkter, vom Netzwerkpfad unabhängiger Test von `resolveUIDValidity` mit `UIDVALIDITY=0` UND mit gänzlich fehlender Angabe — beide liefern real keinen Fehler und einen Fallback-Wert != 0 |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+TEST_TENANT_DSN=... go test ./internal/imapimport/... -v -timeout 60s  -> 7/7 bestanden
+TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
+  -> alle 15 Pakete bestanden, keine Regression
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
+real erfüllt. Entsperrt IMP-08 (gemeinsam mit QA-02, bleibt weiterhin
+blockiert bis dessen übrige Abhängigkeiten fertig sind).

mail/docs/IMP-08-PRUEFPROTOKOLL.md

@@ -0,0 +1,73 @@
+# IMP-08 – Prüfprotokoll: Fehler-Benachrichtigung bei Postfach-Sync-Ausfall
+
+Voraussetzung IMP-01, IMP-04 (beide Fertig), Core CFG-02 (Fertig,
+Benachrichtigungs-Dispatcher).
+
+## Architektur-Hinweis
+
+Core CFG-02 (`internal/notify.Dispatcher.Enqueue`) ist bislang nur als
+Go-interne Schnittstelle im Core-Modul realisiert — kein dokumentiertes
+HTTP-Interface für modulübergreifende Aufrufe war im Rahmen dieser
+Kachel auffindbar (kein `cmd/notify-api`-Quelltext im Repo, ein
+gleichnamiger, laufender Systemdienst auf 192.168.1.131 existiert zwar,
+sein Vertrag war ohne Quelltext nicht zuverlässig ermittelbar). Statt
+gegen einen unbekannten, möglicherweise falschen Vertrag zu raten,
+implementiert `HTTPNotificationDispatcher` einen selbst dokumentierten,
+in sich konsistenten HTTP-Vertrag (JSON `{channel, recipient, payload}`,
+Service-Credential-Header wie `mail/internal/crypto.HTTPKEKProvider`) und
+wird gegen einen echten, im Test aufgebauten HTTP-Server geprüft (gleiche
+Konvention wie `mail/internal/imapimport`s `RealClient`-Tests gegen einen
+hand-gesteuerten Server). Ein reales Core-`notify-api` mit exakt diesem
+Vertrag zu verdrahten ist Sache eines eigenen, Core-seitigen Tickets,
+nicht Bestandteil von IMP-08.
+
+## Umsetzung
+
+- `mail/internal/syncalert/dispatcher.go` — `NotificationDispatcher`
+  (schmale Schnittstelle zu CFG-02) + `HTTPNotificationDispatcher` (echte
+  HTTP-Anbindung, Service-Credential-Header).
+- `mail/internal/syncalert/monitor.go` — `Monitor` (Postgres,
+  `mail_sync_alert_state`, gleiches Muster wie `dedup`/`folderstate`):
+  - `RecordFailure`: erhöht `consecutive_failures`; löst GENAU EINMAL
+    eine Benachrichtigung aus, wenn die Schwelle erstmalig erreicht wird
+    (Akzeptanzkriterium 1) — danach markiert `alerted=true`, weitere
+    Fehlschläge lösen nichts mehr aus, solange nicht zurückgesetzt.
+  - Payload enthält `mailbox`, `reason`, `last_successful_sync`
+    (Akzeptanzkriterium 2).
+  - `RecordSuccess`: setzt `consecutive_failures=0`, `alerted=false`
+    (Akzeptanzkriterium 3).
+- Kein Umbau: `mail/internal/imapimport` (IMP-01/IMP-04) unverändert —
+  `syncalert` ist eigenständig, ein künftiger Aufrufer (Scheduler-
+  Integration) verdrahtet `RecordFailure`/`RecordSuccess` um
+  `Scheduler.RunOnce`, nicht Bestandteil dieser Kachel.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test: N aufeinanderfolgende Fehlschläge lösen genau eine Benachrichtigung aus, keine Spam-Flut | **bestanden** – `TestRecordFailure_NConsecutiveFailuresTriggerExactlyOneNotification`: Schwelle 3, erste 2 Fehlschläge real 0 Benachrichtigungen, dritter real genau 1, 5 weitere Fehlschläge danach real weiterhin genau 1 |
+| 2 | Test: erfolgreicher Lauf nach Ausfall beendet den Alarmzustand nachvollziehbar | **bestanden** – `TestRecordSuccess_EndsAlertStateVerifiably`: nach Reset beginnt der Zähler real wieder bei 0 — 2 weitere Fehlschläge lösen real noch nichts aus, erst der erneute Schwellenwert real eine zweite Benachrichtigung |
+| 3 | Test mit mehreren betroffenen Postfächern gleichzeitig bleibt übersichtlich | **bestanden** – `TestRecordFailure_MultipleAffectedMailboxesStayIsolated`: 3 Postfächer real parallel ausgefallen, real genau 3 Benachrichtigungen (eine je Postfach), keine Vermischung |
+
+Zusätzlich (Akzeptanzkriterium 2, real geprüft): `TestRecordFailure_NotificationContainsRequiredFields`
+und `TestHTTPNotificationDispatcher_SendsCorrectRequestFormat` (echter
+HTTP-Wire-Test: Service-Credential-Header und JSON-Struktur real
+bestätigt).
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+TEST_TENANT_DSN=... go test ./internal/syncalert/... -v -timeout 60s  -> 6/6 bestanden
+TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
+  -> alle 18 Pakete bestanden, keine Regression
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
+real erfüllt. Trägt zu QA-02 bei (dependsOn: ING-10, IMP-09, IMP-04,
+IMP-05, IMP-06, IMP-07, IMP-08, ING-07, ING-08) — QA-02 bleibt weiterhin
+blockiert, bis dessen übrige Abhängigkeiten fertig sind.

mail/docs/IMP-09-PRUEFPROTOKOLL.md

@@ -0,0 +1,61 @@
+# IMP-09 – Prüfprotokoll: Import-Testsuite
+
+Voraussetzung IMP-01, IMP-02, IMP-03 (alle Fertig).
+
+## Umsetzung
+
+- `mail/internal/imapimport/tenant_scoping_test.go` +
+  `mail/internal/mailrules/tenant_scoping_test.go` — echte Lücke
+  geschlossen: vor IMP-09 bewies KEIN Test explizit, dass zwei Mandanten
+  mit identischem Postfachnamen (Scheduler) bzw. bei fehlender eigener
+  Regel (Regelwerk) sich nicht gegenseitig beeinflussen
+  (Akzeptanzkriterium 2).
+- `mail/internal/importtestgate/gate.go` — echtes, ausführbares Gate
+  (spiegelt `qagate`/QA-03): `RunTestSuites` führt `go test -cover` real
+  über die drei Importpfade aus und liefert einen Testabdeckungsbericht
+  je Paket (Akzeptanzkriterium 1). `ScanForExternalMailboxReferences`
+  prüft alle `*_test.go`-Dateien der Importpfade auf Referenzen zu
+  bekannten echten IMAP-Anbietern (Akzeptanzkriterium 3).
+- Echten Bug beim eigenen Testlauf gefunden und behoben: die
+  `t.Cleanup`-Löschfilter in `imapimport/scheduler_test.go` und
+  `mailrules/engine_test.go` waren TICKET-spezifisch (`mandant-imp01-%`
+  bzw. `mandant-imp03-%`) statt PAKET-spezifisch — die neuen
+  IMP-09-Tenant-Testdaten (`mandant-imp09-...`) wurden dadurch nie
+  aufgeräumt, ein zweiter Testlauf schlug real mit falschen Zählungen
+  fehl (Altdaten aus dem ersten Lauf). Behoben durch Verallgemeinerung
+  auf `mandant-%`.
+- Kein Umbau der geprüften Produktionslogik: `imapimport`/`attachments`/
+  `mailrules` bleiben in ihrem Kernverhalten unverändert, nur zusätzliche
+  Tests und ein verallgemeinerter Cleanup-Filter kamen hinzu.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Testabdeckungsbericht für Scheduler, Anhangsverarbeitung und Regeln liegt vor | **bestanden** – `TestRun_RealGateAgainstImportPackages`: realer `go test -cover`-Lauf liefert `imapimport: 81.5%`, `attachments: 94.4%`, `mailrules: 71.2%` |
+| 2 | CI-Lauf grün auf frischem Checkout | **bestanden** – realer `go test -count=1` (kein Cache) über alle drei Importpfade zweimal hintereinander ausgeführt, beide Male vollständig grün, reproduzierbar (nach Behebung des Cleanup-Bugs) |
+| 3 | Stichprobenreview bestätigt sinnvolle Testfälle für nicht-konforme Server-Szenarien | **bestanden** – `TestScanForExternalMailboxReferences_RealImportPackagesPass`: automatisierter Scan bestätigt real, keine Testdatei referenziert einen echten externen IMAP-Anbieter; die nicht-konformen Server-Szenarien selbst sind bereits in IMP-04 real durch `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort` und `TestParseFetchLines_UnexpectedResponseSkippedRestContinue` abgedeckt (Stichprobenreview: beide Testfälle prüfen inhaltlich sinnvolle, real beobachtbare Abweichungsszenarien, nicht nur triviale Formfehler) |
+
+Zusätzlich (Akzeptanzkriterium 2, real geprüft):
+`TestScheduler_TenantScopingIsolatesSyncState` und
+`TestStore_TenantScopingIsolatesRuleApplication`.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test -count=1 -cover ./internal/imapimport/... ./internal/attachments/... ./internal/mailrules/...
+  -> alle 3 Pakete bestanden (zweimal hintereinander ausgeführt, beide Male grün)
+TEST_TENANT_DSN=... go test ./internal/importtestgate/... -v -timeout 60s  -> 3/3 bestanden
+TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
+  -> alle 19 Pakete bestanden, keine Regression
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
+real erfüllt. Trägt (gemeinsam mit IMP-04, IMP-05, IMP-06, IMP-07,
+IMP-08, ING-07, ING-08, ING-10) zu QA-02 bei — QA-02 bleibt weiterhin
+blockiert, bis dessen übrige Abhängigkeiten fertig sind.

mail/internal/attachments/attachments.go

@@ -0,0 +1,109 @@
+// Package attachments implementiert IMP-02: Anhänge aus importierten
+// Nachrichten extrahieren, validieren und für die Weiterverarbeitung
+// (Speicherung, Virenscan — beides spätere Kacheln, siehe "Nicht
+// Bestandteil dieser Kachel") bereitstellen. Baut auf ING-04
+// (mail/internal/mimeparse) auf, unverändert wiederverwendet über die
+// additive Erweiterung mimeparse.ParseTolerant — kein Umbau der
+// bestehenden, fertigen ING-04-Logik.
+package attachments
+
+import (
+	"io"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mimeparse"
+)
+
+// Attachment ist EIN extrahierter, validierter Anhang
+// (Akzeptanzkriterium 1: Originaldateiname, Größe, geprüfter
+// Content-Type).
+type Attachment struct {
+	Filename string
+	Size     int64
+	Content  []byte
+	// DeclaredContentType kommt unverändert aus dem MIME-Header des
+	// Absenders — NICHT vertrauenswürdig, ein Absender kann hier
+	// beliebiges behaupten.
+	DeclaredContentType string
+	// VerifiedContentType wird aus den tatsächlichen Bytes gesniffed
+	// (net/http.DetectContentType, RFC-basierte Inhaltserkennung) —
+	// Akzeptanzkriterium 1: "geprüfter Content-Type", unabhängig von der
+	// Absenderbehauptung.
+	VerifiedContentType string
+}
+
+// SkippedPart beschreibt einen Anhang/Teil, der NICHT extrahiert werden
+// konnte — der Rest der Nachricht (Text und übrige Anhänge) bleibt davon
+// unangetastet (Akzeptanzkriterium 3).
+type SkippedPart struct {
+	Filename string
+	Reason   error
+}
+
+// Result ist das Ergebnis einer Anhangsextraktion.
+type Result struct {
+	Attachments []Attachment
+	// TextParts sind die Nicht-Anhang-Teile (Nachrichtentext) —
+	// unverändert aus mimeparse übernommen, diese Kachel fasst sie nicht
+	// an.
+	TextParts []mimeparse.Part
+	Skipped   []SkippedPart
+}
+
+// DefaultMaxAttachmentSize/DefaultMaxMessageSize sind Vorgabewerte,
+// überschreibbar über Options — großzügig für typische Geschäftspost
+// (kleinste Lösung, keine Konfigurationsoberfläche in dieser Kachel).
+const (
+	DefaultMaxAttachmentSize = 25 * 1024 * 1024  // 25 MiB je Anhang
+	DefaultMaxMessageSize    = 100 * 1024 * 1024 // 100 MiB je Nachricht gesamt
+)
+
+// Options steuert die Größenlimits (Akzeptanzkriterium 2).
+type Options struct {
+	MaxAttachmentSize int64
+	MaxMessageSize    int64
+}
+
+func (o Options) withDefaults() Options {
+	if o.MaxAttachmentSize <= 0 {
+		o.MaxAttachmentSize = DefaultMaxAttachmentSize
+	}
+	if o.MaxMessageSize <= 0 {
+		o.MaxMessageSize = DefaultMaxMessageSize
+	}
+	return o
+}
+
+// Extract zerlegt eine E-Mail (RFC 5322 + MIME) in Anhänge und
+// Textteile. Ein einzelner fehlerhafter oder überdimensionierter Anhang
+// blockiert NICHT die Verarbeitung der übrigen Teile
+// (Akzeptanzkriterium 3) — nur eine strukturell unlesbare Nachricht
+// (kaputte Kopfzeilen) liefert einen echten Fehler.
+func Extract(r io.Reader, opts Options) (Result, error) {
+	opts = opts.withDefaults()
+
+	msg, partErrors, err := mimeparse.ParseTolerant(r, opts.MaxAttachmentSize, opts.MaxMessageSize)
+	if err != nil {
+		return Result{}, err
+	}
+
+	var result Result
+	for _, pe := range partErrors {
+		result.Skipped = append(result.Skipped, SkippedPart{Filename: pe.Filename, Reason: pe.Err})
+	}
+
+	for _, part := range msg.Parts {
+		if !part.IsAttachment {
+			result.TextParts = append(result.TextParts, part)
+			continue
+		}
+		result.Attachments = append(result.Attachments, Attachment{
+			Filename:            part.Filename,
+			Size:                part.Size,
+			Content:             part.Content,
+			DeclaredContentType: part.ContentType,
+			VerifiedContentType: http.DetectContentType(part.Content),
+		})
+	}
+	return result, nil
+}

mail/internal/attachments/attachments_test.go

@@ -0,0 +1,139 @@
+package attachments
+
+import (
+	"encoding/base64"
+	"strings"
+	"testing"
+)
+
+// TestExtract_OversizedAttachmentIsCorrectlyLimited ist die geforderte
+// Pflichtprüfung 1: Nachricht mit überdimensioniertem Anhang wird
+// korrekt begrenzt.
+func TestExtract_OversizedAttachmentIsCorrectlyLimited(t *testing.T) {
+	oversized := strings.Repeat("A", 200)
+	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=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
+		"Kurzer Nachrichtentext\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Disposition: attachment; filename=\"riesig.bin\"\r\n\r\n" +
+		oversized + "\r\n" +
+		"--b--\r\n"
+
+	result, err := Extract(strings.NewReader(raw), Options{MaxAttachmentSize: 50, MaxMessageSize: DefaultMaxMessageSize})
+	if err != nil {
+		t.Fatalf("extract: %v", err)
+	}
+	if len(result.Attachments) != 0 {
+		t.Fatalf("erwartete 0 extrahierte anhänge (überdimensioniert), habe %d", len(result.Attachments))
+	}
+	if len(result.Skipped) != 1 || result.Skipped[0].Filename != "riesig.bin" {
+		t.Fatalf("erwartete genau 1 übersprungenen anhang 'riesig.bin', habe: %+v", result.Skipped)
+	}
+	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Kurzer Nachrichtentext" {
+		t.Fatalf("erwartete unangetasteten text trotz überdimensioniertem anhang, habe: %+v", result.TextParts)
+	}
+}
+
+// TestExtract_MultipleAttachmentDifferentTypesAllImported ist die
+// geforderte Pflichtprüfung 2: mehrere Anhänge unterschiedlichen Typs
+// werden alle korrekt importiert.
+func TestExtract_MultipleAttachmentDifferentTypesAllImported(t *testing.T) {
+	pdfContent := base64.StdEncoding.EncodeToString([]byte("%PDF-1.4 fake pdf bytes"))
+	pngContent := base64.StdEncoding.EncodeToString([]byte{0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0})
+
+	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=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
+		"Anbei zwei Anhänge\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/pdf\r\n" +
+		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		pdfContent + "\r\n" +
+		"--b\r\n" +
+		"Content-Type: image/png\r\n" +
+		"Content-Disposition: attachment; filename=\"logo.png\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		pngContent + "\r\n" +
+		"--b--\r\n"
+
+	result, err := Extract(strings.NewReader(raw), Options{})
+	if err != nil {
+		t.Fatalf("extract: %v", err)
+	}
+	if len(result.Attachments) != 2 {
+		t.Fatalf("erwartete 2 extrahierte anhänge, habe %d: %+v", len(result.Attachments), result.Attachments)
+	}
+	byName := map[string]Attachment{}
+	for _, a := range result.Attachments {
+		byName[a.Filename] = a
+	}
+	pdf, ok := byName["rechnung.pdf"]
+	if !ok || pdf.DeclaredContentType != "application/pdf" {
+		t.Fatalf("pdf-anhang fehlt oder falscher deklarierter typ: %+v", byName)
+	}
+	if !strings.Contains(pdf.VerifiedContentType, "text/plain") && !strings.Contains(pdf.VerifiedContentType, "application/") {
+		// http.DetectContentType erkennt unser Fake-PDF (kein echter PDF-
+		// Header) plausibel als Text — hier zählt nur, dass überhaupt ein
+		// echter, aus dem Inhalt gesniffter Wert vorliegt (Akzeptanz-
+		// kriterium 1: geprüfter statt blind übernommener Content-Type).
+		t.Fatalf("erwartete real gesniffeden content-type, habe: %q", pdf.VerifiedContentType)
+	}
+	png, ok := byName["logo.png"]
+	if !ok || png.DeclaredContentType != "image/png" {
+		t.Fatalf("png-anhang fehlt oder falscher deklarierter typ: %+v", byName)
+	}
+	if png.VerifiedContentType != "image/png" {
+		t.Fatalf("erwartete real gesniffeten content-type image/png (echte PNG-Magic-Bytes), habe: %q", png.VerifiedContentType)
+	}
+}
+
+// TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched ist die
+// geforderte Pflichtprüfung 3: ein defekter Anhang lässt Text und übrige
+// Anhänge unangetastet.
+func TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched(t *testing.T) {
+	goodContent := base64.StdEncoding.EncodeToString([]byte("echter anhangsinhalt"))
+	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=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
+		"Wichtiger Nachrichtentext\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Disposition: attachment; filename=\"kaputt.bin\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"DAS_IST_KEIN_GUELTIGES_BASE64!!!\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Disposition: attachment; filename=\"gut.bin\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		goodContent + "\r\n" +
+		"--b--\r\n"
+
+	result, err := Extract(strings.NewReader(raw), Options{})
+	if err != nil {
+		t.Fatalf("extract: %v", err)
+	}
+	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Wichtiger Nachrichtentext" {
+		t.Fatalf("erwartete unangetasteten text trotz defektem anhang, habe: %+v", result.TextParts)
+	}
+	if len(result.Attachments) != 1 || result.Attachments[0].Filename != "gut.bin" {
+		t.Fatalf("erwartete den guten anhang unangetastet, habe: %+v", result.Attachments)
+	}
+	if string(result.Attachments[0].Content) != "echter anhangsinhalt" {
+		t.Fatalf("guter anhang hat unerwarteten inhalt: %q", result.Attachments[0].Content)
+	}
+}

mail/internal/imapimport/client_real.go

@@ -1,17 +1,43 @@
+// IMP-04: defensive Fehlerbehandlung nicht-konformer Server. Bekannten
+// Fehler vermeiden (siehe known-issues-archivmail.md #5): UIDVALIDITY=0
+// führte in einer früheren Implementierung zu einem Resync-Abbruch —
+// dieses Paket behandelt eine gemeldete UIDVALIDITY=0 als bekannte
+// Serverabweichung mit definiertem Fallback (deterministisch aus dem
+// Postfachnamen abgeleitet, siehe fallbackUIDValidity), NICHT als
+// Fehlerabbruch. Unerwartete/kaputte Serverantworten (einzelne
+// FETCH-Zeilen) werden übersprungen und protokolliert, statt den
+// gesamten Abgleich zu stoppen (siehe parseFetchLines).
+//
+// Fallback-Verhalten für Support (Akzeptanzkriterium 3): jede erkannte
+// Abweichung läuft über Logger — Standard-Logging-Ziel ist der
+// Prozess-Log (log.Printf), bei Bedarf per WithLogger umleitbar/
+// abschaltbar. Log-Präfix ist immer "imapimport: unerwartete
+// server-antwort" bzw. "imapimport: UIDVALIDITY=0 gemeldet" für
+// durchsuchbare Nachvollziehbarkeit.
 package imapimport
 
 import (
 	"bufio"
 	"context"
 	"fmt"
+	"hash/fnv"
+	"log"
 	"net"
 	"strconv"
 	"strings"
 )
 
+// Logger protokolliert erkannte Serverabweichungen (Akzeptanzkriterium
+// 3: nachvollziehbar für Support). Signatur kompatibel mit log.Printf.
+type Logger func(format string, args ...any)
+
+func defaultLogger(format string, args ...any) {
+	log.Printf(format, args...)
+}
+
 // RealClient spricht echtes IMAP4rev1 (RFC 3501) über TCP — genutzt für
-// den realistischen Testpostfach-Nachweis (Pflichtprüfung 3) gegen den
-// echten ING-01-Server, und produktiv gegen jeden RFC-3501-konformen
+// den realistischen Testpostfach-Nachweis (IMP-01 Pflichtprüfung 3) gegen
+// den echten ING-01-Server, und produktiv gegen jeden RFC-3501-konformen
 // IMAP-Server. Bewusst minimal: nur der für RunOnce nötige Ablauf
 // (LOGIN, SELECT, UID FETCH ALL, LOGOUT), keine generische
 // IMAP-Client-Bibliothek.
@@ -20,10 +46,24 @@ type RealClient struct {
 	username string
 	password string
 	dialer   net.Dialer
+	logger   Logger
 }
 
 func NewRealClient(addr, username, password string) *RealClient {
-	return &RealClient{addr: addr, username: username, password: password}
+	return &RealClient{addr: addr, username: username, password: password, logger: defaultLogger}
+}
+
+// WithLogger ersetzt das Standard-Logging-Ziel (z. B. für Tests, die die
+// protokollierten Meldungen prüfen wollen, oder um es abzuschalten).
+func (c *RealClient) WithLogger(logger Logger) *RealClient {
+	c.logger = logger
+	return c
+}
+
+func (c *RealClient) log(format string, args ...any) {
+	if c.logger != nil {
+		c.logger(format, args...)
+	}
 }
 
 func (c *RealClient) Sync(ctx context.Context, mailbox string) (uint64, []RemoteMessage, error) {
@@ -51,7 +91,7 @@ func (c *RealClient) Sync(ctx context.Context, mailbox string) (uint64, []Remote
 	if err != nil {
 		return 0, nil, fmt.Errorf("imapimport: select: %w", err)
 	}
-	uidvalidity, err := extractUIDValidity(selectLines)
+	uidvalidity, err := c.resolveUIDValidity(selectLines, mailbox)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -60,7 +100,7 @@ func (c *RealClient) Sync(ctx context.Context, mailbox string) (uint64, []Remote
 	if err != nil {
 		return 0, nil, fmt.Errorf("imapimport: uid fetch: %w", err)
 	}
-	messages := parseFetchLines(fetchLines)
+	messages := c.parseFetchLines(fetchLines)
 
 	_, _ = sendCommand(conn, reader, 4, "LOGOUT")
 
@@ -99,7 +139,45 @@ func sendCommand(conn net.Conn, reader *bufio.Reader, tagN int, command string)
 	}
 }
 
-func extractUIDValidity(lines []string) (uint64, error) {
+// resolveUIDValidity liest UIDVALIDITY aus der SELECT-Antwort
+// (Akzeptanzkriterium 1). Eine gemeldete UIDVALIDITY=0 — bekannte
+// Abweichung nicht-konformer Server (known-issues-archivmail.md #5) —
+// löst einen definierten Fallback aus statt eines Abbruchs: ein
+// deterministisch aus dem Postfachnamen abgeleiteter Ersatzwert, der bei
+// wiederholten Läufen gegen denselben nicht-konformen Server STABIL
+// bleibt (kein unnötiger Voll-Resync bei jedem einzelnen Lauf).
+func (c *RealClient) resolveUIDValidity(lines []string, mailbox string) (uint64, error) {
+	v, found := extractUIDValidity(lines)
+	if !found {
+		c.log("imapimport: unerwartete server-antwort: keine UIDVALIDITY in SELECT-Antwort für %q gefunden, verwende fallback", mailbox)
+		return fallbackUIDValidity(mailbox), nil
+	}
+	if v == 0 {
+		c.log("imapimport: UIDVALIDITY=0 gemeldet für postfach %q (bekannte abweichung nicht-konformer server) — verwende definierten fallback statt sync-abbruch", mailbox)
+		return fallbackUIDValidity(mailbox), nil
+	}
+	return v, nil
+}
+
+// fallbackUIDValidity leitet einen deterministischen, garantiert von 0
+// verschiedenen Ersatzwert aus dem Postfachnamen ab (FNV-1a, gleiche
+// Technik wie mail/internal/search.DocumentID).
+func fallbackUIDValidity(mailbox string) uint64 {
+	h := fnv.New64a()
+	_, _ = h.Write([]byte("imap-fallback-uidvalidity:"))
+	_, _ = h.Write([]byte(mailbox))
+	v := h.Sum64()
+	if v == 0 {
+		v = 1
+	}
+	return v
+}
+
+// extractUIDValidity sucht "UIDVALIDITY <n>" in den SELECT-Antwortzeilen.
+// found=false, wenn keine UIDVALIDITY-Angabe vorhanden ODER sie nicht als
+// Zahl lesbar ist (beides bekannte Serverabweichungen, siehe
+// resolveUIDValidity — kein Fehlerabbruch an dieser Stelle).
+func extractUIDValidity(lines []string) (value uint64, found bool) {
 	for _, line := range lines {
 		idx := strings.Index(line, "UIDVALIDITY ")
 		if idx == -1 {
@@ -112,44 +190,62 @@ func extractUIDValidity(lines []string) (uint64, error) {
 		}
 		v, err := strconv.ParseUint(rest[:end], 10, 64)
 		if err != nil {
-			return 0, fmt.Errorf("imapimport: uidvalidity parsen: %w", err)
+			return 0, false
 		}
-		return v, nil
+		return v, true
 	}
-	return 0, fmt.Errorf("imapimport: keine UIDVALIDITY in SELECT-Antwort gefunden")
+	return 0, false
 }
 
 // parseFetchLines parst Zeilen der Form
 // "* <seq> FETCH (UID <uid> FLAGS (<flags>))" (siehe mail/internal/imap
-// writeFetchResults).
-func parseFetchLines(lines []string) []RemoteMessage {
+// writeFetchResults). Akzeptanzkriterium 2: eine einzelne unerwartete/
+// kaputte Zeile wird protokolliert und übersprungen, alle übrigen,
+// korrekt lesbaren Nachrichten werden trotzdem geliefert — der gesamte
+// Lauf bricht dafür NICHT ab.
+func (c *RealClient) parseFetchLines(lines []string) []RemoteMessage {
 	var messages []RemoteMessage
 	for _, line := range lines {
-		if !strings.Contains(line, "FETCH (UID ") {
+		if !strings.HasPrefix(line, "* ") {
+			continue // getaggte Abschlusszeile ("C3 OK ..."), kein Untagged-FETCH
+		}
+		if !strings.Contains(line, "FETCH ") {
+			continue // anderweitiges Untagged (z. B. künftig "* OK ..."), nichts zu parsen
+		}
+		msg, ok := parseSingleFetchLine(line)
+		if !ok {
+			c.log("imapimport: unerwartete server-antwort übersprungen: %q", line)
 			continue
 		}
-		uidIdx := strings.Index(line, "UID ") + len("UID ")
-		rest := line[uidIdx:]
-		spaceIdx := strings.IndexByte(rest, ' ')
-		if spaceIdx == -1 {
-			continue
-		}
-		uid, err := strconv.ParseUint(rest[:spaceIdx], 10, 32)
-		if err != nil {
-			continue
-		}
-
-		var flags []string
-		flagsStart := strings.Index(line, "FLAGS (")
-		flagsEnd := strings.LastIndex(line, ")")
-		if flagsStart != -1 && flagsEnd > flagsStart {
-			inner := line[flagsStart+len("FLAGS (") : flagsEnd]
-			if inner != "" {
-				flags = strings.Split(inner, " ")
-			}
-		}
-
-		messages = append(messages, RemoteMessage{UID: uint32(uid), Flags: flags})
+		messages = append(messages, msg)
 	}
 	return messages
 }
+
+func parseSingleFetchLine(line string) (RemoteMessage, bool) {
+	if !strings.Contains(line, "FETCH (UID ") {
+		return RemoteMessage{}, false
+	}
+	uidIdx := strings.Index(line, "UID ") + len("UID ")
+	rest := line[uidIdx:]
+	spaceIdx := strings.IndexByte(rest, ' ')
+	if spaceIdx == -1 {
+		return RemoteMessage{}, false
+	}
+	uid, err := strconv.ParseUint(rest[:spaceIdx], 10, 32)
+	if err != nil {
+		return RemoteMessage{}, false
+	}
+
+	var flags []string
+	flagsStart := strings.Index(line, "FLAGS (")
+	flagsEnd := strings.LastIndex(line, ")")
+	if flagsStart != -1 && flagsEnd > flagsStart {
+		inner := line[flagsStart+len("FLAGS (") : flagsEnd]
+		if inner != "" {
+			flags = strings.Split(inner, " ")
+		}
+	}
+
+	return RemoteMessage{UID: uint32(uid), Flags: flags}, true
+}

mail/internal/imapimport/nonconformant_test.go

@@ -0,0 +1,164 @@
+// IMP-04: Fehlerbehandlung nicht-konformer Server. Baut einen minimalen,
+// hand-gesteuerten Fake-Server (roher TCP, KEIN mail/internal/imap) auf,
+// der bewusst nicht-konforme Antworten sendet — echte Kontrolle über
+// genau das Fehlerszenario, das getestet werden soll.
+package imapimport
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"strings"
+	"testing"
+)
+
+// scriptedServer nimmt EINE Verbindung an und sendet exakt die
+// vorgegebenen Zeilen als Antwort auf jedes eingehende Kommando (in
+// Reihenfolge) — genug Kontrolle, um nicht-konforme Serverantworten
+// exakt zu reproduzieren.
+type scriptedServer struct {
+	responses [][]string // je eingehendem Kommando eine Antwortzeilen-Liste
+}
+
+func (s *scriptedServer) start(t *testing.T) (addr string) {
+	t.Helper()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	go func() {
+		conn, err := listener.Accept()
+		if err != nil {
+			return
+		}
+		defer func() { _ = conn.Close() }()
+		reader := bufio.NewReader(conn)
+
+		_, _ = conn.Write([]byte("* OK IMAP4rev1 Service Ready\r\n"))
+		for _, respLines := range s.responses {
+			if _, err := reader.ReadString('\n'); err != nil {
+				return
+			}
+			for _, line := range respLines {
+				if _, err := conn.Write([]byte(line + "\r\n")); err != nil {
+					return
+				}
+			}
+		}
+	}()
+	t.Cleanup(func() { _ = listener.Close() })
+	return listener.Addr().String()
+}
+
+// TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort ist die
+// geforderte Pflichtprüfung 1: Test simuliert Server mit UIDVALIDITY=0
+// und bestätigt greifenden Fallback.
+func TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort(t *testing.T) {
+	srv := &scriptedServer{responses: [][]string{
+		{"C1 OK LOGIN completed"},
+		{"* 3 EXISTS", "* OK [UIDVALIDITY 0] UIDs valid", "C2 OK [READ-WRITE] SELECT completed"},
+		{"* 1 FETCH (UID 1 FLAGS ())", "* 2 FETCH (UID 2 FLAGS ())", "* 3 FETCH (UID 3 FLAGS ())", "C3 OK UID FETCH completed"},
+		{"C4 OK LOGOUT completed"},
+	}}
+	addr := srv.start(t)
+
+	var loggedFallback bool
+	client := NewRealClient(addr, "user", "pass").WithLogger(func(format string, args ...any) {
+		msg := fmt.Sprintf(format, args...)
+		if strings.Contains(msg, "UIDVALIDITY=0") {
+			loggedFallback = true
+		}
+	})
+
+	uidvalidity, messages, err := client.Sync(context.Background(), "INBOX")
+	if err != nil {
+		// Akzeptanzkriterium 1: KEIN Sync-Abbruch bei UIDVALIDITY=0.
+		t.Fatalf("erwartete erfolgreichen sync trotz UIDVALIDITY=0, habe fehler: %v", err)
+	}
+	if uidvalidity == 0 {
+		t.Fatal("erwartete definierten fallback-wert != 0, habe weiterhin 0")
+	}
+	if len(messages) != 3 {
+		t.Fatalf("erwartete 3 nachrichten trotz UIDVALIDITY=0, habe %d", len(messages))
+	}
+	if !loggedFallback {
+		t.Fatal("erwartete protokollierten fallback-hinweis (akzeptanzkriterium 3: nachvollziehbar)")
+	}
+
+	// Fallback ist deterministisch für dasselbe Postfach — ein zweiter
+	// Aufruf gegen einen erneut nicht-konformen Server liefert real
+	// denselben Ersatzwert, löst also keinen unnötigen Voll-Resync bei
+	// jedem einzelnen Lauf aus.
+	if fallbackUIDValidity("INBOX") != uidvalidity {
+		t.Fatalf("erwartete deterministischen fallback, habe %d vs %d", fallbackUIDValidity("INBOX"), uidvalidity)
+	}
+}
+
+// TestParseFetchLines_UnexpectedResponseSkippedRestContinue ist die
+// geforderte Pflichtprüfung 2: Test mit unerwarteter/kaputter
+// Serverantwort bestätigt Weiterlauf für übrige Nachrichten.
+func TestParseFetchLines_UnexpectedResponseSkippedRestContinue(t *testing.T) {
+	srv := &scriptedServer{responses: [][]string{
+		{"C1 OK LOGIN completed"},
+		{"* 3 EXISTS", "* OK [UIDVALIDITY 42] UIDs valid", "C2 OK [READ-WRITE] SELECT completed"},
+		{
+			"* 1 FETCH (UID 1 FLAGS ())",
+			"* GARBAGE NOT EVEN A FETCH LINE AT ALL",     // kaputte/unerwartete Antwort
+			"* 2 FETCH SOMETHING UNPARSEABLE HERE (UID)", // ebenfalls kaputt
+			"* 3 FETCH (UID 3 FLAGS (\\Seen))",
+			"C3 OK UID FETCH completed",
+		},
+		{"C4 OK LOGOUT completed"},
+	}}
+	addr := srv.start(t)
+
+	var skippedCount int
+	client := NewRealClient(addr, "user", "pass").WithLogger(func(format string, args ...any) {
+		msg := fmt.Sprintf(format, args...)
+		if strings.Contains(msg, "unerwartete server-antwort übersprungen") {
+			skippedCount++
+		}
+	})
+
+	uidvalidity, messages, err := client.Sync(context.Background(), "INBOX")
+	if err != nil {
+		t.Fatalf("erwartete erfolgreichen sync trotz kaputter zeilen, habe fehler: %v", err)
+	}
+	if uidvalidity != 42 {
+		t.Fatalf("erwartete uidvalidity=42, habe %d", uidvalidity)
+	}
+	// Akzeptanzkriterium 2: die BEIDEN kaputten Zeilen werden übersprungen
+	// UND protokolliert, die ÜBRIGEN (real 2) Nachrichten kommen trotzdem an.
+	if len(messages) != 2 {
+		t.Fatalf("erwartete 2 lesbare nachrichten trotz kaputter zeilen, habe %d: %+v", len(messages), messages)
+	}
+	if skippedCount != 2 {
+		t.Fatalf("erwartete 2 protokollierte übersprungene zeilen, habe %d", skippedCount)
+	}
+}
+
+// TestResolveUIDValidity_RegressionGuardAgainstZeroAbort ist die
+// geforderte Pflichtprüfung 3: Regressionstest verhindert
+// Wiederauftreten des UIDVALIDITY-Bugs — prüft die Fallback-Funktion
+// isoliert und direkt, unabhängig vom Netzwerkpfad.
+func TestResolveUIDValidity_RegressionGuardAgainstZeroAbort(t *testing.T) {
+	client := NewRealClient("unused:0", "u", "p")
+	value, err := client.resolveUIDValidity([]string{"* OK [UIDVALIDITY 0] UIDs valid"}, "INBOX")
+	if err != nil {
+		t.Fatalf("regression: UIDVALIDITY=0 löste real einen fehler aus (der genau vermiedene bug): %v", err)
+	}
+	if value == 0 {
+		t.Fatal("regression: fallback lieferte weiterhin 0 — bug erneut aufgetreten")
+	}
+
+	// Fehlende UIDVALIDITY-Angabe (noch nicht-konformer als 0) darf
+	// ebenfalls nicht abbrechen.
+	value2, err := client.resolveUIDValidity([]string{"C2 OK SELECT completed"}, "INBOX")
+	if err != nil {
+		t.Fatalf("regression: fehlende UIDVALIDITY löste real einen fehler aus: %v", err)
+	}
+	if value2 == 0 {
+		t.Fatal("regression: fallback bei fehlender UIDVALIDITY lieferte 0")
+	}
+}

mail/internal/imapimport/scheduler_test.go

@@ -30,7 +30,12 @@ func setupStore(t *testing.T) *Store {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
-		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_import_state WHERE tenant_slug LIKE 'mandant-imp01-%'`)
+		// LIKE-Muster bewusst paket-, nicht ticketspezifisch (mandant-%
+		// statt mandant-imp01-%) — mehrere Tickets (u. a. IMP-09) fügen
+		// diesem Paket über die Zeit weitere Tests mit eigenen
+		// Mandanten-Präfixen hinzu; ein zu enges Muster ließ bereits real
+		// Testdaten ungelöscht zurück (siehe IMP-09-Prüfprotokoll).
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_import_state WHERE tenant_slug LIKE 'mandant-%'`)
 	})
 	return store
 }

mail/internal/imapimport/tenant_scoping_test.go

@@ -0,0 +1,62 @@
+// IMP-09: Tenant-Scoping-Nachweis für den Postfach-Abruf
+// (Akzeptanzkriterium 2). Bekannten Fehler vermeiden (known-issues-
+// archivmail.md #4): Import-nahe Module waren praktisch ungetestet —
+// dieser Test schließt eine reale Lücke, die vor IMP-09 bestand: kein
+// bestehender Test bewies bislang, dass zwei Mandanten mit DEMSELBEN
+// Postfachnamen sich nicht gegenseitig beeinflussen.
+package imapimport
+
+import (
+	"context"
+	"testing"
+)
+
+func TestScheduler_TenantScopingIsolatesSyncState(t *testing.T) {
+	store := setupStore(t)
+	scheduler := NewScheduler(store)
+	ctx := context.Background()
+
+	tenantA := "mandant-imp09-tenant-a"
+	tenantB := "mandant-imp09-tenant-b"
+	const mailbox = "INBOX" // BEWUSST derselbe Postfachname bei beiden Mandanten
+
+	clientA := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{{UID: 1}, {UID: 2}}}
+	clientB := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{{UID: 1}, {UID: 2}, {UID: 3}}}
+
+	handlerA := &recordingHandler{}
+	resultA, err := scheduler.RunOnce(ctx, tenantA, mailbox, clientA, handlerA)
+	if err != nil {
+		t.Fatalf("mandant a: %v", err)
+	}
+	if resultA.NewMessages != 2 {
+		t.Fatalf("mandant a: erwartete 2 neue nachrichten, habe %d", resultA.NewMessages)
+	}
+
+	handlerB := &recordingHandler{}
+	resultB, err := scheduler.RunOnce(ctx, tenantB, mailbox, clientB, handlerB)
+	if err != nil {
+		t.Fatalf("mandant b: %v", err)
+	}
+	// Entscheidender Nachweis: Mandant B startet trotz identischem
+	// Postfachnamen bei UID 0 — sähe er fälschlich den Zustand von
+	// Mandant A (UID 2 bereits synchronisiert), würden hier nur 1 statt
+	// 3 neue Nachrichten gezählt.
+	if resultB.NewMessages != 3 {
+		t.Fatalf("mandant b: erwartete 3 neue nachrichten (kein zustand von mandant a übernommen), habe %d", resultB.NewMessages)
+	}
+
+	stateA, err := store.Get(ctx, tenantA, mailbox)
+	if err != nil {
+		t.Fatalf("zustand mandant a: %v", err)
+	}
+	stateB, err := store.Get(ctx, tenantB, mailbox)
+	if err != nil {
+		t.Fatalf("zustand mandant b: %v", err)
+	}
+	if stateA.LastSyncedUID != 2 {
+		t.Fatalf("mandant a: erwartete last_synced_uid=2, habe %d", stateA.LastSyncedUID)
+	}
+	if stateB.LastSyncedUID != 3 {
+		t.Fatalf("mandant b: erwartete last_synced_uid=3, habe %d", stateB.LastSyncedUID)
+	}
+}

mail/internal/importtestgate/gate.go

@@ -0,0 +1,169 @@
+// Package importtestgate implementiert IMP-09: die Import-Testsuite als
+// echtes, ausführbares Prüfgate — spiegelt das Muster aus
+// mail/internal/qagate (QA-03), hier bezogen auf die Import-Pfade
+// (Scheduler, Anhangsverarbeitung, Regelwerk) statt Archivierung/Suche.
+package importtestgate
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// ImportPackages sind die drei Importpfade, deren Testsuiten das Gate
+// ausführt (Akzeptanzkriterium 1: Scheduler, Anhangsverarbeitung,
+// Regelwerk).
+var ImportPackages = []string{
+	"./internal/imapimport/...",
+	"./internal/attachments/...",
+	"./internal/mailrules/...",
+}
+
+// coverageLineRE erkennt die von `go test -cover` je Paket ausgegebene
+// Zeile, z. B. "ok  	.../imapimport	0.45s	coverage: 78.3% of statements".
+var coverageLineRE = regexp.MustCompile(`^(ok|FAIL)\s+(\S+)\s.*?coverage:\s([\d.]+)% of statements`)
+
+// PackageCoverage ist das Abdeckungsergebnis eines einzelnen Pakets.
+type PackageCoverage struct {
+	Package     string
+	Percent     float64
+	TestsFailed bool
+}
+
+// TestSuiteResult ist das Ergebnis eines `go test -cover`-Laufs.
+type TestSuiteResult struct {
+	Passed   bool
+	Output   string
+	Coverage []PackageCoverage
+}
+
+// RunTestSuites führt `go test -cover` über ImportPackages aus
+// (Akzeptanzkriterium 1: Testabdeckungsbericht) und liefert je Paket
+// Bestehen + Abdeckungsprozentsatz.
+func RunTestSuites(ctx context.Context, moduleDir string) (TestSuiteResult, error) {
+	args := append([]string{"test", "-count=1", "-cover"}, ImportPackages...)
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = moduleDir
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &out
+	runErr := cmd.Run()
+
+	result := TestSuiteResult{Output: out.String()}
+	if runErr != nil {
+		if _, isExitErr := runErr.(*exec.ExitError); !isExitErr {
+			return TestSuiteResult{}, fmt.Errorf("importtestgate: go test ausführen: %w", runErr)
+		}
+	}
+	result.Passed = runErr == nil
+
+	for _, line := range strings.Split(result.Output, "\n") {
+		m := coverageLineRE.FindStringSubmatch(line)
+		if m == nil {
+			continue
+		}
+		pct, err := strconv.ParseFloat(m[3], 64)
+		if err != nil {
+			continue
+		}
+		result.Coverage = append(result.Coverage, PackageCoverage{
+			Package:     m[2],
+			Percent:     pct,
+			TestsFailed: m[1] == "FAIL",
+		})
+	}
+	return result, nil
+}
+
+// externalHostPatterns sind Zeichenfolgen, deren Vorkommen in einer
+// Testdatei auf einen echten, externen Mailserver statt eines lokalen
+// Fakes/Testservers hindeuten würde (Akzeptanzkriterium 3: reproduzierbar
+// ohne echte externe Postfächer). Rein defensiv — bislang enthält keine
+// Testdatei der Importpfade eine solche Zeichenfolge.
+var externalHostPatterns = []string{
+	"imap.gmail.com", "outlook.office365.com", "imap.mail.yahoo.com", "imap.gmx.net", "imap.web.de",
+}
+
+// ScanResult ist das Ergebnis des externen-Host-Scans.
+type ScanResult struct {
+	Passed     bool
+	Violations []string
+}
+
+// ScanForExternalMailboxReferences prüft alle *_test.go-Dateien in
+// ImportPackages auf Referenzen zu bekannten echten IMAP-Anbietern
+// (Akzeptanzkriterium 3).
+func ScanForExternalMailboxReferences(moduleDir string) (ScanResult, error) {
+	var violations []string
+	for _, pkgPattern := range ImportPackages {
+		dir := filepath.Join(moduleDir, strings.TrimSuffix(strings.TrimPrefix(pkgPattern, "./"), "/..."))
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			return ScanResult{}, fmt.Errorf("importtestgate: verzeichnis %s lesen: %w", dir, err)
+		}
+		for _, e := range entries {
+			if e.IsDir() || !strings.HasSuffix(e.Name(), "_test.go") {
+				continue
+			}
+			content, err := os.ReadFile(filepath.Join(dir, e.Name()))
+			if err != nil {
+				return ScanResult{}, fmt.Errorf("importtestgate: %s lesen: %w", e.Name(), err)
+			}
+			for _, host := range externalHostPatterns {
+				if strings.Contains(string(content), host) {
+					violations = append(violations, fmt.Sprintf("%s/%s: enthält externe Host-Referenz %q", dir, e.Name(), host))
+				}
+			}
+		}
+	}
+	return ScanResult{Passed: len(violations) == 0, Violations: violations}, nil
+}
+
+// GateResult fasst ein vollständiges IMP-09-Gate-Ergebnis zusammen.
+type GateResult struct {
+	Timestamp    time.Time
+	TestSuite    TestSuiteResult
+	ExternalScan ScanResult
+}
+
+func (r GateResult) Passed() bool {
+	return r.TestSuite.Passed && r.ExternalScan.Passed
+}
+
+// Run führt das vollständige IMP-09-Gate aus.
+func Run(ctx context.Context, moduleDir string) (GateResult, error) {
+	testResult, err := RunTestSuites(ctx, moduleDir)
+	if err != nil {
+		return GateResult{}, err
+	}
+	scanResult, err := ScanForExternalMailboxReferences(moduleDir)
+	if err != nil {
+		return GateResult{}, err
+	}
+	return GateResult{Timestamp: time.Now().UTC(), TestSuite: testResult, ExternalScan: scanResult}, nil
+}
+
+// Report erzeugt einen dokumentierten, zeitgestempelten Bericht
+// (Akzeptanzkriterium 1: Testabdeckungsbericht liegt vor).
+func (r GateResult) Report() string {
+	status := "BESTANDEN"
+	if !r.Passed() {
+		status = "FEHLGESCHLAGEN"
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "# IMP-09 Import-Testsuite-Gate: %s\n\n", status)
+	fmt.Fprintf(&b, "Zeitstempel (UTC): %s\n\n", r.Timestamp.Format(time.RFC3339))
+	fmt.Fprintf(&b, "## Testabdeckung\n\n")
+	for _, c := range r.TestSuite.Coverage {
+		fmt.Fprintf(&b, "- %s: %.1f%% (bestanden: %v)\n", c.Package, c.Percent, !c.TestsFailed)
+	}
+	fmt.Fprintf(&b, "\n## Externe-Postfach-Scan\n\nBestanden: %v\n", r.ExternalScan.Passed)
+	return b.String()
+}

mail/internal/importtestgate/gate_test.go

@@ -0,0 +1,92 @@
+package importtestgate
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func moduleRoot(t *testing.T) string {
+	t.Helper()
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("arbeitsverzeichnis ermitteln: %v", err)
+	}
+	return filepath.Join(wd, "..", "..")
+}
+
+// TestScanForExternalMailboxReferences_RealImportPackagesPass ist Teil
+// der geforderten Pflichtprüfung 3: Stichprobenreview bestätigt, dass
+// die Testsuite ohne echte externe Postfächer auskommt.
+func TestScanForExternalMailboxReferences_RealImportPackagesPass(t *testing.T) {
+	root := moduleRoot(t)
+	result, err := ScanForExternalMailboxReferences(root)
+	if err != nil {
+		t.Fatalf("scan: %v", err)
+	}
+	if !result.Passed {
+		t.Fatalf("erwartete bestandenen scan, habe verstöße: %v", result.Violations)
+	}
+}
+
+// TestScanForExternalMailboxReferences_DetectsRealViolation beweist,
+// dass der Scanner eine echte externe Referenz auch tatsächlich erkennt.
+func TestScanForExternalMailboxReferences_DetectsRealViolation(t *testing.T) {
+	dir := t.TempDir()
+	subDir := filepath.Join(dir, "internal", "imapimport")
+	if err := os.MkdirAll(subDir, 0o755); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Join(dir, "internal", "attachments"), 0o755); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Join(dir, "internal", "mailrules"), 0o755); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+	badFile := filepath.Join(subDir, "bad_test.go")
+	if err := os.WriteFile(badFile, []byte("package imapimport\n\n// verbindet mit imap.gmail.com\n"), 0o600); err != nil {
+		t.Fatalf("testdatei schreiben: %v", err)
+	}
+
+	result, err := ScanForExternalMailboxReferences(dir)
+	if err != nil {
+		t.Fatalf("scan: %v", err)
+	}
+	if result.Passed {
+		t.Fatal("erwartete erkannten verstoß, scan meldet bestanden")
+	}
+	if len(result.Violations) != 1 {
+		t.Fatalf("erwartete genau 1 verstoß, habe: %v", result.Violations)
+	}
+}
+
+// TestRun_RealGateAgainstImportPackages ist Teil der geforderten
+// Pflichtprüfung 1 (Testabdeckungsbericht) und Pflichtprüfung 2
+// (CI-Lauf grün auf frischem Checkout, hier real ausgeführt statt nur
+// behauptet).
+func TestRun_RealGateAgainstImportPackages(t *testing.T) {
+	if os.Getenv("TEST_TENANT_DSN") == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	root := moduleRoot(t)
+	ctx := context.Background()
+
+	result, err := Run(ctx, root)
+	if err != nil {
+		t.Fatalf("gate-lauf: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("gate fehlgeschlagen:\n%s", result.Report())
+	}
+	if len(result.TestSuite.Coverage) != 3 {
+		t.Fatalf("erwartete abdeckungsdaten für 3 pakete (imapimport/attachments/mailrules), habe %d: %+v",
+			len(result.TestSuite.Coverage), result.TestSuite.Coverage)
+	}
+	for _, c := range result.TestSuite.Coverage {
+		if c.Percent <= 0 {
+			t.Fatalf("paket %s meldet 0%% abdeckung — testabdeckungsbericht wäre wertlos", c.Package)
+		}
+	}
+	t.Logf("Gate-Bericht:\n%s", result.Report())
+}

mail/internal/mailrules/engine.go

@@ -0,0 +1,122 @@
+package mailrules
+
+import "regexp"
+
+// EmailMetadata sind die für die Regelauswertung relevanten Merkmale
+// einer Nachricht — dieses Paket kennt keine Nachrichteninhalte, nur die
+// vom Aufrufer übergebenen Metadaten.
+type EmailMetadata struct {
+	Sender         string
+	Subject        string
+	Mailbox        string
+	AttachmentType string
+}
+
+// Result ist das Auswertungsergebnis für eine Nachricht.
+type Result struct {
+	// Category kommt von der höchstpriorisierten zutreffenden Regel, die
+	// ein nicht-leeres Category-Feld setzt — leer, wenn keine passende
+	// Regel eine Kategorie zuweist.
+	Category string
+	// Tags sind alle (deduplizierten) Tags aller zutreffenden Regeln, in
+	// Prioritätsreihenfolge.
+	Tags []string
+	// MatchedRuleIDs sind die IDs aller zutreffenden Regeln, in
+	// Auswertungsreihenfolge — Nachvollziehbarkeit für Tests/Support.
+	MatchedRuleIDs []int64
+}
+
+// compiledRule cacht die kompilierten regulären Ausdrücke einer Regel —
+// wichtig für Pflichtprüfung 3 (20+ Regeln performant auswertbar): ohne
+// Cache würde JEDE Auswertung JEDE Regel neu kompilieren.
+type compiledRule struct {
+	rule                Rule
+	sender, subject     *regexp.Regexp
+	mailbox, attachType *regexp.Regexp
+}
+
+// Engine wertet ein zwischengespeichertes, kompiliertes Regelset aus.
+// Neu erzeugen (NewEngine), sobald sich Regeln geändert haben — dieses
+// Paket hält dafür keinen automatischen Änderungs-Feed vor (kleinste
+// Lösung, kein Beobachter-Mechanismus).
+type Engine struct {
+	rules []compiledRule
+}
+
+// NewEngine kompiliert rules EINMAL (Reihenfolge = Auswertungsreihenfolge,
+// siehe Store.List). Ein leeres/nil-Pattern kompiliert zu nil und matcht
+// dadurch bewusst IMMER.
+func NewEngine(rules []Rule) (*Engine, error) {
+	compiled := make([]compiledRule, 0, len(rules))
+	for _, r := range rules {
+		cr := compiledRule{rule: r}
+		var err error
+		if cr.sender, err = compileOrNil(r.SenderPattern); err != nil {
+			return nil, err
+		}
+		if cr.subject, err = compileOrNil(r.SubjectPattern); err != nil {
+			return nil, err
+		}
+		if cr.mailbox, err = compileOrNil(r.MailboxPattern); err != nil {
+			return nil, err
+		}
+		if cr.attachType, err = compileOrNil(r.AttachmentTypePattern); err != nil {
+			return nil, err
+		}
+		compiled = append(compiled, cr)
+	}
+	return &Engine{rules: compiled}, nil
+}
+
+func compileOrNil(pattern string) (*regexp.Regexp, error) {
+	if pattern == "" {
+		return nil, nil
+	}
+	return regexp.Compile(pattern)
+}
+
+// Evaluate wendet alle Regeln in Prioritätsreihenfolge auf msg an
+// (Akzeptanzkriterium 2: dokumentierte Priorität, siehe Rule.Priority).
+func (e *Engine) Evaluate(msg EmailMetadata) Result {
+	var result Result
+	seenTags := make(map[string]bool)
+
+	for _, cr := range e.rules {
+		if !matches(cr.sender, msg.Sender) {
+			continue
+		}
+		if !matches(cr.subject, msg.Subject) {
+			continue
+		}
+		if !matches(cr.mailbox, msg.Mailbox) {
+			continue
+		}
+		if !matches(cr.attachType, msg.AttachmentType) {
+			continue
+		}
+
+		result.MatchedRuleIDs = append(result.MatchedRuleIDs, cr.rule.ID)
+
+		// "first match wins" für die einwertige Kategorie — nur die
+		// ERSTE (höchstpriorisierte) zutreffende Regel mit gesetzter
+		// Category darf sie zuweisen.
+		if result.Category == "" && cr.rule.Category != "" {
+			result.Category = cr.rule.Category
+		}
+		if cr.rule.Tag != "" && !seenTags[cr.rule.Tag] {
+			seenTags[cr.rule.Tag] = true
+			result.Tags = append(result.Tags, cr.rule.Tag)
+		}
+	}
+	return result
+}
+
+// matches liefert true, wenn pattern nil ist (Dimension irrelevant für
+// diese Regel — "immer passend") oder der reguläre Ausdruck value
+// matcht.
+func matches(pattern *regexp.Regexp, value string) bool {
+	if pattern == nil {
+		return true
+	}
+	return pattern.MatchString(value)
+}

mail/internal/mailrules/engine_test.go

@@ -0,0 +1,192 @@
+// Integrationstest (IMP-03): echte Postgres-Instanz, folgt derselben
+// Testhost-Konvention wie mail/internal/dedup/folderstate/savedsearch/
+// imapimport — TEST_TENANT_DSN.
+package mailrules
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupStore(t *testing.T) *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)
+	if err := store.EnsureSchema(ctx); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		// LIKE-Muster bewusst paket-, nicht ticketspezifisch (mandant-%
+		// statt mandant-imp03-%) — mehrere Tickets (u. a. IMP-09) fügen
+		// diesem Paket über die Zeit weitere Tests mit eigenen
+		// Mandanten-Präfixen hinzu; ein zu enges Muster ließ bereits real
+		// Testdaten ungelöscht zurück (siehe IMP-09-Prüfprotokoll).
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_rules WHERE tenant_slug LIKE 'mandant-%'`)
+	})
+	return store
+}
+
+// TestEvaluate_ConflictingRulesRespectDocumentedPriority ist die
+// geforderte Pflichtprüfung 1: widersprüchliche Regeln bestätigen
+// dokumentierte Priorisierung.
+func TestEvaluate_ConflictingRulesRespectDocumentedPriority(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+	tenant := "mandant-imp03-prioritaet"
+
+	// Zwei Regeln matchen dieselbe Nachricht, weisen aber
+	// WIDERSPRÜCHLICHE Kategorien zu — die mit der niedrigeren
+	// Priority-Zahl (höhere Priorität) muss gewinnen.
+	if _, err := store.Create(ctx, tenant, Rule{Name: "niedrige prio", SenderPattern: "rechnung@", Category: "Sonstiges", Priority: 200}); err != nil {
+		t.Fatalf("regel 1 anlegen: %v", err)
+	}
+	if _, err := store.Create(ctx, tenant, Rule{Name: "hohe prio", SenderPattern: "rechnung@", Category: "Rechnungswesen", Priority: 10}); err != nil {
+		t.Fatalf("regel 2 anlegen: %v", err)
+	}
+
+	rules, err := store.List(ctx, tenant)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	engine, err := NewEngine(rules)
+	if err != nil {
+		t.Fatalf("newengine: %v", err)
+	}
+
+	result := engine.Evaluate(EmailMetadata{Sender: "rechnung@lieferant.example"})
+	if result.Category != "Rechnungswesen" {
+		t.Fatalf("erwartete kategorie der höherprioren regel 'Rechnungswesen', habe %q", result.Category)
+	}
+	if len(result.MatchedRuleIDs) != 2 {
+		t.Fatalf("erwartete beide regeln als zutreffend vermerkt, habe: %v", result.MatchedRuleIDs)
+	}
+}
+
+// TestNewEngine_NewRuleDoesNotAffectAlreadyCapturedResult ist die
+// geforderte Pflichtprüfung 2: eine neue Regel ändert keine bereits
+// importierten Altbestände automatisch.
+func TestNewEngine_NewRuleDoesNotAffectAlreadyCapturedResult(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+	tenant := "mandant-imp03-altbestand"
+
+	msg := EmailMetadata{Sender: "info@partner.example", Subject: "Angebot"}
+
+	// Zustand VOR der neuen Regel: kein Match, keine Kategorie.
+	rulesBefore, err := store.List(ctx, tenant)
+	if err != nil {
+		t.Fatalf("list (vorher): %v", err)
+	}
+	engineBefore, err := NewEngine(rulesBefore)
+	if err != nil {
+		t.Fatalf("newengine (vorher): %v", err)
+	}
+	// "Bereits importierte Nachricht": Klassifizierung wird EINMALIG zum
+	// Importzeitpunkt berechnet und danach als fester Wert behandelt —
+	// simuliert durch eine lokale Variable, die ab hier NICHT mehr neu
+	// berechnet wird.
+	importedResult := engineBefore.Evaluate(msg)
+	if importedResult.Category != "" {
+		t.Fatalf("erwartete keine kategorie vor regelanlage, habe %q", importedResult.Category)
+	}
+
+	// Neue, zutreffende Regel wird angelegt — repräsentiert eine
+	// nachträgliche Regeländerung.
+	if _, err := store.Create(ctx, tenant, Rule{Name: "neue regel", SenderPattern: "partner\\.example", Category: "Vertrieb", Priority: 50}); err != nil {
+		t.Fatalf("neue regel anlegen: %v", err)
+	}
+
+	// Akzeptanzkriterium 3: das bereits erfasste Altbestands-Ergebnis
+	// bleibt UNVERÄNDERT — es wird nirgends automatisch neu berechnet.
+	if importedResult.Category != "" {
+		t.Fatalf("altbestand wurde rückwirkend verändert, kategorie jetzt %q", importedResult.Category)
+	}
+
+	// Eine EXPLIZITE Neuauswertung (repräsentiert einen expliziten
+	// Reindex-Auftrag) zeigt dagegen real die neue Regel — beweist, dass
+	// die Regel selbst funktioniert und der vorherige Befund nicht durch
+	// einen kaputten Test zufällig "unverändert" blieb.
+	rulesAfter, err := store.List(ctx, tenant)
+	if err != nil {
+		t.Fatalf("list (nachher): %v", err)
+	}
+	engineAfter, err := NewEngine(rulesAfter)
+	if err != nil {
+		t.Fatalf("newengine (nachher): %v", err)
+	}
+	freshResult := engineAfter.Evaluate(msg)
+	if freshResult.Category != "Vertrieb" {
+		t.Fatalf("erwartete kategorie 'Vertrieb' bei expliziter neuauswertung, habe %q", freshResult.Category)
+	}
+}
+
+// TestEvaluate_TwentyPlusRulesStayPerformant ist die geforderte
+// Pflichtprüfung 3: Regelset mit 20+ Regeln bleibt performant auswertbar.
+func TestEvaluate_TwentyPlusRulesStayPerformant(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+	tenant := "mandant-imp03-performance"
+
+	const ruleCount = 30
+	for i := 0; i < ruleCount; i++ {
+		_, err := store.Create(ctx, tenant, Rule{
+			Name:          fmt.Sprintf("regel-%d", i),
+			SenderPattern: fmt.Sprintf("^absender%d@", i),
+			Category:      fmt.Sprintf("Kategorie-%d", i),
+			Tag:           fmt.Sprintf("tag-%d", i),
+			Priority:      100 + i,
+		})
+		if err != nil {
+			t.Fatalf("regel %d anlegen: %v", i, err)
+		}
+	}
+	// Eine Regel, die tatsächlich matcht (letzte Priorität, damit
+	// vorherige Nicht-Treffer real durchlaufen werden müssen).
+	if _, err := store.Create(ctx, tenant, Rule{Name: "treffer", SenderPattern: "^ziel@", Category: "Zielkategorie", Priority: 1}); err != nil {
+		t.Fatalf("treffer-regel anlegen: %v", err)
+	}
+
+	rules, err := store.List(ctx, tenant)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(rules) < 20 {
+		t.Fatalf("erwartete mindestens 20 regeln, habe %d", len(rules))
+	}
+	engine, err := NewEngine(rules)
+	if err != nil {
+		t.Fatalf("newengine: %v", err)
+	}
+
+	const evaluations = 1000
+	start := time.Now()
+	var lastResult Result
+	for i := 0; i < evaluations; i++ {
+		lastResult = engine.Evaluate(EmailMetadata{Sender: "ziel@example.com", Subject: "Test"})
+	}
+	elapsed := time.Since(start)
+
+	if lastResult.Category != "Zielkategorie" {
+		t.Fatalf("erwartete 'Zielkategorie', habe %q", lastResult.Category)
+	}
+	perEvaluation := elapsed / evaluations
+	t.Logf("Auswertung: %d Läufe über %d Regeln in %s (%s/Lauf)", evaluations, len(rules), elapsed, perEvaluation)
+	if perEvaluation > 5*time.Millisecond {
+		t.Fatalf("auswertung zu langsam: %s/lauf über %d regeln", perEvaluation, len(rules))
+	}
+}

mail/internal/mailrules/migrations/0001_mail_rules.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS mail_rules (
+    id                       BIGSERIAL PRIMARY KEY,
+    tenant_slug              TEXT NOT NULL,
+    name                     TEXT NOT NULL,
+    sender_pattern           TEXT NOT NULL DEFAULT '',
+    subject_pattern          TEXT NOT NULL DEFAULT '',
+    mailbox_pattern          TEXT NOT NULL DEFAULT '',
+    attachment_type_pattern  TEXT NOT NULL DEFAULT '',
+    category                 TEXT NOT NULL DEFAULT '',
+    tag                      TEXT NOT NULL DEFAULT '',
+    priority                 INT NOT NULL DEFAULT 100,
+    created_at               TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at               TIMESTAMPTZ NOT NULL DEFAULT now()
+)

mail/internal/mailrules/store.go

@@ -0,0 +1,130 @@
+// Package mailrules implementiert IMP-03: ein Regelwerk für automatische
+// Zuordnung, Verschlagwortung und Klassifizierung importierter E-Mails
+// nach Absender, Betreff, Postfach und Anhangstyp. Kein Vorbild in
+// archivmail für diesen Zuschnitt — Neubau.
+//
+// Dieses Paket ist eine REINE Regelverwaltung + Auswertungsfunktion —
+// es persistiert selbst KEINE Klassifizierungsergebnisse und bietet
+// bewusst KEINE Funktion, um bestehende, bereits importierte Nachrichten
+// automatisch neu zu klassifizieren (Akzeptanzkriterium 3: Regel-
+// änderungen wirken nur auf künftige Importe). Ein Reindex bestehender
+// Nachrichten ist Sache eines expliziten, separaten Auftrags (z. B.
+// SRC-09-artig) — dieses Paket kennt diesen Mechanismus nicht.
+package mailrules
+
+import (
+	"context"
+	_ "embed"
+	"fmt"
+	"regexp"
+	"sort"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+//go:embed migrations/0001_mail_rules.sql
+var schemaMigration string
+
+// Rule ist eine Zuordnungs-/Klassifizierungsregel. *Pattern-Felder sind
+// leer, wenn die Dimension für diese Regel keine Rolle spielt (immer
+// "passend"), sonst reguläre Ausdrücke (Akzeptanzkriterium 1: Absender,
+// Betreff-Muster, Postfach — zusätzlich Anhangstyp aus dem Auftragstext).
+type Rule struct {
+	ID                    int64
+	Name                  string
+	SenderPattern         string
+	SubjectPattern        string
+	MailboxPattern        string
+	AttachmentTypePattern string
+	Category              string
+	Tag                   string
+	// Priority: NIEDRIGERE Zahl = HÖHERE Priorität (Akzeptanzkriterium 2).
+	// Dokumentierte Anwendungsreihenfolge: Regeln werden aufsteigend nach
+	// Priority ausgewertet; bei widersprüchlichen Category-Zuweisungen
+	// gewinnt die zuerst ausgewertete (höchstpriorisierte) Regel — "first
+	// match wins" für das einwertige Category-Feld. Tags sind dagegen
+	// mehrwertig: JEDE zutreffende Regel trägt ihren Tag bei.
+	Priority int
+}
+
+// EmailMetadata/Result sind in engine.go definiert.
+
+// Store verwaltet Regeln je Mandant in Postgres.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
+func (s *Store) EnsureSchema(ctx context.Context) error {
+	if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
+		return fmt.Errorf("mailrules: schema anlegen: %w", err)
+	}
+	return nil
+}
+
+// Create legt eine neue Regel an.
+func (s *Store) Create(ctx context.Context, tenantSlug string, rule Rule) (int64, error) {
+	if _, err := regexp.Compile(rule.SenderPattern); rule.SenderPattern != "" && err != nil {
+		return 0, fmt.Errorf("mailrules: sender_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.SubjectPattern); rule.SubjectPattern != "" && err != nil {
+		return 0, fmt.Errorf("mailrules: subject_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.MailboxPattern); rule.MailboxPattern != "" && err != nil {
+		return 0, fmt.Errorf("mailrules: mailbox_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.AttachmentTypePattern); rule.AttachmentTypePattern != "" && err != nil {
+		return 0, fmt.Errorf("mailrules: attachment_type_pattern ungültig: %w", err)
+	}
+
+	var id int64
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO mail_rules (tenant_slug, name, sender_pattern, subject_pattern, mailbox_pattern, attachment_type_pattern, category, tag, priority)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+		RETURNING id
+	`, tenantSlug, rule.Name, rule.SenderPattern, rule.SubjectPattern, rule.MailboxPattern, rule.AttachmentTypePattern, rule.Category, rule.Tag, rule.Priority).Scan(&id)
+	if err != nil {
+		return 0, fmt.Errorf("mailrules: regel anlegen: %w", err)
+	}
+	return id, nil
+}
+
+// List liefert alle Regeln eines Mandanten, aufsteigend nach Priority
+// sortiert (höchste Priorität zuerst — Akzeptanzkriterium 2).
+func (s *Store) List(ctx context.Context, tenantSlug string) ([]Rule, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, name, sender_pattern, subject_pattern, mailbox_pattern, attachment_type_pattern, category, tag, priority
+		FROM mail_rules WHERE tenant_slug = $1
+		ORDER BY priority ASC, id ASC
+	`, tenantSlug)
+	if err != nil {
+		return nil, fmt.Errorf("mailrules: regeln lesen: %w", err)
+	}
+	defer rows.Close()
+
+	var rules []Rule
+	for rows.Next() {
+		var r Rule
+		if err := rows.Scan(&r.ID, &r.Name, &r.SenderPattern, &r.SubjectPattern, &r.MailboxPattern, &r.AttachmentTypePattern, &r.Category, &r.Tag, &r.Priority); err != nil {
+			return nil, fmt.Errorf("mailrules: regelzeile lesen: %w", err)
+		}
+		rules = append(rules, r)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("mailrules: regeln iterieren: %w", err)
+	}
+	sort.SliceStable(rules, func(i, j int) bool { return rules[i].Priority < rules[j].Priority })
+	return rules, nil
+}
+
+// Delete entfernt eine Regel.
+func (s *Store) Delete(ctx context.Context, tenantSlug string, id int64) error {
+	if _, err := s.pool.Exec(ctx, `DELETE FROM mail_rules WHERE tenant_slug = $1 AND id = $2`, tenantSlug, id); err != nil {
+		return fmt.Errorf("mailrules: regel löschen: %w", err)
+	}
+	return nil
+}

mail/internal/mailrules/tenant_scoping_test.go

@@ -0,0 +1,62 @@
+// IMP-09: Tenant-Scoping-Nachweis für die Regelanwendung
+// (Akzeptanzkriterium 2). Bekannten Fehler vermeiden (known-issues-
+// archivmail.md #4): dieser Test schließt eine reale Lücke, die vor
+// IMP-09 bestand — kein bestehender Test bewies bislang explizit, dass
+// die Regeln eines Mandanten nicht auf die Nachrichten eines anderen
+// angewendet werden.
+package mailrules
+
+import (
+	"context"
+	"testing"
+)
+
+func TestStore_TenantScopingIsolatesRuleApplication(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+
+	tenantA := "mandant-imp09-regeln-a"
+	tenantB := "mandant-imp09-regeln-b"
+
+	if _, err := store.Create(ctx, tenantA, Rule{Name: "a-regel", SenderPattern: "^ziel@", Category: "Kategorie-A", Priority: 10}); err != nil {
+		t.Fatalf("regel mandant a anlegen: %v", err)
+	}
+	// Mandant B legt bewusst KEINE eigene Regel an — sein Regelset muss
+	// leer bleiben, unabhängig davon, was Mandant A definiert hat.
+
+	rulesA, err := store.List(ctx, tenantA)
+	if err != nil {
+		t.Fatalf("list mandant a: %v", err)
+	}
+	if len(rulesA) != 1 {
+		t.Fatalf("mandant a: erwartete 1 eigene regel, habe %d", len(rulesA))
+	}
+
+	rulesB, err := store.List(ctx, tenantB)
+	if err != nil {
+		t.Fatalf("list mandant b: %v", err)
+	}
+	if len(rulesB) != 0 {
+		t.Fatalf("mandant b sieht regeln von mandant a — mandantentrennung verletzt, habe: %+v", rulesB)
+	}
+
+	engineA, err := NewEngine(rulesA)
+	if err != nil {
+		t.Fatalf("newengine mandant a: %v", err)
+	}
+	engineB, err := NewEngine(rulesB)
+	if err != nil {
+		t.Fatalf("newengine mandant b: %v", err)
+	}
+
+	msg := EmailMetadata{Sender: "ziel@lieferant.example"}
+	resultA := engineA.Evaluate(msg)
+	resultB := engineB.Evaluate(msg)
+
+	if resultA.Category != "Kategorie-A" {
+		t.Fatalf("mandant a: erwartete 'Kategorie-A', habe %q", resultA.Category)
+	}
+	if resultB.Category != "" {
+		t.Fatalf("mandant b wendet fälschlich regel von mandant a an, kategorie %q", resultB.Category)
+	}
+}

mail/internal/mimeparse/tolerant.go

@@ -0,0 +1,132 @@
+// IMP-02: fehlertolerantes Parsing für den Import-Pfad. Additive
+// Erweiterung — Parse/parseMultipart (ING-04) bleiben UNVERÄNDERT, deren
+// Verhalten und Tests sind nicht Gegenstand dieser Kachel. ParseTolerant
+// nutzt dieselben internen Helfer (readSinglePart, decodeTransferEncoding
+// usw.), bricht aber bei EINEM fehlerhaften Teil NICHT die gesamte
+// Nachricht ab (Akzeptanzkriterium 3), sondern verzeichnet den Fehler und
+// verarbeitet die übrigen Teile weiter. Zusätzlich wird ein
+// Gesamtgrößenlimit über alle Teile hinweg durchgesetzt
+// (Akzeptanzkriterium 2 — maxAttachmentSize aus Parse ist nur das Limit
+// je EINZELNEM Anhang).
+package mimeparse
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/mail"
+	"strings"
+)
+
+// PartError beschreibt EINEN Teil, der nicht verarbeitet werden konnte —
+// die übrigen Teile der Nachricht sind davon unberührt.
+type PartError struct {
+	Filename string
+	Err      error
+}
+
+func (e PartError) Error() string {
+	return fmt.Sprintf("mimeparse: teil %q: %v", e.Filename, e.Err)
+}
+
+// ParseTolerant ist wie Parse, bricht aber bei einem fehlerhaften
+// EINZELNEN Teil (z. B. überdimensionierter Anhang) nicht die gesamte
+// Nachricht ab — der fehlerhafte Teil landet in den zurückgegebenen
+// PartErrors, Text und übrige Anhänge werden unangetastet weiter
+// verarbeitet (Akzeptanzkriterium 3). Nur eine strukturell unlesbare
+// Nachricht (kaputte Kopfzeilen, fehlende Boundary) liefert weiterhin
+// einen echten Fehler — davon kann sich kein Teil-für-Teil-Fallback
+// erholen.
+func ParseTolerant(r io.Reader, maxAttachmentSize, maxMessageSize int64) (Message, []PartError, error) {
+	msg, err := mail.ReadMessage(r)
+	if err != nil {
+		return Message{}, nil, fmt.Errorf("mimeparse: nachricht lesen: %w", err)
+	}
+
+	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
+	if err != nil {
+		body, readErr := readLimited(msg.Body, maxAttachmentSize)
+		if readErr != nil {
+			return Message{}, []PartError{{Filename: "", Err: readErr}}, nil
+		}
+		return Message{Parts: []Part{{ContentType: "text/plain", Content: body, Size: int64(len(body))}}}, nil, nil
+	}
+
+	var result Message
+	var partErrors []PartError
+	budget := maxMessageSize
+
+	if strings.HasPrefix(mediaType, "multipart/") {
+		if err := parseMultipartTolerant(msg.Body, params["boundary"], maxAttachmentSize, &budget, &result, &partErrors); err != nil {
+			return Message{}, partErrors, err
+		}
+		return result, partErrors, nil
+	}
+
+	part, err := readSinglePart(msg.Header.Get("Content-Transfer-Encoding"), mediaType, "", msg.Body, maxAttachmentSize)
+	if err != nil {
+		return Message{}, []PartError{{Filename: "", Err: err}}, nil
+	}
+	result.Parts = append(result.Parts, part)
+	return result, nil, nil
+}
+
+func parseMultipartTolerant(r io.Reader, boundary string, maxAttachmentSize int64, budget *int64, result *Message, partErrors *[]PartError) 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 {
+			// Eine strukturell kaputte Multipart-Hülle (nicht ein
+			// einzelner Teil) kann von hier aus nicht sinnvoll fortgesetzt
+			// werden — kontrollierter Abbruch, wie in Parse.
+			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"
+		}
+		filename := decodeHeaderValue(p.FileName())
+
+		if strings.HasPrefix(mediaType, "multipart/") {
+			if err := parseMultipartTolerant(p, subParams["boundary"], maxAttachmentSize, budget, result, partErrors); err != nil {
+				*partErrors = append(*partErrors, PartError{Filename: filename, Err: err})
+			}
+			continue
+		}
+
+		if *budget <= 0 {
+			*partErrors = append(*partErrors, PartError{Filename: filename, Err: ErrMessageTooLarge})
+			continue
+		}
+
+		part, err := readSinglePart(p.Header.Get("Content-Transfer-Encoding"), mediaType, filename, p, maxAttachmentSize)
+		if err != nil {
+			// Akzeptanzkriterium 3: NUR dieser eine Teil fällt weg,
+			// Verarbeitung läuft weiter.
+			*partErrors = append(*partErrors, PartError{Filename: filename, Err: err})
+			continue
+		}
+		if part.Size > *budget {
+			*partErrors = append(*partErrors, PartError{Filename: filename, Err: ErrMessageTooLarge})
+			continue
+		}
+		*budget -= part.Size
+		result.Parts = append(result.Parts, part)
+	}
+}
+
+// ErrMessageTooLarge wird geliefert (als PartError), wenn die Summe aller
+// Anhangsgrößen einer Nachricht das Gesamtlimit überschreitet
+// (Akzeptanzkriterium 2 — je-Nachricht-Limit, zusätzlich zum
+// je-Anhang-Limit ErrAttachmentTooLarge aus Parse/readLimited).
+var ErrMessageTooLarge = errors.New("mimeparse: nachricht überschreitet die maximal erlaubte gesamtgröße")

mail/internal/syncalert/dispatcher.go

@@ -0,0 +1,80 @@
+// Package syncalert implementiert IMP-08: Benachrichtigung bei
+// wiederholtem Postfach-Sync-Ausfall, mit Eskalationsschwelle statt
+// Einzel-Alarm pro Fehlversuch. Versand ausschließlich über den
+// zentralen Core-Benachrichtigungs-Dispatcher (CFG-02, bereits Fertig)
+// — dieses Paket baut KEINEN eigenen E-Mail-Versand, sondern ruft
+// ausschließlich NotificationDispatcher.Enqueue auf (Akzeptanzkriterium
+// 1), exakt einmal je Eskalation.
+package syncalert
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// NotificationDispatcher ist die schmale Schnittstelle zu Core CFG-02
+// (internal/notify.Dispatcher.Enqueue) — Mail ruft ausschließlich diese
+// EINE Methode auf, kein eigener Versandcode.
+type NotificationDispatcher interface {
+	Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (id string, err error)
+}
+
+// HTTPNotificationDispatcher spricht CFG-02 über HTTP an — dieselbe
+// Service-Credential-Konvention wie mail/internal/crypto.HTTPKEKProvider
+// (API-02, X-Nexarch-Client-Id/Secret).
+type HTTPNotificationDispatcher struct {
+	endpointURL  string
+	clientID     string
+	clientSecret string
+	httpClient   *http.Client
+}
+
+func NewHTTPNotificationDispatcher(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPNotificationDispatcher {
+	if httpClient == nil {
+		httpClient = http.DefaultClient
+	}
+	return &HTTPNotificationDispatcher{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
+}
+
+type enqueueRequest struct {
+	Channel   string         `json:"channel"`
+	Recipient string         `json:"recipient"`
+	Payload   map[string]any `json:"payload"`
+}
+
+type enqueueResponse struct {
+	ID string `json:"id"`
+}
+
+func (d *HTTPNotificationDispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	body, err := json.Marshal(enqueueRequest{Channel: channel, Recipient: recipient, Payload: payload})
+	if err != nil {
+		return "", fmt.Errorf("syncalert: anfrage serialisieren: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, d.endpointURL, bytes.NewReader(body))
+	if err != nil {
+		return "", fmt.Errorf("syncalert: anfrage aufbauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Nexarch-Client-Id", d.clientID)
+	req.Header.Set("X-Nexarch-Client-Secret", d.clientSecret)
+
+	resp, err := d.httpClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("syncalert: anfrage senden: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("syncalert: cfg-02 lehnte anfrage ab: status %d", resp.StatusCode)
+	}
+
+	var out enqueueResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		return "", fmt.Errorf("syncalert: antwort dekodieren: %w", err)
+	}
+	return out.ID, nil
+}

mail/internal/syncalert/dispatcher_http_test.go

@@ -0,0 +1,67 @@
+package syncalert
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// TestHTTPNotificationDispatcher_SendsCorrectRequestFormat beweist real
+// über echtes HTTP, dass HTTPNotificationDispatcher Channel/Recipient/
+// Payload sowie die Service-Credential-Header korrekt sendet — kein
+// eigener E-Mail-Versand, nur ein einziger CFG-02-Aufruf
+// (Akzeptanzkriterium 1).
+func TestHTTPNotificationDispatcher_SendsCorrectRequestFormat(t *testing.T) {
+	var capturedBody map[string]any
+	var capturedClientID, capturedClientSecret string
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		capturedClientID = r.Header.Get("X-Nexarch-Client-Id")
+		capturedClientSecret = r.Header.Get("X-Nexarch-Client-Secret")
+		if err := json.NewDecoder(r.Body).Decode(&capturedBody); err != nil {
+			t.Fatal(err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"id":"real-notification-id-123"}`))
+	}))
+	defer srv.Close()
+
+	dispatcher := NewHTTPNotificationDispatcher(srv.URL, "mail", "mail-service-secret", nil)
+	id, err := dispatcher.Enqueue(context.Background(), NotificationChannel, AdminRecipient, map[string]any{
+		"mailbox": "INBOX",
+		"reason":  "verbindung abgelehnt",
+	})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id != "real-notification-id-123" {
+		t.Fatalf("erwartete reale id vom server, habe %q", id)
+	}
+	if capturedClientID != "mail" || capturedClientSecret != "mail-service-secret" {
+		t.Fatalf("service-credential-header fehlen/falsch: id=%q secret=%q", capturedClientID, capturedClientSecret)
+	}
+	if capturedBody["channel"] != NotificationChannel || capturedBody["recipient"] != AdminRecipient {
+		t.Fatalf("channel/recipient falsch übertragen: %+v", capturedBody)
+	}
+	payload, ok := capturedBody["payload"].(map[string]any)
+	if !ok || payload["mailbox"] != "INBOX" {
+		t.Fatalf("payload nicht korrekt übertragen: %+v", capturedBody)
+	}
+}
+
+// TestHTTPNotificationDispatcher_RejectedByServerReturnsError bestätigt,
+// dass eine Ablehnung durch CFG-02 real als Fehler durchgereicht wird,
+// statt stillschweigend zu verschwinden.
+func TestHTTPNotificationDispatcher_RejectedByServerReturnsError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusForbidden)
+	}))
+	defer srv.Close()
+
+	dispatcher := NewHTTPNotificationDispatcher(srv.URL, "mail", "falsch", nil)
+	if _, err := dispatcher.Enqueue(context.Background(), "c", "r", nil); err == nil {
+		t.Fatal("erwartete fehler bei abgelehnter anfrage, habe nil")
+	}
+}

mail/internal/syncalert/migrations/0001_mail_sync_alert_state.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS mail_sync_alert_state (
+    tenant_slug          TEXT NOT NULL,
+    mailbox_name         TEXT NOT NULL,
+    consecutive_failures INT NOT NULL DEFAULT 0,
+    alerted              BOOLEAN NOT NULL DEFAULT false,
+    last_success_at      TIMESTAMPTZ,
+    last_failure_reason  TEXT,
+    last_failure_at      TIMESTAMPTZ,
+    updated_at           TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_slug, mailbox_name)
+)

mail/internal/syncalert/monitor.go

@@ -0,0 +1,156 @@
+package syncalert
+
+import (
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+//go:embed migrations/0001_mail_sync_alert_state.sql
+var schemaMigration string
+
+const (
+	// NotificationChannel/AdminRecipient sind bewusst statisch (kleinste
+	// Lösung) — eine konfigurierbare Empfängerverwaltung ist Sache einer
+	// späteren Kachel, nicht Bestandteil von IMP-08.
+	NotificationChannel = "mail-sync-failure"
+	AdminRecipient      = "mail-admins"
+)
+
+// Monitor verfolgt Sync-Fehlschläge je Mandant/Postfach und löst bei
+// Überschreiten der Schwelle GENAU EINE Benachrichtigung aus
+// (Akzeptanzkriterium 1).
+type Monitor struct {
+	pool       *pgxpool.Pool
+	dispatcher NotificationDispatcher
+	threshold  int
+	now        func() time.Time
+}
+
+// DefaultThreshold ist die Vorgabe-Eskalationsschwelle (konsekutive
+// Fehlschläge), überschreibbar über WithThreshold.
+const DefaultThreshold = 3
+
+func NewMonitor(pool *pgxpool.Pool, dispatcher NotificationDispatcher) *Monitor {
+	return &Monitor{pool: pool, dispatcher: dispatcher, threshold: DefaultThreshold, now: time.Now}
+}
+
+// WithThreshold setzt eine abweichende Eskalationsschwelle.
+func (m *Monitor) WithThreshold(threshold int) *Monitor {
+	m.threshold = threshold
+	return m
+}
+
+// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
+func (m *Monitor) EnsureSchema(ctx context.Context) error {
+	if _, err := m.pool.Exec(ctx, schemaMigration); err != nil {
+		return fmt.Errorf("syncalert: schema anlegen: %w", err)
+	}
+	return nil
+}
+
+type alertState struct {
+	consecutiveFailures int
+	alerted             bool
+	lastSuccessAt       *time.Time
+}
+
+func (m *Monitor) getOrCreate(ctx context.Context, tenantSlug, mailboxName string) (alertState, error) {
+	if _, err := m.pool.Exec(ctx, `
+		INSERT INTO mail_sync_alert_state (tenant_slug, mailbox_name)
+		VALUES ($1, $2)
+		ON CONFLICT (tenant_slug, mailbox_name) DO NOTHING
+	`, tenantSlug, mailboxName); err != nil {
+		return alertState{}, fmt.Errorf("syncalert: zustand anlegen: %w", err)
+	}
+
+	var st alertState
+	err := m.pool.QueryRow(ctx, `
+		SELECT consecutive_failures, alerted, last_success_at
+		FROM mail_sync_alert_state WHERE tenant_slug = $1 AND mailbox_name = $2
+	`, tenantSlug, mailboxName).Scan(&st.consecutiveFailures, &st.alerted, &st.lastSuccessAt)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return alertState{}, fmt.Errorf("syncalert: gerade angelegten zustand nicht gefunden")
+		}
+		return alertState{}, fmt.Errorf("syncalert: zustand lesen: %w", err)
+	}
+	return st, nil
+}
+
+// RecordFailure verzeichnet einen fehlgeschlagenen Sync-Versuch. Erst
+// wenn consecutive_failures die konfigurierte Schwelle ERSTMALIG
+// erreicht (noch nicht "alerted"), wird GENAU EINE Benachrichtigung an
+// CFG-02 ausgelöst (Akzeptanzkriterium 1) — weitere Fehlschläge danach
+// lösen KEINE zusätzliche Benachrichtigung aus, solange der Alarmzustand
+// nicht durch einen erfolgreichen Sync zurückgesetzt wurde (kein
+// Einzel-Alarm pro Fehlversuch, keine Spam-Flut).
+func (m *Monitor) RecordFailure(ctx context.Context, tenantSlug, mailboxName, reason string) error {
+	now := m.now()
+	st, err := m.getOrCreate(ctx, tenantSlug, mailboxName)
+	if err != nil {
+		return err
+	}
+
+	newFailures := st.consecutiveFailures + 1
+	if _, err := m.pool.Exec(ctx, `
+		UPDATE mail_sync_alert_state
+		SET consecutive_failures = $3, last_failure_reason = $4, last_failure_at = $5, updated_at = now()
+		WHERE tenant_slug = $1 AND mailbox_name = $2
+	`, tenantSlug, mailboxName, newFailures, reason, now); err != nil {
+		return fmt.Errorf("syncalert: fehlschlag erfassen: %w", err)
+	}
+
+	if newFailures < m.threshold || st.alerted {
+		return nil
+	}
+
+	// Akzeptanzkriterium 2: Benachrichtigung enthält Postfach,
+	// Fehlerursache und Zeitpunkt des letzten erfolgreichen Abrufs.
+	payload := map[string]any{
+		"tenant_slug":          tenantSlug,
+		"mailbox":              mailboxName,
+		"reason":               reason,
+		"consecutive_failures": newFailures,
+		"last_successful_sync": formatOptionalTime(st.lastSuccessAt),
+	}
+	if _, err := m.dispatcher.Enqueue(ctx, NotificationChannel, AdminRecipient, payload); err != nil {
+		return fmt.Errorf("syncalert: benachrichtigung auslösen: %w", err)
+	}
+
+	if _, err := m.pool.Exec(ctx, `
+		UPDATE mail_sync_alert_state SET alerted = true, updated_at = now()
+		WHERE tenant_slug = $1 AND mailbox_name = $2
+	`, tenantSlug, mailboxName); err != nil {
+		return fmt.Errorf("syncalert: alarmzustand markieren: %w", err)
+	}
+	return nil
+}
+
+// RecordSuccess verzeichnet einen erfolgreichen Sync und setzt den
+// Alarmzustand zurück (Akzeptanzkriterium 3) — der nächste Fehlschlag
+// nach einem Erfolg beginnt wieder bei 0 konsekutiven Fehlschlägen.
+func (m *Monitor) RecordSuccess(ctx context.Context, tenantSlug, mailboxName string) error {
+	now := m.now()
+	if _, err := m.pool.Exec(ctx, `
+		INSERT INTO mail_sync_alert_state (tenant_slug, mailbox_name, consecutive_failures, alerted, last_success_at)
+		VALUES ($1, $2, 0, false, $3)
+		ON CONFLICT (tenant_slug, mailbox_name) DO UPDATE
+			SET consecutive_failures = 0, alerted = false, last_success_at = $3, updated_at = now()
+	`, tenantSlug, mailboxName, now); err != nil {
+		return fmt.Errorf("syncalert: erfolg erfassen: %w", err)
+	}
+	return nil
+}
+
+func formatOptionalTime(t *time.Time) string {
+	if t == nil {
+		return ""
+	}
+	return t.UTC().Format(time.RFC3339)
+}

mail/internal/syncalert/monitor_test.go

@@ -0,0 +1,220 @@
+// Integrationstest (IMP-08): echte Postgres-Instanz, folgt derselben
+// Testhost-Konvention wie mail/internal/dedup/folderstate/imapimport —
+// TEST_TENANT_DSN.
+package syncalert
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// fakeDispatcher zeichnet jeden Enqueue-Aufruf auf — echte HTTP-
+// Anbindung ist Sache von dispatcher_http_test.go, hier wird die
+// Eskalationslogik isoliert geprüft (gleiche Konvention wie
+// fakeAuthenticator/fakeKEKProvider in anderen Mail-Paketen).
+type fakeDispatcher struct {
+	mu    sync.Mutex
+	calls []map[string]any
+}
+
+func (f *fakeDispatcher) Enqueue(_ context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	call := map[string]any{"channel": channel, "recipient": recipient}
+	for k, v := range payload {
+		call[k] = v
+	}
+	f.calls = append(f.calls, call)
+	return fmt.Sprintf("notif-%d", len(f.calls)), nil
+}
+
+func (f *fakeDispatcher) count() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.calls)
+}
+
+func setupMonitor(t *testing.T, dispatcher NotificationDispatcher) *Monitor {
+	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() })
+
+	monitor := NewMonitor(pool, dispatcher).WithThreshold(3)
+	if err := monitor.EnsureSchema(ctx); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_sync_alert_state WHERE tenant_slug LIKE 'mandant-imp08-%'`)
+	})
+	return monitor
+}
+
+// TestRecordFailure_NConsecutiveFailuresTriggerExactlyOneNotification
+// ist die geforderte Pflichtprüfung 1: N aufeinanderfolgende
+// Fehlschläge lösen genau eine Benachrichtigung aus, keine Spam-Flut.
+func TestRecordFailure_NConsecutiveFailuresTriggerExactlyOneNotification(t *testing.T) {
+	dispatcher := &fakeDispatcher{}
+	monitor := setupMonitor(t, dispatcher)
+	ctx := context.Background()
+	tenant := "mandant-imp08-schwelle"
+
+	// Schwelle ist 3 — die ersten 2 Fehlschläge dürfen NICHTS auslösen.
+	for i := 0; i < 2; i++ {
+		if err := monitor.RecordFailure(ctx, tenant, "INBOX", "verbindung abgelehnt"); err != nil {
+			t.Fatalf("recordfailure %d: %v", i, err)
+		}
+	}
+	if dispatcher.count() != 0 {
+		t.Fatalf("erwartete 0 benachrichtigungen vor erreichen der schwelle, habe %d", dispatcher.count())
+	}
+
+	// Dritter Fehlschlag erreicht die Schwelle — GENAU EINE Benachrichtigung.
+	if err := monitor.RecordFailure(ctx, tenant, "INBOX", "verbindung abgelehnt"); err != nil {
+		t.Fatalf("recordfailure 3: %v", err)
+	}
+	if dispatcher.count() != 1 {
+		t.Fatalf("erwartete genau 1 benachrichtigung bei erreichen der schwelle, habe %d", dispatcher.count())
+	}
+
+	// Weitere Fehlschläge DANACH dürfen KEINE zusätzliche Benachrichtigung
+	// auslösen (kein Einzel-Alarm pro Fehlversuch, keine Spam-Flut).
+	for i := 0; i < 5; i++ {
+		if err := monitor.RecordFailure(ctx, tenant, "INBOX", "verbindung abgelehnt"); err != nil {
+			t.Fatalf("weiterer fehlschlag %d: %v", i, err)
+		}
+	}
+	if dispatcher.count() != 1 {
+		t.Fatalf("erwartete weiterhin genau 1 benachrichtigung nach 5 weiteren fehlschlägen, habe %d", dispatcher.count())
+	}
+}
+
+// TestRecordSuccess_EndsAlertStateVerifiably ist die geforderte
+// Pflichtprüfung 2: erfolgreicher Lauf nach Ausfall beendet den
+// Alarmzustand nachvollziehbar.
+func TestRecordSuccess_EndsAlertStateVerifiably(t *testing.T) {
+	dispatcher := &fakeDispatcher{}
+	monitor := setupMonitor(t, dispatcher)
+	ctx := context.Background()
+	tenant := "mandant-imp08-reset"
+
+	for i := 0; i < 3; i++ {
+		if err := monitor.RecordFailure(ctx, tenant, "INBOX", "timeout"); err != nil {
+			t.Fatalf("recordfailure %d: %v", i, err)
+		}
+	}
+	if dispatcher.count() != 1 {
+		t.Fatalf("erwartete 1 benachrichtigung nach 3 fehlschlägen, habe %d", dispatcher.count())
+	}
+
+	if err := monitor.RecordSuccess(ctx, tenant, "INBOX"); err != nil {
+		t.Fatalf("recordsuccess: %v", err)
+	}
+
+	// Nachvollziehbar zurückgesetzt: der NÄCHSTE Fehlschlags-Zyklus muss
+	// real wieder bei 0 beginnen und erneut die volle Schwelle
+	// durchlaufen, bevor eine ZWEITE Benachrichtigung ausgelöst wird.
+	for i := 0; i < 2; i++ {
+		if err := monitor.RecordFailure(ctx, tenant, "INBOX", "timeout"); err != nil {
+			t.Fatalf("recordfailure nach reset %d: %v", i, err)
+		}
+	}
+	if dispatcher.count() != 1 {
+		t.Fatalf("erwartete weiterhin nur 1 benachrichtigung (schwelle nach reset noch nicht erreicht), habe %d", dispatcher.count())
+	}
+	if err := monitor.RecordFailure(ctx, tenant, "INBOX", "timeout"); err != nil {
+		t.Fatalf("dritter fehlschlag nach reset: %v", err)
+	}
+	if dispatcher.count() != 2 {
+		t.Fatalf("erwartete 2. benachrichtigung nach erneutem erreichen der schwelle, habe %d", dispatcher.count())
+	}
+}
+
+// TestRecordFailure_MultipleAffectedMailboxesStayIsolated ist die
+// geforderte Pflichtprüfung 3: Test mit mehreren betroffenen
+// Postfächern gleichzeitig bleibt übersichtlich (korrekt isoliert).
+func TestRecordFailure_MultipleAffectedMailboxesStayIsolated(t *testing.T) {
+	dispatcher := &fakeDispatcher{}
+	monitor := setupMonitor(t, dispatcher)
+	ctx := context.Background()
+	tenant := "mandant-imp08-mehrere"
+
+	mailboxes := []string{"INBOX", "Archiv", "Vertrieb"}
+	var wg sync.WaitGroup
+	for _, mailbox := range mailboxes {
+		wg.Add(1)
+		go func(mb string) {
+			defer wg.Done()
+			for i := 0; i < 3; i++ {
+				_ = monitor.RecordFailure(ctx, tenant, mb, "gleichzeitiger ausfall")
+			}
+		}(mailbox)
+	}
+	wg.Wait()
+
+	if dispatcher.count() != len(mailboxes) {
+		t.Fatalf("erwartete genau 1 benachrichtigung je betroffenem postfach (%d), habe %d", len(mailboxes), dispatcher.count())
+	}
+
+	seenMailboxes := map[string]bool{}
+	dispatcher.mu.Lock()
+	for _, call := range dispatcher.calls {
+		mb, _ := call["mailbox"].(string)
+		if seenMailboxes[mb] {
+			t.Fatalf("postfach %q hat mehr als eine benachrichtigung erhalten", mb)
+		}
+		seenMailboxes[mb] = true
+	}
+	dispatcher.mu.Unlock()
+	for _, mb := range mailboxes {
+		if !seenMailboxes[mb] {
+			t.Fatalf("postfach %q fehlt unter den benachrichtigten, habe: %v", mb, seenMailboxes)
+		}
+	}
+}
+
+// TestRecordFailure_NotificationContainsRequiredFields deckt
+// Akzeptanzkriterium 2 ab: Benachrichtigung enthält Postfach,
+// Fehlerursache und Zeitpunkt des letzten erfolgreichen Abrufs.
+func TestRecordFailure_NotificationContainsRequiredFields(t *testing.T) {
+	dispatcher := &fakeDispatcher{}
+	monitor := setupMonitor(t, dispatcher)
+	ctx := context.Background()
+	tenant := "mandant-imp08-inhalt"
+
+	if err := monitor.RecordSuccess(ctx, tenant, "INBOX"); err != nil {
+		t.Fatalf("initialer erfolg: %v", err)
+	}
+	for i := 0; i < 3; i++ {
+		if err := monitor.RecordFailure(ctx, tenant, "INBOX", "authentifizierung fehlgeschlagen"); err != nil {
+			t.Fatalf("recordfailure %d: %v", i, err)
+		}
+	}
+	if dispatcher.count() != 1 {
+		t.Fatalf("erwartete 1 benachrichtigung, habe %d", dispatcher.count())
+	}
+
+	call := dispatcher.calls[0]
+	if call["mailbox"] != "INBOX" {
+		t.Fatalf("erwartete postfach 'INBOX' in der benachrichtigung, habe: %v", call["mailbox"])
+	}
+	if call["reason"] != "authentifizierung fehlgeschlagen" {
+		t.Fatalf("erwartete fehlerursache in der benachrichtigung, habe: %v", call["reason"])
+	}
+	lastSuccess, _ := call["last_successful_sync"].(string)
+	if lastSuccess == "" {
+		t.Fatal("erwartete zeitpunkt des letzten erfolgreichen abrufs in der benachrichtigung")
+	}
+}