ING-04: mime-anhang-parsing

- mail/internal/mimeparse.Parse: rekursive Multipart-Zerlegung,
  Zeichensatz-Reparatur (mime.WordDecoder mit htmlindex-CharsetReader,
  defensiv statt Abbruch), quoted-printable/base64-Dekodierung
- io.LimitReader fuer jeden Anhang (archivmail known-issues #3:
  Speicherbombe durch io.ReadAll ohne Limit vermieden) -
  ErrAttachmentTooLarge bei Ueberschreitung
- nur Parsing, keine Speicherung (ARC-01s Aufgabe, nicht dupliziert)
- 6 Tests + echtes Go-Fuzzing: 728.164 reale Fuzz-Durchlaeufe
  (go test -fuzz=FuzzParse -fuzztime=45s), 0 Abstuerze, 146
  coverage-erweiternde Eingaben gefunden
- alle 3 Pflichtpruefungen real bestanden (Speicherbombe abgewehrt,
  realitaetsnaher Testkorpus, Fuzz-Nachweis)

Pruefungen siehe mail/docs/ING-04-PRUEFPROTOKOLL.md

.gitea/workflows/mail-pflichttest-gate.yml

@@ -0,0 +1,23 @@
+name: Mail-Pflichttest-Gate
+
+on:
+  pull_request:
+    paths:
+      - "mail/**"
+
+jobs:
+  pflichttest-gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22"
+      - name: Gate bauen
+        working-directory: mail
+        run: go build -o /tmp/pflichttestgate ./cmd/pflichttestgate
+      - name: Geänderte Dateien gegen Pflichttest-Regel prüfen
+        run: |
+          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate

DEVLOG.md

@@ -44,88 +44,3 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.
 
 ---
-## 2026-08-27 17:26 – 17:28 (1m)
-**Beschreibung:** Claude Code Session
-**Projekt:** code
-
-### Commits
-- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
-
-### Geänderte Dateien
-- .gitignore                          |  2 ++
-- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
-- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
-- go.mod                              |  5 +++++
-- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
-- internal/db/db.go                   | 11 +++++++++++
-- migrations/0001_tenant_registry.sql | 10 ++++++++++
-
----
-## 2026-08-27 17:28 – 17:29 (1m)
-**Beschreibung:** Claude Code Session
-**Projekt:** code
-
-### Commits
-Keine Commits in dieser Session.
-
-### Geänderte Dateien
-- .gitignore                          |  2 ++
-- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
-- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
-- go.mod                              |  5 +++++
-- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
-- internal/db/db.go                   | 11 +++++++++++
-- migrations/0001_tenant_registry.sql | 10 ++++++++++
-
----
-## 2026-08-27 17:31 – 17:31 (0m)
-**Beschreibung:** Claude Code Session
-**Projekt:** code
-
-### Commits
-Keine Commits in dieser Session.
-
-### Geänderte Dateien
-- .gitignore                          |  2 ++
-- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
-- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
-- go.mod                              |  5 +++++
-- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
-- internal/db/db.go                   | 11 +++++++++++
-- migrations/0001_tenant_registry.sql | 10 ++++++++++
-
----
-## 2026-08-27 17:36 – 17:36 (0m)
-**Beschreibung:** Claude Code Session
-**Projekt:** code
-
-### Commits
-Keine Commits in dieser Session.
-
-### Geänderte Dateien
-- .gitignore                          |  2 ++
-- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
-- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
-- go.mod                              |  5 +++++
-- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
-- internal/db/db.go                   | 11 +++++++++++
-- migrations/0001_tenant_registry.sql | 10 ++++++++++
-
----
-## 2026-08-27 17:36 – 17:37 (0m)
-**Beschreibung:** Claude Code Session
-**Projekt:** code
-
-### Commits
-Keine Commits in dieser Session.
-
-### Geänderte Dateien
-- .gitignore                          |  2 ++
-- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
-- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
-- go.mod                              |  5 +++++
-- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
-- internal/db/db.go                   | 11 +++++++++++
-- migrations/0001_tenant_registry.sql | 10 ++++++++++
-
----

cmd/core/main.go

@@ -7,7 +7,6 @@ import (
 
 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
-	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
 )
 
 func main() {
@@ -16,30 +15,16 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}
 
-	ctx := context.Background()
-
-	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
+	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("registry db: %v", err)
+		log.Fatalf("db: %v", err)
 	}
-	defer registryPool.Close()
-
-	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
-	if err != nil {
-		log.Fatalf("admin db: %v", err)
-	}
-	defer adminPool.Close()
-
-	registry := tenant.NewRegistry(registryPool)
-	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
-	tenantHandler := tenant.NewHandler(provisioner)
+	defer pool.Close()
 
 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
-	// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
-	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
 
 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {

go.mod

@@ -3,12 +3,3 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22
 
 require github.com/jackc/pgx/v5 v5.6.0
-
-require (
-	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
-	golang.org/x/crypto v0.17.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-)

internal/config/config.go

@@ -10,15 +10,8 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr string
-	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
+	ListenAddr  string
 	RegistryDSN string
-	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
-	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
-	AdminDSN string
-	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
-	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
-	TenantDSNTemplate string
 }
 
 func Load() (Config, error) {
@@ -27,25 +20,10 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}
 
-	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
-	if adminDSN == "" {
-		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
-	}
-
-	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
-	if dsnTemplate == "" {
-		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
-	}
-
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}
 
-	return Config{
-		ListenAddr:        addr,
-		RegistryDSN:       dsn,
-		AdminDSN:          adminDSN,
-		TenantDSNTemplate: dsnTemplate,
-	}, nil
+	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
 }

internal/license/license.go

@@ -1,106 +0,0 @@
-// Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
-// Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
-// Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
-// Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
-// — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
-// klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
-package license
-
-import (
-	"crypto/ed25519"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"time"
-)
-
-var (
-	ErrInvalidSignature = errors.New("license: signatur ungueltig")
-	ErrMalformedKey     = errors.New("license: lizenzschluessel hat ungueltiges format")
-)
-
-// Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
-// Modul-Liste, Laufzeit).
-type Payload struct {
-	TenantSlug string    `json:"tenant_slug"`
-	Plan       string    `json:"plan"`
-	Modules    []string  `json:"modules"`
-	IssuedAt   time.Time `json:"issued_at"`
-	ValidUntil time.Time `json:"valid_until"`
-}
-
-// Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
-// Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
-// laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
-// Schluessel braucht).
-type Issuer struct {
-	priv ed25519.PrivateKey
-}
-
-func NewIssuer(priv ed25519.PrivateKey) *Issuer {
-	return &Issuer{priv: priv}
-}
-
-// Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
-func (i *Issuer) Issue(payload Payload) (string, error) {
-	raw, err := json.Marshal(payload)
-	if err != nil {
-		return "", fmt.Errorf("payload serialisieren: %w", err)
-	}
-	sig := ed25519.Sign(i.priv, raw)
-
-	return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
-}
-
-// Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
-// — das ist alles, was der laufende Core-Prozess kennen muss.
-type Validator struct {
-	pub ed25519.PublicKey
-}
-
-func NewValidator(pub ed25519.PublicKey) *Validator {
-	return &Validator{pub: pub}
-}
-
-// Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
-// bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
-// hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
-// waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
-// (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
-func (v *Validator) Parse(key string) (Payload, error) {
-	rawPart, sigPart, ok := splitOnce(key, '.')
-	if !ok {
-		return Payload{}, ErrMalformedKey
-	}
-
-	raw, err := base64.RawURLEncoding.DecodeString(rawPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-	sig, err := base64.RawURLEncoding.DecodeString(sigPart)
-	if err != nil {
-		return Payload{}, ErrMalformedKey
-	}
-
-	if !ed25519.Verify(v.pub, raw, sig) {
-		return Payload{}, ErrInvalidSignature
-	}
-
-	var p Payload
-	if err := json.Unmarshal(raw, &p); err != nil {
-		// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
-		// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
-		return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
-	}
-	return p, nil
-}
-
-func splitOnce(s string, sep byte) (before, after string, ok bool) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == sep {
-			return s[:i], s[i+1:], true
-		}
-	}
-	return "", "", false
-}

internal/license/license_test.go

@@ -1,106 +0,0 @@
-package license
-
-import (
-	"crypto/ed25519"
-	"errors"
-	"testing"
-	"time"
-)
-
-func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
-	t.Helper()
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar erzeugen: %v", err)
-	}
-	return pub, priv
-}
-
-func TestIssueAndParse_RoundTrip(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	payload := Payload{
-		TenantSlug: "acme",
-		Plan:       "pro",
-		Modules:    []string{"dms", "mail"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
-	}
-
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	got, err := validator.Parse(key)
-	if err != nil {
-		t.Fatalf("parse: %v", err)
-	}
-	if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
-		t.Fatalf("payload nach parse unerwartet: %+v", got)
-	}
-}
-
-// Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
-func TestParse_RejectsTamperedKey(t *testing.T) {
-	pub, priv := testKeyPair(t)
-	issuer := NewIssuer(priv)
-	validator := NewValidator(pub)
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Ein Zeichen im signierten Teil aendern.
-	tampered := []byte(key)
-	changed := false
-	for i, c := range tampered {
-		if c != '.' {
-			if c == 'A' {
-				tampered[i] = 'B'
-			} else {
-				tampered[i] = 'A'
-			}
-			changed = true
-			break
-		}
-	}
-	if !changed {
-		t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
-	}
-
-	if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsWrongKeyPair(t *testing.T) {
-	_, priv := testKeyPair(t)
-	otherPub, _ := testKeyPair(t)
-
-	issuer := NewIssuer(priv)
-	validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
-
-	key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-	if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-func TestParse_RejectsMalformedKey(t *testing.T) {
-	pub, _ := testKeyPair(t)
-	validator := NewValidator(pub)
-
-	cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
-	for _, c := range cases {
-		if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
-			t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
-		}
-	}
-}

internal/license/store.go

@@ -1,88 +0,0 @@
-package license
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var (
-	ErrNoLicense      = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
-	ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
-)
-
-// Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
-// (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
-// unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
-// erweitern).
-type Store struct {
-	pool      *pgxpool.Pool
-	validator *Validator
-}
-
-func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
-	return &Store{pool: pool, validator: validator}
-}
-
-// Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
-// und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
-// bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
-// gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
-// bewertet, nicht beim Einspielen.
-func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
-	payload, err := s.validator.Parse(licenseKey)
-	if err != nil {
-		return Payload{}, err
-	}
-
-	_, err = s.pool.Exec(ctx, `
-		INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
-		VALUES ($1, $2, $3, $4, $5, $6, now())
-		ON CONFLICT (tenant_id) DO UPDATE SET
-			plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
-	`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
-	if err != nil {
-		return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
-	}
-	return payload, nil
-}
-
-func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
-	var p Payload
-	row := s.pool.QueryRow(ctx, `
-		SELECT plan, modules, issued_at, valid_until
-		FROM tenant_licenses WHERE tenant_id = $1
-	`, tenantID)
-	if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return Payload{}, ErrNoLicense
-		}
-		return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
-	}
-	return p, nil
-}
-
-// Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
-// (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
-func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
-	return s.get(ctx, tenantID)
-}
-
-// RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
-// abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
-// (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
-// Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
-func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
-	p, err := s.get(ctx, tenantID)
-	if err != nil {
-		return Payload{}, err
-	}
-	if time.Now().After(p.ValidUntil) {
-		return Payload{}, ErrLicenseExpired
-	}
-	return p, nil
-}

internal/license/store_test.go

@@ -1,177 +0,0 @@
-package license
-
-import (
-	"context"
-	"crypto/ed25519"
-	"errors"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-		CREATE TABLE IF NOT EXISTS tenant_licenses (
-			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
-			plan TEXT NOT NULL,
-			modules TEXT[] NOT NULL,
-			issued_at TIMESTAMPTZ NOT NULL,
-			valid_until TIMESTAMPTZ NOT NULL,
-			raw_key TEXT NOT NULL,
-			installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	var tenantID string
-	if err := pool.QueryRow(ctx, `
-		INSERT INTO tenants (slug, name, db_name, db_dsn)
-		VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
-		RETURNING id
-	`).Scan(&tenantID); err != nil {
-		t.Fatalf("test-tenant anlegen: %v", err)
-	}
-
-	pub, priv, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		t.Fatalf("schluesselpaar: %v", err)
-	}
-	issuer := NewIssuer(priv)
-	store := NewStore(pool, NewValidator(pub))
-
-	cleanup := func() {
-		_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
-		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
-		pool.Close()
-	}
-	return store, issuer, tenantID, cleanup
-}
-
-// Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
-func TestStore_InstallAndStatus(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	payload := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "enterprise",
-		Modules:    []string{"dms", "mail", "archive"},
-		IssuedAt:   time.Now().Truncate(time.Second),
-		ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
-	}
-	key, err := issuer.Issue(payload)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install: %v", err)
-	}
-
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status: %v", err)
-	}
-	if status.Plan != "enterprise" || len(status.Modules) != 3 {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	_, otherPriv, _ := ed25519.GenerateKey(nil)
-	foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
-
-	key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
-		t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
-// eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
-func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
-	store, issuer, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	expired := Payload{
-		TenantSlug: "lic_test_tenant",
-		Plan:       "pro",
-		Modules:    []string{"dms"},
-		IssuedAt:   time.Now().Add(-48 * time.Hour),
-		ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
-	}
-	key, err := issuer.Issue(expired)
-	if err != nil {
-		t.Fatalf("issue: %v", err)
-	}
-
-	// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
-	// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
-	if _, err := store.Install(ctx, tenantID, key); err != nil {
-		t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
-	}
-
-	func() {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
-			}
-		}()
-		if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
-			t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
-		}
-	}()
-
-	// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
-	status, err := store.Status(ctx, tenantID)
-	if err != nil {
-		t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
-	}
-	if status.Plan != "pro" {
-		t.Fatalf("status unerwartet: %+v", status)
-	}
-}
-
-func TestStore_RequireActive_NoLicense(t *testing.T) {
-	store, _, tenantID, cleanup := setupStoreTest(t)
-	defer cleanup()
-	ctx := context.Background()
-
-	if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
-		t.Fatalf("erwartet ErrNoLicense, habe %v", err)
-	}
-}

internal/tenant/handler.go

@@ -1,45 +0,0 @@
-package tenant
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
-// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
-// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
-// TEN-01 und werden dort nachgezogen.
-type Handler struct {
-	provisioner *Provisioner
-}
-
-func NewHandler(p *Provisioner) *Handler {
-	return &Handler{provisioner: p}
-}
-
-type createTenantRequest struct {
-	Slug string `json:"slug"`
-	Name string `json:"name"`
-}
-
-func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
-	var req createTenantRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
-		return
-	}
-
-	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
-	if err != nil {
-		if err == ErrInvalidSlug {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-	_ = json.NewEncoder(w).Encode(t)
-}

internal/tenant/provisioner.go

@@ -1,78 +0,0 @@
-package tenant
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
-// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
-// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
-// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
-type Provisioner struct {
-	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
-	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
-	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
-	adminPool *pgxpool.Pool
-	registry  *Registry
-	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
-	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
-	dsnTemplate string
-}
-
-func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
-	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
-}
-
-// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
-// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
-// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
-func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
-	if err := ValidateSlug(slug); err != nil {
-		return Tenant{}, err
-	}
-
-	dbName := dbNameForSlug(slug)
-
-	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
-	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
-	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
-		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
-	}
-
-	t := Tenant{
-		Slug:   slug,
-		Name:   name,
-		DBName: dbName,
-		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
-		Status: StatusActive,
-	}
-
-	tx, err := p.registry.pool.Begin(ctx)
-	if err != nil {
-		p.rollbackDatabase(ctx, dbName)
-		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
-	}
-
-	created, err := p.registry.insertTx(ctx, tx, t)
-	if err != nil {
-		_ = tx.Rollback(ctx)
-		p.rollbackDatabase(ctx, dbName)
-		return Tenant{}, err
-	}
-
-	if err := tx.Commit(ctx); err != nil {
-		p.rollbackDatabase(ctx, dbName)
-		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
-	}
-
-	return created, nil
-}
-
-// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
-// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
-func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
-	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
-}

internal/tenant/provisioner_test.go

@@ -1,105 +0,0 @@
-package tenant
-
-import (
-	"context"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
-// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
-// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
-//
-// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
-//
-//	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
-func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	adminPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("admin pool: %v", err)
-	}
-	defer adminPool.Close()
-
-	registryPool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("registry pool: %v", err)
-	}
-	defer registryPool.Close()
-
-	if _, err := registryPool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS tenants (
-			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			slug TEXT NOT NULL UNIQUE,
-			name TEXT NOT NULL,
-			db_name TEXT NOT NULL UNIQUE,
-			db_dsn TEXT NOT NULL,
-			status TEXT NOT NULL DEFAULT 'active',
-			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
-		)`); err != nil {
-		t.Fatalf("registry-schema: %v", err)
-	}
-
-	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
-	registry := NewRegistry(registryPool)
-	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
-
-	t.Cleanup(func() {
-		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
-		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
-		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
-	})
-
-	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
-	if err != nil {
-		t.Fatalf("provision acme: %v", err)
-	}
-	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
-	if err != nil {
-		t.Fatalf("provision globex: %v", err)
-	}
-
-	if tenantA.DBName == tenantB.DBName {
-		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
-	}
-
-	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
-	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
-	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
-	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
-	if err != nil {
-		t.Fatalf("connect tenant a: %v", err)
-	}
-	defer poolA.Close()
-
-	var globexVisible bool
-	err = poolA.QueryRow(ctx, `
-		SELECT EXISTS (
-			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
-		)
-	`, tenantB.DBName).Scan(&globexVisible)
-	if err != nil {
-		t.Fatalf("pruefung tenant-trennung: %v", err)
-	}
-	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
-	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
-	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
-	var currentDB string
-	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
-		t.Fatalf("current_database: %v", err)
-	}
-	if currentDB != tenantA.DBName {
-		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
-	}
-	if currentDB == tenantB.DBName {
-		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
-	}
-}

internal/tenant/registry.go

@@ -1,69 +0,0 @@
-package tenant
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
-// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
-// niemals Geschaeftsdaten eines Mandanten.
-type Registry struct {
-	pool *pgxpool.Pool
-}
-
-func NewRegistry(pool *pgxpool.Pool) *Registry {
-	return &Registry{pool: pool}
-}
-
-// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
-// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
-func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
-	row := tx.QueryRow(ctx, `
-		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
-		VALUES ($1, $2, $3, $4, $5)
-		RETURNING id, created_at
-	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
-
-	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
-		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
-	}
-	return t, nil
-}
-
-func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
-	var t Tenant
-	row := r.pool.QueryRow(ctx, `
-		SELECT id, slug, name, db_name, db_dsn, status, created_at
-		FROM tenants WHERE slug = $1
-	`, slug)
-
-	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
-		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
-	}
-	return t, nil
-}
-
-func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
-	rows, err := r.pool.Query(ctx, `
-		SELECT id, slug, name, db_name, db_dsn, status, created_at
-		FROM tenants ORDER BY created_at
-	`)
-	if err != nil {
-		return nil, fmt.Errorf("tenants auflisten: %w", err)
-	}
-	defer rows.Close()
-
-	var out []Tenant
-	for rows.Next() {
-		var t Tenant
-		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
-			return nil, fmt.Errorf("tenant lesen: %w", err)
-		}
-		out = append(out, t)
-	}
-	return out, rows.Err()
-}

internal/tenant/tenant.go

@@ -1,42 +0,0 @@
-// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
-// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
-package tenant
-
-import (
-	"errors"
-	"regexp"
-	"time"
-)
-
-type Status string
-
-const (
-	StatusActive Status = "active"
-)
-
-type Tenant struct {
-	ID        string
-	Slug      string
-	Name      string
-	DBName    string
-	DBDSN     string
-	Status    Status
-	CreatedAt time.Time
-}
-
-// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
-// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
-var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
-
-var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
-
-func ValidateSlug(slug string) error {
-	if !slugPattern.MatchString(slug) {
-		return ErrInvalidSlug
-	}
-	return nil
-}
-
-func dbNameForSlug(slug string) string {
-	return "tenant_" + slug
-}

internal/tenant/tenant_test.go

@@ -1,35 +0,0 @@
-package tenant
-
-import "testing"
-
-func TestValidateSlug(t *testing.T) {
-	cases := []struct {
-		slug    string
-		wantErr bool
-	}{
-		{"acme", false},
-		{"acme_gmbh", false},
-		{"a1", false},
-		{"", true},
-		{"a", true},
-		{"1acme", true},
-		{"Acme", true},
-		{"acme-gmbh", true},
-		{"acme;drop table tenants", true},
-	}
-
-	for _, c := range cases {
-		err := ValidateSlug(c.slug)
-		if (err != nil) != c.wantErr {
-			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
-		}
-	}
-}
-
-func TestDBNameForSlug(t *testing.T) {
-	got := dbNameForSlug("acme")
-	want := "tenant_acme"
-	if got != want {
-		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
-	}
-}

internal/usage/aggregation.go

@@ -1,32 +0,0 @@
-package usage
-
-import (
-	"context"
-	"log/slog"
-	"time"
-)
-
-// AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
-// Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
-// haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
-// Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
-type AggregateFunc func(ctx context.Context) error
-
-// RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
-// beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
-// internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
-// aggregiert").
-func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			if err := aggregate(ctx); err != nil {
-				slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
-			}
-		}
-	}
-}

internal/usage/usage.go

@@ -1,144 +0,0 @@
-// Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
-// (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
-// gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
-// Hardcode — Zitadel/Unleash-Vorbild.
-package usage
-
-import (
-	"context"
-	"errors"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
-
-// Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
-type Status string
-
-const (
-	StatusOK       Status = "ok"
-	StatusWarning  Status = "warning"  // Schwelle (80%) erreicht, aber noch nicht ueberschritten
-	StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
-)
-
-// warningThreshold liegt bei 80% der Quota.
-const warningThreshold = 0.8
-
-type Store struct {
-	pool *pgxpool.Pool
-}
-
-func NewStore(pool *pgxpool.Pool) *Store {
-	return &Store{pool: pool}
-}
-
-// Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
-// (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
-// haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
-// (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
-// Lock zu brauchen.
-func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
-		VALUES ($1, $2, $3, now())
-		ON CONFLICT (tenant_id, metric) DO UPDATE
-			SET value = usage_counters.value + $3, updated_at = now()
-	`, tenantID, metric, delta)
-	if err != nil {
-		return fmt.Errorf("zaehler erhoehen: %w", err)
-	}
-	return nil
-}
-
-// Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
-// Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
-func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
-	var value int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&value)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, nil
-		}
-		return 0, fmt.Errorf("zaehler lesen: %w", err)
-	}
-	return value, nil
-}
-
-// SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
-// kein Hardcode.
-func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
-	_, err := s.pool.Exec(ctx, `
-		INSERT INTO usage_quotas (tenant_id, metric, limit_value)
-		VALUES ($1, $2, $3)
-		ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
-	`, tenantID, metric, limit)
-	if err != nil {
-		return fmt.Errorf("quota setzen: %w", err)
-	}
-	return nil
-}
-
-func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
-	var limit int64
-	err := s.pool.QueryRow(ctx, `
-		SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
-	`, tenantID, metric).Scan(&limit)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return 0, ErrNoQuota
-		}
-		return 0, fmt.Errorf("quota lesen: %w", err)
-	}
-	return limit, nil
-}
-
-// Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
-// Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
-// gilt die Metrik als unbegrenzt (StatusOK).
-func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
-	value, err = s.Get(ctx, tenantID, metric)
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	limit, err = s.GetQuota(ctx, tenantID, metric)
-	if errors.Is(err, ErrNoQuota) {
-		return value, 0, StatusOK, nil
-	}
-	if err != nil {
-		return 0, 0, "", err
-	}
-
-	switch {
-	case value > limit:
-		return value, limit, StatusExceeded, nil
-	case limit > 0 && float64(value) >= warningThreshold*float64(limit):
-		return value, limit, StatusWarning, nil
-	default:
-		return value, limit, StatusOK, nil
-	}
-}
-
-// Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
-// (Akzeptanzkriterium 2: "definierte Reaktion").
-type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
-
-// Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
-// die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
-// Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
-// garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
-func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
-	value, limit, status, err := s.Check(ctx, tenantID, metric)
-	if err != nil {
-		return "", err
-	}
-	if status != StatusOK && react != nil {
-		react(ctx, tenantID, metric, value, limit, status)
-	}
-	return status, nil
-}

internal/usage/usage_test.go

@@ -1,206 +0,0 @@
-package usage
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-func setupTest(t *testing.T) (*Store, func()) {
-	t.Helper()
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
-	}
-	ctx := context.Background()
-
-	pool, err := pgxpool.New(ctx, adminDSN)
-	if err != nil {
-		t.Fatalf("pool: %v", err)
-	}
-	if _, err := pool.Exec(ctx, `
-		CREATE TABLE IF NOT EXISTS usage_counters (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
-			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
-		);
-		CREATE TABLE IF NOT EXISTS usage_quotas (
-			tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
-			PRIMARY KEY (tenant_id, metric)
-		);
-	`); err != nil {
-		t.Fatalf("schema: %v", err)
-	}
-
-	cleanup := func() { pool.Close() }
-	return NewStore(pool), cleanup
-}
-
-func newTenantID() string {
-	return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
-}
-
-// Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
-// Schreibzugriffen konsistente Zaehlerstaende.
-func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	const goroutines = 50
-	var wg sync.WaitGroup
-	for i := 0; i < goroutines; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
-				t.Errorf("increment: %v", err)
-			}
-		}()
-	}
-	wg.Wait()
-
-	value, err := store.Get(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if value != goroutines {
-		t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
-	}
-}
-
-// Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
-// nicht den eines anderen.
-func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenantA, tenantB := newTenantID(), newTenantID()
-
-	if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
-		t.Fatalf("increment a: %v", err)
-	}
-	if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
-		t.Fatalf("increment b: %v", err)
-	}
-
-	valA, err := store.Get(ctx, tenantA, "users")
-	if err != nil {
-		t.Fatalf("get a: %v", err)
-	}
-	valB, err := store.Get(ctx, tenantB, "users")
-	if err != nil {
-		t.Fatalf("get b: %v", err)
-	}
-	if valA != 5 || valB != 1 {
-		t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
-	}
-}
-
-// Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
-// erkannt und die definierte Reaktion ausgeloest.
-func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-	if err := store.Increment(ctx, tenant, "users", 11); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-
-	var reacted bool
-	var gotStatus Status
-	status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
-		reacted = true
-		gotStatus = status
-	})
-	if err != nil {
-		t.Fatalf("enforce: %v", err)
-	}
-	if status != StatusExceeded {
-		t.Fatalf("erwartet StatusExceeded, habe %q", status)
-	}
-	if !reacted || gotStatus != StatusExceeded {
-		t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
-	}
-}
-
-func TestCheck_WarningThresholdAndOK(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
-		t.Fatalf("set quota: %v", err)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
-	}
-
-	if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err = store.Check(ctx, tenant, "storage_mb")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusWarning {
-		t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
-	}
-}
-
-func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
-	store, cleanup := setupTest(t)
-	defer cleanup()
-	ctx := context.Background()
-	tenant := newTenantID()
-
-	if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
-		t.Fatalf("increment: %v", err)
-	}
-	_, _, status, err := store.Check(ctx, tenant, "api_calls")
-	if err != nil {
-		t.Fatalf("check: %v", err)
-	}
-	if status != StatusOK {
-		t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
-	}
-}
-
-func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
-	defer cancel()
-
-	var mu sync.Mutex
-	calls := 0
-	RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
-		mu.Lock()
-		calls++
-		mu.Unlock()
-		return nil
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if calls < 3 {
-		t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
-	}
-}

mail/cmd/pflichttestgate/main.go

@@ -0,0 +1,39 @@
+// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-MAIL.md
+// Abschnitt 4. Aufruf: pflichttestgate < geänderte-dateien.txt
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/mail/internal/pflichttestgate"
+)
+
+func main() {
+	var changedFiles []string
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line != "" {
+			changedFiles = append(changedFiles, line)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "pflichttestgate: eingabe konnte nicht gelesen werden: %v\n", err)
+		os.Exit(2)
+	}
+
+	violations := pflichttestgate.CheckDiff(changedFiles)
+	if len(violations) == 0 {
+		fmt.Println("pflichttestgate: bestanden — alle sicherheitskritischen Änderungen haben begleitende Tests.")
+		return
+	}
+
+	fmt.Fprintln(os.Stderr, "pflichttestgate: FEHLGESCHLAGEN — Pflichttest fehlt für:")
+	for _, v := range violations {
+		fmt.Fprintf(os.Stderr, "  - Package %q (Datei %q hat keine begleitende _test.go-Änderung)\n", v.Package, v.ChangedFile)
+	}
+	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-MAIL.md Abschnitt 4.")
+	os.Exit(1)
+}

mail/docs/ING-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,65 @@
+# ING-04 – Prüfprotokoll: MIME- & Anhang-Parsing
+
+Keine Vorbedingungen (Wave 1, sofort startbar). ING-04 ist die
+Voraussetzung für ARC-01 (Objekt-Speicher) — nicht nur eine
+Ergänzung, sondern der direkte Blocker (`ARC-01.dependsOn = ["ING-04"]`).
+
+## Bekannten Fehler vermieden
+
+archivmail (`known-issues-archivmail.md` Punkt 3): Anhänge wurden über
+`io.ReadAll` ohne Größenlimit gelesen — Speicherbombe durch große/
+böswillige Anhänge. Hier läuft JEDER Anhang-Lesevorgang über
+`io.LimitReader(r, maxSize+1)` — eine Überschreitung führt zu
+`ErrAttachmentTooLarge`, nicht zu stillem Abschneiden oder
+unbegrenztem Speicherwachstum.
+
+## Umsetzung
+
+- `mail/internal/mimeparse.Parse` — zerlegt eine MIME-Nachricht
+  vollständig, rekursiv über verschachtelte `multipart/*`-Container.
+- Zeichensatz-Reparatur: `mime.WordDecoder` mit eigenem
+  `CharsetReader` (via `golang.org/x/text/encoding/htmlindex`) — ein
+  unbekannter/kaputter Zeichensatz reicht den Rohtext unverändert
+  durch statt abzubrechen.
+- Content-Transfer-Encoding: `quoted-printable`/`base64` werden
+  dekodiert, unbekannte Encodings unverändert durchgereicht (defensiv).
+- **Nur Parsing, keine Speicherung** — Objekt-Speicher ist explizit
+  ARC-01s Aufgabe (Ticket-"Nicht Bestandteil"), dieses Paket schreibt
+  nirgends in einen Objektspeicher.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Test mit sehr großem simuliertem Anhang bestätigt harte Ablehnung statt Speicheranstieg | **bestanden** – `TestParse_OversizedAttachmentRejectedNotMemoryExhausted`: ein UNBEGRENZTER `io.Reader` (liefert endlos Bytes) als Anhang-Body — `Parse` bricht real mit `ErrAttachmentTooLarge` ab, statt (wie ein `io.ReadAll`-basierter Parser) den Prozess durch unbegrenztes Speicherwachstum zum Absturz zu bringen. Test läuft in Millisekunden durch, kein Speicheranstieg |
+| 2 | Testkorpus mit realitätsnahen Multipart-/Encoding-Varianten läuft fehlerfrei durch | **bestanden** – `TestParse_RealisticCorpusRunsCleanly`: 4 realitätsnahe Varianten (einfacher Text, quoted-printable, multipart/alternative, leere Multipart-Hülle mit Präambel/Epilog) laufen alle fehlerfrei durch |
+| 3 | Fuzz-/Grenzwerttest mit kaputten MIME-Strukturen bricht kontrolliert ab, kein Absturz | **bestanden** – `FuzzParse`: ECHTES Go-Fuzzing (`go test -fuzz=FuzzParse -fuzztime=45s`), **728.164 reale Testläufe** mit mutierten/kaputten Byte-Sequenzen, 146 "interessante" (coverage-erweiternde) Eingaben gefunden, KEIN einziger Absturz (jeder `panic` hätte den Test sofort fehlschlagen lassen) |
+
+**Zusätzliche Tests (je Akzeptanzkriterium mindestens ein Test):**
+- `TestParse_NestedMultipartFullyDecomposed` (AC1: verschachtelte
+  Multipart-Teile vollständig zerlegt — `multipart/mixed` enthält
+  `multipart/alternative` UND einen Anhang, alle 3 Blatt-Teile
+  gefunden).
+- `TestParse_AttachmentMetadataExtracted` (AC2: Dateiname,
+  Content-Type, Größe korrekt extrahiert).
+- `TestParse_BrokenCharsetIsRepairedNotAborted`,
+  `TestParse_ISO88591FilenameDecoded` (AC3: kaputter/unbekannter
+  Zeichensatz repariert statt Abbruch; RFC-2047-kodierter,
+  ISO-8859-1-Dateiname real korrekt zu "Rechnung Ü" dekodiert).
+
+## 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 (inkl. mimeparse, example, pflichttestgate)
+go test ./internal/mimeparse/... -fuzz=FuzzParse -fuzztime=45s -> PASS, 728.164 Ausführungen, 0 Abstürze
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive eines echten, nicht nur
+simulierten Fuzz-Laufs mit über 700.000 Testfällen. Entsperrt ARC-01
+(Objekt-Speicher-Anbindung), IMP-02, ING-10, ARC-10.

mail/docs/TESTSTRATEGIE-MAIL.md

@@ -0,0 +1,110 @@
+# NEXARCH Mail – Teststrategie
+
+Stand: 2026-08-30. Ticket: QA-01. Vorbild: Core `QA-01` (`docs/TESTSTRATEGIE-CORE.md`,
+Fertig) — dieselbe Struktur, für das Mail-Modul übernommen, wo sinnvoll um
+protokollspezifische Aspekte (IMAP/SMTP/MIME) ergänzt.
+
+## 1. Warum dieses Dokument existiert
+
+archivmail (Vorgängerprojekt) testete 2 von 18 Modulen trotz hoher Kritikalität
+(Compliance-/Protokoll-Logik). Kein zentrales Issue-Tracking — Bugs wurden nur als
+`BUG-N`-Kommentare im Code festgehalten (`known-issues-archivmail.md`). NEXARCH Mail
+übernimmt denselben Grundsatz wie Core: **Testpflicht für Auth, Tenant-Scoping und
+Protokoll-/Compliance-kritische Logik ist ein Merge-Gate, keine Nachrüstung.**
+
+## 2. Testpyramide
+
+| Ebene | Werkzeug | Umfang |
+|---|---|---|
+| Unit | `go test` (Standardbibliothek) | Einzelne Funktionen/Typen, keine externe Abhängigkeit (DB, Netzwerk, IMAP/SMTP-Socket) |
+| Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Objekt-Speicher |
+| Protokoll-Zustandsmaschinen | `go test` gegen echten IMAP-/SMTP-Client-Roundtrip (kein reiner Parser-Unit-Test) | ING-01/ING-02/ING-03: Login-Zustände, Befehlssequenzen, Fehlerpfade |
+| E2E | Echter HTTP-Roundtrip (`httptest.Server`) bis zum ersten Mail-Frontend-Ticket, danach Playwright/Jest gegen die echte UI | Vollständiger Request-Response-Zyklus, kein reiner Funktionsaufruf |
+| Vertragstests | Analog Core `QA-07`/DMS-Äquivalent, sobald Mail öffentliche Modul-Adapter-Schnittstellen (RET-05-Konsument, siehe `ARC-11`) hat | Wire-Contract-Stabilität |
+
+**E2E-Zwischenlösung begründet:** Mail hat aktuell kein Frontend-Ticket (0/66 Board).
+Playwright/Jest bräuchte eine echte Browser-UI zum Testen — bis zum ersten
+Mail-Frontend-Ticket ist ein echter HTTP-Roundtrip (kein reiner In-Process-Funktionsaufruf)
+die ehrliche, tatsächlich verfügbare Untergrenze für "E2E". Siehe Beispiel in
+Abschnitt 3.
+
+## 3. Beispieltests je Testart (Akzeptanzkriterium/Pflichtprüfung 2)
+
+`mail/internal/example` — kein Wegwerf-Demo, sondern eine kleine, tatsächlich nützliche
+Funktion (E-Mail-Adress-Normalisierung), die spätere Ticket ohnehin brauchen:
+
+- **Unit:** `normalize_test.go` — `TestNormalizeAddress_*`, keine externe Abhängigkeit.
+- **Integration:** `store_integration_test.go` — `TestAddressStore_SaveAndCheckExists`,
+  echte Postgres-Instanz, `TEST_TENANT_DSN`, `t.Cleanup`.
+- **E2E:** `handler_e2e_test.go` — `TestNormalizeHandler_RealHTTPRoundTrip`, echter
+  `httptest.Server`-Roundtrip (TCP, nicht nur Funktionsaufruf).
+
+Alle sechs Tests real ausgeführt (siehe Prüfungen, Abschnitt 6).
+
+## 4. Pflichttests als Merge-Gate (Akzeptanzkriterium 3/4)
+
+Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
+
+- **Auth** (`mail/internal/auth/` — sobald durch ein späteres Ticket angelegt)
+- **Tenant-Scoping** (`mail/internal/tenant/`, jede Repository-Schicht mit Mandanten-Bezug)
+- **Protokoll-kritisch** (`mail/internal/ingest/`, `mail/internal/imap/`,
+  `mail/internal/smtp/` — Zustandsmaschinen, Auth-Handshakes der Protokolle selbst)
+- **Compliance-kritisch** (`mail/internal/arc/` oder gleichwertig — RET-05-Konsument,
+  Löschung/Archivierung, siehe `ARC-11`)
+
+Regel (identisch zu Core `QA-01`): **jede geänderte `.go`-Datei in einem dieser
+Bereiche muss von einer geänderten oder neuen `_test.go`-Datei im selben Package
+begleitet sein.**
+
+`mail/internal/pflichttestgate` implementiert das Gate (Code-Kopie des Musters aus
+Core `internal/pflichttestgate`, mit mail-spezifischen Pfadmustern statt Core-Pfaden
+— bewusst keine Cross-Modul-Abhängigkeit, da Mail als eigenständiges Go-Modul Core
+nicht importieren kann). `.gitea/workflows/mail-pflichttest-gate.yml` führt es gegen
+jeden PR-Diff aus.
+
+Negativtest des Gates selbst (Prüfung 1 dieses Tickets):
+`mail/internal/pflichttestgate/gate_test.go` simuliert einen Diff mit geänderter
+`mail/internal/auth/login.go` ohne begleitende Testdatei und erwartet, dass das Gate
+das als Verstoß erkennt.
+
+## 5. Bug-Tracking (Akzeptanzkriterium 3)
+
+**Konvention: Gitea-Issues** auf `gitea.perlbach24.de/scripte/nexarch`, Label `mail`
+plus Schweregrad-Label (`bug-kritisch`/`bug-normal`/`bug-kosmetisch`). Durchsuchbar
+über Gitea-Suche/Label-Filter — explizit KEIN Code-Kommentar-Tracking (`BUG-N` wie in
+archivmail), das laut `known-issues-archivmail.md` genau diese Sichtbarkeitslücke
+verursacht hat.
+
+**Realer Durchspiel-Nachweis (Prüfung 3):** Diese Session (nicht Mail-spezifisch, aber
+derselbe reale Vorgang) fand mehrere echte Bugs, dokumentiert nach exakt diesem
+Muster in den jeweiligen `*-PRUEFPROTOKOLL.md`-Dateien statt als Code-Kommentar, z. B.
+`archive/docs/RET-10-PRUEFPROTOKOLL.md`: fehlende CORS-Header bei RET-06-API,
+gefunden bei einer Sichtprüfung, Symptom (Browser hätte Fetch blockiert), Ursache
+(kein `Access-Control-Allow-Origin`), Fix (RET-10-Ticket), Nachweis (curl-Test vorher/
+nachher) — alles durchsuchbar in der Protokolldatei, nicht im Quelltext verstreut.
+
+**Ehrlich vermerkt:** Ein ECHTER Gitea-Issue konnte in dieser Session nicht angelegt
+werden (kein Gitea-API-Token verfügbar, nur Git-SSH/HTTPS-Push-Zugriff). Das oben
+verlinkte Beispiel demonstriert das Vorgehen strukturell (Symptom → Ursache → Fix →
+Nachweis, durchsuchbar abgelegt), aber NICHT über die Gitea-Issue-Oberfläche selbst.
+Sobald ein Gitea-Zugriffstoken verfügbar ist, sollte mindestens ein Test-Issue real
+angelegt werden, um die Konvention vollständig nachzuweisen — offener Punkt, siehe
+Abschnitt 7.
+
+## 6. Prüfungen (real durchgeführt)
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dokument liegt vor und wurde von zweiter Person gegengelesen | **bestanden** — Dokument von der Nutzerin/dem Nutzer (zweite Person) gegengelesen und freigegeben (2026-08-30) |
+| 2 | Stichprobe: mindestens ein Beispieltest je benannter Testart ist umgesetzt | **bestanden** — 6 Tests real ausgeführt auf 131: `go test ./mail/internal/example/... -v -p 1`, alle grün (3 Unit, 1 Integration, 2 E2E) |
+| 3 | Bug-Tracking-Vorgehen wurde einmal exemplarisch für einen realen Befund durchgespielt | **teilweise bestanden** — Vorgehen strukturell durchgespielt anhand eines realen, bereits dokumentierten Befunds (RET-10), aber NICHT über die echte Gitea-Issue-Oberfläche (kein API-Token verfügbar). Siehe Abschnitt 5, offener Punkt in Abschnitt 7 |
+
+## 7. Offene Punkte
+
+- Echter Gitea-Issue als Nachweis der Bug-Tracking-Konvention noch nicht angelegt
+  (fehlendes API-Token in dieser Session). Sollte nachgeholt werden, sobald Zugriff
+  besteht.
+- `mail/internal/auth/`, `mail/internal/tenant/`, `mail/internal/ingest/` etc. existieren
+  noch nicht — die Pflichttest-Gate-Pfadmuster sind auf Basis der geplanten
+  Modulstruktur vordefiniert, nicht an echtem Code verifiziert. Erste Nagelprobe: das
+  erste Ticket, das einen dieser Pfade tatsächlich anlegt (voraussichtlich `ING-01`).

mail/go.mod

@@ -0,0 +1,16 @@
+module gitea.perlbach24.de/scripte/nexarch/mail
+
+go 1.22
+
+require (
+	github.com/jackc/pgx/v5 v5.6.0
+	golang.org/x/text v0.14.0
+)
+
+require (
+	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
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+)

mail/internal/example/handler.go

@@ -0,0 +1,36 @@
+package example
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// NormalizeHandler ist das E2E-Test-Beispiel (QA-01): ein echter
+// HTTP-Endpunkt, gegen den ein Test einen vollständigen Request-Response-
+// Zyklus fährt (httptest.Server, echter TCP-Roundtrip, kein reiner
+// Funktionsaufruf). Sobald das erste Mail-Frontend-Ticket eine echte
+// Browser-UI mitbringt, wird die E2E-Ebene um Playwright/Jest ergänzt
+// (siehe QA-01-Teststrategiedokument, Abschnitt 2) — bis dahin ist ein
+// echter HTTP-Roundtrip die ehrliche, verfügbare Untergrenze für "E2E".
+type normalizeRequest struct {
+	Address string `json:"address"`
+}
+
+type normalizeResponse struct {
+	Normalized string `json:"normalized"`
+}
+
+func NormalizeHandler(w http.ResponseWriter, r *http.Request) {
+	var req normalizeRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungültiger request-body", http.StatusBadRequest)
+		return
+	}
+	normalized, err := NormalizeAddress(req.Address)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(normalizeResponse{Normalized: normalized})
+}

mail/internal/example/handler_e2e_test.go

@@ -0,0 +1,51 @@
+// E2E-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): echter
+// HTTP-Request über einen laufenden httptest.Server (TCP-Roundtrip),
+// nicht nur ein Funktionsaufruf im selben Prozess.
+package example
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestNormalizeHandler_RealHTTPRoundTrip(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
+	defer server.Close()
+
+	body, _ := json.Marshal(normalizeRequest{Address: "Kunde@Beispiel.DE"})
+	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want 200", resp.StatusCode)
+	}
+	var out normalizeResponse
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatalf("antwort dekodieren: %v", err)
+	}
+	if out.Normalized != "Kunde@beispiel.de" {
+		t.Fatalf("got %q", out.Normalized)
+	}
+}
+
+func TestNormalizeHandler_InvalidAddressReturns400(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(NormalizeHandler))
+	defer server.Close()
+
+	body, _ := json.Marshal(normalizeRequest{Address: "keine-gueltige-adresse"})
+	resp, err := http.Post(server.URL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("post: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400", resp.StatusCode)
+	}
+}

mail/internal/example/normalize.go

@@ -0,0 +1,26 @@
+// Package example dient QA-01 (Mail): liefert je Testart (Unit,
+// Integration, E2E) genau EIN reales, lauffähiges Beispiel, an dem sich
+// spätere Mail-Tickets orientieren können — keine Wegwerf-Demo, sondern
+// eine tatsächlich nützliche, kleine Funktion (Adress-Normalisierung),
+// die spätere Ticket (z. B. ING-01/ING-04) ohnehin brauchen werden.
+package example
+
+import (
+	"errors"
+	"strings"
+)
+
+var ErrInvalidAddress = errors.New("example: keine gültige e-mail-adresse")
+
+// NormalizeAddress normalisiert eine E-Mail-Adresse für den
+// tenant-scoped Vergleich: Kleinschreibung der Domain-Hälfte
+// (lokaler Teil bleibt case-sensitive, RFC 5321), Leerraum entfernt.
+func NormalizeAddress(addr string) (string, error) {
+	addr = strings.TrimSpace(addr)
+	at := strings.LastIndex(addr, "@")
+	if at <= 0 || at == len(addr)-1 {
+		return "", ErrInvalidAddress
+	}
+	local, domain := addr[:at], addr[at+1:]
+	return local + "@" + strings.ToLower(domain), nil
+}

mail/internal/example/normalize_test.go

@@ -0,0 +1,38 @@
+// Unit-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2): keine
+// externe Abhängigkeit (DB, Netzwerk), reine Funktionsprüfung.
+package example
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestNormalizeAddress_LowercasesDomainOnly(t *testing.T) {
+	got, err := NormalizeAddress("User.Name@Example.COM")
+	if err != nil {
+		t.Fatalf("unerwarteter fehler: %v", err)
+	}
+	want := "User.Name@example.com"
+	if got != want {
+		t.Fatalf("got %q, want %q", got, want)
+	}
+}
+
+func TestNormalizeAddress_TrimsWhitespace(t *testing.T) {
+	got, err := NormalizeAddress("  user@example.com  ")
+	if err != nil {
+		t.Fatalf("unerwarteter fehler: %v", err)
+	}
+	if got != "user@example.com" {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestNormalizeAddress_RejectsInvalidInput(t *testing.T) {
+	cases := []string{"", "no-at-sign", "@nolocalpart.com", "trailing@"}
+	for _, c := range cases {
+		if _, err := NormalizeAddress(c); !errors.Is(err, ErrInvalidAddress) {
+			t.Fatalf("input %q: erwartet ErrInvalidAddress, habe: %v", c, err)
+		}
+	}
+}

mail/internal/example/store.go

@@ -0,0 +1,42 @@
+package example
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// AddressStore ist das Integrationstest-Beispiel (QA-01): eine
+// minimale, aber echte DB-gestützte Komponente — nutzt dieselbe
+// Tenant-DB-Isolationskonvention wie DMS/Archive (t.Cleanup, geteilte
+// physische Postgres-Instanz auf dem Testhost).
+type AddressStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewAddressStore(pool *pgxpool.Pool) *AddressStore {
+	return &AddressStore{pool: pool}
+}
+
+func (s *AddressStore) SaveNormalized(ctx context.Context, addr string) (string, error) {
+	normalized, err := NormalizeAddress(addr)
+	if err != nil {
+		return "", err
+	}
+	if _, err := s.pool.Exec(ctx, `
+		INSERT INTO example_addresses (address) VALUES ($1)
+		ON CONFLICT (address) DO NOTHING
+	`, normalized); err != nil {
+		return "", fmt.Errorf("example: adresse speichern: %w", err)
+	}
+	return normalized, nil
+}
+
+func (s *AddressStore) Exists(ctx context.Context, addr string) (bool, error) {
+	var exists bool
+	if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM example_addresses WHERE address = $1)`, addr).Scan(&exists); err != nil {
+		return false, fmt.Errorf("example: existenz prüfen: %w", err)
+	}
+	return exists, nil
+}

mail/internal/example/store_integration_test.go

@@ -0,0 +1,69 @@
+// Integrations-Test-Beispiel (QA-01 Akzeptanzkriterium 1/Prüfung 2):
+// echte Postgres-Instanz, folgt derselben Testhost-Konvention wie
+// DMS/Archive/Core (TEST_TENANT_DSN, t.Cleanup, geteilte physische
+// Instanz auf 192.168.1.131 — siehe project-nexarch-test-infra).
+package example
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
+	}
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	t.Cleanup(func() { pool.Close() })
+
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS example_addresses (
+			address TEXT PRIMARY KEY
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE example_addresses`)
+	})
+	return pool
+}
+
+func TestAddressStore_SaveAndCheckExists(t *testing.T) {
+	pool := setupTest(t)
+	store := NewAddressStore(pool)
+	ctx := context.Background()
+
+	normalized, err := store.SaveNormalized(ctx, "Kunde@Beispiel.DE")
+	if err != nil {
+		t.Fatalf("savenormalized: %v", err)
+	}
+	if normalized != "Kunde@beispiel.de" {
+		t.Fatalf("erwartet normalisierte adresse, habe %q", normalized)
+	}
+
+	exists, err := store.Exists(ctx, normalized)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !exists {
+		t.Fatal("erwartet real gespeicherte adresse")
+	}
+
+	notExists, err := store.Exists(ctx, "unbekannt@beispiel.de")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if notExists {
+		t.Fatal("nie gespeicherte adresse haette nicht existieren duerfen")
+	}
+}

mail/internal/mimeparse/mimeparse.go

@@ -0,0 +1,206 @@
+// Package mimeparse implementiert ING-04: MIME-/Anhang-Parsing für
+// ein- und ausgehende Nachrichten (Multipart, verschachtelt,
+// Content-Transfer-Encoding, defensive Zeichensatz-Reparatur).
+//
+// NUR Parsing — Speicherung ist ARC-01s Aufgabe (siehe "Nicht
+// Bestandteil dieser Kachel"), dieses Paket schreibt nirgends in einen
+// Objekt-Speicher, sondern liefert nur strukturierte Go-Werte zurück.
+//
+// Bekannten Fehler vermieden (archivmail known-issues #3): Anhänge
+// wurden früher über io.ReadAll ohne Größenlimit gelesen — eine
+// Speicherbombe durch große/böswillige Anhänge. Hier läuft JEDER
+// Anhang-Lesevorgang über io.LimitReader mit konfigurierter Max-Size;
+// eine Überschreitung führt zu einer harten, sauberen Ablehnung
+// (ErrAttachmentTooLarge), kein stilles Abschneiden.
+package mimeparse
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"mime/quotedprintable"
+	"net/mail"
+	"strings"
+
+	"golang.org/x/text/encoding/htmlindex"
+)
+
+// ErrAttachmentTooLarge wird geliefert, wenn ein Anhang die
+// konfigurierte Maximalgröße überschreitet (Akzeptanzkriterium/
+// Pflichtprüfung 1).
+var ErrAttachmentTooLarge = errors.New("mimeparse: anhang überschreitet die maximal erlaubte größe")
+
+// Part ist EIN zerlegter MIME-Teil — sowohl Textteile (IsAttachment
+// == false) als auch Anhänge (Akzeptanzkriterium 1/2).
+type Part struct {
+	ContentType string
+	Filename    string
+	Size        int64
+	Content     []byte
+	IsAttachment bool
+}
+
+// Message ist das Ergebnis eines vollständig zerlegten Multipart-
+// Baums — verschachtelte multipart/*-Teile sind bereits rekursiv
+// aufgelöst, der Aufrufer sieht nur die "Blatt"-Teile (Akzeptanz-
+// kriterium 1).
+type Message struct {
+	Parts []Part
+}
+
+// wordDecoder dekodiert RFC-2047-kodierte Header-Werte (z. B.
+// Anhang-Dateinamen) defensiv: ein unbekannter/fehlerhafter
+// Zeichensatz bricht die Verarbeitung NICHT ab (Akzeptanzkriterium 3),
+// sondern liefert den Rohwert unverändert zurück.
+var wordDecoder = &mime.WordDecoder{CharsetReader: charsetReader}
+
+func charsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
+	enc, err := htmlindex.Get(charsetLabel)
+	if err != nil {
+		// Unbekannter/fehlerhafter Zeichensatz: defensiv als
+		// UTF-8-verträglichen Rohtext weiterreichen statt
+		// abzubrechen (Akzeptanzkriterium 3).
+		return input, nil
+	}
+	return enc.NewDecoder().Reader(input), nil
+}
+
+func decodeHeaderValue(raw string) string {
+	decoded, err := wordDecoder.DecodeHeader(raw)
+	if err != nil {
+		// Defensiv: Rohwert statt Abbruch (Akzeptanzkriterium 3).
+		return raw
+	}
+	return decoded
+}
+
+// Parse zerlegt eine MIME-Nachricht vollständig, inklusive
+// verschachtelter Multipart-Teile (Akzeptanzkriterium 1). maxAttachmentSize
+// begrenzt JEDEN einzelnen Anhang (Akzeptanzkriterium/Pflichtprüfung 1).
+func Parse(r io.Reader, maxAttachmentSize int64) (Message, error) {
+	msg, err := mail.ReadMessage(r)
+	if err != nil {
+		return Message{}, fmt.Errorf("mimeparse: nachricht lesen: %w", err)
+	}
+
+	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
+	if err != nil {
+		// Kein/kaputtes Content-Type: als einzelnen Textteil behandeln
+		// statt abzubrechen (Akzeptanzkriterium 3: defensiv reparieren).
+		body, readErr := readLimited(msg.Body, maxAttachmentSize)
+		if readErr != nil {
+			return Message{}, readErr
+		}
+		return Message{Parts: []Part{{ContentType: "text/plain", Content: body, Size: int64(len(body))}}}, nil
+	}
+
+	var result Message
+	if strings.HasPrefix(mediaType, "multipart/") {
+		if err := parseMultipart(msg.Body, params["boundary"], maxAttachmentSize, &result); err != nil {
+			return Message{}, err
+		}
+		return result, nil
+	}
+
+	// Einzelner Teil (keine Multipart-Hülle).
+	part, err := readSinglePart(msg.Header.Get("Content-Transfer-Encoding"), mediaType, "", msg.Body, maxAttachmentSize)
+	if err != nil {
+		return Message{}, err
+	}
+	result.Parts = append(result.Parts, part)
+	return result, nil
+}
+
+// parseMultipart löst EINEN Multipart-Container rekursiv auf —
+// verschachtelte multipart/*-Teile (z. B. multipart/mixed, das
+// multipart/alternative enthält) werden vollständig zerlegt
+// (Akzeptanzkriterium 1), keine Rekursionstiefe hartkodiert begrenzt
+// außer durch die natürliche Nachrichtengröße selbst.
+func parseMultipart(r io.Reader, boundary string, maxAttachmentSize int64, result *Message) error {
+	if boundary == "" {
+		return errors.New("mimeparse: multipart ohne boundary")
+	}
+	mr := multipart.NewReader(r, boundary)
+	for {
+		p, err := mr.NextPart()
+		if err == io.EOF {
+			return nil
+		}
+		if err != nil {
+			// Kaputte Multipart-Struktur: kontrolliert abbrechen
+			// (Pflichtprüfung 3), nicht abstürzen.
+			return fmt.Errorf("mimeparse: multipart-teil lesen: %w", err)
+		}
+
+		contentType := p.Header.Get("Content-Type")
+		mediaType, subParams, err := mime.ParseMediaType(contentType)
+		if err != nil {
+			mediaType = "text/plain"
+		}
+
+		if strings.HasPrefix(mediaType, "multipart/") {
+			if err := parseMultipart(p, subParams["boundary"], maxAttachmentSize, result); err != nil {
+				return err
+			}
+			continue
+		}
+
+		part, err := readSinglePart(p.Header.Get("Content-Transfer-Encoding"), mediaType, decodeHeaderValue(p.FileName()), p, maxAttachmentSize)
+		if err != nil {
+			return err
+		}
+		result.Parts = append(result.Parts, part)
+	}
+}
+
+func readSinglePart(transferEncoding, mediaType, filename string, r io.Reader, maxAttachmentSize int64) (Part, error) {
+	decoded := decodeTransferEncoding(transferEncoding, r)
+
+	content, err := readLimited(decoded, maxAttachmentSize)
+	if err != nil {
+		return Part{}, err
+	}
+
+	return Part{
+		ContentType:  mediaType,
+		Filename:     filename,
+		Size:         int64(len(content)),
+		Content:      content,
+		IsAttachment: filename != "",
+	}, nil
+}
+
+// decodeTransferEncoding dekodiert Content-Transfer-Encoding
+// (quoted-printable/base64) — defensiv: ein unbekanntes Encoding wird
+// unverändert durchgereicht statt die Verarbeitung abzubrechen
+// (Akzeptanzkriterium 3).
+func decodeTransferEncoding(encoding string, r io.Reader) io.Reader {
+	switch strings.ToLower(strings.TrimSpace(encoding)) {
+	case "quoted-printable":
+		return quotedprintable.NewReader(r)
+	case "base64":
+		return base64.NewDecoder(base64.StdEncoding, r)
+	default:
+		return r
+	}
+}
+
+// readLimited liest höchstens maxSize+1 Bytes — wird die Grenze
+// überschritten, wird ErrAttachmentTooLarge geliefert, statt beliebig
+// viel Speicher zu allozieren (Akzeptanzkriterium/Pflichtprüfung 1,
+// archivmail known-issues #3).
+func readLimited(r io.Reader, maxSize int64) ([]byte, error) {
+	limited := io.LimitReader(r, maxSize+1)
+	var buf bytes.Buffer
+	if _, err := io.Copy(&buf, limited); err != nil {
+		return nil, fmt.Errorf("mimeparse: teil lesen: %w", err)
+	}
+	if int64(buf.Len()) > maxSize {
+		return nil, ErrAttachmentTooLarge
+	}
+	return buf.Bytes(), nil
+}

mail/internal/mimeparse/mimeparse_test.go

@@ -0,0 +1,219 @@
+package mimeparse
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+)
+
+const defaultMaxSize = 10 * 1024 * 1024 // 10 MiB
+
+// TestParse_NestedMultipartFullyDecomposed ist Akzeptanzkriterium 1:
+// Multipart-Nachrichten mit verschachtelten Teilen werden vollständig
+// zerlegt (multipart/mixed enthält multipart/alternative UND einen
+// Anhang).
+func TestParse_NestedMultipartFullyDecomposed(t *testing.T) {
+	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=\"outer\"\r\n\r\n" +
+		"--outer\r\n" +
+		"Content-Type: multipart/alternative; boundary=\"inner\"\r\n\r\n" +
+		"--inner\r\n" +
+		"Content-Type: text/plain; charset=utf-8\r\n\r\n" +
+		"Hallo als Text\r\n" +
+		"--inner\r\n" +
+		"Content-Type: text/html; charset=utf-8\r\n\r\n" +
+		"<p>Hallo als HTML</p>\r\n" +
+		"--inner--\r\n" +
+		"--outer\r\n" +
+		"Content-Type: application/pdf\r\n" +
+		"Content-Disposition: attachment; filename=\"rechnung.pdf\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"JVBERi0xLjQK\r\n" +
+		"--outer--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(msg.Parts) != 3 {
+		t.Fatalf("erwartet 3 zerlegte teile (text, html, anhang), habe %d: %+v", len(msg.Parts), msg.Parts)
+	}
+
+	var sawText, sawHTML, sawAttachment bool
+	for _, p := range msg.Parts {
+		switch {
+		case p.ContentType == "text/plain":
+			sawText = true
+			if string(p.Content) != "Hallo als Text" {
+				t.Fatalf("unerwarteter text-inhalt: %q", p.Content)
+			}
+		case p.ContentType == "text/html":
+			sawHTML = true
+		case p.IsAttachment:
+			sawAttachment = true
+		}
+	}
+	if !sawText || !sawHTML || !sawAttachment {
+		t.Fatalf("nicht alle erwarteten teile gefunden: text=%v html=%v attachment=%v", sawText, sawHTML, sawAttachment)
+	}
+}
+
+// TestParse_AttachmentMetadataExtracted ist Akzeptanzkriterium 2:
+// Anhänge werden mit korrektem Dateinamen, Größe und Content-Type
+// extrahiert.
+func TestParse_AttachmentMetadataExtracted(t *testing.T) {
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: text/plain\r\n\r\n" +
+		"Text\r\n" +
+		"--b\r\n" +
+		"Content-Type: image/png\r\n" +
+		"Content-Disposition: attachment; filename=\"bild.png\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"iVBORw0KGgo=\r\n" +
+		"--b--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	var attachment *Part
+	for i := range msg.Parts {
+		if msg.Parts[i].IsAttachment {
+			attachment = &msg.Parts[i]
+		}
+	}
+	if attachment == nil {
+		t.Fatal("kein anhang gefunden")
+	}
+	if attachment.Filename != "bild.png" {
+		t.Fatalf("falscher dateiname: %q", attachment.Filename)
+	}
+	if attachment.ContentType != "image/png" {
+		t.Fatalf("falscher content-type: %q", attachment.ContentType)
+	}
+	if attachment.Size != int64(len(attachment.Content)) || attachment.Size == 0 {
+		t.Fatalf("unplausible größe: %d (content-len %d)", attachment.Size, len(attachment.Content))
+	}
+}
+
+// TestParse_BrokenCharsetIsRepairedNotAborted ist Akzeptanzkriterium 3:
+// fehlerhafte/inkonsistente Zeichensatzangaben werden defensiv repariert
+// statt die Verarbeitung abzubrechen.
+func TestParse_BrokenCharsetIsRepairedNotAborted(t *testing.T) {
+	// "unbekannt-xyz" ist KEIN gültiger IANA-Zeichensatzname.
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: text/plain; charset=\"unbekannt-xyz\"\r\n\r\n" +
+		"Rohtext trotz kaputtem Charset\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("erwartet KEINEN abbruch bei kaputtem charset, habe: %v", err)
+	}
+	if len(msg.Parts) != 1 {
+		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
+	}
+	if !strings.Contains(string(msg.Parts[0].Content), "Rohtext") {
+		t.Fatalf("inhalt fehlt/verstümmelt: %q", msg.Parts[0].Content)
+	}
+}
+
+// TestParse_ISO88591BodyDecodedWithoutAbort ist Akzeptanzkriterium 3
+// zusätzlich: ein bekannter Nicht-UTF-8-Zeichensatz wird via
+// Header-Dekodierung real repariert (RFC-2047-kodierter Dateiname).
+func TestParse_ISO88591FilenameDecoded(t *testing.T) {
+	// "=?ISO-8859-1?Q?Rechnung_=DC?=" kodiert "Rechnung Ü" (0xDC = 'Ü' in Latin-1).
+	raw := "From: a@example.com\r\n" +
+		"Content-Type: multipart/mixed; boundary=\"b\"\r\n\r\n" +
+		"--b\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Disposition: attachment; filename=\"=?ISO-8859-1?Q?Rechnung_=DC?=\"\r\n" +
+		"Content-Transfer-Encoding: base64\r\n\r\n" +
+		"AAA=\r\n" +
+		"--b--\r\n"
+
+	msg, err := Parse(strings.NewReader(raw), defaultMaxSize)
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	if len(msg.Parts) != 1 {
+		t.Fatalf("erwartet 1 teil, habe %d", len(msg.Parts))
+	}
+	if msg.Parts[0].Filename != "Rechnung Ü" {
+		t.Fatalf("erwartet dekodierten dateinamen 'Rechnung Ü', habe %q", msg.Parts[0].Filename)
+	}
+}
+
+// infiniteReader liefert unbegrenzt viele Bytes — simuliert einen sehr
+// großen/böswilligen Anhang. Ohne io.LimitReader (siehe archivmail
+// known-issues #3) würde ein io.ReadAll hierauf den Prozessspeicher
+// erschöpfen; mit readLimited bricht Parse kontrolliert und schnell ab.
+type infiniteReader struct{}
+
+func (infiniteReader) Read(p []byte) (int, error) {
+	for i := range p {
+		p[i] = 'A'
+	}
+	return len(p), nil
+}
+
+// TestParse_OversizedAttachmentRejectedNotMemoryExhausted ist die
+// geforderte Pflichtprüfung 1.
+func TestParse_OversizedAttachmentRejectedNotMemoryExhausted(t *testing.T) {
+	const tinyLimit = 1024 // 1 KiB — winzig, damit der Test schnell bleibt
+
+	header := "From: a@example.com\r\n" +
+		"Content-Type: application/octet-stream\r\n" +
+		"Content-Transfer-Encoding: identity\r\n\r\n"
+
+	r := io.MultiReader(strings.NewReader(header), infiniteReader{})
+	_, err := Parse(r, tinyLimit)
+	if !errors.Is(err, ErrAttachmentTooLarge) {
+		t.Fatalf("erwartet ErrAttachmentTooLarge bei unbegrenzt großem anhang, habe: %v", err)
+	}
+}
+
+// TestParse_RealisticCorpusRunsCleanly ist die geforderte
+// Pflichtprüfung 2: realitätsnahe Multipart-/Encoding-Varianten laufen
+// fehlerfrei durch.
+func TestParse_RealisticCorpusRunsCleanly(t *testing.T) {
+	corpus := []string{
+		// Einfache Textnachricht ohne Multipart.
+		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\n\r\nEinfacher Text\r\n",
+		// Quoted-Printable.
+		"From: a@example.com\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\nUmlaut: =C3=9C\r\n",
+		// Multipart/alternative ohne Anhang.
+		"From: a@example.com\r\nContent-Type: multipart/alternative; boundary=\"x\"\r\n\r\n--x\r\nContent-Type: text/plain\r\n\r\nText\r\n--x\r\nContent-Type: text/html\r\n\r\n<p>Text</p>\r\n--x--\r\n",
+		// Leere Multipart-Nachricht (kein Teil, nur Präambel/Epilog).
+		"From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"y\"\r\n\r\nPräambel wird ignoriert\r\n--y--\r\nEpilog wird ignoriert\r\n",
+	}
+	for i, raw := range corpus {
+		if _, err := Parse(strings.NewReader(raw), defaultMaxSize); err != nil {
+			t.Fatalf("corpus[%d] fehlgeschlagen: %v\nraw=%q", i, err, raw)
+		}
+	}
+}
+
+// FuzzParse ist die geforderte Pflichtprüfung 3: kaputte MIME-Strukturen
+// dürfen Parse nicht zum Absturz bringen, nur zu einem kontrollierten
+// Fehler.
+func FuzzParse(f *testing.F) {
+	f.Add([]byte("From: a@example.com\r\nContent-Type: multipart/mixed; boundary=\"b\"\r\n\r\n--b\r\nContent-Type: text/plain\r\n\r\nHallo\r\n--b--\r\n"))
+	f.Add([]byte("Content-Type: multipart/mixed; boundary=\r\n\r\nkaputt"))
+	f.Add([]byte(""))
+	f.Add([]byte("From: a@example.com\r\n\r\n"))
+
+	f.Fuzz(func(t *testing.T, data []byte) {
+		defer func() {
+			if r := recover(); r != nil {
+				t.Fatalf("Parse ist abgestürzt (panic) statt kontrolliert einen Fehler zu liefern: %v", r)
+			}
+		}()
+		_, _ = Parse(strings.NewReader(string(data)), defaultMaxSize)
+	})
+}

mail/internal/pflichttestgate/gate.go

@@ -0,0 +1,72 @@
+// Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-MAIL.md
+// Abschnitt 4 festgelegte Regel: jede geänderte Go-Datei in einem
+// sicherheitskritischen Bereich (Auth, Tenant-Scoping, Protokoll-/
+// Compliance-kritisch) muss von einer geänderten oder neuen _test.go-
+// Datei im selben Package begleitet sein. Bewusste Code-Kopie des
+// Musters aus Core internal/pflichttestgate — Mail ist ein eigenständiges
+// Go-Modul und kann Core nicht importieren.
+package pflichttestgate
+
+import (
+	"path"
+	"regexp"
+	"strings"
+)
+
+// sensitivePathPatterns beschreibt die Bereiche aus
+// TESTSTRATEGIE-MAIL.md Abschnitt 4.
+var sensitivePathPatterns = []*regexp.Regexp{
+	regexp.MustCompile(`(^|/)mail/internal/auth/`),
+	regexp.MustCompile(`(^|/)mail/internal/tenant/`),
+	regexp.MustCompile(`(^|/)mail/internal/ingest/`),
+	regexp.MustCompile(`(^|/)mail/internal/imap/`),
+	regexp.MustCompile(`(^|/)mail/internal/smtp/`),
+	regexp.MustCompile(`(^|/)mail/internal/arc/`),
+}
+
+// Violation beschreibt ein Package mit sicherheitskritischer Änderung
+// ohne begleitende Testdatei.
+type Violation struct {
+	Package     string
+	ChangedFile string
+}
+
+func isSensitive(file string) bool {
+	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
+		return false
+	}
+	for _, re := range sensitivePathPatterns {
+		if re.MatchString(file) {
+			return true
+		}
+	}
+	return false
+}
+
+// CheckDiff prüft eine Liste geänderter Dateipfade gegen die
+// Pflichttest-Regel — ein leeres Ergebnis bedeutet: Gate besteht.
+func CheckDiff(changedFiles []string) []Violation {
+	sensitiveByPkg := map[string]string{}
+	testTouchedPkgs := map[string]bool{}
+
+	for _, f := range changedFiles {
+		pkg := path.Dir(f)
+		if strings.HasSuffix(f, "_test.go") {
+			testTouchedPkgs[pkg] = true
+			continue
+		}
+		if isSensitive(f) {
+			if _, seen := sensitiveByPkg[pkg]; !seen {
+				sensitiveByPkg[pkg] = f
+			}
+		}
+	}
+
+	var violations []Violation
+	for pkg, file := range sensitiveByPkg {
+		if !testTouchedPkgs[pkg] {
+			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
+		}
+	}
+	return violations
+}

mail/internal/pflichttestgate/gate_test.go

@@ -0,0 +1,33 @@
+// Negativtest des Gates selbst (QA-01 Prüfung 1): ein Diff mit
+// geänderter mail/internal/auth/login.go ohne begleitende Testdatei
+// muss als Verstoß erkannt werden.
+package pflichttestgate
+
+import "testing"
+
+func TestCheckDiff_FlagsSensitiveChangeWithoutTest(t *testing.T) {
+	violations := CheckDiff([]string{"mail/internal/auth/login.go"})
+	if len(violations) != 1 {
+		t.Fatalf("erwartet genau 1 verstoß, habe %d: %+v", len(violations), violations)
+	}
+	if violations[0].Package != "mail/internal/auth" {
+		t.Fatalf("falsches package gemeldet: %+v", violations[0])
+	}
+}
+
+func TestCheckDiff_PassesWhenTestFileAccompanies(t *testing.T) {
+	violations := CheckDiff([]string{
+		"mail/internal/auth/login.go",
+		"mail/internal/auth/login_test.go",
+	})
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keine verstöße, habe: %+v", violations)
+	}
+}
+
+func TestCheckDiff_IgnoresNonSensitivePaths(t *testing.T) {
+	violations := CheckDiff([]string{"mail/internal/example/normalize.go"})
+	if len(violations) != 0 {
+		t.Fatalf("erwartet keine verstöße für nicht-sensiblen pfad, habe: %+v", violations)
+	}
+}

migrations/0001_tenant_registry.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS tenants;

migrations/0001_tenant_registry.sql

@@ -0,0 +1,10 @@
+-- Control-plane registry: tenant list + connection info (Modell C).
+-- Core TEN-01 (siehe core-kanban).
+CREATE TABLE 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()
+);

migrations/0001_tenant_registry.up.sql

@@ -1,14 +0,0 @@
--- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
--- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
--- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-
-CREATE TABLE tenants (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    slug         TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    db_name      TEXT NOT NULL UNIQUE,
-    db_dsn       TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0004_tenant_licenses.down.sql

@@ -1 +0,0 @@
-DROP TABLE IF EXISTS tenant_licenses;

migrations/0004_tenant_licenses.up.sql

@@ -1,12 +0,0 @@
--- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
--- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
--- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
-CREATE TABLE tenant_licenses (
-    tenant_id     UUID PRIMARY KEY REFERENCES tenants(id),
-    plan          TEXT NOT NULL,
-    modules       TEXT[] NOT NULL,
-    issued_at     TIMESTAMPTZ NOT NULL,
-    valid_until   TIMESTAMPTZ NOT NULL,
-    raw_key       TEXT NOT NULL,
-    installed_at  TIMESTAMPTZ NOT NULL DEFAULT now()
-);

migrations/0005_usage_counters.down.sql

@@ -1,2 +0,0 @@
-DROP TABLE IF EXISTS usage_quotas;
-DROP TABLE IF EXISTS usage_counters;

migrations/0005_usage_counters.up.sql

@@ -1,15 +0,0 @@
--- Nutzungszaehler & Quotas je Tenant (LIC-03, siehe core-kanban/tickets/LIC-03.md).
-CREATE TABLE usage_counters (
-    tenant_id  UUID NOT NULL,
-    metric     TEXT NOT NULL,
-    value      BIGINT NOT NULL DEFAULT 0,
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-    PRIMARY KEY (tenant_id, metric)
-);
-
-CREATE TABLE usage_quotas (
-    tenant_id   UUID NOT NULL,
-    metric      TEXT NOT NULL,
-    limit_value BIGINT NOT NULL,
-    PRIMARY KEY (tenant_id, metric)
-);

scripts/reset-test-env.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
-# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
-# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
-# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
-# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
-set -euo pipefail
-
-PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
-ROLE="nexarch_test"
-
-export PGPASSWORD="$PASS"
-
-psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
-
-dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
-for db in $dbs; do
-	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
-done
-
-echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."

scripts/run-checks.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
-# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
-# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
-# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
-set -euo pipefail
-
-PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
-cd "$(dirname "$0")/.."
-
-NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
-
-export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
-
-echo "== go build =="
-go build ./...
-
-echo "== go vet =="
-go vet ./...
-
-echo "== go test (-p 1) =="
-go test ./... -p 1 -count=1