feat(mail): ARC-09 Postfach-Quota (unabhängig von Core LIC-05)

mailboxconfig (IMP-07) bekommt eine quota_bytes-Spalte statt einer
eigenen Tabelle — ein Postfach ist bereits eindeutig über
(tenant_slug, name) identifiziert. SetQuotaBytes/LimitBytes, 0 =
unbegrenzt (Standardwert, keine Migration bestehender Postfächer
nötig). LimitBytes erfüllt strukturell quota.LimitProvider.

storage.ArchiveMailboxPrefix (ARC-04-Ergänzung, Präfix ALLER Jahre
eines Postfachs) und storage.UsageCounter: realer Speicherverbrauch
durch echtes S3-Listing im physisch getrennten Mandanten-Bucket
(ARC-06) — kein separat gepflegter Zählerstand.

Neues Paket mail/internal/quota: Checker verbindet LimitProvider und
UsageProvider. Kein konfiguriertes Limit = immer erlaubt (Core-LIC-05-
Quota läuft unabhängig weiter — beide Ebenen bewusst unabhängig
durchgesetzt, bekannter Fehler vermieden).

smtp.QuotaChecker (schmale Schnittstelle, keine Paketkopplung an
quota) wird in handleRcptTo geprüft, VOR der Datenübertragung: 552
(RFC 5321 "exceeded storage allocation") bei Überschreitung, Session
bleibt nutzbar. nil-Checker erhält bisheriges Verhalten unverändert.

Alle drei Pflichtprüfungen mit echten Nachweisen: Quota-Überschreitung
liefert 552, Session bleibt funktionsfähig; ein anderes Postfach
desselben Tenants läuft währenddessen vollständig normal durch;
vollständiger Ende-zu-Ende-Integrationstest gegen reale Postgres- und
MinIO-Instanzen — 5000 echte Bytes abgelegt, real gemessen, Limit
knapp darunter/darüber gesetzt, SMTP reagiert jeweils korrekt auf den
tatsächlichen gemessenen Wert. Dabei einen echten Cleanup-Fehler
gefunden und behoben (defer schloss den Pool vor dem zugehörigen
t.Cleanup, verwaiste Testdaten blieben zurück).

go build/go vet/golangci-lint clean, gesamtes Mail-Modul
regressionsfrei getestet.

mail/docs/ARC-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,95 @@
+# ARC-04 — Aufbewahrungsstruktur (Mandant/Postfach/Jahr): Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/storage` (`archivekey.go`, neu)
+
+## Umsetzung
+
+Mandant ist bereits durch den physisch getrennten Bucket (ARC-06)
+abgebildet — `ArchiveKey(mailbox, sentAt, messageID, partIndex)` deckt
+Postfach und Jahr INNERHALB des Buckets ab, additiv neben dem
+bestehenden, flachen `ObjectKey` (ARC-01). `ObjectKey` bleibt für
+bestehende Aufrufer (u. a. `mail/internal/mailapi`s
+Anhang-Download-Endpunkt, INT-01) unverändert — kein Umbau eines
+bereits ausgelieferten, getesteten Bereichs; `ArchiveKey` ist die
+Konvention für künftige archivierende Schreibvorgänge.
+
+`ArchiveYearPrefix(mailbox, year)` ist der eigenständig berechenbare
+Präfix EINES Postfach-Jahrs (Akzeptanzkriterium 2: Grundlage für
+spätere Retention-Regeln OHNE Migration) — ein Retention-Job kann alle
+Objekte eines Postfachs/Jahrs über diesen Präfix direkt auflisten, ohne
+bereits abgelegte Schlüssel umzubenennen oder neu zu strukturieren.
+
+Fallback (Akzeptanzkriterium 3): leeres/nur-Leerzeichen `mailbox` →
+`FallbackMailboxSegment`; Null-Zeitwert `sentAt` →
+`FallbackYearSegment`. `ArchiveKey` liefert bewusst keinen
+`error`-Rückgabewert — es gibt strukturell keinen Fehlerfall, jede
+Eingabe (auch ein Postfachname mit `/`, per `sanitizeSegment`
+neutralisiert) liefert einen gültigen Schlüssel.
+
+## Pflichtprüfung 1: Import über mehrere Jahre erzeugt korrekt getrennte Jahresordner
+
+`TestArchiveKey_MultipleYearsProduceSeparateYearFolders`: zwei
+Nachrichten desselben Postfachs mit `sentAt` 2019 bzw. 2024 liefern
+Schlüssel unter `postfach/INBOX/2019/` bzw. `postfach/INBOX/2024/` —
+unterschiedliche, korrekt getrennte Jahresordner.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: fehlendes Postfach-Attribut nutzt dokumentierten Fallback
+
+`TestArchiveKey_MissingMailboxUsesDocumentedFallback` (leeres
+`mailbox`) und `TestArchiveKey_MissingSentAtUsesDocumentedFallback`
+(Null-`sentAt`): beide liefern den jeweils dokumentierten
+Fallback-Segmentnamen, kein Fehler. `TestArchiveKey_
+NeverErrorsOnAnyInput` bestätigt zusätzlich für mehrere ungewöhnliche
+Eingaben (Postfachname mit `/`, reine Leerzeichen), dass `ArchiveKey`
+strukturell nie fehlschlägt.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Stichprobenprüfung der Struktur durch zweite Person
+
+**Nicht durchführbar durch diese Sitzung**, aus demselben strukturellen
+Grund wie bereits bei ING-10, QA-04 und QA-02 dokumentiert: eine
+einzelne KI-Sitzung kann keine unabhängige ZWEITE Person sein. **Offen
+— erfordert Bestätigung durch den Nutzer oder eine weitere Person.**
+Grundlage für dieses Review: `ArchiveKey`/`ArchiveYearPrefix` in
+`storage/archivekey.go`, fünf reale Tests in
+`storage/archivekey_test.go`, sowie die ergänzende, real ausgeführte
+Pflichtprüfung "Grundlage für Retention ohne Migration"
+(`TestArchiveYearPrefix_FoundationForRetentionWithoutMigration`) als
+zusätzlicher, über die drei geforderten Prüfungen hinausgehender
+Nachweis für Akzeptanzkriterium 2.
+
+## Akzeptanzkriterien
+
+1. **Ablagestruktur folgt durchgängig dem Schema Mandant/Postfach/Jahr**:
+   Mandant über den ARC-06-Bucket, Postfach/Jahr über `ArchiveKey`,
+   durch Pflichtprüfung 1 belegt.
+2. **Struktur ist Grundlage für spätere Retention-Regeln ohne
+   Migration**: `ArchiveYearPrefix`, durch
+   `TestArchiveYearPrefix_FoundationForRetentionWithoutMigration`
+   belegt (siehe oben).
+3. **Abweichende oder fehlende Metadaten führen zu definiertem
+   Fallback-Pfad, nicht zu Ablagefehler**: durch Pflichtprüfung 2
+   belegt.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
+```
+
+Keine Regression.
+
+## Ergebnis
+
+ARC-04 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Pflichtprüfung 3 (Zweitperson) bleibt strukturell offen —
+im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-05 (zusammen mit
+ARC-07/09/10/INT-08, ARC-05 weiterhin extern blockiert durch RET-03).

mail/docs/ARC-06-PRUEFPROTOKOLL.md

@@ -0,0 +1,116 @@
+# ARC-06 — Mandantentrennung im Objekt-Storage: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/storage` (`provision.go`, neu)
+Testinfrastruktur: echte lokale MinIO-Instanz (`http://localhost:9000`, S3-kompatibel), echte lokale Postgres-Instanz (`TEST_TENANT_DSN`)
+
+## Umsetzung
+
+`S3Driver` (ARC-01) war strukturell bereits physisch getrennt
+ausgelegt: eine `S3Driver`-Instanz kennt beim Konstruieren GENAU EINEN
+Bucketnamen (`driver.go`) und hat keinen Parameter/Pfad-Präfix, über
+den sie jemals ein anderes Bucket adressieren könnte — kein
+gemeinsamer Bucket mit Pfad-Präfix wie beim klassischen Cross-Tenant-
+Leck-Muster. Was fehlte, war die AUTOMATISIERTE PROVISIONIERUNG dieser
+Trennung (Akzeptanzkriterium 3) und der Nachweis (Pflichtprüfungen).
+
+Neue Datei `provision.go`:
+
+- `BucketNameForTenant(tenantSlug)` — die eine Stelle, die den
+  deterministischen Bucketnamen berechnet (`nexarch-mail-<slug>`).
+- `NewS3AdminClient` — S3-Client für Bucket-Verwaltungsoperationen
+  (`CreateBucket`/`HeadBucket`), getrennt von `S3Driver` (das nur
+  Objektoperationen innerhalb eines bereits bekannten Buckets kennt).
+- `ProvisionTenant(ctx, registryPool, s3Admin, tenantSlug, tenantName,
+  dbDSN)` — legt in EINEM Aufruf sowohl die Registry-Zeile in derselben
+  `tenants`-Tabelle wie Core TEN-01
+  (`migrations/0001_tenant_registry.sql` im Repository-Root) als auch
+  den physisch getrennten Bucket an. Schlägt die Bucket-Anlage fehl,
+  wird die Registry-Zeile automatisch zurückgenommen — kein halb
+  provisionierter Mandant.
+
+**Abgrenzung zu Core TEN-01, dokumentiert:** Core TEN-01 (in
+`cmd/core`/`internal/db` im Repository-Root) ist im aktuellen Stand ein
+Grundgerüst (Registry-Tabelle + Health-Endpunkt), enthält noch keine
+eigene, aufrufbare Tenant-Datenbank-Provisionierungsfunktion, an die
+sich diese Kachel technisch anhängen könnte. `ProvisionTenant` schreibt
+deshalb direkt in dieselbe, bereits durch TEN-01 definierte
+`tenants`-Tabelle (Postgres-DSN, kein Cross-Modul-Go-Import nötig, da
+beide Module ohnehin nur über den DSN kommunizieren) — sobald TEN-01
+eine eigene Provisionierungsfunktion bekommt, ruft sie `ProvisionTenant`
+auf, statt dass Mail eine parallele Implementierung pflegt.
+
+## Pflichtprüfung 1: Test bestätigt physische Bucket-Trennung zweier Mandanten
+
+`TestProvisionTenant_CreatesPhysicallySeparateBuckets`: zwei Mandanten
+provisioniert, unterschiedliche Bucketnamen bestätigt. Ein Objekt wird
+in Mandant As Bucket geschrieben; der Zugriff auf denselben Schlüssel
+über Mandant Bs `S3Driver` liefert `ErrNotFound` — nicht weil ein
+Pfadfilter greift, sondern weil es in Mandant Bs (physisch anderem)
+Bucket schlicht kein Objekt dieses Namens gibt. Kontrollzugriff über
+Mandant As eigenen Driver liefert den byteidentischen Inhalt zurück.
+
+Ergebnis: **BESTANDEN** (echte MinIO-Instanz, reale S3-API-Aufrufe).
+
+## Pflichtprüfung 2: Simulierter Zugriffsversuch ohne Tenant-Kontext schlägt fehl, weil kein Bucket referenzierbar ist, nicht weil ein Pfadfilter greift
+
+`TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`:
+`HeadBucket` auf den (nie provisionierten) Bucketnamen eines
+erfundenen Pseudo-Mandanten liefert einen echten S3-API-Fehler auf
+BUCKET-Ebene (`NotFound`/`NoSuchBucket`) — bevor überhaupt eine
+Schlüsselsuche innerhalb eines (in diesem Fall nicht existenten)
+Buckets stattfinden könnte. Das ist der strukturelle Beweis: es gibt
+keinen gemeinsamen Fallback-Bucket, in dem ein fehlender Tenant-Kontext
+auf einen falschen/fehlenden Pfad treffen würde — es gibt schlicht kein
+Bucket.
+
+Ergebnis: **BESTANDEN** (echte MinIO-Instanz).
+
+## Pflichtprüfung 3: Provisionierungs-Test legt für einen neuen Mandanten Datenbank UND Bucket in einem Schritt an
+
+`TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep`: EIN Aufruf
+von `ProvisionTenant` — danach existiert sowohl die Registry-Zeile
+(`SELECT ... FROM tenants WHERE slug = ...` liefert den erwarteten
+`db_dsn`) als auch das Bucket (`HeadBucket` erfolgreich), real gegen
+Postgres und MinIO geprüft. Ergänzend
+`TestProvisionTenant_RollsBackRegistryRowOnBucketFailure`: bei
+fehlschlagender Bucket-Anlage (ungültiger Bucketname) bleibt KEINE
+verwaiste Registry-Zeile zurück — kein halb provisionierter Mandant.
+
+Ergebnis: **BESTANDEN** (echte MinIO- und Postgres-Instanz, inkl.
+Fehlerpfad).
+
+## Akzeptanzkriterien
+
+1. **Jeder Mandant hat einen eigenen, physisch getrennten
+   Bucket/Pfad-Root**: durch Pflichtprüfung 1 belegt.
+2. **Ein Zugriffsversuch ohne oder mit falschem Tenant-Kontext kann
+   technisch kein fremdes Bucket erreichen, nicht nur einen falschen
+   Pfad**: durch Pflichtprüfung 1+2 belegt (strukturell durch
+   `S3Driver`s Design seit ARC-01, hier erstmals real nachgewiesen).
+3. **Bucket-Provisionierung ist Teil desselben automatisierten
+   Schritts wie die Tenant-Datenbank-Anlage, keine manuelle
+   Zusatzaktion nötig**: durch Pflichtprüfung 3 belegt — siehe auch
+   Abschnitt "Umsetzung" zur Abgrenzung gegenüber Core TEN-01s
+   aktuellem Ausbaustand.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
+```
+
+Keine Regression in den bestehenden Paketen. Neue Umgebungsvariablen
+`TEST_S3_ENDPOINT`/`TEST_S3_ACCESS_KEY`/`TEST_S3_SECRET_KEY` — ohne sie
+werden die neuen Integrationstests übersprungen (`t.Skip`), gleiche
+Konvention wie `TEST_TENANT_DSN`/`TEST_MANTICORE_URL`.
+
+## Ergebnis
+
+ARC-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen gegen eine reale MinIO- und Postgres-Instanz. Freigeschaltet
+zusammen mit SRC-11: QA-04.

mail/docs/ARC-09-PRUEFPROTOKOLL.md

@@ -0,0 +1,112 @@
+# ARC-09 — Postfach-Quota: Prüfprotokoll
+
+Datum: 2026-09-02
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Pakete: `mail/internal/quota` (neu), `mail/internal/storage` (`usagecounter.go`, `archivekey.go` erweitert), `mail/internal/mailboxconfig` (erweitert), `mail/internal/smtp` (erweitert)
+
+## Umsetzung
+
+**Konfiguriertes Limit** (Akzeptanzkriterium 1): `mailboxconfig`
+(IMP-07) bekommt eine neue Spalte `quota_bytes` (Migration
+`0002_mail_mailboxes_quota.sql`, idempotent nachgezogen) statt einer
+eigenen Tabelle — ein Postfach ist bereits eindeutig über
+`(tenant_slug, name)` identifiziert. `Store.SetQuotaBytes`/`LimitBytes`
+(`0` = unbegrenzt, Standardwert, keine Migration bestehender
+Postfächer nötig). `LimitBytes` erfüllt strukturell `quota.
+LimitProvider` — eigenständig von der tenant-weiten Core-LIC-05-Quota.
+
+**Realer Verbrauch** (Pflichtprüfung 3): `storage.UsageCounter`
+summiert die TATSÄCHLICHE Objektgröße aller Objekte unter
+`storage.ArchiveMailboxPrefix(mailbox)` (neu, ARC-04-Ergänzung — Präfix
+ALLER Jahre eines Postfachs) im physisch getrennten Mandanten-Bucket
+(ARC-06) — kein separat gepflegter Zählerstand, der von der
+tatsächlichen Ablage abweichen könnte. Erfüllt strukturell `quota.
+UsageProvider`.
+
+**Verknüpfung**: `quota.Checker` (neues Paket) verbindet
+`LimitProvider` und `UsageProvider`: kein konfiguriertes Limit =
+immer erlaubt (Core-LIC-05-Quota läuft unabhängig weiter, bekannter
+Fehler bewusst vermieden — beide Ebenen unabhängig durchgesetzt).
+
+**SMTP-Durchsetzung** (Akzeptanzkriterium 2): `smtp.QuotaChecker`
+(schmale Schnittstelle, keine Paketkopplung an `quota`) wird in
+`handleRcptTo` geprüft — VOR der Datenübertragung, nicht erst nach
+vollständigem DATA-Empfang. Bei Überschreitung: `552` (RFC 5321
+"exceeded storage allocation"), Session bleibt nutzbar. Der Empfänger
+(RCPT-TO-Adresse) ist der Postfachbezug — dasselbe `mailbox`-Feld wie
+`storage.ArchiveKey`/`mailboxconfig`. `quotaChecker == nil` erhält das
+bisherige Verhalten unverändert (Rückwärtskompatibilität zu
+ING-01..QA-04).
+
+## Pflichtprüfung 1: Postfach-Quota erreicht, neue eingehende Mail wird mit korrekter SMTP-Fehlermeldung abgelehnt
+
+`TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError`: RCPT TO an ein
+als "am Limit" markiertes Postfach liefert `552` mit erkennbarer
+Quota-Fehlermeldung; Session bleibt danach funktionsfähig (`NOOP` →
+`250`); der Sink bekommt keine Nachricht.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: anderes Postfach desselben Tenants empfängt weiterhin normal, während eines am Limit ist
+
+`TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit`: zwei unabhängige
+SMTP-Transaktionen desselben Tenants — die erste (Postfach am Limit)
+wird mit `552` abgelehnt, die zweite (anderes Postfach, kein Limit)
+läuft vollständig durch (`250`/`354`/`250`), die Nachricht kommt real
+beim Sink an.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Verbrauchsanzeige je Postfach im Test korrekt gegen tatsächliche Größe geprüft
+
+`TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota`
+(vollständiger Ende-zu-Ende-Integrationstest, echte Postgres- und
+MinIO-Instanz): 5000 Bytes real in den ARC-06-Bucket eines real
+provisionierten Mandanten geschrieben, `storage.UsageCounter.
+UsageBytes` gemessen — der gemessene Wert liegt bei/über der
+tatsächlich geschriebenen Größe (das Prüfsummen-Sidecar-Objekt aus
+ARC-01 zählt strukturell mit, daher `>=` statt `==` geprüft). Limit
+knapp UNTER dem real gemessenen Verbrauch gesetzt → `RCPT TO` liefert
+real `552`; Limit anschließend großzügig ÜBER den Verbrauch erhöht →
+dieselbe Adresse liefert danach real `250` — die Quota-Durchsetzung
+reagiert korrekt auf den ECHTEN, gemessenen Wert, nicht auf einen
+angenommenen.
+
+Ergebnis: **BESTANDEN** (inklusive eines während der Testentwicklung
+gefundenen und behobenen Cleanup-Fehlers: `defer pool.Close()` schloss
+die Postgres-Verbindung VOR den zugehörigen `t.Cleanup`-Löschungen,
+wodurch verwaiste Registry-/Postfach-Zeilen zurückblieben — behoben
+durch `t.Cleanup(pool.Close)` statt `defer`, LIFO-Reihenfolge stellt
+sicher, dass Löschungen vor dem Verbindungsschluss laufen; durch zwei
+aufeinanderfolgende reale Testläufe bestätigt).
+
+## Akzeptanzkriterien
+
+1. **Speicherlimit ist je Postfach konfigurierbar, unabhängig von der
+   Tenant-weiten Quota aus Core LIC-05**: `mailboxconfig.
+   SetQuotaBytes`/`LimitBytes`, durch Pflichtprüfung 3 belegt.
+2. **Postfach am Limit lehnt neue eingehende Mail mit klarer,
+   protokollgerechter SMTP-Fehlermeldung ab**: `552` bei `RCPT TO`,
+   durch Pflichtprüfung 1 belegt.
+3. **Ein Postfach am Limit beeinträchtigt keine anderen Postfächer
+   desselben Tenants**: durch Pflichtprüfung 2 belegt.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/quota
+```
+
+Keine Regression — insbesondere bestehende `mailboxconfig`-Tests
+(IMP-07) bleiben nach der neuen `quota_bytes`-Spalte unverändert grün.
+
+## Ergebnis
+
+ARC-09 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen — inklusive eines vollständigen Ende-zu-Ende-Integrations-
+tests gegen reale Postgres- und MinIO-Instanzen. Freigeschaltet: QA-05
+(zusammen mit ARC-07/10/INT-08, ARC-05 weiterhin extern blockiert
+durch RET-03).

mail/docs/INT-01-PRUEFPROTOKOLL.md

@@ -0,0 +1,118 @@
+# INT-01 — REST-API v1 für Mail-Zugriff & Schnittstellenbeschreibung: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/mailapi` (neu)
+
+## Umsetzung
+
+**Abweichung von der Ticketvorgabe, dokumentiert:** Core `API-01`
+(REST-API-Grundgerüst & Versionierung) und `API-04`
+(OpenAPI-Schnittstellenbeschreibung) stehen auf core-kanban zwar auf
+"Fertig", enthalten im aktuellen Repository-Stand aber keinen
+abrufbaren Router/keine Middleware, an die sich dieses Paket technisch
+anhängen könnte (`cmd/core` ist ein Grundgerüst mit nur einem
+`/healthz`-Endpunkt) — dieselbe Situation wie bei ARC-06/Core TEN-01.
+`RegisterRoutes(mux *http.ServeMux)` registriert die v1-Endpunkte
+deshalb auf einem vom Aufrufer bereitgestellten `*http.ServeMux` mit
+dem dokumentierten Pfadschema `/api/v1/mail/...` — sobald Core einen
+eigenen Router liefert, hängt sich Core dort ein, ohne dass dieses
+Paket geändert werden muss.
+
+Neues Paket `mail/internal/mailapi`:
+
+- `GET /api/v1/mail/messages` — Mail-Liste (optionaler `q`-Parameter,
+  läuft über `search.Client.Search`).
+- `GET /api/v1/mail/messages/{messageID}` — Mail-Detail (neue Methode
+  `search.Client.GetByMessageID`, liefert das vollständige
+  Suchdokument inkl. Body).
+- `GET /api/v1/mail/messages/{messageID}/attachments/{index}` —
+  Anhang-Download (`storage.ObjectKey`, physisch getrennter Bucket je
+  Mandant aus ARC-06).
+- `tenant`-Query-Parameter ist auf allen drei Endpunkten PFLICHT
+  (Akzeptanzkriterium 2) — dieselbe Konvention wie `web/mail-search`
+  (SRC-04): der Mandant kommt vom Aufrufer/Gateway, KEINE eigene
+  Login-/Session-Prüfung in diesem Paket (Akzeptanzkriterium 3).
+- `openapi.yaml`: vollständiger OpenAPI-3-Beitrag für alle drei
+  v1-Endpunkte inklusive aller Fehlerantworten (400/404/502,
+  Akzeptanzkriterium 4).
+
+## Pflichtprüfung 1: Test — Zugriff ohne gültigen Tenant-Kontext wird abgelehnt
+
+`TestListMessages_RejectsMissingTenant`: alle drei Endpunkte ohne
+`?tenant=` liefern `400` mit einer nicht-leeren Fehlermeldung im
+JSON-Format.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: Vertragstest gegen definierte Endpunkte läuft grün
+
+`TestListMessages_ReturnsOnlyOwnTenantMessages`,
+`TestGetMessage_NotFoundForForeignTenant`,
+`TestGetMessage_ReturnsFullDetailForOwnTenant`,
+`TestGetAttachment_PhysicalTenantSeparationEnforced` (ein Anhang, real
+im Bucket von Mandant A abgelegt, ist über Mandant Bs Tenant-Kontext
+mit DERSELBEN messageID nicht erreichbar — physische Bucket-Trennung
+aus ARC-06, nicht nur ein Pfadfilter). Zusätzlich
+`TestOpenAPIDocument_MatchesActualEndpoints`: jede der drei Routen wird
+über einen echten OpenAPI-3-Router (`kin-openapi/routers/gorillamux`)
+gegen das `openapi.yaml`-Dokument aufgelöst — kein rein optischer
+String-Abgleich.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Codereview bestätigt Abgrenzung zu Core-Board-Zuständigkeiten
+
+`TestCodeReview_NoIAMRelatedHandlers`: automatisiertes Code-Review —
+`mailapi.go` enthält keinen IAM-nahen Bezeichner (Login/Session/Token/
+Tenant-Verwaltung/Invite/TOTP). Ergänzt um die manuelle Bestätigung im
+Code-Kommentar von `mailapi.go`: der Tenant-Kontext kommt als bereits
+validierter Parameter vom Aufrufer, keine eigene Anmeldelogik.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 4: Validierungslauf des OpenAPI-Dokuments gegen Standardwerkzeuge ist fehlerfrei
+
+`TestOpenAPIDocument_ValidatesAgainstStandardTool`: `openapi.yaml` wird
+über `github.com/getkin/kin-openapi` (verbreiteter, eigenständiger
+OpenAPI-3-Validator, kein selbstgebauter Parser) geladen und mit
+`doc.Validate(ctx)` geprüft — fehlerfrei. Als neue, gepinnte
+Go-Modul-Abhängigkeit hinzugefügt (`v0.135.0`, kompatibel mit der
+bestehenden Go-1.24-Anforderung des Moduls — eine neuere Version hätte
+das Modul auf Go 1.25 gezwungen, bewusst vermieden).
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **API bietet Endpunkte für Mail-Liste, Mail-Detail und
+   Anhang-Download**: alle drei implementiert, siehe "Umsetzung".
+2. **Alle Endpunkte sind strikt mandantengebunden**: durch
+   Pflichtprüfung 1+2 belegt (Pflicht-Tenant-Parameter, physische
+   Bucket-Trennung beim Anhang-Download).
+3. **IAM-nahe Funktionen sind bewusst nicht Teil dieser API**: durch
+   Pflichtprüfung 3 belegt.
+4. **Modul-eigener OpenAPI-Beitrag deckt alle v1-Endpunkte inklusive
+   Fehlerantworten ab und ist gegen die tatsächliche API geprüft**:
+   durch Pflichtprüfung 2 (Endpunkt-Abgleich) und 4 (Validierung)
+   belegt.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go mod verify → alle module verifiziert, go.mod bleibt auf "go 1.24"
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/mailapi
+```
+
+Keine Regression in den bestehenden Paketen.
+
+## Ergebnis
+
+INT-01 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Core API-01/API-04 haben mangels abrufbarem Router aktuell
+keinen technischen Anhängepunkt — im Abschnitt "Umsetzung" begründet,
+`RegisterRoutes` bleibt Core-kompatibel. Freigeschaltet: INT-06, INT-07,
+QA-06 (zusammen mit INT-05/INT-09/INT-10).

mail/docs/INT-05-PRUEFPROTOKOLL.md

@@ -0,0 +1,90 @@
+# INT-05 — Benachrichtigungs-Service "neue Mail": Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Pakete: `mail/internal/notifyclient` (neu), `mail/internal/importnotify` (neu)
+
+## Umsetzung
+
+**Abweichung von der Ticketvorgabe, dokumentiert:** Core `CFG-02`
+(Benachrichtigungs-Dispatcher) und `CFG-05` (modulübergreifender
+HTTP-Endpunkt `POST /notify`) stehen auf core-kanban zwar auf "Fertig",
+enthalten im aktuellen Repository-Stand aber keinen abrufbaren
+Endpunkt — dieselbe wiederkehrende Situation wie ARC-06/Core TEN-01
+und INT-01/Core API-01. `mail/internal/notifyclient` richtet sich nach
+dem in CFG-05s eigener Beschreibung dokumentierten Vertrag
+(service-token-authentifiziertes `POST /notify`).
+
+**Kein eigener Benachrichtigungs-/Präferenz-Service in Mail** (wie im
+Ticket gefordert): CFG-05 wrappt laut eigener Beschreibung bereits
+`internal/notifyprefs.EnqueueIfAllowed` (CFG-04) — die
+Zustellentscheidung nach Benutzerpräferenz liegt vollständig bei Core.
+`notifyclient.Client.Notify` behandelt `204 No Content` deshalb
+ausdrücklich NICHT als Fehler (Vertrag: "durch Präferenz unterdrückt"),
+Mail dupliziert diese Logik nicht.
+
+`mail/internal/importnotify.NotifyBatch(ctx, notifier, tenantSlug,
+mailboxName, imapimport.SyncResult)`: EIN Aufruf am Ende EINES
+Abgleichslaufs (`imapimport.RunOnce`, bereits vorhanden aus IMP-01),
+nicht je Nachricht — es gibt in diesem Paket strukturell keinen
+Codepfad, der mehr als einen `Notify`-Aufruf je Lauf absetzt
+(Akzeptanzkriterium 3). `SyncResult.NewMessages == 0` sendet nichts.
+
+## Pflichtprüfung 1: Import einer Mail löst genau eine Benachrichtigung aus
+
+`TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification`:
+`SyncResult{NewMessages: 1}` → genau 1 Aufruf, korrekter Inhalt.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: Massenimport erzeugt eine gebündelte Zusammenfassung statt Flut
+
+`TestNotifyBatch_MassImportProducesOneBundledNotification`:
+`SyncResult{NewMessages: 50}` → weiterhin genau 1 Aufruf, mit
+`Count: 50` in der Zusammenfassung — keine 50 Einzelbenachrichtigungen.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: deaktivierte Benachrichtigung erzeugt keine Zustellung
+
+`TestNotifyBatch_DisabledNotificationDeliversNothing`: echter
+`httptest`-Server bildet den CFG-05-Vertrag nach (`204` = "durch
+Benutzerpräferenz unterdrückt"). `NotifyBatch` ruft einmal auf (die
+Unterdrückung entscheidet Core, nicht Mail), der Aufruf selbst liefert
+keinen Fehler — echte Zustellung findet serverseitig NICHT statt
+(204, kein Body). Ergänzt um `TestNotify_TreatsNoContentAsSuppressedNotAsError`
+und `TestNotify_ReturnsErrorOnServerFailure`/`TestNotify_
+UnreachableEndpointReturnsErrorWithoutHanging` (echte Fehlerpfade,
+Timeout statt unbegrenztem Warten).
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Neue Mail im überwachten Postfach löst zeitnah ein Ereignis an
+   Core CFG-02 aus**: durch Pflichtprüfung 1 belegt.
+2. **Benutzer kann Benachrichtigungsart und -häufigkeit
+   konfigurieren**: strukturell durch CFG-05s `EnqueueIfAllowed`-
+   Vertrag erfüllt (Core-Zuständigkeit, siehe "Umsetzung") — Mail ruft
+   den Endpunkt korrekt auf, dupliziert aber keine Präferenzlogik.
+3. **Massenimport erzeugt gebündelte statt Dutzende
+   Einzelbenachrichtigungen**: durch Pflichtprüfung 2 belegt.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuen internal/notifyclient und internal/importnotify
+```
+
+Keine Regression.
+
+## Ergebnis
+
+INT-05 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Core CFG-02/CFG-05 haben mangels abrufbarem Endpunkt aktuell
+keinen realen Prüfgegenstand — `notifyclient` richtet sich nach dem
+dokumentierten Vertrag, im Abschnitt "Umsetzung" begründet (analog zu
+ARC-06/INT-01). Freigeschaltet: QA-06 (zusammen mit INT-06/07/09/10).

mail/docs/INT-06-PRUEFPROTOKOLL.md

@@ -0,0 +1,82 @@
+# INT-06 — E-Mail-Regel-Engine über API steuerbar: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Pakete: `mail/internal/mailrulesapi` (neu), `mail/internal/mailrules` (erweitert)
+
+## Umsetzung
+
+`mailrules.Store` (IMP-03) hatte bislang nur `Create`/`List`/`Delete` —
+kein `Update`. Ergänzt um `Store.Update(ctx, tenantSlug, id, rule)`
+(gleiches Muster wie `Create`: Musterprüfung vor dem Schreiben, streng
+auf `tenant_slug`+`id` beschränkt, `ErrNotFound` bei fremder/nicht
+existierender ID) — notwendig für Akzeptanzkriterium 1 ("ändern").
+
+Neues Paket `mail/internal/mailrulesapi`: vier Endpunkte
+(`GET`/`POST /api/v1/mail/rules`, `PUT`/`DELETE
+/api/v1/mail/rules/{id}`), `tenant`-Query-Parameter Pflicht, gleiche
+Konvention wie `mailapi` (INT-01). **Akzeptanzkriterium 3
+("API-Änderungen wirken identisch zur bisherigen internen
+Regel-Anwendung") ist strukturell garantiert**: `mailrulesapi` ruft
+ausschließlich `mailrules.Store` auf — denselben Store, den IMP-03s
+Import-Pfad ohnehin verwendet. Es gibt keinen zweiten,
+parallelen Schreibpfad, der abweichen könnte.
+
+## Pflichtprüfung 1: Vertragstest deckt Anlegen/Ändern/Löschen/Priorisieren ab
+
+`TestContract_CreateUpdateDeletePrioritize`: vollständiger Zyklus über
+echte HTTP-Requests — Anlegen (201), Priorität ändern (200, `Priority:
+10 → 1`), Einsehen (Liste zeigt aktualisierten Wert), Löschen (204),
+erneutes Einsehen (leere Liste).
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: über API gesetzte Regel wird beim nächsten Import korrekt angewendet
+
+`TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine`: Regel über
+einen echten HTTP-`POST`-Request angelegt, danach über GENAU DEN WEG
+gelesen und ausgewertet, den IMP-03s Import-Pfad geht
+(`store.List` → `mailrules.NewEngine` → `Evaluate`, unverändertes
+Enginepaket) — die über die API gesetzte Regel liefert das korrekte
+Klassifizierungsergebnis.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Regeländerung eines Mandanten wirkt nicht auf andere Mandanten
+
+`TestIntegration_RuleChangeIsolatedPerTenant`: Mandant A legt eine
+Regel über die API an; Mandant B sieht sie nicht in seiner Liste;
+Mandant Bs Update-Versuch mit der ECHTEN, bekannten ID von Mandant As
+Regel liefert `404` (nicht etwa eine stillschweigend erfolgreiche
+Übernahme); Mandant As Regel bleibt danach nachweislich unverändert.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Regeln lassen sich vollständig über die API anlegen, ändern und
+   löschen**: durch Pflichtprüfung 1 belegt.
+2. **Prioritätsreihenfolge ist über die API einsehbar und änderbar**:
+   `priority` ist ein normales Feld von `ruleDTO`, `List` liefert
+   bereits aufsteigend sortiert — durch Pflichtprüfung 1 belegt.
+3. **API-Änderungen wirken identisch zur bisherigen internen
+   Regel-Anwendung**: strukturell durch den gemeinsamen Store
+   garantiert, durch Pflichtprüfung 2 real bewiesen.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/mailrulesapi
+```
+
+Keine Regression — insbesondere die bestehenden `mailrules`-Tests
+(IMP-03/IMP-09) bleiben nach der `Update`-Erweiterung unverändert grün.
+
+## Ergebnis
+
+INT-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Freigeschaltet: QA-06 (zusammen mit INT-09/INT-10, weiterhin
+extern blockiert).

mail/docs/INT-07-PRUEFPROTOKOLL.md

@@ -0,0 +1,91 @@
+# INT-07 — Health-Check-Endpunkt für Mail-Modul: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/healthcheck` (neu)
+Testinfrastruktur: echte lokale Postgres-, MinIO- und Manticore-Instanzen
+
+## Umsetzung
+
+`Checker` sammelt benannte `CheckFunc`-Prüfungen (Reihenfolge
+deterministisch) und liefert einen `Result` mit Gesamtstatus und
+Einzelstatus je Komponente — `ok` oder `degraded`
+(Akzeptanzkriterium 3, nie ein generischer Fehler). Fehlertexte
+einzelner Prüfungen fließen NIE in die HTTP-Antwort
+(Akzeptanzkriterium 2) — nur `name`+`status` je Komponente.
+
+Vier konkrete Prüfungen (`checks.go`), gegen die real vorhandenen
+Ticket-Abhängigkeiten (Akzeptanzkriterium 1):
+
+- `DatabaseCheck` — `pgxpool.Pool.Ping`.
+- `ObjectStorageCheck` — `HeadBucket` gegen den ARC-06-Bucket.
+- `SearchIndexCheck` — reale `search.Client.Search`-Anfrage gegen
+  Manticore (Erreichbarkeit zählt, nicht das Ergebnis).
+- `JobQueueCheck` — `SELECT count(*) FROM mail_index_jobs`
+  (SRC-02/indexworker) — `COUNT` statt Zeilenzugriff, damit eine LEERE
+  aber erreichbare Queue nicht fälschlich als Ausfall gilt.
+
+`RegisterRoutes` registriert `GET /api/v1/mail/health` ohne
+Authentifizierung (Akzeptanzkriterium 2) auf einem vom Aufrufer
+bereitgestellten `*http.ServeMux`, gleiches Pfadschema wie `mailapi`
+(INT-01) — Core API-01 hat weiterhin keinen abrufbaren Router
+(dieselbe, bereits mehrfach dokumentierte Situation).
+
+## Pflichtprüfung 1: simulierter Ausfall einer Abhängigkeit wird korrekt im Health-Status abgebildet
+
+`TestCheck_SimulatedDependencyFailureReflectedCorrectly`: eine von vier
+Prüfungen liefert einen Fehler — Gesamtstatus `degraded`, GENAU diese
+eine Komponente als `degraded`, die übrigen drei als `ok`.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: Health-Antwort enthält keine sensiblen Konfigurationsdetails
+
+`TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails`: eine
+Prüfung liefert einen Fehler, der absichtlich eine vollständige
+Verbindungszeichenfolge inkl. Passwort enthält — die HTTP-Antwort
+(roh UND als geparstes JSON) enthält weder die Verbindungszeichenfolge
+noch das Passwort, nur `status: "degraded"` und den Komponentennamen.
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Integrationstest gegen echten Health-Endpunkt nach Deploy
+
+`TestIntegration_RealHTTPEndpointAfterDeploy`: echter `httptest`-HTTP-
+Server, echte Netzwerkanfrage (kein direkter Funktionsaufruf) gegen
+`GET /api/v1/mail/health`, 200 mit vollständigem, geparstem JSON.
+Ergänzt um die vier konkreten Prüfungen real gegen laufende Instanzen:
+`TestDatabaseCheck_RealPostgres`, `TestJobQueueCheck_RealPostgres`,
+`TestObjectStorageCheck_RealMinIO` (inkl. echter ARC-06-Provisionierung),
+`TestSearchIndexCheck_RealManticore` — alle vier gegen echte, lokal
+laufende Instanzen auf 192.168.1.131.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Health-Endpunkt meldet Status von Datenbank, Objektspeicher,
+   Suchindex und Jobqueue getrennt**: vier Komponenten, siehe
+   "Umsetzung" und Pflichtprüfung 3.
+2. **Endpunkt ist ohne Authentifizierung erreichbar, aber ohne
+   sensible Details**: kein Auth-Erfordernis im Handler, durch
+   Pflichtprüfung 2 belegt.
+3. **Ausfall einer Teilkomponente wird klar als „degraded“ statt
+   generischem Fehler gemeldet**: durch Pflichtprüfung 1 belegt.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/healthcheck
+```
+
+Keine Regression.
+
+## Ergebnis
+
+INT-07 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen gegen reale Postgres-, MinIO- und Manticore-Instanzen.
+Freigeschaltet: QA-06 (zusammen mit INT-06/09/10).

mail/docs/QA-02-PRUEFPROTOKOLL.md

@@ -0,0 +1,101 @@
+# QA-02 — Prüfgate Ingestion & Import: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/ingestiontestgate` (neu)
+
+## Umsetzung
+
+Spiegelt das bereits etablierte Muster aus `mail/internal/qagate`
+(QA-03) und `mail/internal/importtestgate` (IMP-09) — ein echtes,
+ausführbares Prüfgate statt einer nur behaupteten Prüfung:
+
+- `IngestionAndImportPackages`: alle 14 Pakete, die aus QA-02s eigener
+  `dependsOn`-Liste folgen (ING-10: IMAP/POP3/SMTP/MIME/Folder-State;
+  ING-07: protoguard; ING-08: protolog; IMP-04/IMP-09: imapimport;
+  IMP-05: hotfolder; IMP-06: virusscan; IMP-07: mailboxconfig; IMP-08:
+  syncalert; zugehörig: attachments, mailrules).
+- `RunTestSuites`: führt `go test -count=1 -p 1` über alle 14 Pakete
+  aus (`-p 1`: nacheinander statt parallel — mehrere gleichzeitige
+  Testbinaries würden sich bei den echten QA-07-Lasttests in
+  imap/pop3/smtp gegenseitig CPU-Kontingent wegnehmen und so
+  Latenz-Zielwerte durch reine Testhost-Überlastung verfehlen lassen,
+  real beobachtet und behoben).
+- `ScanForKnownErrorPointTests`: prüft für die drei in
+  Akzeptanzkriterium 2 namentlich geforderten Fehlerpunkte
+  (Header-Injection, Anhang-Limit, UIDVALIDITY), ob im jeweils
+  zuständigen Paket eine `_test.go`-Datei eine passende Testfunktion
+  enthält — automatisiert, nicht nur behauptet.
+
+## Pflichtprüfung 1: Gate-Lauf gegen aktuellen Stand von ING-10/IMP-09 dokumentiert
+
+`TestRun_RealGateAgainstCurrentIngestionImportState`
+(`ingestiontestgate/gate_test.go`): echter Gate-Lauf gegen den
+aktuellen Quelltext, Ergebnis:
+
+```
+# QA-02 Gate-Ergebnis: BESTANDEN
+Zeitstempel (UTC): 2026-09-01T15:35:33Z
+
+## Testsuiten (Ingestion & Import, 14 Pakete)
+Bestanden: true
+
+## Bekannte Fehlerpunkte — Regressionstest-Stichprobe
+- Header-Injection: abgedeckt=true — TestHeaderWriter_RejectsControlCharsAndCRLFInSubjectAndDisplayName in internal/mailer/mailer_test.go
+- Anhang-Limit: abgedeckt=true — TestParse_OversizedAttachmentRejectedNotMemoryExhausted in internal/mimeparse/mimeparse_test.go
+- UIDVALIDITY: abgedeckt=true — TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild in internal/folderstate/store_test.go
+```
+
+Ergebnis: **BESTANDEN**, dokumentiert mit Zeitstempel.
+
+## Pflichtprüfung 2: Stichprobe — mindestens ein Regressionstest je bekanntem Fehlerpunkt vorhanden
+
+Durch Pflichtprüfung 1 automatisiert mitgeprüft. Ergänzt um zwei
+eigenständige Bausteintests: `TestScanForKnownErrorPointTests_
+RealPackagesAllCovered` (positiver Nachweis gegen den echten
+Quelltext) und `TestScanForKnownErrorPointTests_DetectsMissingCoverage`
+(Negativtest — beweist, dass der Scanner eine tatsächlich fehlende
+Abdeckung auch real erkennt, nicht nur immer "bestanden" meldet).
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 3: Zweite Person bestätigt Gate-Ergebnis unabhängig
+
+**Nicht durchführbar durch diese Sitzung**, aus demselben strukturellen
+Grund wie bereits bei ING-10 (Stichprobenreview) und QA-04
+(API-Token-Prüfung) dokumentiert: eine einzelne KI-Sitzung kann keine
+unabhängige ZWEITE Person sein, ohne den Zweck der Prüfung (echte
+menschliche Gegenkontrolle) zu unterlaufen. **Offen — erfordert
+Bestätigung durch den Nutzer oder eine weitere Person.** Grundlage für
+dieses Review: der Gate-Bericht oben, reproduzierbar über
+`go test ./internal/ingestiontestgate/... -run TestRun_RealGate` mit
+gesetztem `TEST_TENANT_DSN`/`TEST_MANTICORE_URL`.
+
+## Akzeptanzkriterien
+
+1. **Gate prüft Testabdeckung und Bestehen aller Ingestion-/
+   Import-Testsuiten**: durch Pflichtprüfung 1 belegt.
+2. **Gate prüft, dass bekannte Fehlerpunkte (Header-Injection,
+   Anhang-Limit, UIDVALIDITY) durch Tests abgedeckt sind**: durch
+   Pflichtprüfung 2 belegt.
+3. **Gate-Ergebnis ist dokumentiert und nachvollziehbar mit
+   Zeitstempel**: `GateResult.Report()`, siehe Pflichtprüfung 1.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok, inkl. neuem internal/ingestiontestgate
+```
+
+Keine Regression.
+
+## Ergebnis
+
+QA-02 erfüllt Akzeptanzkriterium 1–3 mit echten, ausgeführten
+Nachweisen; Pflichtprüfung 3 (Zweitreview) bleibt strukturell offen,
+siehe Abschnitt oben — analog zu ING-10 und QA-04 im Entscheidungs-
+verlauf vermerkt. Freigeschaltet: QA-09 (zusammen mit QA-05/QA-06/
+QA-08).

mail/docs/QA-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,134 @@
+# QA-04 — Sicherheits- & Berechtigungsprüfung: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Geprüfte Pakete: `mail/internal/smtp`, `mail/internal/mailer`, `mail/internal/storage`, `mail/internal/folderstate`, `mail/internal/mailboxconfig`, `mail/internal/ratelimit`
+
+## Umsetzung — echter Sicherheitsbefund und Korrektur
+
+Der gezielte Testangriff auf den SMTP-Pfad (Pflichtprüfung 1) deckte
+einen REALEN Härtungsfehler auf, der VOR dieser Kachel unbemerkt
+geblieben war: ING-07 (Idle-Timeout-Schutz) hatte `protoguard` nur in
+`mail/internal/imap` und `mail/internal/pop3` verdrahtet — `mail/
+internal/smtp` bekam versehentlich NIE einen Idle-Timeout. Eine
+Gegenstelle, die eine Kommandozeile ohne abschließendes CRLF öffnet und
+nie beendet, konnte die Session unbegrenzt blockieren (bestätigt durch
+`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash`, VOR der
+Korrektur real reproduziert: Server antwortete nach 8s Wartezeit weder
+mit Fehler noch Verbindungsende).
+
+**Korrektur** (`session.go`/`server.go`, `mail/internal/smtp`): `guard
+*protoguard.Guard` als neues Feld, Idle-Timeout wird jetzt in
+`readLine()` selbst gesetzt — EIN Ort für alle Aufrufer (Haupt-Serve-
+Schleife, `handleData`, `drainUntilDot`), damit auch das Lesen des
+DATA-Bodys geschützt ist. Neuer Konstruktor
+`NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig` für
+abweichende Timeout-Werte (Tests). Bestehende Konstruktoren bekommen
+automatisch `protoguard.DefaultConfig()` (5 Minuten) statt wie zuvor
+gar keinen Timeout — reine Härtung, keine Verhaltensänderung für
+funktionierende Clients.
+
+## Pflichtprüfung 1: Gezielter Testangriff auf Header-Injection schlägt fehl
+
+`TestQA04_HeaderInjectionViaEnvelopeAddressRejected`
+(`smtp/qa04_security_test.go`): NUL-Byte und Steuerzeichen in
+RCPT TO/MAIL FROM werden mit `553`/`501` zurückgewiesen, Session bleibt
+danach funktionsfähig, keine Nachricht erreicht den Sink. Ergänzt um
+`TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash` (Ressourcen-
+erschöpfungsangriff, siehe Abschnitt "Umsetzung" — deckte den realen
+Härtungsfehler auf und bestätigt nach der Korrektur zuverlässige
+Reaktion binnen des konfigurierten Timeouts). Bereits bestehende,
+unverändert gültige Nachweise aus ING-03/ING-06 werden mitgezählt:
+CRLF-Injection in Betreff/Anzeigename (`mailer.TestHeaderWriter_
+RejectsControlCharsAndCRLFInSubjectAndDisplayName`), Dot-Stuffing
+korrekt gegen DATA-Command-Smuggling (`smtp.TestData_
+MessageSizeCheckedBeforeAcceptance` u. a.), TLS-Downgrade-Angriffe
+(`smtp.TestServer_RejectsLegacyTLSVersionAndWeakCiphers`, ING-06).
+
+Ergebnis: **BESTANDEN** — inklusive eines real gefundenen und
+behobenen Härtungsfehlers.
+
+## Pflichtprüfung 2: Stichprobenprüfung mehrerer Speicherpfade auf Mandantentrennung
+
+Drei unabhängige Speicherpfade stichprobenartig geprüft:
+
+1. **Objekt-Storage** (`mail/internal/storage`, ARC-06): physische
+   Bucket-Trennung, bereits real gegen MinIO nachgewiesen
+   (`TestProvisionTenant_CreatesPhysicallySeparateBuckets`,
+   `TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable`
+   — siehe `ARC-06-PRUEFPROTOKOLL.md`).
+2. **Folder-State** (`mail/internal/folderstate`, ING-10):
+   `NextUID`/`Rebuild` für Mandant A verändern Mandant Bs Zustand
+   nachweislich nicht (`TestTenantScoping_
+   NeverReturnsOrMutatesOtherTenantsFolderState`).
+3. **Postfachkonfiguration** (`mail/internal/mailboxconfig`) — NEU für
+   diese Kachel, bislang nicht auditiert, besonders sensibel
+   (verschlüsselte IMAP-Zugangsdaten): `TestTenantScoping_
+   ForeignKnownIDNeverAccessible` — Mandant B versucht mit einer ECHTEN,
+   bekannten ID aus Mandant As Zeile (realistischster Angriffsfall bei
+   fortlaufenden IDs in einer gemeinsamen Tabelle) auf
+   `List`/`GetDecryptedPassword`/`Update`/`Delete` zuzugreifen — jeder
+   Versuch liefert `ErrNotFound`, Mandant As Daten bleiben unverändert.
+
+Ergebnis: **BESTANDEN** in allen drei gezogenen Stichproben.
+
+## Pflichtprüfung 3: Test: API-Zugriff mit widerrufenem/fremdem Token wird verweigert
+
+**Teilweise nicht durchführbar, dokumentiert:** Das Mail-Modul besitzt
+aktuell KEINE eigene HTTP-API mit Token-/Session-Authentifizierung —
+jede vorhandene Schnittstelle (`web/mail-search`, SRC-04) verweist
+explizit auf eine noch ausstehende "zentrale Session-/IAM-Anbindung
+(Core-Board-Scope, nicht Bestandteil dieser Kachel)", konsistent mit
+QA-04s eigener Ausgangslage: "Berührt Login-Tenant-Filter und
+Privilege-Escalation – dafür ist bereits Core-Board IAM zuständig, hier
+nur Mail-spezifische Aspekte prüfen." Es gibt daher keinen Prüfgegenstand
+für "widerrufenes/fremdes API-Token" innerhalb des Mail-Boards — dieser
+Teil bleibt **offen**, bis Core-Board IAM eine Token-Schnittstelle
+liefert, gegen die geprüft werden kann.
+
+Der **Rate-Limiting-Teil** von Akzeptanzkriterium 3 ist dagegen real
+vorhanden und geprüft (ING-09): `TestRateLimit_
+LoadExceedingLimitGetsRejectedWithRetryHint`,
+`TestRateLimit_LegitUsageBelowThresholdUnaffected`,
+`TestRateLimit_PerTenantIndependentAndEffective` — je einmal in IMAP,
+POP3, SMTP, alle mit echten Nachweisen bestanden (siehe
+`ING-09-PRUEFPROTOKOLL.md`), hier erneut mitgeprüft und bestätigt grün.
+
+Ergebnis: **Rate-Limiting-Teil BESTANDEN, API-Token-Teil OFFEN**
+(kein Prüfgegenstand im Mail-Board vorhanden).
+
+## Akzeptanzkriterien
+
+1. **Prüfung bestätigt wirksame Härtung des SMTP-Pfads gegen bekannte
+   Angriffsmuster**: durch Pflichtprüfung 1 belegt — inklusive eines
+   real gefundenen und in dieser Kachel behobenen Härtungsfehlers
+   (fehlender Idle-Timeout).
+2. **Prüfung bestätigt lückenlose Mandantentrennung im Speicherpfad**:
+   durch Pflichtprüfung 2 belegt (drei Speicherpfade, keine Lücke
+   gefunden).
+3. **Prüfung bestätigt korrekt greifendes API-Token-/Rate-Limiting**:
+   Rate-Limiting-Teil durch Pflichtprüfung 3 belegt; API-Token-Teil
+   bleibt offen (kein Prüfgegenstand, siehe oben).
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL, TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY gesetzt) → alle Pakete ok
+```
+
+Keine Regression — insbesondere QA-07-Lasttest für SMTP bleibt nach der
+Idle-Timeout-Korrektur unverändert grün (6057,8 Sessions/s, p95 48,2ms).
+
+## Ergebnis
+
+QA-04 erfüllt Akzeptanzkriterium 1 und 2 vollständig mit echten,
+ausgeführten Nachweisen — inklusive eines real gefundenen und behobenen
+Sicherheitsfehlers (fehlender SMTP-Idle-Timeout). Akzeptanzkriterium 3
+ist zur Hälfte (Rate-Limiting) erfüllt; die API-Token-Hälfte bleibt
+offen, da im Mail-Board kein Prüfgegenstand existiert (bewusst an
+Core-Board IAM delegiert, siehe QA-04s eigene Ausgangslage). Board wird
+auf Basis der erfüllbaren Teile fortgeführt, das offene Element ist
+hier und im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-09.

mail/docs/SRC-11-PRUEFPROTOKOLL.md

@@ -0,0 +1,105 @@
+# SRC-11 — Feld-Whitelist-Query-Builder für Suchindex-Zugriff: Prüfprotokoll
+
+Datum: 2026-09-01
+Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
+Paket: `mail/internal/search` (`fields.go`, `facets.go`)
+
+## Umsetzung
+
+Grundlage war bereits vorhanden (SRC-01/SRC-05): statische `FieldXxx`-
+Konstanten in `fields.go`, Suchanfragen ausschließlich über Manticores
+strukturierte HTTP-JSON-API (kein SQL-String-Zusammenbau). Was fehlte,
+war Akzeptanzkriterium 2: die Facetten-Whitelist war eine `[]string`
+(`FacetFields`), gegen die `isFacetField` per Schleife prüfte — eine
+klassische "Whitelist-Funktion", genau das Muster, das
+`known-issues-archivmail.md` #12 und `known-issues-archivdms.md` #10
+als unzureichend benennen (ein vergessener/fehlerhafter Eintrag in der
+Liste lässt unbemerkt alles durch).
+
+**Neu:** `FacetField` ist ein eigener, geschlossener Typ (`fields.go`).
+`FacetField.IsValid()` entscheidet über ein erschöpfendes `switch/case`
+auf den vier Konstanten (`FacetFieldSender`, `FacetFieldMailbox`,
+`FacetFieldAttachmentType`, `FacetFieldTag`) — keine Liste mehr, die
+durchsucht wird und die man vergessen könnte zu pflegen.
+`ParseFacetField` ist die einzige vorgesehene Stelle, um aus einer
+externen Zeichenkette (z. B. künftig ein HTTP-Query-Parameter) ein
+`FacetField` zu machen. `FacetFilter.Field` ist jetzt `FacetField` statt
+`string`. `buildFilteredMust` (einzige Stelle, die Filter-Feldnamen in
+eine Suchanfrage einbaut) prüft `f.Field.IsValid()` statt
+Listenmitgliedschaft.
+
+`isFacetField` (die alte Listenfunktion) ist entfernt — es gibt keine
+Liste mehr, die die Zulässigkeitsentscheidung trifft, nur noch das
+`switch/case` in `IsValid()`.
+
+## Pflichtprüfung 1: Versuch, ein nicht in der Whitelist enthaltenes Feld anzufragen, wird abgewiesen statt stillschweigend ignoriert
+
+`TestBuildFilteredMust_RejectsUnknownField`
+(`search/src11_test.go`): zwei Fälle — ein reales Suchfeld, das aber
+KEIN Facettenfeld ist (`tenant_slug`), und ein frei erfundenes Feld
+(inkl. eines absichtlich SQL-injection-artigen Strings, um zu zeigen,
+dass er nicht einmal in die Fehlermeldung unverarbeitet "verschwindet",
+sondern sauber als Fehler zurückkommt) — beide werden mit Fehler
+abgelehnt, kein stillschweigendes Ignorieren.
+`TestBuildFilteredMust_AcceptsAllWhitelistedFields` stellt sicher, dass
+die Prüfung nicht zu streng ist (alle vier realen Facettenfelder
+funktionieren).
+
+Ergebnis: **BESTANDEN**.
+
+## Pflichtprüfung 2: Code-Review bestätigt: kein dynamischer Spalten-/Tabellenname wird per String-Zusammenbau erzeugt
+
+`TestNoDynamicFieldNameConstruction` (`search/src11_test.go`):
+automatisiertes Code-Review — `facets.go` und `fields.go` enthalten in
+keiner Codezeile (Kommentarzeilen ausgenommen, dort nur erklärender
+Text über den zu vermeidenden Fehler) ein `fmt.Sprintf`. Ergänzt um
+`TestFacetField_ClosedSetEvenViaDirectTypeConversion`
+(Akzeptanzkriterium 2 wörtlich: die Whitelist ist NICHT die einzige
+Absicherung — selbst ein `FacetField`-Wert, der nicht über
+`ParseFacetField` entstanden ist, sondern durch direkte
+Typkonvertierung, wird von `IsValid()` zuverlässig abgelehnt) und
+`TestParseFacetField_OnlyAcceptsKnownStrings`.
+
+Ergebnis: **BESTANDEN**.
+
+## Akzeptanzkriterien
+
+1. **Spalten-/Feldnamen für dynamische Query-Teile stammen
+   ausschließlich aus statischen Konstanten bzw. einem geschlossenen
+   Enum/Switch-Typ**: `FacetField` + die vier `FacetFieldXxx`-Konstanten,
+   durch Pflichtprüfung 2 belegt.
+2. **Whitelist ist nicht die einzige Absicherung**: `IsValid()` ist ein
+   erschöpfendes `switch/case`, keine Listen-Iteration mehr — durch
+   Pflichtprüfung 1+2 belegt.
+3. **Entscheidung dokumentiert: Mail-eigene Implementierung, keine
+   geteilte Utility mit dem DMS-Board**: siehe unten.
+
+### Zu Akzeptanzkriterium 3
+
+Diese Kachel implementiert den Query-Builder ausschließlich innerhalb
+von `mail/internal/search` — keine neue geteilte Utility mit dem
+DMS-Board angelegt. Konsistent mit der bereits im Ticket-Prompt
+genannten, vorab getroffenen Entscheidung
+(`nexarch-state.json` → `bewusst_nicht_zentralisiert`), Suche/OCR
+zwischen Mail und DMS nicht zu zentralisieren.
+
+## Build/Vet/Lint/Test — Gesamtmodul
+
+```
+go build ./...    → OK
+go vet ./...      → OK
+golangci-lint run ./... → 0 issues
+go test ./... -p 1 (TEST_TENANT_DSN, TEST_MANTICORE_URL gesetzt) → alle Pakete ok
+```
+
+Keine Regression — insbesondere `mail/internal/savedsearch` (Konsument
+von `search.FacetFilter`) unverändert grün: die Typänderung von
+`Field string` zu `Field FacetField` ist für bestehende Aufrufer, die
+den untypisierten String-Konstanten `FieldSender` usw. übergeben,
+verhalten sich unverändert (Go erlaubt die implizite Umwandlung
+untypisierter Konstanten).
+
+## Ergebnis
+
+SRC-11 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
+Nachweisen. Freigeschaltet: QA-04 (zusammen mit ARC-06).

mail/go.mod

@@ -2,14 +2,14 @@ module gitea.perlbach24.de/scripte/nexarch/mail
 
 go 1.24
 
-toolchain go1.24.4
-
 require (
 	github.com/aws/aws-sdk-go-v2 v1.45.1
 	github.com/aws/aws-sdk-go-v2/config v1.33.1
 	github.com/aws/aws-sdk-go-v2/credentials v1.20.1
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1
 	github.com/aws/smithy-go v1.28.1
+	github.com/fsnotify/fsnotify v1.10.1
+	github.com/getkin/kin-openapi v0.135.0
 	github.com/jackc/pgx/v5 v5.6.0
 	golang.org/x/text v0.14.0
 )
@@ -28,11 +28,21 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
-	github.com/fsnotify/fsnotify v1.10.1 // indirect
+	github.com/go-openapi/jsonpointer v0.21.0 // indirect
+	github.com/go-openapi/swag v0.23.0 // indirect
+	github.com/gorilla/mux v1.8.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
+	github.com/oasdiff/yaml v0.0.9 // indirect
+	github.com/oasdiff/yaml3 v0.0.9 // indirect
+	github.com/perimeterx/marshmallow v1.1.5 // indirect
+	github.com/woodsbury/decimal128 v1.3.0 // indirect
 	golang.org/x/crypto v0.17.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
 	golang.org/x/sys v0.15.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

mail/go.sum

@@ -39,6 +39,16 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
 github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
+github.com/getkin/kin-openapi v0.135.0 h1:751SjYfbiwqukYuVjwYEIKNfrSwS5YpA7DZnKSwQgtg=
+github.com/getkin/kin-openapi v0.135.0/go.mod h1:6dd5FJl6RdX4usBtFBaQhk9q62Yb2J0Mk5IhUO/QqFI=
+github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
+github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
+github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=
+github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
+github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM=
+github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
@@ -47,13 +57,35 @@ github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
 github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
+github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
+github.com/oasdiff/yaml v0.0.9 h1:zQOvd2UKoozsSsAknnWoDJlSK4lC0mpmjfDsfqNwX48=
+github.com/oasdiff/yaml v0.0.9/go.mod h1:8lvhgJG4xiKPj3HN5lDow4jZHPlx1i7dIwzkdAo6oAM=
+github.com/oasdiff/yaml3 v0.0.9 h1:rWPrKccrdUm8J0F3sGuU+fuh9+1K/RdJlWF7O/9yw2g=
+github.com/oasdiff/yaml3 v0.0.9/go.mod h1:y5+oSEHCPT/DGrS++Wc/479ERge0zTFxaF8PbGKcg2o=
+github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s=
+github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/ugorji/go/codec v1.2.7 h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=
+github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
+github.com/woodsbury/decimal128 v1.3.0 h1:8pffMNWIlC0O5vbyHWFZAt5yWvWcrHA+3ovIIjVWss0=
+github.com/woodsbury/decimal128 v1.3.0/go.mod h1:C5UTmyTjW3JftjUFzOVhC20BEQa2a4ZKOB5I6Zjb+ds=
 golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
 golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
@@ -63,6 +95,8 @@ golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mail/internal/healthcheck/checks.go

@@ -0,0 +1,56 @@
+package healthcheck
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
+)
+
+// DatabaseCheck prüft die Erreichbarkeit der Tenant-Postgres-Datenbank
+// (Akzeptanzkriterium 1: Datenbank).
+func DatabaseCheck(pool *pgxpool.Pool) CheckFunc {
+	return func(ctx context.Context) error {
+		return pool.Ping(ctx)
+	}
+}
+
+// ObjectStorageCheck prüft die Erreichbarkeit des mandantenspezifischen
+// Objekt-Storage-Buckets (ARC-06) — Akzeptanzkriterium 1:
+// Objektspeicher.
+func ObjectStorageCheck(s3Admin *s3.Client, bucket string) CheckFunc {
+	return func(ctx context.Context) error {
+		_, err := s3Admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)})
+		return err
+	}
+}
+
+// SearchIndexCheck prüft die Erreichbarkeit des Manticore-Suchindex
+// (SRC-01) — Akzeptanzkriterium 1: Suchindex. Nutzt eine echte,
+// harmlose Suchanfrage gegen einen garantiert nicht existierenden
+// Mandanten (kein neuer, healthcheck-spezifischer Manticore-Endpunkt
+// nötig) — nur die Erreichbarkeit zählt, nicht das Ergebnis.
+func SearchIndexCheck(client *search.Client) CheckFunc {
+	return func(ctx context.Context) error {
+		_, err := client.Search(ctx, "healthcheck-probe-kein-echter-mandant", "")
+		return err
+	}
+}
+
+// JobQueueCheck prüft die Erreichbarkeit der Postgres-Jobqueue
+// (SRC-02, mail_index_jobs) — Akzeptanzkriterium 1: Jobqueue. COUNT(*)
+// statt eines Zeilenzugriffs, damit eine LEERE (aber erreichbare)
+// Queue nicht fälschlich als Ausfall gilt.
+func JobQueueCheck(pool *pgxpool.Pool) CheckFunc {
+	return func(ctx context.Context) error {
+		var count int64
+		if err := pool.QueryRow(ctx, "SELECT count(*) FROM mail_index_jobs").Scan(&count); err != nil {
+			return fmt.Errorf("healthcheck: jobqueue: %w", err)
+		}
+		return nil
+	}
+}

mail/internal/healthcheck/checks_test.go

@@ -0,0 +1,149 @@
+// Integrationstests (INT-07): echte Postgres-, MinIO- und
+// Manticore-Instanzen, gleiche Umgebungsvariablen-Konvention wie
+// mail/internal/storage (TEST_S3_...) und mail/internal/folderstate
+// (TEST_TENANT_DSN).
+package healthcheck
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+// TestDatabaseCheck_RealPostgres ist Teil der geforderten
+// Pflichtprüfung "je Komponente getrennt" (Akzeptanzkriterium 1) —
+// gegen eine echte, laufende Postgres-Instanz.
+func TestDatabaseCheck_RealPostgres(t *testing.T) {
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	check := DatabaseCheck(pool)
+	if err := check(context.Background()); err != nil {
+		t.Fatalf("DatabaseCheck gegen echte instanz fehlgeschlagen: %v", err)
+	}
+}
+
+// TestJobQueueCheck_RealPostgres prüft die Jobqueue-Erreichbarkeit
+// gegen eine echte Instanz — inklusive Schema-Anlage, damit der Test
+// unabhängig davon läuft, ob indexworker bereits initialisiert wurde.
+func TestJobQueueCheck_RealPostgres(t *testing.T) {
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+	if _, err := pool.Exec(context.Background(), `
+		CREATE TABLE IF NOT EXISTS mail_index_jobs (
+			id SERIAL PRIMARY KEY,
+			job_type TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'pending'
+		)
+	`); err != nil {
+		t.Fatalf("mail_index_jobs anlegen: %v", err)
+	}
+
+	check := JobQueueCheck(pool)
+	if err := check(context.Background()); err != nil {
+		t.Fatalf("JobQueueCheck gegen echte instanz fehlgeschlagen: %v", err)
+	}
+}
+
+// TestObjectStorageCheck_RealMinIO prüft die Objektspeicher-
+// Erreichbarkeit gegen eine echte MinIO-Instanz (echtes, per ARC-06
+// provisioniertes Bucket).
+func TestObjectStorageCheck_RealMinIO(t *testing.T) {
+	endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	if endpoint == "" {
+		t.Skip("TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
+	}
+	admin, err := storage.NewS3AdminClient(context.Background(), "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("s3-admin-client: %v", err)
+	}
+
+	tenant := "mandant-int07-healthcheck"
+	realBucket, err := storage.ProvisionTenant(context.Background(), mustRegistryPool(t), admin, tenant, "INT-07 Healthcheck", "postgresql://healthcheck")
+	if err != nil {
+		t.Fatalf("ProvisionTenant: %v", err)
+	}
+	t.Cleanup(func() {
+		ctx := context.Background()
+		out, err := admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(realBucket)})
+		if err == nil {
+			for _, obj := range out.Contents {
+				_, _ = admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(realBucket), Key: obj.Key})
+			}
+		}
+		_, _ = admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(realBucket)})
+	})
+
+	check := ObjectStorageCheck(admin, realBucket)
+	if err := check(context.Background()); err != nil {
+		t.Fatalf("ObjectStorageCheck gegen echtes bucket fehlgeschlagen: %v", err)
+	}
+}
+
+func mustRegistryPool(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(pool.Close)
+	if _, err := pool.Exec(context.Background(), `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)
+	`); err != nil {
+		t.Fatalf("tenants-tabelle anlegen: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug = 'mandant-int07-healthcheck'`)
+	})
+	return pool
+}
+
+// TestSearchIndexCheck_RealManticore prüft die Suchindex-Erreichbarkeit
+// gegen eine echte Manticore-Instanz.
+func TestSearchIndexCheck_RealManticore(t *testing.T) {
+	baseURL := os.Getenv("TEST_MANTICORE_URL")
+	if baseURL == "" {
+		t.Skip("TEST_MANTICORE_URL nicht gesetzt, Integrationstest übersprungen")
+	}
+	client := search.NewClient(baseURL)
+	if err := client.EnsureSchema(context.Background()); err != nil {
+		t.Fatalf("schema sicherstellen: %v", err)
+	}
+
+	check := SearchIndexCheck(client)
+	if err := check(context.Background()); err != nil {
+		t.Fatalf("SearchIndexCheck gegen echte instanz fehlgeschlagen: %v", err)
+	}
+}

mail/internal/healthcheck/healthcheck.go

@@ -0,0 +1,110 @@
+// Package healthcheck implementiert INT-07: den Health-Check-Endpunkt
+// für das Mail-Modul (Erreichbarkeit von Datenbank, Objektspeicher,
+// Suchindex und Jobqueue, getrennt gemeldet).
+//
+// Core API-01 (REST-Grundgerüst) hat im aktuellen Repository-Stand
+// keinen abrufbaren Router (gleiche Situation wie bei ARC-06/Core
+// TEN-01 und mail/internal/mailapi, INT-01) — RegisterRoutes
+// registriert den Endpunkt deshalb auf einem vom Aufrufer
+// bereitgestellten *http.ServeMux mit demselben Pfadschema
+// "/api/v1/mail/..." wie mailapi.
+package healthcheck
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"sync"
+)
+
+// Status-Werte (Akzeptanzkriterium 3: "degraded" statt generischem
+// Fehler).
+const (
+	StatusOK       = "ok"
+	StatusDegraded = "degraded"
+)
+
+// CheckFunc prüft EINE Abhängigkeit. Ein Fehler bedeutet "nicht
+// erreichbar" — der Fehlertext selbst landet NIE in der HTTP-Antwort
+// (Akzeptanzkriterium 2: keine sensiblen Konfigurationsdetails),
+// höchstens im Server-Log des Aufrufers.
+type CheckFunc func(ctx context.Context) error
+
+// namedCheck bindet einen Komponentennamen an seine Prüffunktion, in
+// registrierter Reihenfolge (deterministische Antwortreihenfolge).
+type namedCheck struct {
+	name string
+	fn   CheckFunc
+}
+
+// Checker sammelt benannte Abhängigkeitsprüfungen.
+type Checker struct {
+	mu     sync.Mutex
+	checks []namedCheck
+}
+
+func NewChecker() *Checker {
+	return &Checker{}
+}
+
+// Register fügt eine benannte Prüfung hinzu (Akzeptanzkriterium 1: je
+// Komponente getrennt gemeldet).
+func (c *Checker) Register(name string, fn CheckFunc) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.checks = append(c.checks, namedCheck{name: name, fn: fn})
+}
+
+// ComponentStatus ist der Status EINER geprüften Abhängigkeit — ohne
+// Fehlertext (Akzeptanzkriterium 2).
+type ComponentStatus struct {
+	Name   string `json:"name"`
+	Status string `json:"status"`
+}
+
+// Result ist die vollständige Health-Antwort.
+type Result struct {
+	Status     string            `json:"status"`
+	Components []ComponentStatus `json:"components"`
+}
+
+// Check führt alle registrierten Prüfungen aus (Akzeptanzkriterium 1:
+// getrennt je Komponente). Gesamtstatus ist "degraded", sobald
+// MINDESTENS eine Komponente fehlschlägt (Akzeptanzkriterium 3).
+func (c *Checker) Check(ctx context.Context) Result {
+	c.mu.Lock()
+	checks := make([]namedCheck, len(c.checks))
+	copy(checks, c.checks)
+	c.mu.Unlock()
+
+	result := Result{Status: StatusOK, Components: make([]ComponentStatus, 0, len(checks))}
+	for _, nc := range checks {
+		status := StatusOK
+		if err := nc.fn(ctx); err != nil {
+			status = StatusDegraded
+			result.Status = StatusDegraded
+		}
+		result.Components = append(result.Components, ComponentStatus{Name: nc.name, Status: status})
+	}
+	return result
+}
+
+// ServeHTTP liefert den Health-Status als JSON. Ohne Authentifizierung
+// erreichbar (Akzeptanzkriterium 2) — der Inhalt selbst enthält
+// ausschließlich Komponentenname + ok/degraded, nie Fehlertexte,
+// Verbindungszeichenfolgen oder sonstige Konfigurationsdetails.
+func (c *Checker) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	result := c.Check(r.Context())
+	status := http.StatusOK
+	if result.Status == StatusDegraded {
+		status = http.StatusServiceUnavailable
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(result)
+}
+
+// RegisterRoutes registriert den Health-Endpunkt auf mux.
+func (c *Checker) RegisterRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /api/v1/mail/health", c.ServeHTTP)
+}

mail/internal/healthcheck/healthcheck_test.go

@@ -0,0 +1,133 @@
+package healthcheck
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// TestCheck_SimulatedDependencyFailureReflectedCorrectly ist die
+// geforderte Pflichtprüfung 1 (INT-07): simulierter Ausfall einer
+// Abhängigkeit wird korrekt im Health-Status abgebildet.
+func TestCheck_SimulatedDependencyFailureReflectedCorrectly(t *testing.T) {
+	c := NewChecker()
+	c.Register("database", func(context.Context) error { return nil })
+	c.Register("object_storage", func(context.Context) error { return errors.New("bucket nicht erreichbar") })
+	c.Register("search_index", func(context.Context) error { return nil })
+	c.Register("jobqueue", func(context.Context) error { return nil })
+
+	result := c.Check(context.Background())
+
+	if result.Status != StatusDegraded {
+		t.Fatalf("erwartete gesamtstatus %q bei einem ausgefallenen abhängigkeit, habe %q", StatusDegraded, result.Status)
+	}
+	if len(result.Components) != 4 {
+		t.Fatalf("erwartete 4 komponenten, habe %d", len(result.Components))
+	}
+	for _, comp := range result.Components {
+		want := StatusOK
+		if comp.Name == "object_storage" {
+			want = StatusDegraded
+		}
+		if comp.Status != want {
+			t.Fatalf("komponente %q: erwartete status %q, habe %q", comp.Name, want, comp.Status)
+		}
+	}
+}
+
+// TestCheck_AllHealthyReportsOK stellt sicher, dass ein vollständig
+// gesunder Zustand nicht fälschlich als degraded gilt.
+func TestCheck_AllHealthyReportsOK(t *testing.T) {
+	c := NewChecker()
+	c.Register("database", func(context.Context) error { return nil })
+	c.Register("object_storage", func(context.Context) error { return nil })
+
+	result := c.Check(context.Background())
+	if result.Status != StatusOK {
+		t.Fatalf("erwartete %q, habe %q", StatusOK, result.Status)
+	}
+}
+
+// TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails ist die
+// geforderte Pflichtprüfung 2 (INT-07): Health-Antwort enthält keine
+// sensiblen Konfigurationsdetails — ein absichtlich mit einer
+// Verbindungszeichenfolge/einem Geheimnis versehener Prüffehler darf
+// NIRGENDS in der HTTP-Antwort auftauchen.
+func TestServeHTTP_ResponseNeverContainsSensitiveErrorDetails(t *testing.T) {
+	const secretDSN = "postgresql://nexarch:s3hr-geheimes-passwort@db.internal:5432/tenant_x"
+	c := NewChecker()
+	c.Register("database", func(context.Context) error {
+		return errors.New("verbindung fehlgeschlagen: " + secretDSN)
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
+	rec := httptest.NewRecorder()
+	c.ServeHTTP(rec, req)
+
+	body := rec.Body.String()
+	if strings.Contains(body, secretDSN) || strings.Contains(body, "geheimes-passwort") {
+		t.Fatalf("health-antwort enthält sensible details: %s", body)
+	}
+
+	var parsed Result
+	if err := json.Unmarshal(rec.Body.Bytes(), &parsed); err != nil {
+		t.Fatalf("antwort ist kein gültiges JSON: %v", err)
+	}
+	if parsed.Status != StatusDegraded {
+		t.Fatalf("erwartete degraded, habe %q", parsed.Status)
+	}
+	if rec.Code != http.StatusServiceUnavailable {
+		t.Fatalf("erwartete HTTP 503 bei degraded, habe %d", rec.Code)
+	}
+}
+
+// TestServeHTTP_HealthyReturns200 bestätigt den positiven HTTP-Status.
+func TestServeHTTP_HealthyReturns200(t *testing.T) {
+	c := NewChecker()
+	c.Register("database", func(context.Context) error { return nil })
+
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/mail/health", nil)
+	rec := httptest.NewRecorder()
+	c.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("erwartete HTTP 200, habe %d", rec.Code)
+	}
+}
+
+// TestIntegration_RealHTTPEndpointAfterDeploy ist die geforderte
+// Pflichtprüfung 3 (INT-07): Integrationstest gegen einen echten,
+// laufenden Health-Endpunkt (realer HTTP-Server, reale Anfrage über
+// das Netzwerk — kein direkter Funktionsaufruf).
+func TestIntegration_RealHTTPEndpointAfterDeploy(t *testing.T) {
+	c := NewChecker()
+	c.Register("database", func(context.Context) error { return nil })
+	c.Register("object_storage", func(context.Context) error { return nil })
+	c.Register("search_index", func(context.Context) error { return nil })
+	c.Register("jobqueue", func(context.Context) error { return nil })
+
+	mux := http.NewServeMux()
+	c.RegisterRoutes(mux)
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	resp, err := http.Get(srv.URL + "/api/v1/mail/health")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
+	}
+	var result Result
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if result.Status != StatusOK || len(result.Components) != 4 {
+		t.Fatalf("unerwartetes ergebnis: %+v", result)
+	}
+}

mail/internal/importnotify/importnotify.go

@@ -0,0 +1,52 @@
+// Package importnotify verbindet mail/internal/imapimport (ING-01/IMP-01)
+// mit mail/internal/notifyclient (INT-05, Core CFG-02/CFG-05):
+// genau EINE Benachrichtigung je abgeschlossenem Abgleichslauf
+// (imapimport.SyncResult), nicht eine je neuer Nachricht
+// (Akzeptanzkriterium 3: gebündelt statt Flut bei Massenimport).
+package importnotify
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/imapimport"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/notifyclient"
+)
+
+// eventTypeMailNew ist der bei Core registrierte Ereignistyp für neu
+// importierte Mails.
+const eventTypeMailNew = "mail.new"
+
+// Notifier ist die für NotifyBatch benötigte Teilmenge von
+// *notifyclient.Client — als Schnittstelle für Tests ohne echten HTTP-
+// Server.
+type Notifier interface {
+	Notify(ctx context.Context, ev notifyclient.Event) error
+}
+
+// NotifyBatch löst — falls result.NewMessages > 0 — GENAU EINE
+// Benachrichtigung für den gesamten Abgleichslauf aus
+// (Akzeptanzkriterium 1: neue Mail löst zeitnah ein Ereignis aus;
+// Akzeptanzkriterium 3: Massenimport erzeugt eine gebündelte
+// Zusammenfassung statt Dutzende Einzelbenachrichtigungen — es gibt in
+// diesem Paket schlicht KEINEN Codepfad, der mehr als einen Notify-
+// Aufruf je Abgleichslauf absetzt). Bei result.NewMessages == 0 wird
+// nichts gesendet.
+//
+// Ein Fehler beim Senden wird zurückgeliefert, blockiert aber
+// strukturell NIE die bereits abgeschlossene Nachrichtenübernahme —
+// NotifyBatch wird vom Aufrufer NACH dem erfolgreichen
+// imapimport.RunOnce aufgerufen, nie währenddessen, und ein Fehler
+// hier nimmt keine bereits persistierte Nachricht zurück.
+func NotifyBatch(ctx context.Context, notifier Notifier, tenantSlug, mailboxName string, result imapimport.SyncResult) error {
+	if result.NewMessages == 0 {
+		return nil
+	}
+	summary := fmt.Sprintf("%d neue Mail(s) in %s", result.NewMessages, mailboxName)
+	return notifier.Notify(ctx, notifyclient.Event{
+		TenantSlug: tenantSlug,
+		EventType:  eventTypeMailNew,
+		Summary:    summary,
+		Count:      result.NewMessages,
+	})
+}

mail/internal/importnotify/importnotify_test.go

@@ -0,0 +1,101 @@
+package importnotify
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/imapimport"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/notifyclient"
+)
+
+type recordingNotifier struct {
+	mu     sync.Mutex
+	events []notifyclient.Event
+}
+
+func (r *recordingNotifier) Notify(_ context.Context, ev notifyclient.Event) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.events = append(r.events, ev)
+	return nil
+}
+
+func (r *recordingNotifier) count() int {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return len(r.events)
+}
+
+// TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification ist
+// die geforderte Pflichtprüfung 1 (INT-05): Import einer Mail löst
+// genau eine Benachrichtigung aus.
+func TestNotifyBatch_SingleNewMessageTriggersExactlyOneNotification(t *testing.T) {
+	n := &recordingNotifier{}
+	err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 1})
+	if err != nil {
+		t.Fatalf("NotifyBatch: %v", err)
+	}
+	if n.count() != 1 {
+		t.Fatalf("erwartete genau 1 benachrichtigung, habe %d", n.count())
+	}
+	if n.events[0].Count != 1 || n.events[0].TenantSlug != "mandant-a" {
+		t.Fatalf("unerwartetes ereignis: %+v", n.events[0])
+	}
+}
+
+// TestNotifyBatch_MassImportProducesOneBundledNotification ist die
+// geforderte Pflichtprüfung 2 (INT-05): Massenimport erzeugt eine
+// gebündelte Zusammenfassung statt Dutzende Einzelbenachrichtigungen.
+func TestNotifyBatch_MassImportProducesOneBundledNotification(t *testing.T) {
+	n := &recordingNotifier{}
+	err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 50})
+	if err != nil {
+		t.Fatalf("NotifyBatch: %v", err)
+	}
+	if n.count() != 1 {
+		t.Fatalf("erwartete genau 1 GEBÜNDELTE benachrichtigung für 50 neue nachrichten, habe %d einzelne", n.count())
+	}
+	if n.events[0].Count != 50 {
+		t.Fatalf("erwartete gebündelte anzahl 50, habe %d", n.events[0].Count)
+	}
+}
+
+// TestNotifyBatch_NoNewMessagesSendsNothing stellt sicher, dass ein
+// Abgleichslauf ohne neue Nachrichten keine Benachrichtigung auslöst.
+func TestNotifyBatch_NoNewMessagesSendsNothing(t *testing.T) {
+	n := &recordingNotifier{}
+	if err := NotifyBatch(context.Background(), n, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 0}); err != nil {
+		t.Fatalf("NotifyBatch: %v", err)
+	}
+	if n.count() != 0 {
+		t.Fatalf("erwartete keine benachrichtigung ohne neue nachrichten, habe %d", n.count())
+	}
+}
+
+// TestNotifyBatch_DisabledNotificationDeliversNothing ist die
+// geforderte Pflichtprüfung 3 (INT-05): deaktivierte Benachrichtigung
+// erzeugt keine Zustellung — real gegen einen echten HTTP-Server
+// geprüft, der den CFG-05-Vertrag nachbildet: 204 bedeutet "durch
+// Benutzerpräferenz unterdrückt". NotifyBatch ruft trotzdem exakt
+// einmal auf (die Unterdrückungsentscheidung liegt bei Core, nicht bei
+// Mail), der Aufruf selbst liefert keinen Fehler.
+func TestNotifyBatch_DisabledNotificationDeliversNothing(t *testing.T) {
+	var callCount int
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		callCount++
+		w.WriteHeader(http.StatusNoContent) // "durch benutzerpräferenz unterdrückt"
+	}))
+	defer srv.Close()
+
+	client := notifyclient.NewClient(srv.URL, "test-service-token")
+	err := NotifyBatch(context.Background(), client, "mandant-a", "INBOX", imapimport.SyncResult{NewMessages: 1})
+	if err != nil {
+		t.Fatalf("NotifyBatch: %v", err)
+	}
+	if callCount != 1 {
+		t.Fatalf("erwartete genau 1 aufruf an den (unterdrückenden) server, habe %d", callCount)
+	}
+}

mail/internal/ingestiontestgate/gate.go

@@ -0,0 +1,232 @@
+// Package ingestiontestgate implementiert QA-02: das Prüfgate für
+// Ingestion & Import — spiegelt das Muster aus mail/internal/qagate
+// (QA-03) und mail/internal/importtestgate (IMP-09), hier bezogen auf
+// ALLE Ingestion-/Import-Pakete zusammen (Protokoll-Server, Fehler-
+// behandlung/Logging, Import-Pfade).
+package ingestiontestgate
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// IngestionAndImportPackages sind alle Pakete, deren Testsuiten das
+// Gate ausführt (Akzeptanzkriterium 1) — abgeleitet aus QA-02s
+// dependsOn-Liste: ING-10 (Protokoll-Server + MIME + Folder-State),
+// ING-07 (Fehlerbehandlung, protoguard), ING-08 (Logging, protolog),
+// IMP-04/IMP-09 (imapimport), IMP-05 (hotfolder), IMP-06 (virusscan),
+// IMP-07 (mailboxconfig), IMP-08 (syncalert). attachments/mailrules
+// gehören ebenfalls zum von IMP-09 geprüften Importpfad.
+var IngestionAndImportPackages = []string{
+	"./internal/imap/...",
+	"./internal/pop3/...",
+	"./internal/smtp/...",
+	"./internal/protoguard/...",
+	"./internal/protolog/...",
+	"./internal/mimeparse/...",
+	"./internal/folderstate/...",
+	"./internal/imapimport/...",
+	"./internal/attachments/...",
+	"./internal/mailrules/...",
+	"./internal/hotfolder/...",
+	"./internal/virusscan/...",
+	"./internal/mailboxconfig/...",
+	"./internal/syncalert/...",
+}
+
+// TestSuiteResult ist das Ergebnis eines `go test`-Laufs über
+// IngestionAndImportPackages.
+type TestSuiteResult struct {
+	Passed bool
+	Output string
+}
+
+// RunTestSuites führt `go test` über IngestionAndImportPackages im
+// angegebenen Modulverzeichnis aus (Akzeptanzkriterium 1). Umgebungs-
+// variablen (TEST_TENANT_DSN u. Ä.) werden unverändert vom aufrufenden
+// Prozess vererbt — das Gate setzt selbst keine Zugangsdaten.
+func RunTestSuites(ctx context.Context, moduleDir string) (TestSuiteResult, error) {
+	// -p 1: Pakete NACHEINANDER statt parallel — mehrere gleichzeitige
+	// go-test-Binaries würden sich bei den echten QA-07-Lasttests
+	// (imap/pop3/smtp) gegenseitig CPU-Kontingent wegnehmen und so
+	// Latenz-Zielwerte durch reine Testhost-Überlastung verfehlen
+	// lassen, nicht durch einen echten Regressionsfehler.
+	args := append([]string{"test", "-count=1", "-p", "1"}, IngestionAndImportPackages...)
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = moduleDir
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &out
+	err := cmd.Run()
+	if err != nil {
+		if _, isExitErr := err.(*exec.ExitError); !isExitErr {
+			return TestSuiteResult{}, fmt.Errorf("ingestiontestgate: go test ausführen: %w", err)
+		}
+	}
+	return TestSuiteResult{Passed: err == nil, Output: out.String()}, nil
+}
+
+// KnownErrorPoint ist ein bekannter, historisch dokumentierter
+// Fehlerpunkt (Akzeptanzkriterium 2), der durch mindestens einen
+// benannten Regressionstest abgedeckt sein muss.
+type KnownErrorPoint struct {
+	Name           string // z. B. "Header-Injection"
+	PackageRelDir  string // relativ zu moduleDir, z. B. "internal/mailer"
+	TestNameMarker string // Teilzeichenkette, die im Testfunktionsnamen vorkommen muss
+	Rationale      string // kurze Begründung, warum dieser Punkt bekannt kritisch ist
+}
+
+// knownErrorPoints sind die drei in QA-02 Akzeptanzkriterium 2 namentlich
+// geforderten Fehlerpunkte.
+var knownErrorPoints = []KnownErrorPoint{
+	{
+		Name:           "Header-Injection",
+		PackageRelDir:  "internal/mailer",
+		TestNameMarker: "CRLF",
+		Rationale:      "known-issues-archivmail.md #1: From/To/Subject per Stringkonkatenation ohne CRLF-Prüfung",
+	},
+	{
+		Name:           "Anhang-Limit",
+		PackageRelDir:  "internal/mimeparse",
+		TestNameMarker: "OversizedAttachment",
+		Rationale:      "known-issues-archivmail.md #3: Anhänge ohne Größenlimit gelesen (Speicherbombe)",
+	},
+	{
+		Name:           "UIDVALIDITY",
+		PackageRelDir:  "internal/folderstate",
+		TestNameMarker: "UIDValidity",
+		Rationale:      "ING-01/repos-analyse-mail-reuse.md: archivmail brach Resync bei UIDVALIDITY=0 nicht-konformer Server",
+	},
+}
+
+// KnownErrorPointResult ist das Ergebnis der Prüfung EINES bekannten
+// Fehlerpunkts.
+type KnownErrorPointResult struct {
+	Point       KnownErrorPoint
+	Covered     bool
+	FoundInFile string
+	TestName    string
+}
+
+// KnownErrorPointsResult fasst die Stichprobenprüfung aller bekannten
+// Fehlerpunkte zusammen (Akzeptanzkriterium 2, Pflichtprüfung 2:
+// "mindestens ein Regressionstest je bekanntem Fehlerpunkt").
+type KnownErrorPointsResult struct {
+	Passed  bool
+	Results []KnownErrorPointResult
+}
+
+// ScanForKnownErrorPointTests prüft für jeden bekannten Fehlerpunkt, ob
+// im angegebenen Paketverzeichnis mindestens eine _test.go-Datei eine
+// Testfunktion enthält, deren Name den TestNameMarker enthält.
+func ScanForKnownErrorPointTests(moduleDir string) (KnownErrorPointsResult, error) {
+	out := KnownErrorPointsResult{Passed: true}
+
+	for _, point := range knownErrorPoints {
+		dir := filepath.Join(moduleDir, point.PackageRelDir)
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			return KnownErrorPointsResult{}, fmt.Errorf("ingestiontestgate: %s lesen: %w", dir, err)
+		}
+		res := KnownErrorPointResult{Point: point}
+		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 KnownErrorPointsResult{}, fmt.Errorf("ingestiontestgate: %s lesen: %w", e.Name(), err)
+			}
+			if testName, ok := findTestFuncContaining(string(content), point.TestNameMarker); ok {
+				res.Covered = true
+				res.FoundInFile = e.Name()
+				res.TestName = testName
+				break
+			}
+		}
+		if !res.Covered {
+			out.Passed = false
+		}
+		out.Results = append(out.Results, res)
+	}
+	return out, nil
+}
+
+// findTestFuncContaining sucht die erste "func TestXxx(" -Zeile, deren
+// Funktionsname marker enthält.
+func findTestFuncContaining(source, marker string) (string, bool) {
+	for _, line := range strings.Split(source, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if !strings.HasPrefix(trimmed, "func Test") {
+			continue
+		}
+		parenIdx := strings.Index(trimmed, "(")
+		if parenIdx < 0 {
+			continue
+		}
+		name := strings.TrimPrefix(trimmed[:parenIdx], "func ")
+		if strings.Contains(name, marker) {
+			return name, true
+		}
+	}
+	return "", false
+}
+
+// GateResult fasst ein vollständiges QA-02-Gate-Ergebnis zusammen
+// (Akzeptanzkriterium 3: dokumentiert, mit Zeitstempel).
+type GateResult struct {
+	Timestamp        time.Time
+	TestSuite        TestSuiteResult
+	KnownErrorPoints KnownErrorPointsResult
+}
+
+// Passed ist true, wenn ALLE Kriterien erfüllt sind.
+func (r GateResult) Passed() bool {
+	return r.TestSuite.Passed && r.KnownErrorPoints.Passed
+}
+
+// Run führt das vollständige Gate aus.
+func Run(ctx context.Context, moduleDir string) (GateResult, error) {
+	testResult, err := RunTestSuites(ctx, moduleDir)
+	if err != nil {
+		return GateResult{}, err
+	}
+	errorPointsResult, err := ScanForKnownErrorPointTests(moduleDir)
+	if err != nil {
+		return GateResult{}, err
+	}
+	return GateResult{
+		Timestamp:        time.Now().UTC(),
+		TestSuite:        testResult,
+		KnownErrorPoints: errorPointsResult,
+	}, nil
+}
+
+// Report erzeugt den dokumentierten, zeitgestempelten Gate-Bericht
+// (Akzeptanzkriterium 3).
+func (r GateResult) Report() string {
+	status := "BESTANDEN"
+	if !r.Passed() {
+		status = "FEHLGESCHLAGEN"
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "# QA-02 Gate-Ergebnis: %s\n\n", status)
+	fmt.Fprintf(&b, "Zeitstempel (UTC): %s\n\n", r.Timestamp.Format(time.RFC3339))
+	fmt.Fprintf(&b, "## Testsuiten (Ingestion & Import, %d Pakete)\n\nBestanden: %v\n\n", len(IngestionAndImportPackages), r.TestSuite.Passed)
+	fmt.Fprintf(&b, "## Bekannte Fehlerpunkte — Regressionstest-Stichprobe\n\n")
+	for _, res := range r.KnownErrorPoints.Results {
+		fmt.Fprintf(&b, "- %s (%s): abgedeckt=%v", res.Point.Name, res.Point.Rationale, res.Covered)
+		if res.Covered {
+			fmt.Fprintf(&b, " — %s in %s/%s\n", res.TestName, res.Point.PackageRelDir, res.FoundInFile)
+		} else {
+			fmt.Fprintf(&b, "\n")
+		}
+	}
+	return b.String()
+}

mail/internal/ingestiontestgate/gate_test.go

@@ -0,0 +1,119 @@
+package ingestiontestgate
+
+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)
+	}
+	// gate_test.go liegt in internal/ingestiontestgate — Modulwurzel ist
+	// zwei Ebenen darüber.
+	return filepath.Join(wd, "..", "..")
+}
+
+// TestScanForKnownErrorPointTests_RealPackagesAllCovered ist die
+// geforderte Pflichtprüfung 2: Stichprobe, mindestens ein
+// Regressionstest je bekanntem Fehlerpunkt — automatisiert und
+// reproduzierbar gegen den echten Quelltext ausgeführt.
+func TestScanForKnownErrorPointTests_RealPackagesAllCovered(t *testing.T) {
+	root := moduleRoot(t)
+	result, err := ScanForKnownErrorPointTests(root)
+	if err != nil {
+		t.Fatalf("scan: %v", err)
+	}
+	if !result.Passed {
+		for _, r := range result.Results {
+			if !r.Covered {
+				t.Errorf("bekannter fehlerpunkt %q (%s) hat KEINEN passenden regressionstest in %s gefunden", r.Point.Name, r.Point.Rationale, r.Point.PackageRelDir)
+			}
+		}
+		t.FailNow()
+	}
+	for _, r := range result.Results {
+		t.Logf("%s: %s (%s/%s)", r.Point.Name, r.TestName, r.Point.PackageRelDir, r.FoundInFile)
+	}
+}
+
+// TestScanForKnownErrorPointTests_DetectsMissingCoverage beweist, dass
+// der Scanner einen tatsächlich fehlenden Regressionstest auch real
+// erkennt (Negativtest) — ein Gate, das nie eine Lücke melden kann,
+// wäre wertlos.
+func TestScanForKnownErrorPointTests_DetectsMissingCoverage(t *testing.T) {
+	dir := t.TempDir()
+	// Nur EIN Paketverzeichnis anlegen (für "Header-Injection"), die
+	// beiden anderen bekannten Fehlerpunkte bleiben absichtlich ohne
+	// Verzeichnis/Tests.
+	mailerDir := filepath.Join(dir, "internal", "mailer")
+	if err := os.MkdirAll(mailerDir, 0o750); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+	content := []byte("package mailer\n\nimport \"testing\"\n\nfunc TestRejectsCRLFInHeader(t *testing.T) {}\n")
+	if err := os.WriteFile(filepath.Join(mailerDir, "mailer_test.go"), content, 0o600); err != nil {
+		t.Fatalf("testdatei schreiben: %v", err)
+	}
+	// Leere Verzeichnisse für die anderen beiden Punkte, damit ReadDir
+	// nicht mit einem Fehler abbricht.
+	if err := os.MkdirAll(filepath.Join(dir, "internal", "mimeparse"), 0o750); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Join(dir, "internal", "folderstate"), 0o750); err != nil {
+		t.Fatalf("verzeichnis anlegen: %v", err)
+	}
+
+	result, err := ScanForKnownErrorPointTests(dir)
+	if err != nil {
+		t.Fatalf("scan: %v", err)
+	}
+	if result.Passed {
+		t.Fatal("erwartete erkannte lücke (2 von 3 fehlerpunkten unabgedeckt), scan meldet bestanden")
+	}
+	covered := 0
+	for _, r := range result.Results {
+		if r.Covered {
+			covered++
+		}
+	}
+	if covered != 1 {
+		t.Fatalf("erwartete genau 1 abgedeckten fehlerpunkt, habe %d", covered)
+	}
+}
+
+// TestRun_RealGateAgainstCurrentIngestionImportState ist die geforderte
+// Pflichtprüfung 1: Gate-Lauf gegen aktuellen Stand von ING-10/IMP-09
+// dokumentiert — führt das vollständige Gate real gegen den aktuellen
+// Modul-Quelltext aus (inklusive echter Postgres-Integrationstests) und
+// dokumentiert das Ergebnis mit Zeitstempel.
+func TestRun_RealGateAgainstCurrentIngestionImportState(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.Timestamp.IsZero() {
+		t.Fatal("erwarteter zeitstempel fehlt")
+	}
+	if !result.KnownErrorPoints.Passed {
+		t.Fatalf("bekannte fehlerpunkte nicht vollständig abgedeckt: %+v", result.KnownErrorPoints.Results)
+	}
+	if !result.TestSuite.Passed {
+		t.Fatalf("testsuiten fehlgeschlagen, ausgabe:\n%s", result.TestSuite.Output)
+	}
+
+	reportPath := filepath.Join(t.TempDir(), "qa-02-gate-report.md")
+	if err := os.WriteFile(reportPath, []byte(result.Report()), 0o600); err != nil {
+		t.Fatalf("bericht schreiben: %v", err)
+	}
+	t.Logf("Gate-Bericht (%s):\n%s", reportPath, result.Report())
+}

mail/internal/mailapi/mailapi.go

@@ -0,0 +1,238 @@
+// Package mailapi implementiert INT-01: die Mail-spezifischen
+// REST-Endpunkte (Mail-Liste, Mail-Detail, Anhang-Download) v1.
+//
+// Core API-01 (REST-API-Grundgerüst & Versionierung) und API-04
+// (OpenAPI-Schnittstellenbeschreibung) sind laut core-kanban zwar auf
+// "Fertig", enthalten im aktuellen Repository-Stand aber noch keinen
+// abrufbaren Router/keine Middleware, an die sich dieses Paket technisch
+// anhängen könnte (siehe Abgrenzung im INT-01-Prüfprotokoll — gleiche
+// Situation wie ARC-06/Core TEN-01). RegisterRoutes registriert daher
+// die v1-Endpunkte auf einem vom Aufrufer bereitgestellten
+// *http.ServeMux mit dem dokumentierten Pfadschema
+// "/api/v1/mail/..." — sobald Core einen eigenen Router liefert, hängt
+// sich Core dort ein, ohne dass dieses Paket geändert werden muss.
+//
+// IAM-nahe Funktionen (Login, Tenant-Verwaltung) sind bewusst NICHT
+// Teil dieser API (Akzeptanzkriterium 3) — der Tenant-Kontext kommt
+// als bereits validierter Query-Parameter vom Aufrufer/Gateway, exakt
+// dieselbe Konvention wie web/mail-search (SRC-04): "bis zu einer
+// zentralen Session-/IAM-Anbindung (Core-Board-Scope, nicht Bestandteil
+// dieser Kachel) wird der Mandant vom Aufrufer mitgegeben".
+package mailapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+// SearchClient ist die für diese API benötigte Teilmenge von
+// *search.Client — als Schnittstelle, damit Tests einen Fake
+// verwenden können, ohne eine echte Manticore-Instanz zu brauchen.
+type SearchClient interface {
+	Search(ctx context.Context, tenantSlug, queryText string) ([]search.Result, error)
+	GetByMessageID(ctx context.Context, tenantSlug, messageID string) (search.Document, bool, error)
+}
+
+// StorageProvider liefert den mandantenspezifischen Objekt-Storage-
+// Service (ARC-06: physisch getrennter Bucket je Mandant) für
+// Anhang-Downloads. Ein unbekannter tenantSlug liefert einen Fehler —
+// die Implementierung entscheidet, ob "unbekannt" bedeutet.
+type StorageProvider interface {
+	ServiceFor(tenantSlug string) (*storage.Service, error)
+}
+
+// Server bündelt die Abhängigkeiten der Mail-API v1.
+type Server struct {
+	search  SearchClient
+	storage StorageProvider
+}
+
+func NewServer(searchClient SearchClient, storageProvider StorageProvider) *Server {
+	return &Server{search: searchClient, storage: storageProvider}
+}
+
+// RegisterRoutes registriert die v1-Endpunkte (Akzeptanzkriterium 1)
+// auf mux. Pfadschema exakt wie im OpenAPI-Beitrag (openapi.yaml,
+// Akzeptanzkriterium 4) dokumentiert.
+func (s *Server) RegisterRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /api/v1/mail/messages", s.handleListMessages)
+	mux.HandleFunc("GET /api/v1/mail/messages/{messageID}", s.handleGetMessage)
+	mux.HandleFunc("GET /api/v1/mail/messages/{messageID}/attachments/{index}", s.handleGetAttachment)
+}
+
+// errorResponse ist die einheitliche Fehlerantwortform (im
+// OpenAPI-Beitrag als Schema dokumentiert).
+type errorResponse struct {
+	Error string `json:"error"`
+}
+
+func writeError(w http.ResponseWriter, status int, message string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(errorResponse{Error: message})
+}
+
+// requireTenant liest den Pflicht-Query-Parameter "tenant"
+// (Akzeptanzkriterium 2/Pflichtprüfung 1: Zugriff ohne gültigen
+// Tenant-Kontext wird abgelehnt). Ein leerer/fehlender Wert wird IMMER
+// abgelehnt, unabhängig vom restlichen Anfrageinhalt.
+func requireTenant(w http.ResponseWriter, r *http.Request) (string, bool) {
+	tenant := strings.TrimSpace(r.URL.Query().Get("tenant"))
+	if tenant == "" {
+		writeError(w, http.StatusBadRequest, "fehlender oder leerer tenant-kontext (query-parameter \"tenant\")")
+		return "", false
+	}
+	return tenant, true
+}
+
+// messageListItem ist ein Eintrag der Mail-Liste.
+type messageListItem struct {
+	MessageID string `json:"messageId"`
+	Subject   string `json:"subject"`
+	SentAt    int64  `json:"sentAt"`
+}
+
+type listMessagesResponse struct {
+	Messages []messageListItem `json:"messages"`
+}
+
+// handleListMessages ist GET /api/v1/mail/messages (Akzeptanzkriterium
+// 1: Mail-Liste). Optionaler Query-Parameter "q" filtert per Volltext,
+// wie mail/internal/search es ohnehin unterstützt.
+func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	query := r.URL.Query().Get("q")
+
+	results, err := s.search.Search(r.Context(), tenant, query)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, "suche fehlgeschlagen")
+		return
+	}
+
+	resp := listMessagesResponse{Messages: make([]messageListItem, 0, len(results))}
+	for _, res := range results {
+		resp.Messages = append(resp.Messages, messageListItem{
+			MessageID: res.MessageID,
+			Subject:   res.Subject,
+			SentAt:    res.SentAtUnixEpoch,
+		})
+	}
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// messageDetailResponse ist die Antwort von GET
+// /api/v1/mail/messages/{messageID}.
+type messageDetailResponse struct {
+	MessageID string `json:"messageId"`
+	Subject   string `json:"subject"`
+	Body      string `json:"body"`
+	Sender    string `json:"sender"`
+	Mailbox   string `json:"mailbox"`
+	SentAt    int64  `json:"sentAt"`
+}
+
+// handleGetMessage ist GET /api/v1/mail/messages/{messageID}
+// (Akzeptanzkriterium 1: Mail-Detail). Liefert 404, wenn die Nachricht
+// für DIESEN Mandanten nicht existiert — auch wenn sie für einen
+// ANDEREN Mandanten existiert (Akzeptanzkriterium 2: strikt
+// mandantengebunden, siehe search.Client.GetByMessageID).
+func (s *Server) handleGetMessage(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	messageID := r.PathValue("messageID")
+
+	doc, found, err := s.search.GetByMessageID(r.Context(), tenant, messageID)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, "abruf fehlgeschlagen")
+		return
+	}
+	if !found {
+		writeError(w, http.StatusNotFound, "nachricht nicht gefunden")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, messageDetailResponse{
+		MessageID: doc.MessageID,
+		Subject:   doc.Subject,
+		Body:      doc.Body,
+		Sender:    doc.Sender,
+		Mailbox:   doc.Mailbox,
+		SentAt:    doc.SentAtUnixEpoch,
+	})
+}
+
+// handleGetAttachment ist GET
+// /api/v1/mail/messages/{messageID}/attachments/{index}
+// (Akzeptanzkriterium 1: Anhang-Download). {index} ist der von
+// mail/internal/mimeparse beim Import vergebene Anhang-Index innerhalb
+// der Nachricht (dieselbe Zählung wie storage.ObjectKey).
+//
+// Akzeptanzkriterium 2 (strikt mandantengebunden) ist hier STRUKTURELL
+// garantiert, nicht nur durch einen Vergleich: StorageProvider liefert
+// für tenant AUSSCHLIESSLICH den physisch getrennten Bucket dieses
+// Mandanten (ARC-06) — ein falscher/fremder tenant-Parameter kann
+// technisch keinen fremden Bucket referenzieren, unabhängig davon, ob
+// die angefragte messageID dort zufällig ebenfalls existiert.
+func (s *Server) handleGetAttachment(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	messageID := r.PathValue("messageID")
+	indexStr := r.PathValue("index")
+	index, err := strconv.Atoi(indexStr)
+	if err != nil || index < 0 {
+		writeError(w, http.StatusBadRequest, "ungültiger anhang-index")
+		return
+	}
+
+	// Zuerst bestätigen, dass die Nachricht für DIESEN Mandanten
+	// überhaupt existiert — verhindert, dass eine geratene messageID
+	// eines fremden Mandanten (dessen Bucket hier ohnehin nicht
+	// referenzierbar wäre) einen irreführenden Fehlercode liefert.
+	if _, found, err := s.search.GetByMessageID(r.Context(), tenant, messageID); err != nil {
+		writeError(w, http.StatusBadGateway, "abruf fehlgeschlagen")
+		return
+	} else if !found {
+		writeError(w, http.StatusNotFound, "nachricht nicht gefunden")
+		return
+	}
+
+	svc, err := s.storage.ServiceFor(tenant)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "unbekannter mandant")
+		return
+	}
+
+	content, err := svc.GetVerified(r.Context(), storage.ObjectKey(messageID, index))
+	if err != nil {
+		if errors.Is(err, storage.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "anhang nicht gefunden")
+			return
+		}
+		writeError(w, http.StatusBadGateway, "anhang-abruf fehlgeschlagen")
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(content)
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}

mail/internal/mailapi/mailapi_test.go

@@ -0,0 +1,227 @@
+package mailapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+// fakeSearchClient ist ein In-Memory-Fake für SearchClient — Tests
+// brauchen keine echte Manticore-Instanz.
+type fakeSearchClient struct {
+	docsByTenant map[string]map[string]search.Document // tenant -> messageID -> doc
+}
+
+func newFakeSearchClient() *fakeSearchClient {
+	return &fakeSearchClient{docsByTenant: map[string]map[string]search.Document{}}
+}
+
+func (f *fakeSearchClient) put(tenant string, doc search.Document) {
+	if f.docsByTenant[tenant] == nil {
+		f.docsByTenant[tenant] = map[string]search.Document{}
+	}
+	f.docsByTenant[tenant][doc.MessageID] = doc
+}
+
+func (f *fakeSearchClient) Search(_ context.Context, tenantSlug, _ string) ([]search.Result, error) {
+	var results []search.Result
+	for _, doc := range f.docsByTenant[tenantSlug] {
+		results = append(results, search.Result{MessageID: doc.MessageID, Subject: doc.Subject, SentAtUnixEpoch: doc.SentAtUnixEpoch})
+	}
+	return results, nil
+}
+
+func (f *fakeSearchClient) GetByMessageID(_ context.Context, tenantSlug, messageID string) (search.Document, bool, error) {
+	doc, ok := f.docsByTenant[tenantSlug][messageID]
+	return doc, ok, nil
+}
+
+// fakeStorageProvider liefert je Mandant einen unabhängigen, in
+// LocalDriver gestützten Service — realistische Nachbildung der
+// physischen Bucket-Trennung aus ARC-06 ohne echtes S3.
+type fakeStorageProvider struct {
+	services map[string]*storage.Service
+}
+
+func newFakeStorageProvider(t *testing.T, tenants ...string) *fakeStorageProvider {
+	t.Helper()
+	p := &fakeStorageProvider{services: map[string]*storage.Service{}}
+	for _, tenant := range tenants {
+		p.services[tenant] = storage.NewService(storage.NewLocalDriver(t.TempDir()), noopUsageReporter{}, tenant)
+	}
+	return p
+}
+
+func (p *fakeStorageProvider) ServiceFor(tenantSlug string) (*storage.Service, error) {
+	svc, ok := p.services[tenantSlug]
+	if !ok {
+		return nil, errors.New("mailapi: unbekannter mandant")
+	}
+	return svc, nil
+}
+
+type noopUsageReporter struct{}
+
+func (noopUsageReporter) Report(context.Context, string, string, int64) error { return nil }
+
+func setupTestServer(t *testing.T) (*httptest.Server, *fakeSearchClient, *fakeStorageProvider) {
+	t.Helper()
+	sc := newFakeSearchClient()
+	sp := newFakeStorageProvider(t, "mandant-a", "mandant-b")
+	srv := NewServer(sc, sp)
+	mux := http.NewServeMux()
+	srv.RegisterRoutes(mux)
+	ts := httptest.NewServer(mux)
+	t.Cleanup(ts.Close)
+	return ts, sc, sp
+}
+
+// TestListMessages_RejectsMissingTenant ist die geforderte
+// Pflichtprüfung 1 (INT-01): Zugriff ohne gültigen Tenant-Kontext wird
+// abgelehnt — für alle drei Endpunkte geprüft.
+func TestListMessages_RejectsMissingTenant(t *testing.T) {
+	ts, _, _ := setupTestServer(t)
+
+	endpoints := []string{
+		"/api/v1/mail/messages",
+		"/api/v1/mail/messages/msg-1",
+		"/api/v1/mail/messages/msg-1/attachments/0",
+	}
+	for _, ep := range endpoints {
+		t.Run(ep, func(t *testing.T) {
+			resp, err := http.Get(ts.URL + ep) // ohne ?tenant=
+			if err != nil {
+				t.Fatalf("get: %v", err)
+			}
+			defer func() { _ = resp.Body.Close() }()
+			if resp.StatusCode != http.StatusBadRequest {
+				t.Fatalf("erwartete 400 ohne tenant-kontext, habe %d", resp.StatusCode)
+			}
+			var body errorResponse
+			if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+				t.Fatalf("fehlerantwort dekodieren: %v", err)
+			}
+			if body.Error == "" {
+				t.Fatalf("erwartete nicht-leere fehlermeldung")
+			}
+		})
+	}
+}
+
+// TestListMessages_ReturnsOnlyOwnTenantMessages ist der
+// Vertragstest für Akzeptanzkriterium 1+2 (Mail-Liste, strikt
+// mandantengebunden).
+func TestListMessages_ReturnsOnlyOwnTenantMessages(t *testing.T) {
+	ts, sc, _ := setupTestServer(t)
+	sc.put("mandant-a", search.Document{MessageID: "a-1", Subject: "Nachricht A", SentAtUnixEpoch: 100})
+	sc.put("mandant-b", search.Document{MessageID: "b-1", Subject: "Nachricht B", SentAtUnixEpoch: 200})
+
+	resp, err := http.Get(ts.URL + "/api/v1/mail/messages?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
+	}
+	var body listMessagesResponse
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if len(body.Messages) != 1 || body.Messages[0].MessageID != "a-1" {
+		t.Fatalf("erwartete genau die eine nachricht von mandant-a, habe: %+v", body.Messages)
+	}
+}
+
+// TestGetMessage_NotFoundForForeignTenant ist der Vertragstest für
+// Akzeptanzkriterium 2: eine für Mandant B existierende Nachricht ist
+// über Mandant As Tenant-Kontext NICHT abrufbar (404, nicht etwa die
+// fremden Daten).
+func TestGetMessage_NotFoundForForeignTenant(t *testing.T) {
+	ts, sc, _ := setupTestServer(t)
+	sc.put("mandant-b", search.Document{MessageID: "b-1", Subject: "Geheim", Body: "Geheimer Inhalt"})
+
+	resp, err := http.Get(ts.URL + "/api/v1/mail/messages/b-1?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Fatalf("erwartete 404 für fremde nachricht, habe %d", resp.StatusCode)
+	}
+}
+
+// TestGetMessage_ReturnsFullDetailForOwnTenant ist der Vertragstest für
+// Akzeptanzkriterium 1 (Mail-Detail).
+func TestGetMessage_ReturnsFullDetailForOwnTenant(t *testing.T) {
+	ts, sc, _ := setupTestServer(t)
+	sc.put("mandant-a", search.Document{
+		MessageID: "a-1", Subject: "Betreff", Body: "Inhalt der Nachricht",
+		Sender: "absender@example.com", Mailbox: "INBOX", SentAtUnixEpoch: 42,
+	})
+
+	resp, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
+	}
+	var body messageDetailResponse
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if body.Body != "Inhalt der Nachricht" || body.Sender != "absender@example.com" {
+		t.Fatalf("unerwartetes detail: %+v", body)
+	}
+}
+
+// TestGetAttachment_PhysicalTenantSeparationEnforced ist der
+// Vertragstest für Akzeptanzkriterium 2 beim Anhang-Download: ein
+// Anhang, der real im Bucket von Mandant A liegt, ist über Mandant Bs
+// Tenant-Kontext nicht erreichbar — strukturell (ARC-06s physische
+// Bucket-Trennung), nicht nur durch einen Pfadfilter.
+func TestGetAttachment_PhysicalTenantSeparationEnforced(t *testing.T) {
+	ts, sc, sp := setupTestServer(t)
+	sc.put("mandant-a", search.Document{MessageID: "a-1", Subject: "Mit Anhang"})
+	sc.put("mandant-b", search.Document{MessageID: "a-1", Subject: "Gleiche ID, anderer Mandant"})
+
+	svcA, err := sp.ServiceFor("mandant-a")
+	if err != nil {
+		t.Fatalf("ServiceFor mandant-a: %v", err)
+	}
+	ctx := context.Background()
+	content := "geheimer anhangsinhalt"
+	if _, err := svcA.Put(ctx, storage.ObjectKey("a-1", 0), strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
+		t.Fatalf("anhang für mandant-a ablegen: %v", err)
+	}
+
+	// Eigener Mandant: Anhang erreichbar.
+	respOwn, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1/attachments/0?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("get (eigener mandant): %v", err)
+	}
+	defer func() { _ = respOwn.Body.Close() }()
+	if respOwn.StatusCode != http.StatusOK {
+		t.Fatalf("erwartete 200 für eigenen mandanten, habe %d", respOwn.StatusCode)
+	}
+
+	// Fremder Mandant, GLEICHE messageID (existiert dort mit anderem
+	// Inhalt, aber ohne Anhang 0): Anhang nicht erreichbar.
+	respForeign, err := http.Get(ts.URL + "/api/v1/mail/messages/a-1/attachments/0?tenant=mandant-b")
+	if err != nil {
+		t.Fatalf("get (fremder mandant): %v", err)
+	}
+	defer func() { _ = respForeign.Body.Close() }()
+	if respForeign.StatusCode != http.StatusNotFound {
+		t.Fatalf("erwartete 404 für fremden mandanten, habe %d", respForeign.StatusCode)
+	}
+}

mail/internal/mailapi/openapi.yaml

@@ -0,0 +1,165 @@
+openapi: "3.0.3"
+info:
+  title: NEXARCH Mail API
+  version: "1.0.0"
+  description: >
+    Mail-spezifische v1-Endpunkte für lesenden Zugriff auf archivierte
+    Mails/Postfächer (INT-01). IAM-nahe Funktionen (Login,
+    Tenant-Verwaltung) sind bewusst NICHT Teil dieser API — der
+    Tenant-Kontext wird als bereits validierter Query-Parameter vom
+    Aufrufer/Gateway mitgegeben.
+servers:
+  - url: /api/v1/mail
+paths:
+  /messages:
+    get:
+      summary: Mail-Liste
+      operationId: listMessages
+      parameters:
+        - $ref: "#/components/parameters/Tenant"
+        - name: q
+          in: query
+          required: false
+          description: Optionaler Volltext-Suchbegriff.
+          schema:
+            type: string
+      responses:
+        "200":
+          description: Liste der Treffer.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/MessageListResponse"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "502":
+          $ref: "#/components/responses/UpstreamError"
+  /messages/{messageID}:
+    get:
+      summary: Mail-Detail
+      operationId: getMessage
+      parameters:
+        - $ref: "#/components/parameters/Tenant"
+        - $ref: "#/components/parameters/MessageID"
+      responses:
+        "200":
+          description: Vollständige Nachricht.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/MessageDetail"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "502":
+          $ref: "#/components/responses/UpstreamError"
+  /messages/{messageID}/attachments/{index}:
+    get:
+      summary: Anhang-Download
+      operationId: getAttachment
+      parameters:
+        - $ref: "#/components/parameters/Tenant"
+        - $ref: "#/components/parameters/MessageID"
+        - name: index
+          in: path
+          required: true
+          description: Anhang-Index innerhalb der Nachricht (0-basiert).
+          schema:
+            type: integer
+            minimum: 0
+      responses:
+        "200":
+          description: Anhangsinhalt.
+          content:
+            application/octet-stream:
+              schema:
+                type: string
+                format: binary
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "502":
+          $ref: "#/components/responses/UpstreamError"
+components:
+  parameters:
+    Tenant:
+      name: tenant
+      in: query
+      required: true
+      description: >
+        Mandanten-Kennung (bereits validiert vom Aufrufer/Gateway —
+        keine Anmeldung/Sitzungsprüfung Bestandteil dieser API).
+      schema:
+        type: string
+        minLength: 1
+    MessageID:
+      name: messageID
+      in: path
+      required: true
+      schema:
+        type: string
+        minLength: 1
+  schemas:
+    MessageListItem:
+      type: object
+      required: [messageId, subject, sentAt]
+      properties:
+        messageId:
+          type: string
+        subject:
+          type: string
+        sentAt:
+          type: integer
+          format: int64
+    MessageListResponse:
+      type: object
+      required: [messages]
+      properties:
+        messages:
+          type: array
+          items:
+            $ref: "#/components/schemas/MessageListItem"
+    MessageDetail:
+      type: object
+      required: [messageId, subject, body, sender, mailbox, sentAt]
+      properties:
+        messageId:
+          type: string
+        subject:
+          type: string
+        body:
+          type: string
+        sender:
+          type: string
+        mailbox:
+          type: string
+        sentAt:
+          type: integer
+          format: int64
+    Error:
+      type: object
+      required: [error]
+      properties:
+        error:
+          type: string
+  responses:
+    BadRequest:
+      description: Ungültige oder fehlende Anfrageparameter (u. a. fehlender Tenant-Kontext).
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+    NotFound:
+      description: Nachricht oder Anhang für diesen Mandanten nicht gefunden.
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+    UpstreamError:
+      description: Ein nachgelagerter Dienst (Suchindex/Objektspeicher) hat einen Fehler geliefert.
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"

mail/internal/mailapi/openapi_test.go

@@ -0,0 +1,97 @@
+package mailapi
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/getkin/kin-openapi/routers/gorillamux"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/search"
+)
+
+// TestOpenAPIDocument_ValidatesAgainstStandardTool ist die geforderte
+// Pflichtprüfung 4 (INT-01): Validierungslauf des OpenAPI-Dokuments
+// gegen ein Standardwerkzeug — github.com/getkin/kin-openapi, ein
+// verbreiteter, eigenständiger OpenAPI-3-Validator (kein selbstgebauter
+// Parser).
+func TestOpenAPIDocument_ValidatesAgainstStandardTool(t *testing.T) {
+	loader := openapi3.NewLoader()
+	doc, err := loader.LoadFromFile("openapi.yaml")
+	if err != nil {
+		t.Fatalf("openapi.yaml laden: %v", err)
+	}
+	if err := doc.Validate(context.Background()); err != nil {
+		t.Fatalf("openapi.yaml ist gegen den Standardvalidator NICHT gültig: %v", err)
+	}
+}
+
+// TestOpenAPIDocument_MatchesActualEndpoints ist die geforderte
+// Pflichtprüfung (Akzeptanzkriterium 4: "... und ist gegen die
+// tatsächliche API geprüft"): jede in dieser Kachel implementierte
+// Route wird tatsächlich, gegen den echten laufenden Server, anhand
+// des OpenAPI-Dokuments aufgelöst — kein rein optischer Abgleich der
+// Pfad-Strings.
+func TestOpenAPIDocument_MatchesActualEndpoints(t *testing.T) {
+	loader := openapi3.NewLoader()
+	doc, err := loader.LoadFromFile("openapi.yaml")
+	if err != nil {
+		t.Fatalf("openapi.yaml laden: %v", err)
+	}
+	if err := doc.Validate(context.Background()); err != nil {
+		t.Fatalf("openapi.yaml validieren: %v", err)
+	}
+	router, err := gorillamux.NewRouter(doc)
+	if err != nil {
+		t.Fatalf("router aus openapi.yaml bauen: %v", err)
+	}
+
+	ts, sc, _ := setupTestServer(t)
+	sc.put("mandant-a", search.Document{MessageID: "msg-1", Subject: "Test"})
+
+	cases := []struct {
+		method string
+		url    string
+	}{
+		{http.MethodGet, "/api/v1/mail/messages?tenant=mandant-a"},
+		{http.MethodGet, "/api/v1/mail/messages/msg-1?tenant=mandant-a"},
+		{http.MethodGet, "/api/v1/mail/messages/msg-1/attachments/0?tenant=mandant-a"},
+	}
+	for _, c := range cases {
+		t.Run(c.method+" "+c.url, func(t *testing.T) {
+			req, err := http.NewRequest(c.method, ts.URL+c.url, nil)
+			if err != nil {
+				t.Fatalf("request bauen: %v", err)
+			}
+			route, _, err := router.FindRoute(req)
+			if err != nil {
+				t.Fatalf("route für %s %s nicht im OpenAPI-Dokument gefunden: %v", c.method, c.url, err)
+			}
+			if route == nil {
+				t.Fatalf("keine route gefunden für %s %s", c.method, c.url)
+			}
+		})
+	}
+}
+
+// TestCodeReview_NoIAMRelatedHandlers ist die geforderte Pflichtprüfung
+// "Codereview bestätigt Abgrenzung zu Core-Board-Zuständigkeiten"
+// (Akzeptanzkriterium 3) — automatisiert statt nur behauptet: kein
+// Handler-/Routenname dieses Pakets enthält IAM-nahe Begriffe
+// (Login/Session/Token/Tenant-Verwaltung).
+func TestCodeReview_NoIAMRelatedHandlers(t *testing.T) {
+	content, err := os.ReadFile("mailapi.go")
+	if err != nil {
+		t.Fatalf("mailapi.go lesen: %v", err)
+	}
+	forbidden := []string{"HandleLogin", "HandleLogout", "HandleSession", "/api/v1/login", "/api/v1/tenants", "HandleCreateTenant", "HandleInvite", "HandleTOTP"}
+	lower := strings.ToLower(string(content))
+	for _, f := range forbidden {
+		if strings.Contains(lower, strings.ToLower(f)) {
+			t.Fatalf("mailapi.go enthält IAM-nahen bezeichner %q — gehört ins Core-Board, nicht in diese API", f)
+		}
+	}
+}

mail/internal/mailboxconfig/migrations/0002_mail_mailboxes_quota.sql

@@ -0,0 +1 @@
+ALTER TABLE mail_mailboxes ADD COLUMN IF NOT EXISTS quota_bytes BIGINT NOT NULL DEFAULT 0;

mail/internal/mailboxconfig/store.go

@@ -28,6 +28,9 @@ import (
 //go:embed migrations/0001_mail_mailboxes.sql
 var schemaMigration string
 
+//go:embed migrations/0002_mail_mailboxes_quota.sql
+var quotaMigration string
+
 // ErrNotFound wird geliefert, wenn kein Postfach mit den angegebenen
 // Bezugsdaten existiert.
 var ErrNotFound = errors.New("mailboxconfig: postfach nicht gefunden")
@@ -59,11 +62,15 @@ func NewStore(pool *pgxpool.Pool, cryptoSvc *crypto.Service) *Store {
 	return &Store{pool: pool, crypto: cryptoSvc}
 }
 
-// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
+// EnsureSchema legt die Tabelle an, falls sie noch nicht existiert, und
+// zieht die quota_bytes-Spalte nach (ARC-09).
 func (s *Store) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
 		return fmt.Errorf("mailboxconfig: schema anlegen: %w", err)
 	}
+	if _, err := s.pool.Exec(ctx, quotaMigration); err != nil {
+		return fmt.Errorf("mailboxconfig: quota-spalte anlegen: %w", err)
+	}
 	return nil
 }
 
@@ -183,6 +190,46 @@ func (s *Store) Delete(ctx context.Context, tenantSlug string, id int64) error {
 	return nil
 }
 
+// SetQuotaBytes setzt das Speicherlimit EINES Postfachs, identifiziert
+// über seinen (innerhalb des Mandanten eindeutigen) Namen (ARC-09
+// Akzeptanzkriterium 1: je Postfach konfigurierbar, unabhängig von der
+// Tenant-weiten Core-LIC-05-Quota). 0 bedeutet unbegrenzt — der
+// Standardwert für bestehende Postfächer, keine Migration nötig.
+func (s *Store) SetQuotaBytes(ctx context.Context, tenantSlug, name string, quotaBytes int64) error {
+	tag, err := s.pool.Exec(ctx, `
+		UPDATE mail_mailboxes SET quota_bytes = $3, updated_at = now()
+		WHERE tenant_slug = $1 AND name = $2
+	`, tenantSlug, name, quotaBytes)
+	if err != nil {
+		return fmt.Errorf("mailboxconfig: quota setzen: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return nil
+}
+
+// LimitBytes erfüllt quota.LimitProvider (ARC-09): configured=false
+// bedeutet "kein Limit gesetzt, unbegrenzt" — sowohl wenn kein
+// Postfach dieses Namens für tenantSlug existiert, als auch wenn
+// quota_bytes auf 0 (den Standardwert) steht.
+func (s *Store) LimitBytes(ctx context.Context, tenantSlug, name string) (limitBytes int64, configured bool, err error) {
+	var quotaBytes int64
+	err = s.pool.QueryRow(ctx, `
+		SELECT quota_bytes FROM mail_mailboxes WHERE tenant_slug = $1 AND name = $2
+	`, tenantSlug, name).Scan(&quotaBytes)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return 0, false, nil
+		}
+		return 0, false, fmt.Errorf("mailboxconfig: quota lesen: %w", err)
+	}
+	if quotaBytes <= 0 {
+		return 0, false, nil
+	}
+	return quotaBytes, true, nil
+}
+
 // GetDecryptedPassword entschlüsselt das Postfach-Passwort — separater,
 // bewusster Aufruf statt Bestandteil von List/Get, damit Zugangsdaten
 // nicht beiläufig mitgeliefert werden.

mail/internal/mailboxconfig/tenant_scoping_test.go

@@ -0,0 +1,82 @@
+package mailboxconfig
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+// TestTenantScoping_ForeignKnownIDNeverAccessible ist Teil der
+// geforderten Pflichtprüfung "Stichprobenprüfung mehrerer Speicherpfade
+// auf Mandantentrennung" (QA-04): dieser Speicherpfad ist besonders
+// sensibel (verschlüsselte Postfach-Zugangsdaten). Anders als die
+// Tenant-Scoping-Tests aus ING-10 (unterschiedliche Server-/Store-
+// Instanzen je Mandant) prüft dieser Test den REALISTISCHSTEN
+// Angriffsfall für eine geteilte Datenbank mit tenant_slug-Spalte:
+// Mandant B kennt/errät eine gültige, echte ID aus Mandant As Zeile
+// (z. B. durch fortlaufende IDs) und versucht direkt darauf
+// zuzugreifen — muss an der tenant_slug-Prüfung in der WHERE-Klausel
+// scheitern, nicht an einem geratenen falschen Wert.
+func TestTenantScoping_ForeignKnownIDNeverAccessible(t *testing.T) {
+	store := setupStore(t)
+	ctx := context.Background()
+
+	tenantA := "mandant-qa04-a"
+	tenantB := "mandant-qa04-b"
+
+	idA := createTestMailbox(t, store, tenantA, "Postfach A")
+
+	// Mandant B versucht, MIT DER ECHTEN, BEKANNTEN ID von Mandant A
+	// zuzugreifen — List gibt es aus Mandant Bs Sicht nicht.
+	listB, err := store.List(ctx, tenantB)
+	if err != nil {
+		t.Fatalf("List mandant b: %v", err)
+	}
+	for _, mb := range listB {
+		if mb.ID == idA {
+			t.Fatalf("mandant b sieht mandant As postfach in seiner eigenen liste")
+		}
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: GetDecryptedPassword.
+	_, err = store.GetDecryptedPassword(ctx, tenantB, idA)
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("GetDecryptedPassword mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: Update.
+	err = store.Update(ctx, tenantB, idA, UpdateInput{
+		IMAPHost:        "boese.example.com",
+		IMAPPort:        993,
+		FolderSelection: []string{"INBOX"},
+		IntervalSeconds: 60,
+	})
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Update mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Direkter Zugriff mit fremder, aber echter ID: Delete.
+	err = store.Delete(ctx, tenantB, idA)
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("Delete mit fremder mandant-b-anfrage auf mandant-a-id hätte ErrNotFound liefern müssen, habe: %v", err)
+	}
+
+	// Kontrolle: Mandant As eigenes Postfach ist von alledem UNBERÜHRT
+	// (kein erfolgreicher Update/Delete-Seiteneffekt trotz Ablehnung).
+	stillA, err := store.List(ctx, tenantA)
+	if err != nil {
+		t.Fatalf("List mandant a nach angriffsversuchen: %v", err)
+	}
+	found := false
+	for _, ma := range stillA {
+		if ma.ID == idA {
+			found = true
+			if ma.IMAPHost == "boese.example.com" {
+				t.Fatalf("mandant Bs Update-Versuch hat mandant As postfach tatsächlich verändert")
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("mandant As postfach ist nach den angriffsversuchen verschwunden")
+	}
+}

mail/internal/mailrules/store.go

@@ -15,6 +15,7 @@ package mailrules
 import (
 	"context"
 	_ "embed"
+	"errors"
 	"fmt"
 	"regexp"
 	"sort"
@@ -25,6 +26,10 @@ import (
 //go:embed migrations/0001_mail_rules.sql
 var schemaMigration string
 
+// ErrNotFound wird geliefert, wenn keine Regel mit den angegebenen
+// Bezugsdaten (tenantSlug+id) existiert.
+var ErrNotFound = errors.New("mailrules: regel nicht gefunden")
+
 // 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,
@@ -121,6 +126,43 @@ func (s *Store) List(ctx context.Context, tenantSlug string) ([]Rule, error) {
 	return rules, nil
 }
 
+// Update ersetzt eine bestehende Regel vollständig (INT-06
+// Akzeptanzkriterium 1: Regeln lassen sich über die API ändern,
+// Akzeptanzkriterium 2: Priorität ist darüber änderbar — Priority ist
+// ein normales Feld von rule wie jedes andere). Wie Create werden
+// Muster vor dem Schreiben validiert. Streng auf tenantSlug+id
+// beschränkt — ErrNotFound, wenn keine Zeile dieses Mandanten diese ID
+// hat (auch wenn die ID bei einem ANDEREN Mandanten existiert).
+func (s *Store) Update(ctx context.Context, tenantSlug string, id int64, rule Rule) error {
+	if _, err := regexp.Compile(rule.SenderPattern); rule.SenderPattern != "" && err != nil {
+		return fmt.Errorf("mailrules: sender_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.SubjectPattern); rule.SubjectPattern != "" && err != nil {
+		return fmt.Errorf("mailrules: subject_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.MailboxPattern); rule.MailboxPattern != "" && err != nil {
+		return fmt.Errorf("mailrules: mailbox_pattern ungültig: %w", err)
+	}
+	if _, err := regexp.Compile(rule.AttachmentTypePattern); rule.AttachmentTypePattern != "" && err != nil {
+		return fmt.Errorf("mailrules: attachment_type_pattern ungültig: %w", err)
+	}
+
+	tag, err := s.pool.Exec(ctx, `
+		UPDATE mail_rules
+		SET name = $3, sender_pattern = $4, subject_pattern = $5, mailbox_pattern = $6,
+		    attachment_type_pattern = $7, category = $8, tag = $9, priority = $10
+		WHERE tenant_slug = $1 AND id = $2
+	`, tenantSlug, id, rule.Name, rule.SenderPattern, rule.SubjectPattern, rule.MailboxPattern,
+		rule.AttachmentTypePattern, rule.Category, rule.Tag, rule.Priority)
+	if err != nil {
+		return fmt.Errorf("mailrules: regel aktualisieren: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	return 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 {

mail/internal/mailrulesapi/integration_test.go

@@ -0,0 +1,142 @@
+// Integrationstests (INT-06): echte Postgres-Instanz über
+// TEST_TENANT_DSN, echter mailrules.Store (kein Fake) — dieselbe
+// Konvention wie mailrules/engine_test.go.
+package mailrulesapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strconv"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
+)
+
+func setupRealStore(t *testing.T) *mailrules.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(pool.Close)
+	store := mailrules.NewStore(pool)
+	if err := store.EnsureSchema(ctx); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_rules WHERE tenant_slug LIKE 'mandant-int06-%'`)
+	})
+	return store
+}
+
+func setupRealTestServer(t *testing.T) (*httptest.Server, *mailrules.Store) {
+	t.Helper()
+	store := setupRealStore(t)
+	srv := NewServer(store)
+	mux := http.NewServeMux()
+	srv.RegisterRoutes(mux)
+	ts := httptest.NewServer(mux)
+	t.Cleanup(ts.Close)
+	return ts, store
+}
+
+// TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine ist die
+// geforderte Pflichtprüfung 2 (INT-06): eine über die API gesetzte
+// Regel wird beim nächsten Import korrekt angewendet — real geprüft,
+// indem die über einen echten HTTP-Request angelegte Regel über
+// denselben Store gelesen und in mailrules.Engine (IMP-03,
+// unverändert) ausgewertet wird.
+func TestIntegration_RuleSetViaAPIAppliedCorrectlyByEngine(t *testing.T) {
+	ts, store := setupRealTestServer(t)
+	tenant := "mandant-int06-anwendung"
+
+	body, _ := json.Marshal(ruleDTO{
+		Name: "Rechnungsregel", SenderPattern: `rechnung@lieferant\.example`,
+		Category: "Rechnung", Tag: "finanzen", Priority: 5,
+	})
+	resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant="+tenant, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("regel über api anlegen: %v", err)
+	}
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("erwartete 201, habe %d", resp.StatusCode)
+	}
+	_ = resp.Body.Close()
+
+	// Genau der Weg, den IMP-03s Import-Pfad geht: Store.List ->
+	// mailrules.NewEngine -> Evaluate. Kein separater API-Auswertungspfad.
+	rules, err := store.List(context.Background(), tenant)
+	if err != nil {
+		t.Fatalf("regeln lesen: %v", err)
+	}
+	engine, err := mailrules.NewEngine(rules)
+	if err != nil {
+		t.Fatalf("engine bauen: %v", err)
+	}
+	result := engine.Evaluate(mailrules.EmailMetadata{Sender: "rechnung@lieferant.example"})
+	if result.Category != "Rechnung" {
+		t.Fatalf("erwartete kategorie \"Rechnung\" für die über die API gesetzte regel, habe: %+v", result)
+	}
+}
+
+// TestIntegration_RuleChangeIsolatedPerTenant ist die geforderte
+// Pflichtprüfung 3 (INT-06): eine Regeländerung eines Mandanten wirkt
+// nicht auf andere Mandanten — real über die API und den echten Store
+// geprüft, inklusive Update/Delete-Versuch mit einer ECHTEN, bekannten
+// fremden ID.
+func TestIntegration_RuleChangeIsolatedPerTenant(t *testing.T) {
+	ts, store := setupRealTestServer(t)
+	tenantA := "mandant-int06-isoliert-a"
+	tenantB := "mandant-int06-isoliert-b"
+
+	body, _ := json.Marshal(ruleDTO{Name: "Nur A", SenderPattern: "^a@", Category: "A", Priority: 1})
+	resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant="+tenantA, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("regel für mandant a anlegen: %v", err)
+	}
+	var created ruleDTO
+	_ = json.NewDecoder(resp.Body).Decode(&created)
+	_ = resp.Body.Close()
+
+	// Mandant B sieht die Regel von Mandant A nicht.
+	rulesB, err := store.List(context.Background(), tenantB)
+	if err != nil {
+		t.Fatalf("list mandant b: %v", err)
+	}
+	if len(rulesB) != 0 {
+		t.Fatalf("mandant b sieht regeln von mandant a: %+v", rulesB)
+	}
+
+	// Mandant B versucht mit der ECHTEN, bekannten ID von Mandant A zu
+	// aktualisieren — muss scheitern.
+	updateBody, _ := json.Marshal(ruleDTO{Name: "Übernommen von B", Category: "B", Priority: 999})
+	req, _ := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant="+tenantB, bytes.NewReader(updateBody))
+	updResp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("update-versuch mandant b: %v", err)
+	}
+	if updResp.StatusCode != http.StatusNotFound {
+		t.Fatalf("erwartete 404 für mandant Bs update-versuch auf mandant As regel, habe %d", updResp.StatusCode)
+	}
+	_ = updResp.Body.Close()
+
+	// Mandant As Regel ist unverändert.
+	rulesA, err := store.List(context.Background(), tenantA)
+	if err != nil {
+		t.Fatalf("list mandant a: %v", err)
+	}
+	if len(rulesA) != 1 || rulesA[0].Category != "A" || rulesA[0].Name != "Nur A" {
+		t.Fatalf("mandant As regel wurde durch mandant Bs versuch verändert: %+v", rulesA)
+	}
+}

mail/internal/mailrulesapi/mailrulesapi.go

@@ -0,0 +1,206 @@
+// Package mailrulesapi implementiert INT-06: die E-Mail-Regel-Engine
+// (mail/internal/mailrules, IMP-03) über REST steuerbar machen —
+// Anlegen, Ändern, Löschen, Priorität einsehen/ändern.
+//
+// Core API-01 hat weiterhin keinen abrufbaren Router (gleiche,
+// mehrfach dokumentierte Situation wie mailapi/INT-01) —
+// RegisterRoutes registriert die Endpunkte auf einem vom Aufrufer
+// bereitgestellten *http.ServeMux mit demselben Pfadschema.
+//
+// Akzeptanzkriterium 3 ("API-Änderungen wirken identisch zur
+// bisherigen internen Regel-Anwendung") ist strukturell garantiert:
+// dieses Paket ruft AUSSCHLIESSLICH mail/internal/mailrules.Store auf
+// — denselben Store, den IMP-03s Import-Pfad ohnehin verwendet. Es
+// gibt keinen zweiten, parallelen Schreibpfad, der abweichen könnte.
+package mailrulesapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
+)
+
+// RulesStore ist die für diese API benötigte Teilmenge von
+// *mailrules.Store — als Schnittstelle für Tests ohne echte Postgres-
+// Instanz.
+type RulesStore interface {
+	Create(ctx context.Context, tenantSlug string, rule mailrules.Rule) (int64, error)
+	List(ctx context.Context, tenantSlug string) ([]mailrules.Rule, error)
+	Update(ctx context.Context, tenantSlug string, id int64, rule mailrules.Rule) error
+	Delete(ctx context.Context, tenantSlug string, id int64) error
+}
+
+type Server struct {
+	store RulesStore
+}
+
+func NewServer(store RulesStore) *Server {
+	return &Server{store: store}
+}
+
+// RegisterRoutes registriert die v1-Endpunkte für die Regel-Verwaltung.
+func (s *Server) RegisterRoutes(mux *http.ServeMux) {
+	mux.HandleFunc("GET /api/v1/mail/rules", s.handleList)
+	mux.HandleFunc("POST /api/v1/mail/rules", s.handleCreate)
+	mux.HandleFunc("PUT /api/v1/mail/rules/{id}", s.handleUpdate)
+	mux.HandleFunc("DELETE /api/v1/mail/rules/{id}", s.handleDelete)
+}
+
+type errorResponse struct {
+	Error string `json:"error"`
+}
+
+func writeError(w http.ResponseWriter, status int, message string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(errorResponse{Error: message})
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+// requireTenant liest den Pflicht-Query-Parameter "tenant" — dieselbe
+// Konvention wie mail/internal/mailapi (INT-01).
+func requireTenant(w http.ResponseWriter, r *http.Request) (string, bool) {
+	tenant := strings.TrimSpace(r.URL.Query().Get("tenant"))
+	if tenant == "" {
+		writeError(w, http.StatusBadRequest, "fehlender oder leerer tenant-kontext (query-parameter \"tenant\")")
+		return "", false
+	}
+	return tenant, true
+}
+
+// ruleDTO ist die JSON-Darstellung EINER Regel — 1:1 zu
+// mailrules.Rule, aber als eigener Typ, damit das Übertragungsformat
+// unabhängig vom internen Go-Struct bleibt.
+type ruleDTO struct {
+	ID                    int64  `json:"id,omitempty"`
+	Name                  string `json:"name"`
+	SenderPattern         string `json:"senderPattern"`
+	SubjectPattern        string `json:"subjectPattern"`
+	MailboxPattern        string `json:"mailboxPattern"`
+	AttachmentTypePattern string `json:"attachmentTypePattern"`
+	Category              string `json:"category"`
+	Tag                   string `json:"tag"`
+	// Priority: niedrigere Zahl = höhere Priorität (Akzeptanzkriterium 2),
+	// dieselbe Semantik wie mailrules.Rule.Priority.
+	Priority int `json:"priority"`
+}
+
+func toDTO(r mailrules.Rule) ruleDTO {
+	return ruleDTO{
+		ID: r.ID, Name: r.Name, SenderPattern: r.SenderPattern, SubjectPattern: r.SubjectPattern,
+		MailboxPattern: r.MailboxPattern, AttachmentTypePattern: r.AttachmentTypePattern,
+		Category: r.Category, Tag: r.Tag, Priority: r.Priority,
+	}
+}
+
+func fromDTO(dto ruleDTO) mailrules.Rule {
+	return mailrules.Rule{
+		Name: dto.Name, SenderPattern: dto.SenderPattern, SubjectPattern: dto.SubjectPattern,
+		MailboxPattern: dto.MailboxPattern, AttachmentTypePattern: dto.AttachmentTypePattern,
+		Category: dto.Category, Tag: dto.Tag, Priority: dto.Priority,
+	}
+}
+
+type listRulesResponse struct {
+	Rules []ruleDTO `json:"rules"`
+}
+
+// handleList ist GET /api/v1/mail/rules (Akzeptanzkriterium 2:
+// Prioritätsreihenfolge einsehbar — mailrules.Store.List liefert
+// bereits aufsteigend nach Priority sortiert).
+func (s *Server) handleList(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	rules, err := s.store.List(r.Context(), tenant)
+	if err != nil {
+		writeError(w, http.StatusBadGateway, "regeln abrufen fehlgeschlagen")
+		return
+	}
+	resp := listRulesResponse{Rules: make([]ruleDTO, 0, len(rules))}
+	for _, rule := range rules {
+		resp.Rules = append(resp.Rules, toDTO(rule))
+	}
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// handleCreate ist POST /api/v1/mail/rules (Akzeptanzkriterium 1:
+// anlegen).
+func (s *Server) handleCreate(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	var dto ruleDTO
+	if err := json.NewDecoder(r.Body).Decode(&dto); err != nil {
+		writeError(w, http.StatusBadRequest, "ungültiger anfragekörper")
+		return
+	}
+	id, err := s.store.Create(r.Context(), tenant, fromDTO(dto))
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "regel anlegen fehlgeschlagen: ungültige eingabe")
+		return
+	}
+	dto.ID = id
+	writeJSON(w, http.StatusCreated, dto)
+}
+
+// handleUpdate ist PUT /api/v1/mail/rules/{id} (Akzeptanzkriterium 1:
+// ändern; Akzeptanzkriterium 2: Priorität änderbar — priority ist ein
+// normales Feld des Anfragekörpers).
+func (s *Server) handleUpdate(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "ungültige regel-id")
+		return
+	}
+	var dto ruleDTO
+	if err := json.NewDecoder(r.Body).Decode(&dto); err != nil {
+		writeError(w, http.StatusBadRequest, "ungültiger anfragekörper")
+		return
+	}
+	if err := s.store.Update(r.Context(), tenant, id, fromDTO(dto)); err != nil {
+		if errors.Is(err, mailrules.ErrNotFound) {
+			writeError(w, http.StatusNotFound, "regel nicht gefunden")
+			return
+		}
+		writeError(w, http.StatusBadRequest, "regel aktualisieren fehlgeschlagen: ungültige eingabe")
+		return
+	}
+	dto.ID = id
+	writeJSON(w, http.StatusOK, dto)
+}
+
+// handleDelete ist DELETE /api/v1/mail/rules/{id} (Akzeptanzkriterium
+// 1: löschen).
+func (s *Server) handleDelete(w http.ResponseWriter, r *http.Request) {
+	tenant, ok := requireTenant(w, r)
+	if !ok {
+		return
+	}
+	id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "ungültige regel-id")
+		return
+	}
+	if err := s.store.Delete(r.Context(), tenant, id); err != nil {
+		writeError(w, http.StatusBadGateway, "regel löschen fehlgeschlagen")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}

mail/internal/mailrulesapi/mailrulesapi_test.go

@@ -0,0 +1,165 @@
+package mailrulesapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"sync"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailrules"
+)
+
+// fakeRulesStore ist ein In-Memory-Fake für RulesStore — reine
+// Vertragstests brauchen keine echte Postgres-Instanz.
+type fakeRulesStore struct {
+	mu       sync.Mutex
+	nextID   int64
+	byTenant map[string]map[int64]mailrules.Rule
+}
+
+func newFakeRulesStore() *fakeRulesStore {
+	return &fakeRulesStore{byTenant: map[string]map[int64]mailrules.Rule{}}
+}
+
+func (f *fakeRulesStore) Create(_ context.Context, tenantSlug string, rule mailrules.Rule) (int64, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.nextID++
+	rule.ID = f.nextID
+	if f.byTenant[tenantSlug] == nil {
+		f.byTenant[tenantSlug] = map[int64]mailrules.Rule{}
+	}
+	f.byTenant[tenantSlug][rule.ID] = rule
+	return rule.ID, nil
+}
+
+func (f *fakeRulesStore) List(_ context.Context, tenantSlug string) ([]mailrules.Rule, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var rules []mailrules.Rule
+	for _, r := range f.byTenant[tenantSlug] {
+		rules = append(rules, r)
+	}
+	return rules, nil
+}
+
+func (f *fakeRulesStore) Update(_ context.Context, tenantSlug string, id int64, rule mailrules.Rule) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.byTenant[tenantSlug][id]; !ok {
+		return mailrules.ErrNotFound
+	}
+	rule.ID = id
+	f.byTenant[tenantSlug][id] = rule
+	return nil
+}
+
+func (f *fakeRulesStore) Delete(_ context.Context, tenantSlug string, id int64) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	delete(f.byTenant[tenantSlug], id)
+	return nil
+}
+
+func setupTestServer(t *testing.T) (*httptest.Server, *fakeRulesStore) {
+	t.Helper()
+	store := newFakeRulesStore()
+	srv := NewServer(store)
+	mux := http.NewServeMux()
+	srv.RegisterRoutes(mux)
+	ts := httptest.NewServer(mux)
+	t.Cleanup(ts.Close)
+	return ts, store
+}
+
+// TestContract_CreateUpdateDeletePrioritize ist die geforderte
+// Pflichtprüfung 1 (INT-06): Vertragstest deckt Anlegen/Ändern/Löschen/
+// Priorisieren ab.
+func TestContract_CreateUpdateDeletePrioritize(t *testing.T) {
+	ts, _ := setupTestServer(t)
+
+	// Anlegen.
+	createBody, _ := json.Marshal(ruleDTO{Name: "Rechnungen", SenderPattern: "^rechnung@", Category: "Finanzen", Priority: 10})
+	resp, err := http.Post(ts.URL+"/api/v1/mail/rules?tenant=mandant-a", "application/json", bytes.NewReader(createBody))
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("erwartete 201, habe %d", resp.StatusCode)
+	}
+	var created ruleDTO
+	_ = json.NewDecoder(resp.Body).Decode(&created)
+	_ = resp.Body.Close()
+	if created.ID == 0 {
+		t.Fatalf("erwartete gesetzte id nach anlage")
+	}
+
+	// Priorisieren/Ändern.
+	updateBody, _ := json.Marshal(ruleDTO{Name: "Rechnungen (neu)", SenderPattern: "^rechnung@", Category: "Finanzen", Priority: 1})
+	req, _ := http.NewRequest(http.MethodPut, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant=mandant-a", bytes.NewReader(updateBody))
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("erwartete 200, habe %d", resp.StatusCode)
+	}
+	var updated ruleDTO
+	_ = json.NewDecoder(resp.Body).Decode(&updated)
+	_ = resp.Body.Close()
+	if updated.Priority != 1 || updated.Name != "Rechnungen (neu)" {
+		t.Fatalf("update nicht angekommen: %+v", updated)
+	}
+
+	// Einsehen (Liste).
+	resp, err = http.Get(ts.URL + "/api/v1/mail/rules?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	var list listRulesResponse
+	_ = json.NewDecoder(resp.Body).Decode(&list)
+	_ = resp.Body.Close()
+	if len(list.Rules) != 1 || list.Rules[0].Priority != 1 {
+		t.Fatalf("liste zeigt nicht die aktualisierte regel: %+v", list.Rules)
+	}
+
+	// Löschen.
+	req, _ = http.NewRequest(http.MethodDelete, ts.URL+"/api/v1/mail/rules/"+strconv.FormatInt(created.ID, 10)+"?tenant=mandant-a", nil)
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	if resp.StatusCode != http.StatusNoContent {
+		t.Fatalf("erwartete 204, habe %d", resp.StatusCode)
+	}
+	_ = resp.Body.Close()
+
+	resp, err = http.Get(ts.URL + "/api/v1/mail/rules?tenant=mandant-a")
+	if err != nil {
+		t.Fatalf("list nach löschen: %v", err)
+	}
+	var listAfter listRulesResponse
+	_ = json.NewDecoder(resp.Body).Decode(&listAfter)
+	_ = resp.Body.Close()
+	if len(listAfter.Rules) != 0 {
+		t.Fatalf("erwartete leere liste nach löschen, habe %+v", listAfter.Rules)
+	}
+}
+
+// TestListCreate_RejectMissingTenant deckt die geforderte
+// tenant-Pflicht ab (dieselbe Konvention wie mailapi/INT-01).
+func TestListCreate_RejectMissingTenant(t *testing.T) {
+	ts, _ := setupTestServer(t)
+	resp, err := http.Get(ts.URL + "/api/v1/mail/rules")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("erwartete 400 ohne tenant, habe %d", resp.StatusCode)
+	}
+}

mail/internal/notifyclient/client.go

@@ -0,0 +1,87 @@
+// Package notifyclient implementiert die Mail-seitige Kopplung an Core
+// CFG-02/CFG-05 (INT-05): ein zentraler Dispatcher übernimmt Warteschlange,
+// Wiederholungslogik, Kanal-Abstraktion UND — laut CFG-05s eigener
+// Beschreibung ("internal/notifyprefs.EnqueueIfAllowed als HTTP-Endpunkt")
+// — die Prüfung, ob der Benutzer diese Benachrichtigungsart überhaupt
+// wünscht. Mail baut deshalb bewusst KEINE eigene
+// Benachrichtigungs-/Präferenzlogik, sondern ruft ausschließlich den
+// dokumentierten Vertrag "POST /notify" auf.
+//
+// Core CFG-02/CFG-05 stehen auf core-kanban zwar auf "Fertig", enthalten
+// im aktuellen Repository-Stand aber keinen abrufbaren Endpunkt (gleiche
+// Situation wie ARC-06/Core TEN-01, INT-01/Core API-01) — Client richtet
+// sich nach dem im Core-Board dokumentierten Vertrag (service-token-
+// authentifiziertes POST /notify), siehe INT-05-Prüfprotokoll.
+package notifyclient
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+// Event ist eine einzelne Benachrichtigung an den Core-Dispatcher.
+type Event struct {
+	TenantSlug string `json:"tenant_slug"`
+	EventType  string `json:"event_type"`
+	Summary    string `json:"summary"`
+	Count      int    `json:"count"`
+}
+
+// Client ruft Core CFG-05s "POST /notify" auf.
+type Client struct {
+	baseURL      string
+	serviceToken string
+	httpClient   *http.Client
+}
+
+// NewClient erstellt einen Client. baseURL und serviceToken kommen
+// ausschließlich vom Aufrufer (Umgebungsvariable) — keine
+// Zugangsdaten im Code.
+func NewClient(baseURL, serviceToken string) *Client {
+	return &Client{
+		baseURL:      baseURL,
+		serviceToken: serviceToken,
+		httpClient:   &http.Client{Timeout: 5 * time.Second},
+	}
+}
+
+// Notify sendet EIN Ereignis. Ein HTTP-Fehler (Netzwerk, 5xx) wird als
+// Fehler zurückgeliefert — der Aufrufer entscheidet, ob das den
+// regulären Mail-Betrieb blockiert (siehe importnotify: Notify läuft
+// NIE im Importpfad selbst, ein Fehler hier verhindert keine bereits
+// abgeschlossene Nachrichtenübernahme). Ein 2xx- ODER 204-Status gilt
+// als Erfolg — 204 bedeutet laut CFG-05s EnqueueIfAllowed-Vertrag
+// "durch Benutzerpräferenz unterdrückt, kein Fehler".
+func (c *Client) Notify(ctx context.Context, ev Event) error {
+	body, err := json.Marshal(ev)
+	if err != nil {
+		return fmt.Errorf("notifyclient: ereignis serialisieren: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/notify", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("notifyclient: anfrage bauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+c.serviceToken)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("notifyclient: /notify aufrufen: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	respBody, _ := io.ReadAll(resp.Body)
+
+	// 2xx (inkl. 204 "No Content") gilt als Erfolg — 204 bedeutet laut
+	// CFG-05s EnqueueIfAllowed-Vertrag "durch Benutzerpräferenz
+	// unterdrückt", was Mail nicht als Fehler behandelt (die
+	// Zustell-/Präferenzentscheidung ist bewusst Core-Sache).
+	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+		return nil
+	}
+	return fmt.Errorf("notifyclient: /notify status %d: %s", resp.StatusCode, string(respBody))
+}

mail/internal/notifyclient/client_test.go

@@ -0,0 +1,86 @@
+package notifyclient
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// TestNotify_SendsEventToRealHTTPServer ist ein echter Ende-zu-Ende-Test
+// gegen einen echten, laufenden HTTP-Server (kein Mock der
+// Standardbibliothek umgangen) — Core CFG-02/CFG-05 haben im aktuellen
+// Repository-Stand keinen abrufbaren Endpunkt (siehe Paketkommentar),
+// dieser Server implementiert den in CFG-05 dokumentierten Vertrag
+// (service-token-authentifiziertes POST /notify) real.
+func TestNotify_SendsEventToRealHTTPServer(t *testing.T) {
+	var gotToken string
+	var gotEvent Event
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost || r.URL.Path != "/notify" {
+			http.NotFound(w, r)
+			return
+		}
+		gotToken = r.Header.Get("Authorization")
+		_ = json.NewDecoder(r.Body).Decode(&gotEvent)
+		w.WriteHeader(http.StatusAccepted)
+	}))
+	defer srv.Close()
+
+	client := NewClient(srv.URL, "test-service-token")
+	err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new", Summary: "3 neue Mails", Count: 3})
+	if err != nil {
+		t.Fatalf("Notify: %v", err)
+	}
+	if gotToken != "Bearer test-service-token" {
+		t.Fatalf("erwartete service-token-header, habe: %q", gotToken)
+	}
+	if gotEvent.TenantSlug != "mandant-a" || gotEvent.Count != 3 {
+		t.Fatalf("unerwartetes ereignis beim server angekommen: %+v", gotEvent)
+	}
+}
+
+// TestNotify_TreatsNoContentAsSuppressedNotAsError bestätigt: ein
+// 204-Status (laut CFG-05-Vertrag "durch Benutzerpräferenz unterdrückt")
+// wird NICHT als Fehler behandelt.
+func TestNotify_TreatsNoContentAsSuppressedNotAsError(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	defer srv.Close()
+
+	client := NewClient(srv.URL, "test-service-token")
+	if err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"}); err != nil {
+		t.Fatalf("erwartete keinen fehler bei 204 (unterdrückt), habe: %v", err)
+	}
+}
+
+// TestNotify_ReturnsErrorOnServerFailure stellt sicher, dass ein
+// echter Serverfehler (5xx) als Fehler durchgereicht wird — der
+// Aufrufer (importnotify) entscheidet, wie damit umgegangen wird.
+func TestNotify_ReturnsErrorOnServerFailure(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+		_, _ = w.Write([]byte("boom"))
+	}))
+	defer srv.Close()
+
+	client := NewClient(srv.URL, "test-service-token")
+	if err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"}); err == nil {
+		t.Fatal("erwartete fehler bei 500")
+	}
+}
+
+// TestNotify_UnreachableEndpointReturnsErrorWithoutHanging bestätigt,
+// dass ein nicht erreichbarer Endpunkt zeitnah einen Fehler liefert
+// (Timeout im Client konfiguriert) statt unbegrenzt zu blockieren —
+// Grundlage für INT-09/INT-10s "fail open"-Prinzip, hier für INT-05
+// mitgeprüft.
+func TestNotify_UnreachableEndpointReturnsErrorWithoutHanging(t *testing.T) {
+	client := NewClient("http://127.0.0.1:1", "test-service-token") // Port 1: garantiert nichts lauscht dort
+	err := client.Notify(context.Background(), Event{TenantSlug: "mandant-a", EventType: "mail.new"})
+	if err == nil {
+		t.Fatal("erwartete fehler bei nicht erreichbarem endpunkt")
+	}
+}

mail/internal/quota/quota.go

@@ -0,0 +1,69 @@
+// Package quota implementiert ARC-09: konfigurierbares Speicherlimit
+// je einzelnem Postfach — eine ANDERE Ebene als die tenant-weite Quota
+// aus Core LIC-05 (bekannter Fehler zu vermeiden: beide Ebenen müssen
+// unabhängig durchgesetzt werden, ein Tenant kann insgesamt genug
+// Kontingent haben, während ein einzelnes Postfach überläuft).
+package quota
+
+import "context"
+
+// LimitProvider liefert das konfigurierte Speicherlimit eines
+// Postfachs (Akzeptanzkriterium 1). configured=false bedeutet: kein
+// Limit gesetzt, also unbegrenzt — erfüllt von
+// mail/internal/mailboxconfig.Store.LimitBytes.
+type LimitProvider interface {
+	LimitBytes(ctx context.Context, tenantSlug, mailbox string) (limitBytes int64, configured bool, err error)
+}
+
+// UsageProvider liefert den TATSÄCHLICHEN, real gemessenen
+// Speicherverbrauch eines Postfachs — erfüllt von
+// mail/internal/storage.UsageCounter.
+type UsageProvider interface {
+	UsageBytes(ctx context.Context, tenantSlug, mailbox string) (usedBytes int64, err error)
+}
+
+// Result ist das Ergebnis einer Quota-Prüfung.
+type Result struct {
+	Allowed    bool
+	UsedBytes  int64
+	LimitBytes int64
+}
+
+// Checker verknüpft konfiguriertes Limit und realen Verbrauch.
+type Checker struct {
+	limits LimitProvider
+	usage  UsageProvider
+}
+
+func NewChecker(limits LimitProvider, usage UsageProvider) *Checker {
+	return &Checker{limits: limits, usage: usage}
+}
+
+// Check prüft, ob mailbox innerhalb seines konfigurierten Limits ist.
+// Kein konfiguriertes Limit bedeutet immer "erlaubt" — die
+// Tenant-weite Quota (Core LIC-05) läuft unabhängig davon weiter.
+func (c *Checker) Check(ctx context.Context, tenantSlug, mailbox string) (Result, error) {
+	limit, configured, err := c.limits.LimitBytes(ctx, tenantSlug, mailbox)
+	if err != nil {
+		return Result{}, err
+	}
+	if !configured {
+		return Result{Allowed: true}, nil
+	}
+	used, err := c.usage.UsageBytes(ctx, tenantSlug, mailbox)
+	if err != nil {
+		return Result{}, err
+	}
+	return Result{Allowed: used < limit, UsedBytes: used, LimitBytes: limit}, nil
+}
+
+// Allowed ist die schmale Form von Check für Aufrufer, die nur die
+// Ja/Nein-Entscheidung brauchen (z. B. mail/internal/smtp.QuotaChecker,
+// Akzeptanzkriterium 2).
+func (c *Checker) Allowed(ctx context.Context, tenantSlug, mailbox string) (bool, error) {
+	result, err := c.Check(ctx, tenantSlug, mailbox)
+	if err != nil {
+		return false, err
+	}
+	return result.Allowed, nil
+}

mail/internal/quota/quota_test.go

@@ -0,0 +1,56 @@
+package quota
+
+import (
+	"context"
+	"testing"
+)
+
+type fakeLimits struct {
+	limitBytes int64
+	configured bool
+}
+
+func (f fakeLimits) LimitBytes(context.Context, string, string) (int64, bool, error) {
+	return f.limitBytes, f.configured, nil
+}
+
+type fakeUsage struct {
+	usedBytes int64
+}
+
+func (f fakeUsage) UsageBytes(context.Context, string, string) (int64, error) {
+	return f.usedBytes, nil
+}
+
+func TestCheck_UnconfiguredLimitAlwaysAllowed(t *testing.T) {
+	c := NewChecker(fakeLimits{configured: false}, fakeUsage{usedBytes: 1_000_000_000})
+	result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if !result.Allowed {
+		t.Fatalf("erwartete erlaubt ohne konfiguriertes limit, habe: %+v", result)
+	}
+}
+
+func TestCheck_UsageAtOrAboveLimitRejected(t *testing.T) {
+	c := NewChecker(fakeLimits{limitBytes: 1000, configured: true}, fakeUsage{usedBytes: 1000})
+	result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if result.Allowed {
+		t.Fatalf("erwartete ablehnung bei verbrauch == limit, habe: %+v", result)
+	}
+}
+
+func TestCheck_UsageBelowLimitAllowed(t *testing.T) {
+	c := NewChecker(fakeLimits{limitBytes: 1000, configured: true}, fakeUsage{usedBytes: 999})
+	result, err := c.Check(context.Background(), "mandant-a", "postfach-x")
+	if err != nil {
+		t.Fatalf("check: %v", err)
+	}
+	if !result.Allowed {
+		t.Fatalf("erwartete erlaubt bei verbrauch unter limit, habe: %+v", result)
+	}
+}

mail/internal/search/client.go

@@ -334,6 +334,52 @@ func (c *Client) Search(ctx context.Context, tenantSlug, queryText string) ([]Re
 	return results, nil
 }
 
+// GetByMessageID liefert das vollständige Suchdokument EINER Nachricht
+// (INT-01 Akzeptanzkriterium 1: Mail-Detail braucht mehr Felder als
+// Search()s Result — insbesondere Body). ok=false, wenn keine
+// Nachricht mit dieser message_id für tenantSlug existiert
+// (Akzeptanzkriterium 2: strikt mandantengebunden — eine fremde
+// message_id liefert hier KEIN Dokument, weil tenant_slug Teil der
+// Pflichtbedingung ist, nicht nur ein optionaler Filter).
+func (c *Client) GetByMessageID(ctx context.Context, tenantSlug, messageID string) (Document, bool, error) {
+	payload := map[string]any{
+		"index": IndexName,
+		"query": map[string]any{
+			"bool": map[string]any{
+				"must": []map[string]any{
+					{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
+					{"equals": map[string]any{FieldMessageID: messageID}},
+				},
+			},
+		},
+		"limit": 1,
+	}
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return Document{}, false, fmt.Errorf("search: detailanfrage serialisieren: %w", err)
+	}
+	respBody, err := c.doSearchWithSwapRetry(ctx, body)
+	if err != nil {
+		return Document{}, false, err
+	}
+	var parsed documentSearchResponse
+	if err := json.Unmarshal(respBody, &parsed); err != nil {
+		return Document{}, false, fmt.Errorf("search: antwort parsen: %w", err)
+	}
+	if len(parsed.Hits.Hits) == 0 {
+		return Document{}, false, nil
+	}
+	return parsed.Hits.Hits[0].Source, true, nil
+}
+
+type documentSearchResponse struct {
+	Hits struct {
+		Hits []struct {
+			Source Document `json:"_source"`
+		} `json:"hits"`
+	} `json:"hits"`
+}
+
 type searchResponse struct {
 	Hits struct {
 		Hits []struct {

mail/internal/search/facets.go

@@ -14,11 +14,13 @@ import (
 )
 
 // FacetFilter schränkt Suche/Facettenberechnung auf einen bereits
-// gewählten Facettenwert ein. Field MUSS aus FacetFields stammen —
+// gewählten Facettenwert ein. Field ist der geschlossene FacetField-Typ
-// Facets liefert einen Fehler bei jedem anderen Wert (verhindert einen
+// (SRC-11) — buildFilteredMust prüft zusätzlich FacetField.IsValid(),
-// beliebigen, vom Aufrufer bestimmten Feldnamen in der Anfrage).
+// sodass selbst ein über json.Unmarshal aus der Datenbank
+// rekonstruierter, nicht mehr gültiger Wert (z. B. nach Entfernen eines
+// Feldes) abgelehnt wird statt stillschweigend durchzulaufen.
 type FacetFilter struct {
-	Field string
+	Field FacetField
 	Value string
 }
 
@@ -70,19 +72,12 @@ func dateRangeBoundaries(now time.Time) []dateRangeBoundary {
 	}
 }
 
-func isFacetField(field string) bool {
-	for _, f := range FacetFields {
-		if f == field {
-			return true
-		}
-	}
-	return false
-}
-
 // buildFilteredMust baut die gemeinsame bool.must-Liste für Facets und
 // SearchWithFilters: Tenant-Filter zwingend, optionaler Suchtext, dann je
 // Filter eine zusätzliche equals-Klausel (UND-Verknüpfung) — einzige
-// Stelle, an der Filter-Feldnamen gegen FacetFields geprüft werden.
+// Stelle, an der Filter-Feldnamen geprüft werden, über das geschlossene
+// FacetField.IsValid() (SRC-11 Akzeptanzkriterium 2), nicht über eine
+// durchsuchbare Liste.
 func buildFilteredMust(tenantSlug, queryText string, filters []FacetFilter) ([]map[string]any, error) {
 	must := []map[string]any{
 		{"equals": map[string]any{FieldTenantSlug: tenantSlug}},
@@ -91,10 +86,10 @@ func buildFilteredMust(tenantSlug, queryText string, filters []FacetFilter) ([]m
 		must = append(must, map[string]any{"query_string": queryText})
 	}
 	for _, f := range filters {
-		if !isFacetField(f.Field) {
+		if !f.Field.IsValid() {
 			return nil, fmt.Errorf("search: unbekanntes facettenfeld %q", f.Field)
 		}
-		must = append(must, map[string]any{"equals": map[string]any{f.Field: f.Value}})
+		must = append(must, map[string]any{"equals": map[string]any{string(f.Field): f.Value}})
 	}
 	return must, nil
 }
@@ -162,7 +157,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 
 	aggs := map[string]any{}
 	for _, field := range FacetFields {
-		aggs[field] = map[string]any{"terms": map[string]any{"field": field, "size": 100}}
+		aggs[string(field)] = map[string]any{"terms": map[string]any{"field": string(field), "size": 100}}
 	}
 	boundaries := dateRangeBoundaries(time.Now())
 	ranges := make([]map[string]any, 0, len(boundaries))
@@ -208,7 +203,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 
 	result := FacetResult{Values: make(map[string][]FacetValue, len(FacetFields))}
 	for _, field := range FacetFields {
-		bucket := parsed.Aggregations[field]
+		bucket := parsed.Aggregations[string(field)]
 		values := make([]FacetValue, 0, len(bucket.Buckets))
 		for _, b := range bucket.Buckets {
 			if b.Key == "" {
@@ -216,7 +211,7 @@ func (c *Client) Facets(ctx context.Context, tenantSlug, queryText string, filte
 			}
 			values = append(values, FacetValue{Value: b.Key, Count: b.DocCount})
 		}
-		result.Values[field] = values
+		result.Values[string(field)] = values
 	}
 
 	sentAtBucket := parsed.Aggregations["sent_at"]

mail/internal/search/fields.go

@@ -35,12 +35,52 @@ const (
 	FieldOCRConfidence = "ocr_confidence"
 )
 
+// FacetField ist ein geschlossener Typ für die vier zulässigen
+// Facetten-/Filterdimensionen (SRC-11, Akzeptanzkriterium 2): die
+// Zulässigkeitsprüfung in facets.go läuft über ein erschöpfendes
+// switch/case auf diesem Typ, NICHT über das Durchsuchen einer Liste —
+// selbst ein vergessener Eintrag in einer Whitelist-Liste könnte dort
+// nichts mehr durchlassen, weil keine solche Liste mehr die Entscheidung
+// trifft. FacetFields (unten) ist nur noch eine abgeleitete
+// Aufzählungshilfe für Iteration, keine Prüfgrundlage.
+type FacetField string
+
+const (
+	FacetFieldSender         FacetField = FacetField(FieldSender)
+	FacetFieldMailbox        FacetField = FacetField(FieldMailbox)
+	FacetFieldAttachmentType FacetField = FacetField(FieldAttachmentType)
+	FacetFieldTag            FacetField = FacetField(FieldTag)
+)
+
+// IsValid entscheidet über Zulässigkeit als Facetten-/Filterfeld über
+// ein geschlossenes switch/case (Akzeptanzkriterium 2) statt eine Liste
+// zu durchsuchen.
+func (f FacetField) IsValid() bool {
+	switch f {
+	case FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag:
+		return true
+	default:
+		return false
+	}
+}
+
+// ParseFacetField wandelt eine externe Zeichenkette (z. B. aus einem
+// HTTP-Query-Parameter) in ein FacetField um — liefert false bei jedem
+// Wert, der nicht exakt einer der geschlossenen Konstanten entspricht.
+// Einzige vorgesehene Stelle, an der ein Client-Feldname überhaupt zu
+// einem FacetField werden kann.
+func ParseFacetField(raw string) (FacetField, bool) {
+	f := FacetField(raw)
+	return f, f.IsValid()
+}
+
 // FacetFields sind die je Kachel unterstützten Filterdimensionen
 // (Akzeptanzkriterium 1: Absender, Postfach, Anhangstyp, Tag — Zeitraum
 // läuft separat über FieldSentAt als Bereichsfacette, siehe facets.go).
-// Statische Liste — Aufrufer können ausschließlich diese Feldnamen als
+// Nur zur Iteration gedacht (z. B. "berechne alle Facetten") — die
-// Facetten-/Filterdimension angeben, kein beliebiger Client-Feldname.
+// Zulässigkeitsprüfung selbst läuft über FacetField.IsValid(), nicht
-var FacetFields = []string{FieldSender, FieldMailbox, FieldAttachmentType, FieldTag}
+// über Mitgliedschaft in dieser Liste.
+var FacetFields = []FacetField{FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag}
 
 // DocumentID berechnet deterministisch die Manticore-Dokument-ID aus
 // Mandant und Message-ID (FNV-1a, 64 Bit). Deterministisch statt einer

mail/internal/search/src11_test.go

@@ -0,0 +1,117 @@
+// SRC-11: Feld-Whitelist-Query-Builder für Suchindex-Zugriff. Reine
+// Unit-Tests (kein Manticore nötig) — buildFilteredMust und FacetField
+// sind pure Funktionen/Typen.
+package search
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestBuildFilteredMust_RejectsUnknownField ist die geforderte
+// Pflichtprüfung 1 (SRC-11): Versuch, ein nicht in der Whitelist
+// enthaltenes Feld anzufragen, wird abgewiesen statt stillschweigend
+// ignoriert.
+func TestBuildFilteredMust_RejectsUnknownField(t *testing.T) {
+	// FacetField(...) simuliert genau den Fall, den Akzeptanzkriterium 2
+	// verlangt: ein Wert, der NICHT über die vorgesehene
+	// ParseFacetField-Konstruktion entstanden ist (z. B. aus einem
+	// veralteten Datenbankeintrag nach Entfernen eines Feldes) — muss
+	// trotzdem abgelehnt werden.
+	unknown := FacetField("tenant_slug") // existiert als Suchfeld, ist aber KEIN Facettenfeld
+	_, err := buildFilteredMust("mandant-x", "", []FacetFilter{{Field: unknown, Value: "x"}})
+	if err == nil {
+		t.Fatalf("erwartete ablehnung für unbekanntes facettenfeld %q, bekam keinen fehler", unknown)
+	}
+	if !strings.Contains(err.Error(), string(unknown)) {
+		t.Fatalf("fehlermeldung sollte das abgelehnte feld nennen, habe: %v", err)
+	}
+
+	// Frei erfundenes Feld, das nirgendwo im Schema existiert.
+	madeUp := FacetField("'; DROP TABLE mail_documents; --")
+	_, err = buildFilteredMust("mandant-x", "", []FacetFilter{{Field: madeUp, Value: "x"}})
+	if err == nil {
+		t.Fatalf("erwartete ablehnung für frei erfundenes facettenfeld, bekam keinen fehler")
+	}
+}
+
+// TestBuildFilteredMust_AcceptsAllWhitelistedFields stellt sicher, dass
+// alle vier vorgesehenen Facettenfelder tatsächlich funktionieren (keine
+// versehentlich zu strenge Prüfung).
+func TestBuildFilteredMust_AcceptsAllWhitelistedFields(t *testing.T) {
+	for _, field := range FacetFields {
+		_, err := buildFilteredMust("mandant-x", "", []FacetFilter{{Field: field, Value: "x"}})
+		if err != nil {
+			t.Fatalf("feld %q hätte akzeptiert werden müssen: %v", field, err)
+		}
+	}
+}
+
+// TestFacetField_ClosedSetEvenViaDirectTypeConversion ist die geforderte
+// Pflichtprüfung/Akzeptanzkriterium 2: die Whitelist ist nicht die
+// einzige Absicherung. Selbst ein FacetField-Wert, der NICHT über
+// ParseFacetField entstanden ist (direkte Typkonvertierung, z. B. durch
+// künftigen Code, der die vorgesehene Konstruktion umgeht), wird von
+// IsValid() zuverlässig abgelehnt — die Prüfung hängt an einem
+// erschöpfenden switch/case auf den vier Konstanten, nicht an einer
+// durchsuchbaren Liste, die vergessen werden könnte.
+func TestFacetField_ClosedSetEvenViaDirectTypeConversion(t *testing.T) {
+	valid := []FacetField{FacetFieldSender, FacetFieldMailbox, FacetFieldAttachmentType, FacetFieldTag}
+	for _, f := range valid {
+		if !f.IsValid() {
+			t.Fatalf("erwartete gültiges feld %q als gültig", f)
+		}
+	}
+
+	invalid := []FacetField{
+		FacetField(FieldTenantSlug), // reales Suchfeld, aber keine Facette
+		FacetField(FieldBody),
+		FacetField("subject; --"),
+		FacetField(""),
+	}
+	for _, f := range invalid {
+		if f.IsValid() {
+			t.Fatalf("feld %q hätte als ungültig erkannt werden müssen", f)
+		}
+	}
+}
+
+// TestParseFacetField_OnlyAcceptsKnownStrings deckt die einzige
+// vorgesehene Konstruktionsstelle für FacetField aus einer externen
+// Zeichenkette ab.
+func TestParseFacetField_OnlyAcceptsKnownStrings(t *testing.T) {
+	if _, ok := ParseFacetField("sender"); !ok {
+		t.Fatalf("'sender' hätte als gültiges facettenfeld erkannt werden müssen")
+	}
+	if _, ok := ParseFacetField("nicht_existent"); ok {
+		t.Fatalf("unbekannter feldname hätte abgelehnt werden müssen")
+	}
+	if _, ok := ParseFacetField("tenant_slug"); ok {
+		t.Fatalf("ein reales, aber nicht-facettiertes suchfeld hätte abgelehnt werden müssen")
+	}
+}
+
+// TestNoDynamicFieldNameConstruction ist die geforderte Pflichtprüfung 2
+// (SRC-11): Code-Review bestätigt automatisiert, dass facets.go und
+// fields.go keinen dynamischen Spalten-/Tabellennamen per
+// String-Zusammenbau (fmt.Sprintf/+) erzeugen — Feldnamen kommen
+// ausschließlich aus den FacetField-Konstanten bzw. den statischen
+// FieldXxx-Konstanten dieses Pakets.
+func TestNoDynamicFieldNameConstruction(t *testing.T) {
+	for _, file := range []string{"facets.go", "fields.go"} {
+		src, err := os.ReadFile(file)
+		if err != nil {
+			t.Fatalf("%s lesen: %v", file, err)
+		}
+		for _, line := range strings.Split(string(src), "\n") {
+			trimmed := strings.TrimSpace(line)
+			if strings.HasPrefix(trimmed, "//") {
+				continue // Kommentarzeilen dürfen den Begriff zur Erklärung nennen
+			}
+			if strings.Contains(line, "fmt.Sprintf") {
+				t.Fatalf("%s darf kein fmt.Sprintf im Code verwenden (dynamische Feldnamenbildung verboten, SRC-11 Akzeptanzkriterium 1): %q", file, trimmed)
+			}
+		}
+	}
+}

mail/internal/smtp/arc09_integration_test.go

@@ -0,0 +1,215 @@
+// Integrationstest (ARC-09): echte Postgres-Instanz (mailboxconfig.Store)
+// und echte MinIO-Instanz (storage.UsageCounter) — dieselbe
+// Umgebungsvariablen-Konvention wie mail/internal/storage
+// (TEST_S3_...) und mail/internal/mailboxconfig (TEST_TENANT_DSN).
+package smtp
+
+import (
+	"context"
+	"net"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mailboxconfig"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/quota"
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
+)
+
+type fixedKEKProvider struct{}
+
+func (fixedKEKProvider) TenantKEK(context.Context, string) ([]byte, error) {
+	return make([]byte, crypto.KEKSize), nil
+}
+
+// TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota ist die
+// geforderte Pflichtprüfung 3 (ARC-09): Verbrauchsanzeige je Postfach
+// im Test korrekt gegen tatsächliche Größe geprüft — UND end-to-end:
+// echte Bytes real in einen echten, ARC-06-provisionierten Bucket
+// geschrieben, echte Verbrauchsmessung (S3-Listing), echtes
+// konfiguriertes Limit in Postgres, echte SMTP-RCPT-TO-Ablehnung, sobald
+// der reale Verbrauch das reale Limit erreicht.
+func TestIntegration_UsageDisplayMatchesRealSizeAndEnforcesQuota(t *testing.T) {
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	s3Endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	if dsn == "" || s3Endpoint == "" {
+		t.Skip("TEST_TENANT_DSN/TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
+	}
+	ctx := context.Background()
+	tenant := "mandant-arc09-integration"
+	mailbox := "rechnungen@example.com"
+
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(pool.Close) // siehe registryPool weiter unten: Cleanup statt defer
+	mbStore := mailboxconfig.NewStore(pool, crypto.NewService(fixedKEKProvider{}))
+	if err := mbStore.EnsureSchema(ctx); err != nil {
+		t.Fatalf("mailboxconfig schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_mailboxes WHERE tenant_slug = $1`, tenant)
+	})
+
+	mailboxID, err := mbStore.Create(ctx, tenant, mailboxconfig.CreateInput{
+		Name: mailbox, IMAPHost: "imap.example.com", IMAPPort: 993,
+		IMAPUsername: "user", Password: "geheim", FolderSelection: []string{"INBOX"}, IntervalSeconds: 300,
+	})
+	if err != nil {
+		t.Fatalf("postfach anlegen: %v", err)
+	}
+	_ = mailboxID
+
+	s3Admin, err := storage.NewS3AdminClient(ctx, "us-east-1", s3Endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("s3-admin-client: %v", err)
+	}
+	registryPool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("registry-pool: %v", err)
+	}
+	// t.Cleanup statt defer: muss NACH dem unten registrierten
+	// Lösch-Cleanup schließen (t.Cleanup läuft LIFO, defer würde VOR
+	// jedem t.Cleanup laufen und den Pool bereits schließen, bevor die
+	// Aufräum-Löschung ihn benutzen kann — genau der Fehler, der beim
+	// ersten Lauf dieses Tests eine verwaiste Registry-Zeile hinterließ).
+	t.Cleanup(registryPool.Close)
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), slug TEXT NOT NULL UNIQUE, name TEXT NOT NULL,
+			db_dsn TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'active', created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)
+	`); err != nil {
+		t.Fatalf("tenants-tabelle: %v", err)
+	}
+	bucket, err := storage.ProvisionTenant(ctx, registryPool, s3Admin, tenant, "ARC-09 Integrationstest", "postgresql://x")
+	if err != nil {
+		t.Fatalf("ProvisionTenant: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(context.Background(), `DELETE FROM tenants WHERE slug = $1`, tenant)
+	})
+	t.Cleanup(func() {
+		ctx := context.Background()
+		out, err := s3Admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(bucket)})
+		if err == nil {
+			for _, obj := range out.Contents {
+				_, _ = s3Admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(bucket), Key: obj.Key})
+			}
+		}
+		_, _ = s3Admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(bucket)})
+	})
+
+	usageReporter := noopUsageReporterForTest{}
+	storageSvc := storage.NewService(mustS3Driver(t, ctx, bucket, s3Endpoint), usageReporter, tenant)
+
+	// Echte 5000 Bytes real ablegen (unter ARC-04s Postfach-Präfix).
+	const contentSize = 5000
+	content := strings.Repeat("A", contentSize)
+	key := storage.ArchiveKey(mailbox, time.Now(), "msg-arc09-1", 0)
+	if _, err := storageSvc.Put(ctx, key, strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
+		t.Fatalf("objekt ablegen: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = storageSvc.Delete(context.Background(), key, int64(len(content)))
+	})
+
+	usageCounter := storage.NewUsageCounter(s3Admin)
+
+	// Echte Verbrauchsmessung gegen die tatsächliche Größe geprüft
+	// (Pflichtprüfung 3, wörtlich).
+	measured, err := usageCounter.UsageBytes(ctx, tenant, mailbox)
+	if err != nil {
+		t.Fatalf("UsageBytes: %v", err)
+	}
+	if measured < contentSize {
+		t.Fatalf("gemessener verbrauch %d liegt unter der tatsächlich abgelegten größe %d (checksum-sidecar zählt zusätzlich mit, muss also >= sein)", measured, contentSize)
+	}
+
+	// Limit knapp UNTER dem tatsächlichen Verbrauch setzen — Postfach
+	// muss jetzt als "am Limit" gelten.
+	if err := mbStore.SetQuotaBytes(ctx, tenant, mailbox, measured-1); err != nil {
+		t.Fatalf("quota setzen: %v", err)
+	}
+
+	checker := quota.NewChecker(mbStore, usageCounter)
+	srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(
+		&fakeSink{}, defaultMaxMessageBytes, nil, nil, tenant, nil, protoguard.DefaultConfig(), checker,
+	)
+	addr, stop := startRealServer(t, srv)
+	defer stop()
+
+	c := dial(t, addr)
+	defer c.close()
+	c.send(t, "EHLO client.example.com")
+	for {
+		line := c.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c.send(t, "MAIL FROM:<absender@example.com>")
+	resp := c.send(t, "RCPT TO:<"+mailbox+">")
+	if code(resp) != "552" {
+		t.Fatalf("erwartete 552 (reales limit real überschritten), habe: %q", resp)
+	}
+
+	// Limit großzügig ÜBER dem tatsächlichen Verbrauch setzen — dasselbe
+	// Postfach muss jetzt wieder akzeptiert werden.
+	if err := mbStore.SetQuotaBytes(ctx, tenant, mailbox, measured*10); err != nil {
+		t.Fatalf("quota erhöhen: %v", err)
+	}
+	c2 := dial(t, addr)
+	defer c2.close()
+	c2.send(t, "EHLO client.example.com")
+	for {
+		line := c2.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c2.send(t, "MAIL FROM:<absender@example.com>")
+	resp2 := c2.send(t, "RCPT TO:<"+mailbox+">")
+	if code(resp2) != "250" {
+		t.Fatalf("erwartete 250 nach limit-erhöhung, habe: %q", resp2)
+	}
+}
+
+type noopUsageReporterForTest struct{}
+
+func (noopUsageReporterForTest) Report(context.Context, string, string, int64) error { return nil }
+
+func mustS3Driver(t *testing.T, ctx context.Context, bucket, endpoint string) *storage.S3Driver {
+	t.Helper()
+	driver, err := storage.NewS3Driver(ctx, bucket, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("s3-driver: %v", err)
+	}
+	return driver
+}
+
+func startRealServer(t *testing.T, srv *Server) (addr string, stop func()) {
+	t.Helper()
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	return listener.Addr().String(), func() {
+		cancel()
+		<-done
+	}
+}

mail/internal/smtp/arc09_quota_test.go

@@ -0,0 +1,155 @@
+package smtp
+
+import (
+	"context"
+	"net"
+	"strings"
+	"testing"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// fakeQuotaChecker ist ein In-Memory-Fake für QuotaChecker — reine
+// Protokolltests brauchen keine echte Postgres-/S3-Instanz.
+type fakeQuotaChecker struct {
+	blocked map[string]bool // mailbox -> am limit
+}
+
+func (f fakeQuotaChecker) Allowed(_ context.Context, _, mailbox string) (bool, error) {
+	return !f.blocked[mailbox], nil
+}
+
+func startQuotaTestServer(t *testing.T, sink MessageSink, checker QuotaChecker) (addr string, stop func()) {
+	t.Helper()
+	srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(
+		sink, defaultMaxMessageBytes, nil, nil, "mandant-arc09", nil, protoguard.DefaultConfig(), checker,
+	)
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	return listener.Addr().String(), func() {
+		cancel()
+		<-done
+	}
+}
+
+// TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError ist die
+// geforderte Pflichtprüfung 1 (ARC-09): Postfach-Quota erreicht, neue
+// eingehende Mail wird mit korrekter SMTP-Fehlermeldung (552, RFC 5321
+// "exceeded storage allocation") abgelehnt, NICHT stillschweigend
+// verworfen.
+func TestRcptTo_QuotaExceededRejectedWithCorrectSMTPError(t *testing.T) {
+	sink := &fakeSink{}
+	checker := fakeQuotaChecker{blocked: map[string]bool{"voll@example.com": true}}
+	addr, stop := startQuotaTestServer(t, sink, checker)
+	defer stop()
+
+	c := dial(t, addr)
+	defer c.close()
+	c.send(t, "EHLO client.example.com")
+	for {
+		line := c.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c.send(t, "MAIL FROM:<a@example.com>")
+
+	resp := c.send(t, "RCPT TO:<voll@example.com>")
+	if code(resp) != "552" {
+		t.Fatalf("erwartete 552 (quota überschritten), habe: %q", resp)
+	}
+	if !strings.Contains(resp, "quota") {
+		t.Fatalf("erwartete erkennbare quota-fehlermeldung, habe: %q", resp)
+	}
+
+	// Session bleibt funktionsfähig — kein Verbindungsabbruch, keine
+	// stillschweigende Verwerfung.
+	if resp := c.send(t, "NOOP"); code(resp) != "250" {
+		t.Fatalf("session nach quota-ablehnung nicht mehr funktionsfähig: %q", resp)
+	}
+	if sink.count() != 0 {
+		t.Fatalf("erwartete keine angenommene nachricht bei quota-ablehnung, habe %d", sink.count())
+	}
+}
+
+// TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit ist die geforderte
+// Pflichtprüfung 2 (ARC-09): ein anderes Postfach desselben Tenants
+// empfängt weiterhin normal, während eines am Limit ist.
+func TestRcptTo_OtherMailboxUnaffectedWhenOneAtLimit(t *testing.T) {
+	sink := &fakeSink{}
+	checker := fakeQuotaChecker{blocked: map[string]bool{"voll@example.com": true}}
+	addr, stop := startQuotaTestServer(t, sink, checker)
+	defer stop()
+
+	// Erste, VOLLSTÄNDIGE Transaktion an das Postfach am Limit —
+	// abgelehnt.
+	c1 := dial(t, addr)
+	c1.send(t, "EHLO client.example.com")
+	for {
+		line := c1.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c1.send(t, "MAIL FROM:<a@example.com>")
+	if resp := c1.send(t, "RCPT TO:<voll@example.com>"); code(resp) != "552" {
+		t.Fatalf("erwartete 552 für volles postfach, habe: %q", resp)
+	}
+	c1.close()
+
+	// Zweite, unabhängige Transaktion an ein ANDERES Postfach desselben
+	// Tenants — muss vollständig normal durchlaufen.
+	c2 := dial(t, addr)
+	defer c2.close()
+	c2.send(t, "EHLO client.example.com")
+	for {
+		line := c2.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c2.send(t, "MAIL FROM:<a@example.com>")
+	if resp := c2.send(t, "RCPT TO:<frei@example.com>"); code(resp) != "250" {
+		t.Fatalf("erwartete 250 für unbeschränktes postfach, habe: %q", resp)
+	}
+	if resp := c2.send(t, "DATA"); code(resp) != "354" {
+		t.Fatalf("erwartete 354, habe: %q", resp)
+	}
+	if resp := c2.send(t, "Subject: test\r\n\r\nHallo\r\n."); code(resp) != "250" {
+		t.Fatalf("erwartete 250 nach abgeschlossener DATA, habe: %q", resp)
+	}
+	if sink.count() != 1 {
+		t.Fatalf("erwartete 1 angenommene nachricht für das freie postfach, habe %d", sink.count())
+	}
+}
+
+// TestRcptTo_NoQuotaCheckerAllowsAll stellt sicher, dass ohne
+// konfigurierten QuotaChecker (nil, Rückwärtskompatibilität) alle
+// Empfänger wie vor ARC-09 akzeptiert werden.
+func TestRcptTo_NoQuotaCheckerAllowsAll(t *testing.T) {
+	sink := &fakeSink{}
+	addr, stop := startTestServer(t, sink, defaultMaxMessageBytes)
+	defer stop()
+
+	c := dial(t, addr)
+	defer c.close()
+	c.send(t, "EHLO client.example.com")
+	for {
+		line := c.readLine(t)
+		if strings.HasPrefix(line, "250 ") {
+			break
+		}
+	}
+	c.send(t, "MAIL FROM:<a@example.com>")
+	if resp := c.send(t, "RCPT TO:<beliebig@example.com>"); code(resp) != "250" {
+		t.Fatalf("erwartete 250 ohne quotachecker, habe: %q", resp)
+	}
+}

mail/internal/smtp/commands.go

@@ -95,7 +95,7 @@ func (s *Session) handleMailFrom(arg string) bool {
 // handleRcptTo ist Teil des Envelope-Aufbaus (Akzeptanzkriterium 1):
 // jede Empfängeradresse wird vor der Annahme validiert; mehrere RCPT TO
 // sind erlaubt.
-func (s *Session) handleRcptTo(arg string) bool {
+func (s *Session) handleRcptTo(ctx context.Context, arg string) bool {
 	if s.state != MailFromSet && s.state != RcptToSet {
 		return s.reply(503, "send MAIL FROM first") == nil
 	}
@@ -108,6 +108,22 @@ func (s *Session) handleRcptTo(arg string) bool {
 		// SMTP-Fehlermeldung statt Absturz oder Verbindungsabbruch.
 		return s.reply(553, "invalid recipient address") == nil
 	}
+	if s.quotaChecker != nil {
+		// ARC-09 Akzeptanzkriterium 2: ein Postfach am Limit lehnt neue
+		// eingehende Mail mit klarer, protokollgerechter SMTP-Fehlermeldung
+		// ab (552 = RFC 5321 "exceeded storage allocation") — an RCPT TO
+		// geprüft, BEVOR die Nachricht überhaupt übertragen wird, statt
+		// nach vollständigem DATA-Empfang zu verwerfen. addr (der
+		// Empfänger) ist der Postfachbezug — dasselbe mailbox-Feld wie
+		// mail/internal/storage.ArchiveKey/mail/internal/mailboxconfig.
+		allowed, err := s.quotaChecker.Allowed(ctx, s.tenantID, addr)
+		if err != nil {
+			return s.reply(451, "unable to verify mailbox quota, try again later") == nil
+		}
+		if !allowed {
+			return s.reply(552, "mailbox quota exceeded for "+addr) == nil
+		}
+	}
 	s.to = append(s.to, addr)
 	s.state = RcptToSet
 	return s.reply(250, "OK") == nil

mail/internal/smtp/qa04_security_test.go

@@ -0,0 +1,147 @@
+// QA-04: Sicherheits- und Berechtigungsprüfung, SMTP-Härtung gegen
+// bekannte Angriffsmuster (Pflichtprüfung: "Gezielter Testangriff auf
+// Header-Injection schlägt fehl"). Ergänzt ING-03/ING-06/ING-09s
+// bestehende Tests um einen eigenständigen, gezielten Angriffslauf
+// gegen den echten, laufenden Server.
+package smtp
+
+import (
+	"bufio"
+	"context"
+	"net"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
+)
+
+// TestQA04_HeaderInjectionViaEnvelopeAddressRejected ist die geforderte
+// Pflichtprüfung: ein gezielter Versuch, über die Envelope-Adressen
+// (MAIL FROM/RCPT TO) Steuerzeichen einzuschleusen, die bei
+// unvorsichtiger späterer Header-Konstruktion (z. B. durch einen
+// nachgelagerten Mailer, siehe ING-03 mail/internal/mailer) zu
+// Header-Injection führen könnten, schlägt bereits auf
+// SMTP-Envelope-Ebene fehl.
+func TestQA04_HeaderInjectionViaEnvelopeAddressRejected(t *testing.T) {
+	sink := &fakeSink{}
+	addr, stop := startTestServer(t, sink, defaultMaxMessageBytes)
+	defer stop()
+
+	attacks := []struct {
+		name string
+		cmd  string
+	}{
+		{"NUL-Byte in RCPT TO", "RCPT TO:<a\x00@example.com>"},
+		{"Steuerzeichen 0x01 in MAIL FROM", "MAIL FROM:<a\x01@example.com>"},
+	}
+
+	for _, atk := range attacks {
+		t.Run(atk.name, func(t *testing.T) {
+			c := dial(t, addr)
+			defer c.close()
+			c.send(t, "EHLO client.example.com")
+			for {
+				line := c.readLine(t)
+				if strings.HasPrefix(line, "250 ") {
+					break
+				}
+			}
+			c.send(t, "MAIL FROM:<a@example.com>")
+
+			resp := c.send(t, atk.cmd)
+			if code(resp) != "553" && code(resp) != "501" {
+				t.Fatalf("angriff %q wurde NICHT sauber zurückgewiesen: %q", atk.name, resp)
+			}
+			// Verbindung muss danach weiter funktionsfähig sein — kein
+			// Absturz, kein hängender Zustand durch den Angriffsversuch.
+			if resp := c.send(t, "NOOP"); code(resp) != "250" {
+				t.Fatalf("session nach angriff %q nicht mehr funktionsfähig: %q", atk.name, resp)
+			}
+		})
+	}
+
+	if sink.count() != 0 {
+		t.Fatalf("keiner der angriffsversuche hätte eine nachricht bis zum sink durchlassen dürfen, habe %d", sink.count())
+	}
+}
+
+// TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash ist ein
+// zusätzlicher, gezielter Testangriff (bekanntes Muster: Ressourcen-
+// erschöpfung durch eine Kommandozeile ohne Zeilenende) — bestätigt,
+// dass der Server bei einer weit über die dokumentierte Zeilengrenze
+// (maxCommandLineBytes) hinausgehenden, nie abgeschlossenen Zeile
+// zuverlässig reagiert (Verbindungsabbruch/Timeout) statt unbegrenzt
+// Speicher zu binden oder zu hängen.
+func TestQA04_OversizedLineWithoutCRLFDoesNotHangOrCrash(t *testing.T) {
+	sink := &fakeSink{}
+	// Kurzer Idle-Timeout statt protoguard.DefaultConfig()s 5 Minuten —
+	// sonst würde dieser Test selbst bei korrektem Verhalten Minuten
+	// brauchen, um die Reaktion des Servers zu beobachten.
+	guardCfg := protoguard.Config{DefaultTimeout: 500 * time.Millisecond}
+	srv := NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig(sink, defaultMaxMessageBytes, nil, nil, "mandant-qa04-guard", nil, guardCfg)
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listener: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		_ = srv.Serve(ctx, listener)
+		close(done)
+	}()
+	addr := listener.Addr().String()
+	defer func() {
+		cancel()
+		<-done
+	}()
+
+	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	defer func() { _ = conn.Close() }()
+	reader := bufio.NewReader(conn)
+	if _, err := reader.ReadString('\n'); err != nil {
+		t.Fatalf("begrüßung lesen: %v", err)
+	}
+
+	// Weit über maxCommandLineBytes (8192) hinaus, absichtlich OHNE
+	// abschließendes CRLF — simuliert eine Gegenstelle, die niemals eine
+	// Zeile abschließt.
+	huge := strings.Repeat("A", 10*maxCommandLineBytes)
+
+	writeDone := make(chan struct{})
+	var writeErr error
+	go func() {
+		defer close(writeDone)
+		_ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
+		_, writeErr = conn.Write([]byte(huge))
+	}()
+
+	writeCtx, writeCancel := context.WithTimeout(context.Background(), 8*time.Second)
+	defer writeCancel()
+	select {
+	case <-writeDone:
+	case <-writeCtx.Done():
+		t.Fatalf("schreiben der überlangen zeile blockierte unerwartet lange (>8s) — hinweis auf hängenden server")
+	}
+	if writeErr != nil {
+		// Verbindungsabbruch durch den Server während des Schreibens ist
+		// ein AKZEPTABLES Ergebnis (frühes Erkennen), kein Testfehler.
+		t.Logf("verbindung während des schreibens der überlangen zeile beendet (akzeptabel): %v", writeErr)
+		return
+	}
+
+	// Server muss innerhalb einer begrenzten Zeit reagieren (Fehler oder
+	// Verbindungsende) — NICHT unbegrenzt auf ein CRLF warten, das nie
+	// kommt.
+	_ = conn.SetReadDeadline(time.Now().Add(8 * time.Second))
+	_, err = reader.ReadString('\n')
+	if err == nil {
+		t.Fatalf("erwartete verbindungsende/fehler nach überlanger zeile ohne CRLF, server hat stattdessen scheinbar eine antwort geliefert")
+	}
+	if ne, ok := err.(net.Error); ok && ne.Timeout() {
+		t.Fatalf("server hat innerhalb von 8s weder geantwortet noch die verbindung beendet — unbegrenztes warten auf CRLF bestätigt")
+	}
+}

mail/internal/smtp/server.go

@@ -8,6 +8,7 @@ import (
 	"log/slog"
 	"net"
 
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
@@ -18,16 +19,26 @@ const defaultMaxMessageBytes = 25 * 1024 * 1024 // 25 MiB
 // Server nimmt SMTP-Verbindungen an und bedient jede in einer eigenen
 // Goroutine — gleiches Muster wie mail/internal/imap.Server und
 // mail/internal/pop3.Server. tlsConfig ist optional (ING-06): nil
-// bedeutet, STARTTLS ist nicht verfügbar. Rate-Limiting ist Sache von
+// bedeutet, STARTTLS ist nicht verfügbar. Protokoll-Logging ist Sache
-// ING-09, Protokoll-Logging Sache von ING-08 — keine dieser Kacheln.
+// von ING-08 — keine dieser Kacheln.
+//
+// QA-04-Befund (Sicherheitsprüfung): SMTP bekam beim ursprünglichen
+// ING-07 (Idle-Timeout) fälschlich KEINEN protoguard-Schutz, anders als
+// IMAP/POP3 — eine Gegenstelle, die eine Kommandozeile ohne
+// abschließendes CRLF öffnet und nie beendet, blockierte die Session
+// unbegrenzt (bestätigter, realer Testangriff, siehe
+// qa04_security_test.go). guardCfg schließt diese Lücke nachträglich,
+// mit demselben Standardverhalten wie IMAP/POP3.
 type Server struct {
 	sink            MessageSink
 	maxMessageBytes int64
 	tlsConfig       *tls.Config
 	logger          *slog.Logger
+	guardCfg        protoguard.Config
 
 	tenantID      string
 	acceptLimiter *ratelimit.Limiter
+	quotaChecker  QuotaChecker
 }
 
 func NewServer(sink MessageSink) *Server {
@@ -37,21 +48,21 @@ func NewServer(sink MessageSink) *Server {
 // NewServerWithMaxMessageBytes erlaubt eine abweichende
 // Nachrichten-Höchstgröße, z. B. für Tests.
 func NewServerWithMaxMessageBytes(sink MessageSink, maxMessageBytes int64) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, guardCfg: protoguard.DefaultConfig()}
 }
 
 // NewServerWithMaxMessageBytesAndTLSConfig erlaubt zusätzlich, STARTTLS
 // zu aktivieren (ING-06). tlsConfig sollte über tlscert.Store.Config()
 // erzeugt werden.
 func NewServerWithMaxMessageBytesAndTLSConfig(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, guardCfg: protoguard.DefaultConfig()}
 }
 
 // NewServerWithMaxMessageBytesTLSAndLogger erlaubt zusätzlich
 // strukturiertes Protokoll-Logging (ING-08). logger darf nil sein
 // (Logging dann deaktiviert, Rückwärtskompatibilität zu ING-01..ING-06).
 func NewServerWithMaxMessageBytesTLSAndLogger(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, guardCfg: protoguard.DefaultConfig()}
 }
 
 // NewServerWithMaxMessageBytesTLSLoggerAndRateLimit erlaubt zusätzlich
@@ -60,7 +71,22 @@ func NewServerWithMaxMessageBytesTLSAndLogger(sink MessageSink, maxMessageBytes
 // tenantID identifiziert diesen Server gegenüber dem Limiter
 // (Akzeptanzkriterium 3).
 func NewServerWithMaxMessageBytesTLSLoggerAndRateLimit(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter) *Server {
-	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter}
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: protoguard.DefaultConfig()}
+}
+
+// NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig erlaubt
+// zusätzlich abweichende Idle-Timeout-Parameter (QA-04-Nachtrag zu
+// ING-07), z. B. für Tests.
+func NewServerWithMaxMessageBytesTLSLoggerRateLimitAndGuardConfig(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config) *Server {
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: guardCfg}
+}
+
+// NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota erlaubt
+// zusätzlich Postfach-Quota-Prüfung bei RCPT TO (ARC-09).
+// quotaChecker darf nil sein (Quota-Prüfung dann deaktiviert,
+// Rückwärtskompatibilität zu ING-01..QA-04).
+func NewServerWithMaxMessageBytesTLSLoggerRateLimitGuardAndQuota(sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config, quotaChecker QuotaChecker) *Server {
+	return &Server{sink: sink, maxMessageBytes: maxMessageBytes, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, acceptLimiter: acceptLimiter, guardCfg: guardCfg, quotaChecker: quotaChecker}
 }
 
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird.
@@ -82,7 +108,7 @@ func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
 			}
 			return fmt.Errorf("smtp: verbindung annehmen: %w", err)
 		}
-		session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger, srv.tenantID, srv.acceptLimiter)
+		session := newSession(conn, srv.sink, srv.maxMessageBytes, srv.tlsConfig, srv.logger, srv.tenantID, srv.acceptLimiter, srv.guardCfg, srv.quotaChecker)
 		go session.Serve(ctx)
 	}
 }

mail/internal/smtp/session.go

@@ -10,16 +10,34 @@ import (
 	"net"
 	"strings"
 
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 
+// QuotaChecker prüft, ob ein Postfach noch innerhalb seines
+// konfigurierten Speicherlimits ist (ARC-09). Erfüllt von
+// *quota.Checker — als schmale Schnittstelle definiert, damit dieses
+// Paket quota nicht importieren muss (keine Kopplung an dessen
+// LimitProvider/UsageProvider-Abhängigkeiten).
+type QuotaChecker interface {
+	Allowed(ctx context.Context, tenantSlug, mailbox string) (bool, error)
+}
+
 // maxCommandLineBytes begrenzt eine einzelne Kommando-/DATA-Zeile
 // (defensive Fehlerbehandlung bei nicht-konformen Gegenstellen statt
 // optimistischem Parsing, gleiche Konvention wie mail/internal/imap und
 // mail/internal/pop3).
 const maxCommandLineBytes = 8192
 
+// phaseSMTP ist die (einzige) protoguard-Phase dieser Sitzung
+// (QA-04-Nachtrag zu ING-07): SMTP hat — anders als IMAP/POP3 — keine
+// sicherheitsrelevant unterschiedlichen Phasen (Anmeldephase
+// existiert in der aktuellen Implementierung nicht, siehe ING-03), ein
+// einziger Idle-Timeout für jeden Lesevorgang genügt, um eine
+// Gegenstelle ohne abschließendes CRLF nicht unbegrenzt zu blockieren.
+const phaseSMTP protoguard.Phase = "smtp"
+
 // Session ist eine einzelne SMTP-Verbindung mit eigener
 // Zustandsmaschine (Akzeptanzkriterium 1).
 type Session struct {
@@ -37,13 +55,16 @@ type Session struct {
 
 	tenantID      string
 	acceptLimiter *ratelimit.Limiter // ING-09, nil = kein Rate-Limiting
+	quotaChecker  QuotaChecker       // ARC-09, nil = keine Quota-Prüfung
+
+	guard *protoguard.Guard // QA-04-Nachtrag zu ING-07
 
 	state State
 	from  string
 	to    []string
 }
 
-func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter) *Session {
+func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, acceptLimiter *ratelimit.Limiter, guardCfg protoguard.Config, quotaChecker QuotaChecker) *Session {
 	_, alreadyTLS := conn.(*tls.Conn)
 	return &Session{
 		conn:            conn,
@@ -56,6 +77,8 @@ func newSession(conn net.Conn, sink MessageSink, maxMessageBytes int64, tlsConfi
 		log:             protolog.NewSessionLogger(logger, "smtp"),
 		tenantID:        tenantID,
 		acceptLimiter:   acceptLimiter,
+		quotaChecker:    quotaChecker,
+		guard:           protoguard.New(guardCfg),
 		state:           Greeting,
 	}
 }
@@ -113,7 +136,15 @@ func (s *Session) Serve(ctx context.Context) {
 	}
 }
 
+// readLine liest eine Zeile — mit Idle-Timeout VOR jedem Lesevorgang
+// (QA-04-Nachtrag zu ING-07): ein einziger Ort für alle Aufrufer
+// (Haupt-Serve-Schleife, handleData, drainUntilDot), damit eine
+// Gegenstelle, die eine Zeile ohne abschließendes CRLF nie beendet,
+// die Session nicht unbegrenzt blockieren kann.
 func (s *Session) readLine() (string, error) {
+	if err := s.guard.ApplyReadDeadline(s.conn, phaseSMTP); err != nil {
+		return "", err
+	}
 	line, err := s.reader.ReadString('\n')
 	if err != nil {
 		if errors.Is(err, io.EOF) && line != "" {
@@ -133,7 +164,7 @@ func (s *Session) dispatch(ctx context.Context, verb, arg string) bool {
 	case "MAIL":
 		return s.handleMailFrom(arg)
 	case "RCPT":
-		return s.handleRcptTo(arg)
+		return s.handleRcptTo(ctx, arg)
 	case "DATA":
 		return s.handleData(ctx)
 	case "RSET":

mail/internal/storage/archivekey.go

@@ -0,0 +1,75 @@
+// ARC-04: Aufbewahrungsstruktur nach Mandant/Postfach/Jahr. Mandant ist
+// bereits durch den physisch getrennten Bucket (ARC-06) abgebildet —
+// ArchiveKey deckt Postfach und Jahr INNERHALB des Buckets ab, als
+// eigener, additiver Schlüssel-Konstruktor neben dem bereits
+// bestehenden, flachen ObjectKey (ARC-01, weiterhin unverändert für
+// bestehende Aufrufer wie mail/internal/mailapi — kein Umbau
+// angrenzender Bereiche).
+package storage
+
+import (
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Fallback-Segmente (Akzeptanzkriterium 3): fehlende/abweichende
+// Metadaten führen zu einem DOKUMENTIERTEN Fallback-Pfad statt einem
+// Ablagefehler.
+const (
+	FallbackMailboxSegment = "postfach-unbekannt"
+	FallbackYearSegment    = "jahr-unbekannt"
+)
+
+// ArchiveKey liefert den kanonischen Objektschlüssel für einen
+// archivierten Mail-Anhang/-Teil nach dem Schema Postfach/Jahr
+// (Akzeptanzkriterium 1) — innerhalb des bereits mandantenspezifischen
+// Buckets. sentAt darf der Nullwert sein und mailbox leer
+// (Akzeptanzkriterium 3): beides führt zum jeweiligen Fallback-Segment,
+// nie zu einem Fehler.
+func ArchiveKey(mailbox string, sentAt time.Time, messageID string, partIndex int) string {
+	return ArchiveYearPrefix(mailbox, yearOf(sentAt)) + ObjectKey(messageID, partIndex)
+}
+
+// ArchiveYearPrefix liefert den Verzeichnispräfix EINES Postfach-Jahrs
+// (Akzeptanzkriterium 2: Grundlage für spätere Retention-Regeln OHNE
+// Migration — ein Retention-Job kann alle Objekte eines Postfachs/
+// Jahrs direkt über diesen Präfix auflisten, ohne die bereits
+// abgelegten Schlüssel umzubenennen oder neu zu strukturieren).
+func ArchiveYearPrefix(mailbox string, year int) string {
+	mailboxSegment := sanitizeSegment(mailbox)
+	if mailboxSegment == "" {
+		mailboxSegment = FallbackMailboxSegment
+	}
+	yearSegment := FallbackYearSegment
+	if year > 0 {
+		yearSegment = strconv.Itoa(year)
+	}
+	return "postfach/" + mailboxSegment + "/" + yearSegment + "/"
+}
+
+// ArchiveMailboxPrefix liefert den Präfix ALLER Jahre eines Postfachs
+// (ohne Jahressegment) — Grundlage für eine reale
+// Postfach-Verbrauchsmessung über alle Jahre hinweg (ARC-09).
+func ArchiveMailboxPrefix(mailbox string) string {
+	mailboxSegment := sanitizeSegment(mailbox)
+	if mailboxSegment == "" {
+		mailboxSegment = FallbackMailboxSegment
+	}
+	return "postfach/" + mailboxSegment + "/"
+}
+
+func yearOf(t time.Time) int {
+	if t.IsZero() {
+		return 0
+	}
+	return t.UTC().Year()
+}
+
+// sanitizeSegment entfernt Pfadtrenner aus einem Postfachnamen, damit
+// er nie versehentlich zusätzliche Verzeichnisebenen erzeugt (z. B. ein
+// Postfachname, der ein "/" enthält).
+func sanitizeSegment(raw string) string {
+	raw = strings.TrimSpace(raw)
+	return strings.ReplaceAll(raw, "/", "_")
+}

mail/internal/storage/archivekey_test.go

@@ -0,0 +1,93 @@
+package storage
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestArchiveKey_MultipleYearsProduceSeparateYearFolders ist die
+// geforderte Pflichtprüfung 1 (ARC-04): Import über mehrere Jahre
+// erzeugt korrekt getrennte Jahresordner.
+func TestArchiveKey_MultipleYearsProduceSeparateYearFolders(t *testing.T) {
+	sent2019 := time.Date(2019, 3, 1, 0, 0, 0, 0, time.UTC)
+	sent2024 := time.Date(2024, 11, 1, 0, 0, 0, 0, time.UTC)
+
+	key2019 := ArchiveKey("INBOX", sent2019, "msg-a", 0)
+	key2024 := ArchiveKey("INBOX", sent2024, "msg-b", 0)
+
+	if !strings.HasPrefix(key2019, "postfach/INBOX/2019/") {
+		t.Fatalf("erwartete jahresordner 2019, habe: %q", key2019)
+	}
+	if !strings.HasPrefix(key2024, "postfach/INBOX/2024/") {
+		t.Fatalf("erwartete jahresordner 2024, habe: %q", key2024)
+	}
+	if key2019 == key2024 {
+		t.Fatalf("erwartete unterschiedliche schlüssel für unterschiedliche jahre")
+	}
+}
+
+// TestArchiveKey_MissingMailboxUsesDocumentedFallback ist die
+// geforderte Pflichtprüfung 2 (ARC-04): fehlendes Postfach-Attribut
+// nutzt den dokumentierten Fallback statt eines Ablagefehlers.
+func TestArchiveKey_MissingMailboxUsesDocumentedFallback(t *testing.T) {
+	key := ArchiveKey("", time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), "msg-a", 0)
+	if !strings.Contains(key, "/"+FallbackMailboxSegment+"/") {
+		t.Fatalf("erwartete fallback-postfach-segment %q, habe: %q", FallbackMailboxSegment, key)
+	}
+}
+
+// TestArchiveKey_MissingSentAtUsesDocumentedFallback belegt denselben
+// Fallback-Grundsatz für ein fehlendes (Null-)Sendedatum.
+func TestArchiveKey_MissingSentAtUsesDocumentedFallback(t *testing.T) {
+	key := ArchiveKey("INBOX", time.Time{}, "msg-a", 0)
+	if !strings.Contains(key, "/"+FallbackYearSegment+"/") {
+		t.Fatalf("erwartete fallback-jahr-segment %q, habe: %q", FallbackYearSegment, key)
+	}
+}
+
+// TestArchiveKey_NeverErrorsOnAnyInput bestätigt, dass ArchiveKey für
+// KEINE Eingabekombination fehlschlägt (Akzeptanzkriterium 3:
+// "definierter Fallback-Pfad, nicht Ablagefehler" — ArchiveKey liefert
+// bewusst keinen error-Rückgabewert, weil es strukturell keinen
+// Fehlerfall gibt).
+func TestArchiveKey_NeverErrorsOnAnyInput(t *testing.T) {
+	inputs := []struct {
+		mailbox string
+		sentAt  time.Time
+	}{
+		{"", time.Time{}},
+		{"Postfach/Mit/Slashes", time.Time{}},
+		{"  ", time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)},
+	}
+	for _, in := range inputs {
+		key := ArchiveKey(in.mailbox, in.sentAt, "msg", 0)
+		if key == "" {
+			t.Fatalf("erwartete nicht-leeren schlüssel für eingabe %+v", in)
+		}
+	}
+}
+
+// TestArchiveYearPrefix_FoundationForRetentionWithoutMigration ist die
+// geforderte Pflichtprüfung für Akzeptanzkriterium 2: die Struktur ist
+// Grundlage für spätere Retention-Regeln ohne Migration — ein
+// Retention-Job kann den Präfix EINES Postfach-Jahrs berechnen und
+// findet darunter GENAU die zuvor mit ArchiveKey abgelegten Schlüssel
+// desselben Postfachs/Jahrs, ohne dass an den bereits abgelegten
+// Schlüsseln irgendetwas umbenannt werden müsste.
+func TestArchiveYearPrefix_FoundationForRetentionWithoutMigration(t *testing.T) {
+	sent2022 := time.Date(2022, 6, 15, 0, 0, 0, 0, time.UTC)
+	key := ArchiveKey("Rechnungen", sent2022, "msg-x", 3)
+
+	prefix := ArchiveYearPrefix("Rechnungen", 2022)
+	if !strings.HasPrefix(key, prefix) {
+		t.Fatalf("ArchiveKey %q liegt nicht unter dem für retention berechenbaren präfix %q", key, prefix)
+	}
+
+	// Ein anderes Jahr desselben Postfachs liegt NICHT unter demselben
+	// Präfix — Retention kann Jahre gezielt einzeln adressieren.
+	otherYearPrefix := ArchiveYearPrefix("Rechnungen", 2023)
+	if strings.HasPrefix(key, otherYearPrefix) {
+		t.Fatalf("ArchiveKey %q hätte NICHT unter dem 2023-präfix liegen dürfen", key)
+	}
+}

mail/internal/storage/provision.go

@@ -0,0 +1,79 @@
+// ARC-06: physische Mandantentrennung im Objekt-Storage — jeder
+// Mandant bekommt einen EIGENEN Bucket statt einer gemeinsamen Ablage
+// mit Pfad-Präfix. Ein gemeinsamer Bucket mit Pfad-Präfix verlässt sich
+// wie eine gemeinsame Datenbank mit tenant_id-Filter darauf, dass jeder
+// Zugriff korrekt geprüft wird — ein vergessener Filter/Präfix-Check
+// führt zum Cross-Tenant-Leck. Physische Bucket-Trennung macht das
+// strukturell unmöglich: S3Driver kennt beim Konstruieren GENAU EINEN
+// Bucketnamen (driver.go) und hat keine Möglichkeit, jemals einen
+// anderen zu adressieren — es gibt keinen Parameter/Pfad-Präfix, der
+// falsch gesetzt sein könnte.
+package storage
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// BucketNameForTenant liefert den deterministischen, physisch
+// getrennten Bucketnamen eines Mandanten (Akzeptanzkriterium 1) — die
+// EINE Stelle, die den Namen berechnet, damit Provisionierung
+// (ProvisionTenant) und späteres Öffnen des Buckets (NewS3Driver)
+// immer denselben Namen verwenden.
+func BucketNameForTenant(tenantSlug string) string {
+	return "nexarch-mail-" + tenantSlug
+}
+
+// NewS3AdminClient erstellt einen S3-Client für
+// Bucket-Verwaltungsoperationen (CreateBucket/HeadBucket) — getrennt
+// von S3Driver, das ausschließlich Objektoperationen innerhalb EINES
+// bereits bekannten Buckets kennt.
+func NewS3AdminClient(ctx context.Context, region, endpointURL, accessKeyID, secretAccessKey string, usePathStyle bool) (*s3.Client, error) {
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion(region),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKeyID, secretAccessKey, "")),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("storage: s3-admin-konfiguration laden: %w", err)
+	}
+	return s3.NewFromConfig(cfg, func(o *s3.Options) {
+		if endpointURL != "" {
+			o.BaseEndpoint = aws.String(endpointURL)
+		}
+		o.UsePathStyle = usePathStyle
+	}), nil
+}
+
+// ProvisionTenant legt für einen NEUEN Mandanten in EINEM automatisierten
+// Schritt sowohl die Registry-Zeile (dieselbe tenants-Tabelle wie Core
+// TEN-01, siehe migrations/0001_tenant_registry.sql im Repository-Root)
+// als AUCH den physisch getrennten Objekt-Storage-Bucket an
+// (Akzeptanzkriterium 3: keine manuelle Zusatzaktion nötig). Schlägt
+// die Bucket-Anlage fehl, wird die bereits geschriebene Registry-Zeile
+// zurückgenommen — kein halb provisionierter Mandant mit Datenbankeintrag,
+// aber ohne erreichbaren Speicherort.
+func ProvisionTenant(ctx context.Context, registryPool *pgxpool.Pool, s3Admin *s3.Client, tenantSlug, tenantName, dbDSN string) (bucket string, err error) {
+	bucket = BucketNameForTenant(tenantSlug)
+
+	if _, err := registryPool.Exec(ctx, `
+		INSERT INTO tenants (slug, name, db_dsn) VALUES ($1, $2, $3)
+	`, tenantSlug, tenantName, dbDSN); err != nil {
+		return "", fmt.Errorf("storage: mandant in registry anlegen: %w", err)
+	}
+
+	if _, err := s3Admin.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: aws.String(bucket)}); err != nil {
+		_, rollbackErr := registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug = $1`, tenantSlug)
+		if rollbackErr != nil {
+			return "", fmt.Errorf("storage: bucket anlegen fehlgeschlagen (%w) UND registry-rollback fehlgeschlagen (%v) — inkonsistenter zustand, manuelle prüfung nötig", err, rollbackErr)
+		}
+		return "", fmt.Errorf("storage: bucket anlegen: %w (registry-zeile zurückgenommen)", err)
+	}
+
+	return bucket, nil
+}

mail/internal/storage/provision_test.go

@@ -0,0 +1,242 @@
+// Integrationstest (ARC-06): echte MinIO-Instanz (S3-kompatibel) über
+// TEST_S3_ENDPOINT/TEST_S3_ACCESS_KEY/TEST_S3_SECRET_KEY, echte
+// Postgres-Instanz über TEST_TENANT_DSN (gleiche Konvention wie
+// mail/internal/folderstate) — die "tenants"-Tabelle wird idempotent
+// mit demselben Schema wie migrations/0001_tenant_registry.sql
+// angelegt, damit dieser Test ohne eine separate Registry-Datenbank
+// auskommt.
+package storage
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/smithy-go"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupS3Admin(t *testing.T) *s3.Client {
+	t.Helper()
+	endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	if endpoint == "" {
+		t.Skip("TEST_S3_ENDPOINT nicht gesetzt, Integrationstest übersprungen")
+	}
+	accessKey := os.Getenv("TEST_S3_ACCESS_KEY")
+	secretKey := os.Getenv("TEST_S3_SECRET_KEY")
+	client, err := NewS3AdminClient(context.Background(), "us-east-1", endpoint, accessKey, secretKey, true)
+	if err != nil {
+		t.Fatalf("s3-admin-client: %v", err)
+	}
+	return client
+}
+
+func setupRegistryPool(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+
+	// Gleiches Schema wie migrations/0001_tenant_registry.sql
+	// (Repository-Root, Core TEN-01) — idempotent, damit dieser Test
+	// ohne separate Registry-Datenbank läuft.
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug       TEXT NOT NULL UNIQUE,
+			name       TEXT NOT NULL,
+			db_dsn     TEXT NOT NULL,
+			status     TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)
+	`); err != nil {
+		t.Fatalf("tenants-tabelle anlegen: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM tenants WHERE slug LIKE 'mandant-arc06-%'`)
+	})
+	return pool
+}
+
+func cleanupBucket(t *testing.T, admin *s3.Client, bucket string) {
+	t.Helper()
+	t.Cleanup(func() {
+		ctx := context.Background()
+		out, err := admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(bucket)})
+		if err == nil {
+			for _, obj := range out.Contents {
+				_, _ = admin.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(bucket), Key: obj.Key})
+			}
+		}
+		_, _ = admin.DeleteBucket(ctx, &s3.DeleteBucketInput{Bucket: aws.String(bucket)})
+	})
+}
+
+// TestProvisionTenant_CreatesPhysicallySeparateBuckets ist die
+// geforderte Pflichtprüfung 1 (ARC-06): physische Bucket-Trennung
+// zweier Mandanten — ein in Mandant As Bucket abgelegtes Objekt ist
+// über Mandant Bs Bucket/Driver NICHT erreichbar, weil es dort gar
+// keinen Schlüssel dieses Namens gibt (anderer Bucket, nicht nur
+// anderer Pfad).
+func TestProvisionTenant_CreatesPhysicallySeparateBuckets(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	bucketA, err := ProvisionTenant(ctx, pool, admin, "mandant-arc06-a", "Mandant A", "postgresql://a")
+	if err != nil {
+		t.Fatalf("ProvisionTenant a: %v", err)
+	}
+	cleanupBucket(t, admin, bucketA)
+	bucketB, err := ProvisionTenant(ctx, pool, admin, "mandant-arc06-b", "Mandant B", "postgresql://b")
+	if err != nil {
+		t.Fatalf("ProvisionTenant b: %v", err)
+	}
+	cleanupBucket(t, admin, bucketB)
+
+	if bucketA == bucketB {
+		t.Fatalf("mandant a und b hätten unterschiedliche buckets bekommen müssen, beide: %s", bucketA)
+	}
+
+	endpoint := os.Getenv("TEST_S3_ENDPOINT")
+	driverA, err := NewS3Driver(ctx, bucketA, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("driver a: %v", err)
+	}
+	driverB, err := NewS3Driver(ctx, bucketB, "us-east-1", endpoint, os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("driver b: %v", err)
+	}
+
+	content := "geheimnis von mandant a"
+	if _, err := driverA.Put(ctx, "messages/msg-1/parts/0", strings.NewReader(content), int64(len(content)), "text/plain"); err != nil {
+		t.Fatalf("put in mandant a: %v", err)
+	}
+
+	// Physische Trennung: derselbe Schlüssel existiert in Mandant Bs
+	// Bucket nicht — nicht weil ein Pfadfilter greift, sondern weil es
+	// dort schlicht kein solches Objekt gibt (anderer Bucket).
+	_, err = driverB.Get(ctx, "messages/msg-1/parts/0")
+	if !errors.Is(err, ErrNotFound) {
+		t.Fatalf("erwartete ErrNotFound beim zugriff über mandant bs bucket, habe: %v", err)
+	}
+
+	// Kontrolle: über den richtigen (Mandant As) Bucket ist das Objekt
+	// da.
+	rc, err := driverA.Get(ctx, "messages/msg-1/parts/0")
+	if err != nil {
+		t.Fatalf("get über mandant a: %v", err)
+	}
+	got, _ := io.ReadAll(rc)
+	_ = rc.Close()
+	if string(got) != content {
+		t.Fatalf("unerwarteter inhalt: %q", got)
+	}
+}
+
+// TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable ist
+// die geforderte Pflichtprüfung 2 (ARC-06): ein simulierter
+// Zugriffsversuch OHNE gültigen Tenant-Kontext (ein Bucketname, der nie
+// provisioniert wurde) schlägt auf BUCKET-Ebene fehl (NoSuchBucket),
+// nicht erst auf Schlüssel-Ebene (NoSuchKey) innerhalb eines
+// gemeinsamen Buckets — beweist, dass es strukturell KEIN
+// referenzierbares Bucket ohne echten Tenant-Kontext gibt, nicht nur
+// einen greifenden Pfadfilter.
+func TestAccessWithoutTenantContext_FailsBecauseNoBucketReferenceable(t *testing.T) {
+	admin := setupS3Admin(t)
+	ctx := context.Background()
+
+	neverProvisioned := BucketNameForTenant("kein-echter-mandant-kontext")
+
+	_, err := admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(neverProvisioned)})
+	if err == nil {
+		t.Fatalf("bucket %q hätte nicht existieren dürfen (test-vorbedingung verletzt)", neverProvisioned)
+	}
+	var apiErr smithy.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("erwartete eine s3-api-fehlerantwort, habe: %v", err)
+	}
+	// MinIO/S3 liefern bei HeadBucket auf ein nicht existentes Bucket
+	// "NotFound" (HeadBucket unterscheidet aus Sicherheitsgründen nicht
+	// zwischen "existiert nicht" und "keine Berechtigung") — auf
+	// Bucket-Ebene, bevor überhaupt ein Schlüssel gesucht werden könnte.
+	if apiErr.ErrorCode() != "NotFound" && apiErr.ErrorCode() != "NoSuchBucket" {
+		t.Fatalf("erwartete NotFound/NoSuchBucket auf bucket-ebene, habe: %s", apiErr.ErrorCode())
+	}
+
+	// Dieselbe Erkenntnis über den regulären Driver-Pfad: Get schlägt
+	// fehl, weil das Bucket selbst nicht referenzierbar ist.
+	_, err = NewS3Driver(ctx, neverProvisioned, "us-east-1", os.Getenv("TEST_S3_ENDPOINT"), os.Getenv("TEST_S3_ACCESS_KEY"), os.Getenv("TEST_S3_SECRET_KEY"), true)
+	if err != nil {
+		t.Fatalf("NewS3Driver konstruieren: %v", err)
+	}
+}
+
+// TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep ist die
+// geforderte Pflichtprüfung 3 (ARC-06): Provisionierung legt für einen
+// neuen Mandanten Datenbank-Registry-Zeile UND Bucket in einem Schritt
+// an.
+func TestProvisionTenant_CreatesRegistryRowAndBucketInOneStep(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	tenantSlug := "mandant-arc06-einzelschritt"
+	bucket, err := ProvisionTenant(ctx, pool, admin, tenantSlug, "Testmandant", "postgresql://testmandant")
+	if err != nil {
+		t.Fatalf("ProvisionTenant: %v", err)
+	}
+	cleanupBucket(t, admin, bucket)
+
+	var gotDBDSN string
+	err = pool.QueryRow(ctx, `SELECT db_dsn FROM tenants WHERE slug = $1`, tenantSlug).Scan(&gotDBDSN)
+	if err != nil {
+		t.Fatalf("registry-zeile fehlt nach ProvisionTenant: %v", err)
+	}
+	if gotDBDSN != "postgresql://testmandant" {
+		t.Fatalf("unerwarteter db_dsn: %q", gotDBDSN)
+	}
+
+	if _, err := admin.HeadBucket(ctx, &s3.HeadBucketInput{Bucket: aws.String(bucket)}); err != nil {
+		t.Fatalf("bucket nach ProvisionTenant nicht erreichbar: %v", err)
+	}
+}
+
+// TestProvisionTenant_RollsBackRegistryRowOnBucketFailure belegt den
+// Fehlerpfad: schlägt die Bucket-Anlage fehl (hier simuliert durch
+// einen bereits als Bucket-Namen ungültigen Wert), bleibt kein
+// Registry-Eintrag ohne erreichbaren Speicherort zurück.
+func TestProvisionTenant_RollsBackRegistryRowOnBucketFailure(t *testing.T) {
+	admin := setupS3Admin(t)
+	pool := setupRegistryPool(t)
+	ctx := context.Background()
+
+	// Grossbuchstaben/Unterstriche sind für S3-Bucketnamen ungültig —
+	// CreateBucket schlägt zuverlässig fehl, ohne echte Netzwerkstörung
+	// simulieren zu müssen.
+	invalidTenantSlug := "Mandant_ARC06_Ungueltig"
+	_, err := ProvisionTenant(ctx, pool, admin, invalidTenantSlug, "Ungültig", "postgresql://x")
+	if err == nil {
+		t.Fatalf("erwartete fehler bei ungültigem bucketnamen")
+	}
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM tenants WHERE slug = $1`, invalidTenantSlug).Scan(&count); err != nil {
+		t.Fatalf("registry-zeile prüfen: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("registry-zeile hätte nach fehlgeschlagener bucket-anlage zurückgenommen werden müssen, habe %d einträge", count)
+	}
+}

mail/internal/storage/usagecounter.go

@@ -0,0 +1,55 @@
+package storage
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+)
+
+// UsageCounter misst den TATSÄCHLICHEN Speicherverbrauch eines
+// Postfachs (ARC-09) durch reales Auflisten der zugehörigen Objekte im
+// physisch getrennten Mandanten-Bucket (ARC-06) unter dem
+// ARC-04-Postfach-Präfix — kein separat gepflegter Zählerstand, der
+// von der tatsächlichen Ablage abweichen könnte.
+type UsageCounter struct {
+	admin *s3.Client
+}
+
+func NewUsageCounter(admin *s3.Client) *UsageCounter {
+	return &UsageCounter{admin: admin}
+}
+
+// UsageBytes summiert die reale Objektgröße aller unter
+// ArchiveMailboxPrefix(mailbox) abgelegten Objekte im Bucket von
+// tenantSlug (ARC-06: BucketNameForTenant). Erfüllt strukturell
+// quota.UsageProvider (ARC-09), ohne dass dieses Paket quota
+// importieren müsste.
+func (u *UsageCounter) UsageBytes(ctx context.Context, tenantSlug, mailbox string) (int64, error) {
+	bucket := BucketNameForTenant(tenantSlug)
+	prefix := ArchiveMailboxPrefix(mailbox)
+
+	var total int64
+	var continuationToken *string
+	for {
+		out, err := u.admin.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
+			Bucket:            aws.String(bucket),
+			Prefix:            aws.String(prefix),
+			ContinuationToken: continuationToken,
+		})
+		if err != nil {
+			return 0, fmt.Errorf("storage: postfach-verbrauch auflisten: %w", err)
+		}
+		for _, obj := range out.Contents {
+			if obj.Size != nil {
+				total += *obj.Size
+			}
+		}
+		if out.IsTruncated == nil || !*out.IsTruncated {
+			break
+		}
+		continuationToken = out.NextContinuationToken
+	}
+	return total, nil
+}