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

archive/.golangci.yml

@@ -1,18 +0,0 @@
-version: "2"
-
-run:
-  timeout: 3m
-
-linters:
-  default: none
-  enable:
-    - govet
-    - staticcheck
-    - errcheck
-    - unused
-    - ineffassign
-
-formatters:
-  enable:
-    - gofmt
-    - goimports

archive/Makefile

@@ -1,19 +0,0 @@
-.PHONY: build lint fmt test check
-
-build:
-	go build ./...
-
-lint:
-	golangci-lint run ./...
-
-fmt:
-	gofmt -l .
-	@test -z "$$(gofmt -l .)" || (echo "gofmt-Verstoesse gefunden, siehe oben" && exit 1)
-
-test:
-	go test ./... -p 1 -count=1
-
-check: build
-	go vet ./...
-	golangci-lint run ./...
-	go test ./... -p 1 -count=1

archive/README.md

@@ -1,62 +0,0 @@
-# NEXARCH Archive
-
-Zentrales, modulübergreifendes Modul für Aufbewahrung, WORM, Compliance und
-Backup. Dieses Verzeichnis enthält bisher `internal/backup` (BAK-01,
-Datenbank-Backup-Strategie) — weitere Bausteine folgen ticketweise.
-
-## BAK-01: Datenbank-Backup
-
-`cmd/backup-cli` — Aufrufpunkt für systemd-Timer (siehe
-`../deploy/systemd/nexarch-archive-backup-*.timer`):
-
-```bash
-export NEXARCH_BACKUP_PG_USER=nexarch_backup
-export NEXARCH_BACKUP_PG_PASSWORD=...
-export NEXARCH_BACKUP_DIR=/var/nexarch-archiv/backups/postgres   # NICHT auf einem ephemeren Test-Dataset (siehe Betrieb)
-export NEXARCH_BACKUP_KEEP_GENERATIONS=7   # optional, Default 7
-
-backup-cli full          # neue Vollsicherung + Verifikation
-backup-cli incremental   # inkrementelle Sicherung gegen die neueste Generation
-backup-cli rotate        # entfernt alle bis auf die neuesten N Generationen
-```
-
-Voraussetzung: die konfigurierte Postgres-Rolle braucht das
-`REPLICATION`-Attribut (`pg_basebackup` nutzt eine
-Replikationsverbindung), und `summarize_wal = on` muss serverseitig gesetzt
-sein (PostgreSQL 17s natives inkrementelles Backup, keine WAL-Archivierung
-nötig).
-
-## BAK-02: Objekt-Storage-Backup
-
-`cmd/objectbackup-cli` sichert einen lokalen Verzeichnisbaum (den
-FDN-03-`LocalDriver`-Basisordner direkt, oder — für S3-gestützte
-Deployments — einen vorgelagerten `rclone`-Spiegel) mit
-[restic](https://restic.net) (Content-defined Chunking, verschlüsseltes
-Repository, geprüftes Tooling statt Eigenbau):
-
-```bash
-export NEXARCH_OBJECTBACKUP_REPO_DIR=/var/nexarch-archiv/backups/objects
-export NEXARCH_OBJECTBACKUP_PASSWORD=...
-export NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS=30   # optional, Default 7
-
-objectbackup-cli backup /var/nexarch-objects   # Sicherung + Verifikation
-objectbackup-cli check                          # vollständiges Lesen aller Datenblöcke
-objectbackup-cli rotate                          # restic forget --keep-last N --prune
-```
-
-## Betrieb: Backup-Zielverzeichnis
-
-Backup-Ziele liegen unter `/var/nexarch-archiv/` (persistentes ZFS-Dataset,
-`zfs/data/subvol-1131-disk-0` auf 192.168.1.131), NIEMALS unter
-`/var/nexarch-test/` (ephemeres Dataset, wird von den `reset-test-env.sh`-
-Skripten der anderen Module geleert). ZFS-seitige Snapshots/Replikation
-dieses Datasets sind ein eigenständiges Infra-Runbook (siehe
-`../../STORAGE-KONZEPT.md` Abschnitt 7), kein Ticket-Code — `zfs
-dedup=on` bewusst NICHT setzen (hoher RAM-Bedarf), Deduplizierung läuft
-ausschließlich App-seitig über restic.
-
-## Prüfungen
-
-```bash
-make check   # build + vet + lint + test, analog Core/DMS
-```

archive/cmd/backup-cli/main.go

@@ -1,107 +0,0 @@
-// backup-cli ist der Aufrufpunkt für BAK-01, gedacht für systemd-Timer
-// (siehe deploy/systemd/) — "automatisiert nach Zeitplan" (Akzeptanzkriterium
-// 1) entsteht durch die Zeitplan-Definition im Timer-Unit, nicht durch
-// einen eigenen In-Prozess-Scheduler (kein zusätzlicher Dauerprozess nötig,
-// passt zur Produkt-DNA "kein Anwendungsserver mit unnötigem
-// Ressourcenverbrauch").
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"time"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/backup"
-)
-
-func loadConfig() backup.Config {
-	cfg := backup.Config{
-		Host:      os.Getenv("NEXARCH_BACKUP_PG_HOST"),
-		Port:      os.Getenv("NEXARCH_BACKUP_PG_PORT"),
-		User:      os.Getenv("NEXARCH_BACKUP_PG_USER"),
-		Password:  os.Getenv("NEXARCH_BACKUP_PG_PASSWORD"),
-		BackupDir: os.Getenv("NEXARCH_BACKUP_DIR"),
-	}
-	if cfg.Host == "" {
-		cfg.Host = "localhost"
-	}
-	if cfg.Port == "" {
-		cfg.Port = "5432"
-	}
-	if cfg.User == "" || cfg.Password == "" || cfg.BackupDir == "" {
-		log.Fatal("NEXARCH_BACKUP_PG_USER, NEXARCH_BACKUP_PG_PASSWORD und NEXARCH_BACKUP_DIR muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func latestManifest(backupDir string) (string, error) {
-	generations, err := backup.ListGenerations(backupDir)
-	if err != nil {
-		return "", err
-	}
-	if len(generations) == 0 {
-		return "", fmt.Errorf("keine vorhandene generation fuer inkrementelle sicherung gefunden - zuerst 'full' ausfuehren")
-	}
-	latest := generations[len(generations)-1]
-	full := backupDir + "/" + latest + "/" + backup.FullBackupDirName + "/" + backup.BackupManifestFile
-	if _, err := os.Stat(full); err == nil {
-		return full, nil
-	}
-	return "", fmt.Errorf("kein backup_manifest in der neuesten generation %q gefunden", latest)
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: backup-cli <full|incremental|verify|rotate> [args]")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	switch os.Args[1] {
-	case "full":
-		genID := backup.NewGenerationID(time.Now())
-		manifest, err := backup.FullBackup(ctx, cfg, genID)
-		if err != nil {
-			log.Fatalf("vollsicherung fehlgeschlagen: %v", err)
-		}
-		dir := manifest[:len(manifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der vollsicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("vollsicherung %q erstellt und verifiziert: %s\n", genID, manifest)
-
-	case "incremental":
-		manifest, err := latestManifest(cfg.BackupDir)
-		if err != nil {
-			log.Fatal(err)
-		}
-		generations, _ := backup.ListGenerations(cfg.BackupDir)
-		genID := generations[len(generations)-1]
-		incID := backup.NewGenerationID(time.Now())
-		newManifest, err := backup.IncrementalBackup(ctx, cfg, genID, incID, manifest)
-		if err != nil {
-			log.Fatalf("inkrementelle sicherung fehlgeschlagen: %v", err)
-		}
-		dir := newManifest[:len(newManifest)-len("/"+backup.BackupManifestFile)]
-		if err := backup.Verify(dir); err != nil {
-			log.Fatalf("verifikation der inkrementellen sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("inkrementelle sicherung %q erstellt und verifiziert: %s\n", incID, newManifest)
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_BACKUP_KEEP_GENERATIONS"); v != "" {
-			_, _ = fmt.Sscanf(v, "%d", &keep)
-		}
-		removed, err := backup.Rotate(cfg.BackupDir, keep)
-		if err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("rotation abgeschlossen, %d generation(en) entfernt: %v\n", len(removed), removed)
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}

archive/cmd/objectbackup-cli/main.go

@@ -1,75 +0,0 @@
-// objectbackup-cli ist der Aufrufpunkt für BAK-02, für systemd-Timer
-// gedacht (siehe deploy/systemd/) — "automatisiert nach Zeitplan" entsteht
-// durch die Timer-Definition, kein eigener Dauerprozess (dieselbe
-// Begründung wie BAK-01 / cmd/backup-cli).
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-	"strconv"
-
-	"gitea.perlbach24.de/scripte/nexarch/archive/internal/objectbackup"
-)
-
-func loadConfig() objectbackup.Config {
-	cfg := objectbackup.Config{
-		RepoDir:  os.Getenv("NEXARCH_OBJECTBACKUP_REPO_DIR"),
-		Password: os.Getenv("NEXARCH_OBJECTBACKUP_PASSWORD"),
-	}
-	if cfg.RepoDir == "" || cfg.Password == "" {
-		log.Fatal("NEXARCH_OBJECTBACKUP_REPO_DIR und NEXARCH_OBJECTBACKUP_PASSWORD muessen gesetzt sein")
-	}
-	return cfg
-}
-
-func main() {
-	if len(os.Args) < 2 {
-		log.Fatal("aufruf: objectbackup-cli <backup <quellverzeichnis>|check|rotate>")
-	}
-	cfg := loadConfig()
-	ctx := context.Background()
-
-	if err := objectbackup.InitRepo(ctx, cfg); err != nil {
-		log.Fatalf("repository initialisieren: %v", err)
-	}
-
-	switch os.Args[1] {
-	case "backup":
-		if len(os.Args) < 3 {
-			log.Fatal("aufruf: objectbackup-cli backup <quellverzeichnis>")
-		}
-		summary, err := objectbackup.Backup(ctx, cfg, os.Args[2])
-		if err != nil {
-			log.Fatalf("sicherung fehlgeschlagen: %v", err)
-		}
-		if err := objectbackup.Check(ctx, cfg, false); err != nil {
-			log.Fatalf("verifikation nach sicherung fehlgeschlagen: %v", err)
-		}
-		fmt.Printf("sicherung %q erstellt und verifiziert (neu=%d geaendert=%d unveraendert=%d)\n",
-			summary.SnapshotID, summary.FilesNew, summary.FilesChanged, summary.FilesUnmodified)
-
-	case "check":
-		if err := objectbackup.Check(ctx, cfg, true); err != nil {
-			log.Fatalf("verifikation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("verifikation (mit vollstaendigem lesen) erfolgreich")
-
-	case "rotate":
-		keep := 7
-		if v := os.Getenv("NEXARCH_OBJECTBACKUP_KEEP_SNAPSHOTS"); v != "" {
-			if n, err := strconv.Atoi(v); err == nil {
-				keep = n
-			}
-		}
-		if err := objectbackup.Forget(ctx, cfg, keep); err != nil {
-			log.Fatalf("rotation fehlgeschlagen: %v", err)
-		}
-		fmt.Println("rotation abgeschlossen")
-
-	default:
-		log.Fatalf("unbekannter befehl %q", os.Args[1])
-	}
-}

archive/docs/BAK-01-PRUEFPROTOKOLL.md

@@ -1,87 +0,0 @@
-# BAK-01 – Prüfprotokoll: Datenbank-Backup-Strategie
-
-Welle 1, keine Vorbedingungen. Neues Modul-Verzeichnis `code/archive/`
-(gleiches Monorepo-Muster wie `code/dms/`), eigenes Go-Modul
-`gitea.perlbach24.de/scripte/nexarch/archive`.
-
-## Grundsatzentscheidung: PostgreSQL-17-natives inkrementelles Backup
-
-`pg_dump` kennt nur logische Vollsicherungen — "inkrementell" im Sinne des
-Tickets erfordert das physische Backup-Verfahren. Gewählt: PostgreSQL 17s
-natives `pg_basebackup --incremental` (WAL-Summarization), NICHT klassisches
-WAL-Archiving (`archive_mode`), weil letzteres einen Neustart der
-(geteilten, auch von Core/DMS-Tests genutzten) Postgres-Instanz auf
-192.168.1.131 erfordert hätte. Stattdessen `summarize_wal = on` gesetzt —
-nur ein `pg_reload_conf()`, kein Neustart, keine Unterbrechung laufender
-Verbindungen (per Health-Check nach der Änderung bestätigt).
-
-Voraussetzung geschaffen: Rolle `nexarch_backup` mit `REPLICATION`-Attribut
-angelegt (Postgres verlangt eine Replikationsverbindung für
-`pg_basebackup`), `pg_hba.conf` erlaubte lokale Replikationsverbindungen
-bereits.
-
-## Umsetzung
-
-- `internal/backup.FullBackup`/`IncrementalBackup` — rufen `pg_basebackup`
-  über `os/exec` auf, Ergebnis landet in einer Generationsstruktur
-  (`<BackupDir>/<Generation>/full/` bzw. `.../incremental/<ID>/`).
-- `internal/backup.Verify` — öffnet `base.tar.gz` vollständig (gzip- UND
-  tar-Stream, jeder Eintrag bis zum Ende gelesen, nicht nur Kopfdaten) —
-  Akzeptanzkriterium 2: Verifikation auf Lesbarkeit, nicht nur Erstellung.
-- `internal/backup.Rotate`/`ListGenerations` — Generationen sind nach
-  Zeitstempel-ID sortierbar, `Rotate` entfernt die ältesten bis auf `keep`
-  komplett (inklusive aller abhängigen Inkremente).
-- `cmd/backup-cli` — `full`/`incremental`/`rotate`, aufgerufen von
-  systemd-Timern (`deploy/systemd/nexarch-archive-backup-*.timer`) —
-  "automatisiert nach Zeitplan" (Akzeptanzkriterium 1) entsteht durch die
-  Timer-Definition, kein zusätzlicher Dauerprozess nötig.
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Sicherung gegen Testdatenbank erfolgreich erstellt und verifiziert | **bestanden** — `TestFullBackup_CreatesVerifiedBackup` gegen die echte Postgres-17-Instanz auf 192.168.1.131 (kein Mock), zusätzlich `TestIncrementalBackup_IsSmallerThanFull`: inkrementelle Sicherung real deutlich kleiner als Vollsicherung (167 KB vs. 16 MB bei der ersten manuellen Probe) — beweist echte inkrementelle Übertragung, nicht nur eine zweite Vollsicherung |
-| 2 | Verifikation erkennt eine absichtlich beschädigte Sicherungsdatei | **bestanden** — `TestVerify_DetectsCorruptedFile`: 64 Bytes in der Mitte von `base.tar.gz` gekippt, `Verify` schlägt danach fehl (unbeschädigt zuvor erfolgreich) |
-| 3 | Rotationsregel entfernt nachweislich nur die ältesten Generationen | **bestanden** — `TestRotate_RemovesOnlyOldestGenerations`: 5 Generationen, `keep=2`, exakt die 3 ältesten entfernt, die 2 neuesten nachweislich unangetastet |
-
-## Echte Verdrahtung auf 192.168.1.131 (nicht nur Testcode)
-
-Anders als die zuletzt in DMS gefundenen "Baustein existiert, ist aber
-nirgends verdrahtet"-Fälle (FDN-03/FDN-09 gegen Core) wurde hier die
-komplette Kette tatsächlich installiert und ausgeführt:
-
-- `backup-cli` gebaut nach `/opt/nexarch-archive/bin/`
-- `/etc/nexarch/archive-backup.env` mit den Verbindungsdaten (0600)
-- 3 systemd-Timer installiert und aktiviert (`enable --now`):
-  Vollsicherung täglich 02:00 UTC, Inkrement stündlich, Rotation täglich
-  03:00 UTC (`systemctl list-timers` bestätigt alle drei scharf)
-- Jeder der drei Dienste (`full`/`incremental`/`rotate`) einmal manuell über
-  `systemctl start` ausgelöst (nicht nur `go test` direkt) — alle drei mit
-  `status=0/SUCCESS`, Journal bestätigt inhaltlich korrekte Ausgabe
-  (Vollsicherung erstellt+verifiziert, Inkrement erstellt+verifiziert
-  gegen die richtige Vorgänger-Generation, Rotation lief ohne Fehler)
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 4/4 Tests ok, 0 Fehlschläge (echter Postgres 17, kein Mock)
-```
-
-## Nachtrag (BAK-02-Sitzung): Backup-Zielverzeichnis korrigiert
-
-`NEXARCH_BACKUP_DIR` zeigte ursprünglich auf `/var/backups/nexarch`
-(Root-Dateisystem des Containers, kein dediziertes Dataset) — korrigiert auf
-`/var/nexarch-archiv/backups/postgres` (persistentes ZFS-Dataset), siehe
-`docs/BAK-02-PRUEFPROTOKOLL.md` Abschnitt „Korrektur an BAK-01" für Details.
-Vollsicherung nach der Korrektur erneut über systemd ausgelöst, landet
-nachweislich am neuen Ort.
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real erfüllt — inklusive tatsächlicher systemd-Timer-Installation und
-manuell ausgelöstem End-to-End-Lauf aller drei Dienste auf dem Testhost,
-nicht nur isolierter Testcode.

archive/docs/BAK-02-PRUEFPROTOKOLL.md

@@ -1,93 +0,0 @@
-# BAK-02 – Prüfprotokoll: Objekt-Storage-Backup/Snapshots
-
-Welle 1, keine Vorbedingungen.
-
-## Grundsatzentscheidung: restic statt Eigenbau
-
-Nutzerentscheidung: restic statt einer Neuimplementierung, weil restic alle
-vier Akzeptanzkriterien mit ausgereiftem, breit geprüftem Tooling erfüllt
-(Content-defined Chunking für Dedup, `check --read-data` für
-Vollständigkeit, `forget --keep-last` für Rotation, Repository-Verschlüsselung
-ab Werk). Installiert via `apt-get install restic` (Version 0.18.0).
-
-Backup-Quelle ist ein lokaler Verzeichnisbaum — für den FDN-03-`LocalDriver`
-direkt dessen Basisverzeichnis. Für S3-gestützte Produktions-Deployments
-(Betriebsmodus 2/3 aus `STORAGE-KONZEPT.md` Abschnitt 6.2) wäre ein
-vorgelagerter Sync-Schritt (z. B. `rclone`) nötig, um Bucket-Inhalte lokal
-zu spiegeln, bevor restic sie sichert — restic sichert Dateibäume, keine
-S3-Buckets direkt. Das bleibt hier bewusst unimplementiert (kein konkreter
-S3-Produktionsbestand vorhanden, der das aktuell erfordert), aber
-architektonisch vorgesehen und dokumentiert (`README.md`).
-
-## Umsetzung
-
-- `internal/objectbackup.InitRepo` — idempotent, erkennt "bereits
-  initialisiert" am `restic init`-Fehlertext statt zu scheitern.
-- `internal/objectbackup.Backup` — `restic backup --json`, parst die
-  `summary`-Zeile (mehrere JSON-Zeilen in der Ausgabe, gezielt die mit
-  `message_type=="summary"` gesucht).
-- `internal/objectbackup.Check` — `restic check [--read-data]` (Akzeptanz-
-  kriterium 3: Vollständigkeitsprüfung).
-- `internal/objectbackup.Forget` — `restic forget --keep-last N --prune`
-  (Rotation).
-- `cmd/objectbackup-cli` — `backup <dir>`/`check`/`rotate`, aufgerufen von
-  systemd-Timern (stündlich/wöchentlich/täglich).
-
-## Prüfungen
-
-| # | Prüfung | Ergebnis |
-|---|---|---|
-| 1 | Zweiter Sicherungslauf nach unverändertem Bestand überträgt keine Daten erneut | **bestanden** — `TestBackup_UnchangedSecondRunTransmitsNothingNew`: zweiter Lauf gegen unveränderten Bestand liefert `files_new=0`, `files_changed=0`, `files_unmodified=1` |
-| 2 | Zwei identische Testdateien belegen nachweislich nur einmal Speicherplatz | **bestanden** — `TestBackup_DeduplicatesIdenticalContent`: zwei Dateien mit identischem Inhalt erzeugen `data_blobs=1`, nicht 2 — echter Dedup-Nachweis über restics Content-defined Chunking, nicht nur Namensvergleich |
-| 3 | Vollständigkeitsprüfung erkennt ein fehlendes Objekt in der Sicherung | **bestanden** — `TestCheck_DetectsCorruptedPack`: ein Byte in einer echten Repository-Pack-Datei gekippt, `Check(readData=true)` schlägt danach fehl (unbeschädigt zuvor erfolgreich) — dieselbe Vorgehensweise wie die manuelle Recherche vor der Implementierung |
-
-Zusätzlich (nicht explizit als Pflichtprüfung gefordert, aber Teil von
-Akzeptanzkriterium 3 „lässt sich einzeln prüfen"): `TestForget_
-KeepsOnlyRequestedSnapshotCount` — 3 Sicherungsläufe, `Forget(keepLast=1)`
-reduziert auf genau 1 verbleibenden Snapshot.
-
-## Korrektur an BAK-01 im selben Rutsch: Backup-Zielverzeichnis
-
-Nutzerhinweis aufgegriffen: `NEXARCH_BACKUP_DIR` zeigte bei BAK-01
-ursprünglich auf `/var/backups/nexarch` (Root-Dateisystem des LXC-
-Containers, nicht auf einem der beiden dedizierten ZFS-Datasets). Korrigiert
-auf `/var/nexarch-archiv/backups/postgres` (persistentes Dataset
-`zfs/data/subvol-1131-disk-0`), NICHT `/var/nexarch-test/` (ephemeres
-Dataset `ssd-rpool-data/swap/subvol-1131-disk-0`, wird von
-`reset-test-env.sh`-Skripten anderer Module geleert). `objectbackup-cli`s
-Repository liegt von Anfang an korrekt unter
-`/var/nexarch-archiv/backups/objects`. Beide Pfade real auf
-192.168.1.131 verifiziert (`df`/`mount` bestätigt ZFS-Dataset-Zuordnung),
-BAK-01s Vollsicherung nach der Korrektur erneut über systemd ausgelöst und
-bestätigt am neuen Ort gelandet.
-
-ZFS-seitige Snapshot-/Replikations-Strategie für `nexarch/archiv` bleibt
-bewusst außerhalb dieses Tickets (Infra-Runbook, siehe
-`STORAGE-KONZEPT.md` Abschnitt 7 „Backup vs. Storage-Redundanz" sowie den
-Hinweis, `zfs dedup=on` NICHT zu setzen — App-seitige Dedup über restic
-genügt, ZFS-Dedup wäre auf dem 4-GB-Testhost ein Speicherrisiko).
-
-## Echte Verdrahtung auf 192.168.1.131
-
-- `objectbackup-cli` gebaut nach `/opt/nexarch-archive/bin/`
-- `/etc/nexarch/archive-objectbackup.env` (0600)
-- 3 systemd-Timer installiert und aktiviert: Sicherung stündlich (`:30`),
-  Vollständigkeitsprüfung wöchentlich (So. 04:00 UTC), Rotation täglich
-  (03:30 UTC) — `systemctl list-timers` bestätigt alle scharf
-- Jeder der drei Dienste einmal über `systemctl start` ausgelöst, alle mit
-  `status=0/SUCCESS`; Journal bestätigt inhaltlich korrekte Ausgabe
-
-## Build/Test-Ergebnis (192.168.1.131, `make check`)
-
-```
-go build ./...  -> clean
-go vet ./...    -> clean
-golangci-lint run ./...  -> 0 issues
-go test ./... -p 1 -count=1  -> 2/2 Pakete mit Tests ok (internal/backup, internal/objectbackup), 0 Fehlschläge
-```
-
-## Gesamtergebnis
-
-**Bestanden.** Alle drei Akzeptanzkriterien und alle drei Pflichtprüfungen
-real gegen echtes restic-Tooling erfüllt. BAK-01-Pfadfehler im selben
-Rutsch korrigiert und erneut end-to-end verifiziert.

archive/go.mod

@@ -1,3 +0,0 @@
-module gitea.perlbach24.de/scripte/nexarch/archive
-
-go 1.22

archive/internal/backup/backup.go

@@ -1,102 +0,0 @@
-// Package backup implementiert BAK-01: automatisierte, inkrementelle
-// Sicherung der PostgreSQL-Datenbank per pg_basebackup (PostgreSQL 17s
-// natives inkrementelles Backup über WAL-Summarization, siehe
-// `summarize_wal`), mit Verifikation jeder Sicherung und
-// generationsbasierter Rotation. Kein pg_dump-basierter Ansatz, weil
-// pg_dump ausschließlich logische Vollsicherungen kennt — "inkrementell"
-// im Sinne des Tickets erfordert das physische, WAL-summary-gestützte
-// Verfahren aus PostgreSQL 17.
-package backup
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"time"
-)
-
-// Config enthält die Verbindungsdaten für pg_basebackup — ausschließlich
-// über Umgebungsvariablen befüllt, nie im Code (siehe Ticket-Abschluss-
-// Regel).
-type Config struct {
-	Host             string
-	Port             string
-	User             string
-	Password         string
-	BackupDir        string
-	PgBaseBackupPath string // Default "pg_basebackup", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.PgBaseBackupPath != "" {
-		return c.PgBaseBackupPath
-	}
-	return "pg_basebackup"
-}
-
-// FullBackupDirName/IncrementalDirName sind die festen Unterverzeichnis-
-// namen je Generation.
-const (
-	FullBackupDirName  = "full"
-	IncrementalSubdir  = "incremental"
-	BackupManifestFile = "backup_manifest"
-	BaseTarGzFile      = "base.tar.gz"
-)
-
-// NewGenerationID liefert eine sortierbare, eindeutige Generation-Kennung
-// (RFC3339-artig, dateisystemtauglich) — Generationen werden anhand dieser
-// Kennung chronologisch sortiert (Rotate, ListGenerations).
-func NewGenerationID(t time.Time) string {
-	return t.UTC().Format("20060102T150405Z")
-}
-
-// FullBackup erstellt eine neue Vollsicherung (Akzeptanzkriterium 1) als
-// eigene Generation. Liefert den Pfad zum backup_manifest, das spätere
-// IncrementalBackup-Aufrufe als Referenz brauchen.
-func FullBackup(ctx context.Context, cfg Config, generationID string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, FullBackupDirName)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: generationsverzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: vollsicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-// IncrementalBackup erstellt eine inkrementelle Sicherung gegen die zuletzt
-// bekannte Vollsicherung ODER die letzte Inkrement-Sicherung (priorManifestPath
-// zeigt jeweils auf das backup_manifest der Referenz).
-func IncrementalBackup(ctx context.Context, cfg Config, generationID, incrementID, priorManifestPath string) (manifestPath string, err error) {
-	dir := filepath.Join(cfg.BackupDir, generationID, IncrementalSubdir, incrementID)
-	if err := os.MkdirAll(filepath.Dir(dir), 0o750); err != nil {
-		return "", fmt.Errorf("backup: inkrement-verzeichnis anlegen: %w", err)
-	}
-
-	args := []string{
-		"-h", cfg.Host, "-p", cfg.Port, "-U", cfg.User,
-		"-D", dir, "-Ft", "-z", "--checkpoint=fast", "--no-password",
-		"--incremental=" + priorManifestPath,
-	}
-	if err := runPgBaseBackup(ctx, cfg, args); err != nil {
-		return "", fmt.Errorf("backup: inkrementelle sicherung: %w", err)
-	}
-	return filepath.Join(dir, BackupManifestFile), nil
-}
-
-func runPgBaseBackup(ctx context.Context, cfg Config, args []string) error {
-	cmd := exec.CommandContext(ctx, cfg.binary(), args...)
-	cmd.Env = append(os.Environ(), "PGPASSWORD="+cfg.Password)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("%s fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), err, string(output))
-	}
-	return nil
-}

archive/internal/backup/backup_test.go

@@ -1,187 +0,0 @@
-package backup
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func requireTestConfig(t *testing.T) Config {
-	t.Helper()
-	user := os.Getenv("TEST_BACKUP_PG_USER")
-	if user == "" {
-		t.Skip("TEST_BACKUP_PG_USER nicht gesetzt, Integrationstest uebersprungen (braucht echten Postgres mit REPLICATION-Rolle)")
-	}
-	return Config{
-		Host:      envOr("TEST_BACKUP_PG_HOST", "localhost"),
-		Port:      envOr("TEST_BACKUP_PG_PORT", "5432"),
-		User:      user,
-		Password:  os.Getenv("TEST_BACKUP_PG_PASSWORD"),
-		BackupDir: t.TempDir(),
-	}
-}
-
-func envOr(key, fallback string) string {
-	if v := os.Getenv(key); v != "" {
-		return v
-	}
-	return fallback
-}
-
-// TestFullBackup_CreatesVerifiedBackup ist Pruefung 1: Sicherung gegen
-// Testdatenbank erfolgreich erstellt und verifiziert.
-func TestFullBackup_CreatesVerifiedBackup(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	if _, err := os.Stat(manifest); err != nil {
-		t.Fatalf("backup_manifest fehlt: %v", err)
-	}
-
-	dir := filepath.Dir(manifest)
-	if _, err := os.Stat(filepath.Join(dir, BaseTarGzFile)); err != nil {
-		t.Fatalf("%s fehlt: %v", BaseTarGzFile, err)
-	}
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify: %v", err)
-	}
-}
-
-// TestIncrementalBackup_IsSmallerThanFull ist der Nachweis fuer
-// Akzeptanzkriterium 1 (inkrementell): eine echte inkrementelle Sicherung
-// gegen unveraenderten Bestand ist deutlich kleiner als die Vollsicherung —
-// beweist, dass tatsaechlich nur Aenderungen uebertragen wurden (PostgreSQL
-// 17 WAL-Summarization), nicht nochmal alles.
-func TestIncrementalBackup_IsSmallerThanFull(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	fullManifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	fullDir := filepath.Dir(fullManifest)
-	fullSize := fileSize(t, filepath.Join(fullDir, BaseTarGzFile))
-
-	incID := NewGenerationID(time.Now().Add(time.Second))
-	incManifest, err := IncrementalBackup(ctx, cfg, genID, incID, fullManifest)
-	if err != nil {
-		t.Fatalf("incrementalbackup: %v", err)
-	}
-	incDir := filepath.Dir(incManifest)
-	if err := Verify(incDir); err != nil {
-		t.Fatalf("verify (inkrementell): %v", err)
-	}
-	incSize := fileSize(t, filepath.Join(incDir, BaseTarGzFile))
-
-	if incSize >= fullSize {
-		t.Fatalf("inkrementelle sicherung (%d bytes) ist nicht kleiner als die vollsicherung (%d bytes) - keine echte inkrementelle Uebertragung", incSize, fullSize)
-	}
-}
-
-func fileSize(t *testing.T, path string) int64 {
-	t.Helper()
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatalf("dateigroesse von %q ermitteln: %v", path, err)
-	}
-	return info.Size()
-}
-
-// TestVerify_DetectsCorruptedFile ist Pruefung 2: Verifikation erkennt eine
-// absichtlich beschaedigte Sicherungsdatei.
-func TestVerify_DetectsCorruptedFile(t *testing.T) {
-	cfg := requireTestConfig(t)
-	ctx := context.Background()
-
-	genID := NewGenerationID(time.Now())
-	manifest, err := FullBackup(ctx, cfg, genID)
-	if err != nil {
-		t.Fatalf("fullbackup: %v", err)
-	}
-	dir := filepath.Dir(manifest)
-
-	if err := Verify(dir); err != nil {
-		t.Fatalf("verify (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: mehrere Bytes in der Mitte der Datei kippen.
-	path := filepath.Join(dir, BaseTarGzFile)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("sicherungsdatei lesen: %v", err)
-	}
-	mid := len(data) / 2
-	for i := mid; i < mid+64 && i < len(data); i++ {
-		data[i] ^= 0xFF
-	}
-	if err := os.WriteFile(path, data, 0o600); err != nil {
-		t.Fatalf("beschaedigte sicherungsdatei schreiben: %v", err)
-	}
-
-	if err := Verify(dir); err == nil {
-		t.Fatal("verify haette die beschaedigte sicherungsdatei erkennen muessen")
-	}
-}
-
-// TestRotate_RemovesOnlyOldestGenerations ist Pruefung 3.
-func TestRotate_RemovesOnlyOldestGenerations(t *testing.T) {
-	backupDir := t.TempDir()
-	generationIDs := []string{
-		"20260101T000000Z",
-		"20260102T000000Z",
-		"20260103T000000Z",
-		"20260104T000000Z",
-		"20260105T000000Z",
-	}
-	for _, id := range generationIDs {
-		if err := os.MkdirAll(filepath.Join(backupDir, id, FullBackupDirName), 0o750); err != nil {
-			t.Fatalf("generation %q anlegen: %v", id, err)
-		}
-	}
-
-	removed, err := Rotate(backupDir, 2)
-	if err != nil {
-		t.Fatalf("rotate: %v", err)
-	}
-	wantRemoved := []string{"20260101T000000Z", "20260102T000000Z", "20260103T000000Z"}
-	if len(removed) != len(wantRemoved) {
-		t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-	}
-	for i, w := range wantRemoved {
-		if removed[i] != w {
-			t.Fatalf("entfernte generationen = %v, want %v", removed, wantRemoved)
-		}
-	}
-
-	remaining, err := ListGenerations(backupDir)
-	if err != nil {
-		t.Fatalf("listgenerations: %v", err)
-	}
-	wantRemaining := []string{"20260104T000000Z", "20260105T000000Z"}
-	if len(remaining) != len(wantRemaining) {
-		t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-	}
-	for i, w := range wantRemaining {
-		if remaining[i] != w {
-			t.Fatalf("verbleibende generationen = %v, want %v", remaining, wantRemaining)
-		}
-	}
-
-	// Die NEUESTEN duerfen NICHT entfernt sein (Pruefung 3: nur die
-	// aeltesten Generationen).
-	for _, w := range wantRemaining {
-		if _, err := os.Stat(filepath.Join(backupDir, w)); err != nil {
-			t.Fatalf("neueste generation %q wurde faelschlich entfernt: %v", w, err)
-		}
-	}
-}

archive/internal/backup/rotate.go

@@ -1,56 +0,0 @@
-package backup
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-)
-
-// ListGenerations liefert alle Generation-IDs in backupDir, aufsteigend
-// sortiert (die GenerationID selbst ist chronologisch sortierbar, siehe
-// NewGenerationID — kein Blick auf Dateisystem-Zeitstempel nötig, die bei
-// einem Restore/Kopiervorgang verändert werden könnten).
-func ListGenerations(backupDir string) ([]string, error) {
-	entries, err := os.ReadDir(backupDir)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, fmt.Errorf("backup: sicherungsverzeichnis lesen: %w", err)
-	}
-	var generations []string
-	for _, e := range entries {
-		if e.IsDir() {
-			generations = append(generations, e.Name())
-		}
-	}
-	sort.Strings(generations)
-	return generations, nil
-}
-
-// Rotate entfernt alle bis auf die `keep` NEUESTEN Generationen
-// (Akzeptanzkriterium 3) — jede Generation umfasst ihre Vollsicherung UND
-// alle davon abhängigen Inkremente, ein Löschen der gesamten
-// Generationsverzeichnisses entfernt beides konsistent zusammen.
-func Rotate(backupDir string, keep int) (removed []string, err error) {
-	if keep < 0 {
-		keep = 0
-	}
-	generations, err := ListGenerations(backupDir)
-	if err != nil {
-		return nil, err
-	}
-	if len(generations) <= keep {
-		return nil, nil
-	}
-
-	toRemove := generations[:len(generations)-keep]
-	for _, gen := range toRemove {
-		if err := os.RemoveAll(filepath.Join(backupDir, gen)); err != nil {
-			return removed, fmt.Errorf("backup: generation %q entfernen: %w", gen, err)
-		}
-		removed = append(removed, gen)
-	}
-	return removed, nil
-}

archive/internal/backup/verify.go

@@ -1,54 +0,0 @@
-package backup
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-// ErrCorrupted wird geliefert, wenn eine Sicherungsdatei nicht lesbar ist
-// (Akzeptanzkriterium 2: Verifikation, nicht nur Erstellungs-Prüfung).
-var ErrCorrupted = fmt.Errorf("backup: sicherungsdatei ist beschaedigt oder unvollstaendig")
-
-// Verify prüft, dass base.tar.gz im gegebenen Sicherungsverzeichnis
-// vollständig lesbar ist — öffnet gzip- UND tar-Stream und liest JEDEN
-// Eintrag bis zum Ende durch (nicht nur die Kopfdaten), damit ein
-// abgeschnittener oder mit kaputten Bytes überschriebener Inhalt
-// zuverlässig auffällt, nicht nur ein defekter Tar-Header.
-func Verify(backupDir string) error {
-	path := filepath.Join(backupDir, BaseTarGzFile)
-	f, err := os.Open(path)
-	if err != nil {
-		return fmt.Errorf("%w: %s nicht lesbar: %v", ErrCorrupted, path, err)
-	}
-	defer func() { _ = f.Close() }()
-
-	gz, err := gzip.NewReader(f)
-	if err != nil {
-		return fmt.Errorf("%w: gzip-header ungueltig: %v", ErrCorrupted, err)
-	}
-	defer func() { _ = gz.Close() }()
-
-	tr := tar.NewReader(gz)
-	entries := 0
-	for {
-		hdr, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("%w: tar-eintrag ungueltig: %v", ErrCorrupted, err)
-		}
-		if _, err := io.Copy(io.Discard, tr); err != nil {
-			return fmt.Errorf("%w: inhalt von %q nicht vollstaendig lesbar: %v", ErrCorrupted, hdr.Name, err)
-		}
-		entries++
-	}
-	if entries == 0 {
-		return fmt.Errorf("%w: archiv enthaelt keine eintraege", ErrCorrupted)
-	}
-	return nil
-}

archive/internal/objectbackup/restic.go

@@ -1,156 +0,0 @@
-// Package objectbackup implementiert BAK-02: automatisierte, inkrementelle,
-// deduplizierende Sicherung des Objekt-Storage-Bestands. Nutzt restic
-// (Content-defined Chunking, verschlüsseltes Repository ab Werk) statt
-// Eigenbau — restic erfüllt alle Akzeptanzkriterien mit ausgereiftem,
-// geprüftem Tooling statt einer weniger robusten Neuimplementierung.
-//
-// Backup-Quelle ist ein lokaler Verzeichnisbaum — für den LocalDriver aus
-// FDN-03 direkt dessen Basisverzeichnis, für S3-gestützte Produktions-
-// Deployments ein vorgelagerter Sync-Schritt (z.B. rclone) auf einen
-// lokalen Spiegel, bevor restic ihn sichert (nicht Bestandteil dieser
-// Kachel — restic selbst sichert Dateibäume, keine S3-Buckets direkt).
-package objectbackup
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-// Config enthält Repository-Ort und -Passwort — ausschließlich über
-// Umgebungsvariablen befüllt (siehe Ticket-Abschluss-Regel).
-type Config struct {
-	RepoDir    string
-	Password   string
-	ResticPath string // Default "restic", überschreibbar für Tests
-}
-
-func (c Config) binary() string {
-	if c.ResticPath != "" {
-		return c.ResticPath
-	}
-	return "restic"
-}
-
-func (c Config) env() []string {
-	return append(os.Environ(), "RESTIC_PASSWORD="+c.Password)
-}
-
-func run(ctx context.Context, cfg Config, args ...string) ([]byte, error) {
-	fullArgs := append([]string{"-r", cfg.RepoDir}, args...)
-	cmd := exec.CommandContext(ctx, cfg.binary(), fullArgs...)
-	cmd.Env = cfg.env()
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return output, fmt.Errorf("%s %v fehlgeschlagen: %w (ausgabe: %s)", cfg.binary(), args, err, string(output))
-	}
-	return output, nil
-}
-
-// InitRepo legt ein neues restic-Repository an, falls es noch nicht
-// existiert — idempotent, ein bereits initialisiertes Repository ist kein
-// Fehler (Wiederholte Aufrufe durch systemd-Timer nach einem Neustart
-// dürfen nicht fehlschlagen).
-func InitRepo(ctx context.Context, cfg Config) error {
-	output, err := run(ctx, cfg, "init")
-	if err != nil {
-		if strings.Contains(string(output), "config file already exists") {
-			return nil
-		}
-		return fmt.Errorf("objectbackup: repository initialisieren: %w", err)
-	}
-	return nil
-}
-
-// BackupSummary ist der geparste "summary"-Datensatz aus `restic backup --json`.
-type BackupSummary struct {
-	SnapshotID      string `json:"snapshot_id"`
-	FilesNew        int    `json:"files_new"`
-	FilesChanged    int    `json:"files_changed"`
-	FilesUnmodified int    `json:"files_unmodified"`
-	DataBlobs       int    `json:"data_blobs"`
-	TotalBytes      int64  `json:"total_bytes_processed"`
-}
-
-// Backup sichert sourceDir inkrementell (Akzeptanzkriterium 1: unveränderte
-// Objekte werden nicht erneut übertragen — restics Content-defined
-// Chunking erkennt das automatisch, kein manueller Änderungsabgleich
-// nötig).
-func Backup(ctx context.Context, cfg Config, sourceDir string) (BackupSummary, error) {
-	output, err := run(ctx, cfg, "backup", sourceDir, "--json")
-	if err != nil {
-		return BackupSummary{}, fmt.Errorf("objectbackup: sicherung: %w", err)
-	}
-	return parseSummary(output)
-}
-
-// parseSummary sucht in der zeilenweisen JSON-Ausgabe von `restic backup
-// --json` (mehrere Fortschritts-/Statuszeilen, GENAU EINE mit
-// message_type=="summary") die Zusammenfassung.
-func parseSummary(output []byte) (BackupSummary, error) {
-	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-	for i := len(lines) - 1; i >= 0; i-- {
-		var probe struct {
-			MessageType string `json:"message_type"`
-		}
-		if err := json.Unmarshal([]byte(lines[i]), &probe); err != nil {
-			continue
-		}
-		if probe.MessageType == "summary" {
-			var summary BackupSummary
-			if err := json.Unmarshal([]byte(lines[i]), &summary); err != nil {
-				return BackupSummary{}, fmt.Errorf("objectbackup: summary-zeile dekodieren: %w", err)
-			}
-			return summary, nil
-		}
-	}
-	return BackupSummary{}, fmt.Errorf("objectbackup: keine summary-zeile in der restic-ausgabe gefunden")
-}
-
-// Check prüft die Vollständigkeit/Lesbarkeit des Repository
-// (Akzeptanzkriterium 3 / Pflichtprüfung: Vollständigkeitsprüfung erkennt
-// fehlendes/beschädigtes Objekt). readData=true liest jeden gespeicherten
-// Datenblock tatsächlich (teurer, aber die einzige Prüfung, die
-// Bit-Rot in bereits gespeicherten Paketen erkennt — ohne readData prüft
-// restic nur Struktur/Indizes, nicht den tatsächlichen Blockinhalt).
-func Check(ctx context.Context, cfg Config, readData bool) error {
-	args := []string{"check"}
-	if readData {
-		args = append(args, "--read-data")
-	}
-	if _, err := run(ctx, cfg, args...); err != nil {
-		return fmt.Errorf("objectbackup: %w", err)
-	}
-	return nil
-}
-
-// Forget entfernt alte Snapshots nach Rotationsregel und gibt den davon
-// belegten Speicherplatz frei (--prune) — restics Äquivalent zu
-// BAK-01s Rotate.
-func Forget(ctx context.Context, cfg Config, keepLast int) error {
-	if _, err := run(ctx, cfg, "forget", "--keep-last", fmt.Sprintf("%d", keepLast), "--prune"); err != nil {
-		return fmt.Errorf("objectbackup: rotation: %w", err)
-	}
-	return nil
-}
-
-type snapshotEntry struct {
-	ShortID string `json:"short_id"`
-}
-
-// SnapshotCount liefert die Anzahl vorhandener Snapshots — für Tests und
-// Statusabfragen.
-func SnapshotCount(ctx context.Context, cfg Config) (int, error) {
-	output, err := run(ctx, cfg, "snapshots", "--json")
-	if err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshots auflisten: %w", err)
-	}
-	var snapshots []snapshotEntry
-	if err := json.Unmarshal(output, &snapshots); err != nil {
-		return 0, fmt.Errorf("objectbackup: snapshot-liste dekodieren: %w", err)
-	}
-	return len(snapshots), nil
-}

archive/internal/objectbackup/restic_test.go

@@ -1,168 +0,0 @@
-package objectbackup
-
-import (
-	"context"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-func requireRestic(t *testing.T) {
-	t.Helper()
-	if _, err := exec.LookPath("restic"); err != nil {
-		t.Skip("restic nicht installiert, Integrationstest uebersprungen")
-	}
-}
-
-func setupTest(t *testing.T) Config {
-	t.Helper()
-	requireRestic(t)
-	cfg := Config{RepoDir: filepath.Join(t.TempDir(), "repo"), Password: "test-passwort-fuer-objectbackup"}
-	if err := InitRepo(context.Background(), cfg); err != nil {
-		t.Fatalf("initrepo: %v", err)
-	}
-	return cfg
-}
-
-func writeFile(t *testing.T, dir, name, content string) {
-	t.Helper()
-	if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
-		t.Fatalf("testdatei %q schreiben: %v", name, err)
-	}
-}
-
-// TestBackup_UnchangedSecondRunTransmitsNothingNew ist Pruefung 1:
-// zweiter Sicherungslauf nach unveraendertem Bestand ueberraegt keine
-// Daten erneut.
-func TestBackup_UnchangedSecondRunTransmitsNothingNew(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "dokument.pdf", "unveraenderter inhalt")
-
-	first, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("erste sicherung: %v", err)
-	}
-	if first.FilesNew != 1 {
-		t.Fatalf("erste sicherung: files_new = %d, want 1", first.FilesNew)
-	}
-
-	second, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("zweite sicherung: %v", err)
-	}
-	if second.FilesNew != 0 || second.FilesChanged != 0 {
-		t.Fatalf("zweite sicherung (unveraendert): files_new=%d files_changed=%d, want beide 0", second.FilesNew, second.FilesChanged)
-	}
-	if second.FilesUnmodified != 1 {
-		t.Fatalf("zweite sicherung: files_unmodified = %d, want 1", second.FilesUnmodified)
-	}
-}
-
-// TestBackup_DeduplicatesIdenticalContent ist Pruefung 2: zwei identische
-// Testdateien belegen nachweislich nur einmal Speicherplatz.
-func TestBackup_DeduplicatesIdenticalContent(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	content := "exakt identischer inhalt in beiden dateien fuer den dedup-nachweis"
-	writeFile(t, sourceDir, "original.pdf", content)
-	writeFile(t, sourceDir, "kopie.pdf", content)
-
-	summary, err := Backup(ctx, cfg, sourceDir)
-	if err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if summary.FilesNew != 2 {
-		t.Fatalf("erwartet 2 neue dateien, habe %d", summary.FilesNew)
-	}
-	// Zwei Dateien mit IDENTISCHEM Inhalt duerfen nur EINEN data_blob
-	// erzeugen - das ist der Dedup-Nachweis (Akzeptanzkriterium 2).
-	if summary.DataBlobs != 1 {
-		t.Fatalf("data_blobs = %d, want 1 (zwei identische dateien haetten nur einen blob erzeugen duerfen - keine dedup)", summary.DataBlobs)
-	}
-}
-
-// TestCheck_DetectsCorruptedPack ist Pruefung 3: Vollstaendigkeitspruefung
-// erkennt ein beschaedigtes/fehlendes Objekt in der Sicherung.
-func TestCheck_DetectsCorruptedPack(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-	writeFile(t, sourceDir, "wichtig.pdf", "inhalt, der spaeter absichtlich beschaedigt wird")
-
-	if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-		t.Fatalf("sicherung: %v", err)
-	}
-	if err := Check(ctx, cfg, true); err != nil {
-		t.Fatalf("check (unbeschaedigt) haette erfolgreich sein muessen: %v", err)
-	}
-
-	// Absichtliche Beschaedigung: ein Byte in einer Pack-Datei im
-	// Repository kippen (dieselbe Fundstelle wie beim manuellen
-	// Nachweis waehrend der Recherche zu diesem Ticket).
-	packDir := filepath.Join(cfg.RepoDir, "data")
-	corrupted := false
-	if err := filepath.Walk(packDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil || info.IsDir() || corrupted {
-			return err
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		if len(data) < 20 {
-			return nil
-		}
-		data[10] ^= 0xFF
-		if err := os.WriteFile(path, data, 0o600); err != nil {
-			return err
-		}
-		corrupted = true
-		return nil
-	}); err != nil {
-		t.Fatalf("pack-datei beschaedigen: %v", err)
-	}
-	if !corrupted {
-		t.Fatal("keine pack-datei zum beschaedigen gefunden - testaufbau fehlerhaft")
-	}
-
-	if err := Check(ctx, cfg, true); err == nil {
-		t.Fatal("check haette die beschaedigte pack-datei erkennen muessen")
-	}
-}
-
-// TestForget_KeepsOnlyRequestedSnapshotCount prueft die Rotation.
-func TestForget_KeepsOnlyRequestedSnapshotCount(t *testing.T) {
-	cfg := setupTest(t)
-	ctx := context.Background()
-	sourceDir := t.TempDir()
-
-	for i := 0; i < 3; i++ {
-		writeFile(t, sourceDir, "f.txt", "version "+string(rune('a'+i)))
-		if _, err := Backup(ctx, cfg, sourceDir); err != nil {
-			t.Fatalf("sicherung %d: %v", i, err)
-		}
-	}
-	before, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (vorher): %v", err)
-	}
-	if before != 3 {
-		t.Fatalf("erwartet 3 snapshots vor rotation, habe %d", before)
-	}
-
-	if err := Forget(ctx, cfg, 1); err != nil {
-		t.Fatalf("forget: %v", err)
-	}
-
-	after, err := SnapshotCount(ctx, cfg)
-	if err != nil {
-		t.Fatalf("snapshotcount (nachher): %v", err)
-	}
-	if after != 1 {
-		t.Fatalf("erwartet 1 snapshot nach rotation (keep-last 1), habe %d", after)
-	}
-}

deploy/systemd/nexarch-archive-backup-full.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Vollsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli full

deploy/systemd/nexarch-archive-backup-full.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Datenbank-Vollsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 02:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-backup-incremental.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Datenbank-Inkrementalsicherung (BAK-01)
-After=network.target postgresql.service
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli incremental

deploy/systemd/nexarch-archive-backup-incremental.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Datenbank-Inkrementalsicherung (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* *:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-backup-rotate.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Sicherungsgenerationen-Rotation (BAK-01)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-backup.env
-ExecStart=__INSTALL_DIR__/bin/backup-cli rotate

deploy/systemd/nexarch-archive-backup-rotate.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Sicherungsgenerationen-Rotation (BAK-01)
-
-[Timer]
-OnCalendar=*-*-* 03:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-backup.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli backup __OBJECT_SOURCE_DIR__

deploy/systemd/nexarch-archive-objectbackup-backup.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Stuendlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Sicherung (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* *:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-check.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Vollstaendigkeitspruefung (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli check

deploy/systemd/nexarch-archive-objectbackup-check.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Woechentlicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Vollstaendigkeitspruefung (BAK-02)
-
-[Timer]
-OnCalendar=Sun *-*-* 04:00:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

deploy/systemd/nexarch-archive-objectbackup-rotate.service.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=NEXARCH Archive - Objekt-Storage-Sicherung Rotation (BAK-02)
-After=network.target
-
-[Service]
-Type=oneshot
-User=nexarch
-EnvironmentFile=/etc/nexarch/archive-objectbackup.env
-ExecStart=__INSTALL_DIR__/bin/objectbackup-cli rotate

deploy/systemd/nexarch-archive-objectbackup-rotate.timer.tmpl

@@ -1,9 +0,0 @@
-[Unit]
-Description=Taeglicher Zeitplan fuer NEXARCH Archive Objekt-Storage-Rotation (BAK-02)
-
-[Timer]
-OnCalendar=*-*-* 03:30:00
-Persistent=true
-
-[Install]
-WantedBy=timers.target

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/go.sum

@@ -0,0 +1,28 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
+github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
+github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

mail/internal/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)
+	}
+}