feat(mail): ARC-04 Aufbewahrungsstruktur (Mandant/Postfach/Jahr)

Neue Datei storage/archivekey.go: ArchiveKey(mailbox, sentAt,
messageID, partIndex) liefert den Objektschlüssel nach dem Schema
Postfach/Jahr innerhalb des bereits mandantenspezifischen Buckets
(ARC-06) — additiv neben dem bestehenden, flachen ObjectKey (ARC-01),
das für bestehende Aufrufer (mailapi/INT-01) unverändert bleibt.
ArchiveYearPrefix(mailbox, year) ist der eigenständig berechenbare
Präfix eines Postfach-Jahrs — Grundlage für spätere Retention-Regeln
ohne Migration. Fehlendes Postfach bzw. Null-Sendedatum führen zu
dokumentierten Fallback-Segmenten statt einem Ablagefehler; ArchiveKey
liefert bewusst keinen error, da es strukturell keinen Fehlerfall gibt.

Alle drei Pflichtprüfungen: mehrjähriger Import erzeugt nachweislich
getrennte Jahresordner, fehlendes Postfach/Sendedatum nutzt den
dokumentierten Fallback (inkl. Test gegen mehrere ungewöhnliche
Eingaben), sowie ergänzend ein Nachweis für Akzeptanzkriterium 2
(Retention-Präfix trifft exakt die zuvor abgelegten Schlüssel
desselben Postfach-Jahrs). Pflichtprüfung 3 (Stichprobenreview durch
zweite Person) bleibt strukturell offen, im Prüfprotokoll dokumentiert
(analog zu ING-10/QA-04/QA-02).

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

mail/docs/ARC-04-PRUEFPROTOKOLL.md

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

mail/docs/INT-06-PRUEFPROTOKOLL.md

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

mail/docs/INT-07-PRUEFPROTOKOLL.md

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

mail/internal/healthcheck/checks.go

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

mail/internal/healthcheck/checks_test.go

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

mail/internal/healthcheck/healthcheck.go

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

mail/internal/healthcheck/healthcheck_test.go

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

mail/internal/mailrules/store.go

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

mail/internal/mailrulesapi/integration_test.go

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

mail/internal/mailrulesapi/mailrulesapi.go

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

mail/internal/mailrulesapi/mailrulesapi_test.go

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

mail/internal/storage/archivekey.go

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

mail/internal/storage/archivekey_test.go

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