feat(mail): INT-07 Health-Check-Endpunkt für Mail-Modul

Neues Paket mail/internal/healthcheck: Checker sammelt benannte
CheckFunc-Prüfungen, liefert Gesamt- und Einzelstatus je Komponente
(ok/degraded, nie ein generischer Fehler). Fehlertexte einzelner
Prüfungen fließen nie in die HTTP-Antwort — nur Name+Status je
Komponente.

Vier konkrete Prüfungen (checks.go) gegen die real vorhandenen
Ticket-Abhängigkeiten: DatabaseCheck (pgxpool.Ping), ObjectStorageCheck
(HeadBucket gegen den ARC-06-Bucket), SearchIndexCheck (reale
Manticore-Anfrage), JobQueueCheck (COUNT gegen 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 auf einem vom Aufrufer bereitgestellten
*http.ServeMux, gleiches Pfadschema wie mailapi (INT-01) — Core API-01
hat weiterhin keinen abrufbaren Router.

Alle drei Pflichtprüfungen mit echten Nachweisen: simulierter Ausfall
einer von vier Abhängigkeiten korrekt als degraded abgebildet, eine
Prüfung mit absichtlich eingebetteter Verbindungszeichenfolge inkl.
Passwort im Fehlertext taucht nirgends in der HTTP-Antwort auf, echter
httptest-HTTP-Server-Integrationstest gegen den Endpunkt. Alle vier
konkreten Prüfungen zusätzlich real gegen laufende Postgres-, MinIO-
und Manticore-Instanzen verifiziert (inkl. echter ARC-06-Provisionierung).

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

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