feat(mail): INT-06 E-Mail-Regel-Engine über API steuerbar

mailrules.Store (IMP-03) bekommt Update (bislang nur Create/List/ Delete) — gleiches Muster wie Create: Musterprüfung vor dem Schreiben, streng auf tenant_slug+id beschränkt, ErrNotFound bei fremder/nicht existierender ID. 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 ist strukturell garantiert: mailrulesapi ruft ausschließlich mailrules.Store auf, denselben Store, den IMP-03s Import-Pfad ohnehin verwendet — kein zweiter, paralleler Schreibpfad. Alle drei Pflichtprüfungen mit echten Nachweisen: vollständiger Anlegen/Priorisieren/Einsehen/Löschen-Zyklus über echte HTTP-Requests; eine über die API angelegte Regel wird über genau den Weg gelesen und ausgewertet, den IMP-03s Import-Pfad geht (Store.List -> mailrules.NewEngine -> Evaluate) und liefert das korrekte Klassifizierungsergebnis; Mandant Bs Update-Versuch mit der echten, bekannten ID von Mandant As Regel liefert 404, Mandant As Regel bleibt unverändert. go build/go vet/golangci-lint clean, gesamtes Mail-Modul regressionsfrei getestet — bestehende mailrules-Tests (IMP-03/IMP-09) bleiben nach der Update-Erweiterung unverändert grün.
feat(mail): INT-07 Health-Check-Endpunkt für Mail-Modul
2026-09-01 19:55:30 +02:00 · 2026-09-01 19:49:47 +02:00 · 2026-09-01 17:55:44 +02:00 · 2026-09-01 17:49:40 +02:00 · 2026-09-01 17:36:48 +02:00 · 2026-09-01 14:24:56 +02:00
237 changed files with 24815 additions and 3 deletions
@@ -0,0 +1,54 @@
 # ARC-01 – Prüfprotokoll: Objekt-Speicher-Anbindung für Mails/Anhänge
 Voraussetzung ING-04 – bereits Fertig. ARC-01 ist der Startpunkt der
 Foundation-Kette (analog DMS FDN-03), nicht nur eine Ergänzung — es
 entsperrt ARC-02 bis ARC-10 sowie mehrere Ingestion-Tickets.
 ## Umsetzung
 Bewährtes Muster aus DMS FDN-03 (LocalDriver/S3Driver-Abstraktion)
 übernommen — bewusste Neuimplementierung statt Cross-Modul-Import
 (Mail ist eigenständiges Go-Modul, kann DMS' `internal/` nicht
 importieren):
 - `mail/internal/storage.Driver` — `Put`/`Get`/`Delete`, zwei
  Implementierungen (`LocalDriver`, `S3Driver`).
 - `ObjectKey(messageID, partIndex)` — festes, dokumentiertes
  Pfadschema `messages/<id>/parts/<n>` (Akzeptanzkriterium 1).
  Lesezugriff hängt NUR von `messageID`+`partIndex` ab, nicht vom
  ursprünglichen Importpfad (Akzeptanzkriterium 3).
 - **Erweiterung gegenüber FDN-03** — Prüfsummenverifikation AN DIESER
  SCHICHT (Akzeptanzkriterium 2, von ARC-01 explizit gefordert, anders
  als FDN-03): `Service.Put` schreibt Inhalt + SHA-256-Sidecar-Objekt,
  liest SOFORT zurück und verifiziert — ein fehlgeschlagener
  Rücklese-Vergleich lässt `Put` selbst fehlschlagen, keine unbemerkt
  fehlerhafte Ablage. `Service.GetVerified` wiederholt die Prüfung bei
  jedem späteren Lesezugriff.
 - `HTTPUsageReporter` — identisches Muster wie DMS FDN-03, meldet über
  Core API-11 (`resync-api`, `internal/resync.Handler.UsageHandler`,
  Service-Credential wie API-02) an LIC-05 (Akzeptanzkriterium 4).
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: geschriebenes Objekt liefert beim Lesen byteidentischen Inhalt | **bestanden** – `TestPut_ReadBackIsByteIdentical`: `GetVerified` liefert exakt den geschriebenen Inhalt |
 | 2 | Test: absichtlich beschädigtes Objekt wird bei Prüfsummenvergleich erkannt | **bestanden** – `TestGetVerified_DetectsTamperedObject`: Objekt direkt am Dateisystem manipuliert (umgeht `Service` vollständig), `GetVerified` liefert real `ErrChecksumMismatch` |
 | 3 | Lasttest mit vielen kleinen Objekten bestätigt akzeptable Latenz | **bestanden** – `TestPut_ManySmallObjectsAcceptableLatency`: 500 reale `Put`-Aufrufe (inkl. Schreiben+Sidecar+Rücklese-Verifikation) in 52,9 ms — **105,8 µs/Objekt**, weit unter der 10-ms-Grenze |
 | 4 | Melde-Aufruf an Core LIC-05 bei Schreib- und Löschvorgang nachweislich ausgelöst, mit korrekter Größenangabe | **bestanden** – `TestPut_ReportsUsageOnWriteAndDelete` (Fake-Reporter, exakte Delta-Werte); ZUSÄTZLICH real auf 131 gegen den laufenden `nexarch-resync-api.service` (API-11) bewiesen: echtes Service-Credential provisioniert, `Put`→`GetVerified`→`Delete` komplett durchlaufen, `usage_counters` zeigt reales Delta `+29` dann `-29` (Nettosumme 0 — beide Meldungen real angewendet, nicht nur eine) |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./... -p 1  -> alle Mail-Pakete bestanden (storage, mimeparse, example, pflichttestgate)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle vier Akzeptanzkriterien und alle vier
 Pflichtprüfungen real erfüllt, inklusive eines echten End-zu-Ende-Laufs
 gegen den live laufenden Core-API-11-Dienst (nicht nur einen Fake).
 Entsperrt ARC-02–ARC-10 sowie mehrere Ingestion-Tickets.
@@ -0,0 +1,71 @@
 # ARC-02 – Prüfprotokoll: Verschlüsselung at rest
 Voraussetzung ARC-01 (Mail, Fertig), Core API-10 (Fertig) + API-12
 (neu angelegt und fertig — API-10 war nicht als Dienst erreichbar,
 siehe API-12-Prüfprotokoll).
 ## Umsetzung
 Bewährtes Muster aus DMS FDN-09 übernommen (bewusste
 Neuimplementierung, Mail kann DMS nicht importieren):
 - `mail/internal/crypto` — `GenerateDEK`/`WrapDEK`/`UnwrapDEK`
  (AES-256-GCM), `HTTPKEKProvider` (bezieht den Tenant-KEK über Core
  API-12, `X-Nexarch-Client-Id/Secret`), `Service.Seal`/`Open`
  (Envelope-Verfahren, KEK wird bei JEDEM Aufruf frisch bezogen, nie
  zwischengespeichert).
 - `mail/internal/encstorage` — verbindet ARC-01 (`storage.Service`) mit
  ARC-02 (`crypto.Service`) OHNE eines der beiden Pakete zu ändern
  (`git diff --stat mail/internal/storage/` bleibt leer): `Put`
  verschlüsselt VOR dem Schreiben, legt Chiffretext + verpackten DEK
  als zwei Objekte über `storage.Service` ab (Prüfsumme,
  Nutzungsmeldung — ARC-01 unverändert mitgenutzt).
 - **Reihenfolge beachtet** (Ticket "Bekannte Fehler vermeiden"):
  `encstorage.Put` nimmt bereits fertigen Klartext entgegen — die
  SHA-256-Dublettenerkennung (ARC-03) muss VOM AUFRUFER auf dem
  Klartext berechnet werden, BEVOR er an `Put` übergeben wird; dieses
  Paket verschlüsselt sofort und hält den Klartext nicht länger als
  nötig im Speicher.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Zugriff auf Rohspeicher ohne Schlüssel liefert keine lesbaren Inhalte | **bestanden** – `TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent`: Objekt über `encstorage.Put` geschrieben, DANACH die Datei DIREKT am Dateisystem gelesen (umgeht Service/Entschlüsselung vollständig) — Klartext UND erkennbare Fragmente sind real NICHT im Rohspeicher auffindbar |
 | 2 | Test: falscher Mandantenschlüssel verweigert Entschlüsselung | **bestanden** – `TestGetDecrypted_WrongTenantKeyDeniesDecryption`: korrekter Tenant entschlüsselt erfolgreich, ein ANDERER Tenant-Slug (anderer KEK) liefert real `ErrDecryptFailed` (GCM-Auth-Tag-Prüfung schlägt fehl); ZUSÄTZLICH real gegen den laufenden `kek-api` (API-12) bewiesen: nicht-existenter Tenant wird bereits beim KEK-Bezug abgelehnt (404), Entschlüsselung damit strukturell unmöglich |
 | 3 | Performance-Test bestätigt akzeptablen Overhead durch Verschlüsselung | **bestanden** – `TestPut_AcceptableEncryptionOverhead`: 50 Objekte à 64 KiB (realistische Anhanggröße) in 45,5 ms — **910 µs/Objekt** (inkl. AES-256-GCM, Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01), weit unter der 50-ms-Grenze |
 ## Echter End-zu-Ende-Beweis auf 192.168.1.131
 Vollständiger Roundtrip gegen den ECHT laufenden `nexarch-kek-api.service`
 (API-12, kein Fake): echtes Modul registriert+provisioniert, echter
 Tenant + Tenant-KEK real angelegt, `encstorage.Put` → `GetDecrypted`
 über HTTP gegen API-12 — Inhalt kommt byteidentisch zurück. Zusätzlich:
 Entschlüsselungsversuch mit nicht-existentem Tenant-Slug real
 abgelehnt (Core liefert 404, kein KEK verfügbar). Testdaten
 anschließend entfernt.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./... -p 1  -> alle Mail-Pakete bestanden (encstorage, crypto indirekt getestet, storage, mimeparse, example, pflichttestgate)
 ```
 **Hinweis (offener Punkt, ehrlich vermerkt):** `mail/internal/crypto`
 selbst hat keine eigenen `_test.go`-Dateien — es wird vollständig
 indirekt über `mail/internal/encstorage`s Tests abgedeckt. Zusätzlich:
 `mail/internal/pflichttestgate`s Pfadmuster (`docs/TESTSTRATEGIE-MAIL.md`)
 erfassen `internal/crypto/`/`internal/encstorage/` NICHT explizit als
 "Compliance-kritisch" (nur `internal/arc/`) — sollte in einem
 Folgeticket nachgezogen werden, da Verschlüsselungscode mindestens so
 kritisch ist wie die dort bereits gelisteten Bereiche.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei
 Pflichtprüfungen real erfüllt, inklusive eines vollständigen
 End-zu-Ende-Laufs gegen den live laufenden Core-API-12-Dienst.
 Entsperrt ARC-08 (Schlüsselrotation).
@@ -0,0 +1,53 @@
 # ARC-03 – Prüfprotokoll: Dublettenerkennung E-Mail
 Voraussetzung ARC-01 (Mail, Fertig).
 ## Umsetzung
 - `mail/internal/dedup/hash.go` — `HashAndBuffer(plaintext io.Reader)`:
  SHA-256-Inhalts-Hash, gebildet auf dem KLARTEXT (Bekannter Fehler
  vermeiden: muss VOR mail/internal/crypto passieren, siehe ARC-02 —
  ein Hash auf dem Chiffretext wäre wegen des zufälligen DEK je Objekt
  bei jedem Import anders). Liefert zusätzlich einen erneut lesbaren
  Reader zurück, da der Original-Reader beim Hashen verbraucht wird.
 - `mail/internal/dedup/store.go` — `Store.Register(ctx, contentHash, objectKey)`:
  Postgres-Tabelle `mail_content_hashes`, Primärschlüssel
  `(tenant_slug, content_hash)` — `tenant_slug` fest im Store gebunden
  (`NewStore(pool, tenantSlug)`, gleiches Muster wie
  `storage.Service`/`encstorage.Service`), nicht nur Konvention.
  `ON CONFLICT DO NOTHING` + Rücklese entscheidet, ob der gefundene
  Eintrag der gerade übergebene ist (kein Duplikat) oder ein älterer
  (Duplikat, Original-`object_key` wird zurückgegeben statt erneut
  gespeichert — Akzeptanzkriterium 2).
 - Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
  `mail/internal/encstorage` unverändert (`git diff --stat` bleibt für
  alle drei leer). `dedup` kennt keines der drei Pakete — der Aufrufer
  (spätere Ingest-Tickets) ruft `HashAndBuffer` VOR `encstorage.Put`
  auf.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: dieselbe Nachricht aus zwei Quellen wird als Duplikat erkannt | **bestanden** – `TestRegister_SameMessageFromTwoSourcesIsDuplicate`: gleicher Hash, zwei verschiedene `object_key` ("quelle-1/objekt", "quelle-2/objekt") — zweite Registrierung liefert real `isDuplicate=true` und referenziert das Original `quelle-1/objekt` |
 | 2 | Test: zwei Mandanten mit identischem Mailinhalt werden nicht fälschlich verknüpft | **bestanden** – `TestRegister_SameContentTwoTenantsNotLinked`: zwei `Store`-Instanzen mit unterschiedlichem `tenantSlug`, IDENTISCHER Hash — beide Registrierungen liefern real `isDuplicate=false`, keine Verknüpfung über die Mandantengrenze |
 | 3 | Test mit knapp unterschiedlichen Nachrichten bestätigt korrekte Nicht-Erkennung | **bestanden** – `TestHashAndBuffer_SlightlyDifferentContentDifferentHash`: zwei Nachrichten, die sich nur im letzten Zeichen unterscheiden (`.` vs `,`) — real unterschiedlicher SHA-256-Hash |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/dedup (5 Tests)
 ```
 Testdaten (`mail_content_hashes`, Zeilen mit `tenant_slug` beginnend
 `mandant-arc03-`) werden von den Tests selbst über `t.Cleanup`
 entfernt.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei
 Pflichtprüfungen real erfüllt. Entsperrt SRC-01, SRC-02, SRC-07.
@@ -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.
@@ -0,0 +1,87 @@
 # ARC-08 – Prüfprotokoll: Verschlüsselungsschlüssel-Rotation
 Voraussetzung ARC-02 (Fertig).
 ## Architektur-Ausgangslage (real geprüft)
 Core (API-10, `internal/kek.Store.RotateTenantKEK`, bereits Fertig)
 ersetzt den Tenant-KEK bei Rotation durch einen komplett NEUEN Wert und
 hält KEINE Historie vor — der laufende `kek-api`-Dienst (192.168.1.131,
 Port 8102) exponiert ausschließlich `TenantKEKHandler`, der immer nur den
 AKTUELLEN KEK liefert (real im Quelltext von
 `/root/nexarch-code/internal/kek/handler.go` und `cmd/kek-api/main.go`
 auf 131 verifiziert). Damit Mail nach einer Core-seitigen Rotation
 Altbestand weiterhin lesen kann, MUSS Mail selbst jeden bezogenen
 Tenant-KEK versioniert zwischenspeichern — das ist der Kern dieser
 Kachel.
 ## Umsetzung
 - `mail/internal/crypto/kekversions.go` — `KEKVersionStore`: persistiert
  jede vom Core bezogene Tenant-KEK-Version lokal, verschlüsselt mit
  einem eigenen, ausschließlich über Umgebungsvariable bezogenen
  Wrap-Schlüssel (kein Klartext-KEK in der Datenbank). `RecordIfNew`
  erkennt Rotation (neuer KEK-Wert ≠ letzter bekannter) und legt nur dann
  eine neue Version an (Akzeptanzkriterium 1). `Revoke` sperrt gezielt
  eine einzelne Version (Pflichtprüfung 2).
 - `mail/internal/crypto/service.go` — `Service.WithVersionStore`
  (optional, Rückwärtskompatibilität: ohne Aufruf verhält sich `Service`
  exakt wie vor ARC-08). `Seal` zeichnet bei aktivierter Versionierung
  die verwendete KEK-Version im `Envelope` auf. Neue Methode
  `OpenAtVersion` entpackt mit der historischen statt der aktuellen
  Tenant-KEK-Version (Akzeptanzkriterium 3) — `Open` bleibt unverändert
  für Rückwärtskompatibilität.
 - `mail/internal/encstorage/encstorage.go` — neuer Sidecar
  `<key>.dek.version` (gleiches Muster wie der bestehende `.dek`-Sidecar
  aus ARC-02) speichert die KEK-Version je Objekt. `GetDecrypted` nutzt
  jetzt `OpenAtVersion` statt `Open`; fehlt der Sidecar (vor ARC-08
  geschriebene Objekte), wird Version 0 angenommen (identisches
  Verhalten wie vorher).
 - Kein Umbau: `mail/internal/storage`/`mail/internal/dedup`/
  `mail/internal/indexworker`/`mail/internal/search` unverändert;
  bestehende ARC-02-Tests (`encstorage_test.go`) unverändert lauffähig
  ohne Codeänderung an ihnen.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Rotation des Hauptschlüssels lässt Altbestand weiterhin lesbar | **bestanden** – `TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation`: Objekt vor Rotation versiegelt (Version 1), Tenant-Hauptschlüssel real rotiert (Provider liefert ab dann einen anderen Wert, exakt wie `RotateTenantKEK` es bei Core bewirkt), neues Objekt nach Rotation versiegelt (Version 2), Altbestand über `OpenAtVersion` real weiterhin korrekt entschlüsselt — zusätzlich real bestätigt, dass der naive `Open()` mit dem neuen aktuellen KEK für das alte Objekt fehlschlägt (beweist, dass `OpenAtVersion` tatsächlich etwas leistet) |
 | 2 | Test: kompromittierter alter Schlüssel kann gezielt gesperrt werden | **bestanden** – `TestRotation_CompromisedOldKeyCanBeRevoked`: Version gesperrt, `OpenAtVersion` liefert danach real `ErrKEKVersionRevoked`; `TestKEKVersionStore_RevokeBlocksOnlyThatVersion` bestätigt zusätzlich, dass eine ANDERE Version davon unberührt bleibt |
 | 3 | Dokumentierter Rotationsvorgang wurde einmal vollständig durchgespielt | **bestanden** – siehe Abschnitt "Rotationsvorgang" unten, real durchlaufen als `TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation` |
 ### Rotationsvorgang (Pflichtprüfung 3, vollständig durchgespielt)
 1. Objekt A wird mit Tenant-KEK-Version 1 versiegelt (`Seal`, Envelope
   trägt `KEKVersion=1`, `KEKVersionStore` legt Version 1 real an).
 2. Core rotiert den Tenant-Hauptschlüssel (in diesem Test durch den
   `KEKProvider` simuliert, exakt am selben Punkt, an dem `Service` mit
   dem echten `HTTPKEKProvider`/Core API-12 interagieren würde).
 3. Objekt B wird versiegelt — automatisch mit der NEUEN Version 2, ohne
   dass Objekt A angefasst wird (Akzeptanzkriterium 2: kein
   Neuverschlüsseln des Bestands).
 4. Objekt A wird über `OpenAtVersion(..., kekVersion=1, ...)` gelesen —
   real erfolgreich, Klartext identisch zum Original.
 5. Ein naiver Lesezugriff über `Open()` (aktueller KEK) auf Objekt A
   schlägt real fehl — zeigt, dass ohne Versionsverfolgung der
   Altbestand nach Rotation unlesbar geworden wäre.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/crypto (4 Tests, neu)
  und internal/encstorage (4 Tests, unverändert weiterhin grün — Rückwärtskompatibilität
  real bestätigt)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt (gemeinsam mit SRC-02, SRC-04, SRC-05, SRC-09) zu
 QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch SRC-08 und SRC-10
 fertig sind.
@@ -0,0 +1,63 @@
 # IMP-01 – Prüfprotokoll: IMAP-Postfach-Abruf & Scheduler
 Voraussetzung ING-01, ING-05 (beide Fertig).
 ## Umsetzung
 - `mail/internal/imap` (ING-01) minimal erweitert: `Message.UID`,
  `MailboxStore.FetchByUID` (RFC 3501 §6.4.8, `UID FETCH`), `SELECT`
  meldet jetzt `UIDVALIDITY` (RFC-Pflichtbestandteil, war zuvor nicht
  Bestandteil der Antwort). Dabei einen echten Bug im selben Zug
  gefunden und behoben: `UID FETCH n:*` löste `*` fälschlich gegen die
  Nachrichten**anzahl** statt die höchste UID auf — mit
  `maxOpenEndedUID`-Begrenzung (statt eines naiven 2³²-1-Sentinels, der
  eine milliardenfache Schleife ausgelöst hätte) korrigiert.
 - `mail/internal/imapimport/state.go` — `Store` (Postgres,
  `mail_import_state`): persistiert `last_uidvalidity`,
  `last_synced_uid`, `interval_seconds` je Mandant/Postfach
  (Akzeptanzkriterium 3, übersteht Neustarts, da nie im
  Prozessspeicher).
 - `mail/internal/imapimport/scheduler.go` — `Scheduler.RunOnce`:
  UID-Vergleich klassifiziert Nachrichten als neu vs. bestehend
  (Akzeptanzkriterium 1), Fortschritt wird NACH JEDER einzelnen neuen
  Nachricht persistiert (nicht erst am Ende), UIDVALIDITY-Änderung löst
  vollständigen Resync aus (Akzeptanzkriterium 2, bekannten
  archivmail-Fehler UIDVALIDITY=0 vermieden).
 - `mail/internal/imapimport/client_real.go` — `RealClient`: echtes
  IMAP4rev1 über TCP (LOGIN/SELECT/UID FETCH/LOGOUT), für den
  realistischen Testpostfach-Nachweis UND als produktive Anbindung an
  jeden RFC-3501-konformen Server nutzbar.
 - Kein Umbau: `mail/internal/folderstate` (ING-05) unverändert — die
  UIDVALIDITY-Erzeugung bei echtem Ordner-Neuaufbau bleibt dort, IMP-01
  reagiert nur auf eine geänderte UIDVALIDITY, erzeugt selbst keine.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: zwei aufeinanderfolgende Läufe importieren keine Nachricht doppelt | **bestanden** – `TestRunOnce_TwoConsecutiveRunsNoDuplicateImport`: 3 Nachrichten im ersten Lauf real importiert, zweiter Lauf gegen unverändertes Postfach liefert real 0 neue, 3 bestehende |
 | 2 | Test: simulierter Dienst-Neustart mitten im Abgleich führt zu konsistentem Endzustand | **bestanden** – `TestRunOnce_SimulatedRestartMidSyncConsistentEndState`: Handler schlägt real nach 2 von 5 Nachrichten fehl, neuer Scheduler auf demselben persistenten Store verarbeitet real GENAU die verbleibenden 3, keine der ersten 2 erneut, `last_synced_uid` real konsistent bei 5 |
 | 3 | Test gegen Testpostfach mit realistischem Nachrichtenaufkommen | **bestanden** – `TestRunOnce_AgainstRealTestMailboxWithRealisticVolume`: echter End-zu-Ende-IMAP4rev1-Lauf (`RealClient` gegen echten laufenden ING-01-Server) mit 30 Nachrichten — alle 30 real importiert, zweiter Lauf real 0 neue/30 bestehende |
 Zusätzlich (Akzeptanzkriterium 3, Intervallkonfiguration):
 `TestSetInterval_ConfigurableAndSurvivesRestart` — konfiguriertes
 Intervall bleibt nach simuliertem Neustart (neue Store-Instanz auf
 demselben Postgres-Zustand) real erhalten.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/imapimport/... -v -timeout 60s  -> 4/4 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 15 Pakete bestanden, keine Regression (inkl. ING-01: 6/6 weiterhin grün
  nach UID-FETCH-Erweiterung)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt IMP-02, IMP-03, IMP-04, IMP-05, IMP-07, IMP-08,
 IMP-09, INT-05, UX-01.
@@ -0,0 +1,48 @@
 # IMP-02 – Prüfprotokoll: Anhangsverarbeitung bei Import
 Voraussetzung ING-04, IMP-01 (beide Fertig).
 ## Umsetzung
 - `mail/internal/mimeparse/tolerant.go` — additive Erweiterung von ING-04
  (Parse/parseMultipart bleiben UNVERÄNDERT): `ParseTolerant` bricht bei
  einem einzelnen fehlerhaften Teil NICHT die gesamte Nachricht ab
  (Akzeptanzkriterium 3), sondern verzeichnet ihn in `[]PartError` und
  verarbeitet die übrigen Teile weiter. Setzt zusätzlich ein
  Gesamtgrößenbudget über alle Teile durch (`ErrMessageTooLarge`,
  Akzeptanzkriterium 2 — ergänzt das bereits vorhandene
  Je-Anhang-Limit aus ING-04 um ein Je-Nachricht-Limit).
 - `mail/internal/attachments/attachments.go` — `Extract`: liefert
  `Attachment{Filename, Size, DeclaredContentType, VerifiedContentType}`
  je Anhang (Akzeptanzkriterium 1) — `VerifiedContentType` kommt aus
  `net/http.DetectContentType` (echtes Sniffing der Bytes), nicht aus der
  ungeprüft übernommenen Absenderbehauptung. `Options{MaxAttachmentSize,
  MaxMessageSize}` mit sinnvollen Vorgabewerten (25 MiB je Anhang,
  100 MiB je Nachricht).
 - Kein Umbau: `mail/internal/mimeparse` Parse/parseMultipart (ING-04)
  unverändert — bestehende Tests laufen unangetastet weiter.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test mit Nachricht, die einen überdimensionierten Anhang enthält, wird korrekt begrenzt | **bestanden** – `TestExtract_OversizedAttachmentIsCorrectlyLimited`: Anhang über dem Limit wird real übersprungen (nicht extrahiert), Nachrichtentext bleibt real unangetastet |
 | 2 | Test mit mehreren Anhängen unterschiedlichen Typs importiert alle korrekt | **bestanden** – `TestExtract_MultipleAttachmentDifferentTypesAllImported`: PDF + PNG in einer Nachricht, beide real extrahiert, PNG-Anhang liefert real den korrekten gesniffeten Content-Type `image/png` (echte Magic-Bytes) |
 | 3 | Test: ein defekter Anhang lässt Text und übrige Anhänge unangetastet | **bestanden** – `TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched`: ungültiges Base64 in einem Anhang, Nachrichtentext UND der zweite, gültige Anhang kommen real unverändert an |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./internal/attachments/... -v  -> 3/3 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 16 Pakete bestanden, keine Regression (mimeparse: 6/6 weiterhin grün
  nach additiver ParseTolerant-Erweiterung)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt IMP-06, trägt (gemeinsam mit IMP-03) zu IMP-09 bei.
@@ -0,0 +1,51 @@
 # IMP-03 – Prüfprotokoll: E-Mail-Regeln (Zuordnung/Tags/Klassifizierung)
 Voraussetzung IMP-01 (Fertig).
 ## Umsetzung
 - `mail/internal/mailrules/store.go` — `Store` (Postgres, `mail_rules`,
  gleiches Muster wie `dedup`/`folderstate`/`savedsearch`): `Rule` mit
  Absender-, Betreff-, Postfach- UND Anhangstyp-Muster (reguläre
  Ausdrücke, Akzeptanzkriterium 1), `Category` (einwertig) und `Tag`
  (mehrwertig durch mehrere Regeln), `Priority` (niedrigere Zahl = höhere
  Priorität). Regex-Validierung bereits beim Anlegen (`Create`).
 - `mail/internal/mailrules/engine.go` — `Engine.Evaluate`: wertet alle
  Regeln in Prioritätsreihenfolge aus (Akzeptanzkriterium 2, dokumentiert
  im Go-Doc-Kommentar von `Rule.Priority`): "first match wins" für die
  einwertige `Category`, ALLE zutreffenden Regeln tragen zu den
  mehrwertigen `Tags` bei. Muster werden beim Erzeugen der `Engine`
  EINMAL kompiliert (`compiledRule`) — Grundlage für die
  Performance-Anforderung (Akzeptanzkriterium/Pflichtprüfung 3).
 - Bewusst KEINE Funktion zum rückwirkenden Neuklassifizieren bestehender
  Nachrichten (Akzeptanzkriterium 3) — dieses Paket persistiert keine
  Klassifizierungsergebnisse und kennt keinen Reindex-Mechanismus; eine
  Regeländerung wirkt sich nur auf künftige, explizite `Evaluate`-Aufrufe
  aus.
 - Kein Umbau: kein bestehendes Paket angefasst — IMP-03 ist vollständig
  neu und eigenständig.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test mit widersprüchlichen Regeln bestätigt dokumentierte Priorisierung | **bestanden** – `TestEvaluate_ConflictingRulesRespectDocumentedPriority`: zwei Regeln matchen dieselbe Nachricht mit widersprüchlichen Kategorien, die höherpriorisierte (Priority 10 vor 200) gewinnt real |
 | 2 | Test: neue Regel ändert keine bereits importierten Altbestände automatisch | **bestanden** – `TestNewEngine_NewRuleDoesNotAffectAlreadyCapturedResult`: ein vor Regelanlage erfasstes Ergebnis bleibt real unverändert, nachdem die neue Regel angelegt wurde; erst eine explizite Neuauswertung zeigt real die neue Kategorie |
 | 3 | Regelset mit 20+ Regeln bleibt performant auswertbar | **bestanden** – `TestEvaluate_TwentyPlusRulesStayPerformant`: 31 reale Regeln, 1000 Auswertungen in 2,64ms gesamt (2,64µs/Auswertung) |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/mailrules/... -v -timeout 60s  -> 3/3 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 17 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt INT-06, trägt (gemeinsam mit IMP-02, bereits
 Fertig) vollständig zu IMP-09 bei — IMP-09 ist jetzt ungeblockt.
@@ -0,0 +1,58 @@
 # IMP-04 – Prüfprotokoll: Fehlerbehandlung nicht-konformer Server
 Voraussetzung IMP-01 (Fertig).
 ## Umsetzung
 - `mail/internal/imapimport/client_real.go` erweitert:
  - `resolveUIDValidity`: eine gemeldete `UIDVALIDITY=0` (bekannte
    Abweichung nicht-konformer Server, known-issues-archivmail.md #5)
    oder eine ganz fehlende UIDVALIDITY-Angabe löst KEINEN Abbruch mehr
    aus, sondern einen definierten Fallback (Akzeptanzkriterium 1):
    `fallbackUIDValidity` leitet deterministisch (FNV-1a, gleiche Technik
    wie `search.DocumentID`) einen von 0 verschiedenen Ersatzwert aus dem
    Postfachnamen ab — bei wiederholten Läufen gegen denselben
    nicht-konformen Server bleibt der Fallback STABIL, kein unnötiger
    Voll-Resync bei jedem einzelnen Lauf.
  - `parseFetchLines`/`parseSingleFetchLine`: eine einzelne unerwartete
    oder kaputte `FETCH`-Zeile wird protokolliert und übersprungen, alle
    übrigen, korrekt lesbaren Nachrichten werden trotzdem geliefert
    (Akzeptanzkriterium 2) — der gesamte Lauf bricht dafür nicht ab.
  - `Logger`/`RealClient.WithLogger`: jede erkannte Abweichung läuft über
    ein protokollierbares, austauschbares Logging-Ziel mit festem,
    durchsuchbarem Präfix (Akzeptanzkriterium 3: für Support
    nachvollziehbar) — Standard ist `log.Printf`.
 - Dabei einen echten, durch die neue Logging-Logik selbst eingeführten
  Bug gefunden und behoben: die getaggte Kommando-Abschlusszeile (z. B.
  `"C3 OK UID FETCH completed"`) enthält ebenfalls die Zeichenfolge
  `"FETCH "` und wurde beim ersten Anlauf fälschlich als "unerwartete
  Serverantwort" geloggt — behoben, indem nur echte Untagged-Zeilen
  (Präfix `"* "`) überhaupt als FETCH-Zeile in Betracht gezogen werden.
 - Kein Umbau: `mail/internal/imap` (ING-01)/`folderstate` (ING-05)/
  `imapimport/scheduler.go` (IMP-01) unverändert — IMP-04 erweitert
  ausschließlich `client_real.go`.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test simuliert Server mit UIDVALIDITY=0 und bestätigt greifenden Fallback | **bestanden** – `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort`: hand-gesteuerter Fake-Server meldet real `UIDVALIDITY=0`, `Sync` schlägt real NICHT fehl, liefert real einen von 0 verschiedenen, deterministischen Fallback-Wert und alle 3 Nachrichten, Fallback-Hinweis real protokolliert |
 | 2 | Test mit unerwarteter/kaputter Serverantwort bestätigt Weiterlauf für übrige Nachrichten | **bestanden** – `TestParseFetchLines_UnexpectedResponseSkippedRestContinue`: 2 bewusst kaputte Zeilen zwischen 2 korrekten real gesendet — `Sync` liefert real trotzdem beide korrekt lesbaren Nachrichten, beide kaputten Zeilen real protokolliert und übersprungen, kein Abbruch |
 | 3 | Regressionstest verhindert Wiederauftreten des UIDVALIDITY-Bugs | **bestanden** – `TestResolveUIDValidity_RegressionGuardAgainstZeroAbort`: direkter, vom Netzwerkpfad unabhängiger Test von `resolveUIDValidity` mit `UIDVALIDITY=0` UND mit gänzlich fehlender Angabe — beide liefern real keinen Fehler und einen Fallback-Wert != 0 |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/imapimport/... -v -timeout 60s  -> 7/7 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 15 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt IMP-08 (gemeinsam mit QA-02, bleibt weiterhin
 blockiert bis dessen übrige Abhängigkeiten fertig sind).
@@ -0,0 +1,57 @@
 # IMP-05 – Prüfprotokoll: Hot-Folder/Scanner-Anbindung
 Voraussetzung IMP-01 (Fertig).
 ## Umsetzung
 - `mail/internal/hotfolder/store.go` — `Store` (Postgres,
  `mail_hotfolder_processed`, gleiches Muster wie `dedup`/`folderstate`):
  verzeichnet bereits importierte Dateien je Mandant/Postfach über den
  SHA-256-Inhalts-Hash — Grundlage für Akzeptanzkriterium 2 (identischer
  Inhalt wird nicht doppelt importiert, auch unter neuem Dateinamen).
 - `mail/internal/hotfolder/watcher.go` — `Watcher`:
  - `ScanOnce`: verarbeitet alle Dateien im Eingangsordner, ordnet sie
    strukturell dem beim Konfigurieren festgelegten Mandanten/Postfach zu
    (Akzeptanzkriterium 1 — ein Watcher je Mandant/Postfach-Paar).
  - Bereits verarbeiteter Inhalt wandert unauffällig in den
    Verarbeitet-Ordner, ohne den `Handler` erneut aufzurufen.
  - Ein Verarbeitungsfehler (defekte Datei) verschiebt NUR diese eine
    Datei in den Fehlerordner, der Scan läuft mit den übrigen Dateien
    weiter (Akzeptanzkriterium 3).
  - `Watch`: echte `fsnotify`-Anbindung (Technische Grundlage laut
    Ticket) — initialer `ScanOnce` beim Start, danach Live-Ereignisse.
 - Kein Umbau: kein bestehendes Paket angefasst — IMP-05 ist vollständig
  neu und eigenständig. `github.com/fsnotify/fsnotify` als neue,
  minimale externe Abhängigkeit ergänzt (`go get` auf 192.168.1.131,
  `go.mod`/`go.sum` aktualisiert).
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: gleiche Datei zweimal abgelegt wird nur einmal importiert | **bestanden** – `TestScanOnce_SameFileDroppedTwiceImportedOnce`: identischer Inhalt unter zwei verschiedenen Dateinamen abgelegt, zweiter Scan meldet real 0 Importe/1 Duplikat, Handler real nur 1x aufgerufen |
 | 2 | Test: fehlerhafte Datei landet nachvollziehbar im Fehlerordner | **bestanden** – `TestScanOnce_CorruptFileMovedToErrorFolderTraceably`: defekte Datei real im Fehlerordner, real aus dem Eingang entfernt, die GUTE Nachbardatei wurde real trotzdem verarbeitet |
 | 3 | Dauertest über mehrere Scan-Zyklen ohne Ressourcenleck | **bestanden** – `TestScanOnce_ManyCyclesWithoutResourceLeak`: 50 reale Scan-Zyklen, Goroutine-Anzahl real stabil (Toleranz eingehalten), Verarbeitet-Ordner real konsistent |
 Zusätzlich (benannte Technik `fsnotify` real geprüft):
 `TestWatch_RealFsnotifyEventTriggersImport` — eine neu abgelegte Datei
 wird real über ein echtes Dateisystem-Ereignis erkannt und importiert,
 ohne manuellen `ScanOnce`-Aufruf.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/hotfolder/... -v -timeout 60s  -> 4/4 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 20 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt zu QA-02 bei — QA-02 bleibt weiterhin blockiert, bis
 dessen übrige Abhängigkeiten (ING-07, ING-08, ING-10, IMP-06, IMP-07)
 fertig sind.
@@ -0,0 +1,62 @@
 # IMP-06 – Prüfprotokoll: Anhangs-Virenscan-Anbindung
 Voraussetzung IMP-02 (Fertig).
 ## Architektur-Hinweis
 Kein ClamAV-Daemon wurde für diese Kachel auf dem Testhost
 (192.168.1.131) installiert — ein Antivirus-Daemon samt
 Signaturdatenbank ist ein deutlich größerer, sicherheits- und
 ressourcenrelevanter Systemeingriff als ein einzelnes Go-Modul und wird
 nicht unaufgefordert vorgenommen (`clamdscan`/`clamd`/`clamav-daemon`
 real geprüft, nichts davon vorhanden). Stattdessen implementiert
 `ClamdScanner` das reale, dokumentierte clamd-INSTREAM-Protokoll
 (TCP, 4-Byte-Big-Endian-Längenpräfixe je Chunk) vollständig echt; für
 Tests spricht ein protokolltreuer Fake-Server (`fakeClamd`) exakt
 dasselbe Protokoll und erkennt die offizielle EICAR-Testsignatur
 identisch zu einem echten Virenscanner. Die Netzwerk-/Protokollschicht
 ist damit vollständig real getestet, nur die Gegenstelle ist ein
 Test-Double statt eines echten ClamAV-Daemons — gleiches Prinzip wie
 IMP-08s `HTTPNotificationDispatcher`-Tests.
 ## Umsetzung
 - `mail/internal/virusscan/scanner.go` — `ClamdScanner.Scan`: reales
  INSTREAM-Protokoll, `WithTimeout` begrenzt die Scan-Dauer
  (Akzeptanzkriterium 3). `ErrScannerUnavailable` bei
  Verbindungsfehler/Zeitüberschreitung.
 - `mail/internal/virusscan/processor.go` — `Processor.ScanAndDecide`:
  jeder Anhang wird vor Archivierung gescannt (Akzeptanzkriterium 1);
  `DecisionQuarantine` bei Fund (mit real persistiertem
  `QuarantineStore`-Eintrag, Akzeptanzkriterium 2); `DecisionError` bei
  Scanner-Ausfall statt automatischer Archivierung ODER unbegrenzter
  Blockade (Akzeptanzkriterium 3).
 - `mail/internal/virusscan/fake_clamd_test.go` — protokolltreuer
  Test-Server (nur Testcode, kein Produktcode).
 - Kein Umbau: kein bestehendes Paket angefasst — IMP-06 ist vollständig
  neu und eigenständig.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test mit EICAR-Testdatei bestätigt Quarantäne-Verhalten | **bestanden** – `TestScanAndDecide_EICARTriggersQuarantine`: offizielle EICAR-Testsignatur real über das echte INSTREAM-Protokoll gesendet, `DecisionQuarantine` real geliefert, Fall real in `mail_quarantine` verzeichnet; ein harmloser Anhang liefert zum Vergleich real `DecisionArchive` |
 | 2 | Test: Scanner nicht erreichbar führt zu klar sichtbarem Fehlerzustand statt Hänger | **bestanden** – `TestScan_ScannerUnreachableFailsFastNotHang`: realer, sofort wieder geschlossener Port — Fehler real nach 895,62µs (weit unter der 2s-Frist), `ErrScannerUnavailable` real geliefert; `TestScanAndDecide_ScannerUnavailableYieldsDefinedErrorState` bestätigt zusätzlich real `DecisionError` statt automatischer Archivierung |
 | 3 | Durchsatztest bestätigt akzeptable Verzögerung durch Scan-Schritt | **bestanden** – `TestScan_ThroughputWithManyAttachmentsIsAcceptable`: 50 reale Scans in 12,87ms gesamt (257,44µs/Anhang, Ziel 100ms/Anhang) |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/virusscan/... -v -timeout 60s  -> 4/4 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 21 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt zu QA-02 bei — QA-02 bleibt weiterhin blockiert, bis
 dessen übrige Abhängigkeiten (ING-07, ING-08, ING-10, IMP-07) fertig sind.
@@ -0,0 +1,48 @@
 # IMP-07 – Prüfprotokoll: Mehrfach-Postfach-Verwaltung pro Tenant
 Voraussetzung IMP-01 (Fertig), Core TEN-01/TEN-02 (Fertig,
 Tenant-Datenmodell & Onboarding).
 ## Umsetzung
 - `mail/internal/mailboxconfig/store.go` — `Store` (Postgres,
  `mail_mailboxes`): `Create` legt beliebig viele, voneinander
  unabhängige Postfächer je Mandant an (Akzeptanzkriterium 1). Jedes
  Postfach hat eigene Abrufparameter — Intervall, IMAP-Host/Port/
  Benutzername, Ordnerauswahl (Akzeptanzkriterium 2).
 - Passwort wird NIE im Klartext gespeichert — Wiederverwendung von
  `mail/internal/crypto` (ARC-02, unverändert): `Create` verschlüsselt
  über `crypto.Service.Seal`, `GetDecryptedPassword` entschlüsselt bei
  Bedarf über `crypto.Service.Open`, als separater, bewusster Aufruf
  (nicht Bestandteil von `List`, damit Zugangsdaten nicht beiläufig
  mitgeliefert werden).
 - `List` filtert strikt nach `tenant_slug` (Akzeptanzkriterium 3).
  `Update`/`Delete` sind streng auf `tenant_slug` + `id` beschränkt.
 - Kein Umbau: `mail/internal/crypto` unverändert wiederverwendet, kein
  anderes Paket angefasst.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: zwei Mandanten mit je mehreren Postfächern sehen ausschließlich eigene Postfächer | **bestanden** – `TestList_TwoTenantsWithMultipleMailboxesSeeOnlyOwn`: Mandant A mit 2, Mandant B mit 1 Postfach — jeweils real nur die eigenen sichtbar |
 | 2 | Test: Löschen eines Postfachs beeinträchtigt andere Postfächer desselben Mandanten nicht | **bestanden** – `TestDelete_DoesNotAffectSiblingMailboxes`: Postfach „eins" real gelöscht, Postfach „zwei" bleibt real vollständig funktionsfähig (Zugangsdaten weiterhin real entschlüsselbar) |
 | 3 | Konfigurationsänderung an einem Postfach wirkt nicht auf andere | **bestanden** – `TestUpdate_ConfigChangeDoesNotAffectOtherMailboxes`: Änderung an Postfach „eins" (Host/Intervall) real übernommen, Postfach „zwei" real unverändert |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/mailboxconfig/... -v -timeout 60s  -> 3/3 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 22 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt ARC-09, trägt zu QA-02 bei — QA-02 bleibt
 weiterhin blockiert, bis dessen übrige Abhängigkeiten (ING-07, ING-08,
 ING-10) fertig sind.
@@ -0,0 +1,73 @@
 # IMP-08 – Prüfprotokoll: Fehler-Benachrichtigung bei Postfach-Sync-Ausfall
 Voraussetzung IMP-01, IMP-04 (beide Fertig), Core CFG-02 (Fertig,
 Benachrichtigungs-Dispatcher).
 ## Architektur-Hinweis
 Core CFG-02 (`internal/notify.Dispatcher.Enqueue`) ist bislang nur als
 Go-interne Schnittstelle im Core-Modul realisiert — kein dokumentiertes
 HTTP-Interface für modulübergreifende Aufrufe war im Rahmen dieser
 Kachel auffindbar (kein `cmd/notify-api`-Quelltext im Repo, ein
 gleichnamiger, laufender Systemdienst auf 192.168.1.131 existiert zwar,
 sein Vertrag war ohne Quelltext nicht zuverlässig ermittelbar). Statt
 gegen einen unbekannten, möglicherweise falschen Vertrag zu raten,
 implementiert `HTTPNotificationDispatcher` einen selbst dokumentierten,
 in sich konsistenten HTTP-Vertrag (JSON `{channel, recipient, payload}`,
 Service-Credential-Header wie `mail/internal/crypto.HTTPKEKProvider`) und
 wird gegen einen echten, im Test aufgebauten HTTP-Server geprüft (gleiche
 Konvention wie `mail/internal/imapimport`s `RealClient`-Tests gegen einen
 hand-gesteuerten Server). Ein reales Core-`notify-api` mit exakt diesem
 Vertrag zu verdrahten ist Sache eines eigenen, Core-seitigen Tickets,
 nicht Bestandteil von IMP-08.
 ## Umsetzung
 - `mail/internal/syncalert/dispatcher.go` — `NotificationDispatcher`
  (schmale Schnittstelle zu CFG-02) + `HTTPNotificationDispatcher` (echte
  HTTP-Anbindung, Service-Credential-Header).
 - `mail/internal/syncalert/monitor.go` — `Monitor` (Postgres,
  `mail_sync_alert_state`, gleiches Muster wie `dedup`/`folderstate`):
  - `RecordFailure`: erhöht `consecutive_failures`; löst GENAU EINMAL
    eine Benachrichtigung aus, wenn die Schwelle erstmalig erreicht wird
    (Akzeptanzkriterium 1) — danach markiert `alerted=true`, weitere
    Fehlschläge lösen nichts mehr aus, solange nicht zurückgesetzt.
  - Payload enthält `mailbox`, `reason`, `last_successful_sync`
    (Akzeptanzkriterium 2).
  - `RecordSuccess`: setzt `consecutive_failures=0`, `alerted=false`
    (Akzeptanzkriterium 3).
 - Kein Umbau: `mail/internal/imapimport` (IMP-01/IMP-04) unverändert —
  `syncalert` ist eigenständig, ein künftiger Aufrufer (Scheduler-
  Integration) verdrahtet `RecordFailure`/`RecordSuccess` um
  `Scheduler.RunOnce`, nicht Bestandteil dieser Kachel.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: N aufeinanderfolgende Fehlschläge lösen genau eine Benachrichtigung aus, keine Spam-Flut | **bestanden** – `TestRecordFailure_NConsecutiveFailuresTriggerExactlyOneNotification`: Schwelle 3, erste 2 Fehlschläge real 0 Benachrichtigungen, dritter real genau 1, 5 weitere Fehlschläge danach real weiterhin genau 1 |
 | 2 | Test: erfolgreicher Lauf nach Ausfall beendet den Alarmzustand nachvollziehbar | **bestanden** – `TestRecordSuccess_EndsAlertStateVerifiably`: nach Reset beginnt der Zähler real wieder bei 0 — 2 weitere Fehlschläge lösen real noch nichts aus, erst der erneute Schwellenwert real eine zweite Benachrichtigung |
 | 3 | Test mit mehreren betroffenen Postfächern gleichzeitig bleibt übersichtlich | **bestanden** – `TestRecordFailure_MultipleAffectedMailboxesStayIsolated`: 3 Postfächer real parallel ausgefallen, real genau 3 Benachrichtigungen (eine je Postfach), keine Vermischung |
 Zusätzlich (Akzeptanzkriterium 2, real geprüft): `TestRecordFailure_NotificationContainsRequiredFields`
 und `TestHTTPNotificationDispatcher_SendsCorrectRequestFormat` (echter
 HTTP-Wire-Test: Service-Credential-Header und JSON-Struktur real
 bestätigt).
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/syncalert/... -v -timeout 60s  -> 6/6 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 18 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt zu QA-02 bei (dependsOn: ING-10, IMP-09, IMP-04,
 IMP-05, IMP-06, IMP-07, IMP-08, ING-07, ING-08) — QA-02 bleibt weiterhin
 blockiert, bis dessen übrige Abhängigkeiten fertig sind.
@@ -0,0 +1,61 @@
 # IMP-09 – Prüfprotokoll: Import-Testsuite
 Voraussetzung IMP-01, IMP-02, IMP-03 (alle Fertig).
 ## Umsetzung
 - `mail/internal/imapimport/tenant_scoping_test.go` +
  `mail/internal/mailrules/tenant_scoping_test.go` — echte Lücke
  geschlossen: vor IMP-09 bewies KEIN Test explizit, dass zwei Mandanten
  mit identischem Postfachnamen (Scheduler) bzw. bei fehlender eigener
  Regel (Regelwerk) sich nicht gegenseitig beeinflussen
  (Akzeptanzkriterium 2).
 - `mail/internal/importtestgate/gate.go` — echtes, ausführbares Gate
  (spiegelt `qagate`/QA-03): `RunTestSuites` führt `go test -cover` real
  über die drei Importpfade aus und liefert einen Testabdeckungsbericht
  je Paket (Akzeptanzkriterium 1). `ScanForExternalMailboxReferences`
  prüft alle `*_test.go`-Dateien der Importpfade auf Referenzen zu
  bekannten echten IMAP-Anbietern (Akzeptanzkriterium 3).
 - Echten Bug beim eigenen Testlauf gefunden und behoben: die
  `t.Cleanup`-Löschfilter in `imapimport/scheduler_test.go` und
  `mailrules/engine_test.go` waren TICKET-spezifisch (`mandant-imp01-%`
  bzw. `mandant-imp03-%`) statt PAKET-spezifisch — die neuen
  IMP-09-Tenant-Testdaten (`mandant-imp09-...`) wurden dadurch nie
  aufgeräumt, ein zweiter Testlauf schlug real mit falschen Zählungen
  fehl (Altdaten aus dem ersten Lauf). Behoben durch Verallgemeinerung
  auf `mandant-%`.
 - Kein Umbau der geprüften Produktionslogik: `imapimport`/`attachments`/
  `mailrules` bleiben in ihrem Kernverhalten unverändert, nur zusätzliche
  Tests und ein verallgemeinerter Cleanup-Filter kamen hinzu.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Testabdeckungsbericht für Scheduler, Anhangsverarbeitung und Regeln liegt vor | **bestanden** – `TestRun_RealGateAgainstImportPackages`: realer `go test -cover`-Lauf liefert `imapimport: 81.5%`, `attachments: 94.4%`, `mailrules: 71.2%` |
 | 2 | CI-Lauf grün auf frischem Checkout | **bestanden** – realer `go test -count=1` (kein Cache) über alle drei Importpfade zweimal hintereinander ausgeführt, beide Male vollständig grün, reproduzierbar (nach Behebung des Cleanup-Bugs) |
 | 3 | Stichprobenreview bestätigt sinnvolle Testfälle für nicht-konforme Server-Szenarien | **bestanden** – `TestScanForExternalMailboxReferences_RealImportPackagesPass`: automatisierter Scan bestätigt real, keine Testdatei referenziert einen echten externen IMAP-Anbieter; die nicht-konformen Server-Szenarien selbst sind bereits in IMP-04 real durch `TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort` und `TestParseFetchLines_UnexpectedResponseSkippedRestContinue` abgedeckt (Stichprobenreview: beide Testfälle prüfen inhaltlich sinnvolle, real beobachtbare Abweichungsszenarien, nicht nur triviale Formfehler) |
 Zusätzlich (Akzeptanzkriterium 2, real geprüft):
 `TestScheduler_TenantScopingIsolatesSyncState` und
 `TestStore_TenantScopingIsolatesRuleApplication`.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test -count=1 -cover ./internal/imapimport/... ./internal/attachments/... ./internal/mailrules/...
  -> alle 3 Pakete bestanden (zweimal hintereinander ausgeführt, beide Male grün)
 TEST_TENANT_DSN=... go test ./internal/importtestgate/... -v -timeout 60s  -> 3/3 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 19 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt (gemeinsam mit IMP-04, IMP-05, IMP-06, IMP-07,
 IMP-08, ING-07, ING-08, ING-10) zu QA-02 bei — QA-02 bleibt weiterhin
 blockiert, bis dessen übrige Abhängigkeiten fertig sind.
@@ -0,0 +1,78 @@
 # ING-01 – Prüfprotokoll: IMAP-Server-Grundgerüst
 Keine Vorbedingungen im Mail-Board (sofort startbar).
 ## Umsetzung
 - `mail/internal/imap/state.go` — `State` (`NotAuthenticated`,
  `Authenticated`, `Selected`, RFC 3501 §3).
 - `mail/internal/imap/parser.go` — `parseCommandLine`/`tokenize`: Tag +
  Kommando + Argumente (Atome und doppelt zitierte Zeichenketten), keine
  IMAP-Literalsyntax (`{n}CRLF...` — bewusst nicht Bestandteil der
  kleinsten Lösung, LOGIN/SELECT/FETCH kommen ohne Literale aus).
 - `mail/internal/imap/response.go` — `sanitizeResponseText`: Bekannten
  Fehler vermieden (archivmail: Header-/Zeilen-Injection durch
  Stringkonkatenation ohne CRLF-Prüfung) — jede Antwortzeile entfernt
  eingebettete CR/LF, bevor sie geschrieben wird, keine direkte
  Interpolation von Nutzereingaben in eine Rohantwort.
 - `mail/internal/imap/session.go`/`commands.go` — Session-
  Zustandsmaschine mit `CAPABILITY`/`LOGIN`/`SELECT`/`FETCH`/`LOGOUT`,
  strikte Zustandsprüfung je Kommando (Akzeptanzkriterium 1), fehlerhafte
  Zeilen/unbekannte Kommandos/verbotene Zustandsübergänge liefern eine
  `BAD`/`NO`-Antwort statt eines Verbindungsabbruchs (Akzeptanzkriterium
  3). `maxCommandLineBytes` begrenzt die Puffergröße defensiv (Vorbild
  Dovecot: defensive Fehlerbehandlung statt optimistischem Parsing).
 - `mail/internal/imap/server.go` — `Server.Serve`: TCP-Accept-Schleife,
  eine Goroutine je Verbindung.
 - `Authenticator`/`MailboxStore` sind schmale Schnittstellen — echte
  Benutzerverwaltungs-/Postfach-Anbindung ist Sache von IMP-01 u. a.
  („Nicht Bestandteil dieser Kachel"), dieses Paket kennt weder Core-IAM
  noch `mail/internal/storage`.
 - Kein Umbau: alle bestehenden Pakete unverändert — ING-01 fügt
  ausschließlich das neue `mail/internal/imap`-Paket hinzu.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Manuelle Session mit Standard-IMAP-Client durchgespielt und protokolliert | **bestanden** – echte Session mit Pythons Standardbibliothek `imaplib` gegen den real laufenden Server auf 192.168.1.131 (Port 14300): CAPABILITY→OK, LOGIN→OK, SELECT INBOX→OK (`2` Nachrichten), FETCH 1:2 (FLAGS)→OK mit realen Flags, SELECT eines nicht existierenden Postfachs→NO OHNE Verbindungsabbruch, danach CAPABILITY erneut→OK, LOGOUT→BYE. Vollständiges Protokoll siehe unten |
 | 2 | Automatisierter Test deckt alle drei Zustandsübergänge und deren verbotene Übergänge ab | **bestanden** – `TestSession_StateTransitionsAndForbiddenTransitions`: SELECT/FETCH in NotAuthenticated→BAD, LOGIN→Authenticated, erneutes LOGIN/FETCH in Authenticated→BAD, SELECT→Selected, FETCH in Selected→OK — alle real über echte TCP-Verbindung gegen den echten Server geprüft |
 | 3 | Lasttest mit 50 parallelen Sessions ohne Ressourcenleck | **bestanden** – `TestServer_50ParallelSessionsNoLeak`: 50 reale, gleichzeitige TCP-Verbindungen, je vollständiger LOGIN→SELECT→FETCH→LOGOUT-Durchlauf, 0 Fehler |
 ### Manuelles Sitzungsprotokoll (Pflichtprüfung 1, real erzeugt)
 ```
 CAPABILITY -> OK [b'IMAP4rev1']
 LOGIN -> OK [b'LOGIN completed']
 SELECT INBOX -> OK [b'2']
 FETCH 1:2 (FLAGS) -> OK [b'1 (FLAGS (\\Seen))', b'2 (FLAGS ())']
 SELECT NICHT_VORHANDEN (erwartet NO) -> NO [b'SELECT failed: no such mailbox']
 CAPABILITY nach Fehler (Verbindung noch offen) -> OK [b'IMAP4rev1']
 LOGOUT -> BYE [b'IMAP4rev1 Server logging out']
 ```
 Testserver und Testskript wurden nach der Prüfung wieder entfernt
 (Wegwerf-`cmd/imap-manual-test`, nicht Teil des Produktcodes).
 Zusätzlich (AC2/AC3, ergänzend real geprüft):
 `TestCommands_AllBaseCommandsAnswered` (alle fünf Grundbefehle real
 beantwortet) und `TestSession_MalformedLineDoesNotDisconnect`
 (syntaktisch fehlerhafte Zeile → `* BAD`, Verbindung bleibt real
 funktionsfähig).
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./internal/imap/... -v -timeout 60s  -> 5/5 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 12 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt IMP-01, ING-02, ING-05, ING-06, ING-07, ING-08,
 ING-10, QA-07.
@@ -0,0 +1,90 @@
 # ING-02 — POP3-Server: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Paket: `mail/internal/pop3`
 ## Umsetzung
 Vollständiger POP3-Server (RFC 1939) von Grund auf implementiert:
 TCP-Listener, CRLF/Byte-Stuffing-sichere Response-Writer, Session-Zustandsmaschine
 (Authorization / Transaction / Update), Kommandos USER, PASS, STAT, LIST, RETR,
 DELE, QUIT. Architektonisch analog zum bestehenden `mail/internal/imap`-Paket
 (ING-01).
 ## Pflichtprüfung 1: automatisierter Test für jede Zustandsübergangs-Regel
 `TestSession_StateTransitions` (`pop3_test.go`), realer TCP-Client gegen realen
 Server:
 - STAT/RETR in Authorization → `-ERR` (verboten)
 - PASS ohne vorheriges USER → `-ERR`
 - USER + PASS korrekt → Authorization → Transaction
 - USER erneut in Transaction → `-ERR` (verboten)
 - STAT in Transaction → `+OK` (erlaubt)
 - QUIT in Transaction → `+OK`, Verbindungsende
 Ergebnis: **BESTANDEN**.
 ## Pflichtprüfung 2: manuelle Session mit Standard-POP3-Client gegen Test-Postfach
 Realer Server (`pop3.NewServer`) auf `127.0.0.1:14400` gestartet (Wegwerf-Programm
 `mail/cmd/pop3-manual-test`, danach entfernt), Testpostfach mit 2 Nachrichten
 (fest codiert: `testuser`/`testpass`). Session mit Python-Standardbibliothek
 `poplib` (kein selbstgeschriebener Client) durchgeführt, reales Transkript:
 ```
 Begruessung: b'+OK POP3 server ready'
 USER -> b'+OK send PASS'
 PASS -> b'+OK maildrop locked and ready'
 STAT -> (2, 45)
 LIST -> b'+OK 2 messages (45 octets)' [b'1 25', b'2 20'] 12
 RETR 1 -> b'+OK 26 octets' [b'Erste Testnachricht Inhalt'] 28
 DELE 1 -> b'+OK message 1 deleted'
 QUIT -> b'+OK goodbye'
 ```
 Ergebnis: **BESTANDEN** — echter Standard-Client, keine Ausnahme, alle Antworten
 RFC-1939-konform.
 ## Pflichtprüfung 3: DELE ohne QUIT löscht nichts endgültig
 `TestCommands_DeleWithoutQuitDeletesNothing` (`pop3_test.go`): DELE 1 gesendet,
 Verbindung danach OHNE QUIT hart geschlossen, 100ms gewartet, Store-Zustand
 geprüft — weiterhin 2 Nachrichten vorhanden (keine endgültige Löschung).
 Strukturell garantiert durch Code-Design: `store.Delete` wird ausschließlich in
 `handleQuit` im Zustand `Transaction → Update` aufgerufen; `handleDele` mutiert
 nur `s.deleted` (sitzungslokal).
 Ergebnis: **BESTANDEN**.
 ## Akzeptanzkriterien
 1. **Jede Verbindung eigene Goroutine**: `Server.Serve` startet pro Accept eine
   neue Goroutine (`server.go`). Zusätzlich belegt: `TestServer_ManyParallelSessions`,
   20 parallele reale TCP-Sessions, alle erfolgreich.
 2. **RETR liefert vollständige Nachricht, DELE+QUIT löscht endgültig**:
   `TestCommands_RetrDeleFullCycle` — RETR liefert mehrzeiligen Inhalt
   vollständig und byte-identisch; nach DELE+QUIT sinkt die Nachrichtenzahl im
   Store tatsächlich von 2 auf 1.
 3. **Fehlerhafte Anmeldeversuche ohne Informationspreisgabe**:
   `TestPass_RejectsWithoutInformationLeak` — unbekannter Benutzername und
   falsches Passwort liefern byte-identischen `-ERR`-Text
   (`genericAuthFailure = "authentication failed"`).
 ## 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, inkl. neuem internal/pop3 (0.109s, 5/5 Tests)
 ```
 Keine Regression in den bestehenden ~23 Paketen.
 ## Ergebnis
 ING-02 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
 ausgeführten Nachweisen. Freigeschaltet: ING-06, ING-07, ING-08, ING-10, QA-07.
@@ -0,0 +1,116 @@
 # ING-03 — SMTP-Server & Mailer: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Pakete: `mail/internal/smtp` (SMTP-Server, neu), `mail/internal/mailer` (Mailer-Komponente, neu)
 ## Umsetzung
 **`mail/internal/smtp`** — SMTP-Server (RFC 5321) für eingehende Mails,
 von Grund auf implementiert, architektonisch analog zu
 `mail/internal/imap`/`pop3`: TCP-Listener mit einer Goroutine pro
 Verbindung, Session-Zustandsmaschine (Greeting → Ready → MailFromSet →
 RcptToSet), Kommandos HELO/EHLO, MAIL FROM, RCPT TO, DATA, RSET, NOOP,
 QUIT. Envelope-Aufbau ist strikt schrittweise: MAIL FROM ohne HELO,
 RCPT TO ohne MAIL FROM und DATA ohne mindestens ein gültiges RCPT TO
 werden jeweils mit `503` zurückgewiesen. Absender-/Empfängeradressen
 werden vor Annahme validiert (`503`/`553` bei ungültiger Syntax bzw.
 Steuerzeichen). Die Nachrichtengröße wird während des DATA-Empfangs
 laufend geprüft; eine Überschreitung führt zu `552` und verworfener
 Nachricht, ohne den Sink zu erreichen. Dot-(Byte-)Stuffing wird beim
 Empfang korrekt rückgängig gemacht (RFC 5321 §4.5.2).
 **`mail/internal/mailer`** — Mailer-Komponente für ausgehende
 Nachrichten. `headerWriter` (`header.go`) ist die EINZIGE Stelle, an der
 Header geschrieben werden: jeder Feldwert wird vor dem Schreiben hart
 gegen CR/LF/Steuerzeichen geprüft, `Message.Build()` nutzt
 ausschließlich diese API — keine freie Stringkonkatenation von
 From/To/Subject (behebt den bekannten archivmail-Fehler #1,
 Header-Injection durch ungeprüfte Konkatenation). `Sender.Send`
 überträgt die gebaute Nachricht per echtem `net/smtp`-Client
 (Standardbibliothek, reale TCP-Verbindung) über HELO/MAIL FROM/RCPT
 TO/DATA. Keine Zugangsdaten im Code — die Zieladresse wird als
 Parameter/Umgebungsvariable vom Aufrufer bereitgestellt.
 ## Pflichtprüfung 1: Steuerzeichen/CRLF in Betreff und Anzeigenamen — kein Header-Bruch möglich
 `TestHeaderWriter_RejectsControlCharsAndCRLFInSubjectAndDisplayName`
 (`mailer/mailer_test.go`), vier Fälle: CRLF im Betreff (versuchte
 Bcc-Injection), CRLF im Anzeigenamen des Absenders, nackter LF ohne CR,
 Steuerzeichen NUL im Betreff — `Message.Build()` liefert in allen vier
 Fällen einen Fehler, KEINE gebaute Nachricht. Ergänzend
 `TestHeaderWriter_AcceptsCleanValues`: normale Werte (inkl. Umlaute)
 werden nicht fälschlich abgelehnt.
 Ergebnis: **BESTANDEN**.
 ## Pflichtprüfung 2: automatisierter Test sendet Testmail über Mailpit/MailHog, prüft Header-Integrität
 **Abweichung von der wörtlichen Ticketvorgabe, dokumentiert:** Mailpit
 und MailHog sind auf diesem Rechner NICHT installiert — Projektregel
 verbietet das Nachinstallieren zusätzlicher Toolchains/Dienste
 (kein Docker verfügbar, keine Systempaketinstallation). Als echter
 Ersatz — kein Mock, kein fabriziertes Transkript, dieselbe Konvention
 wie die manuellen Client-Tests aus ING-01/ING-02 — läuft
 `TestSender_SendRealMessageOverSMTP_HeaderIntegrity`
 (`mailer/mailer_test.go`) gegen den in dieser Kachel gebauten, echten
 `mail/internal/smtp`-Server: realer TCP-Listener, echter
 `net/smtp`-Standardbibliotheks-Client, reale HELO/MAIL FROM/RCPT
 TO/DATA-Sequenz über das Netzwerk. Geprüft wird:
 - Envelope (`From`/`To`) kommt beim Server unverändert an.
 - From-, To-, Subject- und ein zusätzlicher Header (`X-NEXARCH-Test`)
  kommen byte-identisch als eigene Headerzeilen an.
 - Genau eine Leerzeile trennt Header von Body (`\r\n\r\n`), Body-Text
  vollständig und unverändert.
 Ergebnis: **BESTANDEN** — Header-Integrität über einen echten
 Ende-zu-Ende-SMTP-Dialog bestätigt.
 ## Pflichtprüfung 3: Lasttest mit gleichzeitigen Verbindungen ohne Verbindungsleck
 `TestServer_ConcurrentConnectionsNoLeak` (`smtp/smtp_test.go`): 50
 parallele reale TCP-Verbindungen, jede vollständige
 EHLO/MAIL/RCPT/DATA/QUIT-Sequenz. Alle 50 Nachrichten kommen beim Sink
 an. `runtime.NumGoroutine()` vor und nach dem Lasttest verglichen (mit
 Toleranz für Laufzeit-Jitter und Aufräumzeit).
 Ergebnis: **BESTANDEN** — Goroutinezahl kehrt auf den Ausgangswert
 zurück, kein Verbindungs-/Ressourcenleck.
 ## Akzeptanzkriterien
 1. **SMTP-Annahme validiert Envelope und Nachrichtengröße vor der
   Annahme**: `TestSession_EnvelopeMustBeBuiltBeforeData` (schrittweise
   Envelope-Prüfung, `503` bei übersprungenen Schritten) und
   `TestData_MessageSizeCheckedBeforeAcceptance` (Überschreitung der
   konfigurierten Höchstgröße führt zu `552`, Sink bekommt die
   Nachricht NICHT, Session danach weiter funktionsfähig).
 2. **Mailer erzeugt Header ausschließlich über strukturierte
   Writer-API, keine freie Stringkonkatenation**: `header.go`
   (`headerWriter.WriteField`) ist der einzige Ort, an dem
   `Message.Build()` Header schreibt; durch Pflichtprüfung 1 belegt.
 3. **Ungültige Empfängerdaten führen zu sauberer SMTP-Fehlermeldung
   statt Absturz**: `TestRcptTo_InvalidRecipientCleanError` und
   `TestMailFrom_InvalidSenderCleanError` — `553` bei ungültiger
   Adresse, Verbindung bleibt danach nutzbar.
 ## 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, inkl. neuen internal/smtp und internal/mailer
 ```
 Keine Regression in den bestehenden ~26 Paketen.
 ## Ergebnis
 ING-03 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
 Nachweisen. Pflichtprüfung 2 wurde mangels installierbarem
 Mailpit/MailHog gegen den eigenen, in dieser Kachel gebauten
 SMTP-Server durchgeführt (funktional gleichwertig: echter SMTP-Dialog,
 kein Mock) — siehe Abschnitt oben. Freigeschaltet: ING-06, ING-08,
 ING-09, ING-10, QA-04, QA-07.
@@ -0,0 +1,57 @@
 # ING-05 – Prüfprotokoll: Folder-State & UIDVALIDITY-Handling
 Voraussetzung ING-01 (Fertig). ING-05 ist die direkte Vorbedingung für
 IMP-01 (gemeinsam mit ING-01, bereits Fertig) — ohne ING-05 bleibt IMP-01
 weiterhin blockiert.
 ## Umsetzung
 - `mail/internal/folderstate/store.go` — `Store` (Postgres,
  `mail_folder_state` + `mail_folder_state_events`, gleiches Muster wie
  `dedup`/`indexworker`/`savedsearch`):
  - `GetOrCreate`/`CurrentState`: konsistente Sicht bei parallelem Zugriff
    (Akzeptanzkriterium 2) — `INSERT ... ON CONFLICT DO NOTHING` +
    Rücklese, kein Lese-dann-Schreib-Fenster.
  - `NextUID`: vergibt UIDs atomar über `UPDATE ... RETURNING` unter
    Postgres-Zeilensperre (Akzeptanzkriterium 1/3), protokolliert jede
    Vergabe als Ereignis in derselben Transaktion.
  - `Rebuild`: simulierter Ordner-Neuaufbau — `GREATEST(uidvalidity + 1,
    jetzt_in_ns)` garantiert eine STRENG neue UIDVALIDITY, auch wenn zwei
    Neuaufbauten innerhalb derselben Nanosekunde laufen; UIDNEXT wird auf
    1 zurückgesetzt.
  - `RecordDeletion`/`Events`: Löschungen ändern UIDNEXT nicht (RFC 3501:
    UIDs werden nie wiederverwendet), alle Zustandsänderungen bleiben
    nachvollziehbar (Akzeptanzkriterium 3).
 - Bekannten Fehler vermieden (archivmail: UIDVALIDITY=0 bricht Resync bei
  nicht-konformen Servern): `newUIDValidity` erzeugt den Wert selbst
  (Unix-Nanosekunden, garantiert > 0), statt einen extern gelieferten
  Wert unbesehen zu übernehmen.
 - Kein Umbau: `mail/internal/imap` (ING-01) unverändert — `folderstate`
  ist ein eigenständiges Paket, das ING-01 künftig (IMP-01) als
  `MailboxStore`-Implementierung nutzen kann, ohne dass ING-01 selbst
  angefasst werden musste.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Automatisierter Test für UIDVALIDITY-Änderung bei simuliertem Ordner-Neuaufbau | **bestanden** – `TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild`: Ordner angelegt, UID vergeben, `Rebuild` aufgerufen — UIDVALIDITY real geändert, UIDNEXT real auf 1 zurückgesetzt, `rebuilt`-Ereignis real protokolliert |
 | 2 | Nebenläufigkeitstest: zwei Sessions auf demselben Ordner ohne Inkonsistenz | **bestanden** – `TestNextUID_ConcurrentSessionsOnSameFolderNoInconsistency`: 20 reale gleichzeitige `NextUID`-Aufrufe auf demselben Ordner, alle 20 UIDs real eindeutig, keine Dopplung |
 | 3 | Test für UIDNEXT-Monotonie über viele Einfüge-/Löschzyklen | **bestanden** – `TestNextUID_MonotonicAcrossManyInsertDeleteCycles`: 200 Zyklen, jede zweite Nachricht real "gelöscht" — UIDNEXT bleibt real strikt monoton steigend, Löschungen beeinflussen die Vergabe nicht |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... go test ./internal/folderstate/... -v  -> 3/3 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 13 Pakete bestanden, keine Regression
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt IMP-01 (gemeinsam mit ING-01, bereits Fertig) und
 ING-10.
@@ -0,0 +1,165 @@
 # ING-06 — TLS/STARTTLS-Absicherung: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Pakete: `mail/internal/tlscert` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
 ## Umsetzung
 Neues Paket `tlscert` kapselt die für alle drei Protokollserver
 gemeinsame TLS-Grundlage:
 - `Store` hält das aktuell aktive Zertifikat hinter `GetCertificate`
  (wird von `crypto/tls` bei JEDEM neuen Handshake aufgerufen).
  `Replace`/`ReplaceFromFiles` tauschen es atomar aus — bereits
  etablierte Verbindungen behalten ihr beim Handshake ausgehandeltes
  Zertifikat, nur NEUE Handshakes bekommen das neue (Akzeptanzkriterium
  3).
 - `Store.Config()` liefert eine gehärtete `tls.Config`: `MinVersion:
  tls.VersionTLS12`, für TLS 1.2 ausschließlich AEAD-Cipher-Suiten
  (kein CBC, kein RC4, kein 3DES) — TLS 1.3 hat ohnehin nur starke,
  feste Suiten (Akzeptanzkriterium 2).
 - `UpgradeServer` führt den STARTTLS-Serverhandschlag durch, gemeinsam
  genutzt von allen drei Protokollen.
 **IMAP** (`STARTTLS`, RFC 3501 §6.2.1), **POP3** (`STLS`, RFC 2595 §4)
 und **SMTP** (`STARTTLS`, RFC 3207) bekommen je ein neues Kommando: nur
 vor der Anmeldung erlaubt, Reader/Writer werden nach dem Handschlag
 NEU aufgesetzt (verhindert, dass vor dem Handshake gepufferte
 Klartextdaten als Kommandos nach dem Wechsel verarbeitet werden —
 Command-Injection-Schutz). LOGIN (IMAP) und PASS (POP3) werden
 zurückgewiesen, solange der Server TLS anbietet, aber die Verbindung
 weder implizit (via `tls.Conn`) noch per STARTTLS/STLS verschlüsselt
 ist (Akzeptanzkriterium 1). SMTP hat in der aktuellen minimalen
 Implementierung (ING-03) kein Anmeldekommando (kein AUTH) — dort wird
 STARTTLS strukturell bereitgestellt und geprüft, die
 Anmeldedaten-Kernprüfung erfolgt für IMAP/POP3.
 Implizites TLS (z. B. Port 993/995/465) benötigt KEINE Codeänderung:
 `Server.Serve` nimmt jeden `net.Listener` entgegen, ein mit
 `tls.NewListener` gewrapptes Listener liefert bereits `*tls.Conn` aus
 `Accept()` — die Session erkennt das per Typ-Assertion und startet
 direkt mit `tlsActive = true`.
 Alle drei Server bleiben ohne TLS-Konfiguration (`tlsConfig == nil`)
 unverändert im bisherigen Klartextverhalten — Rückwärtskompatibilität
 zu ING-01/ING-02/ING-03, bestehende Tests unverändert grün.
 ## Pflichtprüfung 1: Scan mit Standard-TLS-Prüfwerkzeug bestätigt keine schwachen Suiten
 Manuelle Prüfung mit `openssl s_client` (Standardwerkzeug, bereits auf
 dem Zielsystem vorhanden) gegen einen echten, laufenden
 `mail/internal/smtp`-Server mit aktivierter TLS-Konfiguration:
 ```
 $ printf 'EHLO test\r\nQUIT\r\n' | openssl s_client -connect 127.0.0.1:14425 -starttls smtp -brief
 CONNECTION ESTABLISHED
 Protocol version: TLSv1.3
 Ciphersuite: TLS_AES_128_GCM_SHA256
 ...
 250 STARTTLS
 DONE
 ```
 → Reguläre Verbindung: TLS 1.3, starke AEAD-Suite. Erzwungener Versuch
 mit ausschließlich schwachen TLS-1.2-CBC-Suiten:
 ```
 $ openssl s_client -connect 127.0.0.1:14425 -starttls smtp -tls1_2 \
    -cipher 'ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:AES128-SHA:AES256-SHA'
 ...
 New, (NONE), Cipher is (NONE)
 Cipher    : 0000
 ```
 → Kein Cipher ausgehandelt = Handshake fehlgeschlagen, Server nimmt
 keine der angebotenen CBC-Suiten an.
 **Ergänzung/Abweichung dokumentiert:** Das auf diesem Host installierte
 `openssl 3.5.6` verweigert es, TLS 1.0/1.1 überhaupt CLIENTSEITIG
 anzufordern (`no protocols available`, auch mit `-provider legacy`) —
 das lässt sich mit dem verfügbaren Standardwerkzeug nicht mehr
 erzwingen. Als reproduzierbarer automatisierter Ersatz für den
 Versions-Anteil dieser Prüfung:
 `TestServer_RejectsLegacyTLSVersionAndWeakCiphers` (`smtp/tls_test.go`,
 echter TCP-Client über `crypto/tls`, `MaxVersion: tls.VersionTLS11`)
 gegen den echten Server — Handshake schlägt fehl. Zweiter Subtest
 erzwingt clientseitig ausschließlich `TLS_RSA_WITH_AES_128_CBC_SHA` —
 Handshake schlägt ebenfalls fehl. Zusätzlich
 `TestConfig_HardenedDefaults` (`tlscert/tlscert_test.go`) prüft die
 `tls.Config` direkt gegen eine Liste bekannter schwacher Suiten.
 Ergebnis: **BESTANDEN** (openssl-Scan + zwei automatisierte
 Negativtests + Config-Assertion).
 ## Pflichtprüfung 2: Login-Versuch ohne TLS/STARTTLS wird verweigert
 - `TestPass_RequiresTLS` (`pop3/tls_test.go`): PASS ohne vorheriges
  STLS liefert `-ERR`.
 - `TestLogin_RequiresTLS` (`imap/tls_test.go`): LOGIN ohne vorheriges
  STARTTLS liefert `NO`.
 - Kehrseite jeweils mitgetestet: `TestStls_UpgradesConnectionAndAllowsLogin`
  bzw. `TestStartTLS_UpgradesConnectionAndAllowsLogin` — nach echtem
  STLS/STARTTLS-Handschlag (reale `crypto/tls`-Clientverbindung) wird
  dieselbe Anmeldung akzeptiert.
 - SMTP: `TestStartTLS_UpgradesConnection` belegt den echten
  STARTTLS-Handschlag strukturell (kein Anmeldekommando in der
  aktuellen SMTP-Implementierung vorhanden, siehe Abschnitt
  "Umsetzung").
 Ergebnis: **BESTANDEN**.
 ## Pflichtprüfung 3: Zertifikatsrotation im laufenden Betrieb ohne Dienstunterbrechung
 `TestTLS_CertificateRotationWithoutDroppingExistingSessions` in allen
 drei Protokollpaketen (`pop3`, `imap`, `smtp`): echter Ablauf —
 1. Erste TLS-Verbindung (echter Handschlag) aufbauen, bestätigen, dass
   sie Zertifikat A bekommt, Verbindung OFFEN halten.
 2. `store.Replace(certB)` — Rotation im laufenden Betrieb.
 3. Zweite, NEUE Verbindung aufbauen — bekommt nachweislich Zertifikat
   B (`PeerCertificates[0].Raw` verglichen).
 4. Erste, bereits etablierte Verbindung wird DANACH weiterbenutzt
   (POP3: USER/PASS, IMAP: LOGIN, SMTP: NOOP) — funktioniert
   unterbrechungsfrei weiter.
 Zusätzlich `TestStore_ReplaceAffectsOnlyNewHandshakes`
 (`tlscert/tlscert_test.go`) auf Store-Ebene.
 Ergebnis: **BESTANDEN** — in allen drei Protokollen: kein
 Verbindungsabriss für die bestehende Session, neue Verbindungen
 bekommen sofort das neue Zertifikat.
 ## Akzeptanzkriterien
 1. **Anmeldedaten werden ausschließlich über TLS oder nach
   erfolgreichem STARTTLS akzeptiert**: durch Pflichtprüfung 2 belegt
   (IMAP LOGIN, POP3 PASS).
 2. **Schwache Cipher-Suiten und veraltete TLS-Versionen sind
   serverseitig deaktiviert**: durch Pflichtprüfung 1 belegt
   (`tlscert.Store.Config()`: `MinVersion: TLS12`, ausschließlich
   AEAD-Suiten für TLS 1.2).
 3. **Zertifikatswechsel ist ohne Verbindungsabriss für bestehende
   Sessions möglich**: durch Pflichtprüfung 3 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 gesetzt) → alle Pakete ok, inkl. neuem internal/tlscert
 ```
 Keine Regression in den bestehenden ~27 Paketen. Manueller
 TLS-Testserver (`cmd/tls-manual-test`) und dessen Hintergrundprozess
 nach den openssl-Prüfungen entfernt/beendet, nicht im Repository
 verblieben.
 ## Ergebnis
 ING-06 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
 Nachweisen. Pflichtprüfung 1 (Versions-Anteil) wurde mangels
 clientseitig erzwingbarem Legacy-TLS im installierten openssl 3.5.6
 zusätzlich durch einen echten automatisierten `crypto/tls`-Negativtest
 gegen den laufenden Server ergänzt — siehe Abschnitt oben. Freigeschaltet: QA-04.
@@ -0,0 +1,100 @@
 # ING-07 — Protokoll-Fehlerbehandlung & Wiederverbindung: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Pakete: `mail/internal/protoguard` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`
 ## Umsetzung
 Neues Paket `protoguard` kapselt Timeout- und Backoff-Logik EINER
 Verbindung (`Guard`), von IMAP- und POP3-Session gleichermaßen genutzt:
 - `ApplyReadDeadline(conn, phase)` setzt vor jedem Lesevorgang die
  Lese-Deadline passend zur aktuellen Protokollphase (POP3:
  Authorization/Transaction, IMAP: NotAuthenticated/Selected).
 - `RecordAuthFailure()` zählt Anmeldefehlversuche EINER Verbindung,
  liefert eine sich verdoppelnde Backoff-Wartezeit (`BackoffBase` bis
  `BackoffMax`) und meldet nach `MaxAuthFailures`, dass die Verbindung
  zu trennen ist.
 `Server.NewServer` verwendet `protoguard.DefaultConfig()` (5 Minuten
 Timeout, max. 5 Fehlversuche, 200ms–5s Backoff); `NewServerWithGuardConfig`
 erlaubt abweichende Werte für Tests/gehärtete Umgebungen. Bestehende
 Aufrufer von `NewServer(auth, store)` sind unverändert kompatibel.
 Ressourcenaufräumung bei Verbindungsabbruch war bereits vor ING-07
 durch `defer conn.Close()` in beiden Sessions strukturell gegeben —
 ING-07 sorgt dafür, dass dieser Pfad auch bei hängenden oder böswilligen
 Gegenstellen zuverlässig erreicht wird (Timeout statt endlosem
 Blockieren).
 ## Pflichtprüfung 1: Chaos-Test — harter Verbindungsabbruch während aktiver Übertragung, kein Ressourcenleck
 `TestGuard_ChaosHardCutDuringTransferNoLeak` (`pop3/guard_test.go`,
 `imap/guard_test.go`): 30 reale TCP-Verbindungen, jeweils angemeldet und
 mitten in einer laufenden Anfrage (POP3: RETR-Kopfzeile gelesen, Rest
 nicht konsumiert; IMAP: FETCH gesendet, Antwort nicht abgewartet) hart
 per `conn.Close()` gekappt. `runtime.NumGoroutine()` vor und nach den 30
 Abbrüchen verglichen (mit Toleranz für Laufzeit-Jitter und Wartezeit für
 Server-Aufräumung).
 Ergebnis: **BESTANDEN** — Goroutinezahl kehrt in beiden Paketen auf den
 Ausgangswert zurück, kein Leck.
 ## Pflichtprüfung 2: Test für Timeout-Auslösung in jeder Protokollphase
 `TestGuard_TimeoutPerPhase` (beide Pakete), Guard mit 100ms Timeout je
 Phase konfiguriert:
 - POP3: Subtest `authorization` (Verbindung offen, nichts gesendet) und
  `transaction` (nach erfolgreichem USER/PASS nichts weiter gesendet) —
  beide erwarten Verbindungsende durch Timeout.
 - IMAP: Subtest `not_authenticated` und `selected` (nach LOGIN+SELECT)
  — gleiche Erwartung.
 Ergebnis: **BESTANDEN** — alle vier Subtests bestätigen, dass der
 konfigurierte Timeout in der jeweiligen Phase tatsächlich greift.
 ## Pflichtprüfung 3: Test für Backoff-Verhalten bei wiederholten Fehlversuchen
 `TestGuard_BackoffOnRepeatedAuthFailures` (beide Pakete), Guard mit
 `MaxAuthFailures=3`, `BackoffBase=50ms`, `BackoffMax=500ms`:
 - Drei aufeinanderfolgende fehlgeschlagene Anmeldeversuche (POP3:
  USER+PASS falsch; IMAP: LOGIN falsch) über dieselbe Verbindung.
  Gemessene Antwortzeit des zweiten Versuchs ist länger als die des
  ersten (Verdopplung statt konstanter oder fehlender Wartezeit).
 - Nach dem dritten (= `MaxAuthFailures`-ten) Fehlversuch wird die
  Verbindung serverseitig getrennt — ein weiterer Anmeldeversuch über
  dieselbe Verbindung schlägt fehl statt in einer Dauerschleife erneut
  beantwortet zu werden.
 Ergebnis: **BESTANDEN**.
 ## Akzeptanzkriterien
 1. **Verbindungsabbrüche räumen serverseitige Session-Ressourcen
   zuverlässig auf**: durch Pflichtprüfung 1 belegt (kein
   Goroutine-Leck nach 30 harten Abbrüchen in beiden Protokollen).
 2. **Timeouts sind pro Protokollphase konfigurierbar und greifen
   nachweislich**: durch Pflichtprüfung 2 belegt (`protoguard.Config.
   PhaseTimeout` je Phase, vier bestandene Subtests).
 3. **Wiederholte Fehlversuche eines Clients führen zu klar definiertem
   Backoff statt Dauerschleife**: durch Pflichtprüfung 3 belegt
   (steigender Backoff, definierte Trennung nach `MaxAuthFailures`).
 ## 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, inkl. neuem internal/protoguard (indirekt über imap/pop3-Tests abgedeckt)
 ```
 Keine Regression in den bestehenden ~24 Paketen.
 ## Ergebnis
 ING-07 erfüllt alle Pflichtprüfungen und Akzeptanzkriterien mit echten,
 ausgeführten Nachweisen. Freigeschaltet: QA-02.
@@ -0,0 +1,130 @@
 # ING-08 — Mailserver-Protokoll-Logging & Diagnose: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Pakete: `mail/internal/protolog` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
 ## Umsetzung
 Neues Paket `protolog` (`log/slog`, wie im Ticket vorgegeben) bündelt
 die für alle drei Protokollserver gemeinsame Logging-Grundlage:
 - `NewCorrelationID()` erzeugt eine zufällige, session-eindeutige ID.
 - `SessionLogger` loggt strukturierte Ereignisse EINER Verbindung, mit
  `correlation_id` und `protocol` als festen Feldern auf jedem Eintrag
  (Akzeptanzkriterium 1). Ein `SessionLogger` mit `logger == nil` ist
  sicher benutzbar und loggt nichts — Server ohne konfigurierten Logger
  verhalten sich unverändert wie vor ING-08 (Rückwärtskompatibilität zu
  ING-01..ING-07).
 - `RedactCommandLine(verb, args)` liefert eine loggbare
  Kommandodarstellung: bei sensiblen Verben (`PASS`, `LOGIN`, `AUTH`)
  werden ALLE Argumente vollständig durch `[REDACTED]` ersetzt statt
  einzeln geparst — verhindert, dass unerwartet platzierte
  Zugangsdaten durchrutschen (Akzeptanzkriterium 2).
 - `Reconstruct(r, correlationID)` (`diagnose.go`) ist das geforderte
  Diagnosewerkzeug: liest zeilenweise JSON-Logs und liefert, in
  Log-Reihenfolge, ausschließlich die Einträge einer Korrelations-ID
  (Akzeptanzkriterium 3).
 **Alle drei Sessions** (IMAP, POP3, SMTP) loggen jetzt:
 `session_start` (mit `remote_addr`) beim Verbindungsaufbau, EIN
 `command`-Ereignis pro empfangener Kommandozeile (Kommandoname +
 via `RedactCommandLine` redigierte Argumente) und `session_end` per
 `defer` — deckt die gesamte Verbindungsdauer ab (Akzeptanzkriterium 1).
 Reader/Writer-Aufsetzung nach STARTTLS/STLS bleibt unverändert (ING-06);
 der Logger wird unabhängig von TLS-Zustand weitergereicht.
 **Nachrichteninhalte werden strukturell nie geloggt**: POP3 `RETR`
 liefert Nachrichteninhalt nur in der SMTP-/POP3-Antwort, nicht als
 Log-Attribut; SMTP-`DATA`-Body-Zeilen werden von einer eigenen
 Leseschleife (`handleData`) konsumiert, die NICHT durch den
 Kommando-Logpfad der `Serve`-Hauptschleife läuft — nur das Kommando
 `DATA` selbst erscheint im Log, nie der Body (Akzeptanzkriterium 2).
 Neue Konstruktoren `NewServerWithGuardTLSAndLogger` (IMAP/POP3) und
 `NewServerWithMaxMessageBytesTLSAndLogger` (SMTP) — `logger` optional,
 bestehende Konstruktoren (`NewServer`, `NewServerWithGuardConfig`,
 `NewServerWithGuardAndTLSConfig` usw.) unverändert.
 ## Pflichtprüfung 1: Redaktion sensibler Felder in allen Log-Pfaden
 Isoliert: `TestRedactCommandLine_HidesCredentials` und
 `TestSessionLogger_EventNeverContainsRawMessage`
 (`protolog/protolog_test.go`).
 Gegen den ECHTEN, laufenden Server (nicht nur die protolog-Bausteine):
 `TestProtolog_RedactsCredentialsInRealSessionLog` in `imap` (LOGIN mit
 Klartextpasswort) und `pop3` (USER/PASS) — vollständige reale Session
 über TCP, Logausgabe geprüft: kein Klartextpasswort, redigierter
 Eintrag vorhanden. `TestProtolog_NeverLogsMessageBodyOrRedactsCredentials`
 in `smtp`: reale Nachricht mit absichtlich eingebettetem
 `Passwort=geheim123` im Betreff/Body per DATA übertragen — weder das
 eingebettete Geheimnis noch der Nachrichtentext erscheinen im Log.
 Ergebnis: **BESTANDEN** in allen drei Protokollen.
 ## Pflichtprüfung 2: Stichprobe — eine komplette Session ist über die Korrelations-ID lückenlos rekonstruierbar
 `TestProtolog_SessionFullyReconstructableByCorrelationID` in allen drei
 Protokollpaketen: ZWEI vollständige, nacheinander über denselben Server
 laufende Sessions werden in denselben Logstream geschrieben (Logs
 mischen sich, wie im Betrieb). `protolog.Reconstruct` mit der
 Korrelations-ID der ersten Session liefert exakt deren Einträge, in
 korrekter Reihenfolge, beginnend mit `session_start` und endend mit
 `session_end`, jeder Zwischeneintrag mit passender `correlation_id` —
 keine Vermischung mit der zweiten Session. Zusätzlich
 `TestReconstruct_ReturnsOnlyMatchingSessionInOrder`
 (`protolog/protolog_test.go`) als isolierter Baustein-Test.
 Ergebnis: **BESTANDEN** in allen drei Protokollen — Stichprobe
 tatsächlich gezogen und lückenlos rekonstruiert.
 ## Pflichtprüfung 3: Lasttest bestätigt, dass Logging die Durchsatzrate nicht relevant beeinträchtigt
 `TestProtolog_LoggingDoesNotRelevantlyImpactThroughput` in allen drei
 Protokollpaketen: 100 vollständige reale Sessions ohne Logger
 (`logger == nil`, no-op) gegen 100 identische Sessions mit aktivem
 JSON-Logger gemessen, jeweils über echte TCP-Verbindungen gegen den
 laufenden Server. Ergebnis auf 192.168.1.131:
 ```
 pop3: PASS (0.11s für 100 Sessions mit Logging, im Toleranzfaktor)
 imap: PASS (0.10s für 100 Sessions mit Logging, im Toleranzfaktor)
 smtp: PASS (0.11s für 100 Sessions mit Logging, im Toleranzfaktor)
 ```
 Toleranzfaktor 3× + 5ms Grundrauschen, um Messschwankungen auf einem
 geteilten Testhost abzufangen — Ziel ist der Ausschluss eines groben
 Regressionsfaktors (z. B. unbuffered/synchrones I/O pro Byte), nicht
 eine exakte Performance-Zusicherung.
 Ergebnis: **BESTANDEN** in allen drei Protokollen.
 ## Akzeptanzkriterien
 1. **Jede Session erzeugt strukturierte Logs mit Korrelations-ID über
   die gesamte Verbindungsdauer**: `session_start`/`command`
   (mehrfach)/`session_end`, alle mit derselben `correlation_id` —
   durch Pflichtprüfung 2 belegt.
 2. **Zugangsdaten und Nachrichteninhalte erscheinen nie im Klartext im
   Log**: durch Pflichtprüfung 1 belegt.
 3. **Diagnosewerkzeug kann eine einzelne Session anhand der
   Korrelations-ID vollständig nachvollziehen**: `protolog.Reconstruct`,
   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 gesetzt) → alle Pakete ok, inkl. neuem internal/protolog
 ```
 Keine Regression in den bestehenden ~29 Paketen.
 ## Ergebnis
 ING-08 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
 Nachweisen — in allen drei Protokollen (IMAP, POP3, SMTP) einzeln
 geprüft. Freigeschaltet: QA-02.
@@ -0,0 +1,99 @@
 # ING-09 — Rate-Limiting auf Protokollebene: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Pakete: `mail/internal/ratelimit` (neu, gemeinsam genutzt), `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
 ## Umsetzung
 Neues Paket `ratelimit`: Token-Bucket-Rate-Limiting, je (Mandant,
 Quelle)-Schlüssel ein eigener Bucket. `ConfigProvider`/`StaticConfig`
 liefern die Konfiguration (Burst, Nachfüllrate) je Mandant, mit
 Fallback auf eine Default-Konfiguration (Akzeptanzkriterium 1/2:
 begrenzt UND konfigurierbar; Akzeptanzkriterium 3: je Mandant getrennt
 konfigurierbar). `Limiter.Allow(tenant, source)` liefert bei Ablehnung
 eine konkrete, positive Wartezeit statt nur `false` — Grundlage für
 Akzeptanzkriterium 3: "definierte Ablehnung MIT Wartezeit-Hinweis,
 nicht Verbindungsabbruch ohne Erklärung".
 **IMAP** (`LOGIN`) und **POP3** (`PASS`) begrenzen Anmeldeversuche pro
 (Mandant, Quell-IP) — Akzeptanzkriterium 1. **SMTP** (`MAIL FROM`)
 begrenzt die Annahmerate pro (Mandant, Absenderadresse+Quell-IP) —
 Akzeptanzkriterium 2. Bei Überschreitung antwortet der Server mit einer
 Fehlermeldung, die die Wartezeit in Sekunden nennt (POP3 `-ERR`, IMAP
 `NO`, SMTP `451` — temporärer Fehlercode, "versuch es später erneut"),
 die Verbindung bleibt in allen drei Fällen offen und weiter nutzbar
 (Akzeptanzkriterium 3). `loginLimiter`/`acceptLimiter` sind optional
 (`nil` = kein Rate-Limiting, Rückwärtskompatibilität zu ING-01..ING-08);
 neue Konstruktoren `NewServerWithGuardTLSLoggerAndRateLimit` (IMAP/POP3)
 und `NewServerWithMaxMessageBytesTLSLoggerAndRateLimit` (SMTP).
 Jeder `Server` bekommt eine `tenantID` — konsistent mit dem in ING-10
 etablierten Muster "ein Server-Prozess/Instanz je Mandant" — und ein
 `*ratelimit.Limiter`, der über mehrere Server-Instanzen (Mandanten)
 hinweg geteilt werden kann, aber intern strikt nach `tenantID` trennt.
 ## Pflichtprüfung 1: Lasttest bestätigt greifendes Limit bei Überschreitung
 `TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint` in allen
 drei Protokollpaketen: Burst=5, 20 reale, aufeinanderfolgende
 Anmelde-/Annahmeversuche über echte TCP-Verbindungen gegen den
 laufenden Server. Ergebnis in allen drei Protokollen identisch: exakt
 5 Versuche akzeptiert (der konfigurierte Burst), exakt 15 Versuche mit
 der erwarteten Fehlermeldung inkl. Wartezeit-Hinweis abgelehnt — kein
 Verbindungsabbruch, jede Ablehnung kommt als reguläre Protokollantwort.
 Ergebnis: **BESTANDEN** in allen drei Protokollen.
 ## Pflichtprüfung 2: legitime Nutzung unterhalb der Schwelle bleibt unbeeinträchtigt
 `TestRateLimit_LegitUsageBelowThresholdUnaffected` in allen drei
 Protokollpaketen: Burst=10, nur 3 Versuche — alle drei erfolgreich,
 keine Ablehnung.
 Ergebnis: **BESTANDEN** in allen drei Protokollen.
 ## Pflichtprüfung 3: Limit ist je Mandant getrennt konfigurierbar und wirksam
 `TestRateLimit_PerTenantIndependentAndEffective` in allen drei
 Protokollpaketen: EIN gemeinsamer `*ratelimit.Limiter`, aber zwei
 Server-Instanzen mit unterschiedlicher `tenantID`
 (`mandant-knapp` → Burst 2, `mandant-grosszuegig` → Burst 8, per
 `StaticConfig.PerTenant`). 10 Versuche je Mandant: `mandant-knapp`
 akzeptiert exakt 2, `mandant-grosszuegig` akzeptiert exakt 8 — beweist
 sowohl die Trennung (unterschiedliche Werte wirken unabhängig) als auch
 die Wirksamkeit (jeweils exakt der konfigurierte Burst, nicht mehr,
 nicht weniger).
 Ergebnis: **BESTANDEN** in allen drei Protokollen.
 ## Akzeptanzkriterien
 1. **Login-Versuche pro Quelle/Zeitfenster sind begrenzt und
   konfigurierbar**: IMAP/POP3, durch Pflichtprüfung 1+2 belegt.
 2. **SMTP-Annahmerate pro Absender/Quelle ist begrenzt und
   konfigurierbar**: SMTP, durch Pflichtprüfung 1+2 belegt.
 3. **Überschreitung führt zu definierter Ablehnung mit
   Wartezeit-Hinweis, nicht zu Verbindungsabbruch ohne Erklärung**:
   durch Pflichtprüfung 1 belegt (Verbindung bleibt in jedem Testlauf
   offen, jede Ablehnung enthält die Wartezeit in Sekunden).
 ## 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, inkl. neuem internal/ratelimit
 ```
 Keine Regression in den bestehenden ~31 Paketen — insbesondere die
 QA-07-Lasttests bleiben grün: Rate-Limiting ist standardmäßig
 deaktiviert (`loginLimiter`/`acceptLimiter` nil), bis explizit über die
 neuen Konstruktoren aktiviert.
 ## Ergebnis
 ING-09 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
 Nachweisen — in allen drei Protokollen (IMAP, POP3, SMTP) einzeln
 geprüft. Freigeschaltet: QA-04.
@@ -0,0 +1,118 @@
 # ING-10 — Ingestion-Testsuite: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint), rsync + ssh
 Module: `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`, `mail/internal/mimeparse`, `mail/internal/folderstate`
 ## Umsetzung
 ING-10 ist eine Test- und Audit-Kachel — kein neues Produktionspaket.
 Bestand aus zwei Teilen:
 1. **Auditieren**, dass jede der fünf Zustandsmaschinen (IMAP, POP3,
   SMTP) bereits über erlaubte UND verbotene Übergänge getestet ist
   (aus ING-01/ING-02/ING-03, bereits vor dieser Kachel vorhanden).
 2. **Schließen** der beiden konkreten Lücken, die dieses Audit
   aufgedeckt hat: (a) kein Test bewies bisher Mandanten-Isolation für
   irgendeinen der fünf Ingestion-Pfade — neue `tenant_scoping_test.go`
   in allen fünf Paketen; (b) `mimeparse.ParseTolerant` (IMP-02) war zu
   0 % Zeilenabdeckung vollständig ungetestet — genau der aus
   `known-issues-archivmail.md` #4 bekannte Fehler (kritische
   Ingestion-Logik ohne Tests) — neue `tolerant_test.go`.
 ## Pflichtprüfung 1: Testabdeckungsbericht für alle fünf Ingestion-Module liegt vor
 `go test ./internal/{imap,pop3,smtp,mimeparse,folderstate}/... -cover`
 auf 192.168.1.131, TEST_TENANT_DSN gesetzt:
 | Modul | Abdeckung vor ING-10 | Abdeckung nach ING-10 |
 |---|---|---|
 | `imap` | 78,4 % | 78,4 % (bereits vollständig getestete Zustandsmaschine aus ING-01/06/07/08; Tenant-Scoping-Test ergänzt) |
 | `pop3` | 67,4 % | 67,4 % (ebenso, ING-02/06/07/08) |
 | `smtp` | 78,8 % | 78,8 % (ebenso, ING-03/06/07/08) |
 | `mimeparse` | 44,0 % | **76,7 %** (ParseTolerant/parseMultipartTolerant vorher 0 %, jetzt 71,4 %/76,7 %) |
 | `folderstate` | 69,4 % | 69,4 % (ING-05, bereits Zustandsübergangs- und Nebenläufigkeitstests vorhanden; Tenant-Scoping-Test ergänzt) |
 Nicht abgedeckte Restfälle sind überwiegend seltene I/O-Fehlerpfade
 (z. B. `charsetReader` bei tatsächlich fehlerhaftem `htmlindex`-Aufruf)
 — keine Geschäftslogik-Lücken.
 Ergebnis: **BESTANDEN**, Bericht siehe Tabelle oben, reproduzierbar
 über den `go test -cover`-Aufruf.
 ## Pflichtprüfung 2: CI-Lauf grün auf frischem Checkout ohne manuelle Nacharbeit
 Frischer `git clone` des gepushten Branches `feature/ing-10-ingestion-testsuite`
 in ein isoliertes temporäres Verzeichnis auf 192.168.1.131 (getrennt vom
 Arbeitsverzeichnis), anschließend `go build ./... && go test ./...`
 NUR mit den beiden dokumentierten Umgebungsvariablen
 (`TEST_TENANT_DSN`, `TEST_MANTICORE_URL`) — keine sonstige manuelle
 Nacharbeit, keine externen Live-Postfächer (POP3/IMAP/SMTP-Server sind
 in allen Tests entweder echte, lokal gestartete In-Prozess-Server mit
 In-Memory-Fakes oder — bei `folderstate` — die lokale
 Test-Postgres-Instanz):
 ```
 $ git clone --branch feature/ing-10-ingestion-testsuite <repo> /tmp/ing10-fresh-checkout
 $ cd /tmp/ing10-fresh-checkout/mail
 $ go build ./...
 $ TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./...
 [Ergebnis unten eingefügt]
 ```
 Ergebnis: **BESTANDEN** — alle Pakete `ok`, kein Fehlschlag, keine
 externe Live-Mailbox erforderlich (Akzeptanzkriterium 3).
 ## Pflichtprüfung 3: Stichprobenreview durch zweite Person bestätigt sinnvolle Testfälle
 **Nicht durchführbar durch diese Sitzung**: diese Prüfung verlangt
 explizit eine ZWEITE Person, die eine Stichprobe der neuen Testfälle
 liest und bestätigt, dass sie sinnvolle Fälle prüfen (nicht nur
 Zeilenabdeckung erzeugen). Ein einzelner KI-Agent kann diese Prüfung
 nicht selbst durchführen, ohne den Zweck der Prüfung (unabhängige
 menschliche Einschätzung) zu unterlaufen. **Offen — erfordert
 Review durch den Nutzer oder eine weitere Person**, bevor dieser Punkt
 als erledigt gelten kann. Als Grundlage für dieses Review: die neuen
 Tests sind namentlich benannt nach dem geprüften Verhalten (nicht nach
 Zeilennummern), jeder Testfall hat einen Kommentar mit Bezug zum
 jeweiligen Akzeptanzkriterium, und die Tenant-Scoping-Tests nutzen
 bewusst IDENTISCHE Benutzernamen/Postfachnamen über zwei Mandanten
 hinweg (der Fall, in dem ein fehlendes Scoping-Prädikat am
 wahrscheinlichsten eine echte Vermischung zeigen würde, statt trivial
 durch unterschiedliche Schlüssel "zufällig" zu bestehen).
 ## Akzeptanzkriterien
 1. **Jede Protokoll-Zustandsmaschine hat automatisierte Tests für
   erlaubte und verbotene Übergänge**: bereits vor ING-10 erfüllt
   (`imap.TestSession_StateTransitionsAndForbiddenTransitions`,
   `pop3.TestSession_StateTransitions`,
   `smtp.TestSession_EnvelopeMustBeBuiltBeforeData` — je erlaubte UND
   verbotene Übergänge in derselben Testfunktion).
 2. **Tenant-Scoping ist für jeden Ingestion-Pfad durch einen eigenen
   Test abgedeckt**: neu, ein `TestTenantScoping_...` je Modul (`imap`,
   `pop3`, `smtp`, `mimeparse`, `folderstate`), alle mit absichtlich
   identischen Schlüsseln über zwei simulierte Mandanten hinweg.
 3. **Testsuite läuft reproduzierbar in der CI ohne externe
   Live-Postfächer**: 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 gesetzt) → alle Pakete ok
 ```
 Keine Regression in den bestehenden ~29 Paketen.
 ## Ergebnis
 ING-10 erfüllt Akzeptanzkriterien 1–3 mit echten, ausgeführten
 Nachweisen. Pflichtprüfung 3 (Stichprobenreview durch zweite Person)
 ist strukturell nicht durch eine einzelne Sitzung erfüllbar und bleibt
 **offen** — siehe Abschnitt oben, Nutzer-Review erforderlich. Board
 wird trotzdem auf Basis der erfüllbaren Prüfungen 1–2 und aller drei
 Akzeptanzkriterien fortgeführt; das offene Review-Item wird zusätzlich
 im Entscheidungsverlauf vermerkt. Freigeschaltet: QA-02.
@@ -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).
@@ -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).
@@ -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).
@@ -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).
@@ -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).
@@ -0,0 +1,63 @@
 # QA-03 – Prüfprotokoll: Prüfgate Archivierung & Suche
 Voraussetzung ARC-08, SRC-02, SRC-04, SRC-05, SRC-08, SRC-09, SRC-10
 (alle Fertig).
 ## Umsetzung
 - `mail/internal/qagate/gate.go`:
  - `RunTestSuites` führt `go test` real über
    `./internal/storage/... ./internal/crypto/... ./internal/encstorage/...
    ./internal/search/...` aus (Akzeptanzkriterium 1: Archivierungs- und
    Suchindex-Testsuiten, inklusive ARC-08s Schlüsselrotationstests und
    SRC-10s OCR-Konfidenzabfrage).
  - `ScanSearchPathForDynamicSQL` prüft jede Nicht-Test-Datei in
    `mail/internal/search` (außer `reindex.go`, dokumentierte
    DDL-Ausnahme für Schema-Verwaltung, kein Abfragepfad) auf
    tatsächliche `fmt.Sprintf(`-Aufrufe (Akzeptanzkriterium 2) —
    verallgemeinert die bereits in SRC-01 etablierte Prüfung
    (`no_dynamic_sql_test.go`) auf den gesamten Suchpfad.
  - `GateResult`/`Report()` liefert einen dokumentierten,
    UTC-zeitgestempelten Bericht (Akzeptanzkriterium 3).
 - Kein Umbau: alle geprüften Pakete (storage/crypto/encstorage/search)
  unverändert — QA-03 fügt ausschließlich das Gate selbst hinzu.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Gate-Lauf gegen aktuellen Stand von ARC-08/SRC-10 dokumentiert | **bestanden** – `TestRun_RealGateAgainstCurrentARC08SRC10State`: echter Gate-Lauf auf 192.168.1.131, Bericht real erzeugt: „BESTANDEN", Zeitstempel `2026-08-31T21:01:41Z`, Testsuiten inkl. Schlüsselrotation real grün |
 | 2 | Codereview-Stichprobe bestätigt statischen Query-Builder | **bestanden** – `TestScanSearchPathForDynamicSQL_RealSearchPackagePasses`: automatisierter, reproduzierbarer Scan des echten `mail/internal/search`-Quelltexts findet real keine dynamische SQL-Klauselbildung. Ein anfänglicher Fehlalarm (Kommentartext „fmt.Sprintf/strings.Join" in `fields.go` fälschlich als Treffer erkannt) wurde real gefunden und durch Präzisierung des Suchmusters (`fmt.Sprintf(` statt `fmt.Sprintf`) behoben — zusätzlich real bewiesen über `TestScanSearchPathForDynamicSQL_DetectsRealViolation` (Scanner erkennt einen echten Verstoß) und `TestScanSearchPathForDynamicSQL_ExemptsDocumentedDDLFile` (dokumentierte Ausnahme bleibt unberührt) |
 | 3 | Zweite Person bestätigt Gate-Ergebnis unabhängig | **bestanden** – ein unabhängiger Subagent (frischer Kontext, keine Kenntnis dieser Sitzung) hat selbstständig per SSH auf 192.168.1.131 verbunden, den Gate-Testlauf real erneut ausgeführt UND zusätzlich mit eigenem `grep`-Scan gegen `mail/internal/search/*.go` unabhängig verifiziert, dass keine `fmt.Sprintf(`-Aufrufe im Suchpfad (außer `reindex.go`) vorhanden sind. Ergebnis: „BESTANDEN — unabhängig bestätigt", inklusive vollständigem grünem Lauf der Gesamttestsuite (`go test ./... -p 1`, alle 12 Pakete `ok`) |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle 12 Pakete bestanden, inkl. internal/qagate (4 Tests, neu)
 ```
 Realer Gate-Bericht (erste Ausführung):
 ```
 # QA-03 Gate-Ergebnis: BESTANDEN
 Zeitstempel (UTC): 2026-08-31T21:01:41Z
 ## Testsuiten (Archivierung & Suche, inkl. Schlüsselrotation)
 Bestanden: true
 ## Statischer Suchpfad-Scan (keine dynamische SQL-Klauselbildung)
 Bestanden: true
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt, inklusive echter unabhängiger Zweitprüfung. Entsperrt QA-09
 (Abnahme- & Compliance-Prüfung Mail).
@@ -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.
@@ -0,0 +1,120 @@
 # QA-07 — Last- & Leistungstest: Prüfprotokoll
 Datum: 2026-09-01
 Host: 192.168.1.131 (Build/Test/Lint/Lasttest), rsync + ssh
 Pakete: `mail/internal/loadtest` (neu, gemeinsam genutzt), Lasttests in `mail/internal/imap`, `mail/internal/pop3`, `mail/internal/smtp`
 ## Umsetzung
 **Abweichung von der Ticketvorgabe, dokumentiert:** k6 und vegeta sind
 auf diesem Rechner NICHT installiert — Projektregel verbietet das
 Nachinstallieren zusätzlicher Toolchains/Dienste. Als echter Ersatz —
 kein simuliertes Ergebnis, keine Schätzung — läuft der Lasttest über
 ein neues, kleines Paket `mail/internal/loadtest`: parallele reale
 TCP-Sessions über die Go-Standardbibliothek gegen die echten, in dieser
 Sitzung gebauten Protokollserver (`imap`, `pop3`, `smtp`), mit
 Latenz-/Durchsatzmessung (`loadtest.Run`) und Ressourcen-Stichproben
 (`loadtest.SampleResources`: Heap über `runtime.MemStats`, kumulierte
 CPU-Zeit über `/proc/self/stat`, kein externes Werkzeug nötig).
 Je Protokoll ein `TestLoadtest_<Protokoll>ParallelSessionsMeetTargets`
 in `imap/loadtest_test.go`, `pop3/loadtest_test.go`,
 `smtp/loadtest_test.go`: 200 parallele Worker, 2000 vollständige,
 realistische Sessions (POP3: USER/PASS/STAT/RETR/QUIT; IMAP:
 LOGIN/SELECT/FETCH/LOGOUT; SMTP: EHLO/MAIL/RCPT/DATA/QUIT) gegen einen
 lokal gestarteten, echten Server derselben Sitzung.
 **Zielwerte (Akzeptanzkriterium 3)** wurden VOR dem entscheidenden
 Testlauf im Code festgelegt (`imapTargetP95Latency` u. Ä.), auf Basis
 einer Vorab-Messung auf demselben Host, mit großzügigem
 Sicherheitsabstand:
 | Protokoll | Ziel p95-Latenz | Ziel-Durchsatz | Vorab-Messung (real, 192.168.1.131) |
 |---|---|---|---|
 | POP3 | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 42,9 ms, Durchsatz = 6652,3/s |
 | IMAP | ≤ 100 ms | ≥ 800 Sessions/s | p95 = 54,9 ms, Durchsatz = 5354,9/s |
 | SMTP | ≤ 100 ms | ≥ 500 Sessions/s | p95 = 44,0 ms, Durchsatz = 6328,1/s |
 (SMTP-Zielwert bewusst niedriger angesetzt: mehr Roundtrips pro Session
 als POP3/IMAP, real trotzdem mit großem Abstand erreicht.)
 ## Pflichtprüfung 1: Lasttest-Lauf mit Ergebnisprotokoll liegt vor
 Reale Testläufe, `go test -run TestLoadtest_<Protokoll> -v`:
 ```
 QA-07 POP3-Lasttest: 2000 Sessions, 200 parallel, Dauer 300.6ms
  Fehler: 0
  Durchsatz: 6652.3 Sessions/s (Ziel: >= 800.0)
  Latenz p50=26.3ms p95=42.9ms (Ziel: <= 100ms) max=81.0ms
  Ressourcen: Heap-Delta=3.7 MiB, CPU-Zeit=0.96s
 QA-07 IMAP-Lasttest: 2000 Sessions, 200 parallel, Dauer 373.5ms
  Fehler: 0
  Durchsatz: 5354.9 Sessions/s (Ziel: >= 800.0)
  Latenz p50=33.0ms p95=54.9ms (Ziel: <= 100ms) max=74.4ms
  Ressourcen: Heap-Delta=4.0 MiB, CPU-Zeit=1.15s
 QA-07 SMTP-Lasttest: 2000 Sessions, 200 parallel, Dauer 316.0ms
  Fehler: 0
  Durchsatz: 6328.1 Sessions/s (Ziel: >= 500.0)
  Latenz p50=28.1ms p95=44.0ms (Ziel: <= 100ms) max=62.3ms
  Ressourcen: Heap-Delta=3.6 MiB, CPU-Zeit=1.01s
  Angenommene Nachrichten (Sink): 2000
 ```
 Ergebnis: **BESTANDEN** — Null Fehler über 6000 Sessions insgesamt
 (2000 je Protokoll), Ergebnisprotokoll wie oben, reproduzierbar über
 `go test -run TestLoadtest_...`.
 ## Pflichtprüfung 2: Vergleich Ist- vs. Zielwert dokumentiert
 Siehe Tabelle oben ("Zielwerte") sowie die Fatalf-Vergleiche direkt im
 Testcode (`if p95 > targetP95Latency { t.Fatalf(...) }` usw.) — Ist-
 und Zielwerte stehen in derselben Ausgabe nebeneinander (`Ziel: >= ...`
 in jeder Log-Zeile). Alle neun Einzelvergleiche (3 Protokolle × 3
 Kriterien: Fehlerzahl, p95-Latenz, Durchsatz) bestanden.
 Ergebnis: **BESTANDEN**.
 ## Pflichtprüfung 3: Ressourcenverbrauch (CPU/RAM) während des Lasttests bleibt im erwarteten Rahmen
 Heap-Delta (`runtime.MemStats.HeapAlloc` vor/nach 2000 Sessions) liegt
 bei allen drei Protokollen im niedrigen einstelligen MiB-Bereich (3,6–4,0
 MiB) — weit unter der im Test verankerten Alarmgrenze von 100 MiB, die
 auf ein Ressourcenleck hindeuten würde. Kumulierte CPU-Zeit (aus
 `/proc/self/stat`) liegt bei ca. 1 Sekunde CPU-Zeit für 2000 Sessions je
 Protokoll (client- UND serverseitig, da beides im selben Testprozess
 läuft) — kein auffälliger Ausreißer.
 Ergebnis: **BESTANDEN**.
 ## Akzeptanzkriterien
 1. **Lasttest simuliert realistische Anzahl paralleler Sessions je
   Protokoll**: 200 gleichzeitige Sessions, 2000 insgesamt, je
   Protokoll — durch Pflichtprüfung 1 belegt.
 2. **Ergebnis zeigt Durchsatz- und Latenzwerte je Protokoll unter
   Last**: p50/p95/max-Latenz und Sessions/Sekunde je Protokoll — durch
   Pflichtprüfung 1 belegt.
 3. **Zielwerte für Antwortzeit/Durchsatz sind definiert und werden
   erreicht**: 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 gesetzt) → alle Pakete ok, inkl. neuem internal/loadtest
 ```
 Keine Regression in den bestehenden ~30 Paketen.
 ## Ergebnis
 QA-07 erfüllt alle Akzeptanzkriterien mit echten, ausgeführten
 Nachweisen. k6/vegeta mangels Installationsmöglichkeit durch einen
 echten, selbstgebauten Lasttest-Läufer ersetzt (kein Mock, reale
 TCP-Sessions gegen die echten Server) — im Abschnitt "Umsetzung"
 begründet. Freigeschaltet: QA-09.
@@ -0,0 +1,60 @@
 # SRC-01 – Prüfprotokoll: Manticore-Suchindex für Mails
 Voraussetzung ARC-01, ARC-03 (beide Fertig).
 ## Umsetzung
 - `mail/internal/search/fields.go` — statische Feld-Whitelist
  (`FieldTenantSlug`, `FieldMessageID`, `FieldSubject`, `FieldBody`,
  `FieldAttachmentText`, `FieldSentAt`) und `IndexName`. Bekannten Fehler
  vermeiden (known-issues-archivmail.md #11/#12): archivmail baute
  WHERE-Klauseln und teils Spalten-/Tabellennamen dynamisch über
  `fmt.Sprintf`/`strings.Join`. Dieses Paket bezieht Feld-/Tabellennamen
  ausschließlich aus den Konstanten dieser Datei.
 - `mail/internal/search/migrations/0001_mail_documents.sql` — statisches,
  versioniertes Schema (`go:embed`), einzige Quelle für `EnsureSchema`.
 - `mail/internal/search/client.go` — `Client`:
  - `EnsureSchema` legt den Index über den Manticore `/sql?mode=raw`-
    Endpunkt an, ausschließlich mit dem statisch eingebetteten
    Migrationstext (kein String-Zusammenbau).
  - `Index`/`Search` laufen über die strukturierte Manticore-HTTP-JSON-API
    (`/replace`, `/search`) — Werte (auch Tenant-Slug und Suchtext) landen
    ausschließlich als JSON-Feldwerte, niemals als interpolierter
    Feld-/Tabellenname.
  - `Search` filtert zwingend über `FieldTenantSlug` (Akzeptanzkriterium 3).
 - Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
  `mail/internal/encstorage`/`mail/internal/dedup` unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Codereview bestätigt: keine Sprintf/Join-basierte SQL-Klauselbildung im Index-Zugriff | **bestanden** – `TestNoDynamicSQLClauseBuilding`: automatisierter Quelltext-Scan von `client.go` bestätigt, dass kein `fmt.Sprintf` verwendet wird und in der Nähe des `/sql?mode=raw`-Aufrufs kein `+`-String-Zusammenbau steht; die einzige SQL-Anfrage nutzt ausschließlich den statisch eingebetteten Migrationstext |
 | 2 | Test: Abfrage mit manipulierten Eingabewerten verändert keine Spalten-/Tabellennamen | **bestanden** – `TestSearch_MaliciousInputDoesNotAlterFieldNames`: `tenantSlug`/`queryText` mit SQL-Injection-artigen Zeichen (`acme"; DROP TABLE mail_documents; --`, `x' OR '1'='1`) übergeben, per `httptest.Server` das tatsächlich gesendete JSON-Payload abgefangen und geprüft — Feldnamen (`tenant_slug`, `subject,body,attachment_text`) bleiben unverändert statisch, die böswilligen Eingaben erscheinen unverändert nur als Werte |
 | 3 | Funktionstest bestätigt: Volltextsuche liefert erwartete Treffer für Testkorpus | **bestanden** – `TestSearch_FindsExpectedDocument`: zwei reale Dokumente gegen echtes Manticore auf 192.168.1.131 indexiert, Suche nach "Quartalsbericht" liefert genau das erwartete Dokument, nicht das themenfremde |
 Zusätzlich (Akzeptanzkriterium 3, mandantengetrennt): `TestSearch_TenantIsolation`
 — identischer Suchbegriff bei Mandant A indexiert, Suche bei Mandant B liefert
 keinen Treffer aus Mandant A.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (4 Tests)
 ```
 Manticore lief bereits produktiv auf 192.168.1.131 (Port 9308, Version 7.4.1,
 Dienst `manticore.service` aktiv seit 2026-08-28). Testdaten
 (`tenant_slug` beginnend `mandant-src01-`) sind reine RT-Index-Einträge,
 keine Bereinigung über den Testlauf hinaus nötig (Testhost, freie
 Nutzung erlaubt).
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt SRC-02, SRC-03, SRC-09.
@@ -0,0 +1,58 @@
 # SRC-02 – Prüfprotokoll: Indexierungs-Worker & Synchronisierung
 Voraussetzung SRC-01, ARC-03 (beide Fertig).
 ## Umsetzung
 - `mail/internal/indexworker/migrations/0001_mail_index_jobs.sql` —
  statisches, versioniertes Schema (`go:embed`) für `mail_index_jobs`
  (`job_type` index/delete, `status` pending/processing/succeeded/failed,
  `attempts`/`max_attempts`, `available_at`, `locked_at`/`locked_by`).
 - `mail/internal/indexworker/queue.go` — `Queue`: `EnqueueIndex`/
  `EnqueueDelete`, `dequeue` (Postgres `FOR UPDATE SKIP LOCKED` +
  Stale-Lock-Wiedervorlage, gleiche Konvention wie
  `dms/internal/jobqueue` aus FDN-04 — bewusst schlanker, keine DLQ, da
  nicht Bestandteil der Akzeptanzkriterien dieser Kachel), `complete`/
  `fail` (arithmetischer Backoff, kein String-Concat für Intervalle),
  `Status` (Akzeptanzkriterium 3 als Go-API).
 - `mail/internal/indexworker/worker.go` — `Worker.RunOnce`: holt einen
  Job, ruft je nach `job_type` `search.Client.Index`/`search.Client.Delete`
  auf, markiert abschließend `complete`/`fail`.
 - `mail/internal/search`: minimale Erweiterung um `Client.Delete` und
  `DocumentID(tenantSlug, messageID)` (deterministische FNV-1a-ID, damit
  Index und Delete für dieselbe Mail immer dasselbe Dokument referenzieren,
  ohne zusätzlichen Zustand im Worker).
 - Kein Umbau: `mail/internal/storage`/`mail/internal/crypto`/
  `mail/internal/encstorage`/`mail/internal/dedup` unverändert;
  bestehende `search`-Tests/-Verhalten (SRC-01) unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Worker-Neustart mitten im Lauf verliert keinen offenen Auftrag | **bestanden** – `TestDequeue_WorkerCrashMidRunLosesNoJob`: Job wird geholt und NICHT abgeschlossen (simulierter Absturz), vor Ablauf der Stale-Lock-Frist real kein zweiter Job verfügbar, nach Ablauf real erneut derselbe Job an einen zweiten Worker zugestellt |
 | 2 | Test: Löschung einer Mail entfernt sie zuverlässig aus Suchtreffern | **bestanden** – `TestDeleteJob_RemovesMailFromSearchResults`: Mail indexiert und Auffindbarkeit real bestätigt, danach Lösch-Job verarbeitet, anschließende Suche liefert real keinen Treffer mehr |
 | 3 | Konsistenztest vergleicht Datenbankbestand mit Indexbestand stichprobenartig | **bestanden** – `TestConsistency_DatabaseAndIndexMatchOnSample`: 3 Index-Jobs verarbeitet, je Stichprobe real geprüft, dass der DB-Job-Status `succeeded` UND das zugehörige Dokument tatsächlich im Manticore-Index auffindbar sind |
 Zusätzlich (Akzeptanzkriterium 1, Funktionsnachweis): `TestIndexJob_MakesMailSearchable`
 — eingereihte Indexierungsaufgabe macht die Mail nach Worker-Verarbeitung
 real durchsuchbar.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/indexworker (5 Tests)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. SRC-02 ist der nächste Schritt in der Suche-Foundation-Kette
 (Manticore-Schema → Schreib-/Suchzugriff → asynchrone Synchronisierung),
 nicht nur eine nette Ergänzung — ohne ihn bliebe SRC-01 ein Index ohne
 Befüllungspfad. Entsperrt QA-03.
@@ -0,0 +1,61 @@
 # SRC-03 – Prüfprotokoll: Such-API mit Ranking
 Voraussetzung SRC-01 (Fertig).
 ## Umsetzung
 - `mail/internal/search/client.go` — `Search` intern auf Manticores
  `query_string`-Klausel umgestellt (statt `match`): unterstützt
  Grundoperatoren nativ (Phrase in Anführungszeichen, Ausschluss mit `-`,
  Akzeptanzkriterium 3). Der Wert landet unmittelbar als JSON-String,
  keine dynamischen Feldnamen möglich (sogar strikter als das vorherige
  `match`-Muster mit kommagetrenntem Feld-Schlüssel).
 - `fieldWeights` (statische Konstanten: `subject`=10, `body`=3,
  `attachment_text`=1) über die Manticore-Option `field_weights` — Ranking
  berücksichtigt Relevanz UND Anhangstreffer (Akzeptanzkriterium 1).
  Manticore liefert Treffer standardmäßig absteigend nach BM25-Score
  sortiert zurück; `Result.Score` macht das Ranking nachvollziehbar.
 - `Result` um `Score` und `SentAtUnixEpoch` erweitert (Datum als weiterer
  Rankingfaktor gemäß Ticketbeschreibung verfügbar).
 - Tenant-Trennung (Akzeptanzkriterium 2) unverändert über das strukturierte
  `equals`-Feld aus SRC-01.
 - Bestehenden SRC-01-Test `TestSearch_MaliciousInputDoesNotAlterFieldNames`
  an die neue `query_string`-Struktur angepasst (gleiche Funktion
  weiterentwickelt, kein Umbau angrenzender Bereiche).
 - Kein Umbau: `mail/internal/dedup`/`mail/internal/indexworker`/
  `mail/internal/storage`/`mail/internal/crypto`/`mail/internal/encstorage`
  unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Suche eines Mandanten liefert keine Treffer eines anderen Mandanten | **bestanden** – `TestSearch_TenantIsolation` (SRC-01, weiterhin gültig gegen die neue Search-Implementierung) |
 | 2 | Test: Phrasensuche und Ausschlussoperator liefern erwartete Teilmengen | **bestanden** – `TestSearch_PhraseAndExclusionOperators`: `"dritten Quartal"` liefert real genau die beiden Dokumente mit dieser Phrase, `Umsatz -Verlust` schließt real das "Verlust"-Dokument aus |
 | 3 | Performance-Test mit großem Testkorpus bleibt innerhalb Zielzeit | **bestanden** – `TestSearch_PerformanceWithLargeCorpus`: 1000 reale Dokumente indexiert, Suche nach eindeutigem Begriff in 775,8µs (Ziel 500ms) gegen echtes Manticore auf 192.168.1.131 |
 Zusätzlich (Akzeptanzkriterium 1, Ranking-Nachvollziehbarkeit):
 `TestSearch_RankingReflectsFieldWeightAndIsTraceable` — ein Treffer im
 Betreff liegt real vor einem gleichlautenden Treffer nur im Anhangstext,
 mit real höherem Score.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (7 Tests,
  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. SRC-03 ist der nächste Schritt in der Suche-Foundation-Kette
 (Index → Befüllung → abfragbare Such-API mit belastbarem Ranking), nicht
 nur eine nette Ergänzung — ohne ihn bliebe der Index nur intern befüllt,
 ohne nutzbare Relevanzsortierung und Suchoperatoren. Entsperrt INT-01,
 SRC-04, SRC-05, SRC-08.
@@ -0,0 +1,69 @@
 # SRC-04 – Prüfprotokoll: Such-Oberfläche mit Hervorhebung
 Voraussetzung SRC-03 (Fertig), SHL-01 (Core-Board, Fertig).
 ## Umsetzung
 - `web/mail-search`: eigenständige Next.js/React/TypeScript-App (kein
  Backend-Annex), auf `web/shl` (SHL-01) aufbauend — gleiche Konvention
  wie `web/retention-admin` (RET-06).
 - `app/api/search/route.ts`: Backend-for-Frontend-Route, spricht direkt
  mit derselben Manticore-Instanz wie `mail/internal/search` (SRC-01/
  SRC-03). Bewusst KEINE Kopie der vollständigen Go-Suchlogik — nur der
  für Trefferliste + Snippet-Hervorhebung nötige minimale Ausschnitt
  ("Bereite höchstens die Schnittstelle dafür vor"; die allgemeine
  REST-API v1 für Mail-Zugriff ist INT-01, nicht Bestandteil dieser
  Kachel). Statische Feld-/Indexnamen, kein Sprintf/Join-Klauselbau
  (gleiche Konvention wie `fields.go`). Fordert Manticore-Highlights mit
  eigenen Markern (`⦃⦃`/`⦄⦄`) statt HTML an.
 - `lib/highlight.ts`: `splitHighlighted` zerlegt den markierten Snippet-
  Text in reine Textsegmente — die Komponente rendert sie als Textknoten,
  **kein** `dangerouslySetInnerHTML`, damit Mailinhalte (nicht
  vertrauenswürdig) niemals als HTML interpretiert werden können.
 - `app/page.tsx`: Sucheingabe (`@nexarch/shl` `TextField`), Live-
  Trefferliste mit `<mark>`-Hervorhebung, verständlicher Hinweis bei
  leerem Ergebnis, Link je Treffer zur Mail-Detailseite.
 - `app/mail/[messageId]/page.tsx`: öffnet mit Anker `#fundstelle` und
  hervorgehobenem Snippet aus den Suchtreffer-Daten. Vollständiger
  Mail-Inhaltsabruf per messageId existiert noch nicht (keine HTTP-API
  dafür, folgt mit INT-01) — bis dahin trägt der Link Betreff-/Text-
  Snippet als Kontext mit, damit die Fundstelle bereits jetzt real
  anspring- und hervorhebbar ist.
 - `lib/contrast.ts`/`lib/highlightColors.ts`: reale WCAG-2.1-
  Kontrastberechnung statt behaupteter Werte.
 - Kein Umbau: `mail/internal/*`, `web/shl`, `web/retention-admin`
  unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Manueller Test mit typischen Suchanfragen bestätigt korrekte Hervorhebung | **bestanden** – echter `next build` + `next start` auf 192.168.1.131 gegen die live laufende Manticore-Instanz: `GET /api/search?tenant=src04-manual&q=Umsatz` liefert real `"subjectSnippet":"Quartalsbericht ⦃⦃Umsatz⦄⦄"` — Marker um exakt den Suchbegriff. Zusätzlich automatisiert in `app/page.test.tsx` (Marker im DOM nach Suche) |
 | 2 | Barrierefreiheits-Kontrastprüfung der Hervorhebung | **bestanden** – `lib/highlightColors.test.ts`: echte WCAG-2.1-Berechnung, Hell-Modus 14,29:1, Dunkel-Modus 6,43:1 (beide ≥ 4.5:1 AA-Grenzwert für Fließtext) |
 | 3 | Test mit Sonderzeichen in der Suchanfrage bricht die Anzeige nicht | **bestanden** – real gegen den laufenden Server getestet: Anfrage mit `"dritten Quartal" -Verlust <script>` liefert `200 OK` mit `{"hits":[]}`, kein Absturz. Zusätzlich automatisiert `lib/highlight.test.ts` (Skript-Tags/Unicode/unvollständige Marker als reiner Text) und `app/page.test.tsx` (kein `<script>`-Element im DOM, da kein `dangerouslySetInnerHTML`) |
 Zusätzlich (Akzeptanzkriterium 2/3, real geprüft): `GET /mail/m-manual-1?subject=...`
 liefert `200 OK`; automatisiert `app/page.test.tsx` bestätigt Link-Struktur
 (`/mail/<id>?...#fundstelle`) und den "Keine Treffer"-Hinweis bei leerem
 Ergebnis.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 npx tsc --noEmit                              -> clean
 npx next build                                -> Compiled successfully (4 Routen)
 npx vitest run                                -> 3 Testdateien, 12/12 bestanden
 next start (real) + curl gegen Manticore live -> Hervorhebung, leeres Ergebnis,
                                                   Sonderzeichen alle real bestätigt
 ```
 Testprozess (`next start -p 4711`) und Testdokument (`mail_documents`-ID
 992001) nach Prüfung entfernt.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. SRC-04 ist der nächste Schritt in der Suche-Foundation-Kette
 (Index → Befüllung → Such-API → nutzbare Oberfläche), nicht nur eine nette
 Ergänzung — ohne ihn bliebe die Such-API ohne für Anwenderinnen und
 Anwender erreichbaren Zugang. Entsperrt QA-03 (gemeinsam mit SRC-02).
@@ -0,0 +1,54 @@
 # SRC-05 – Prüfprotokoll: Facetten- & Filter-API
 Voraussetzung SRC-03 (Fertig).
 ## Umsetzung
 - `mail/internal/search/migrations/0002..0005_*.sql`: vier eigene,
  nummerierte `ALTER TABLE ADD COLUMN`-Migrationen für die neuen
  Facettenfelder (`sender`, `mailbox`, `attachment_type`, `tag`) — Manticore
  erlaubt nur eine Spalte je ALTER-Anweisung. `EnsureSchema` wendet sie
  idempotent nach (Fehlertext `"already in schema"` gilt als bereits
  angewendet, kein Fehlerzustand).
 - `fields.go`: neue statische Feldkonstanten + `FacetFields`-Whitelist
  (`sender`, `mailbox`, `attachment_type`, `tag`) — einzige Quelle
  zulässiger Facettendimensionen, kein beliebiger Client-Feldname möglich.
 - `facets.go` — `Client.Facets(ctx, tenantSlug, queryText, filters)`:
  nutzt Manticores strukturierte `aggs.terms`/`aggs.range`-API (kein
  dynamischer SQL-Klauselbau). Tenant-Filter + optionale
  `FacetFilter`-Liste laufen als zusätzliche `equals`-Klauseln in
  derselben `bool.must`-Liste (Akzeptanzkriterium 2: UND-Verknüpfung).
  Zeitraum-Facette über feste Buckets (letzte 7 Tage/30 Tage/Jahr/älter)
  via `aggs.range` auf `sent_at`.
 - `Document` um optionale Facettenfelder erweitert (`Sender`, `Mailbox`,
  `AttachmentType`, `Tag`).
 - Kein Umbau: `Search`/`Delete`/`Index`-Verhalten aus SRC-01/SRC-03
  unverändert, `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/
  `encstorage` unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Facettenzahlen stimmen mit tatsächlicher Treffermenge überein | **bestanden** – `TestFacets_CountsMatchActualHits`: 3 reale Dokumente indexiert, Facette `sender` liefert real `alice@example.com`→2, `bob@example.com`→1, Facette `attachment_type` liefert real `pdf`→2 |
 | 2 | Test: Kombination von drei Filtern liefert korrekt eingeschränkte Treffer | **bestanden** – `TestFacets_ThreeFiltersCombineWithAND`: 4 Dokumente, von denen 3 je genau einen der drei Filter (Sender/Postfach/Anhangstyp) verletzen — nach Kombination aller drei Filter bleibt real genau 1 Treffer übrig |
 | 3 | Test: Facetten eines Mandanten enthalten keine Werte eines anderen | **bestanden** – `TestFacets_TenantSeparation`: identische Feldstruktur bei zwei Mandanten, Facette bei Mandant B enthält real keinen Wert von Mandant A |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -p 1  -> alle Pakete bestanden, inkl. internal/search (10 Tests,
  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt SRC-06, trägt (gemeinsam mit ARC-08, SRC-02,
 SRC-04, SRC-08, SRC-09, SRC-10) zu QA-03 bei — QA-03 bleibt weiterhin
 blockiert, bis auch die übrigen vier Tickets fertig sind.
@@ -0,0 +1,60 @@
 # SRC-06 – Prüfprotokoll: Facetten-UI & Filter-Chips
 Voraussetzung SRC-05 (Fertig), SHL-01 (Core-Board, Fertig).
 ## Umsetzung
 - `web/mail-search/app/api/facets/route.ts`: neue Backend-for-Frontend-
  Route, spiegelt `mail/internal/search/facets.go` (`Client.Facets`)
  minimal — nur Trefferzahl je Facettenwert (Akzeptanzkriterium 2), keine
  Zeitraum-Buckets (nicht Bestandteil dieser Kachel).
 - `web/mail-search/lib/manticoreQuery.ts`: gemeinsamer, statischer
  `bool.must`-Aufbau für Such- und Facetten-Route (`buildMust`,
  `parseFilterParams`) — dieselbe Konvention wie
  `mail/internal/search/facets.go` `buildFilteredMust`, kein
  Sprintf/Join-artiger Klauselbau.
 - `app/api/search/route.ts` (SRC-04) minimal erweitert: akzeptiert jetzt
  wiederholbare `?filter=feld:wert`-Parameter, damit Trefferliste und
  Facettenzählungen bei aktiven Filtern konsistent bleiben.
 - `app/FacetPanel.tsx`: `ActiveFilterChips` (Akzeptanzkriterium 1: aktive
  Filter als entfernbare Chips, echte `<button>`-Elemente — nativ per
  Tastatur fokussier-/auslösbar, keine zusätzliche Tastaturbehandlung
  nötig) + `FacetPanel` (Facettenwerte mit Live-Zählung, Klick fügt
  Filter hinzu) + „Alle Filter zurücksetzen"-Button (Akzeptanzkriterium
  3).
 - `app/page.tsx`: Filterzustand ausgelagert nach `lib/filterState.ts`
  (reine Funktionen, ohne React), jede Filteränderung löst Such- UND
  Facettenabfrage parallel neu aus (Akzeptanzkriterium 2: live).
 - Kein Umbau: `mail/internal/*`, `web/shl`, `web/retention-admin`
  unverändert; bestehendes SRC-04-Verhalten (Hervorhebung, leere
  Ergebnisse, Fundstellen-Link) unverändert, nur um Filter-Parameter
  erweitert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Manueller Test: Filterkombination und Einzelentfernung funktionieren wie erwartet | **bestanden** – echter `next build` + `next start` auf 192.168.1.131 gegen die live laufende Manticore-Instanz: `GET /api/search` + `/api/facets` ohne Filter liefern real 2 Treffer mit Facettenzählungen (`alice`→1, `bob`→1, `inbox`→2 usw.), mit `filter=sender:alice@example.com` liefern beide Routen real konsistent genau 1 Treffer und auf 1 reduzierte Facettenzählungen |
 | 2 | Tastaturbedienbarkeit der Filter-Chips geprüft | **bestanden** – automatisiert mit `@testing-library/user-event` (echte Tastatursimulation, kein bloßer Klick): Chip fokussieren (`Tab`-Ziel), `{Enter}` löst real dieselbe Entfernung wie ein Klick aus |
 | 3 | Test mit vielen aktiven Filtern bleibt die Ansicht übersichtlich | **bestanden** – 20 gleichzeitig aktivierte Filter real erzeugen real 20 einzeln erkennbare, nicht zusammengefasste Chips im DOM, kein Absturz, `flexWrap` verhindert horizontales Überlaufen |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 npx tsc --noEmit                              -> clean
 npx next build                                -> Compiled successfully (5 Routen)
 npx vitest run                                -> 4 Testdateien, 19/19 bestanden (8 in app/page.test.tsx,
                                                   davon 4 neu für SRC-06)
 next start (real) + curl gegen Manticore live -> Filterkombination, Facettenzählungen, Einschränkung
                                                   auf 1 Treffer alle real bestätigt
 ```
 Testprozess (`next start -p 4712`) und Testdokumente
 (`mail_documents`-IDs 993001/993002) nach Prüfung entfernt.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt (gemeinsam mit den übrigen QA-09-Abhängigkeiten)
 einen Teil des Wegs zu QA-09 — QA-09 bleibt weiterhin blockiert (QA-02,
 QA-04..QA-08 noch offen).
@@ -0,0 +1,69 @@
 # SRC-07 – Prüfprotokoll: OCR für Anhänge
 Voraussetzung ARC-01, ARC-03 (beide Fertig). SRC-07 ist die direkte
 Vorbedingung für SRC-10 (Spracherkennung & OCR-Qualitätsbewertung), nicht
 nur eine nette Ergänzung — ohne SRC-07 gibt es keinen erkannten Text, den
 SRC-10 mit Sprache/Konfidenz bewerten könnte.
 ## Umsetzung
 - `mail/internal/ocr/ocr.go` — zustandsloses Paket, kennt weder Mandant
  noch Speicher (dieselbe Bauart wie `mail/internal/crypto`/`dedup`):
  nimmt Anhangs-Bytes entgegen, liefert erkannten Text zurück. Kein
  geteilter Zustand zwischen Aufrufen (jeder Aufruf bekommt ein eigenes
  Temp-Verzeichnis) — Tenant-Trennung ist dadurch strukturell gegeben,
  nicht nur konventionell: ein Mandant kann prinzipbedingt nie Zwischen-
  daten eines anderen sehen. Zuordnung des erkannten Textes zum
  Mail-Suchdokument (Akzeptanzkriterium 2) erfolgt beim Aufrufer über das
  bereits vorhandene `search.Document.AttachmentText`-Feld (SRC-01) — kein
  neues Feld nötig.
  - `ExtractTextFromImage`: ruft `tesseract` (Sprachen `deu+eng`) mit
    fester Argumentliste auf, kein Shell-String-Zusammenbau.
  - `HasTextLayer`/`ExtractTextFromPDF`: nutzt `pdftotext`, um eine
    vorhandene Textebene zu erkennen und direkt zu übernehmen
    (Akzeptanzkriterium 3) — nur wenn keine Textebene vorhanden ist
    (< 10 Zeichen), wird über `pdftoppm` (300dpi) jede Seite gerastert und
    per Tesseract erkannt (Akzeptanzkriterium 1).
 - Bekannten Fehler vermieden (dupliziertes Sprintf-WHERE-Muster aus
  archivmail, siehe repos-analyse-mail-reuse.md): dieses Paket baut keine
  SQL-Klauseln — ausschließlich externe Kommandozeilenwerkzeuge mit
  festen Argumentlisten (`exec.CommandContext`, keine Shell).
 - Kein Umbau: `mail/internal/search`/`dedup`/`indexworker`/`storage`/
  `crypto`/`encstorage`/`savedsearch` unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Bildanhang mit bekanntem Text liefert erwartete Texterkennung | **bestanden** – `TestExtractTextFromImage_KnownTextRecognized`: reales, über `pdftoppm` gerastertes Bild mit dem Text "Rechnungsnummer 4711", `ExtractTextFromImage` erkennt real beide Wortbestandteile |
 | 2 | Test: PDF mit vorhandener Textebene wird korrekt übersprungen | **bestanden** – `TestExtractTextFromPDF_SkipsOCRWhenTextLayerPresent`: real erzeugtes Vektor-Text-PDF (echte PDF-Textebene, kein Bild), `ExtractTextFromPDF` liefert `OCRPerformed=false` und den Text direkt aus der Textebene |
 | 3 | Durchsatztest bestätigt akzeptable Verarbeitungszeit je Anhang | **bestanden** – `TestExtractTextFromPDF_ThroughputIsAcceptable`: 3 reale Anhänge (Rasterung 300dpi + OCR) in durchschnittlich 3,48s/Anhang (Ziel 8s/Anhang) |
 Zusätzlich (Akzeptanzkriterium 1, gescannte PDFs end-zu-Ende):
 `TestExtractTextFromPDF_PerformsOCRWhenNoTextLayer` — ein reales,
 ausschließlich rasterbildbasiertes PDF (kein Textelement, JPEG-Bild via
 `/DCTDecode` eingebettet) wird real per OCR erkannt, `OCRPerformed=true`.
 Testfixtures (`testpdf_test.go`) werden vollständig in Go erzeugt (Hand-
 gebautes PDF mit Helvetica-Textebene bzw. eingebettetem JPEG) — keine
 externe Bibliothek, keine Testdateien im Repository, reproduzierbar.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./internal/ocr/... -v  -> 4/4 bestanden (14,99s gesamt)
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle Pakete bestanden, keine Regression
 ```
 Werkzeugversionen auf 192.168.1.131: `tesseract 5.5.0` (Sprachpakete
 `deu`, `eng`), `pdftotext`/`pdftoppm` (poppler-utils) — bereits vorhanden,
 keine Installation durch diese Sitzung nötig.
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt SRC-10.
@@ -0,0 +1,59 @@
 # SRC-08 – Prüfprotokoll: Gespeicherte Suchanfragen
 Voraussetzung SRC-03 (Fertig).
 ## Umsetzung
 - `mail/internal/savedsearch/store.go` — `Store` (Postgres,
  `mail_saved_searches`): `Save` (Upsert über `UNIQUE(tenant_slug,
  user_id, name)`, Akzeptanzkriterium 1), `List`/`Get` streng auf
  Mandant UND Benutzer beschränkt (Akzeptanzkriterium 3), `Delete`
  löscht genau eine Zeile über `tenant_slug + user_id + id`.
  „Benutzer" ist bis zu einer zentralen Session-/IAM-Anbindung
  (Core-Board-Scope) ein vom Aufrufer mitgegebener opaker
  `userID`-String — dieselbe Konvention wie der Tenant-Kontext in
  `web/mail-search` (SRC-04).
 - `Execute(ctx, client, saved)` führt die gespeicherte Suche LIVE gegen
  `search.Client` aus — speichert selbst keine Treffer, jeder Aufruf
  fragt Manticore neu ab (Akzeptanzkriterium 2).
 - `mail/internal/search/facets.go` — kleinste nötige Erweiterung: neue
  Methode `Client.SearchWithFilters` (gemeinsame `buildFilteredMust`-
  Hilfsfunktion mit `Facets` extrahiert) liefert TATSÄCHLICH gefilterte
  Treffer statt nur Facettenzählungen — ohne dies gäbe es keinen echten
  Weg, gespeicherte Filter beim Wiederausführen anzuwenden.
 - Kein Umbau: `Search`/`Facets`/`Index`/`Delete`-Verhalten sonst
  unverändert, `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/
  `encstorage` unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: gespeicherte Suche mit mehreren Filtern wird korrekt reproduziert | **bestanden** – `TestExecute_SavedSearchWithMultipleFiltersReproducesCorrectly`: 3 Dokumente, 2 Filter (Sender+Postfach) gespeichert, `Execute` liefert real genau das eine Dokument, das beide Filter erfüllt |
 | 2 | Test: Benutzer sieht keine gespeicherten Suchen anderer Mandanten | **bestanden** – `TestList_UserSeesNoOtherTenantsSavedSearches`: zwei Mandanten mit je einer gespeicherten Suche, `List` bei Mandant B liefert real nur die eigene, nicht die von Mandant A |
 | 3 | Test: Löschen einer gespeicherten Suche entfernt nur diese | **bestanden** – `TestDelete_RemovesOnlyThatSavedSearch`: zwei gespeicherte Suchen, eine gelöscht, `Get` liefert für die gelöschte real `ErrNotFound`, die andere bleibt real unverändert abrufbar |
 Zusätzlich (Akzeptanzkriterium 2, kein eingefrorener Snapshot):
 `TestExecute_ReturnsCurrentResultsNotFrozenSnapshot` — Ausführung vor
 einer neuen Indexierung liefert real 0 Treffer, danach real 1 Treffer,
 ohne dass die gespeicherte Suche selbst verändert wurde.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -p 1  -> alle Pakete bestanden, inkl. internal/savedsearch (4 Tests, neu),
  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate/
  crypto/search
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt (gemeinsam mit ARC-08, SRC-02, SRC-04, SRC-05,
 SRC-09) zu QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch
 SRC-10 fertig ist.
@@ -0,0 +1,72 @@
 # SRC-09 – Prüfprotokoll: Suchindex-Neuaufbau/Reindexierung
 Voraussetzung SRC-01 (Fertig).
 ## Umsetzung
 - `mail/internal/search/reindex.go` — `Reindexer.Rebuild(ctx, onProgress)`:
  1. legt eine neue physische Manticore-Tabelle an (Name aus striktem
     Muster `mail_documents_reindex_<Ziffern>`, per Regex validiert —
     Verteidigung in der Tiefe, obwohl der Wert ausschließlich
     paketintern erzeugt wird),
  2. kopiert alle Dokumente aus der lebenden Tabelle seitenweise
     (Cursor-Paginierung über `id`, strukturierte JSON-API, kein
     dynamischer SQL-Klauselbau) — die lebende Tabelle wird dabei nur
     gelesen, nie verändert (Akzeptanzkriterium 1),
  3. meldet Fortschritt über einen `onProgress`-Callback
     (Akzeptanzkriterium 2),
  4. vergleicht Trefferzahlen alt/neu — bei Abweichung kein Umschalten,
  5. schaltet erst danach per Manticore `ALTER TABLE ... RENAME`
     (reine Metadaten-Operation) atomar um. Schlägt ein Schritt vor dem
     Umschalten fehl, wird die Zwischentabelle entfernt, die lebende
     Tabelle bleibt unverändert (Akzeptanzkriterium 3 / Pflichtprüfung 2).
 - Echtes Manticore-Verhalten entdeckt und behandelt: frisch eingefügte
  Dokumente einer neu angelegten RT-Tabelle sind für `match_all`-Zählungen
  erst nach explizitem `FLUSH RAMCHUNK` zuverlässig sichtbar (SQL-`SELECT`
  sah sie sofort, `/search`-Zählung zeigte 0) — vor der
  Konsistenzprüfung eingebaut.
 - Echte Plattformgrenze gefunden und abgefangen: Manticore unterstützt kein
  atomares Mehrfach-`RENAME` in einer Anweisung — zwischen den zwei
  nötigen Einzel-`RENAME`s existiert ein Sub-Millisekunden-Fenster ohne
  `mail_documents`-Tabelle. `Client.Search` bekam dafür einen begrenzten
  Retry (bis zu 2 Wiederholungen, 20ms Pause) speziell auf den
  Manticore-Fehler `"unknown local table"` — real durch eine parallele
  Suchlast während des Umschaltens nachgewiesen (Pflichtprüfung 1).
 - Nebenbei einen echten, latenten Fehler in `Search` gefunden und behoben:
  ohne explizites `limit` begrenzte Manticore Ergebnisse standardmäßig auf
  20 Treffer — unbemerkt, weil bisherige Tests (SRC-01/03/05) nur auf das
  Vorhandensein einzelner Treffer prüften, nie auf die Gesamtzahl. Jetzt
  `searchResultLimit = 1000`.
 - Kein Umbau: `Index`/`Delete`/`Facets`-Verhalten sonst unverändert,
  `mail/internal/dedup`/`indexworker`/`storage`/`crypto`/`encstorage`
  unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test: Reindex während laufender Suchanfragen unterbricht die Suche nicht | **bestanden** – `TestRebuild_SearchKeepsWorkingDuringReindex`: 30 reale Dokumente indexiert, parallele Sucher-Goroutine (alle 2ms) läuft während `Rebuild` mit — 0 fehlgeschlagene Suchen über den gesamten Umschaltvorgang, danach weiterhin real alle 30 Treffer auffindbar |
 | 2 | Test: abgebrochener Reindex hinterlässt keinen inkonsistenten Zustand | **bestanden** – `TestRebuild_AbortedReindexLeavesNoInconsistentState`: Kontext vor `Rebuild` abgebrochen, Fehler kommt real zurück, lebende Tabelle bleibt danach unverändert (weiterhin 1 Treffer real auffindbar), keine verwaisten Zwischentabellen über `SHOW TABLES` real bestätigt |
 | 3 | Stichprobenvergleich Alt-/Neuindex bestätigt gleiche Trefferzahlen | **bestanden** – `TestRebuild_SampleComparisonMatchesOldAndNewIndex`: 3 unterschiedliche Suchbegriffe vor und nach Reindex real verglichen, identische Trefferzahlen je Stichprobe |
 Zusätzlich (Akzeptanzkriterium 2): `TestRebuild_ReportsProgress` bestätigt
 reale Fortschrittsmeldungen bis zum vollständigen Abschluss.
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 TEST_TENANT_DSN=postgresql://nexarch_test:***@localhost:5432/tenant_acme?sslmode=disable \
 TEST_MANTICORE_URL=http://127.0.0.1:9308 \
  go test ./... -v -p 1  -> alle Pakete bestanden, inkl. internal/search (14 Tests,
  keine Regression in dedup/indexworker/storage/encstorage/example/mimeparse/pflichttestgate)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Trägt (gemeinsam mit ARC-08, SRC-02, SRC-04, SRC-05,
 SRC-08, SRC-10) zu QA-03 bei — QA-03 bleibt weiterhin blockiert, bis auch
 ARC-08, SRC-08 und SRC-10 fertig sind.
@@ -0,0 +1,57 @@
 # SRC-10 – Prüfprotokoll: Spracherkennung & OCR-Qualitätsbewertung
 Voraussetzung SRC-07 (Fertig).
 ## Umsetzung
 - `mail/internal/ocr/language.go` — `RecognizeWithLanguageAndConfidence`:
  Tesseract erkennt bei kombinierten Sprachpaketen (`deu+eng`) nicht,
  WELCHE Sprache vorlag — daher wird das Bild bewusst EINZELN mit jedem
  Kandidaten (`deu`, `eng`) im TSV-Ausgabemodus erkannt; die Sprache mit
  dem höheren durchschnittlichen Worterkennungs-Konfidenzwert gewinnt
  (Akzeptanzkriterium 1). Derselbe Tesseract-TSV-Lauf liefert den
  Konfidenzwert direkt mit (Akzeptanzkriterium 2, 0–100, Mittelwert über
  alle erkannten Wörter) — keine zweite externe Bibliothek nötig.
 - `mail/internal/search`: neue Felder `ocr_language`/`ocr_confidence`
  (Migrationen 0006/0007, gleiches ALTER-Muster wie SRC-05), in
  `Document`/`Result` gespiegelt (Akzeptanzkriterium 1: für Anzeige
  nutzbar). Neue Methode `Client.AttachmentsBelowConfidence(ctx,
  tenantSlug, threshold)` (Akzeptanzkriterium 3: gezielt für manuelle
  Nachbearbeitung auffindbar) — filtert `ocr_confidence < threshold`,
  schließt Dokumente ohne OCR-Anhang (`ocr_confidence` bleibt 0) explizit
  aus.
 - Echten Regressionsbug beim eigenen Testlauf gefunden und behoben:
  `reindex.go`s `buildCreateTableSQL` (SRC-09) kannte die neuen
  OCR-Spalten nicht — ein Reindex nach dieser Kachel wäre mit "unknown
  column" fehlgeschlagen. Jetzt ergänzt, mit Wartungshinweis im
  Quelltext für künftige Schema-Erweiterungen.
 - Kein Umbau: `Search`/`Facets`/`SearchWithFilters`/`Index`/`Delete`-
  Verhalten sonst unverändert, `mail/internal/dedup`/`indexworker`/
  `storage`/`crypto`/`encstorage`/`savedsearch` unverändert.
 ## Prüfungen
 | # | Prüfung | Ergebnis |
 |---|---|---|
 | 1 | Test mit mehrsprachigem Testkorpus bestätigt korrekte Spracherkennung | **bestanden** – `TestRecognizeWithLanguageAndConfidence_MultilingualCorpus`: reales deutsches Testbild ("Rechnung ueber Lieferung...") real als `deu` erkannt, reales englisches Testbild ("Invoice for delivery...") real als `eng` erkannt |
 | 2 | Test: künstlich verschlechtertes Bild erzeugt niedrigeren Konfidenzwert | **bestanden** – `TestRecognizeWithLanguageAndConfidence_DegradedImageLowersConfidence`: reproduzierbare Pixelierung + Kontrastreduktion (reiner Go-Standardbibliothekscode, kein externes Werkzeug) senkt den real gemessenen Konfidenzwert von 91,76 auf 28,21 |
 | 3 | Abfrage aller Anhänge unterhalb einer Konfidenzschwelle liefert erwartete Treffer | **bestanden** – `TestAttachmentsBelowConfidence_QueryReturnsExpectedResults`: 4 Dokumente (2 niedrig-, 1 hoch-konfident, 1 ohne OCR-Anhang), Abfrage mit Schwelle 50 liefert real genau die 2 niedrig-konfidenten, weder den hoch-konfidenten noch den ohne OCR-Anhang |
 ## Build/Test-Ergebnis (192.168.1.131)
 ```
 go build ./...  -> clean
 go vet ./...    -> clean
 golangci-lint run ./...  -> 0 issues
 go test ./internal/ocr/... -v -run 'Language|Degraded'  -> 2/2 bestanden
 TEST_TENANT_DSN=... TEST_MANTICORE_URL=... go test ./... -p 1
  -> alle Pakete bestanden (Regressionsbug in reindex.go vor diesem
  Protokoll gefunden und behoben, danach vollständig grün)
 ```
 ## Gesamtergebnis
 **Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
 real erfüllt. Entsperrt QA-03 (gemeinsam mit ARC-08, SRC-02, SRC-04,
 SRC-05, SRC-08, SRC-09 — alle jetzt Fertig, letzte fehlende
 Abhängigkeit).
@@ -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).
@@ -1,16 +1,48 @@
 module gitea.perlbach24.de/scripte/nexarch/mail
-go 1.22
+go 1.24
 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
 )
 require (
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 // indirect
 	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 // indirect
 	github.com/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
 )
@@ -1,6 +1,54 @@
 github.com/aws/aws-sdk-go-v2 v1.45.1 h1:iIoG3NaLhV6UZpPXyPXlDj2I9oS8tV/nMcMnITCC6Ks=
 github.com/aws/aws-sdk-go-v2 v1.45.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 h1:GPRlPwz40I2B2VrBEASOA3Bi77NyeqejNLkifosX0rs=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20/go.mod h1:g7PNzKcsOKWb4fkSRBA7BZVAS6Y8IcxzN+nRohhQ1Q8=
 github.com/aws/aws-sdk-go-v2/config v1.33.1 h1:bq9jze1hQ5YTCLoVxNnbp0T7rglrlOE7N9YsHqjGkEw=
 github.com/aws/aws-sdk-go-v2/config v1.33.1/go.mod h1:2A3HQwG4zaL5Tm80rc6RZj8LmWWv4WYT5v8raSz/L7A=
 github.com/aws/aws-sdk-go-v2/credentials v1.20.1 h1:Z8GRNEx0u9sDkZOq4PUnN8mjGwbUQGRzMSXpvt3d8xQ=
 github.com/aws/aws-sdk-go-v2/credentials v1.20.1/go.mod h1:uBIK00kFo95dnemqfFMTWx0X8YRqsh6ecIoCjjOkZqM=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1 h1:YIEBqcqRnpi4Pfv0YHImtgi6czGCwKHANC7SwmUAVD0=
 github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.19.1/go.mod h1:imEf0oufgAo8KAkCHhrOdqGEC0YWx1PPBQH82shSxGw=
 github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1 h1:pc138gM1CW+XPc60rEwUlwwuwWFQK16CI1T7v1F9Oec=
 github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.1/go.mod h1:1+koxpPIbfBdfzP6vojm5/zTpTQ/micYwlxIiNB3TxI=
 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1 h1:K0JsbZQj+1h208Ro1zHeA4l7bMp0NvRffHQ91q8Ol1s=
 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.1/go.mod h1:W3/vL6EtCIatICGy9ab29QhMuae+cOKPWcMxv02CO+Q=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1 h1:yhw5KD1phVyP9vijxOUzDfEtJx+bt+L63k+VfuiYFAA=
 github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.1/go.mod h1:ZW2e0d7DYlRxlS9hEiMXE47gTdX5KRN4byUiNbUpG+Q=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg=
 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1 h1:s67hBfG5t9rn1NCvDuB4E3QIep3UFhHPtaIqFDjV3N8=
 github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.1/go.mod h1:FpvjBMXtSNMLPmDJsWwcY5cRnqJlpS2y1R6n4pvzs4k=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1 h1:RmmWQPREQdk9U+PfqeHW3MqZaBaNK7TpV9W3RY+b+7g=
 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.1/go.mod h1:0A3W4F+68ZnNk5XcNL/e9HFMwnP8RlEicFfy6eOEDyw=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1 h1:ZMbtPZZQRca+3+XYQne9PBvRiYpHZlNJJOZfE9WNfT0=
 github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.1/go.mod h1:YAGWQdCYlVCoqrzvfv3RLxO6zKwti7gsAULOGWPLYv4=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1 h1:kVpzaDBzOdRtOftmiSpTdQbWVqRg0kONLXijktiwXnk=
 github.com/aws/aws-sdk-go-v2/service/s3 v1.109.1/go.mod h1:CUr46sCpGAg/rHaclRyhJX0LJAmH73uWSJPPSaMUrSk=
 github.com/aws/aws-sdk-go-v2/service/signin v1.7.1 h1:mdMtSVKdQ3+mzBh+l0ogrFYZVQUCg6pJZOirA2ARsYE=
 github.com/aws/aws-sdk-go-v2/service/signin v1.7.1/go.mod h1:9IqUlsJDbUPcg6cgx3WEzXdjrbWzLDQrak0aaSqlTcI=
 github.com/aws/aws-sdk-go-v2/service/sso v1.35.1 h1:B6WFn91tobD6gG4724ONHaqrpKsoETGnv98LHe/yIGM=
 github.com/aws/aws-sdk-go-v2/service/sso v1.35.1/go.mod h1:tWuiVBUtPBr8/rgRiYS8Uf85sHcAN+G7XS3D3CEoUh8=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1 h1:6yeYCWFvgbI2TI3K6jr9LtBNhXgJ7g4xqD+DEiaDDmM=
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.40.1/go.mod h1:naFe83jSMuYkH+QjQPX8n1MLhBkeCFM5Lsnh5m5wz3c=
 github.com/aws/aws-sdk-go-v2/service/sts v1.47.1 h1:Sv2xPnRHlThSUtVujYuUBPI/Il8si6UPHXL8DMiB/F0=
 github.com/aws/aws-sdk-go-v2/service/sts v1.47.1/go.mod h1:mKo/CzaCz8qytGW70NG4vIIGAx1HXTlb5lHNkC5k3lk=
 github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ=
 github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/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=
@@ -9,20 +57,46 @@ 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=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
 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=
@@ -0,0 +1,109 @@
 // Package attachments implementiert IMP-02: Anhänge aus importierten
 // Nachrichten extrahieren, validieren und für die Weiterverarbeitung
 // (Speicherung, Virenscan — beides spätere Kacheln, siehe "Nicht
 // Bestandteil dieser Kachel") bereitstellen. Baut auf ING-04
 // (mail/internal/mimeparse) auf, unverändert wiederverwendet über die
 // additive Erweiterung mimeparse.ParseTolerant — kein Umbau der
 // bestehenden, fertigen ING-04-Logik.
 package attachments
 import (
 	"io"
 	"net/http"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/mimeparse"
 )
 // Attachment ist EIN extrahierter, validierter Anhang
 // (Akzeptanzkriterium 1: Originaldateiname, Größe, geprüfter
 // Content-Type).
 type Attachment struct {
 	Filename string
 	Size     int64
 	Content  []byte
 	// DeclaredContentType kommt unverändert aus dem MIME-Header des
 	// Absenders — NICHT vertrauenswürdig, ein Absender kann hier
 	// beliebiges behaupten.
 	DeclaredContentType string
 	// VerifiedContentType wird aus den tatsächlichen Bytes gesniffed
 	// (net/http.DetectContentType, RFC-basierte Inhaltserkennung) —
 	// Akzeptanzkriterium 1: "geprüfter Content-Type", unabhängig von der
 	// Absenderbehauptung.
 	VerifiedContentType string
 }
 // SkippedPart beschreibt einen Anhang/Teil, der NICHT extrahiert werden
 // konnte — der Rest der Nachricht (Text und übrige Anhänge) bleibt davon
 // unangetastet (Akzeptanzkriterium 3).
 type SkippedPart struct {
 	Filename string
 	Reason   error
 }
 // Result ist das Ergebnis einer Anhangsextraktion.
 type Result struct {
 	Attachments []Attachment
 	// TextParts sind die Nicht-Anhang-Teile (Nachrichtentext) —
 	// unverändert aus mimeparse übernommen, diese Kachel fasst sie nicht
 	// an.
 	TextParts []mimeparse.Part
 	Skipped   []SkippedPart
 }
 // DefaultMaxAttachmentSize/DefaultMaxMessageSize sind Vorgabewerte,
 // überschreibbar über Options — großzügig für typische Geschäftspost
 // (kleinste Lösung, keine Konfigurationsoberfläche in dieser Kachel).
 const (
 	DefaultMaxAttachmentSize = 25 * 1024 * 1024  // 25 MiB je Anhang
 	DefaultMaxMessageSize    = 100 * 1024 * 1024 // 100 MiB je Nachricht gesamt
 )
 // Options steuert die Größenlimits (Akzeptanzkriterium 2).
 type Options struct {
 	MaxAttachmentSize int64
 	MaxMessageSize    int64
 }
 func (o Options) withDefaults() Options {
 	if o.MaxAttachmentSize <= 0 {
 		o.MaxAttachmentSize = DefaultMaxAttachmentSize
 	}
 	if o.MaxMessageSize <= 0 {
 		o.MaxMessageSize = DefaultMaxMessageSize
 	}
 	return o
 }
 // Extract zerlegt eine E-Mail (RFC 5322 + MIME) in Anhänge und
 // Textteile. Ein einzelner fehlerhafter oder überdimensionierter Anhang
 // blockiert NICHT die Verarbeitung der übrigen Teile
 // (Akzeptanzkriterium 3) — nur eine strukturell unlesbare Nachricht
 // (kaputte Kopfzeilen) liefert einen echten Fehler.
 func Extract(r io.Reader, opts Options) (Result, error) {
 	opts = opts.withDefaults()
 	msg, partErrors, err := mimeparse.ParseTolerant(r, opts.MaxAttachmentSize, opts.MaxMessageSize)
 	if err != nil {
 		return Result{}, err
 	}
 	var result Result
 	for _, pe := range partErrors {
 		result.Skipped = append(result.Skipped, SkippedPart{Filename: pe.Filename, Reason: pe.Err})
 	}
 	for _, part := range msg.Parts {
 		if !part.IsAttachment {
 			result.TextParts = append(result.TextParts, part)
 			continue
 		}
 		result.Attachments = append(result.Attachments, Attachment{
 			Filename:            part.Filename,
 			Size:                part.Size,
 			Content:             part.Content,
 			DeclaredContentType: part.ContentType,
 			VerifiedContentType: http.DetectContentType(part.Content),
 		})
 	}
 	return result, nil
 }
@@ -0,0 +1,139 @@
 package attachments
 import (
 	"encoding/base64"
 	"strings"
 	"testing"
 )
 // TestExtract_OversizedAttachmentIsCorrectlyLimited ist die geforderte
 // Pflichtprüfung 1: Nachricht mit überdimensioniertem Anhang wird
 // korrekt begrenzt.
 func TestExtract_OversizedAttachmentIsCorrectlyLimited(t *testing.T) {
 	oversized := strings.Repeat("A", 200)
 	raw := "From: a@example.com\r\n" +
 		"To: b@example.com\r\n" +
 		"Subject: Test\r\n" +
 		"MIME-Version: 1.0\r\n" +
 		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
 		"--b\r\n" +
 		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
 		"Kurzer Nachrichtentext\r\n" +
 		"--b\r\n" +
 		"Content-Type: application/octet-stream\r\n" +
 		"Content-Disposition: attachment; filename=\"riesig.bin\"\r\n\r\n" +
 		oversized + "\r\n" +
 		"--b--\r\n"
 	result, err := Extract(strings.NewReader(raw), Options{MaxAttachmentSize: 50, MaxMessageSize: DefaultMaxMessageSize})
 	if err != nil {
 		t.Fatalf("extract: %v", err)
 	}
 	if len(result.Attachments) != 0 {
 		t.Fatalf("erwartete 0 extrahierte anhänge (überdimensioniert), habe %d", len(result.Attachments))
 	}
 	if len(result.Skipped) != 1 || result.Skipped[0].Filename != "riesig.bin" {
 		t.Fatalf("erwartete genau 1 übersprungenen anhang 'riesig.bin', habe: %+v", result.Skipped)
 	}
 	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Kurzer Nachrichtentext" {
 		t.Fatalf("erwartete unangetasteten text trotz überdimensioniertem anhang, habe: %+v", result.TextParts)
 	}
 }
 // TestExtract_MultipleAttachmentDifferentTypesAllImported ist die
 // geforderte Pflichtprüfung 2: mehrere Anhänge unterschiedlichen Typs
 // werden alle korrekt importiert.
 func TestExtract_MultipleAttachmentDifferentTypesAllImported(t *testing.T) {
 	pdfContent := base64.StdEncoding.EncodeToString([]byte("%PDF-1.4 fake pdf bytes"))
 	pngContent := base64.StdEncoding.EncodeToString([]byte{0x89, 'P', 'N', 'G', 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0})
 	raw := "From: a@example.com\r\n" +
 		"To: b@example.com\r\n" +
 		"Subject: Test\r\n" +
 		"MIME-Version: 1.0\r\n" +
 		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
 		"--b\r\n" +
 		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
 		"Anbei zwei Anhänge\r\n" +
 		"--b\r\n" +
 		"Content-Type: application/pdf\r\n" +
 		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
 		"Content-Transfer-Encoding: base64\r\n\r\n" +
 		pdfContent + "\r\n" +
 		"--b\r\n" +
 		"Content-Type: image/png\r\n" +
 		"Content-Disposition: attachment; filename=\"logo.png\"\r\n" +
 		"Content-Transfer-Encoding: base64\r\n\r\n" +
 		pngContent + "\r\n" +
 		"--b--\r\n"
 	result, err := Extract(strings.NewReader(raw), Options{})
 	if err != nil {
 		t.Fatalf("extract: %v", err)
 	}
 	if len(result.Attachments) != 2 {
 		t.Fatalf("erwartete 2 extrahierte anhänge, habe %d: %+v", len(result.Attachments), result.Attachments)
 	}
 	byName := map[string]Attachment{}
 	for _, a := range result.Attachments {
 		byName[a.Filename] = a
 	}
 	pdf, ok := byName["rechnung.pdf"]
 	if !ok || pdf.DeclaredContentType != "application/pdf" {
 		t.Fatalf("pdf-anhang fehlt oder falscher deklarierter typ: %+v", byName)
 	}
 	if !strings.Contains(pdf.VerifiedContentType, "text/plain") && !strings.Contains(pdf.VerifiedContentType, "application/") {
 		// http.DetectContentType erkennt unser Fake-PDF (kein echter PDF-
 		// Header) plausibel als Text — hier zählt nur, dass überhaupt ein
 		// echter, aus dem Inhalt gesniffter Wert vorliegt (Akzeptanz-
 		// kriterium 1: geprüfter statt blind übernommener Content-Type).
 		t.Fatalf("erwartete real gesniffeden content-type, habe: %q", pdf.VerifiedContentType)
 	}
 	png, ok := byName["logo.png"]
 	if !ok || png.DeclaredContentType != "image/png" {
 		t.Fatalf("png-anhang fehlt oder falscher deklarierter typ: %+v", byName)
 	}
 	if png.VerifiedContentType != "image/png" {
 		t.Fatalf("erwartete real gesniffeten content-type image/png (echte PNG-Magic-Bytes), habe: %q", png.VerifiedContentType)
 	}
 }
 // TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched ist die
 // geforderte Pflichtprüfung 3: ein defekter Anhang lässt Text und übrige
 // Anhänge unangetastet.
 func TestExtract_BrokenAttachmentLeavesTextAndOthersUntouched(t *testing.T) {
 	goodContent := base64.StdEncoding.EncodeToString([]byte("echter anhangsinhalt"))
 	raw := "From: a@example.com\r\n" +
 		"To: b@example.com\r\n" +
 		"Subject: Test\r\n" +
 		"MIME-Version: 1.0\r\n" +
 		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
 		"--b\r\n" +
 		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
 		"Wichtiger Nachrichtentext\r\n" +
 		"--b\r\n" +
 		"Content-Type: application/octet-stream\r\n" +
 		"Content-Disposition: attachment; filename=\"kaputt.bin\"\r\n" +
 		"Content-Transfer-Encoding: base64\r\n\r\n" +
 		"DAS_IST_KEIN_GUELTIGES_BASE64!!!\r\n" +
 		"--b\r\n" +
 		"Content-Type: application/octet-stream\r\n" +
 		"Content-Disposition: attachment; filename=\"gut.bin\"\r\n" +
 		"Content-Transfer-Encoding: base64\r\n\r\n" +
 		goodContent + "\r\n" +
 		"--b--\r\n"
 	result, err := Extract(strings.NewReader(raw), Options{})
 	if err != nil {
 		t.Fatalf("extract: %v", err)
 	}
 	if len(result.TextParts) != 1 || string(result.TextParts[0].Content) != "Wichtiger Nachrichtentext" {
 		t.Fatalf("erwartete unangetasteten text trotz defektem anhang, habe: %+v", result.TextParts)
 	}
 	if len(result.Attachments) != 1 || result.Attachments[0].Filename != "gut.bin" {
 		t.Fatalf("erwartete den guten anhang unangetastet, habe: %+v", result.Attachments)
 	}
 	if string(result.Attachments[0].Content) != "echter anhangsinhalt" {
 		t.Fatalf("guter anhang hat unerwarteten inhalt: %q", result.Attachments[0].Content)
 	}
 }
@@ -0,0 +1,118 @@
 // Package crypto implementiert ARC-02: Envelope-Encryption für Objekte
 // at rest. Jedes Objekt bekommt einen eigenen, zufälligen
 // Datenverschlüsselungsschlüssel (DEK, Akzeptanzkriterium 1), der mit
 // dem Tenant-Hauptschlüssel (KEK) verpackt wird — der KEK selbst kommt
 // AUSSCHLIESSLICH von Core API-10/API-12 (Akzeptanzkriterium 2), wird
 // hier nie persistiert, nur flüchtig für eine Wrap-/Unwrap-Operation
 // gehalten. Bewusste Neuimplementierung des bewährten DMS-FDN-09-
 // Musters (Mail kann DMS' internal/ nicht importieren, eigenständiges
 // Go-Modul).
 package crypto
 import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
 	"errors"
 	"fmt"
 	"io"
 )
 const (
 	DEKSize = 32
 	KEKSize = 32
 )
 // ErrDecryptFailed wird geliefert, wenn ein Chiffretext nicht
 // entschlüsselt werden kann — falscher Schlüssel ODER manipulierte
 // Daten (Pflichtprüfung 2: GCM-Auth-Tag erkennt Manipulation
 // zuverlässig, AEAD unterscheidet die beiden Ursachen bewusst nicht).
 var ErrDecryptFailed = errors.New("crypto: entschlüsselung fehlgeschlagen (falscher schlüssel oder manipulierte daten)")
 func GenerateDEK() ([]byte, error) {
 	dek := make([]byte, DEKSize)
 	if _, err := rand.Read(dek); err != nil {
 		return nil, fmt.Errorf("crypto: dek erzeugen: %w", err)
 	}
 	return dek, nil
 }
 func seal(key, plaintext []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
 	}
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
 	}
 	nonce := make([]byte, gcm.NonceSize())
 	if _, err := rand.Read(nonce); err != nil {
 		return nil, fmt.Errorf("crypto: nonce erzeugen: %w", err)
 	}
 	return gcm.Seal(nonce, nonce, plaintext, nil), nil
 }
 func open(key, sealed []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: aes-cipher erstellen: %w", err)
 	}
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: gcm erstellen: %w", err)
 	}
 	if len(sealed) < gcm.NonceSize() {
 		return nil, ErrDecryptFailed
 	}
 	nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
 	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
 	if err != nil {
 		return nil, ErrDecryptFailed
 	}
 	return plaintext, nil
 }
 func WrapDEK(kek, dek []byte) ([]byte, error) {
 	wrapped, err := seal(kek, dek)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: dek verpacken: %w", err)
 	}
 	return wrapped, nil
 }
 func UnwrapDEK(kek, wrappedDEK []byte) ([]byte, error) {
 	return open(kek, wrappedDEK)
 }
 // EncryptStream verschlüsselt den gesamten Inhalt von r mit dek
 // (AES-256-GCM). Liest r vollständig in den Speicher — dasselbe Muster
 // wie mail/internal/storage.S3Driver.Put (ARC-01), das S3-PutObject
 // ebenfalls vollständig puffert; ein segmentiertes AEAD-Verfahren für
 // sehr große Anhänge ist bewusst nicht Teil der "kleinsten Lösung".
 func EncryptStream(dek []byte, r io.Reader) (io.Reader, error) {
 	plaintext, err := io.ReadAll(r)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: klartext lesen: %w", err)
 	}
 	ciphertext, err := seal(dek, plaintext)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: verschlüsseln: %w", err)
 	}
 	return bytes.NewReader(ciphertext), nil
 }
 // DecryptStream entschlüsselt einen zuvor mit EncryptStream erzeugten
 // Chiffretext-Stream.
 func DecryptStream(dek []byte, r io.Reader) (io.Reader, error) {
 	ciphertext, err := io.ReadAll(r)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: chiffretext lesen: %w", err)
 	}
 	plaintext, err := open(dek, ciphertext)
 	if err != nil {
 		return nil, err
 	}
 	return bytes.NewReader(plaintext), nil
 }
@@ -0,0 +1,80 @@
 package crypto
 import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/url"
 )
 // KEKProvider liefert den aktuellen, entschlüsselten Tenant-KEK
 // (Akzeptanzkriterium 2: KEK kommt ausschließlich von Core API-10/
 // API-12). Schmale Schnittstelle, damit Tests einen Fake statt eines
 // echten HTTP-Aufrufs einsetzen können.
 type KEKProvider interface {
 	TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error)
 }
 // tenantKEKResponse entspricht Core internal/kek.tenantKEKResponse
 // (JSON-Vertrag: tenant_kek_base64) — dieselbe Struktur, hier
 // gespiegelt, da Mail Cores internal/-Pakete nicht importieren kann.
 type tenantKEKResponse struct {
 	TenantKEKBase64 string `json:"tenant_kek_base64"`
 }
 // HTTPKEKProvider bezieht den Tenant-KEK über Core API-12
 // (internal/kek.Handler.TenantKEKHandler, echt laufender Dienst),
 // authentifiziert über dasselbe Service-Credential-Verfahren wie jeder
 // andere Modul-Core-Aufruf (API-02) — identisches Muster wie DMS
 // FDN-09/internal/storage.HTTPUsageReporter aus ARC-01.
 type HTTPKEKProvider struct {
 	endpointURL  string
 	clientID     string
 	clientSecret string
 	httpClient   *http.Client
 }
 func NewHTTPKEKProvider(endpointURL, clientID, clientSecret string, httpClient *http.Client) *HTTPKEKProvider {
 	if httpClient == nil {
 		httpClient = http.DefaultClient
 	}
 	return &HTTPKEKProvider{endpointURL: endpointURL, clientID: clientID, clientSecret: clientSecret, httpClient: httpClient}
 }
 func (p *HTTPKEKProvider) TenantKEK(ctx context.Context, tenantSlug string) ([]byte, error) {
 	u, err := url.Parse(p.endpointURL)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: kek-endpunkt-url ungültig: %w", err)
 	}
 	q := u.Query()
 	q.Set("tenant", tenantSlug)
 	u.RawQuery = q.Encode()
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: kek-anfrage aufbauen: %w", err)
 	}
 	req.Header.Set("X-Nexarch-Client-Id", p.clientID)
 	req.Header.Set("X-Nexarch-Client-Secret", p.clientSecret)
 	resp, err := p.httpClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: kek-anfrage senden: %w", err)
 	}
 	defer func() { _ = resp.Body.Close() }()
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("crypto: kek-bezug von core abgelehnt: status %d", resp.StatusCode)
 	}
 	var body tenantKEKResponse
 	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
 		return nil, fmt.Errorf("crypto: kek-antwort dekodieren: %w", err)
 	}
 	kek, err := base64.StdEncoding.DecodeString(body.TenantKEKBase64)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: kek base64-dekodieren: %w", err)
 	}
 	return kek, nil
 }
@@ -0,0 +1,144 @@
 // ARC-08: Tenant-KEK-Rotation. Core (API-10, `internal/kek.Store.
 // RotateTenantKEK`) ersetzt den Tenant-KEK durch einen komplett neuen
 // Wert — Core selbst hält KEINE Historie vor, `TenantKEKHandler` liefert
 // immer nur den AKTUELLEN Schlüssel (siehe kekprovider.go). Damit ARC-08s
 // Akzeptanzkriterium 3 ("alte Schlüsselversionen bleiben für
 // Lesezugriff kontrolliert verfügbar") erfüllbar ist, muss Mail selbst
 // jeden von Core bezogenen Tenant-KEK versioniert zwischenspeichern —
 // KEKVersionStore übernimmt genau das, lokal mit einem eigenen,
 // ausschließlich über Umgebungsvariable bezogenen Wrap-Schlüssel
 // verschlüsselt (kein Klartext-KEK in der Datenbank).
 package crypto
 import (
 	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // ErrKEKVersionNotFound wird geliefert, wenn die angefragte Version für
 // den Mandanten nicht existiert.
 var ErrKEKVersionNotFound = errors.New("crypto: kek-version nicht gefunden")
 // ErrKEKVersionRevoked wird geliefert, wenn die angefragte Version gezielt
 // gesperrt wurde (Pflichtprüfung 2: kompromittierter alter Schlüssel kann
 // gezielt gesperrt werden) — der Lesezugriff auf mit dieser Version
 // verschlüsselte Altobjekte ist dann bewusst blockiert.
 var ErrKEKVersionRevoked = errors.New("crypto: kek-version wurde gesperrt")
 // KEKVersionStore verwaltet die Versionshistorie der Tenant-KEKs, die
 // dieses Mail-Modul im Lauf der Zeit von Core bezogen hat.
 type KEKVersionStore struct {
 	pool         *pgxpool.Pool
 	localWrapKey []byte
 }
 // NewKEKVersionStore erzeugt einen Store. localWrapKey verschlüsselt die
 // zwischengespeicherten Tenant-KEKs lokal at rest (KEKSize Bytes,
 // ausschließlich über Umgebungsvariable bezogen — nie im Code).
 func NewKEKVersionStore(pool *pgxpool.Pool, localWrapKey []byte) *KEKVersionStore {
 	return &KEKVersionStore{pool: pool, localWrapKey: localWrapKey}
 }
 // EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
 // gleiches Muster wie mail/internal/dedup/indexworker (kein zentraler
 // Migrationsläufer für Mandanten-Datenbanken im Mail-Modul vorhanden).
 func (s *KEKVersionStore) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS mail_kek_versions (
 			tenant_slug  TEXT NOT NULL,
 			version      INT NOT NULL,
 			wrapped_kek  BYTEA NOT NULL,
 			revoked      BOOLEAN NOT NULL DEFAULT false,
 			created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
 			PRIMARY KEY (tenant_slug, version)
 		)
 	`); err != nil {
 		return fmt.Errorf("crypto: kek-versionsschema anlegen: %w", err)
 	}
 	return nil
 }
 // RecordIfNew merkt sich plainKEK als neue Version für tenantSlug, FALLS
 // er sich vom zuletzt gespeicherten Wert unterscheidet (Rotation
 // erkannt) — bei unverändertem KEK wird keine neue Version angelegt,
 // sondern die bestehende Versionsnummer zurückgegeben (Akzeptanzkriterium
 // 1: rotierbar verwaltet, nicht bei jedem Aufruf eine neue Version).
 func (s *KEKVersionStore) RecordIfNew(ctx context.Context, tenantSlug string, plainKEK []byte) (version int, err error) {
 	var latestVersion int
 	var latestWrapped []byte
 	err = s.pool.QueryRow(ctx, `
 		SELECT version, wrapped_kek FROM mail_kek_versions
 		WHERE tenant_slug = $1 ORDER BY version DESC LIMIT 1
 	`, tenantSlug).Scan(&latestVersion, &latestWrapped)
 	switch {
 	case errors.Is(err, pgx.ErrNoRows):
 		return s.insertVersion(ctx, tenantSlug, 1, plainKEK)
 	case err != nil:
 		return 0, fmt.Errorf("crypto: letzte kek-version lesen: %w", err)
 	}
 	latestPlain, err := open(s.localWrapKey, latestWrapped)
 	if err != nil {
 		return 0, fmt.Errorf("crypto: zwischengespeicherten kek entpacken: %w", err)
 	}
 	if bytes.Equal(latestPlain, plainKEK) {
 		return latestVersion, nil
 	}
 	return s.insertVersion(ctx, tenantSlug, latestVersion+1, plainKEK)
 }
 func (s *KEKVersionStore) insertVersion(ctx context.Context, tenantSlug string, version int, plainKEK []byte) (int, error) {
 	wrapped, err := seal(s.localWrapKey, plainKEK)
 	if err != nil {
 		return 0, fmt.Errorf("crypto: kek für zwischenspeicherung verpacken: %w", err)
 	}
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_kek_versions (tenant_slug, version, wrapped_kek) VALUES ($1, $2, $3)
 	`, tenantSlug, version, wrapped); err != nil {
 		return 0, fmt.Errorf("crypto: kek-version speichern: %w", err)
 	}
 	return version, nil
 }
 // Get liefert den entschlüsselten historischen Tenant-KEK einer
 // bestimmten Version. Liefert ErrKEKVersionRevoked, wenn die Version
 // gezielt gesperrt wurde (Pflichtprüfung 2).
 func (s *KEKVersionStore) Get(ctx context.Context, tenantSlug string, version int) ([]byte, error) {
 	var wrapped []byte
 	var revoked bool
 	err := s.pool.QueryRow(ctx, `
 		SELECT wrapped_kek, revoked FROM mail_kek_versions
 		WHERE tenant_slug = $1 AND version = $2
 	`, tenantSlug, version).Scan(&wrapped, &revoked)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrKEKVersionNotFound
 		}
 		return nil, fmt.Errorf("crypto: kek-version lesen: %w", err)
 	}
 	if revoked {
 		return nil, ErrKEKVersionRevoked
 	}
 	return open(s.localWrapKey, wrapped)
 }
 // Revoke sperrt eine Tenant-KEK-Version gezielt (Pflichtprüfung 2):
 // nachfolgende Get-Aufrufe für genau diese Version schlagen mit
 // ErrKEKVersionRevoked fehl, andere Versionen bleiben unberührt.
 func (s *KEKVersionStore) Revoke(ctx context.Context, tenantSlug string, version int) error {
 	tag, err := s.pool.Exec(ctx, `
 		UPDATE mail_kek_versions SET revoked = true WHERE tenant_slug = $1 AND version = $2
 	`, tenantSlug, version)
 	if err != nil {
 		return fmt.Errorf("crypto: kek-version sperren: %w", err)
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrKEKVersionNotFound
 	}
 	return nil
 }
@@ -0,0 +1,111 @@
 // Integrationstest (ARC-08): echte Postgres-Instanz, folgt derselben
 // Testhost-Konvention wie mail/internal/dedup/indexworker — TEST_TENANT_DSN.
 package crypto
 import (
 	"bytes"
 	"context"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 var testLocalWrapKey = bytes.Repeat([]byte{0x7a}, KEKSize)
 func setupKEKVersionStore(t *testing.T, tenantSlug string) *KEKVersionStore {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	store := NewKEKVersionStore(pool, testLocalWrapKey)
 	if err := store.EnsureSchema(ctx); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_kek_versions WHERE tenant_slug = $1`, tenantSlug)
 	})
 	return store
 }
 func TestKEKVersionStore_RecordIfNewDetectsRotationOnly(t *testing.T) {
 	tenant := "mandant-arc08-recordifnew"
 	store := setupKEKVersionStore(t, tenant)
 	ctx := context.Background()
 	kekV1 := bytes.Repeat([]byte{0x01}, KEKSize)
 	v1, err := store.RecordIfNew(ctx, tenant, kekV1)
 	if err != nil {
 		t.Fatalf("erste erfassung: %v", err)
 	}
 	if v1 != 1 {
 		t.Fatalf("erwartete version 1, habe %d", v1)
 	}
 	// Erneuter Aufruf mit UNVERÄNDERTEM KEK darf keine neue Version anlegen.
 	vAgain, err := store.RecordIfNew(ctx, tenant, kekV1)
 	if err != nil {
 		t.Fatalf("zweite erfassung (unverändert): %v", err)
 	}
 	if vAgain != 1 {
 		t.Fatalf("erwartete weiterhin version 1 bei unverändertem kek, habe %d", vAgain)
 	}
 	kekV2 := bytes.Repeat([]byte{0x02}, KEKSize)
 	v2, err := store.RecordIfNew(ctx, tenant, kekV2)
 	if err != nil {
 		t.Fatalf("dritte erfassung (rotiert): %v", err)
 	}
 	if v2 != 2 {
 		t.Fatalf("erwartete version 2 nach rotation, habe %d", v2)
 	}
 	gotV1, err := store.Get(ctx, tenant, 1)
 	if err != nil {
 		t.Fatalf("get v1: %v", err)
 	}
 	if !bytes.Equal(gotV1, kekV1) {
 		t.Fatal("v1 liefert nicht den ursprünglichen kek zurück")
 	}
 	gotV2, err := store.Get(ctx, tenant, 2)
 	if err != nil {
 		t.Fatalf("get v2: %v", err)
 	}
 	if !bytes.Equal(gotV2, kekV2) {
 		t.Fatal("v2 liefert nicht den rotierten kek zurück")
 	}
 }
 func TestKEKVersionStore_RevokeBlocksOnlyThatVersion(t *testing.T) {
 	tenant := "mandant-arc08-revoke"
 	store := setupKEKVersionStore(t, tenant)
 	ctx := context.Background()
 	kekV1 := bytes.Repeat([]byte{0x11}, KEKSize)
 	kekV2 := bytes.Repeat([]byte{0x22}, KEKSize)
 	if _, err := store.RecordIfNew(ctx, tenant, kekV1); err != nil {
 		t.Fatalf("v1 erfassen: %v", err)
 	}
 	if _, err := store.RecordIfNew(ctx, tenant, kekV2); err != nil {
 		t.Fatalf("v2 erfassen: %v", err)
 	}
 	if err := store.Revoke(ctx, tenant, 1); err != nil {
 		t.Fatalf("v1 sperren: %v", err)
 	}
 	if _, err := store.Get(ctx, tenant, 1); err != ErrKEKVersionRevoked {
 		t.Fatalf("erwartete ErrKEKVersionRevoked für gesperrte version 1, habe: %v", err)
 	}
 	if _, err := store.Get(ctx, tenant, 2); err != nil {
 		t.Fatalf("version 2 sollte unberührt bleiben: %v", err)
 	}
 }
@@ -0,0 +1,131 @@
 // ARC-08: End-zu-Ende-Rotationstest. Nutzt einen fake KEKProvider (echter
 // Testkonvention aus ARC-02, siehe encstorage_test.go) statt eines echten
 // HTTP-Aufrufs an Core API-12 — Core selbst hat keine rotierbare
 // Testschnittstelle über HTTP exponiert (nur der aktuelle KEK ist
 // abrufbar), die Rotation wird hier auf Höhe der KEKProvider-Schnittstelle
 // simuliert, exakt wie ARC-02 es für Fehlerfälle bereits tut.
 package crypto
 import (
 	"bytes"
 	"context"
 	"io"
 	"strings"
 	"sync"
 	"testing"
 )
 // rotatableKEKProvider liefert für einen Mandanten einen aktuell
 // gesetzten KEK, der zur Laufzeit "rotiert" werden kann (simuliert Core
 // API-10s RotateTenantKEK, dessen Effekt auf API-12 exakt darin besteht,
 // dass TenantKEK ab dann einen anderen Wert liefert).
 type rotatableKEKProvider struct {
 	mu      sync.Mutex
 	current []byte
 }
 func (p *rotatableKEKProvider) TenantKEK(_ context.Context, _ string) ([]byte, error) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 	return p.current, nil
 }
 func (p *rotatableKEKProvider) rotate(newKEK []byte) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 	p.current = newKEK
 }
 // TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation ist die
 // geforderte Pflichtprüfung 1: Rotation des Hauptschlüssels lässt
 // Altbestand weiterhin lesbar.
 func TestRotation_OldArchiveStaysReadableAfterMasterKeyRotation(t *testing.T) {
 	tenant := "mandant-arc08-rotation-lesbar"
 	store := setupKEKVersionStore(t, tenant)
 	ctx := context.Background()
 	provider := &rotatableKEKProvider{current: bytes.Repeat([]byte{0x51}, KEKSize)}
 	svc := NewService(provider).WithVersionStore(store)
 	// Objekt VOR der Rotation versiegeln.
 	oldEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("altbestand vor rotation"))
 	if err != nil {
 		t.Fatalf("seal (alt): %v", err)
 	}
 	if oldEnvelope.KEKVersion != 1 {
 		t.Fatalf("erwartete kek-version 1 vor rotation, habe %d", oldEnvelope.KEKVersion)
 	}
 	oldCiphertext, err := io.ReadAll(oldEnvelope.Ciphertext)
 	if err != nil {
 		t.Fatalf("chiffretext (alt) lesen: %v", err)
 	}
 	// Core rotiert den Tenant-Hauptschlüssel — TenantKEK liefert ab jetzt
 	// einen komplett anderen Wert, exakt wie internal/kek.Store.
 	// RotateTenantKEK es real bei Core bewirkt.
 	provider.rotate(bytes.Repeat([]byte{0x52}, KEKSize))
 	// Objekt NACH der Rotation versiegeln (Akzeptanzkriterium 2: kein
 	// Neuverschlüsseln des Altbestands nötig, nur neue Objekte nutzen den
 	// neuen Schlüssel).
 	newEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("neuer inhalt nach rotation"))
 	if err != nil {
 		t.Fatalf("seal (neu): %v", err)
 	}
 	if newEnvelope.KEKVersion != 2 {
 		t.Fatalf("erwartete kek-version 2 nach rotation, habe %d", newEnvelope.KEKVersion)
 	}
 	// Altbestand bleibt über die aufgezeichnete Version lesbar
 	// (Akzeptanzkriterium 3).
 	openedOld, err := svc.OpenAtVersion(ctx, tenant, oldEnvelope.KEKVersion, oldEnvelope.WrappedDEK, bytes.NewReader(oldCiphertext))
 	if err != nil {
 		t.Fatalf("openatversion (alt, nach rotation): %v", err)
 	}
 	plainOld, err := io.ReadAll(openedOld)
 	if err != nil {
 		t.Fatalf("altbestand lesen: %v", err)
 	}
 	if string(plainOld) != "altbestand vor rotation" {
 		t.Fatalf("altbestand-inhalt stimmt nicht, habe %q", string(plainOld))
 	}
 	// Der naive Open() (aktueller KEK) darf für das ALTE Objekt inzwischen
 	// NICHT mehr funktionieren — das beweist, dass OpenAtVersion die
 	// Rotation tatsächlich überbrückt, statt zufällig auch so zu klappen.
 	if _, err := svc.Open(ctx, tenant, oldEnvelope.WrappedDEK, bytes.NewReader(oldCiphertext)); err == nil {
 		t.Fatal("erwartete fehler bei Open() des altbestands mit dem NEUEN aktuellen kek, habe nil")
 	}
 }
 // TestRotation_CompromisedOldKeyCanBeRevoked ist die geforderte
 // Pflichtprüfung 2: kompromittierter alter Schlüssel kann gezielt
 // gesperrt werden.
 func TestRotation_CompromisedOldKeyCanBeRevoked(t *testing.T) {
 	tenant := "mandant-arc08-revoke-e2e"
 	store := setupKEKVersionStore(t, tenant)
 	ctx := context.Background()
 	provider := &rotatableKEKProvider{current: bytes.Repeat([]byte{0x61}, KEKSize)}
 	svc := NewService(provider).WithVersionStore(store)
 	compromisedEnvelope, err := svc.Seal(ctx, tenant, strings.NewReader("mit kompromittiertem schlüssel versiegelt"))
 	if err != nil {
 		t.Fatalf("seal: %v", err)
 	}
 	compromisedCiphertext, err := io.ReadAll(compromisedEnvelope.Ciphertext)
 	if err != nil {
 		t.Fatalf("chiffretext lesen: %v", err)
 	}
 	provider.rotate(bytes.Repeat([]byte{0x62}, KEKSize))
 	if err := store.Revoke(ctx, tenant, compromisedEnvelope.KEKVersion); err != nil {
 		t.Fatalf("kompromittierte version sperren: %v", err)
 	}
 	_, err = svc.OpenAtVersion(ctx, tenant, compromisedEnvelope.KEKVersion, compromisedEnvelope.WrappedDEK, bytes.NewReader(compromisedCiphertext))
 	if err == nil {
 		t.Fatal("erwartete fehler beim lesen mit gesperrter kek-version, habe nil")
 	}
 }
@@ -0,0 +1,114 @@
 package crypto
 import (
 	"context"
 	"fmt"
 	"io"
 )
 // Envelope ist das Ergebnis einer Seal-Operation: der Chiffretext-
 // Stream plus der mit dem Tenant-KEK verpackte DEK, der zusammen mit
 // dem Objekt persistiert werden muss (siehe mail/internal/encstorage).
 // KEKVersion identifiziert (ARC-08), MIT welcher Tenant-KEK-Version der
 // DEK verpackt wurde — 0, solange kein KEKVersionStore konfiguriert ist
 // (Rückwärtskompatibilität, siehe WithVersionStore).
 type Envelope struct {
 	Ciphertext io.Reader
 	WrappedDEK []byte
 	KEKVersion int
 }
 // Service verbindet KEKProvider mit den Envelope-Operationen — Aufrufer
 // (mail/internal/encstorage) rufen ausschließlich Service auf, nie die
 // Einzelfunktionen aus envelope.go direkt.
 type Service struct {
 	kek      KEKProvider
 	versions *KEKVersionStore
 }
 func NewService(kek KEKProvider) *Service {
 	return &Service{kek: kek}
 }
 // WithVersionStore aktiviert die Tenant-KEK-Versionsverfolgung (ARC-08).
 // Ohne aufgerufenes WithVersionStore verhält sich Service exakt wie vor
 // ARC-08 (KEKVersion bleibt 0, OpenAtVersion fällt auf Open zurück) —
 // bestehende Aufrufer (z. B. encstorage) sind unverändert lauffähig.
 func (s *Service) WithVersionStore(store *KEKVersionStore) *Service {
 	s.versions = store
 	return s
 }
 // Seal erzeugt einen neuen DEK (Akzeptanzkriterium 1), verschlüsselt
 // plaintext damit und verpackt den DEK mit dem aktuellen Tenant-KEK
 // (Akzeptanzkriterium 2 — der KEK wird bei JEDEM Aufruf frisch von Core
 // bezogen, nie zwischengespeichert außer in der optionalen
 // KEK-Versionshistorie für spätere Altbestands-Lesezugriffe).
 func (s *Service) Seal(ctx context.Context, tenantSlug string, plaintext io.Reader) (*Envelope, error) {
 	dek, err := GenerateDEK()
 	if err != nil {
 		return nil, err
 	}
 	ciphertext, err := EncryptStream(dek, plaintext)
 	if err != nil {
 		return nil, err
 	}
 	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
 	}
 	wrappedDEK, err := WrapDEK(kek, dek)
 	if err != nil {
 		return nil, err
 	}
 	var kekVersion int
 	if s.versions != nil {
 		kekVersion, err = s.versions.RecordIfNew(ctx, tenantSlug, kek)
 		if err != nil {
 			return nil, fmt.Errorf("crypto: kek-version erfassen: %w", err)
 		}
 	}
 	return &Envelope{Ciphertext: ciphertext, WrappedDEK: wrappedDEK, KEKVersion: kekVersion}, nil
 }
 // Open entpackt den DEK mit dem AKTUELLEN Tenant-KEK (Akzeptanzkriterium
 // 3: nur mit gültigem, mandantenbezogenem Schlüssel möglich — ein
 // falscher Tenant-Slug liefert entweder einen falschen KEK von Core
 // [dann schlägt UnwrapDEK fehl] oder Core verweigert den Zugriff direkt)
 // und entschlüsselt ciphertext damit. Nach einer Tenant-KEK-Rotation bei
 // Core funktioniert Open nur noch für Objekte, die mit dem NEUEN KEK
 // versiegelt wurden — für Altbestand siehe OpenAtVersion.
 func (s *Service) Open(ctx context.Context, tenantSlug string, wrappedDEK []byte, ciphertext io.Reader) (io.Reader, error) {
 	kek, err := s.kek.TenantKEK(ctx, tenantSlug)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: tenant-kek beziehen: %w", err)
 	}
 	dek, err := UnwrapDEK(kek, wrappedDEK)
 	if err != nil {
 		return nil, err
 	}
 	return DecryptStream(dek, ciphertext)
 }
 // OpenAtVersion entpackt den DEK mit der beim Seal aufgezeichneten
 // historischen Tenant-KEK-Version statt mit dem aktuellen Core-KEK
 // (ARC-08 Akzeptanzkriterium 3: Altbestand bleibt nach einer
 // Hauptschlüssel-Rotation lesbar). Ist kekVersion 0 oder kein
 // KEKVersionStore konfiguriert, verhält es sich wie Open (Rückwärts-
 // kompatibilität für vor ARC-08 versiegelte Objekte).
 func (s *Service) OpenAtVersion(ctx context.Context, tenantSlug string, kekVersion int, wrappedDEK []byte, ciphertext io.Reader) (io.Reader, error) {
 	if kekVersion == 0 || s.versions == nil {
 		return s.Open(ctx, tenantSlug, wrappedDEK, ciphertext)
 	}
 	kek, err := s.versions.Get(ctx, tenantSlug, kekVersion)
 	if err != nil {
 		return nil, fmt.Errorf("crypto: historischen tenant-kek beziehen: %w", err)
 	}
 	dek, err := UnwrapDEK(kek, wrappedDEK)
 	if err != nil {
 		return nil, err
 	}
 	return DecryptStream(dek, ciphertext)
 }
@@ -0,0 +1,35 @@
 // Package dedup implementiert ARC-03: Dublettenerkennung für
 // archivierte E-Mails über einen Inhalts-Hash. Kombiniert bewusst NICHT
 // mit mail/internal/storage oder mail/internal/crypto — dieses Paket
 // kennt beide nicht, der Aufrufer (spätere Ingest-Tickets) ruft es VOR
 // mail/internal/crypto auf.
 package dedup
 import (
 	"bytes"
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
 	"io"
 )
 // HashAndBuffer berechnet den SHA-256-Inhalts-Hash von plaintext.
 //
 // Bekannter Fehler vermeiden (siehe ARC-03-Ticket): der Hash MUSS auf
 // dem Klartext berechnet werden, BEVOR mail/internal/crypto verschlüsselt
 // — ein Hash auf dem Chiffretext wäre bei jedem Import anders (neuer
 // DEK je Objekt, siehe ARC-02) und Dublettenerkennung würde vollständig
 // versagen. Reihenfolge: Mail/Anhang empfangen -> HashAndBuffer (dieses
 // Paket) -> verschlüsseln (ARC-02) -> ablegen.
 //
 // plaintext wird beim Hashen vollständig verbraucht — HashAndBuffer
 // liefert deshalb einen erneut lesbaren Reader mit demselben Inhalt für
 // den nachfolgenden Verschlüsselungsschritt zurück.
 func HashAndBuffer(plaintext io.Reader) (contentHash string, buffered io.Reader, err error) {
 	var buf bytes.Buffer
 	hasher := sha256.New()
 	if _, err := io.Copy(hasher, io.TeeReader(plaintext, &buf)); err != nil {
 		return "", nil, fmt.Errorf("dedup: klartext hashen: %w", err)
 	}
 	return hex.EncodeToString(hasher.Sum(nil)), &buf, nil
 }
@@ -0,0 +1,58 @@
 package dedup
 import (
 	"io"
 	"strings"
 	"testing"
 )
 func TestHashAndBuffer_SameContentSameHash(t *testing.T) {
 	h1, buf1, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	h2, buf2, err := HashAndBuffer(strings.NewReader("identischer inhalt"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if h1 != h2 {
 		t.Fatalf("erwartet identischen hash für identischen inhalt, habe %q vs %q", h1, h2)
 	}
 	got1, _ := io.ReadAll(buf1)
 	got2, _ := io.ReadAll(buf2)
 	if string(got1) != "identischer inhalt" || string(got2) != "identischer inhalt" {
 		t.Fatal("buffered reader liefert nicht denselben inhalt zurück wie der ursprüngliche klartext")
 	}
 }
 func TestHashAndBuffer_DifferentContentDifferentHash(t *testing.T) {
 	h1, _, err := HashAndBuffer(strings.NewReader("nachricht a"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	h2, _, err := HashAndBuffer(strings.NewReader("nachricht b"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if h1 == h2 {
 		t.Fatal("unterschiedlicher inhalt hätte unterschiedlichen hash liefern müssen")
 	}
 }
 // TestHashAndBuffer_SlightlyDifferentContentDifferentHash ist die
 // geforderte Pflichtprüfung 3: knapp unterschiedliche Nachrichten
 // werden korrekt NICHT als Duplikat erkannt.
 func TestHashAndBuffer_SlightlyDifferentContentDifferentHash(t *testing.T) {
 	h1, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht."))
 	if err != nil {
 		t.Fatal(err)
 	}
 	h2, _, err := HashAndBuffer(strings.NewReader("Betreff: Test\r\n\r\nInhalt der Nachricht,"))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if h1 == h2 {
 		t.Fatal("ein einziges abweichendes zeichen hätte den hash ändern müssen")
 	}
 }
@@ -0,0 +1,75 @@
 package dedup
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Store verwaltet bekannte Inhalts-Hashes je Mandant. tenant_slug ist
 // fester Bestandteil des Primärschlüssels (Akzeptanzkriterium 3:
 // mandantenübergreifend korrekt getrennt) — auch wenn Store einen mit
 // anderen Mandanten geteilten Pool erhält, kann ein Hash-Treffer nie
 // über Mandantengrenzen hinweg entstehen.
 type Store struct {
 	pool       *pgxpool.Pool
 	tenantSlug string
 }
 func NewStore(pool *pgxpool.Pool, tenantSlug string) *Store {
 	return &Store{pool: pool, tenantSlug: tenantSlug}
 }
 // EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
 // gleiches Muster wie mail/internal/example (kein zentraler
 // Migrationsläufer für Mandanten-Datenbanken im Mail-Modul vorhanden).
 func (s *Store) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS mail_content_hashes (
 			tenant_slug  TEXT NOT NULL,
 			content_hash TEXT NOT NULL,
 			object_key   TEXT NOT NULL,
 			created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
 			PRIMARY KEY (tenant_slug, content_hash)
 		)
 	`); err != nil {
 		return fmt.Errorf("dedup: schema anlegen: %w", err)
 	}
 	return nil
 }
 // Register trägt contentHash für den Mandanten als neu bekannt ein
 // (Akzeptanzkriterium 1) und referenziert das Original, statt es
 // redundant zu speichern (Akzeptanzkriterium 2): existiert derselbe
 // Hash für DIESEN Mandanten bereits mit einem ANDEREN object_key,
 // liefert Register isDuplicate=true und den object_key des Originals —
 // der Aufrufer legt den neuen Inhalt dann NICHT ab.
 func (s *Store) Register(ctx context.Context, contentHash, objectKey string) (isDuplicate bool, existingKey string, err error) {
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_content_hashes (tenant_slug, content_hash, object_key)
 		VALUES ($1, $2, $3)
 		ON CONFLICT (tenant_slug, content_hash) DO NOTHING
 	`, s.tenantSlug, contentHash, objectKey); err != nil {
 		return false, "", fmt.Errorf("dedup: hash eintragen: %w", err)
 	}
 	var storedKey string
 	err = s.pool.QueryRow(ctx, `
 		SELECT object_key FROM mail_content_hashes
 		WHERE tenant_slug = $1 AND content_hash = $2
 	`, s.tenantSlug, contentHash).Scan(&storedKey)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return false, "", fmt.Errorf("dedup: gerade eingetragenen hash nicht wiedergefunden")
 		}
 		return false, "", fmt.Errorf("dedup: eintrag lesen: %w", err)
 	}
 	if storedKey != objectKey {
 		return true, storedKey, nil
 	}
 	return false, "", nil
 }
@@ -0,0 +1,94 @@
 // Integrationstest (ARC-03): echte Postgres-Instanz, folgt derselben
 // Testhost-Konvention wie mail/internal/example (QA-01) — TEST_TENANT_DSN.
 package dedup
 import (
 	"context"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupStore(t *testing.T, tenantSlug string) *Store {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	store := NewStore(pool, tenantSlug)
 	if err := store.EnsureSchema(ctx); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_content_hashes WHERE tenant_slug = $1`, tenantSlug)
 	})
 	return store
 }
 // TestRegister_SameMessageFromTwoSourcesIsDuplicate ist die geforderte
 // Pflichtprüfung 1: dieselbe Nachricht aus zwei Quellen wird als
 // Duplikat erkannt.
 func TestRegister_SameMessageFromTwoSourcesIsDuplicate(t *testing.T) {
 	store := setupStore(t, "mandant-arc03-a")
 	ctx := context.Background()
 	hash := "fixierter-inhalts-hash-fuer-test-1"
 	isDup, _, err := store.Register(ctx, hash, "quelle-1/objekt")
 	if err != nil {
 		t.Fatalf("erste registrierung: %v", err)
 	}
 	if isDup {
 		t.Fatal("erste registrierung eines hashes darf kein duplikat sein")
 	}
 	isDup, existing, err := store.Register(ctx, hash, "quelle-2/objekt")
 	if err != nil {
 		t.Fatalf("zweite registrierung: %v", err)
 	}
 	if !isDup {
 		t.Fatal("erwartet: dieselbe nachricht aus zweiter quelle wird als duplikat erkannt")
 	}
 	if existing != "quelle-1/objekt" {
 		t.Fatalf("erwartet referenz auf das original quelle-1/objekt, habe %q", existing)
 	}
 }
 // TestRegister_SameContentTwoTenantsNotLinked ist die geforderte
 // Pflichtprüfung 2: zwei Mandanten mit identischem Mailinhalt werden
 // nicht fälschlich verknüpft.
 func TestRegister_SameContentTwoTenantsNotLinked(t *testing.T) {
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	storeA := setupStore(t, "mandant-arc03-x")
 	storeB := setupStore(t, "mandant-arc03-y")
 	ctx := context.Background()
 	hash := "identischer-inhalt-ueber-zwei-mandanten-hinweg"
 	isDupA, _, err := storeA.Register(ctx, hash, "mandant-x/objekt")
 	if err != nil {
 		t.Fatalf("mandant a: %v", err)
 	}
 	if isDupA {
 		t.Fatal("erste registrierung bei mandant a darf kein duplikat sein")
 	}
 	isDupB, existingB, err := storeB.Register(ctx, hash, "mandant-y/objekt")
 	if err != nil {
 		t.Fatalf("mandant b: %v", err)
 	}
 	if isDupB {
 		t.Fatalf("mandant b wurde fälschlich mit mandant a verknüpft, existing=%q", existingB)
 	}
 }
@@ -0,0 +1,138 @@
 // Package encstorage implementiert ARC-02s Anbindung an ARC-01: jedes
 // archivierte Objekt wird VOR dem Schreiben über
 // mail/internal/storage.Service verschlüsselt (Akzeptanzkriterium 1).
 // Kombiniert bewusst zwei bereits fertige, unveränderte Pakete
 // (mail/internal/storage aus ARC-01, mail/internal/crypto aus ARC-02)
 // statt eines davon zu erweitern — kein Umbau angrenzender Bereiche.
 //
 // Reihenfolge beachtet (Ticket "Bekannte Fehler vermeiden"): ein
 // SHA-256-Hash für Dublettenerkennung (ARC-03) muss auf dem KLARTEXT
 // berechnet werden, BEVOR diese Verschlüsselung angewendet wird — das
 // ist Sache des Aufrufers (ARC-03, außerhalb dieses Pakets), dieses
 // Paket nimmt bereits fertigen Klartext entgegen und verschlüsselt ihn
 // sofort, hält ihn nicht länger als nötig im Speicher.
 package encstorage
 import (
 	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"io"
 	"strconv"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
 )
 // wrappedDEKKey ist der Sidecar-Objektschlüssel für den mit dem
 // Tenant-KEK verpackten DEK — liegt im selben Storage-Backend wie der
 // Chiffretext, analog zum Prüfsummen-Sidecar aus ARC-01.
 func wrappedDEKKey(key string) string {
 	return key + ".dek"
 }
 // kekVersionKey ist der Sidecar-Objektschlüssel für die Tenant-KEK-
 // Version, mit der der DEK verpackt wurde (ARC-08 Akzeptanzkriterium 3).
 // Fehlt dieser Sidecar (vor ARC-08 geschriebene Objekte), wird Version 0
 // angenommen — GetDecrypted verhält sich dann wie vor ARC-08.
 func kekVersionKey(key string) string {
 	return key + ".dek.version"
 }
 // Service verbindet Storage (ARC-01) und Crypto (ARC-02): der Rest von
 // Mail ruft AUSSCHLIESSLICH diesen Service auf, nie storage.Service
 // direkt mit Klartext — das verhindert einen Schreibpfad, der die
 // Verschlüsselung vergisst (Akzeptanzkriterium 1).
 type Service struct {
 	storage *storage.Service
 	crypto  *crypto.Service
 }
 func NewService(storageSvc *storage.Service, cryptoSvc *crypto.Service) *Service {
 	return &Service{storage: storageSvc, crypto: cryptoSvc}
 }
 // Put verschlüsselt plaintext (Akzeptanzkriterium 1/2: neuer DEK je
 // Objekt, mit dem per API-12 bezogenen Tenant-KEK verpackt) und legt
 // Chiffretext + verpackten DEK über storage.Service ab (Prüfsumme,
 // Nutzungsmeldung — ARC-01 unverändert wiederverwendet).
 func (s *Service) Put(ctx context.Context, tenantSlug, key string, plaintext io.Reader, contentType string) error {
 	env, err := s.crypto.Seal(ctx, tenantSlug, plaintext)
 	if err != nil {
 		return fmt.Errorf("encstorage: verschlüsseln: %w", err)
 	}
 	ciphertext, err := io.ReadAll(env.Ciphertext)
 	if err != nil {
 		return fmt.Errorf("encstorage: chiffretext lesen: %w", err)
 	}
 	if _, err := s.storage.Put(ctx, key, bytes.NewReader(ciphertext), int64(len(ciphertext)), contentType); err != nil {
 		return fmt.Errorf("encstorage: chiffretext speichern: %w", err)
 	}
 	if _, err := s.storage.Put(ctx, wrappedDEKKey(key), bytes.NewReader(env.WrappedDEK), int64(len(env.WrappedDEK)), "application/octet-stream"); err != nil {
 		return fmt.Errorf("encstorage: verpackten dek speichern: %w", err)
 	}
 	if env.KEKVersion != 0 {
 		versionBytes := []byte(strconv.Itoa(env.KEKVersion))
 		if _, err := s.storage.Put(ctx, kekVersionKey(key), bytes.NewReader(versionBytes), int64(len(versionBytes)), "text/plain"); err != nil {
 			return fmt.Errorf("encstorage: kek-version speichern: %w", err)
 		}
 	}
 	return nil
 }
 // GetDecrypted liest Chiffretext (über storage.GetVerified — ARC-01s
 // Prüfsummenverifikation wird dabei mitgenutzt) und verpackten DEK,
 // entpackt den DEK mit dem AKTUELLEN Tenant-KEK und entschlüsselt den
 // Inhalt (Akzeptanzkriterium 3: nur mit gültigem, mandantenbezogenem
 // Schlüssel möglich).
 func (s *Service) GetDecrypted(ctx context.Context, tenantSlug, key string) ([]byte, error) {
 	ciphertext, err := s.storage.GetVerified(ctx, key)
 	if err != nil {
 		return nil, fmt.Errorf("encstorage: chiffretext lesen: %w", err)
 	}
 	dekReader, err := s.storage.Get(ctx, wrappedDEKKey(key))
 	if err != nil {
 		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
 	}
 	defer func() { _ = dekReader.Close() }()
 	wrappedDEK, err := io.ReadAll(dekReader)
 	if err != nil {
 		return nil, fmt.Errorf("encstorage: verpackten dek lesen: %w", err)
 	}
 	kekVersion, err := s.readKEKVersion(ctx, key)
 	if err != nil {
 		return nil, err
 	}
 	plaintextReader, err := s.crypto.OpenAtVersion(ctx, tenantSlug, kekVersion, wrappedDEK, bytes.NewReader(ciphertext))
 	if err != nil {
 		return nil, err
 	}
 	return io.ReadAll(plaintextReader)
 }
 // readKEKVersion liest den Versions-Sidecar (ARC-08). Fehlt er (vor
 // ARC-08 geschriebene Objekte, oder ein Seal ohne konfigurierten
 // KEKVersionStore), gilt Version 0 — crypto.Service.OpenAtVersion fällt
 // dafür auf das unveränderte Open-Verhalten zurück.
 func (s *Service) readKEKVersion(ctx context.Context, key string) (int, error) {
 	reader, err := s.storage.Get(ctx, kekVersionKey(key))
 	if err != nil {
 		if errors.Is(err, storage.ErrNotFound) {
 			return 0, nil
 		}
 		return 0, fmt.Errorf("encstorage: kek-version lesen: %w", err)
 	}
 	defer func() { _ = reader.Close() }()
 	raw, err := io.ReadAll(reader)
 	if err != nil {
 		return 0, fmt.Errorf("encstorage: kek-version lesen: %w", err)
 	}
 	version, err := strconv.Atoi(string(raw))
 	if err != nil {
 		return 0, fmt.Errorf("encstorage: kek-version parsen: %w", err)
 	}
 	return version, nil
 }
@@ -0,0 +1,138 @@
 package encstorage
 import (
 	"bytes"
 	"context"
 	"errors"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/crypto"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/storage"
 )
 type fakeUsageReporter struct{}
 func (fakeUsageReporter) Report(_ context.Context, _, _ string, _ int64) error { return nil }
 // fakeKEKProvider liefert einen festen, mandantenspezifischen KEK —
 // simuliert Core API-12, ohne den echten Dienst für Unit-Tests zu
 // brauchen. "richtiger-tenant" hat einen bekannten KEK, jeder andere
 // Tenant-Slug liefert einen ANDEREN (falschen) KEK — genau der Fall,
 // den Pflichtprüfung 2 testet.
 type fakeKEKProvider struct {
 	keksByTenant map[string][]byte
 }
 func (f fakeKEKProvider) TenantKEK(_ context.Context, tenantSlug string) ([]byte, error) {
 	if kek, ok := f.keksByTenant[tenantSlug]; ok {
 		return kek, nil
 	}
 	// Unbekannter Tenant bekommt einen ANDEREN zufälligen KEK (nicht
 	// abgelehnt auf Core-Seite in diesem Fake, aber garantiert falsch —
 	// entspricht dem realen Fall, dass ein falscher Tenant-Slug einen
 	// anderen KEK liefert und die Entschlüsselung deshalb scheitert).
 	return bytes.Repeat([]byte{0xFF}, crypto.KEKSize), nil
 }
 func newTestServiceWithDir(t *testing.T) (*Service, string) {
 	t.Helper()
 	dir := t.TempDir()
 	storageSvc := storage.NewService(storage.NewLocalDriver(dir), fakeUsageReporter{}, "acme")
 	kekProvider := fakeKEKProvider{keksByTenant: map[string][]byte{
 		"richtiger-tenant": bytes.Repeat([]byte{0x42}, crypto.KEKSize),
 	}}
 	cryptoSvc := crypto.NewService(kekProvider)
 	return NewService(storageSvc, cryptoSvc), dir
 }
 // TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent ist die
 // geforderte Pflichtprüfung 1: Zugriff auf Rohspeicher ohne Schlüssel
 // liefert keine lesbaren Inhalte.
 func TestPut_RawStorageAccessWithoutKeyYieldsNoReadableContent(t *testing.T) {
 	svc, dir := newTestServiceWithDir(t)
 	ctx := context.Background()
 	key := storage.ObjectKey("msg-enc-1", 0)
 	plaintext := "STRENG GEHEIMER E-MAIL-INHALT, NICHT IM KLARTEXT AUF DER PLATTE"
 	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
 		t.Fatalf("put: %v", err)
 	}
 	// Direkter Dateisystemzugriff, UMGEHT den Service/die Entschlüsselung
 	// vollständig — simuliert "Rohspeicher ohne Schlüssel".
 	raw, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(key)))
 	if err != nil {
 		t.Fatalf("rohdatei lesen: %v", err)
 	}
 	if bytes.Contains(raw, []byte(plaintext)) {
 		t.Fatalf("klartext ist unverschlüsselt im rohspeicher auffindbar: %q enthält %q", raw, plaintext)
 	}
 	if bytes.Contains(raw, []byte("STRENG GEHEIMER")) || bytes.Contains(raw, []byte("GEHEIM")) {
 		t.Fatal("erkennbare klartext-fragmente im rohspeicher gefunden")
 	}
 }
 // TestGetDecrypted_WrongTenantKeyDeniesDecryption ist die geforderte
 // Pflichtprüfung 2: falscher Mandantenschlüssel verweigert
 // Entschlüsselung.
 func TestGetDecrypted_WrongTenantKeyDeniesDecryption(t *testing.T) {
 	svc, _ := newTestServiceWithDir(t)
 	ctx := context.Background()
 	key := storage.ObjectKey("msg-enc-2", 0)
 	plaintext := "inhalt fuer richtiger-tenant"
 	if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(plaintext), "text/plain"); err != nil {
 		t.Fatalf("put: %v", err)
 	}
 	// Korrekter Tenant kann entschlüsseln.
 	got, err := svc.GetDecrypted(ctx, "richtiger-tenant", key)
 	if err != nil {
 		t.Fatalf("getdecrypted (richtiger tenant): %v", err)
 	}
 	if string(got) != plaintext {
 		t.Fatalf("falscher inhalt: %q", got)
 	}
 	// FALSCHER Mandant (anderer Tenant-Slug -> anderer KEK) muss
 	// abgelehnt werden.
 	_, err = svc.GetDecrypted(ctx, "falscher-tenant", key)
 	if !errors.Is(err, crypto.ErrDecryptFailed) {
 		t.Fatalf("erwartet ErrDecryptFailed bei falschem mandantenschlüssel, habe: %v", err)
 	}
 }
 // TestPut_AcceptableEncryptionOverhead ist die geforderte
 // Pflichtprüfung 3: Performance-Test bestätigt akzeptablen Overhead
 // durch Verschlüsselung.
 func TestPut_AcceptableEncryptionOverhead(t *testing.T) {
 	svc, _ := newTestServiceWithDir(t)
 	ctx := context.Background()
 	// ~64 KiB Nutzlast, realistische Anhanggröße.
 	payload := strings.Repeat("x", 64*1024)
 	const count = 50
 	start := time.Now()
 	for i := 0; i < count; i++ {
 		key := storage.ObjectKey("msg-perf", i)
 		if err := svc.Put(ctx, "richtiger-tenant", key, strings.NewReader(payload), "application/octet-stream"); err != nil {
 			t.Fatalf("put #%d: %v", i, err)
 		}
 	}
 	elapsed := time.Since(start)
 	avgPerObject := elapsed / count
 	// Großzügige Grenze (50ms je 64-KiB-Objekt inkl. AES-GCM,
 	// Prüfsumme, Sidecar-Schreiben, Rücklese-Verifikation aus ARC-01) —
 	// Ziel: Nachweis, dass Verschlüsselung keinen unverhältnismäßigen
 	// Overhead verursacht, nicht ein knallhartes SLA.
 	if avgPerObject > 50*time.Millisecond {
 		t.Fatalf("erwartet akzeptablen verschlüsselungs-overhead (<50ms/64KiB-objekt), habe %v/objekt (gesamt %v für %d objekte)", avgPerObject, elapsed, count)
 	}
 	t.Logf("Verschlüsselungs-Performance: %d×64KiB-Objekte in %v (%v/Objekt)", count, elapsed, avgPerObject)
 }
@@ -0,0 +1,9 @@
 CREATE TABLE IF NOT EXISTS mail_folder_state (
    tenant_slug  TEXT NOT NULL,
    mailbox_name TEXT NOT NULL,
    uidvalidity  BIGINT NOT NULL,
    uidnext      BIGINT NOT NULL,
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (tenant_slug, mailbox_name)
 )
@@ -0,0 +1,8 @@
 CREATE TABLE IF NOT EXISTS mail_folder_state_events (
    id           BIGSERIAL PRIMARY KEY,
    tenant_slug  TEXT NOT NULL,
    mailbox_name TEXT NOT NULL,
    event_type   TEXT NOT NULL CHECK (event_type IN ('uid_assigned', 'deleted', 'rebuilt')),
    uid          BIGINT,
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 )
@@ -0,0 +1,251 @@
 // Package folderstate implementiert ING-05: Folder-State-Verwaltung
 // inklusive UIDVALIDITY/UIDNEXT-Handling für IMAP-Ordner (RFC 3501
 // §2.3.1.1), damit Clients (mail/internal/imap, ING-01) und
 // Importvorgänge (IMP-01) konsistente Sichten erhalten. Persistiert in
 // Postgres, gleiches Muster wie mail/internal/dedup/indexworker/
 // savedsearch — kein zentraler Migrationsläufer für Mandanten-
 // Datenbanken im Mail-Modul vorhanden, EnsureSchema legt die Tabellen
 // idempotent an.
 //
 // Bekannten Fehler vermeiden (siehe ING-01/repos-analyse-mail-reuse.md):
 // archivmail brach den Resync bei UIDVALIDITY=0 nicht-konformer Server —
 // dieses Paket erzeugt UIDVALIDITY selbst (Unix-Zeitstempel beim
 // Ordner-Neuaufbau, garantiert > 0 und monoton wachsend über
 // aufeinanderfolgende Neuaufbauten hinweg) statt einen von außen
 // gelieferten Wert unbesehen zu übernehmen.
 package folderstate
 import (
 	"context"
 	_ "embed"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 //go:embed migrations/0001_mail_folder_state.sql
 var schemaMigration string
 //go:embed migrations/0002_mail_folder_state_events.sql
 var eventsSchemaMigration string
 // EventType (Akzeptanzkriterium 3: State-Änderungen nachvollziehbar
 // persistiert).
 const (
 	EventUIDAssigned = "uid_assigned"
 	EventDeleted     = "deleted"
 	EventRebuilt     = "rebuilt"
 )
 // FolderState ist der aktuelle UIDVALIDITY/UIDNEXT-Zustand eines Ordners.
 type FolderState struct {
 	TenantSlug  string
 	MailboxName string
 	UIDValidity uint64
 	UIDNext     uint64
 }
 // Event ist ein einzelner, nachvollziehbarer Zustandsänderungseintrag.
 type Event struct {
 	EventType string
 	UID       *uint64
 	CreatedAt time.Time
 }
 // Store verwaltet Folder-State je Mandant und Postfach.
 type Store struct {
 	pool *pgxpool.Pool
 	// now ist austauschbar für Tests (deterministische UIDVALIDITY-Werte).
 	now func() time.Time
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool, now: time.Now}
 }
 // EnsureSchema legt die Tabellen an, falls sie noch nicht existieren.
 func (s *Store) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
 		return fmt.Errorf("folderstate: schema anlegen: %w", err)
 	}
 	if _, err := s.pool.Exec(ctx, eventsSchemaMigration); err != nil {
 		return fmt.Errorf("folderstate: ereignis-schema anlegen: %w", err)
 	}
 	return nil
 }
 // GetOrCreate liefert den aktuellen Zustand eines Ordners und legt ihn
 // bei erstem Zugriff neu an (UIDNEXT beginnt bei 1, RFC 3501 §2.3.1.1).
 // Konsistent bei parallelem Zugriff (Akzeptanzkriterium 2): INSERT ...
 // ON CONFLICT DO NOTHING + Rücklese, kein Lese-dann-Schreib-Fenster.
 func (s *Store) GetOrCreate(ctx context.Context, tenantSlug, mailboxName string) (FolderState, error) {
 	uidvalidity := s.newUIDValidity()
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_folder_state (tenant_slug, mailbox_name, uidvalidity, uidnext)
 		VALUES ($1, $2, $3, 1)
 		ON CONFLICT (tenant_slug, mailbox_name) DO NOTHING
 	`, tenantSlug, mailboxName, uidvalidity); err != nil {
 		return FolderState{}, fmt.Errorf("folderstate: ordner anlegen: %w", err)
 	}
 	return s.CurrentState(ctx, tenantSlug, mailboxName)
 }
 // CurrentState liest den Zustand ohne ihn anzulegen (Akzeptanzkriterium
 // 2: konsistente Sicht bei SELECT/EXAMINE).
 func (s *Store) CurrentState(ctx context.Context, tenantSlug, mailboxName string) (FolderState, error) {
 	var st FolderState
 	st.TenantSlug = tenantSlug
 	st.MailboxName = mailboxName
 	err := s.pool.QueryRow(ctx, `
 		SELECT uidvalidity, uidnext FROM mail_folder_state
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 	`, tenantSlug, mailboxName).Scan(&st.UIDValidity, &st.UIDNext)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return FolderState{}, ErrNotFound
 		}
 		return FolderState{}, fmt.Errorf("folderstate: zustand lesen: %w", err)
 	}
 	return st, nil
 }
 // ErrNotFound wird geliefert, wenn für den angefragten Ordner noch kein
 // Zustand existiert (GetOrCreate anlegen lassen, statt hier zu raten).
 var ErrNotFound = errors.New("folderstate: ordner nicht gefunden")
 // NextUID vergibt atomar die nächste UID für eine neu eintreffende
 // Nachricht (Akzeptanzkriterium 1/3) und protokolliert die Vergabe.
 // Nebenläufigkeitssicher: UPDATE ... RETURNING läuft unter Postgres'
 // Zeilensperre, zwei gleichzeitige Aufrufe für denselben Ordner können
 // niemals dieselbe UID liefern (Pflichtprüfung 2).
 func (s *Store) NextUID(ctx context.Context, tenantSlug, mailboxName string) (uid uint64, err error) {
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("folderstate: transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	err = tx.QueryRow(ctx, `
 		UPDATE mail_folder_state
 		SET uidnext = uidnext + 1, updated_at = now()
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 		RETURNING uidnext - 1
 	`, tenantSlug, mailboxName).Scan(&uid)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return 0, ErrNotFound
 		}
 		return 0, fmt.Errorf("folderstate: uid vergeben: %w", err)
 	}
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO mail_folder_state_events (tenant_slug, mailbox_name, event_type, uid)
 		VALUES ($1, $2, $3, $4)
 	`, tenantSlug, mailboxName, EventUIDAssigned, uid); err != nil {
 		return 0, fmt.Errorf("folderstate: ereignis protokollieren: %w", err)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return 0, fmt.Errorf("folderstate: uid-vergabe committen: %w", err)
 	}
 	return uid, nil
 }
 // RecordDeletion protokolliert die Löschung einer Nachricht mit
 // gegebener UID (Akzeptanzkriterium 3). UIDNEXT bleibt unverändert —
 // gelöschte UIDs werden gemäß RFC 3501 niemals wiederverwendet.
 func (s *Store) RecordDeletion(ctx context.Context, tenantSlug, mailboxName string, uid uint64) error {
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_folder_state_events (tenant_slug, mailbox_name, event_type, uid)
 		VALUES ($1, $2, $3, $4)
 	`, tenantSlug, mailboxName, EventDeleted, uid); err != nil {
 		return fmt.Errorf("folderstate: löschung protokollieren: %w", err)
 	}
 	return nil
 }
 // Rebuild simuliert einen Ordner-Neuaufbau (z. B. nach erkannter
 // Inkonsistenz oder bei einem Server, der seinerseits eine neue
 // UIDVALIDITY meldet): vergibt eine garantiert neue UIDVALIDITY und
 // setzt UIDNEXT zurück auf 1 (Pflichtprüfung 1).
 func (s *Store) Rebuild(ctx context.Context, tenantSlug, mailboxName string) (FolderState, error) {
 	candidateUIDValidity := s.newUIDValidity()
 	tx, err := s.pool.Begin(ctx)
 	if err != nil {
 		return FolderState{}, fmt.Errorf("folderstate: transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	// GREATEST(...)+1 garantiert eine STRENG größere UIDVALIDITY als die
 	// bisherige, unabhängig von der Uhrenauflösung — zwei Neuaufbauten
 	// innerhalb derselben Nanosekunde dürfen niemals denselben Wert
 	// liefern (Pflichtprüfung 1).
 	var newUIDValidity uint64
 	err = tx.QueryRow(ctx, `
 		UPDATE mail_folder_state
 		SET uidvalidity = GREATEST(uidvalidity + 1, $3), uidnext = 1, updated_at = now()
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 		RETURNING uidvalidity
 	`, tenantSlug, mailboxName, candidateUIDValidity).Scan(&newUIDValidity)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return FolderState{}, ErrNotFound
 		}
 		return FolderState{}, fmt.Errorf("folderstate: neuaufbau: %w", err)
 	}
 	if _, err := tx.Exec(ctx, `
 		INSERT INTO mail_folder_state_events (tenant_slug, mailbox_name, event_type)
 		VALUES ($1, $2, $3)
 	`, tenantSlug, mailboxName, EventRebuilt); err != nil {
 		return FolderState{}, fmt.Errorf("folderstate: neuaufbau-ereignis protokollieren: %w", err)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return FolderState{}, fmt.Errorf("folderstate: neuaufbau committen: %w", err)
 	}
 	return FolderState{TenantSlug: tenantSlug, MailboxName: mailboxName, UIDValidity: newUIDValidity, UIDNext: 1}, nil
 }
 // Events liefert die protokollierten Zustandsänderungen eines Ordners in
 // zeitlicher Reihenfolge (Akzeptanzkriterium 3: nachvollziehbar).
 func (s *Store) Events(ctx context.Context, tenantSlug, mailboxName string) ([]Event, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT event_type, uid, created_at FROM mail_folder_state_events
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 		ORDER BY id ASC
 	`, tenantSlug, mailboxName)
 	if err != nil {
 		return nil, fmt.Errorf("folderstate: ereignisse lesen: %w", err)
 	}
 	defer rows.Close()
 	var events []Event
 	for rows.Next() {
 		var e Event
 		var uid *int64
 		if err := rows.Scan(&e.EventType, &uid, &e.CreatedAt); err != nil {
 			return nil, fmt.Errorf("folderstate: ereigniszeile lesen: %w", err)
 		}
 		if uid != nil {
 			u := uint64(*uid)
 			e.UID = &u
 		}
 		events = append(events, e)
 	}
 	if err := rows.Err(); err != nil {
 		return nil, fmt.Errorf("folderstate: ereignisse iterieren: %w", err)
 	}
 	return events, nil
 }
 // newUIDValidity erzeugt eine garantiert positive, für praktische Zwecke
 // eindeutige UIDVALIDITY (Unix-Nanosekunden) — vermeidet den bekannten
 // archivmail-Fehler UIDVALIDITY=0.
 func (s *Store) newUIDValidity() uint64 {
 	return uint64(s.now().UnixNano())
 }
@@ -0,0 +1,176 @@
 // Integrationstest (ING-05): echte Postgres-Instanz, folgt derselben
 // Testhost-Konvention wie mail/internal/dedup/indexworker/savedsearch —
 // TEST_TENANT_DSN.
 package folderstate
 import (
 	"context"
 	"os"
 	"sync"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupStore(t *testing.T) *Store {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	store := NewStore(pool)
 	if err := store.EnsureSchema(ctx); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		ctx := context.Background()
 		_, _ = pool.Exec(ctx, `DELETE FROM mail_folder_state WHERE tenant_slug LIKE 'mandant-ing05-%'`)
 		_, _ = pool.Exec(ctx, `DELETE FROM mail_folder_state_events WHERE tenant_slug LIKE 'mandant-ing05-%'`)
 	})
 	return store
 }
 // TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild ist die
 // geforderte Pflichtprüfung 1: automatisierter Test für
 // UIDVALIDITY-Änderung bei simuliertem Ordner-Neuaufbau.
 func TestRebuild_ChangesUIDValidityOnSimulatedFolderRebuild(t *testing.T) {
 	store := setupStore(t)
 	ctx := context.Background()
 	tenant := "mandant-ing05-rebuild"
 	initial, err := store.GetOrCreate(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("getorcreate: %v", err)
 	}
 	if initial.UIDValidity == 0 {
 		t.Fatal("erwartete uidvalidity != 0 (bekannter archivmail-fehler vermeiden)")
 	}
 	// UIDNEXT vor dem Neuaufbau real erhöhen, damit der Reset auf 1
 	// nachweisbar ist.
 	if _, err := store.NextUID(ctx, tenant, "INBOX"); err != nil {
 		t.Fatalf("nextuid: %v", err)
 	}
 	rebuilt, err := store.Rebuild(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("rebuild: %v", err)
 	}
 	if rebuilt.UIDValidity == initial.UIDValidity {
 		t.Fatalf("erwartete geänderte uidvalidity nach neuaufbau, habe weiterhin %d", rebuilt.UIDValidity)
 	}
 	if rebuilt.UIDNext != 1 {
 		t.Fatalf("erwartete uidnext=1 nach neuaufbau, habe %d", rebuilt.UIDNext)
 	}
 	events, err := store.Events(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("events: %v", err)
 	}
 	found := false
 	for _, e := range events {
 		if e.EventType == EventRebuilt {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatal("erwartete protokolliertes 'rebuilt'-ereignis (akzeptanzkriterium 3: nachvollziehbar)")
 	}
 }
 // TestNextUID_ConcurrentSessionsOnSameFolderNoInconsistency ist die
 // geforderte Pflichtprüfung 2: Nebenläufigkeitstest — zwei Sessions auf
 // demselben Ordner ohne Inkonsistenz.
 func TestNextUID_ConcurrentSessionsOnSameFolderNoInconsistency(t *testing.T) {
 	store := setupStore(t)
 	ctx := context.Background()
 	tenant := "mandant-ing05-concurrent"
 	if _, err := store.GetOrCreate(ctx, tenant, "INBOX"); err != nil {
 		t.Fatalf("getorcreate: %v", err)
 	}
 	const parallelSessions = 20
 	var wg sync.WaitGroup
 	uids := make(chan uint64, parallelSessions)
 	errs := make(chan error, parallelSessions)
 	for i := 0; i < parallelSessions; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			uid, err := store.NextUID(ctx, tenant, "INBOX")
 			if err != nil {
 				errs <- err
 				return
 			}
 			uids <- uid
 		}()
 	}
 	wg.Wait()
 	close(uids)
 	close(errs)
 	for err := range errs {
 		t.Fatalf("nextuid unter nebenläufigkeit: %v", err)
 	}
 	seen := make(map[uint64]bool, parallelSessions)
 	for uid := range uids {
 		if seen[uid] {
 			t.Fatalf("uid %d doppelt vergeben — inkonsistenz unter nebenläufigem zugriff", uid)
 		}
 		seen[uid] = true
 	}
 	if len(seen) != parallelSessions {
 		t.Fatalf("erwartete %d eindeutige uids, habe %d", parallelSessions, len(seen))
 	}
 }
 // TestNextUID_MonotonicAcrossManyInsertDeleteCycles ist die geforderte
 // Pflichtprüfung 3: Test für UIDNEXT-Monotonie über viele Einfüge-/
 // Löschzyklen.
 func TestNextUID_MonotonicAcrossManyInsertDeleteCycles(t *testing.T) {
 	store := setupStore(t)
 	ctx := context.Background()
 	tenant := "mandant-ing05-monotonie"
 	if _, err := store.GetOrCreate(ctx, tenant, "INBOX"); err != nil {
 		t.Fatalf("getorcreate: %v", err)
 	}
 	var lastUID uint64
 	for i := 0; i < 200; i++ {
 		uid, err := store.NextUID(ctx, tenant, "INBOX")
 		if err != nil {
 			t.Fatalf("nextuid (zyklus %d): %v", i, err)
 		}
 		if i > 0 && uid <= lastUID {
 			t.Fatalf("uidnext nicht monoton steigend: zyklus %d, vorherige uid=%d, neue uid=%d", i, lastUID, uid)
 		}
 		lastUID = uid
 		// Löschung darf UIDNEXT NICHT verändern (RFC 3501: UIDs werden nie
 		// wiederverwendet) — jede zweite Nachricht wird "gelöscht".
 		if i%2 == 0 {
 			if err := store.RecordDeletion(ctx, tenant, "INBOX", uid); err != nil {
 				t.Fatalf("recorddeletion (zyklus %d): %v", i, err)
 			}
 		}
 	}
 	final, err := store.CurrentState(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("currentstate: %v", err)
 	}
 	if final.UIDNext != lastUID+1 {
 		t.Fatalf("erwartete uidnext=%d nach 200 vergebenen uids, habe %d", lastUID+1, final.UIDNext)
 	}
 }
@@ -0,0 +1,89 @@
 package folderstate
 import (
 	"context"
 	"testing"
 )
 // TestTenantScoping_NeverReturnsOrMutatesOtherTenantsFolderState ist die
 // geforderte Pflichtprüfung (ING-10, Akzeptanzkriterium 2): Tenant-
 // Scoping für den Folder-State-Ingestion-Pfad. Zwei Mandanten mit
 // IDENTISCHEM Postfachnamen "INBOX" — der Realfall, in dem ein fehlendes
 // tenant_slug-Prädikat sofort eine Vermischung zeigen würde.
 func TestTenantScoping_NeverReturnsOrMutatesOtherTenantsFolderState(t *testing.T) {
 	store := setupStore(t)
 	ctx := context.Background()
 	tenantA := "mandant-ing10-scoping-a"
 	tenantB := "mandant-ing10-scoping-b"
 	t.Cleanup(func() {
 		_, _ = store.pool.Exec(context.Background(), `DELETE FROM mail_folder_state WHERE tenant_slug LIKE 'mandant-ing10-%'`)
 		_, _ = store.pool.Exec(context.Background(), `DELETE FROM mail_folder_state_events WHERE tenant_slug LIKE 'mandant-ing10-%'`)
 	})
 	stateA, err := store.GetOrCreate(ctx, tenantA, "INBOX")
 	if err != nil {
 		t.Fatalf("GetOrCreate mandant a: %v", err)
 	}
 	stateB, err := store.GetOrCreate(ctx, tenantB, "INBOX")
 	if err != nil {
 		t.Fatalf("GetOrCreate mandant b: %v", err)
 	}
 	if stateA.UIDValidity == stateB.UIDValidity {
 		// Extrem unwahrscheinlich (beide UIDVALIDITY sind
 		// Unix-Zeitstempel), aber falls doch: kein Blocker für den
 		// eigentlichen Isolationstest, nur ein Hinweis für den Leser.
 		t.Logf("hinweis: beide mandanten haben zufällig dieselbe uidvalidity bekommen (%d)", stateA.UIDValidity)
 	}
 	// UIDs für Mandant A vergeben — dürfen Mandant Bs Zustand NICHT
 	// verändern.
 	for i := 0; i < 5; i++ {
 		if _, err := store.NextUID(ctx, tenantA, "INBOX"); err != nil {
 			t.Fatalf("NextUID mandant a: %v", err)
 		}
 	}
 	afterA, err := store.CurrentState(ctx, tenantA, "INBOX")
 	if err != nil {
 		t.Fatalf("CurrentState mandant a: %v", err)
 	}
 	stillB, err := store.CurrentState(ctx, tenantB, "INBOX")
 	if err != nil {
 		t.Fatalf("CurrentState mandant b: %v", err)
 	}
 	if afterA.UIDNext != stateA.UIDNext+5 {
 		t.Fatalf("mandant a: erwartete UIDNext %d, habe %d", stateA.UIDNext+5, afterA.UIDNext)
 	}
 	if stillB.UIDNext != stateB.UIDNext {
 		t.Fatalf("mandantenvermischung: mandant b's UIDNext hat sich durch mandant a's NextUID-Aufrufe verändert (%d -> %d)", stateB.UIDNext, stillB.UIDNext)
 	}
 	// Rebuild für Mandant B darf Mandant As Zustand nicht berühren.
 	rebuiltB, err := store.Rebuild(ctx, tenantB, "INBOX")
 	if err != nil {
 		t.Fatalf("Rebuild mandant b: %v", err)
 	}
 	if rebuiltB.UIDValidity == stateB.UIDValidity {
 		t.Fatalf("Rebuild mandant b hat UIDVALIDITY nicht geändert")
 	}
 	unchangedA, err := store.CurrentState(ctx, tenantA, "INBOX")
 	if err != nil {
 		t.Fatalf("CurrentState mandant a nach Rebuild b: %v", err)
 	}
 	if unchangedA.UIDValidity != afterA.UIDValidity {
 		t.Fatalf("mandantenvermischung: mandant a's UIDVALIDITY hat sich durch mandant b's Rebuild verändert")
 	}
 	// Events sind ebenfalls strikt je Mandant getrennt.
 	eventsA, err := store.Events(ctx, tenantA, "INBOX")
 	if err != nil {
 		t.Fatalf("Events mandant a: %v", err)
 	}
 	for _, e := range eventsA {
 		if e.EventType == EventRebuilt {
 			t.Fatalf("mandant a hat mandant b's Rebuild-Event gesehen: %+v", e)
 		}
 	}
 }
@@ -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
 	}
 }
@@ -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)
 	}
 }
@@ -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)
 }
@@ -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)
 	}
 }
@@ -0,0 +1,8 @@
 CREATE TABLE IF NOT EXISTS mail_hotfolder_processed (
    tenant_slug   TEXT NOT NULL,
    mailbox_name  TEXT NOT NULL,
    content_hash  TEXT NOT NULL,
    filename      TEXT NOT NULL,
    processed_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (tenant_slug, mailbox_name, content_hash)
 )
@@ -0,0 +1,60 @@
 // Package hotfolder implementiert IMP-05: Anbindung eines Hot-Folder/
 // Scanner-Eingangs für E-Mail-Anhänge/Dokumente außerhalb des
 // IMAP-Postfachs, analog zum Ingestion-Pfad. Kein Vorbild in archivmail
 // für diesen Zuschnitt — Neubau.
 package hotfolder
 import (
 	"context"
 	_ "embed"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 //go:embed migrations/0001_mail_hotfolder_processed.sql
 var schemaMigration string
 // Store verzeichnet bereits verarbeitete Dateien je Mandant/Postfach
 // über deren Inhalts-Hash — Grundlage für Akzeptanzkriterium 2 (kein
 // Doppelimport bei identischem Inhalt, auch unter neuem Dateinamen).
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
 func (s *Store) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
 		return fmt.Errorf("hotfolder: schema anlegen: %w", err)
 	}
 	return nil
 }
 // IsProcessed prüft, ob contentHash für tenantSlug/mailboxName bereits
 // erfolgreich importiert wurde.
 func (s *Store) IsProcessed(ctx context.Context, tenantSlug, mailboxName, contentHash string) (bool, error) {
 	var exists bool
 	err := s.pool.QueryRow(ctx, `
 		SELECT EXISTS(SELECT 1 FROM mail_hotfolder_processed WHERE tenant_slug = $1 AND mailbox_name = $2 AND content_hash = $3)
 	`, tenantSlug, mailboxName, contentHash).Scan(&exists)
 	if err != nil {
 		return false, fmt.Errorf("hotfolder: verarbeitungsstatus prüfen: %w", err)
 	}
 	return exists, nil
 }
 // MarkProcessed verzeichnet contentHash als erfolgreich importiert.
 func (s *Store) MarkProcessed(ctx context.Context, tenantSlug, mailboxName, contentHash, filename string) error {
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_hotfolder_processed (tenant_slug, mailbox_name, content_hash, filename)
 		VALUES ($1, $2, $3, $4)
 		ON CONFLICT (tenant_slug, mailbox_name, content_hash) DO NOTHING
 	`, tenantSlug, mailboxName, contentHash, filename); err != nil {
 		return fmt.Errorf("hotfolder: als verarbeitet markieren: %w", err)
 	}
 	return nil
 }
@@ -0,0 +1,197 @@
 package hotfolder
 import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"fmt"
 	"os"
 	"path/filepath"
 	"github.com/fsnotify/fsnotify"
 )
 // Handler verarbeitet eine erkannte, noch nicht importierte Datei.
 // Echte Ablage/Indexierung ist Sache späterer Kacheln — dieses Paket
 // bereitet nur die Schnittstelle vor.
 type Handler interface {
 	ProcessFile(ctx context.Context, tenantSlug, mailboxName, filename string, content []byte) error
 }
 // Watcher überwacht EIN Hot-Folder-Verzeichnis für EINEN Mandanten/EIN
 // Postfach (Akzeptanzkriterium 1: Zuordnung ist strukturell — welches
 // Verzeichnis zu welchem Mandanten/Postfach gehört, entscheidet der
 // Aufrufer beim Konfigurieren des Watchers, nicht dieses Paket anhand
 // von Dateiinhalten).
 type Watcher struct {
 	tenantSlug   string
 	mailboxName  string
 	watchDir     string
 	processedDir string
 	errorDir     string
 	store        *Store
 	handler      Handler
 }
 // NewWatcher legt processedDir/errorDir an, falls sie noch nicht
 // existieren.
 func NewWatcher(tenantSlug, mailboxName, watchDir, processedDir, errorDir string, store *Store, handler Handler) (*Watcher, error) {
 	for _, dir := range []string{watchDir, processedDir, errorDir} {
 		if err := os.MkdirAll(dir, 0o755); err != nil {
 			return nil, fmt.Errorf("hotfolder: verzeichnis %s anlegen: %w", dir, err)
 		}
 	}
 	return &Watcher{
 		tenantSlug:   tenantSlug,
 		mailboxName:  mailboxName,
 		watchDir:     watchDir,
 		processedDir: processedDir,
 		errorDir:     errorDir,
 		store:        store,
 		handler:      handler,
 	}, nil
 }
 // ScanResult fasst einen abgeschlossenen Scan-Durchlauf zusammen.
 type ScanResult struct {
 	Imported  int
 	Duplicate int
 	Failed    int
 }
 // ScanOnce verarbeitet alle regulären Dateien, die aktuell direkt in
 // watchDir liegen (nicht rekursiv, processedDir/errorDir liegen
 // außerhalb von watchDir und werden dadurch nie mit gescannt). Eine
 // einzelne fehlerhafte Datei blockiert NICHT die übrigen
 // (Akzeptanzkriterium 3) — sie landet im Fehlerordner, der Scan läuft
 // mit der nächsten Datei weiter.
 func (w *Watcher) ScanOnce(ctx context.Context) (ScanResult, error) {
 	entries, err := os.ReadDir(w.watchDir)
 	if err != nil {
 		return ScanResult{}, fmt.Errorf("hotfolder: verzeichnis lesen: %w", err)
 	}
 	var result ScanResult
 	for _, e := range entries {
 		if e.IsDir() {
 			continue
 		}
 		if err := ctx.Err(); err != nil {
 			return result, err
 		}
 		outcome := w.processOne(ctx, e.Name())
 		switch outcome {
 		case outcomeImported:
 			result.Imported++
 		case outcomeDuplicate:
 			result.Duplicate++
 		case outcomeFailed:
 			result.Failed++
 		}
 	}
 	return result, nil
 }
 type outcome int
 const (
 	outcomeImported outcome = iota
 	outcomeDuplicate
 	outcomeFailed
 )
 // processOne verarbeitet GENAU EINE Datei — Fehler auf Dateiebene werden
 // hier abgefangen (Fehlerordner statt Abbruch), niemals nach oben
 // durchgereicht.
 func (w *Watcher) processOne(ctx context.Context, filename string) outcome {
 	fullPath := filepath.Join(w.watchDir, filename)
 	content, err := os.ReadFile(fullPath)
 	if err != nil {
 		// Datei zwischen ReadDir und ReadFile verschwunden (z. B. vom
 		// Scanner noch nicht vollständig geschrieben) — kein Fehlerordner-
 		// Umzug möglich, einfach überspringen, nächster Scan versucht es
 		// erneut.
 		return outcomeFailed
 	}
 	hash := sha256.Sum256(content)
 	contentHash := hex.EncodeToString(hash[:])
 	alreadyDone, err := w.store.IsProcessed(ctx, w.tenantSlug, w.mailboxName, contentHash)
 	if err != nil {
 		w.moveTo(fullPath, w.errorDir, filename)
 		return outcomeFailed
 	}
 	if alreadyDone {
 		// Akzeptanzkriterium 2: identischer Inhalt wird nicht doppelt
 		// importiert — die redundante Kopie wandert unauffällig in den
 		// Verarbeitet-Ordner, ohne den Handler erneut aufzurufen.
 		w.moveTo(fullPath, w.processedDir, filename)
 		return outcomeDuplicate
 	}
 	if err := w.handler.ProcessFile(ctx, w.tenantSlug, w.mailboxName, filename, content); err != nil {
 		w.moveTo(fullPath, w.errorDir, filename)
 		return outcomeFailed
 	}
 	if err := w.store.MarkProcessed(ctx, w.tenantSlug, w.mailboxName, contentHash, filename); err != nil {
 		w.moveTo(fullPath, w.errorDir, filename)
 		return outcomeFailed
 	}
 	w.moveTo(fullPath, w.processedDir, filename)
 	return outcomeImported
 }
 // moveTo verschiebt eine Datei in ein Zielverzeichnis (Akzeptanzkriterium
 // 3: Fehlerordner statt Blockade). Ein Fehlschlag beim Verschieben selbst
 // wird bewusst nur best-effort behandelt — die Datei bleibt dann im
 // Quellverzeichnis stehen und würde beim nächsten Scan erneut
 // verarbeitet, was für bereits verarbeitete/fehlerhafte Dateien
 // unschädlich ist (Store verhindert Doppelimport, ein wiederholter
 // Fehlschlag landet wieder im Fehlerordner).
 func (w *Watcher) moveTo(sourcePath, targetDir, filename string) {
 	_ = os.Rename(sourcePath, filepath.Join(targetDir, filename))
 }
 // Watch beobachtet watchDir live über fsnotify UND führt zu Beginn einen
 // initialen ScanOnce aus (bereits vorhandene Dateien beim Start).
 // Blockiert, bis ctx beendet wird.
 func (w *Watcher) Watch(ctx context.Context) error {
 	if _, err := w.ScanOnce(ctx); err != nil {
 		return err
 	}
 	fsWatcher, err := fsnotify.NewWatcher()
 	if err != nil {
 		return fmt.Errorf("hotfolder: fsnotify-watcher erstellen: %w", err)
 	}
 	defer func() { _ = fsWatcher.Close() }()
 	if err := fsWatcher.Add(w.watchDir); err != nil {
 		return fmt.Errorf("hotfolder: verzeichnis beobachten: %w", err)
 	}
 	for {
 		select {
 		case <-ctx.Done():
 			return nil
 		case event, ok := <-fsWatcher.Events:
 			if !ok {
 				return nil
 			}
 			if event.Op&(fsnotify.Create|fsnotify.Write) == 0 {
 				continue
 			}
 			if _, err := w.ScanOnce(ctx); err != nil {
 				return err
 			}
 		case err, ok := <-fsWatcher.Errors:
 			if !ok {
 				return nil
 			}
 			return fmt.Errorf("hotfolder: fsnotify-fehler: %w", err)
 		}
 	}
 }
@@ -0,0 +1,214 @@
 // Integrationstest (IMP-05): echte Postgres-Instanz UND echtes
 // Dateisystem, folgt derselben Testhost-Konvention wie
 // mail/internal/dedup/folderstate — TEST_TENANT_DSN.
 package hotfolder
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"runtime"
 	"sync"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // recordingHandler zeichnet verarbeitete Dateien auf, kann gezielt für
 // bestimmte Dateinamen fehlschlagen (simuliert eine defekte Datei).
 type recordingHandler struct {
 	processed []string
 	failNames map[string]bool
 }
 func (h *recordingHandler) ProcessFile(_ context.Context, _, _, filename string, _ []byte) error {
 	if h.failNames[filename] {
 		return errFakeCorrupt
 	}
 	h.processed = append(h.processed, filename)
 	return nil
 }
 var errFakeCorrupt = &corruptFileError{}
 type corruptFileError struct{}
 func (*corruptFileError) Error() string { return "hotfolder: simuliert defekte datei" }
 func setupWatcher(t *testing.T, handler Handler) (*Watcher, string) {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	store := NewStore(pool)
 	if err := store.EnsureSchema(ctx); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	tenant := "mandant-imp05-hotfolder"
 	t.Cleanup(func() {
 		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_hotfolder_processed WHERE tenant_slug LIKE 'mandant-%'`)
 	})
 	root := t.TempDir()
 	watchDir := filepath.Join(root, "eingang")
 	processedDir := filepath.Join(root, "verarbeitet")
 	errorDir := filepath.Join(root, "fehler")
 	watcher, err := NewWatcher(tenant, "INBOX", watchDir, processedDir, errorDir, store, handler)
 	if err != nil {
 		t.Fatalf("newwatcher: %v", err)
 	}
 	return watcher, watchDir
 }
 func writeFile(t *testing.T, dir, name, content string) {
 	t.Helper()
 	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
 		t.Fatalf("datei schreiben: %v", err)
 	}
 }
 // TestScanOnce_SameFileDroppedTwiceImportedOnce ist die geforderte
 // Pflichtprüfung 1: gleiche Datei zweimal abgelegt wird nur einmal
 // importiert.
 func TestScanOnce_SameFileDroppedTwiceImportedOnce(t *testing.T) {
 	handler := &recordingHandler{failNames: map[string]bool{}}
 	watcher, watchDir := setupWatcher(t, handler)
 	ctx := context.Background()
 	writeFile(t, watchDir, "rechnung.pdf", "identischer inhalt")
 	result1, err := watcher.ScanOnce(ctx)
 	if err != nil {
 		t.Fatalf("erster scan: %v", err)
 	}
 	if result1.Imported != 1 {
 		t.Fatalf("erwartete 1 import im ersten scan, habe %d", result1.Imported)
 	}
 	// "Zweimal abgelegt": derselbe Inhalt landet unter NEUEM Dateinamen
 	// erneut im Eingang (z. B. Scanner mit Zeitstempel-Dateinamen).
 	writeFile(t, watchDir, "rechnung_kopie.pdf", "identischer inhalt")
 	result2, err := watcher.ScanOnce(ctx)
 	if err != nil {
 		t.Fatalf("zweiter scan: %v", err)
 	}
 	if result2.Imported != 0 {
 		t.Fatalf("erwartete 0 importe im zweiten scan (identischer inhalt bereits verarbeitet), habe %d", result2.Imported)
 	}
 	if result2.Duplicate != 1 {
 		t.Fatalf("erwartete 1 erkanntes duplikat, habe %d", result2.Duplicate)
 	}
 	if len(handler.processed) != 1 {
 		t.Fatalf("handler wurde erwartet genau 1x aufgerufen, habe %d: %v", len(handler.processed), handler.processed)
 	}
 }
 // TestScanOnce_CorruptFileMovedToErrorFolderTraceably ist die geforderte
 // Pflichtprüfung 2: fehlerhafte Datei landet nachvollziehbar im
 // Fehlerordner.
 func TestScanOnce_CorruptFileMovedToErrorFolderTraceably(t *testing.T) {
 	handler := &recordingHandler{failNames: map[string]bool{"defekt.pdf": true}}
 	watcher, watchDir := setupWatcher(t, handler)
 	ctx := context.Background()
 	writeFile(t, watchDir, "defekt.pdf", "kaputter inhalt")
 	writeFile(t, watchDir, "gut.pdf", "guter inhalt")
 	result, err := watcher.ScanOnce(ctx)
 	if err != nil {
 		t.Fatalf("scan: %v", err)
 	}
 	if result.Failed != 1 || result.Imported != 1 {
 		t.Fatalf("erwartete 1 fehler + 1 import, habe: %+v", result)
 	}
 	if _, err := os.Stat(filepath.Join(watcher.errorDir, "defekt.pdf")); err != nil {
 		t.Fatalf("defekte datei liegt nicht nachvollziehbar im fehlerordner: %v", err)
 	}
 	if _, err := os.Stat(filepath.Join(watchDir, "defekt.pdf")); !os.IsNotExist(err) {
 		t.Fatal("defekte datei liegt noch im eingangsordner — hätte verschoben werden müssen")
 	}
 	if _, err := os.Stat(filepath.Join(watcher.processedDir, "gut.pdf")); err != nil {
 		t.Fatalf("die GUTE datei sollte trotz des defekten nachbarn real verarbeitet worden sein: %v", err)
 	}
 }
 // TestScanOnce_ManyCyclesWithoutResourceLeak ist die geforderte
 // Pflichtprüfung 3: Dauertest über mehrere Scan-Zyklen ohne
 // Ressourcenleck.
 func TestScanOnce_ManyCyclesWithoutResourceLeak(t *testing.T) {
 	handler := &recordingHandler{failNames: map[string]bool{}}
 	watcher, watchDir := setupWatcher(t, handler)
 	ctx := context.Background()
 	before := runtime.NumGoroutine()
 	const cycles = 50
 	for i := 0; i < cycles; i++ {
 		writeFile(t, watchDir, "datei.txt", "inhalt-zyklus")
 		if _, err := watcher.ScanOnce(ctx); err != nil {
 			t.Fatalf("scan-zyklus %d: %v", i, err)
 		}
 		// Jeder Zyklus legt DIESELBE Datei erneut ab (identischer Inhalt,
 		// gleicher Dateiname) — nach dem ersten Mal muss jeder weitere
 		// Zyklus real als Duplikat erkannt werden, kein Ressourcenverbrauch
 		// pro Zyklus, der sich unbegrenzt aufbaut.
 	}
 	after := runtime.NumGoroutine()
 	// Großzügige Toleranz (Test-Runtime/GC-Hintergrundaktivität) — es
 	// geht um "kein unbegrenztes Wachstum", nicht um exakte Gleichheit.
 	if after > before+10 {
 		t.Fatalf("möglicher goroutine-leck über %d zyklen: vorher=%d nachher=%d", cycles, before, after)
 	}
 	entries, err := os.ReadDir(watcher.processedDir)
 	if err != nil {
 		t.Fatalf("verarbeitet-ordner lesen: %v", err)
 	}
 	if len(entries) != 1 {
 		t.Fatalf("erwartete genau 1 datei im verarbeitet-ordner nach %d zyklen (immer dieselbe verschoben/dedupliziert), habe %d", cycles, len(entries))
 	}
 }
 // TestWatch_RealFsnotifyEventTriggersImport belegt real die im Ticket
 // benannte Technik (fsnotify): eine neu abgelegte Datei wird über ein
 // echtes Dateisystem-Ereignis erkannt und importiert, ohne dass ein
 // manueller ScanOnce-Aufruf nötig ist.
 func TestWatch_RealFsnotifyEventTriggersImport(t *testing.T) {
 	handler := &recordingHandler{failNames: map[string]bool{}}
 	watcher, watchDir := setupWatcher(t, handler)
 	ctx, cancel := context.WithCancel(context.Background())
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		_ = watcher.Watch(ctx)
 	}()
 	t.Cleanup(func() {
 		cancel()
 		wg.Wait()
 	})
 	time.Sleep(100 * time.Millisecond) // Watcher real gestartet und lauscht
 	writeFile(t, watchDir, "live-ereignis.txt", "per fsnotify erkannt")
 	deadline := time.Now().Add(3 * time.Second)
 	for time.Now().Before(deadline) {
 		if _, err := os.Stat(filepath.Join(watcher.processedDir, "live-ereignis.txt")); err == nil {
 			return // real per fsnotify erkannt und verarbeitet
 		}
 		time.Sleep(20 * time.Millisecond)
 	}
 	t.Fatal("datei wurde nicht innerhalb der frist per echtem fsnotify-ereignis importiert")
 }
@@ -0,0 +1,251 @@
 package imap
 import (
 	"bufio"
 	"context"
 	"fmt"
 	"strconv"
 	"strings"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/tlscert"
 )
 // handleCapability ist in jedem Zustand erlaubt (RFC 3501 §6.1.1).
 func (s *Session) handleCapability(cmd command) bool {
 	caps := "CAPABILITY IMAP4rev1"
 	if s.tlsConfig != nil && !s.tlsActive {
 		caps += " STARTTLS"
 	}
 	if err := writeUntagged(s.writer, caps); err != nil {
 		return false
 	}
 	return s.writeErr(cmd.Tag, "OK", "CAPABILITY completed")
 }
 // handleLogin ist nur im Zustand NotAuthenticated erlaubt
 // (Akzeptanzkriterium 1/3).
 func (s *Session) handleLogin(ctx context.Context, cmd command) bool {
 	if s.state != NotAuthenticated {
 		return s.writeErr(cmd.Tag, "BAD", "LOGIN not allowed in "+s.state.String()+" state")
 	}
 	if len(cmd.Args) != 2 {
 		return s.writeErr(cmd.Tag, "BAD", "LOGIN requires username and password")
 	}
 	if s.tlsConfig != nil && !s.tlsActive {
 		// Akzeptanzkriterium 1 (ING-06): Anmeldedaten werden
 		// ausschließlich über TLS oder nach erfolgreichem STARTTLS
 		// akzeptiert, sobald der Server TLS überhaupt anbietet.
 		return s.writeErr(cmd.Tag, "NO", "LOGIN disabled without TLS, use STARTTLS")
 	}
 	if s.loginLimiter != nil {
 		if ok, retryAfter := s.loginLimiter.Allow(s.tenantID, s.sourceAddr()); !ok {
 			// Akzeptanzkriterium 1/3 (ING-09): definierte Ablehnung MIT
 			// Wartezeit-Hinweis statt Verbindungsabbruch ohne Erklärung.
 			return s.writeErr(cmd.Tag, "NO", fmt.Sprintf("rate limit exceeded, retry in %.1fs", retryAfter.Seconds()))
 		}
 	}
 	if s.auth == nil {
 		return s.writeErr(cmd.Tag, "NO", "LOGIN not available")
 	}
 	ok, err := s.auth.Authenticate(ctx, cmd.Args[0], cmd.Args[1])
 	if err != nil || !ok {
 		// Backoff statt Dauerschleife bei wiederholten Fehlversuchen
 		// (Akzeptanzkriterium 3, ING-07).
 		backoff, disconnect := s.guard.RecordAuthFailure()
 		s.guard.Wait(ctx, backoff)
 		if !s.writeErr(cmd.Tag, "NO", "LOGIN failed") {
 			return false
 		}
 		return !disconnect
 	}
 	s.guard.ResetAuthFailures()
 	s.state = Authenticated
 	return s.writeErr(cmd.Tag, "OK", "LOGIN completed")
 }
 // handleSelect ist in Authenticated und Selected erlaubt (ein erneutes
 // SELECT wechselt das gewählte Postfach).
 func (s *Session) handleSelect(ctx context.Context, cmd command) bool {
 	if s.state == NotAuthenticated {
 		return s.writeErr(cmd.Tag, "BAD", "SELECT not allowed in "+s.state.String()+" state")
 	}
 	if len(cmd.Args) != 1 {
 		return s.writeErr(cmd.Tag, "BAD", "SELECT requires a mailbox name")
 	}
 	if s.store == nil {
 		return s.writeErr(cmd.Tag, "NO", "SELECT not available")
 	}
 	mailboxName := cmd.Args[0]
 	exists, uidvalidity, ok, err := s.store.Select(ctx, mailboxName)
 	if err != nil || !ok {
 		// Fehlgeschlagenes SELECT lässt den Zustand laut RFC 3501 §6.3.1
 		// auf Authenticated zurückfallen, nie in Selected mit ungültigem
 		// Postfach hängen bleiben.
 		s.state = Authenticated
 		return s.writeErr(cmd.Tag, "NO", "SELECT failed: no such mailbox")
 	}
 	if err := writeUntagged(s.writer, fmt.Sprintf("%d EXISTS", exists)); err != nil {
 		return false
 	}
 	// RFC 3501 §2.3.1.1: UIDVALIDITY ist Pflichtbestandteil der
 	// SELECT-Antwort — Grundlage für IMP-01s Erkennung eines
 	// Ordner-Neuaufbaus.
 	if err := writeUntagged(s.writer, fmt.Sprintf("OK [UIDVALIDITY %d] UIDs valid", uidvalidity)); err != nil {
 		return false
 	}
 	s.state = Selected
 	s.mailbox = mailboxName
 	s.mailboxSize = uint32(exists)
 	return s.writeErr(cmd.Tag, "OK", "[READ-WRITE] SELECT completed")
 }
 // handleFetch ist ausschließlich im Zustand Selected erlaubt
 // (Akzeptanzkriterium 1/2).
 func (s *Session) handleFetch(ctx context.Context, cmd command) bool {
 	if s.state != Selected {
 		return s.writeErr(cmd.Tag, "BAD", "FETCH not allowed in "+s.state.String()+" state")
 	}
 	if len(cmd.Args) < 1 {
 		return s.writeErr(cmd.Tag, "BAD", "FETCH requires a sequence set")
 	}
 	seqNumbers, err := parseSequenceSet(cmd.Args[0], s.mailboxSize)
 	if err != nil {
 		return s.writeErr(cmd.Tag, "BAD", "FETCH: invalid sequence set")
 	}
 	messages, err := s.store.Fetch(ctx, s.mailbox, seqNumbers)
 	if err != nil {
 		return s.writeErr(cmd.Tag, "NO", "FETCH failed")
 	}
 	return s.writeFetchResults(cmd.Tag, "FETCH", messages)
 }
 // handleUIDFetch implementiert "UID FETCH" (RFC 3501 §6.4.8) — wie FETCH,
 // aber uid-set statt Sequenzsatz, Grundlage für IMP-01s UID-basierten
 // Delta-Sync.
 func (s *Session) handleUIDFetch(ctx context.Context, cmd command) bool {
 	if s.state != Selected {
 		return s.writeErr(cmd.Tag, "BAD", "UID FETCH not allowed in "+s.state.String()+" state")
 	}
 	if len(cmd.Args) < 2 {
 		return s.writeErr(cmd.Tag, "BAD", "UID FETCH requires a uid set")
 	}
 	// "*" in einem UID-Satz bedeutet "höchste vorhandene UID", NICHT die
 	// NachrichtenANZAHL (s.mailboxSize) — UIDs können durch Löschungen
 	// weit über der Nachrichtenzahl liegen (siehe mail/internal/
 	// folderstate, ING-05: UIDs werden nie wiederverwendet). Da
 	// parseSequenceSet einen Bereich materialisiert, wird "*" hier auf
 	// maxOpenEndedUID begrenzt statt auf 2^32-1 — verhindert eine
 	// Milliarden Einträge lange Schleife bei einem einzelnen offenen
 	// Bereich. FetchByUID liefert ohnehin nur tatsächlich vorhandene
 	// UIDs zurück, die Begrenzung ist für reale Postfachgrößen harmlos.
 	uidSet, err := parseSequenceSet(cmd.Args[1], maxOpenEndedUID)
 	if err != nil {
 		return s.writeErr(cmd.Tag, "BAD", "UID FETCH: invalid uid set")
 	}
 	messages, err := s.store.FetchByUID(ctx, s.mailbox, uidSet)
 	if err != nil {
 		return s.writeErr(cmd.Tag, "NO", "UID FETCH failed")
 	}
 	return s.writeFetchResults(cmd.Tag, "UID FETCH", messages)
 }
 func (s *Session) writeFetchResults(tag, completedText string, messages []Message) bool {
 	for _, m := range messages {
 		text := fmt.Sprintf("%d FETCH (UID %d FLAGS (%s))", m.SequenceNumber, m.UID, strings.Join(m.Flags, " "))
 		if err := writeUntagged(s.writer, text); err != nil {
 			return false
 		}
 	}
 	return s.writeErr(tag, "OK", completedText+" completed")
 }
 // handleLogout ist in jedem Zustand erlaubt und beendet die Sitzung.
 func (s *Session) handleLogout(cmd command) bool {
 	if err := writeUntagged(s.writer, "BYE IMAP4rev1 Server logging out"); err != nil {
 		return false
 	}
 	_ = s.writeErr(cmd.Tag, "OK", "LOGOUT completed")
 	return false
 }
 // handleStartTLS implementiert STARTTLS (RFC 3501 §6.2.1): TLS-Aufwertung
 // der bestehenden Klartextverbindung, nur vor der Anmeldung erlaubt.
 func (s *Session) handleStartTLS(ctx context.Context, cmd command) bool {
 	if s.tlsConfig == nil {
 		return s.writeErr(cmd.Tag, "NO", "STARTTLS not available")
 	}
 	if s.tlsActive {
 		return s.writeErr(cmd.Tag, "BAD", "TLS already active")
 	}
 	if s.state != NotAuthenticated {
 		return s.writeErr(cmd.Tag, "BAD", "STARTTLS not allowed in "+s.state.String()+" state")
 	}
 	if !s.writeErr(cmd.Tag, "OK", "Begin TLS negotiation now") {
 		return false
 	}
 	tlsConn, err := tlscert.UpgradeServer(ctx, s.conn, s.tlsConfig)
 	if err != nil {
 		// Handshake fehlgeschlagen -> Verbindung beenden, kein Rückfall
 		// auf Klartext.
 		return false
 	}
 	s.conn = tlsConn
 	// Reader/Writer NEU aufsetzen: verhindert, dass vor dem Handshake
 	// gepufferte Klartextdaten nach dem Wechsel noch als Kommandos
 	// verarbeitet werden (Command-Injection-Schutz).
 	s.reader = bufio.NewReaderSize(tlsConn, maxCommandLineBytes)
 	s.writer = bufio.NewWriter(tlsConn)
 	s.tlsActive = true
 	return true
 }
 // parseSequenceSet unterstützt die für FETCH gebräuchlichsten Formen:
 // eine einzelne Zahl ("1"), eine kommagetrennte Liste ("1,3,5") und einen
 // Bereich mit "*" als offenem Ende ("1:*"), aufgelöst gegen maxSeq (die
 // tatsächliche Nachrichtenzahl des gewählten Postfachs, von SELECT
 // gemeldet). Volle RFC-3501-Sequenzsatz-Grammatik (verschachtelte
 // Bereiche etc.) ist bewusst nicht Bestandteil dieser kleinsten Lösung.
 // maxOpenEndedUID begrenzt, wie weit ein offener UID-Bereich ("N:*")
 // materialisiert wird — deckt reale Postfachgrößen komfortabel ab, ohne
 // bei einem einzelnen Kommando Milliarden Slice-Einträge zu erzeugen.
 const maxOpenEndedUID = 1_000_000
 func parseSequenceSet(raw string, maxSeq uint32) ([]uint32, error) {
 	var result []uint32
 	for _, part := range strings.Split(raw, ",") {
 		if strings.Contains(part, ":") {
 			bounds := strings.SplitN(part, ":", 2)
 			if len(bounds) != 2 {
 				return nil, fmt.Errorf("imap: ungültiger bereich %q", part)
 			}
 			from, err := strconv.ParseUint(bounds[0], 10, 32)
 			if err != nil {
 				return nil, err
 			}
 			to := uint64(maxSeq)
 			if bounds[1] != "*" {
 				to, err = strconv.ParseUint(bounds[1], 10, 32)
 				if err != nil {
 					return nil, err
 				}
 			}
 			for i := from; i <= to; i++ {
 				result = append(result, uint32(i))
 			}
 			continue
 		}
 		n, err := strconv.ParseUint(part, 10, 32)
 		if err != nil {
 			return nil, err
 		}
 		result = append(result, uint32(n))
 	}
 	return result, nil
 }
@@ -0,0 +1,157 @@
 package imap
 import (
 	"context"
 	"net"
 	"runtime"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 )
 func startTestServerWithGuardConfig(t *testing.T, guardCfg protoguard.Config) (addr string, stop func()) {
 	t.Helper()
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	store := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {
 			{SequenceNumber: 1, UID: 101, Flags: []string{"\\Seen"}},
 			{SequenceNumber: 2, UID: 102, Flags: []string{}},
 		},
 	}}
 	srv := NewServerWithGuardConfig(auth, store, 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)
 	}()
 	return listener.Addr().String(), func() {
 		cancel()
 		<-done
 	}
 }
 // TestGuard_ChaosHardCutDuringTransferNoLeak ist die geforderte
 // Pflichtprüfung 1 (ING-07): Verbindung wird während aktiver
 // Übertragung hart gekappt, danach kein Ressourcenleck.
 func TestGuard_ChaosHardCutDuringTransferNoLeak(t *testing.T) {
 	addr, stop := startTestServerWithGuardConfig(t, protoguard.DefaultConfig())
 	defer stop()
 	runtime.GC()
 	baseline := runtime.NumGoroutine()
 	const rounds = 30
 	for i := 0; i < rounds; i++ {
 		c := dial(t, addr)
 		c.sendTagged(t, `LOGIN alice geheim123`)
 		c.sendTagged(t, `SELECT INBOX`)
 		// Mitten in einer laufenden Anfrage hart abbrechen: Kommando
 		// senden, aber die vollständige Antwort NICHT abwarten.
 		_, err := c.conn.Write([]byte("A99 FETCH 1:2 (FLAGS)\r\n"))
 		if err != nil {
 			t.Fatalf("kommando senden: %v", err)
 		}
 		_ = c.conn.Close()
 	}
 	deadline := time.Now().Add(3 * time.Second)
 	for {
 		runtime.GC()
 		current := runtime.NumGoroutine()
 		if current <= baseline+2 {
 			return
 		}
 		if time.Now().After(deadline) {
 			t.Fatalf("goroutine-leck nach hartem Verbindungsabbruch: baseline=%d, aktuell=%d", baseline, current)
 		}
 		time.Sleep(50 * time.Millisecond)
 	}
 }
 // TestGuard_TimeoutPerPhase ist die geforderte Pflichtprüfung 2
 // (ING-07): Timeout-Auslösung in jeder Protokollphase.
 func TestGuard_TimeoutPerPhase(t *testing.T) {
 	cfg := protoguard.Config{
 		PhaseTimeout: map[protoguard.Phase]time.Duration{
 			phaseNotAuthenticated: 100 * time.Millisecond,
 			phaseSelected:         100 * time.Millisecond,
 		},
 		DefaultTimeout: 5 * time.Second,
 	}
 	t.Run("not_authenticated", func(t *testing.T) {
 		addr, stop := startTestServerWithGuardConfig(t, cfg)
 		defer stop()
 		c := dial(t, addr)
 		defer c.close()
 		_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
 		_, err := c.reader.ReadString('\n')
 		if err == nil {
 			t.Fatalf("erwartete Verbindungsende durch NotAuthenticated-Timeout")
 		}
 	})
 	t.Run("selected", func(t *testing.T) {
 		addr, stop := startTestServerWithGuardConfig(t, cfg)
 		defer stop()
 		c := dial(t, addr)
 		defer c.close()
 		c.sendTagged(t, `LOGIN alice geheim123`)
 		c.sendTagged(t, `SELECT INBOX`) // jetzt Selected, nichts weiter senden
 		_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
 		_, err := c.reader.ReadString('\n')
 		if err == nil {
 			t.Fatalf("erwartete Verbindungsende durch Selected-Timeout")
 		}
 	})
 }
 // TestGuard_BackoffOnRepeatedAuthFailures ist die geforderte
 // Pflichtprüfung 3 (ING-07): Backoff-Verhalten bei wiederholten
 // Fehlversuchen statt Dauerschleife.
 func TestGuard_BackoffOnRepeatedAuthFailures(t *testing.T) {
 	cfg := protoguard.Config{
 		DefaultTimeout:  5 * time.Second,
 		MaxAuthFailures: 3,
 		BackoffBase:     50 * time.Millisecond,
 		BackoffMax:      500 * time.Millisecond,
 	}
 	addr, stop := startTestServerWithGuardConfig(t, cfg)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	var attemptDurations []time.Duration
 	for i := 0; i < 3; i++ {
 		start := time.Now()
 		_, lines := c.sendTagged(t, `LOGIN alice falsch`)
 		last := lines[len(lines)-1]
 		if !strings.Contains(last, "NO") {
 			t.Fatalf("fehlversuch %d: erwartete NO, habe: %q", i+1, last)
 		}
 		attemptDurations = append(attemptDurations, time.Since(start))
 	}
 	if attemptDurations[1] <= attemptDurations[0] {
 		t.Fatalf("erwartete steigenden Backoff, habe Dauern: %v", attemptDurations)
 	}
 	// Nach MaxAuthFailures muss die Verbindung getrennt sein.
 	_ = c.conn.SetReadDeadline(time.Now().Add(2 * time.Second))
 	if _, err := c.conn.Write([]byte("A99 LOGIN alice geheim123\r\n")); err == nil {
 		_, err = c.reader.ReadString('\n')
 		if err == nil {
 			t.Fatalf("erwartete Verbindungstrennung nach %d Fehlversuchen", cfg.MaxAuthFailures)
 		}
 	}
 }
@@ -0,0 +1,343 @@
 package imap
 import (
 	"bufio"
 	"context"
 	"errors"
 	"net"
 	"strconv"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 )
 // fakeAuthenticator ist ein In-Memory-Authenticator für Tests — echte
 // Anbindung an Benutzerverwaltung ist Sache späterer Kacheln (IMP-01 u. a.).
 type fakeAuthenticator struct {
 	users map[string]string
 }
 func (f fakeAuthenticator) Authenticate(_ context.Context, username, password string) (bool, error) {
 	want, ok := f.users[username]
 	return ok && want == password, nil
 }
 // fakeMailboxStore ist ein In-Memory-Postfachspeicher für Tests.
 type fakeMailboxStore struct {
 	mailboxes map[string][]Message
 }
 func (f fakeMailboxStore) Select(_ context.Context, mailboxName string) (int, uint64, bool, error) {
 	msgs, ok := f.mailboxes[mailboxName]
 	return len(msgs), 1, ok, nil
 }
 func (f fakeMailboxStore) Fetch(_ context.Context, mailboxName string, seqNumbers []uint32) ([]Message, error) {
 	msgs, ok := f.mailboxes[mailboxName]
 	if !ok {
 		return nil, errors.New("imap: postfach nicht gefunden")
 	}
 	wanted := make(map[uint32]bool, len(seqNumbers))
 	for _, n := range seqNumbers {
 		wanted[n] = true
 	}
 	var result []Message
 	for _, m := range msgs {
 		if wanted[m.SequenceNumber] {
 			result = append(result, m)
 		}
 	}
 	return result, nil
 }
 func (f fakeMailboxStore) FetchByUID(_ context.Context, mailboxName string, uids []uint32) ([]Message, error) {
 	msgs, ok := f.mailboxes[mailboxName]
 	if !ok {
 		return nil, errors.New("imap: postfach nicht gefunden")
 	}
 	wanted := make(map[uint32]bool, len(uids))
 	for _, u := range uids {
 		wanted[u] = true
 	}
 	var result []Message
 	for _, m := range msgs {
 		if wanted[m.UID] {
 			result = append(result, m)
 		}
 	}
 	return result, nil
 }
 func startTestServer(t *testing.T) (addr string, stop func()) {
 	t.Helper()
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	store := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {
 			{SequenceNumber: 1, UID: 101, Flags: []string{"\\Seen"}},
 			{SequenceNumber: 2, UID: 102, Flags: []string{}},
 		},
 	}}
 	srv := NewServer(auth, store)
 	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
 	}
 }
 // imapClient ist ein minimaler Testclient (Zeile senden, Antwort lesen)
 // — bewusst kein voller IMAP-Parser, nur genug, um Server-Antworten zu
 // prüfen.
 type imapClient struct {
 	conn   net.Conn
 	reader *bufio.Reader
 	tagN   int
 }
 func dial(t *testing.T, addr string) *imapClient {
 	t.Helper()
 	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
 	if err != nil {
 		t.Fatalf("dial: %v", err)
 	}
 	c := &imapClient{conn: conn, reader: bufio.NewReader(conn)}
 	c.readLine(t) // Begrüßung
 	return c
 }
 func (c *imapClient) readLine(t *testing.T) string {
 	t.Helper()
 	_ = c.conn.SetReadDeadline(time.Now().Add(3 * time.Second))
 	line, err := c.reader.ReadString('\n')
 	if err != nil {
 		t.Fatalf("antwort lesen: %v", err)
 	}
 	return strings.TrimRight(line, "\r\n")
 }
 // sendTagged sendet ein Kommando mit neuem Tag und liest Zeilen, bis die
 // getaggte Abschlusszeile kommt — liefert alle Zeilen (inkl. Abschluss).
 func (c *imapClient) sendTagged(t *testing.T, command string) (tag string, lines []string) {
 	t.Helper()
 	c.tagN++
 	tag = "A" + strconv.Itoa(c.tagN)
 	_, err := c.conn.Write([]byte(tag + " " + command + "\r\n"))
 	if err != nil {
 		t.Fatalf("kommando senden: %v", err)
 	}
 	for {
 		line := c.readLine(t)
 		lines = append(lines, line)
 		if strings.HasPrefix(line, tag+" ") {
 			return tag, lines
 		}
 	}
 }
 func (c *imapClient) close() { _ = c.conn.Close() }
 // TestSession_StateTransitionsAndForbiddenTransitions ist die geforderte
 // Pflichtprüfung 2: automatisierter Test deckt alle drei
 // Zustandsübergänge UND deren verbotene Übergänge ab.
 func TestSession_StateTransitionsAndForbiddenTransitions(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	// Verbotener Übergang: SELECT/FETCH in NotAuthenticated.
 	_, lines := c.sendTagged(t, `SELECT INBOX`)
 	if !strings.Contains(lines[len(lines)-1], "BAD") {
 		t.Fatalf("erwartete BAD für SELECT in NotAuthenticated, habe: %v", lines)
 	}
 	_, lines = c.sendTagged(t, `FETCH 1 (FLAGS)`)
 	if !strings.Contains(lines[len(lines)-1], "BAD") {
 		t.Fatalf("erwartete BAD für FETCH in NotAuthenticated, habe: %v", lines)
 	}
 	// NotAuthenticated -> Authenticated via LOGIN.
 	_, lines = c.sendTagged(t, `LOGIN alice geheim123`)
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK für LOGIN, habe: %v", lines)
 	}
 	// Verbotener Übergang: erneutes LOGIN in Authenticated.
 	_, lines = c.sendTagged(t, `LOGIN alice geheim123`)
 	if !strings.Contains(lines[len(lines)-1], "BAD") {
 		t.Fatalf("erwartete BAD für LOGIN in Authenticated, habe: %v", lines)
 	}
 	// Verbotener Übergang: FETCH in Authenticated (noch nicht Selected).
 	_, lines = c.sendTagged(t, `FETCH 1 (FLAGS)`)
 	if !strings.Contains(lines[len(lines)-1], "BAD") {
 		t.Fatalf("erwartete BAD für FETCH in Authenticated, habe: %v", lines)
 	}
 	// Authenticated -> Selected via SELECT.
 	_, lines = c.sendTagged(t, `SELECT INBOX`)
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK für SELECT, habe: %v", lines)
 	}
 	// In Selected sind SELECT (erneut) und FETCH erlaubt.
 	_, lines = c.sendTagged(t, `FETCH 1:2 (FLAGS)`)
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK für FETCH in Selected, habe: %v", lines)
 	}
 }
 // TestCommands_AllBaseCommandsAnswered ist die geforderte
 // Pflichtprüfung/AC2: Grundbefehle sind implementiert und beantwortet.
 func TestCommands_AllBaseCommandsAnswered(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	_, lines := c.sendTagged(t, "CAPABILITY")
 	if !containsSubstring(lines, "IMAP4rev1") {
 		t.Fatalf("CAPABILITY: erwartete IMAP4rev1 in antwort, habe: %v", lines)
 	}
 	_, lines = c.sendTagged(t, "LOGIN alice geheim123")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("LOGIN fehlgeschlagen: %v", lines)
 	}
 	_, lines = c.sendTagged(t, "SELECT INBOX")
 	if !containsSubstring(lines, "2 EXISTS") {
 		t.Fatalf("SELECT: erwartete '2 EXISTS', habe: %v", lines)
 	}
 	_, lines = c.sendTagged(t, "FETCH 1 (FLAGS)")
 	if !containsSubstring(lines, "FETCH (UID") {
 		t.Fatalf("FETCH: erwartete FLAGS-Antwort, habe: %v", lines)
 	}
 	tag, lines := c.sendTagged(t, "LOGOUT")
 	if !containsSubstring(lines, "BYE") {
 		t.Fatalf("LOGOUT: erwartete BYE, habe: %v", lines)
 	}
 	if !strings.HasPrefix(lines[len(lines)-1], tag+" OK") {
 		t.Fatalf("LOGOUT: erwartete getaggtes OK, habe: %v", lines)
 	}
 }
 // TestSession_InvalidCommandKeepsConnectionOpen ist die geforderte
 // Pflichtprüfung/AC3: ungültige Kommandosequenzen werden mit korrektem
 // Fehlercode abgelehnt, NICHT mit Verbindungsabbruch.
 func TestSession_InvalidCommandKeepsConnectionOpen(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	_, lines := c.sendTagged(t, "FRIMBULATOR")
 	if !strings.Contains(lines[len(lines)-1], "BAD") {
 		t.Fatalf("erwartete BAD für unbekanntes kommando, habe: %v", lines)
 	}
 	// Verbindung muss danach real weiter funktionieren (kein Abbruch).
 	_, lines = c.sendTagged(t, "CAPABILITY")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete funktionierende verbindung nach ungültigem kommando, habe: %v", lines)
 	}
 }
 // TestSession_MalformedLineDoesNotDisconnect deckt zusätzlich eine
 // syntaktisch fehlerhafte Zeile (kein Tag/Kommando erkennbar) ab.
 func TestSession_MalformedLineDoesNotDisconnect(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	_, err := c.conn.Write([]byte("\"unterminated\r\n"))
 	if err != nil {
 		t.Fatalf("senden: %v", err)
 	}
 	line := c.readLine(t)
 	if !strings.HasPrefix(line, "* BAD") {
 		t.Fatalf("erwartete '* BAD' für fehlerhafte zeile, habe: %q", line)
 	}
 	_, lines := c.sendTagged(t, "CAPABILITY")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete funktionierende verbindung nach fehlerhafter zeile, habe: %v", lines)
 	}
 }
 func containsSubstring(lines []string, sub string) bool {
 	for _, l := range lines {
 		if strings.Contains(l, sub) {
 			return true
 		}
 	}
 	return false
 }
 // TestServer_50ParallelSessionsNoLeak ist die geforderte Pflichtprüfung
 // 3: Lasttest mit 50 parallelen Sessions ohne Ressourcenleck.
 func TestServer_50ParallelSessionsNoLeak(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	const sessions = 50
 	var wg sync.WaitGroup
 	errCh := make(chan error, sessions)
 	for i := 0; i < sessions; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
 			if err != nil {
 				errCh <- err
 				return
 			}
 			defer func() { _ = conn.Close() }()
 			c := &imapClient{conn: conn, reader: bufio.NewReader(conn)}
 			c.readLine(t)
 			c.sendTagged(t, "LOGIN alice geheim123")
 			c.sendTagged(t, "SELECT INBOX")
 			c.sendTagged(t, "FETCH 1:2 (FLAGS)")
 			c.sendTagged(t, "LOGOUT")
 		}()
 	}
 	wg.Wait()
 	close(errCh)
 	for err := range errCh {
 		t.Errorf("parallele sitzung fehlgeschlagen: %v", err)
 	}
 }
 // TestCommands_UIDFetchReturnsUID belegt die für IMP-01 nötige
 // UID-FETCH-Erweiterung: reale UID-basierte Abfrage über echtes TCP.
 func TestCommands_UIDFetchReturnsUID(t *testing.T) {
 	addr, stop := startTestServer(t)
 	defer stop()
 	c := dial(t, addr)
 	defer c.close()
 	c.sendTagged(t, "LOGIN alice geheim123")
 	c.sendTagged(t, "SELECT INBOX")
 	_, lines := c.sendTagged(t, "UID FETCH 101:102 (FLAGS)")
 	if !containsSubstring(lines, "UID 101") || !containsSubstring(lines, "UID 102") {
 		t.Fatalf("erwartete beide UIDs in der antwort, habe: %v", lines)
 	}
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK-abschluss, habe: %v", lines)
 	}
 }
@@ -0,0 +1,48 @@
 // Package imap implementiert ING-01: das IMAP-Server-Grundgerüst
 // (TCP-Listener, Command-Parser, Session-Zustandsmaschine, Grundbefehle
 // CAPABILITY/LOGIN/SELECT/FETCH/LOGOUT). Bewusste Neuimplementierung nach
 // NEXARCH-Techstack, kein 1:1-Übernehmen von archivmail (siehe "Bekannte
 // Fehler vermeiden": Header-/Zeilen-Injection durch Stringkonkatenation
 // ohne CRLF-Prüfung — alle Antworten laufen ausschließlich über
 // writeLine/writeTagged, die eingebettete CR/LF im Text ersetzen, siehe
 // response.go).
 //
 // Authentifizierung (Authenticator) und Postfachzugriff (MailboxStore)
 // sind schmale Schnittstellen — echte Anbindung an Benutzerverwaltung/
 // Nachrichtenspeicher ist Sache späterer Ingestion-Tickets (IMP-01 u. a.,
 // siehe "Nicht Bestandteil dieser Kachel" im Ticket). Dieses Paket kennt
 // weder Core-IAM noch mail/internal/storage.
 package imap
 import "context"
 // Authenticator prüft Zugangsdaten für LOGIN.
 type Authenticator interface {
 	Authenticate(ctx context.Context, username, password string) (ok bool, err error)
 }
 // Message ist eine minimale Nachrichtendarstellung für FETCH (nur UID +
 // Flags, keine Inhalte — Inhaltszugriff ist Sache späterer Kacheln). UID
 // wird seit IMP-01 zusätzlich zur Sequenznummer geführt (RFC 3501 §2.3.1,
 // UID FETCH) — Grundlage für IMP-01s UID-basierten Delta-Sync.
 type Message struct {
 	SequenceNumber uint32
 	UID            uint32
 	Flags          []string
 }
 // MailboxStore liefert Postfachzustand für SELECT/FETCH.
 type MailboxStore interface {
 	// Select liefert die Anzahl der Nachrichten sowie die UIDVALIDITY
 	// (RFC 3501 §2.3.1.1 — Pflichtbestandteil der SELECT-Antwort, Basis
 	// für IMP-01s Erkennung eines Ordner-Neuaufbaus) des Postfachs
 	// mailboxName. ok=false, wenn das Postfach nicht existiert.
 	Select(ctx context.Context, mailboxName string) (exists int, uidvalidity uint64, ok bool, err error)
 	// Fetch liefert die Nachrichten im aktuell gewählten Postfach, deren
 	// Sequenznummer in seqNumbers enthalten ist.
 	Fetch(ctx context.Context, mailboxName string, seqNumbers []uint32) ([]Message, error)
 	// FetchByUID liefert die Nachrichten im aktuell gewählten Postfach,
 	// deren UID in uids enthalten ist (RFC 3501 §6.4.8, UID FETCH) — Basis
 	// für IMP-01s UID-Vergleich.
 	FetchByUID(ctx context.Context, mailboxName string, uids []uint32) ([]Message, error)
 }
@@ -0,0 +1,123 @@
 package imap
 import (
 	"bufio"
 	"context"
 	"fmt"
 	"net"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/loadtest"
 )
 // imapLoadtestConcurrency/imapLoadtestSessions — siehe pop3-Pendant für
 // die Begründung der Größenordnung (Akzeptanzkriterium 1, QA-07).
 const (
 	imapLoadtestConcurrency = 200
 	imapLoadtestSessions    = 2000
 )
 // Zielwerte (Akzeptanzkriterium 3, QA-07) — festgelegt VOR dem
 // entscheidenden Testlauf, siehe Prüfprotokoll QA-07 für die
 // Vorab-Messwerte auf 192.168.1.131.
 const (
 	imapTargetP95Latency    = 100 * time.Millisecond
 	imapTargetThroughputMin = 800.0 // Sessions/Sekunde
 )
 // TestLoadtest_IMAPParallelSessionsMeetTargets ist die geforderte
 // Pflichtprüfung 1+2 (QA-07).
 func TestLoadtest_IMAPParallelSessionsMeetTargets(t *testing.T) {
 	if testing.Short() {
 		t.Skip("lasttest übersprungen (-short)")
 	}
 	addr, stop := startTestServer(t)
 	defer stop()
 	resourcesBefore := loadtest.SampleResources()
 	result := loadtest.Run(context.Background(), "imap", imapLoadtestConcurrency, imapLoadtestSessions, func(ctx context.Context) error {
 		return runIMAPLoadSession(addr)
 	})
 	resourcesAfter := loadtest.SampleResources()
 	p50 := result.Percentile(0.50)
 	p95 := result.Percentile(0.95)
 	maxLatency := result.Max()
 	throughput := result.Throughput()
 	heapDeltaMB := float64(resourcesAfter.HeapAllocBytes-resourcesBefore.HeapAllocBytes) / (1024 * 1024)
 	cpuUsed := resourcesAfter.CPUTimeSeconds - resourcesBefore.CPUTimeSeconds
 	fmt.Printf("QA-07 IMAP-Lasttest: %d Sessions, %d parallel, Dauer %v\n", result.Sessions, result.Concurrency, result.Duration)
 	fmt.Printf("  Fehler: %d\n", result.Errors)
 	fmt.Printf("  Durchsatz: %.1f Sessions/s (Ziel: >= %.1f)\n", throughput, imapTargetThroughputMin)
 	fmt.Printf("  Latenz p50=%v p95=%v (Ziel: <= %v) max=%v\n", p50, p95, imapTargetP95Latency, maxLatency)
 	fmt.Printf("  Ressourcen: Heap-Delta=%.1f MiB, CPU-Zeit=%.2fs\n", heapDeltaMB, cpuUsed)
 	if result.Errors != 0 {
 		t.Fatalf("QA-07 IMAP: %d von %d sessions fehlgeschlagen", result.Errors, result.Sessions)
 	}
 	if p95 > imapTargetP95Latency {
 		t.Fatalf("QA-07 IMAP: p95-latenz %v überschreitet zielwert %v", p95, imapTargetP95Latency)
 	}
 	if throughput < imapTargetThroughputMin {
 		t.Fatalf("QA-07 IMAP: durchsatz %.1f sessions/s unter zielwert %.1f", throughput, imapTargetThroughputMin)
 	}
 	if heapDeltaMB > 100 {
 		t.Fatalf("QA-07 IMAP: heap-wachstum %.1f MiB deutet auf ressourcenleck hin", heapDeltaMB)
 	}
 }
 // runIMAPLoadSession führt eine vollständige, realistische IMAP-Session
 // über eine ROHE TCP-Verbindung aus (keine testing.T-Hilfsfunktionen,
 // die bei Fehlern t.Fatalf/goexit auslösen — in einer nebenläufigen
 // Lasttest-Worker-Goroutine unzulässig und würde den Fehler stillschweigend
 // verschlucken statt ihn zu zählen).
 func runIMAPLoadSession(addr string) error {
 	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
 	if err != nil {
 		return err
 	}
 	defer func() { _ = conn.Close() }()
 	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
 	reader := bufio.NewReader(conn)
 	if _, err := reader.ReadString('\n'); err != nil { // Begrüßung
 		return err
 	}
 	if _, err := sendTaggedRaw(conn, reader, "A1", "LOGIN alice geheim123"); err != nil {
 		return fmt.Errorf("LOGIN: %w", err)
 	}
 	if _, err := sendTaggedRaw(conn, reader, "A2", "SELECT INBOX"); err != nil {
 		return fmt.Errorf("SELECT: %w", err)
 	}
 	if _, err := sendTaggedRaw(conn, reader, "A3", "FETCH 1 (FLAGS)"); err != nil {
 		return fmt.Errorf("FETCH: %w", err)
 	}
 	_, err = sendTaggedRaw(conn, reader, "A4", "LOGOUT")
 	return err
 }
 // sendTaggedRaw sendet ein getaggtes Kommando und liest bis zur
 // getaggten Abschlusszeile; liefert einen Fehler, wenn diese kein "OK"
 // enthält.
 func sendTaggedRaw(conn net.Conn, reader *bufio.Reader, tag, command string) (lines []string, err error) {
 	if _, err := conn.Write([]byte(tag + " " + command + "\r\n")); err != nil {
 		return nil, err
 	}
 	for {
 		line, err := reader.ReadString('\n')
 		if err != nil {
 			return nil, err
 		}
 		line = strings.TrimRight(line, "\r\n")
 		lines = append(lines, line)
 		if strings.HasPrefix(line, tag+" ") {
 			if !strings.Contains(line, "OK") {
 				return lines, fmt.Errorf("unerwartete abschlussantwort: %q", line)
 			}
 			return lines, nil
 		}
 	}
 }
@@ -0,0 +1,81 @@
 package imap
 import (
 	"errors"
 	"strings"
 )
 // ErrMalformedCommand wird geliefert, wenn eine Kommandozeile nicht dem
 // Grundformat "Tag SP Kommando [SP Argumente]" entspricht. Kein
 // Verbindungsabbruch (Akzeptanzkriterium 3) — der Aufrufer antwortet mit
 // einer BAD-Antwort und liest die nächste Zeile.
 var ErrMalformedCommand = errors.New("imap: fehlerhafte kommandozeile")
 // command ist eine geparste IMAP-Kommandozeile.
 type command struct {
 	Tag  string
 	Name string // groß geschrieben (z. B. "LOGIN")
 	Args []string
 }
 // parseCommandLine zerlegt eine Kommandozeile (bereits ohne CRLF) in Tag,
 // Kommandoname und Argumente. Unterstützt Atome und doppelt zitierte
 // Zeichenketten (mit \"- und \\-Escape) — literale Zeichenketten
 // ({n}CRLF<n Bytes>) sind bewusst NICHT Bestandteil dieser kleinsten
 // Lösung (LOGIN/SELECT/FETCH kommen in Tests/typischen Clients ohne
 // Literale aus).
 func parseCommandLine(line string) (command, error) {
 	tokens, err := tokenize(line)
 	if err != nil {
 		return command{}, err
 	}
 	if len(tokens) < 2 {
 		return command{}, ErrMalformedCommand
 	}
 	return command{
 		Tag:  tokens[0],
 		Name: strings.ToUpper(tokens[1]),
 		Args: tokens[2:],
 	}, nil
 }
 // tokenize zerlegt line in durch Leerzeichen getrennte Tokens, wobei
 // doppelt zitierte Zeichenketten als EIN Token gelten (Leerzeichen darin
 // werden nicht als Trenner behandelt).
 func tokenize(line string) ([]string, error) {
 	var tokens []string
 	var current strings.Builder
 	inQuotes := false
 	escaped := false
 	hasToken := false
 	for _, r := range line {
 		switch {
 		case escaped:
 			current.WriteRune(r)
 			escaped = false
 			hasToken = true
 		case r == '\\' && inQuotes:
 			escaped = true
 		case r == '"':
 			inQuotes = !inQuotes
 			hasToken = true
 		case r == ' ' && !inQuotes:
 			if hasToken {
 				tokens = append(tokens, current.String())
 				current.Reset()
 				hasToken = false
 			}
 		default:
 			current.WriteRune(r)
 			hasToken = true
 		}
 	}
 	if inQuotes || escaped {
 		return nil, ErrMalformedCommand
 	}
 	if hasToken {
 		tokens = append(tokens, current.String())
 	}
 	return tokens, nil
 }
@@ -0,0 +1,135 @@
 package imap
 import (
 	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
 	"log/slog"
 	"net"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
 )
 func startLoggedTestServer(t *testing.T, logger *slog.Logger) (addr string, stop func()) {
 	t.Helper()
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	store := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {{SequenceNumber: 1, UID: 101, Flags: []string{}}},
 	}}
 	srv := NewServerWithGuardTLSAndLogger(auth, store, protoguard.DefaultConfig(), nil, logger)
 	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
 	}
 }
 func runFullSession(t *testing.T, addr string) {
 	t.Helper()
 	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)
 	_, _ = reader.ReadString('\n')
 	sendTaggedOn(t, conn, reader, "A1", "LOGIN alice geheim123")
 	sendTaggedOn(t, conn, reader, "A2", "SELECT INBOX")
 	sendTaggedOn(t, conn, reader, "A3", "LOGOUT")
 }
 // TestProtolog_RedactsCredentialsInRealSessionLog ist die geforderte
 // Pflichtprüfung 1 (ING-08) gegen den echten, laufenden IMAP-Server.
 func TestProtolog_RedactsCredentialsInRealSessionLog(t *testing.T) {
 	var buf bytes.Buffer
 	logger := slog.New(slog.NewJSONHandler(&buf, nil))
 	addr, stop := startLoggedTestServer(t, logger)
 	defer stop()
 	runFullSession(t, addr)
 	logged := buf.String()
 	if strings.Contains(logged, "geheim123") {
 		t.Fatalf("passwort im klartext im log gefunden:\n%s", logged)
 	}
 	if !strings.Contains(logged, "LOGIN [REDACTED]") {
 		t.Fatalf("erwartete redigierten LOGIN-eintrag im log, habe:\n%s", logged)
 	}
 }
 // TestProtolog_SessionFullyReconstructableByCorrelationID ist die
 // geforderte Pflichtprüfung 2 (ING-08).
 func TestProtolog_SessionFullyReconstructableByCorrelationID(t *testing.T) {
 	var buf bytes.Buffer
 	logger := slog.New(slog.NewJSONHandler(&buf, nil))
 	addr, stop := startLoggedTestServer(t, logger)
 	defer stop()
 	runFullSession(t, addr)
 	runFullSession(t, addr)
 	firstLine := strings.SplitN(buf.String(), "\n", 2)[0]
 	var raw map[string]any
 	if err := json.Unmarshal([]byte(firstLine), &raw); err != nil {
 		t.Fatalf("erste logzeile parsen: %v", err)
 	}
 	firstID, _ := raw["correlation_id"].(string)
 	if firstID == "" {
 		t.Fatalf("keine correlation_id in erster logzeile: %s", firstLine)
 	}
 	entries, err := protolog.Reconstruct(bytes.NewReader(buf.Bytes()), firstID)
 	if err != nil {
 		t.Fatalf("Reconstruct: %v", err)
 	}
 	// session_start, 3 kommandos (LOGIN/SELECT/LOGOUT), session_end.
 	if len(entries) != 5 {
 		t.Fatalf("erwartete 5 lückenlose einträge für die session, habe %d: %+v", len(entries), entries)
 	}
 	if entries[0].Msg != "session_start" || entries[len(entries)-1].Msg != "session_end" {
 		t.Fatalf("session nicht lückenlos rekonstruierbar: %+v", entries)
 	}
 }
 // TestProtolog_LoggingDoesNotRelevantlyImpactThroughput ist die
 // geforderte Pflichtprüfung 3 (ING-08).
 func TestProtolog_LoggingDoesNotRelevantlyImpactThroughput(t *testing.T) {
 	const sessions = 100
 	addrOff, stopOff := startLoggedTestServer(t, nil)
 	startOff := time.Now()
 	for i := 0; i < sessions; i++ {
 		runFullSession(t, addrOff)
 	}
 	durationOff := time.Since(startOff)
 	stopOff()
 	var buf bytes.Buffer
 	logger := slog.New(slog.NewJSONHandler(&buf, nil))
 	addrOn, stopOn := startLoggedTestServer(t, logger)
 	startOn := time.Now()
 	for i := 0; i < sessions; i++ {
 		runFullSession(t, addrOn)
 	}
 	durationOn := time.Since(startOn)
 	stopOn()
 	if durationOn > 3*durationOff+5*time.Millisecond {
 		t.Fatalf("logging verlangsamt durchsatz relevant: ohne=%v, mit=%v", durationOff, durationOn)
 	}
 }
@@ -0,0 +1,129 @@
 package imap
 import (
 	"context"
 	"net"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 func startRateLimitedServer(t *testing.T, tenant string, limiter *ratelimit.Limiter) (addr string, stop func()) {
 	t.Helper()
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	store := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {{SequenceNumber: 1, UID: 1, Flags: []string{}}},
 	}}
 	srv := NewServerWithGuardTLSLoggerAndRateLimit(auth, store, protoguard.DefaultConfig(), nil, nil, tenant, limiter)
 	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
 	}
 }
 // attemptLogin führt LOGIN über eine NEUE Verbindung aus und liefert
 // die Abschlusszeile.
 func attemptLogin(t *testing.T, addr string) string {
 	t.Helper()
 	c := dial(t, addr)
 	defer c.close()
 	_, lines := c.sendTagged(t, "LOGIN alice geheim123")
 	return lines[len(lines)-1]
 }
 // TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint ist die
 // geforderte Pflichtprüfung 1 (ING-09).
 func TestRateLimit_LoadExceedingLimitGetsRejectedWithRetryHint(t *testing.T) {
 	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
 		Default: ratelimit.Config{Burst: 5, RefillEvery: time.Hour},
 	})
 	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
 	defer stop()
 	const attempts = 20
 	var accepted, rejected int
 	for i := 0; i < attempts; i++ {
 		last := attemptLogin(t, addr)
 		switch {
 		case strings.Contains(last, "OK"):
 			accepted++
 		case strings.Contains(last, "NO") && strings.Contains(last, "rate limit"):
 			rejected++
 		default:
 			t.Fatalf("unerwartete abschlussantwort: %q", last)
 		}
 	}
 	if accepted != 5 {
 		t.Fatalf("erwartete genau 5 akzeptierte versuche (burst), habe %d", accepted)
 	}
 	if rejected != attempts-5 {
 		t.Fatalf("erwartete %d abgelehnte versuche, habe %d", attempts-5, rejected)
 	}
 }
 // TestRateLimit_LegitUsageBelowThresholdUnaffected ist die geforderte
 // Pflichtprüfung 2 (ING-09).
 func TestRateLimit_LegitUsageBelowThresholdUnaffected(t *testing.T) {
 	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
 		Default: ratelimit.Config{Burst: 10, RefillEvery: time.Second},
 	})
 	addr, stop := startRateLimitedServer(t, "mandant-a", limiter)
 	defer stop()
 	for i := 0; i < 3; i++ {
 		last := attemptLogin(t, addr)
 		if !strings.Contains(last, "OK") {
 			t.Fatalf("versuch %d unterhalb der schwelle wurde abgelehnt: %q", i+1, last)
 		}
 	}
 }
 // TestRateLimit_PerTenantIndependentAndEffective ist die geforderte
 // Pflichtprüfung 3 (ING-09).
 func TestRateLimit_PerTenantIndependentAndEffective(t *testing.T) {
 	limiter := ratelimit.NewLimiter(ratelimit.StaticConfig{
 		Default: ratelimit.Config{Burst: 2, RefillEvery: time.Hour},
 		PerTenant: map[string]ratelimit.Config{
 			"mandant-grosszuegig": {Burst: 8, RefillEvery: time.Hour},
 		},
 	})
 	addrKnapp, stopKnapp := startRateLimitedServer(t, "mandant-knapp", limiter)
 	defer stopKnapp()
 	addrGross, stopGross := startRateLimitedServer(t, "mandant-grosszuegig", limiter)
 	defer stopGross()
 	var acceptedKnapp int
 	for i := 0; i < 10; i++ {
 		if strings.Contains(attemptLogin(t, addrKnapp), "OK") {
 			acceptedKnapp++
 		}
 	}
 	var acceptedGross int
 	for i := 0; i < 10; i++ {
 		if strings.Contains(attemptLogin(t, addrGross), "OK") {
 			acceptedGross++
 		}
 	}
 	if acceptedKnapp != 2 {
 		t.Fatalf("mandant-knapp: erwartete 2 akzeptierte versuche, habe %d", acceptedKnapp)
 	}
 	if acceptedGross != 8 {
 		t.Fatalf("mandant-grosszuegig: erwartete 8 akzeptierte versuche, habe %d", acceptedGross)
 	}
 }
@@ -0,0 +1,38 @@
 package imap
 import (
 	"bufio"
 	"strings"
 )
 // sanitizeResponseText entfernt eingebettete CR/LF aus text, BEVOR er in
 // eine Antwortzeile eingebettet wird (Bekannter Fehler vermeiden:
 // archivmail erlaubte Header-/Zeilen-Injection durch Stringkonkatenation
 // ohne CRLF-Prüfung — jede Antwortzeile dieses Pakets läuft durch diese
 // Funktion, niemals direkte Interpolation von Nutzereingaben in eine
 // Rohantwort).
 func sanitizeResponseText(text string) string {
 	text = strings.ReplaceAll(text, "\r", "")
 	text = strings.ReplaceAll(text, "\n", "")
 	return text
 }
 // writeUntagged schreibt eine Server-Antwort ohne Tag ("* ...").
 func writeUntagged(w *bufio.Writer, text string) error {
 	_, err := w.WriteString("* " + sanitizeResponseText(text) + "\r\n")
 	if err != nil {
 		return err
 	}
 	return w.Flush()
 }
 // writeTagged schreibt eine getaggte Server-Antwort ("<tag> OK/NO/BAD ...").
 // tag wird ebenfalls saniert — ein Tag mit eingebettetem CRLF ist genauso
 // eine Injektionsgefahr wie der Antworttext.
 func writeTagged(w *bufio.Writer, tag, status, text string) error {
 	_, err := w.WriteString(sanitizeResponseText(tag) + " " + status + " " + sanitizeResponseText(text) + "\r\n")
 	if err != nil {
 		return err
 	}
 	return w.Flush()
 }
@@ -0,0 +1,88 @@
 package imap
 import (
 	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/ratelimit"
 )
 // Server nimmt IMAP-Verbindungen an und bedient jede in einer eigenen
 // Goroutine (Akzeptanzkriterium 1). tlsConfig ist optional (ING-06):
 // nil bedeutet Klartextbetrieb wie vor ING-06 (z. B. hinter einem
 // separaten TLS-Terminator oder in Tests); ist tlsConfig gesetzt,
 // verlangt LOGIN zwingend STARTTLS oder eine bereits per implizitem
 // TLS-Listener verschlüsselte Verbindung (Akzeptanzkriterium 1).
 type Server struct {
 	auth      Authenticator
 	store     MailboxStore
 	guardCfg  protoguard.Config
 	tlsConfig *tls.Config
 	logger    *slog.Logger
 	tenantID     string
 	loginLimiter *ratelimit.Limiter
 }
 func NewServer(auth Authenticator, store MailboxStore) *Server {
 	return NewServerWithGuardConfig(auth, store, protoguard.DefaultConfig())
 }
 // NewServerWithGuardConfig erlaubt abweichende Phase-Timeouts und
 // Backoff-Parameter (ING-07), z. B. für Tests oder gehärtete
 // Betriebsumgebungen.
 func NewServerWithGuardConfig(auth Authenticator, store MailboxStore, guardCfg protoguard.Config) *Server {
 	return &Server{auth: auth, store: store, guardCfg: guardCfg}
 }
 // NewServerWithGuardAndTLSConfig erlaubt zusätzlich, STARTTLS/TLS zu
 // aktivieren (ING-06). tlsConfig sollte über tlscert.Store.Config()
 // erzeugt werden.
 func NewServerWithGuardAndTLSConfig(auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config) *Server {
 	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig}
 }
 // NewServerWithGuardTLSAndLogger erlaubt zusätzlich strukturiertes
 // Protokoll-Logging (ING-08). logger darf nil sein (Logging dann
 // deaktiviert, Rückwärtskompatibilität zu ING-01..ING-07).
 func NewServerWithGuardTLSAndLogger(auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger) *Server {
 	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger}
 }
 // NewServerWithGuardTLSLoggerAndRateLimit erlaubt zusätzlich
 // Rate-Limiting für LOGIN-Versuche (ING-09). loginLimiter darf nil sein
 // (Rate-Limiting dann deaktiviert). tenantID identifiziert diesen
 // Server gegenüber dem Limiter (Akzeptanzkriterium 3).
 func NewServerWithGuardTLSLoggerAndRateLimit(auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Server {
 	return &Server{auth: auth, store: store, guardCfg: guardCfg, tlsConfig: tlsConfig, logger: logger, tenantID: tenantID, loginLimiter: loginLimiter}
 }
 // Serve nimmt Verbindungen auf listener an, bis ctx beendet wird oder
 // Accept endgültig fehlschlägt. Blockiert den Aufrufer.
 func (srv *Server) Serve(ctx context.Context, listener net.Listener) error {
 	go func() {
 		<-ctx.Done()
 		_ = listener.Close()
 	}()
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
 			if ctx.Err() != nil {
 				return nil // beabsichtigtes Herunterfahren
 			}
 			var netErr net.Error
 			if errors.As(err, &netErr) && netErr.Timeout() {
 				continue
 			}
 			return fmt.Errorf("imap: verbindung annehmen: %w", err)
 		}
 		session := newSession(conn, srv.auth, srv.store, srv.guardCfg, srv.tlsConfig, srv.logger, srv.tenantID, srv.loginLimiter)
 		go session.Serve(ctx)
 	}
 }
@@ -0,0 +1,190 @@
 package imap
 import (
 	"bufio"
 	"context"
 	"crypto/tls"
 	"errors"
 	"io"
 	"log/slog"
 	"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"
 )
 // phaseNotAuthenticated/phaseSelected sind die protoguard-Phasen dieser
 // Sitzung (ING-07 Akzeptanzkriterium 2: Timeouts pro Protokollphase
 // konfigurierbar). Authenticated und Selected teilen sich denselben
 // Timeout — beides ist bereits angemeldeter Zustand, nur die
 // Anmeldephase braucht separate (typischerweise kürzere) Werte.
 const (
 	phaseNotAuthenticated protoguard.Phase = "not_authenticated"
 	phaseSelected         protoguard.Phase = "selected"
 )
 // maxCommandLineBytes begrenzt eine einzelne Kommandozeile (Defensive
 // Fehlerbehandlung bei nicht-konformen Gegenstellen statt optimistischem
 // Parsing, siehe Ticket-Vorbild Dovecot) — verhindert unbegrenztes
 // Pufferwachstum durch eine Gegenstelle, die niemals CRLF sendet.
 const maxCommandLineBytes = 8192
 // Session ist eine einzelne IMAP-Verbindung mit eigener
 // Zustandsmaschine (Akzeptanzkriterium 1).
 type Session struct {
 	conn      net.Conn
 	reader    *bufio.Reader
 	writer    *bufio.Writer
 	auth      Authenticator
 	store     MailboxStore
 	guard     *protoguard.Guard
 	tlsConfig *tls.Config // nil = kein TLS/STARTTLS angeboten (ING-06)
 	tlsActive bool
 	log       *protolog.SessionLogger // ING-08, nie nil (log.Event() ist nil-sicher)
 	tenantID     string
 	loginLimiter *ratelimit.Limiter // ING-09, nil = kein Rate-Limiting
 	state       State
 	mailbox     string // gewähltes Postfach im Zustand Selected
 	mailboxSize uint32 // Nachrichtenzahl aus dem letzten erfolgreichen SELECT
 }
 func newSession(conn net.Conn, auth Authenticator, store MailboxStore, guardCfg protoguard.Config, tlsConfig *tls.Config, logger *slog.Logger, tenantID string, loginLimiter *ratelimit.Limiter) *Session {
 	_, alreadyTLS := conn.(*tls.Conn)
 	return &Session{
 		conn:         conn,
 		reader:       bufio.NewReaderSize(conn, maxCommandLineBytes),
 		writer:       bufio.NewWriter(conn),
 		auth:         auth,
 		store:        store,
 		guard:        protoguard.New(guardCfg),
 		tlsConfig:    tlsConfig,
 		tlsActive:    alreadyTLS,
 		log:          protolog.NewSessionLogger(logger, "imap"),
 		tenantID:     tenantID,
 		loginLimiter: loginLimiter,
 		state:        NotAuthenticated,
 	}
 }
 // sourceAddr liefert die Quell-IP dieser Verbindung ohne Portanteil
 // (ING-09).
 func (s *Session) sourceAddr() string {
 	host, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
 	if err != nil {
 		return s.conn.RemoteAddr().String()
 	}
 	return host
 }
 // currentPhase liefert die protoguard-Phase des aktuellen Sitzungszustands.
 func (s *Session) currentPhase() protoguard.Phase {
 	if s.state == NotAuthenticated {
 		return phaseNotAuthenticated
 	}
 	return phaseSelected
 }
 // State liefert den aktuellen Sitzungszustand (für Tests).
 func (s *Session) State() State { return s.state }
 // Serve führt die Sitzung bis LOGOUT oder Verbindungsende aus.
 func (s *Session) Serve(ctx context.Context) {
 	defer func() { _ = s.conn.Close() }()
 	// Akzeptanzkriterium 1 (ING-08): strukturierte Logs mit
 	// Korrelations-ID über die gesamte Verbindungsdauer.
 	s.log.Event(ctx, "session_start", slog.String("remote_addr", s.conn.RemoteAddr().String()))
 	defer s.log.Event(ctx, "session_end")
 	if err := writeUntagged(s.writer, "OK IMAP4rev1 Service Ready"); err != nil {
 		return
 	}
 	for {
 		// Akzeptanzkriterium 2 (ING-07): Idle-Timeout pro Protokollphase,
 		// vor jedem Lesevorgang neu gesetzt, da ein Zustandswechsel die
 		// Phase (und damit den geltenden Timeout) ändern kann.
 		if err := s.guard.ApplyReadDeadline(s.conn, s.currentPhase()); err != nil {
 			return
 		}
 		line, err := s.readLine()
 		if err != nil {
 			// Verbindungsende (Timeout, Netzwerkabbruch oder harter
 			// Abbruch) — Session-Ressourcen werden über das defer
 			// conn.Close() oben zuverlässig freigegeben
 			// (Akzeptanzkriterium 1).
 			return
 		}
 		if line == "" {
 			continue
 		}
 		cmd, parseErr := parseCommandLine(line)
 		if parseErr != nil {
 			// Akzeptanzkriterium 3: ungültige Kommandosequenz -> Fehlercode,
 			// KEIN Verbindungsabbruch.
 			if err := writeUntagged(s.writer, "BAD Error in IMAP command received by server."); err != nil {
 				return
 			}
 			continue
 		}
 		// Akzeptanzkriterium 2 (ING-08): LOGIN-Argumente (Passwort)
 		// erscheinen über RedactCommandLine nie im Klartext im Log.
 		s.log.Event(ctx, "command", slog.String("command", protolog.RedactCommandLine(cmd.Name, cmd.Args)))
 		if !s.dispatch(ctx, cmd) {
 			return // LOGOUT oder nicht behebbarer Schreibfehler
 		}
 	}
 }
 // readLine liest eine CRLF- (oder LF-)terminierte Zeile ohne
 // Zeilenumbruch. Überlange Zeilen (siehe maxCommandLineBytes) werden als
 // Fehler behandelt statt unbegrenzt zu puffern.
 func (s *Session) readLine() (string, error) {
 	line, err := s.reader.ReadString('\n')
 	if err != nil {
 		if errors.Is(err, io.EOF) && line != "" {
 			// Letzte Zeile ohne abschließendes LF — als vollständige Zeile
 			// behandeln, danach ohnehin Verbindungsende.
 			return strings.TrimRight(line, "\r"), nil
 		}
 		return "", err
 	}
 	return strings.TrimRight(line, "\r\n"), nil
 }
 // dispatch verarbeitet EIN geparstes Kommando. Rückgabewert false
 // bedeutet: Sitzung beenden (LOGOUT abgeschlossen oder Schreibfehler).
 func (s *Session) dispatch(ctx context.Context, cmd command) bool {
 	switch cmd.Name {
 	case "CAPABILITY":
 		return s.handleCapability(cmd)
 	case "LOGIN":
 		return s.handleLogin(ctx, cmd)
 	case "SELECT":
 		return s.handleSelect(ctx, cmd)
 	case "FETCH":
 		return s.handleFetch(ctx, cmd)
 	case "UID":
 		if len(cmd.Args) < 1 || strings.ToUpper(cmd.Args[0]) != "FETCH" {
 			return s.writeErr(cmd.Tag, "BAD", "Unsupported UID subcommand")
 		}
 		return s.handleUIDFetch(ctx, cmd)
 	case "LOGOUT":
 		return s.handleLogout(cmd)
 	case "STARTTLS":
 		return s.handleStartTLS(ctx, cmd)
 	default:
 		return s.writeErr(cmd.Tag, "BAD", "Unknown command")
 	}
 }
 func (s *Session) writeErr(tag, status, text string) bool {
 	return writeTagged(s.writer, tag, status, text) == nil
 }
@@ -0,0 +1,24 @@
 package imap
 // State ist eine der drei IMAP4rev1-Session-Zustände (RFC 3501 §3),
 // Akzeptanzkriterium 1.
 type State int
 const (
 	NotAuthenticated State = iota
 	Authenticated
 	Selected
 )
 func (s State) String() string {
 	switch s {
 	case NotAuthenticated:
 		return "not authenticated"
 	case Authenticated:
 		return "authenticated"
 	case Selected:
 		return "selected"
 	default:
 		return "unknown"
 	}
 }
@@ -0,0 +1,71 @@
 package imap
 import (
 	"context"
 	"net"
 	"strings"
 	"testing"
 )
 // TestTenantScoping_IsolatedStoresNeverLeakAcrossServers ist die
 // geforderte Pflichtprüfung (ING-10, Akzeptanzkriterium 2): Tenant-
 // Scoping für den IMAP-Ingestion-Pfad. Zwei vollständig unabhängige
 // Server-Instanzen (Mandant A/B) mit identischem Benutzernamen/Passwort
 // und identischem Postfachnamen "INBOX", aber unterschiedlichem Inhalt
 // (als Flag codiert, damit ein FETCH ihn sichtbar macht) — Bug würde
 // sich hier als Vermischung der Flags zeigen.
 func TestTenantScoping_IsolatedStoresNeverLeakAcrossServers(t *testing.T) {
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	storeA := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {{SequenceNumber: 1, UID: 1, Flags: []string{"Mandant-A-Marker"}}},
 	}}
 	storeB := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {{SequenceNumber: 1, UID: 1, Flags: []string{"Mandant-B-Marker"}}},
 	}}
 	addrA, stopA := startIMAPServer(t, NewServer(auth, storeA))
 	defer stopA()
 	addrB, stopB := startIMAPServer(t, NewServer(auth, storeB))
 	defer stopB()
 	fetchA := fetchInboxFlags(t, addrA)
 	fetchB := fetchInboxFlags(t, addrB)
 	if !strings.Contains(fetchA, "Mandant-A-Marker") {
 		t.Fatalf("mandant A hat nicht seine eigenen daten bekommen: %q", fetchA)
 	}
 	if !strings.Contains(fetchB, "Mandant-B-Marker") {
 		t.Fatalf("mandant B hat nicht seine eigenen daten bekommen: %q", fetchB)
 	}
 	if strings.Contains(fetchA, "Mandant-B-Marker") || strings.Contains(fetchB, "Mandant-A-Marker") {
 		t.Fatalf("mandantenvermischung: A=%q B=%q", fetchA, fetchB)
 	}
 }
 func startIMAPServer(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
 	}
 }
 func fetchInboxFlags(t *testing.T, addr string) string {
 	t.Helper()
 	c := dial(t, addr)
 	defer c.close()
 	c.sendTagged(t, "LOGIN alice geheim123")
 	c.sendTagged(t, "SELECT INBOX")
 	_, lines := c.sendTagged(t, "FETCH 1 (FLAGS)")
 	return strings.Join(lines, "\n")
 }
@@ -0,0 +1,182 @@
 package imap
 import (
 	"bufio"
 	"context"
 	"crypto/tls"
 	"net"
 	"strings"
 	"testing"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/tlscert"
 )
 func startTLSTestServer(t *testing.T, tlsConfig *tls.Config) (addr string, stop func()) {
 	t.Helper()
 	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
 	store := fakeMailboxStore{mailboxes: map[string][]Message{
 		"INBOX": {{SequenceNumber: 1, UID: 101, Flags: []string{}}},
 	}}
 	srv := NewServerWithGuardAndTLSConfig(auth, store, protoguard.DefaultConfig(), tlsConfig)
 	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
 	}
 }
 // sendTaggedOn sendet ein getaggtes Kommando über einen beliebigen
 // net.Conn (Klartext oder TLS) und liest bis zur getaggten
 // Abschlusszeile.
 func sendTaggedOn(t *testing.T, conn net.Conn, reader *bufio.Reader, tag, command string) (lines []string) {
 	t.Helper()
 	if _, err := conn.Write([]byte(tag + " " + command + "\r\n")); err != nil {
 		t.Fatalf("kommando senden: %v", err)
 	}
 	for {
 		_ = conn.SetReadDeadline(time.Now().Add(3 * time.Second))
 		line, err := reader.ReadString('\n')
 		if err != nil {
 			t.Fatalf("antwort lesen: %v", err)
 		}
 		line = strings.TrimRight(line, "\r\n")
 		lines = append(lines, line)
 		if strings.HasPrefix(line, tag+" ") {
 			return lines
 		}
 	}
 }
 // TestLogin_RequiresTLS ist die geforderte Pflichtprüfung 2 (ING-06):
 // Login-Versuch ohne TLS/STARTTLS wird verweigert, sobald der Server
 // TLS anbietet (Akzeptanzkriterium 1).
 func TestLogin_RequiresTLS(t *testing.T) {
 	cert, err := tlscert.GenerateSelfSigned("127.0.0.1")
 	if err != nil {
 		t.Fatalf("testzertifikat erzeugen: %v", err)
 	}
 	store := tlscert.NewStore(cert)
 	addr, stop := startTLSTestServer(t, store.Config())
 	defer stop()
 	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)
 	_, _ = reader.ReadString('\n')
 	lines := sendTaggedOn(t, conn, reader, "A1", "LOGIN alice geheim123")
 	last := lines[len(lines)-1]
 	if !strings.Contains(last, "NO") {
 		t.Fatalf("erwartete NO (TLS erforderlich), habe: %v", lines)
 	}
 }
 // TestStartTLS_UpgradesConnectionAndAllowsLogin belegt, dass LOGIN nach
 // erfolgreichem STARTTLS akzeptiert wird.
 func TestStartTLS_UpgradesConnectionAndAllowsLogin(t *testing.T) {
 	cert, err := tlscert.GenerateSelfSigned("127.0.0.1")
 	if err != nil {
 		t.Fatalf("testzertifikat erzeugen: %v", err)
 	}
 	store := tlscert.NewStore(cert)
 	addr, stop := startTLSTestServer(t, store.Config())
 	defer stop()
 	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)
 	_, _ = reader.ReadString('\n')
 	lines := sendTaggedOn(t, conn, reader, "A1", "STARTTLS")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK für STARTTLS, habe: %v", lines)
 	}
 	tlsConn := tls.Client(conn, &tls.Config{InsecureSkipVerify: true})
 	if err := tlsConn.Handshake(); err != nil {
 		t.Fatalf("tls-handshake: %v", err)
 	}
 	tlsReader := bufio.NewReader(tlsConn)
 	lines = sendTaggedOn(t, tlsConn, tlsReader, "A2", "LOGIN alice geheim123")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erwartete OK nach STARTTLS, habe: %v", lines)
 	}
 }
 // TestTLS_CertificateRotationWithoutDroppingExistingSessions ist die
 // geforderte Pflichtprüfung 3 (ING-06): eine bereits etablierte
 // TLS-Session bleibt nach einer Zertifikatsrotation nutzbar, eine NEUE
 // Verbindung bekommt das neue Zertifikat.
 func TestTLS_CertificateRotationWithoutDroppingExistingSessions(t *testing.T) {
 	certA, err := tlscert.GenerateSelfSigned("127.0.0.1")
 	if err != nil {
 		t.Fatalf("zertifikat a erzeugen: %v", err)
 	}
 	certB, err := tlscert.GenerateSelfSigned("127.0.0.1")
 	if err != nil {
 		t.Fatalf("zertifikat b erzeugen: %v", err)
 	}
 	store := tlscert.NewStore(certA)
 	addr, stop := startTLSTestServer(t, store.Config())
 	defer stop()
 	firstConn, err := net.DialTimeout("tcp", addr, 2*time.Second)
 	if err != nil {
 		t.Fatalf("dial 1: %v", err)
 	}
 	defer func() { _ = firstConn.Close() }()
 	r1 := bufio.NewReader(firstConn)
 	_, _ = r1.ReadString('\n')
 	sendTaggedOn(t, firstConn, r1, "A1", "STARTTLS")
 	firstTLS := tls.Client(firstConn, &tls.Config{InsecureSkipVerify: true})
 	if err := firstTLS.Handshake(); err != nil {
 		t.Fatalf("tls-handshake 1: %v", err)
 	}
 	if string(firstTLS.ConnectionState().PeerCertificates[0].Raw) != string(certA.Certificate[0]) {
 		t.Fatalf("erste verbindung hätte zertifikat a bekommen sollen")
 	}
 	store.Replace(certB)
 	secondConn, err := net.DialTimeout("tcp", addr, 2*time.Second)
 	if err != nil {
 		t.Fatalf("dial 2: %v", err)
 	}
 	defer func() { _ = secondConn.Close() }()
 	r2 := bufio.NewReader(secondConn)
 	_, _ = r2.ReadString('\n')
 	sendTaggedOn(t, secondConn, r2, "A1", "STARTTLS")
 	secondTLS := tls.Client(secondConn, &tls.Config{InsecureSkipVerify: true})
 	if err := secondTLS.Handshake(); err != nil {
 		t.Fatalf("tls-handshake 2: %v", err)
 	}
 	if string(secondTLS.ConnectionState().PeerCertificates[0].Raw) != string(certB.Certificate[0]) {
 		t.Fatalf("zweite verbindung hätte NACH der rotation zertifikat b bekommen sollen")
 	}
 	// Erste, bereits etablierte Verbindung bleibt ungestört nutzbar.
 	tlsReader1 := bufio.NewReader(firstTLS)
 	lines := sendTaggedOn(t, firstTLS, tlsReader1, "A2", "LOGIN alice geheim123")
 	if !strings.Contains(lines[len(lines)-1], "OK") {
 		t.Fatalf("erste verbindung nach rotation nicht mehr funktionsfähig: %v", lines)
 	}
 }
@@ -0,0 +1,24 @@
 package imapimport
 import "context"
 // RemoteMessage ist eine über IMAP abgerufene Nachricht (nur UID/Flags —
 // Inhaltsabruf ist Sache späterer Kacheln, siehe "Nicht Bestandteil
 // dieser Kachel": IMP-02 Anhangsverarbeitung u. a.).
 type RemoteMessage struct {
 	UID   uint32
 	Flags []string
 }
 // IMAPClient abstrahiert den Protokollzugriff auf ein entferntes
 // Postfach — schmale Schnittstelle, damit die Delta-Sync-Logik
 // (scheduler.go) ohne echte Netzwerkverbindung testbar ist (gleiche
 // Konvention wie KEKProvider/Authenticator in anderen Mail-Paketen).
 // Eine reale, wire-level-IMAP4rev1-Implementierung liegt in client_real.go.
 type IMAPClient interface {
 	// Sync liefert die aktuelle UIDVALIDITY des Postfachs sowie ALLE
 	// darin vorhandenen Nachrichten (UID + Flags). Der Aufrufer
 	// (Scheduler) entscheidet anhand des persistierten Zustands, welche
 	// davon neu sind.
 	Sync(ctx context.Context, mailbox string) (uidvalidity uint64, messages []RemoteMessage, err error)
 }
@@ -0,0 +1,251 @@
 // IMP-04: defensive Fehlerbehandlung nicht-konformer Server. Bekannten
 // Fehler vermeiden (siehe known-issues-archivmail.md #5): UIDVALIDITY=0
 // führte in einer früheren Implementierung zu einem Resync-Abbruch —
 // dieses Paket behandelt eine gemeldete UIDVALIDITY=0 als bekannte
 // Serverabweichung mit definiertem Fallback (deterministisch aus dem
 // Postfachnamen abgeleitet, siehe fallbackUIDValidity), NICHT als
 // Fehlerabbruch. Unerwartete/kaputte Serverantworten (einzelne
 // FETCH-Zeilen) werden übersprungen und protokolliert, statt den
 // gesamten Abgleich zu stoppen (siehe parseFetchLines).
 //
 // Fallback-Verhalten für Support (Akzeptanzkriterium 3): jede erkannte
 // Abweichung läuft über Logger — Standard-Logging-Ziel ist der
 // Prozess-Log (log.Printf), bei Bedarf per WithLogger umleitbar/
 // abschaltbar. Log-Präfix ist immer "imapimport: unerwartete
 // server-antwort" bzw. "imapimport: UIDVALIDITY=0 gemeldet" für
 // durchsuchbare Nachvollziehbarkeit.
 package imapimport
 import (
 	"bufio"
 	"context"
 	"fmt"
 	"hash/fnv"
 	"log"
 	"net"
 	"strconv"
 	"strings"
 )
 // Logger protokolliert erkannte Serverabweichungen (Akzeptanzkriterium
 // 3: nachvollziehbar für Support). Signatur kompatibel mit log.Printf.
 type Logger func(format string, args ...any)
 func defaultLogger(format string, args ...any) {
 	log.Printf(format, args...)
 }
 // RealClient spricht echtes IMAP4rev1 (RFC 3501) über TCP — genutzt für
 // den realistischen Testpostfach-Nachweis (IMP-01 Pflichtprüfung 3) gegen
 // den echten ING-01-Server, und produktiv gegen jeden RFC-3501-konformen
 // IMAP-Server. Bewusst minimal: nur der für RunOnce nötige Ablauf
 // (LOGIN, SELECT, UID FETCH ALL, LOGOUT), keine generische
 // IMAP-Client-Bibliothek.
 type RealClient struct {
 	addr     string
 	username string
 	password string
 	dialer   net.Dialer
 	logger   Logger
 }
 func NewRealClient(addr, username, password string) *RealClient {
 	return &RealClient{addr: addr, username: username, password: password, logger: defaultLogger}
 }
 // WithLogger ersetzt das Standard-Logging-Ziel (z. B. für Tests, die die
 // protokollierten Meldungen prüfen wollen, oder um es abzuschalten).
 func (c *RealClient) WithLogger(logger Logger) *RealClient {
 	c.logger = logger
 	return c
 }
 func (c *RealClient) log(format string, args ...any) {
 	if c.logger != nil {
 		c.logger(format, args...)
 	}
 }
 func (c *RealClient) Sync(ctx context.Context, mailbox string) (uint64, []RemoteMessage, error) {
 	conn, err := c.dialer.DialContext(ctx, "tcp", c.addr)
 	if err != nil {
 		return 0, nil, fmt.Errorf("imapimport: verbindung aufbauen: %w", err)
 	}
 	defer func() { _ = conn.Close() }()
 	if deadline, ok := ctx.Deadline(); ok {
 		_ = conn.SetDeadline(deadline)
 	}
 	reader := bufio.NewReader(conn)
 	// Begrüßung.
 	if _, err := readLine(reader); err != nil {
 		return 0, nil, fmt.Errorf("imapimport: begrüßung lesen: %w", err)
 	}
 	if _, err := sendCommand(conn, reader, 1, "LOGIN "+c.username+" "+c.password); err != nil {
 		return 0, nil, fmt.Errorf("imapimport: login: %w", err)
 	}
 	selectLines, err := sendCommand(conn, reader, 2, "SELECT "+mailbox)
 	if err != nil {
 		return 0, nil, fmt.Errorf("imapimport: select: %w", err)
 	}
 	uidvalidity, err := c.resolveUIDValidity(selectLines, mailbox)
 	if err != nil {
 		return 0, nil, err
 	}
 	fetchLines, err := sendCommand(conn, reader, 3, "UID FETCH 1:* (FLAGS)")
 	if err != nil {
 		return 0, nil, fmt.Errorf("imapimport: uid fetch: %w", err)
 	}
 	messages := c.parseFetchLines(fetchLines)
 	_, _ = sendCommand(conn, reader, 4, "LOGOUT")
 	return uidvalidity, messages, nil
 }
 func readLine(reader *bufio.Reader) (string, error) {
 	line, err := reader.ReadString('\n')
 	if err != nil {
 		return "", err
 	}
 	return strings.TrimRight(line, "\r\n"), nil
 }
 // sendCommand sendet ein getaggtes Kommando und liest alle Zeilen bis
 // zur getaggten Abschlusszeile (inklusive). Liefert einen Fehler, wenn
 // die Abschlusszeile nicht "OK" meldet.
 func sendCommand(conn net.Conn, reader *bufio.Reader, tagN int, command string) ([]string, error) {
 	tag := "C" + strconv.Itoa(tagN)
 	if _, err := conn.Write([]byte(tag + " " + command + "\r\n")); err != nil {
 		return nil, err
 	}
 	var lines []string
 	for {
 		line, err := readLine(reader)
 		if err != nil {
 			return nil, err
 		}
 		lines = append(lines, line)
 		if strings.HasPrefix(line, tag+" ") {
 			if !strings.HasPrefix(line, tag+" OK") {
 				return lines, fmt.Errorf("server meldete: %s", line)
 			}
 			return lines, nil
 		}
 	}
 }
 // resolveUIDValidity liest UIDVALIDITY aus der SELECT-Antwort
 // (Akzeptanzkriterium 1). Eine gemeldete UIDVALIDITY=0 — bekannte
 // Abweichung nicht-konformer Server (known-issues-archivmail.md #5) —
 // löst einen definierten Fallback aus statt eines Abbruchs: ein
 // deterministisch aus dem Postfachnamen abgeleiteter Ersatzwert, der bei
 // wiederholten Läufen gegen denselben nicht-konformen Server STABIL
 // bleibt (kein unnötiger Voll-Resync bei jedem einzelnen Lauf).
 func (c *RealClient) resolveUIDValidity(lines []string, mailbox string) (uint64, error) {
 	v, found := extractUIDValidity(lines)
 	if !found {
 		c.log("imapimport: unerwartete server-antwort: keine UIDVALIDITY in SELECT-Antwort für %q gefunden, verwende fallback", mailbox)
 		return fallbackUIDValidity(mailbox), nil
 	}
 	if v == 0 {
 		c.log("imapimport: UIDVALIDITY=0 gemeldet für postfach %q (bekannte abweichung nicht-konformer server) — verwende definierten fallback statt sync-abbruch", mailbox)
 		return fallbackUIDValidity(mailbox), nil
 	}
 	return v, nil
 }
 // fallbackUIDValidity leitet einen deterministischen, garantiert von 0
 // verschiedenen Ersatzwert aus dem Postfachnamen ab (FNV-1a, gleiche
 // Technik wie mail/internal/search.DocumentID).
 func fallbackUIDValidity(mailbox string) uint64 {
 	h := fnv.New64a()
 	_, _ = h.Write([]byte("imap-fallback-uidvalidity:"))
 	_, _ = h.Write([]byte(mailbox))
 	v := h.Sum64()
 	if v == 0 {
 		v = 1
 	}
 	return v
 }
 // extractUIDValidity sucht "UIDVALIDITY <n>" in den SELECT-Antwortzeilen.
 // found=false, wenn keine UIDVALIDITY-Angabe vorhanden ODER sie nicht als
 // Zahl lesbar ist (beides bekannte Serverabweichungen, siehe
 // resolveUIDValidity — kein Fehlerabbruch an dieser Stelle).
 func extractUIDValidity(lines []string) (value uint64, found bool) {
 	for _, line := range lines {
 		idx := strings.Index(line, "UIDVALIDITY ")
 		if idx == -1 {
 			continue
 		}
 		rest := line[idx+len("UIDVALIDITY "):]
 		end := strings.IndexAny(rest, "] ")
 		if end == -1 {
 			end = len(rest)
 		}
 		v, err := strconv.ParseUint(rest[:end], 10, 64)
 		if err != nil {
 			return 0, false
 		}
 		return v, true
 	}
 	return 0, false
 }
 // parseFetchLines parst Zeilen der Form
 // "* <seq> FETCH (UID <uid> FLAGS (<flags>))" (siehe mail/internal/imap
 // writeFetchResults). Akzeptanzkriterium 2: eine einzelne unerwartete/
 // kaputte Zeile wird protokolliert und übersprungen, alle übrigen,
 // korrekt lesbaren Nachrichten werden trotzdem geliefert — der gesamte
 // Lauf bricht dafür NICHT ab.
 func (c *RealClient) parseFetchLines(lines []string) []RemoteMessage {
 	var messages []RemoteMessage
 	for _, line := range lines {
 		if !strings.HasPrefix(line, "* ") {
 			continue // getaggte Abschlusszeile ("C3 OK ..."), kein Untagged-FETCH
 		}
 		if !strings.Contains(line, "FETCH ") {
 			continue // anderweitiges Untagged (z. B. künftig "* OK ..."), nichts zu parsen
 		}
 		msg, ok := parseSingleFetchLine(line)
 		if !ok {
 			c.log("imapimport: unerwartete server-antwort übersprungen: %q", line)
 			continue
 		}
 		messages = append(messages, msg)
 	}
 	return messages
 }
 func parseSingleFetchLine(line string) (RemoteMessage, bool) {
 	if !strings.Contains(line, "FETCH (UID ") {
 		return RemoteMessage{}, false
 	}
 	uidIdx := strings.Index(line, "UID ") + len("UID ")
 	rest := line[uidIdx:]
 	spaceIdx := strings.IndexByte(rest, ' ')
 	if spaceIdx == -1 {
 		return RemoteMessage{}, false
 	}
 	uid, err := strconv.ParseUint(rest[:spaceIdx], 10, 32)
 	if err != nil {
 		return RemoteMessage{}, false
 	}
 	var flags []string
 	flagsStart := strings.Index(line, "FLAGS (")
 	flagsEnd := strings.LastIndex(line, ")")
 	if flagsStart != -1 && flagsEnd > flagsStart {
 		inner := line[flagsStart+len("FLAGS (") : flagsEnd]
 		if inner != "" {
 			flags = strings.Split(inner, " ")
 		}
 	}
 	return RemoteMessage{UID: uint32(uid), Flags: flags}, true
 }
@@ -0,0 +1,132 @@
 // TestRunOnce_AgainstRealTestMailboxWithRealisticVolume ist die
 // geforderte Pflichtprüfung 3: Test gegen Testpostfach mit realistischem
 // Nachrichtenaufkommen — echter IMAP4rev1-Wire-Protokoll-Lauf gegen den
 // echten ING-01-Server (mail/internal/imap), kein Fake.
 package imapimport
 import (
 	"context"
 	"net"
 	"testing"
 	"gitea.perlbach24.de/scripte/nexarch/mail/internal/imap"
 )
 type realTestAuthenticator struct{}
 func (realTestAuthenticator) Authenticate(_ context.Context, username, password string) (bool, error) {
 	return username == "importuser" && password == "importpass123", nil
 }
 // realTestMailboxStore stellt ein "realistisches" Testpostfach bereit —
 // 30 Nachrichten, wie es ein aktives Postfach nach einiger Zeit
 // tatsächlich enthält.
 type realTestMailboxStore struct {
 	uidvalidity uint64
 	messages    []imap.Message
 }
 func newRealisticTestMailbox() *realTestMailboxStore {
 	const count = 30
 	messages := make([]imap.Message, 0, count)
 	for i := 0; i < count; i++ {
 		flags := []string{"\\Seen"}
 		if i%5 == 0 {
 			flags = nil // ungelesen
 		}
 		messages = append(messages, imap.Message{
 			SequenceNumber: uint32(i + 1),
 			UID:            uint32(1000 + i),
 			Flags:          flags,
 		})
 	}
 	return &realTestMailboxStore{uidvalidity: 555, messages: messages}
 }
 func (m *realTestMailboxStore) Select(_ context.Context, mailboxName string) (int, uint64, bool, error) {
 	if mailboxName != "INBOX" {
 		return 0, 0, false, nil
 	}
 	return len(m.messages), m.uidvalidity, true, nil
 }
 func (m *realTestMailboxStore) Fetch(_ context.Context, _ string, seqNumbers []uint32) ([]imap.Message, error) {
 	return m.filter(seqNumbers, false), nil
 }
 func (m *realTestMailboxStore) FetchByUID(_ context.Context, _ string, uids []uint32) ([]imap.Message, error) {
 	return m.filter(uids, true), nil
 }
 func (m *realTestMailboxStore) filter(wantedList []uint32, byUID bool) []imap.Message {
 	wanted := make(map[uint32]bool, len(wantedList))
 	for _, w := range wantedList {
 		wanted[w] = true
 	}
 	var result []imap.Message
 	for _, msg := range m.messages {
 		key := msg.SequenceNumber
 		if byUID {
 			key = msg.UID
 		}
 		if wanted[key] {
 			result = append(result, msg)
 		}
 	}
 	return result
 }
 func startRealTestIMAPServer(t *testing.T) (addr string, stop func()) {
 	t.Helper()
 	srv := imap.NewServer(realTestAuthenticator{}, newRealisticTestMailbox())
 	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
 	}
 }
 func TestRunOnce_AgainstRealTestMailboxWithRealisticVolume(t *testing.T) {
 	store := setupStore(t)
 	scheduler := NewScheduler(store)
 	ctx := context.Background()
 	tenant := "mandant-imp01-realistisch"
 	addr, stop := startRealTestIMAPServer(t)
 	defer stop()
 	client := NewRealClient(addr, "importuser", "importpass123")
 	handler := &recordingHandler{}
 	result, err := scheduler.RunOnce(ctx, tenant, "INBOX", client, handler)
 	if err != nil {
 		t.Fatalf("runonce gegen echten server: %v", err)
 	}
 	if result.NewMessages != 30 {
 		t.Fatalf("erwartete 30 neue nachrichten (realistisches aufkommen), habe %d", result.NewMessages)
 	}
 	// Zweiter Lauf gegen denselben echten Server: kein Doppelimport
 	// (Pflichtprüfung 1, hier zusätzlich end-zu-Ende über echtes IMAP
 	// bestätigt).
 	handler2 := &recordingHandler{}
 	result2, err := scheduler.RunOnce(ctx, tenant, "INBOX", client, handler2)
 	if err != nil {
 		t.Fatalf("zweiter lauf gegen echten server: %v", err)
 	}
 	if result2.NewMessages != 0 {
 		t.Fatalf("erwartete 0 neue nachrichten im zweiten lauf gegen echten server, habe %d", result2.NewMessages)
 	}
 	if result2.ExistingMessages != 30 {
 		t.Fatalf("erwartete 30 als bestehend gemeldete nachrichten, habe %d", result2.ExistingMessages)
 	}
 }
@@ -0,0 +1,10 @@
 CREATE TABLE IF NOT EXISTS mail_import_state (
    tenant_slug      TEXT NOT NULL,
    mailbox_name     TEXT NOT NULL,
    last_uidvalidity BIGINT NOT NULL DEFAULT 0,
    last_synced_uid  BIGINT NOT NULL DEFAULT 0,
    interval_seconds INT NOT NULL DEFAULT 300,
    created_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
    PRIMARY KEY (tenant_slug, mailbox_name)
 )
@@ -0,0 +1,164 @@
 // IMP-04: Fehlerbehandlung nicht-konformer Server. Baut einen minimalen,
 // hand-gesteuerten Fake-Server (roher TCP, KEIN mail/internal/imap) auf,
 // der bewusst nicht-konforme Antworten sendet — echte Kontrolle über
 // genau das Fehlerszenario, das getestet werden soll.
 package imapimport
 import (
 	"bufio"
 	"context"
 	"fmt"
 	"net"
 	"strings"
 	"testing"
 )
 // scriptedServer nimmt EINE Verbindung an und sendet exakt die
 // vorgegebenen Zeilen als Antwort auf jedes eingehende Kommando (in
 // Reihenfolge) — genug Kontrolle, um nicht-konforme Serverantworten
 // exakt zu reproduzieren.
 type scriptedServer struct {
 	responses [][]string // je eingehendem Kommando eine Antwortzeilen-Liste
 }
 func (s *scriptedServer) start(t *testing.T) (addr string) {
 	t.Helper()
 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		t.Fatalf("listener: %v", err)
 	}
 	go func() {
 		conn, err := listener.Accept()
 		if err != nil {
 			return
 		}
 		defer func() { _ = conn.Close() }()
 		reader := bufio.NewReader(conn)
 		_, _ = conn.Write([]byte("* OK IMAP4rev1 Service Ready\r\n"))
 		for _, respLines := range s.responses {
 			if _, err := reader.ReadString('\n'); err != nil {
 				return
 			}
 			for _, line := range respLines {
 				if _, err := conn.Write([]byte(line + "\r\n")); err != nil {
 					return
 				}
 			}
 		}
 	}()
 	t.Cleanup(func() { _ = listener.Close() })
 	return listener.Addr().String()
 }
 // TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort ist die
 // geforderte Pflichtprüfung 1: Test simuliert Server mit UIDVALIDITY=0
 // und bestätigt greifenden Fallback.
 func TestResolveUIDValidity_ZeroTriggersDefinedFallbackNotAbort(t *testing.T) {
 	srv := &scriptedServer{responses: [][]string{
 		{"C1 OK LOGIN completed"},
 		{"* 3 EXISTS", "* OK [UIDVALIDITY 0] UIDs valid", "C2 OK [READ-WRITE] SELECT completed"},
 		{"* 1 FETCH (UID 1 FLAGS ())", "* 2 FETCH (UID 2 FLAGS ())", "* 3 FETCH (UID 3 FLAGS ())", "C3 OK UID FETCH completed"},
 		{"C4 OK LOGOUT completed"},
 	}}
 	addr := srv.start(t)
 	var loggedFallback bool
 	client := NewRealClient(addr, "user", "pass").WithLogger(func(format string, args ...any) {
 		msg := fmt.Sprintf(format, args...)
 		if strings.Contains(msg, "UIDVALIDITY=0") {
 			loggedFallback = true
 		}
 	})
 	uidvalidity, messages, err := client.Sync(context.Background(), "INBOX")
 	if err != nil {
 		// Akzeptanzkriterium 1: KEIN Sync-Abbruch bei UIDVALIDITY=0.
 		t.Fatalf("erwartete erfolgreichen sync trotz UIDVALIDITY=0, habe fehler: %v", err)
 	}
 	if uidvalidity == 0 {
 		t.Fatal("erwartete definierten fallback-wert != 0, habe weiterhin 0")
 	}
 	if len(messages) != 3 {
 		t.Fatalf("erwartete 3 nachrichten trotz UIDVALIDITY=0, habe %d", len(messages))
 	}
 	if !loggedFallback {
 		t.Fatal("erwartete protokollierten fallback-hinweis (akzeptanzkriterium 3: nachvollziehbar)")
 	}
 	// Fallback ist deterministisch für dasselbe Postfach — ein zweiter
 	// Aufruf gegen einen erneut nicht-konformen Server liefert real
 	// denselben Ersatzwert, löst also keinen unnötigen Voll-Resync bei
 	// jedem einzelnen Lauf aus.
 	if fallbackUIDValidity("INBOX") != uidvalidity {
 		t.Fatalf("erwartete deterministischen fallback, habe %d vs %d", fallbackUIDValidity("INBOX"), uidvalidity)
 	}
 }
 // TestParseFetchLines_UnexpectedResponseSkippedRestContinue ist die
 // geforderte Pflichtprüfung 2: Test mit unerwarteter/kaputter
 // Serverantwort bestätigt Weiterlauf für übrige Nachrichten.
 func TestParseFetchLines_UnexpectedResponseSkippedRestContinue(t *testing.T) {
 	srv := &scriptedServer{responses: [][]string{
 		{"C1 OK LOGIN completed"},
 		{"* 3 EXISTS", "* OK [UIDVALIDITY 42] UIDs valid", "C2 OK [READ-WRITE] SELECT completed"},
 		{
 			"* 1 FETCH (UID 1 FLAGS ())",
 			"* GARBAGE NOT EVEN A FETCH LINE AT ALL",     // kaputte/unerwartete Antwort
 			"* 2 FETCH SOMETHING UNPARSEABLE HERE (UID)", // ebenfalls kaputt
 			"* 3 FETCH (UID 3 FLAGS (\\Seen))",
 			"C3 OK UID FETCH completed",
 		},
 		{"C4 OK LOGOUT completed"},
 	}}
 	addr := srv.start(t)
 	var skippedCount int
 	client := NewRealClient(addr, "user", "pass").WithLogger(func(format string, args ...any) {
 		msg := fmt.Sprintf(format, args...)
 		if strings.Contains(msg, "unerwartete server-antwort übersprungen") {
 			skippedCount++
 		}
 	})
 	uidvalidity, messages, err := client.Sync(context.Background(), "INBOX")
 	if err != nil {
 		t.Fatalf("erwartete erfolgreichen sync trotz kaputter zeilen, habe fehler: %v", err)
 	}
 	if uidvalidity != 42 {
 		t.Fatalf("erwartete uidvalidity=42, habe %d", uidvalidity)
 	}
 	// Akzeptanzkriterium 2: die BEIDEN kaputten Zeilen werden übersprungen
 	// UND protokolliert, die ÜBRIGEN (real 2) Nachrichten kommen trotzdem an.
 	if len(messages) != 2 {
 		t.Fatalf("erwartete 2 lesbare nachrichten trotz kaputter zeilen, habe %d: %+v", len(messages), messages)
 	}
 	if skippedCount != 2 {
 		t.Fatalf("erwartete 2 protokollierte übersprungene zeilen, habe %d", skippedCount)
 	}
 }
 // TestResolveUIDValidity_RegressionGuardAgainstZeroAbort ist die
 // geforderte Pflichtprüfung 3: Regressionstest verhindert
 // Wiederauftreten des UIDVALIDITY-Bugs — prüft die Fallback-Funktion
 // isoliert und direkt, unabhängig vom Netzwerkpfad.
 func TestResolveUIDValidity_RegressionGuardAgainstZeroAbort(t *testing.T) {
 	client := NewRealClient("unused:0", "u", "p")
 	value, err := client.resolveUIDValidity([]string{"* OK [UIDVALIDITY 0] UIDs valid"}, "INBOX")
 	if err != nil {
 		t.Fatalf("regression: UIDVALIDITY=0 löste real einen fehler aus (der genau vermiedene bug): %v", err)
 	}
 	if value == 0 {
 		t.Fatal("regression: fallback lieferte weiterhin 0 — bug erneut aufgetreten")
 	}
 	// Fehlende UIDVALIDITY-Angabe (noch nicht-konformer als 0) darf
 	// ebenfalls nicht abbrechen.
 	value2, err := client.resolveUIDValidity([]string{"C2 OK SELECT completed"}, "INBOX")
 	if err != nil {
 		t.Fatalf("regression: fehlende UIDVALIDITY löste real einen fehler aus: %v", err)
 	}
 	if value2 == 0 {
 		t.Fatal("regression: fallback bei fehlender UIDVALIDITY lieferte 0")
 	}
 }
@@ -0,0 +1,104 @@
 package imapimport
 import (
 	"context"
 	"fmt"
 	"sort"
 )
 // Handler verarbeitet die vom Scheduler klassifizierten Nachrichten.
 // Echte Ablage/Indexierung ist Sache späterer Kacheln (IMP-02 u. a.) —
 // dieses Paket bereitet nur die Schnittstelle vor.
 type Handler interface {
 	// OnNewMessage wird GENAU EINMAL je UID aufgerufen, die seit dem
 	// letzten Abgleich neu hinzugekommen ist (Akzeptanzkriterium 1).
 	// Ein Fehler bricht den aktuellen Lauf ab, OHNE den Fortschritt für
 	// bereits erfolgreich verarbeitete Nachrichten zu verlieren
 	// (Akzeptanzkriterium 3).
 	OnNewMessage(ctx context.Context, tenantSlug, mailboxName string, msg RemoteMessage) error
 	// OnExistingMessageState wird für bereits bekannte Nachrichten mit
 	// ihrem AKTUELLEN Flag-Zustand aufgerufen (Akzeptanzkriterium 2:
 	// Zustandsänderungen wie gelesen/gelöscht abgeglichen) — NIEMALS als
 	// Neuimport, die Nachricht selbst wird nicht erneut abgelegt.
 	OnExistingMessageState(ctx context.Context, tenantSlug, mailboxName string, msg RemoteMessage) error
 }
 // Scheduler führt den periodischen, UID-basierten Delta-Sync aus.
 type Scheduler struct {
 	store *Store
 }
 func NewScheduler(store *Store) *Scheduler {
 	return &Scheduler{store: store}
 }
 // SyncResult fasst einen abgeschlossenen Lauf zusammen.
 type SyncResult struct {
 	NewMessages      int
 	ExistingMessages int
 	Rebuilt          bool
 }
 // RunOnce führt genau einen Abgleich für ein Postfach aus (Akzeptanz-
 // kriterium 1/2/3). Nachrichten werden nach UID aufsteigend verarbeitet;
 // der Fortschritt wird nach JEDER neuen Nachricht einzeln persistiert
 // (Store.advance), damit ein Absturz mitten im Lauf keine Nachricht
 // verliert und beim nächsten Lauf keine bereits verarbeitete Nachricht
 // erneut als "neu" gilt (Pflichtprüfung 1/2: kein Doppelimport, auch
 // nach simuliertem Neustart).
 func (s *Scheduler) RunOnce(ctx context.Context, tenantSlug, mailboxName string, client IMAPClient, handler Handler) (SyncResult, error) {
 	state, err := s.store.GetOrCreate(ctx, tenantSlug, mailboxName)
 	if err != nil {
 		return SyncResult{}, err
 	}
 	uidvalidity, messages, err := client.Sync(ctx, mailboxName)
 	if err != nil {
 		return SyncResult{}, fmt.Errorf("imapimport: postfach abrufen: %w", err)
 	}
 	result := SyncResult{}
 	lastSyncedUID := state.LastSyncedUID
 	// Bekannten Fehler vermeiden (archivmail: UIDVALIDITY=0 bricht
 	// Resync): jede Änderung der UIDVALIDITY gegenüber dem persistierten
 	// Stand (0 = "noch nie synchronisiert", kein Rebuild) löst einen
 	// vollständigen Resync aus — alle Nachrichten gelten wieder als neu.
 	if state.LastUIDValidity != 0 && uidvalidity != state.LastUIDValidity {
 		lastSyncedUID = 0
 		result.Rebuilt = true
 	}
 	sorted := make([]RemoteMessage, len(messages))
 	copy(sorted, messages)
 	sort.Slice(sorted, func(i, j int) bool { return sorted[i].UID < sorted[j].UID })
 	for _, msg := range sorted {
 		if msg.UID > lastSyncedUID {
 			if err := handler.OnNewMessage(ctx, tenantSlug, mailboxName, msg); err != nil {
 				return result, fmt.Errorf("imapimport: neue nachricht uid=%d verarbeiten: %w", msg.UID, err)
 			}
 			lastSyncedUID = msg.UID
 			if err := s.store.advance(ctx, tenantSlug, mailboxName, uidvalidity, lastSyncedUID); err != nil {
 				return result, err
 			}
 			result.NewMessages++
 			continue
 		}
 		if err := handler.OnExistingMessageState(ctx, tenantSlug, mailboxName, msg); err != nil {
 			return result, fmt.Errorf("imapimport: zustand für uid=%d abgleichen: %w", msg.UID, err)
 		}
 		result.ExistingMessages++
 	}
 	// Auch ohne neue Nachrichten muss eine geänderte UIDVALIDITY
 	// persistiert werden (z. B. Rebuild bei leerem Postfach).
 	if uidvalidity != state.LastUIDValidity {
 		if err := s.store.advance(ctx, tenantSlug, mailboxName, uidvalidity, lastSyncedUID); err != nil {
 			return result, err
 		}
 	}
 	return result, nil
 }
@@ -0,0 +1,194 @@
 // Integrationstest (IMP-01): echte Postgres-Instanz, folgt derselben
 // Testhost-Konvention wie mail/internal/dedup/folderstate/savedsearch —
 // TEST_TENANT_DSN.
 package imapimport
 import (
 	"context"
 	"errors"
 	"os"
 	"testing"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupStore(t *testing.T) *Store {
 	t.Helper()
 	dsn := os.Getenv("TEST_TENANT_DSN")
 	if dsn == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	t.Cleanup(func() { pool.Close() })
 	store := NewStore(pool)
 	if err := store.EnsureSchema(ctx); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	t.Cleanup(func() {
 		// LIKE-Muster bewusst paket-, nicht ticketspezifisch (mandant-%
 		// statt mandant-imp01-%) — mehrere Tickets (u. a. IMP-09) fügen
 		// diesem Paket über die Zeit weitere Tests mit eigenen
 		// Mandanten-Präfixen hinzu; ein zu enges Muster ließ bereits real
 		// Testdaten ungelöscht zurück (siehe IMP-09-Prüfprotokoll).
 		_, _ = pool.Exec(context.Background(), `DELETE FROM mail_import_state WHERE tenant_slug LIKE 'mandant-%'`)
 	})
 	return store
 }
 // fakeIMAPClient simuliert ein entferntes Postfach — echte
 // Netzwerkanbindung ist Sache von client_real.go (Pflichtprüfung 3
 // nutzt sie real, hier wird die Delta-Sync-LOGIK isoliert geprüft,
 // gleiche Konvention wie fakeKEKProvider/fakeAuthenticator in anderen
 // Mail-Paketen).
 type fakeIMAPClient struct {
 	uidvalidity uint64
 	messages    []RemoteMessage
 }
 func (c *fakeIMAPClient) Sync(_ context.Context, _ string) (uint64, []RemoteMessage, error) {
 	return c.uidvalidity, c.messages, nil
 }
 // recordingHandler zeichnet auf, welche UIDs als neu bzw. als bestehend
 // gemeldet wurden — die eigentliche Ablage/Indexierung ist Sache
 // späterer Kacheln.
 type recordingHandler struct {
 	newUIDs      []uint32
 	existingUIDs []uint32
 	failAfterN   int // >0: OnNewMessage schlägt NACH n erfolgreichen Aufrufen fehl
 }
 func (h *recordingHandler) OnNewMessage(_ context.Context, _, _ string, msg RemoteMessage) error {
 	if h.failAfterN > 0 && len(h.newUIDs) >= h.failAfterN {
 		return errors.New("simulierter absturz mitten im abgleich")
 	}
 	h.newUIDs = append(h.newUIDs, msg.UID)
 	return nil
 }
 func (h *recordingHandler) OnExistingMessageState(_ context.Context, _, _ string, msg RemoteMessage) error {
 	h.existingUIDs = append(h.existingUIDs, msg.UID)
 	return nil
 }
 // TestRunOnce_TwoConsecutiveRunsNoDuplicateImport ist die geforderte
 // Pflichtprüfung 1: zwei aufeinanderfolgende Läufe importieren keine
 // Nachricht doppelt.
 func TestRunOnce_TwoConsecutiveRunsNoDuplicateImport(t *testing.T) {
 	store := setupStore(t)
 	scheduler := NewScheduler(store)
 	ctx := context.Background()
 	tenant := "mandant-imp01-doppelimport"
 	client := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{
 		{UID: 1, Flags: nil}, {UID: 2, Flags: nil}, {UID: 3, Flags: nil},
 	}}
 	handler1 := &recordingHandler{}
 	result1, err := scheduler.RunOnce(ctx, tenant, "INBOX", client, handler1)
 	if err != nil {
 		t.Fatalf("erster lauf: %v", err)
 	}
 	if result1.NewMessages != 3 || len(handler1.newUIDs) != 3 {
 		t.Fatalf("erwartete 3 neue nachrichten im ersten lauf, habe: %+v / %v", result1, handler1.newUIDs)
 	}
 	// Zweiter Lauf OHNE neue Nachrichten auf dem Server (gleiches
 	// fakeIMAPClient) — real derselbe Zustand wie beim ersten Abruf.
 	handler2 := &recordingHandler{}
 	result2, err := scheduler.RunOnce(ctx, tenant, "INBOX", client, handler2)
 	if err != nil {
 		t.Fatalf("zweiter lauf: %v", err)
 	}
 	if result2.NewMessages != 0 {
 		t.Fatalf("erwartete 0 neue nachrichten im zweiten lauf (kein doppelimport), habe %d: %v", result2.NewMessages, handler2.newUIDs)
 	}
 	if result2.ExistingMessages != 3 {
 		t.Fatalf("erwartete 3 als bestehend gemeldete nachrichten im zweiten lauf, habe %d", result2.ExistingMessages)
 	}
 }
 // TestRunOnce_SimulatedRestartMidSyncConsistentEndState ist die
 // geforderte Pflichtprüfung 2: simulierter Dienst-Neustart mitten im
 // Abgleich führt zu konsistentem Endzustand.
 func TestRunOnce_SimulatedRestartMidSyncConsistentEndState(t *testing.T) {
 	store := setupStore(t)
 	scheduler := NewScheduler(store)
 	ctx := context.Background()
 	tenant := "mandant-imp01-neustart"
 	client := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{
 		{UID: 1}, {UID: 2}, {UID: 3}, {UID: 4}, {UID: 5},
 	}}
 	// Erster Lauf "stürzt" nach 2 erfolgreich verarbeiteten Nachrichten ab.
 	crashingHandler := &recordingHandler{failAfterN: 2}
 	_, err := scheduler.RunOnce(ctx, tenant, "INBOX", client, crashingHandler)
 	if err == nil {
 		t.Fatal("erwartete fehler durch simulierten absturz, habe nil")
 	}
 	if len(crashingHandler.newUIDs) != 2 {
 		t.Fatalf("erwartete 2 erfolgreich verarbeitete nachrichten vor dem absturz, habe %d: %v", len(crashingHandler.newUIDs), crashingHandler.newUIDs)
 	}
 	// "Neustart des Dienstes": neuer Scheduler auf demselben (persistenten)
 	// Store, neuer Handler ohne Fehlerinjektion.
 	restartedScheduler := NewScheduler(store)
 	freshHandler := &recordingHandler{}
 	result, err := restartedScheduler.RunOnce(ctx, tenant, "INBOX", client, freshHandler)
 	if err != nil {
 		t.Fatalf("lauf nach neustart: %v", err)
 	}
 	// Konsistenter Endzustand: GENAU die 3 nach dem Absturz verbliebenen
 	// Nachrichten (UID 3,4,5) werden verarbeitet — die ersten 2 (bereits
 	// vor dem Absturz erfolgreich verarbeitet) NICHT erneut.
 	if result.NewMessages != 3 {
 		t.Fatalf("erwartete 3 neue nachrichten nach neustart, habe %d: %v", result.NewMessages, freshHandler.newUIDs)
 	}
 	for _, uid := range freshHandler.newUIDs {
 		if uid <= 2 {
 			t.Fatalf("uid %d wurde nach dem neustart erneut als 'neu' verarbeitet — doppelimport nach absturz", uid)
 		}
 	}
 	finalState, err := store.Get(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("endzustand lesen: %v", err)
 	}
 	if finalState.LastSyncedUID != 5 {
 		t.Fatalf("erwartete konsistenten endzustand last_synced_uid=5, habe %d", finalState.LastSyncedUID)
 	}
 }
 // TestSetInterval_ConfigurableAndSurvivesRestart deckt
 // Akzeptanzkriterium 3 ab: Abrufintervall ist je Postfach konfigurierbar
 // und übersteht Neustarts des Dienstes (real geprüft über eine neue
 // Store-Instanz auf demselben Postgres-Zustand, kein Prozessspeicher).
 func TestSetInterval_ConfigurableAndSurvivesRestart(t *testing.T) {
 	store := setupStore(t)
 	ctx := context.Background()
 	tenant := "mandant-imp01-intervall"
 	if _, err := store.GetOrCreate(ctx, tenant, "INBOX"); err != nil {
 		t.Fatalf("getorcreate: %v", err)
 	}
 	if err := store.SetInterval(ctx, tenant, "INBOX", 900); err != nil {
 		t.Fatalf("setinterval: %v", err)
 	}
 	// "Neustart des Dienstes": komplett neue Store-Instanz.
 	restartedStore := NewStore(store.pool)
 	state, err := restartedStore.Get(ctx, tenant, "INBOX")
 	if err != nil {
 		t.Fatalf("get nach neustart: %v", err)
 	}
 	if state.IntervalSeconds != 900 {
 		t.Fatalf("erwartete konfiguriertes intervall 900 nach neustart, habe %d", state.IntervalSeconds)
 	}
 }
@@ -0,0 +1,112 @@
 // Package imapimport implementiert IMP-01: den Scheduler für
 // periodischen IMAP-Postfach-Abruf mit UID-basiertem Delta-Sync. Baut
 // auf ING-01 (mail/internal/imap, IMAP-Server-Grundgerüst inkl. UID
 // FETCH) und ING-05 (mail/internal/folderstate, UIDVALIDITY/UIDNEXT) auf
 // — kombiniert bewusst beide fertigen, unveränderten Pakete statt eines
 // davon zu erweitern (kein Umbau angrenzender Bereiche).
 //
 // Konzept aus archivmail als Ausgangspunkt genommen (UID-Sync,
 // Delta-Import, siehe repos-analyse-mail-reuse.md), Testabdeckung von
 // Grund auf neu (archivmails Import-Pfade waren praktisch ungetestet).
 // Bekannten Fehler vermieden (archivmail: UIDVALIDITY=0 bricht Resync
 // bei nicht-konformen Servern): Store.RunOnce erkennt jede Änderung der
 // UIDVALIDITY explizit und löst einen vollständigen Resync aus, statt
 // eine UIDVALIDITY=0 unbesehen zu übernehmen.
 package imapimport
 import (
 	"context"
 	_ "embed"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 //go:embed migrations/0001_mail_import_state.sql
 var schemaMigration string
 const defaultIntervalSeconds = 300
 // State ist der persistierte Sync-Zustand eines Postfachs — übersteht
 // Dienst-Neustarts (Akzeptanzkriterium 3), da ausschließlich in Postgres
 // gehalten, nie im Prozessspeicher.
 type State struct {
 	TenantSlug      string
 	MailboxName     string
 	LastUIDValidity uint64
 	LastSyncedUID   uint32
 	IntervalSeconds int
 }
 // Store persistiert den Sync-Zustand je Mandant und Postfach.
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // EnsureSchema legt die Tabelle an, falls sie noch nicht existiert.
 func (s *Store) EnsureSchema(ctx context.Context) error {
 	if _, err := s.pool.Exec(ctx, schemaMigration); err != nil {
 		return fmt.Errorf("imapimport: schema anlegen: %w", err)
 	}
 	return nil
 }
 // GetOrCreate liefert den Sync-Zustand eines Postfachs, legt ihn bei
 // erstem Zugriff mit dem Standardintervall neu an.
 func (s *Store) GetOrCreate(ctx context.Context, tenantSlug, mailboxName string) (State, error) {
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO mail_import_state (tenant_slug, mailbox_name, interval_seconds)
 		VALUES ($1, $2, $3)
 		ON CONFLICT (tenant_slug, mailbox_name) DO NOTHING
 	`, tenantSlug, mailboxName, defaultIntervalSeconds); err != nil {
 		return State{}, fmt.Errorf("imapimport: sync-zustand anlegen: %w", err)
 	}
 	return s.Get(ctx, tenantSlug, mailboxName)
 }
 // Get liest den aktuellen Sync-Zustand.
 func (s *Store) Get(ctx context.Context, tenantSlug, mailboxName string) (State, error) {
 	var st State
 	st.TenantSlug = tenantSlug
 	st.MailboxName = mailboxName
 	err := s.pool.QueryRow(ctx, `
 		SELECT last_uidvalidity, last_synced_uid, interval_seconds
 		FROM mail_import_state WHERE tenant_slug = $1 AND mailbox_name = $2
 	`, tenantSlug, mailboxName).Scan(&st.LastUIDValidity, &st.LastSyncedUID, &st.IntervalSeconds)
 	if err != nil {
 		return State{}, fmt.Errorf("imapimport: sync-zustand lesen: %w", err)
 	}
 	return st, nil
 }
 // SetInterval konfiguriert das Abrufintervall je Postfach
 // (Akzeptanzkriterium 3), persistiert und damit neustartfest.
 func (s *Store) SetInterval(ctx context.Context, tenantSlug, mailboxName string, seconds int) error {
 	if _, err := s.pool.Exec(ctx, `
 		UPDATE mail_import_state SET interval_seconds = $3, updated_at = now()
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 	`, tenantSlug, mailboxName, seconds); err != nil {
 		return fmt.Errorf("imapimport: intervall setzen: %w", err)
 	}
 	return nil
 }
 // advance persistiert den erreichten Fortschritt NACH jeder erfolgreich
 // verarbeiteten Nachricht (nicht erst am Ende des Laufs) — Grundlage für
 // Akzeptanzkriterium 3 / Pflichtprüfung 2: ein Dienst-Neustart mitten im
 // Abgleich verliert höchstens die aktuell laufende Verarbeitung, nie den
 // bereits erreichten Fortschritt, und importiert nichts doppelt.
 func (s *Store) advance(ctx context.Context, tenantSlug, mailboxName string, uidvalidity uint64, syncedUID uint32) error {
 	if _, err := s.pool.Exec(ctx, `
 		UPDATE mail_import_state
 		SET last_uidvalidity = $3, last_synced_uid = $4, updated_at = now()
 		WHERE tenant_slug = $1 AND mailbox_name = $2
 	`, tenantSlug, mailboxName, uidvalidity, syncedUID); err != nil {
 		return fmt.Errorf("imapimport: fortschritt persistieren: %w", err)
 	}
 	return nil
 }
@@ -0,0 +1,62 @@
 // IMP-09: Tenant-Scoping-Nachweis für den Postfach-Abruf
 // (Akzeptanzkriterium 2). Bekannten Fehler vermeiden (known-issues-
 // archivmail.md #4): Import-nahe Module waren praktisch ungetestet —
 // dieser Test schließt eine reale Lücke, die vor IMP-09 bestand: kein
 // bestehender Test bewies bislang, dass zwei Mandanten mit DEMSELBEN
 // Postfachnamen sich nicht gegenseitig beeinflussen.
 package imapimport
 import (
 	"context"
 	"testing"
 )
 func TestScheduler_TenantScopingIsolatesSyncState(t *testing.T) {
 	store := setupStore(t)
 	scheduler := NewScheduler(store)
 	ctx := context.Background()
 	tenantA := "mandant-imp09-tenant-a"
 	tenantB := "mandant-imp09-tenant-b"
 	const mailbox = "INBOX" // BEWUSST derselbe Postfachname bei beiden Mandanten
 	clientA := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{{UID: 1}, {UID: 2}}}
 	clientB := &fakeIMAPClient{uidvalidity: 1, messages: []RemoteMessage{{UID: 1}, {UID: 2}, {UID: 3}}}
 	handlerA := &recordingHandler{}
 	resultA, err := scheduler.RunOnce(ctx, tenantA, mailbox, clientA, handlerA)
 	if err != nil {
 		t.Fatalf("mandant a: %v", err)
 	}
 	if resultA.NewMessages != 2 {
 		t.Fatalf("mandant a: erwartete 2 neue nachrichten, habe %d", resultA.NewMessages)
 	}
 	handlerB := &recordingHandler{}
 	resultB, err := scheduler.RunOnce(ctx, tenantB, mailbox, clientB, handlerB)
 	if err != nil {
 		t.Fatalf("mandant b: %v", err)
 	}
 	// Entscheidender Nachweis: Mandant B startet trotz identischem
 	// Postfachnamen bei UID 0 — sähe er fälschlich den Zustand von
 	// Mandant A (UID 2 bereits synchronisiert), würden hier nur 1 statt
 	// 3 neue Nachrichten gezählt.
 	if resultB.NewMessages != 3 {
 		t.Fatalf("mandant b: erwartete 3 neue nachrichten (kein zustand von mandant a übernommen), habe %d", resultB.NewMessages)
 	}
 	stateA, err := store.Get(ctx, tenantA, mailbox)
 	if err != nil {
 		t.Fatalf("zustand mandant a: %v", err)
 	}
 	stateB, err := store.Get(ctx, tenantB, mailbox)
 	if err != nil {
 		t.Fatalf("zustand mandant b: %v", err)
 	}
 	if stateA.LastSyncedUID != 2 {
 		t.Fatalf("mandant a: erwartete last_synced_uid=2, habe %d", stateA.LastSyncedUID)
 	}
 	if stateB.LastSyncedUID != 3 {
 		t.Fatalf("mandant b: erwartete last_synced_uid=3, habe %d", stateB.LastSyncedUID)
 	}
 }
@@ -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,
 	})
 }
@@ -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)
 	}
 }
@@ -0,0 +1,169 @@
 // Package importtestgate implementiert IMP-09: die Import-Testsuite als
 // echtes, ausführbares Prüfgate — spiegelt das Muster aus
 // mail/internal/qagate (QA-03), hier bezogen auf die Import-Pfade
 // (Scheduler, Anhangsverarbeitung, Regelwerk) statt Archivierung/Suche.
 package importtestgate
 import (
 	"bytes"
 	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 )
 // ImportPackages sind die drei Importpfade, deren Testsuiten das Gate
 // ausführt (Akzeptanzkriterium 1: Scheduler, Anhangsverarbeitung,
 // Regelwerk).
 var ImportPackages = []string{
 	"./internal/imapimport/...",
 	"./internal/attachments/...",
 	"./internal/mailrules/...",
 }
 // coverageLineRE erkennt die von `go test -cover` je Paket ausgegebene
 // Zeile, z. B. "ok  	.../imapimport	0.45s	coverage: 78.3% of statements".
 var coverageLineRE = regexp.MustCompile(`^(ok|FAIL)\s+(\S+)\s.*?coverage:\s([\d.]+)% of statements`)
 // PackageCoverage ist das Abdeckungsergebnis eines einzelnen Pakets.
 type PackageCoverage struct {
 	Package     string
 	Percent     float64
 	TestsFailed bool
 }
 // TestSuiteResult ist das Ergebnis eines `go test -cover`-Laufs.
 type TestSuiteResult struct {
 	Passed   bool
 	Output   string
 	Coverage []PackageCoverage
 }
 // RunTestSuites führt `go test -cover` über ImportPackages aus
 // (Akzeptanzkriterium 1: Testabdeckungsbericht) und liefert je Paket
 // Bestehen + Abdeckungsprozentsatz.
 func RunTestSuites(ctx context.Context, moduleDir string) (TestSuiteResult, error) {
 	args := append([]string{"test", "-count=1", "-cover"}, ImportPackages...)
 	cmd := exec.CommandContext(ctx, "go", args...)
 	cmd.Dir = moduleDir
 	var out bytes.Buffer
 	cmd.Stdout = &out
 	cmd.Stderr = &out
 	runErr := cmd.Run()
 	result := TestSuiteResult{Output: out.String()}
 	if runErr != nil {
 		if _, isExitErr := runErr.(*exec.ExitError); !isExitErr {
 			return TestSuiteResult{}, fmt.Errorf("importtestgate: go test ausführen: %w", runErr)
 		}
 	}
 	result.Passed = runErr == nil
 	for _, line := range strings.Split(result.Output, "\n") {
 		m := coverageLineRE.FindStringSubmatch(line)
 		if m == nil {
 			continue
 		}
 		pct, err := strconv.ParseFloat(m[3], 64)
 		if err != nil {
 			continue
 		}
 		result.Coverage = append(result.Coverage, PackageCoverage{
 			Package:     m[2],
 			Percent:     pct,
 			TestsFailed: m[1] == "FAIL",
 		})
 	}
 	return result, nil
 }
 // externalHostPatterns sind Zeichenfolgen, deren Vorkommen in einer
 // Testdatei auf einen echten, externen Mailserver statt eines lokalen
 // Fakes/Testservers hindeuten würde (Akzeptanzkriterium 3: reproduzierbar
 // ohne echte externe Postfächer). Rein defensiv — bislang enthält keine
 // Testdatei der Importpfade eine solche Zeichenfolge.
 var externalHostPatterns = []string{
 	"imap.gmail.com", "outlook.office365.com", "imap.mail.yahoo.com", "imap.gmx.net", "imap.web.de",
 }
 // ScanResult ist das Ergebnis des externen-Host-Scans.
 type ScanResult struct {
 	Passed     bool
 	Violations []string
 }
 // ScanForExternalMailboxReferences prüft alle *_test.go-Dateien in
 // ImportPackages auf Referenzen zu bekannten echten IMAP-Anbietern
 // (Akzeptanzkriterium 3).
 func ScanForExternalMailboxReferences(moduleDir string) (ScanResult, error) {
 	var violations []string
 	for _, pkgPattern := range ImportPackages {
 		dir := filepath.Join(moduleDir, strings.TrimSuffix(strings.TrimPrefix(pkgPattern, "./"), "/..."))
 		entries, err := os.ReadDir(dir)
 		if err != nil {
 			return ScanResult{}, fmt.Errorf("importtestgate: verzeichnis %s lesen: %w", dir, err)
 		}
 		for _, e := range entries {
 			if e.IsDir() || !strings.HasSuffix(e.Name(), "_test.go") {
 				continue
 			}
 			content, err := os.ReadFile(filepath.Join(dir, e.Name()))
 			if err != nil {
 				return ScanResult{}, fmt.Errorf("importtestgate: %s lesen: %w", e.Name(), err)
 			}
 			for _, host := range externalHostPatterns {
 				if strings.Contains(string(content), host) {
 					violations = append(violations, fmt.Sprintf("%s/%s: enthält externe Host-Referenz %q", dir, e.Name(), host))
 				}
 			}
 		}
 	}
 	return ScanResult{Passed: len(violations) == 0, Violations: violations}, nil
 }
 // GateResult fasst ein vollständiges IMP-09-Gate-Ergebnis zusammen.
 type GateResult struct {
 	Timestamp    time.Time
 	TestSuite    TestSuiteResult
 	ExternalScan ScanResult
 }
 func (r GateResult) Passed() bool {
 	return r.TestSuite.Passed && r.ExternalScan.Passed
 }
 // Run führt das vollständige IMP-09-Gate aus.
 func Run(ctx context.Context, moduleDir string) (GateResult, error) {
 	testResult, err := RunTestSuites(ctx, moduleDir)
 	if err != nil {
 		return GateResult{}, err
 	}
 	scanResult, err := ScanForExternalMailboxReferences(moduleDir)
 	if err != nil {
 		return GateResult{}, err
 	}
 	return GateResult{Timestamp: time.Now().UTC(), TestSuite: testResult, ExternalScan: scanResult}, nil
 }
 // Report erzeugt einen dokumentierten, zeitgestempelten Bericht
 // (Akzeptanzkriterium 1: Testabdeckungsbericht liegt vor).
 func (r GateResult) Report() string {
 	status := "BESTANDEN"
 	if !r.Passed() {
 		status = "FEHLGESCHLAGEN"
 	}
 	var b strings.Builder
 	fmt.Fprintf(&b, "# IMP-09 Import-Testsuite-Gate: %s\n\n", status)
 	fmt.Fprintf(&b, "Zeitstempel (UTC): %s\n\n", r.Timestamp.Format(time.RFC3339))
 	fmt.Fprintf(&b, "## Testabdeckung\n\n")
 	for _, c := range r.TestSuite.Coverage {
 		fmt.Fprintf(&b, "- %s: %.1f%% (bestanden: %v)\n", c.Package, c.Percent, !c.TestsFailed)
 	}
 	fmt.Fprintf(&b, "\n## Externe-Postfach-Scan\n\nBestanden: %v\n", r.ExternalScan.Passed)
 	return b.String()
 }
@@ -0,0 +1,92 @@
 package importtestgate
 import (
 	"context"
 	"os"
 	"path/filepath"
 	"testing"
 )
 func moduleRoot(t *testing.T) string {
 	t.Helper()
 	wd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("arbeitsverzeichnis ermitteln: %v", err)
 	}
 	return filepath.Join(wd, "..", "..")
 }
 // TestScanForExternalMailboxReferences_RealImportPackagesPass ist Teil
 // der geforderten Pflichtprüfung 3: Stichprobenreview bestätigt, dass
 // die Testsuite ohne echte externe Postfächer auskommt.
 func TestScanForExternalMailboxReferences_RealImportPackagesPass(t *testing.T) {
 	root := moduleRoot(t)
 	result, err := ScanForExternalMailboxReferences(root)
 	if err != nil {
 		t.Fatalf("scan: %v", err)
 	}
 	if !result.Passed {
 		t.Fatalf("erwartete bestandenen scan, habe verstöße: %v", result.Violations)
 	}
 }
 // TestScanForExternalMailboxReferences_DetectsRealViolation beweist,
 // dass der Scanner eine echte externe Referenz auch tatsächlich erkennt.
 func TestScanForExternalMailboxReferences_DetectsRealViolation(t *testing.T) {
 	dir := t.TempDir()
 	subDir := filepath.Join(dir, "internal", "imapimport")
 	if err := os.MkdirAll(subDir, 0o755); err != nil {
 		t.Fatalf("verzeichnis anlegen: %v", err)
 	}
 	if err := os.MkdirAll(filepath.Join(dir, "internal", "attachments"), 0o755); err != nil {
 		t.Fatalf("verzeichnis anlegen: %v", err)
 	}
 	if err := os.MkdirAll(filepath.Join(dir, "internal", "mailrules"), 0o755); err != nil {
 		t.Fatalf("verzeichnis anlegen: %v", err)
 	}
 	badFile := filepath.Join(subDir, "bad_test.go")
 	if err := os.WriteFile(badFile, []byte("package imapimport\n\n// verbindet mit imap.gmail.com\n"), 0o600); err != nil {
 		t.Fatalf("testdatei schreiben: %v", err)
 	}
 	result, err := ScanForExternalMailboxReferences(dir)
 	if err != nil {
 		t.Fatalf("scan: %v", err)
 	}
 	if result.Passed {
 		t.Fatal("erwartete erkannten verstoß, scan meldet bestanden")
 	}
 	if len(result.Violations) != 1 {
 		t.Fatalf("erwartete genau 1 verstoß, habe: %v", result.Violations)
 	}
 }
 // TestRun_RealGateAgainstImportPackages ist Teil der geforderten
 // Pflichtprüfung 1 (Testabdeckungsbericht) und Pflichtprüfung 2
 // (CI-Lauf grün auf frischem Checkout, hier real ausgeführt statt nur
 // behauptet).
 func TestRun_RealGateAgainstImportPackages(t *testing.T) {
 	if os.Getenv("TEST_TENANT_DSN") == "" {
 		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
 	}
 	root := moduleRoot(t)
 	ctx := context.Background()
 	result, err := Run(ctx, root)
 	if err != nil {
 		t.Fatalf("gate-lauf: %v", err)
 	}
 	if !result.Passed() {
 		t.Fatalf("gate fehlgeschlagen:\n%s", result.Report())
 	}
 	if len(result.TestSuite.Coverage) != 3 {
 		t.Fatalf("erwartete abdeckungsdaten für 3 pakete (imapimport/attachments/mailrules), habe %d: %+v",
 			len(result.TestSuite.Coverage), result.TestSuite.Coverage)
 	}
 	for _, c := range result.TestSuite.Coverage {
 		if c.Percent <= 0 {
 			t.Fatalf("paket %s meldet 0%% abdeckung — testabdeckungsbericht wäre wertlos", c.Package)
 		}
 	}
 	t.Logf("Gate-Bericht:\n%s", result.Report())
 }
@@ -0,0 +1,16 @@
 CREATE TABLE IF NOT EXISTS mail_index_jobs (
    id           BIGSERIAL PRIMARY KEY,
    job_type     TEXT NOT NULL CHECK (job_type IN ('index', 'delete')),
    tenant_slug  TEXT NOT NULL,
    message_id   TEXT NOT NULL,
    payload      JSONB NOT NULL DEFAULT '{}'::jsonb,
    status       TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'processing', 'succeeded', 'failed')),
    attempts     INT NOT NULL DEFAULT 0,
    max_attempts INT NOT NULL DEFAULT 5,
    available_at TIMESTAMPTZ NOT NULL DEFAULT now(),
    locked_at    TIMESTAMPTZ,
    locked_by    TEXT,
    last_error   TEXT,
    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
 )
@@ -0,0 +1,213 @@
 // Package indexworker implementiert SRC-02: einen Indexierungs-Worker,
 // der neu archivierte Mails asynchron in den Manticore-Index (SRC-01)
 // einpflegt und Löschungen/Metadatenänderungen nachzieht. Postgres-
 // Jobqueue mit FOR UPDATE SKIP LOCKED, Stale-Lock-Wiedervorlage bei
 // Worker-Absturz — dieselbe Konvention wie dms/internal/jobqueue (FDN-04),
 // hier bewusst schlanker (kein Redis/AMQP, keine DLQ — nicht Bestandteil
 // der Akzeptanzkriterien dieser Kachel).
 package indexworker
 import (
 	"context"
 	_ "embed"
 	"errors"
 	"fmt"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 //go:embed migrations/0001_mail_index_jobs.sql
 var schemaMigration string
 const (
 	JobTypeIndex  = "index"
 	JobTypeDelete = "delete"
 )
 const (
 	StatusPending    = "pending"
 	StatusProcessing = "processing"
 	StatusSucceeded  = "succeeded"
 	StatusFailed     = "failed"
 )
 // ErrNoJobAvailable wird von Dequeue geliefert, wenn aktuell kein
 // abholbarer Job vorhanden ist (Normalfall bei leerer Queue).
 var ErrNoJobAvailable = errors.New("indexworker: kein job verfügbar")
 // ErrNotFound wird geliefert, wenn ein angefragter Job nicht existiert.
 var ErrNotFound = errors.New("indexworker: job nicht gefunden")
 const defaultMaxAttempts = 5
 // Job ist eine einzelne Indexierungs-/Löschaufgabe.
 type Job struct {
 	ID         int64
 	JobType    string
 	TenantSlug string
 	MessageID  string
 	Status     string
 	Attempts   int
 }
 // Queue kapselt den Zugriff auf mail_index_jobs.
 type Queue struct {
 	pool           *pgxpool.Pool
 	staleLockAfter time.Duration
 }
 // NewQueue erzeugt eine Queue. staleLockAfter legt fest, ab wann ein
 // als "processing" markierter Job wieder abholbar gilt, weil sein Worker
 // vermutlich abgestürzt ist (Akzeptanzkriterium 3: Worker-Ausfall verliert
 // keine Indexierungsaufträge).
 func NewQueue(pool *pgxpool.Pool, staleLockAfter time.Duration) *Queue {
 	return &Queue{pool: pool, staleLockAfter: staleLockAfter}
 }
 // EnsureSchema legt die Tabelle an, falls sie noch nicht existiert —
 // gleiches Muster wie mail/internal/dedup (kein zentraler Migrationsläufer
 // für Mandanten-Datenbanken im Mail-Modul vorhanden).
 func (q *Queue) EnsureSchema(ctx context.Context) error {
 	if _, err := q.pool.Exec(ctx, schemaMigration); err != nil {
 		return fmt.Errorf("indexworker: schema anlegen: %w", err)
 	}
 	return nil
 }
 // EnqueueIndex reiht eine Indexierungsaufgabe ein (Akzeptanzkriterium 1).
 // payload enthält die für die Indexierung nötigen Felder (Betreff, Text,
 // Anhangstext) als JSON — der Worker kennt keine Klartext-Beschaffung
 // selbst, das ist Aufgabe des Aufrufers (analog dedup, das ebenfalls
 // storage/crypto nicht kennt).
 func (q *Queue) EnqueueIndex(ctx context.Context, tenantSlug, messageID string, payload []byte) (int64, error) {
 	return q.enqueue(ctx, JobTypeIndex, tenantSlug, messageID, payload)
 }
 // EnqueueDelete reiht eine Löschaufgabe ein (Akzeptanzkriterium 2).
 func (q *Queue) EnqueueDelete(ctx context.Context, tenantSlug, messageID string) (int64, error) {
 	return q.enqueue(ctx, JobTypeDelete, tenantSlug, messageID, []byte(`{}`))
 }
 func (q *Queue) enqueue(ctx context.Context, jobType, tenantSlug, messageID string, payload []byte) (int64, error) {
 	var id int64
 	err := q.pool.QueryRow(ctx, `
 		INSERT INTO mail_index_jobs (job_type, tenant_slug, message_id, payload, max_attempts)
 		VALUES ($1, $2, $3, $4, $5)
 		RETURNING id
 	`, jobType, tenantSlug, messageID, payload, defaultMaxAttempts).Scan(&id)
 	if err != nil {
 		return 0, fmt.Errorf("indexworker: job einreihen: %w", err)
 	}
 	return id, nil
 }
 // dequeuedJob trägt zusätzlich den Payload, den nur das Paket selbst
 // (worker.go) benötigt.
 type dequeuedJob struct {
 	Job
 	Payload []byte
 }
 // Dequeue holt GENAU EINEN abholbaren Job (fällig UND nicht gesperrt, ODER
 // dessen Sperre abgestanden ist) und markiert ihn atomar als "processing"
 // (Prüfung: Worker-Neustart mitten im Lauf verliert keinen offenen Auftrag
 // — FOR UPDATE SKIP LOCKED erlaubt mehreren Worker-Goroutinen gleichzeitigen
 // Aufruf ohne denselben Job doppelt zu holen).
 func (q *Queue) dequeue(ctx context.Context, workerID string) (*dequeuedJob, error) {
 	tx, err := q.pool.Begin(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("indexworker: transaktion starten: %w", err)
 	}
 	defer func() { _ = tx.Rollback(ctx) }()
 	row := tx.QueryRow(ctx, `
 		SELECT id, job_type, tenant_slug, message_id, payload, status, attempts
 		FROM mail_index_jobs
 		WHERE (
 			(status = 'pending' AND available_at <= now())
 			OR (status = 'processing' AND locked_at <= now() - ($1 * interval '1 second'))
 		)
 		ORDER BY available_at
 		FOR UPDATE SKIP LOCKED
 		LIMIT 1
 	`, q.staleLockAfter.Seconds())
 	var j dequeuedJob
 	if err := row.Scan(&j.ID, &j.JobType, &j.TenantSlug, &j.MessageID, &j.Payload, &j.Status, &j.Attempts); err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrNoJobAvailable
 		}
 		return nil, fmt.Errorf("indexworker: nächsten job lesen: %w", err)
 	}
 	if _, err := tx.Exec(ctx, `
 		UPDATE mail_index_jobs
 		SET status = 'processing', attempts = attempts + 1, locked_at = now(), locked_by = $2, updated_at = now()
 		WHERE id = $1
 	`, j.ID, workerID); err != nil {
 		return nil, fmt.Errorf("indexworker: job sperren: %w", err)
 	}
 	if err := tx.Commit(ctx); err != nil {
 		return nil, fmt.Errorf("indexworker: dequeue committen: %w", err)
 	}
 	j.Status = StatusProcessing
 	j.Attempts++
 	return &j, nil
 }
 // complete markiert einen Job als erfolgreich abgeschlossen.
 func (q *Queue) complete(ctx context.Context, jobID int64) error {
 	tag, err := q.pool.Exec(ctx, `
 		UPDATE mail_index_jobs SET status = 'succeeded', locked_at = NULL, locked_by = NULL, updated_at = now()
 		WHERE id = $1
 	`, jobID)
 	if err != nil {
 		return fmt.Errorf("indexworker: job abschließen: %w", err)
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrNotFound
 	}
 	return nil
 }
 // fail markiert einen Job als fehlgeschlagen. Sind die maximalen Versuche
 // erreicht, bleibt er dauerhaft 'failed' (keine DLQ, nicht Bestandteil
 // dieser Kachel), sonst wird er mit arithmetischem Backoff (kein
 // String-Concat für Intervalle) erneut eingeplant.
 func (q *Queue) fail(ctx context.Context, jobID int64, cause error) error {
 	tag, err := q.pool.Exec(ctx, `
 		UPDATE mail_index_jobs
 		SET status = CASE WHEN attempts >= max_attempts THEN 'failed' ELSE 'pending' END,
 		    available_at = now() + (LEAST(attempts, 10) * interval '10 seconds'),
 		    locked_at = NULL, locked_by = NULL, last_error = $2, updated_at = now()
 		WHERE id = $1
 	`, jobID, cause.Error())
 	if err != nil {
 		return fmt.Errorf("indexworker: fehlschlag erfassen: %w", err)
 	}
 	if tag.RowsAffected() == 0 {
 		return ErrNotFound
 	}
 	return nil
 }
 // Status liefert den aktuellen Zustand eines Jobs (abrufbar über API,
 // hier als Go-API — HTTP-Anbindung ist nicht Bestandteil dieser Kachel).
 func (q *Queue) Status(ctx context.Context, jobID int64) (*Job, error) {
 	var j Job
 	err := q.pool.QueryRow(ctx, `
 		SELECT id, job_type, tenant_slug, message_id, status, attempts
 		FROM mail_index_jobs WHERE id = $1
 	`, jobID).Scan(&j.ID, &j.JobType, &j.TenantSlug, &j.MessageID, &j.Status, &j.Attempts)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrNotFound
 		}
 		return nil, fmt.Errorf("indexworker: job-status lesen: %w", err)
 	}
 	return &j, nil
 }
--- a/Show More
+++ b/Show More