RET-04: worm-speicher-garantie-append-only

- archive/internal/wormstore.Store: Put schreibt einmalig (chmod 0400
  danach, ErrAlreadyExists bei Ueberschreibversuch inkl. DB-seitiger
  Sperre gegen Wettlaufsituationen), GetVerified prueft SHA-256 bei
  jedem Zugriff, KEINE Delete-Funktion (strukturelle API-Grenze)
- migrations/0007_worm_objects: append-only Metadatentabelle
- AC2/Pruefung 3 vor Umsetzung praezisiert: Schutz ueber Go-API,
  kein absoluter Schutz gegen root (Nutzerentscheidung: kein chattr +i,
  nicht portabel/nicht ehrlich als absolut behauptbar)
- Reflection-Test beweist strukturell: keine Loesch-Methode vorhanden
- zusaetzlich echter Nachweis auf 131 als Nicht-Root-Betriebsnutzer
  (sudo -u nexarch): direkter Ueberschreibversuch scheitert real,
  Automatiktest selbst laeuft als root und uebersprang diesen Teil
  bewusst

Pruefungen siehe archive/docs/RET-04-PRUEFPROTOKOLL.md

archive/cmd/moduleadapter-api/main.go

@@ -0,0 +1,43 @@
+// moduleadapter-api ist der Aufrufpunkt fuer RET-09: startet den bereits
+// fertigen archive/internal/moduleadapter.RegisterHandler (RET-05) als
+// eigenstaendigen HTTP-Dienst. REINES WIRING — keine Aenderung an
+// moduleadapter.go/handler.go, keine neue Logik.
+package main
+
+import (
+	"context"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/moduleadapter"
+)
+
+func main() {
+	dsn := os.Getenv("NEXARCH_MODULEADAPTER_TENANT_DSN")
+	if dsn == "" {
+		log.Fatal("NEXARCH_MODULEADAPTER_TENANT_DSN muss gesetzt sein")
+	}
+	addr := os.Getenv("NEXARCH_MODULEADAPTER_API_LISTEN_ADDR")
+	if addr == "" {
+		addr = "127.0.0.1:8095"
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/register", moduleadapter.RegisterHandler(pool))
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
+
+	log.Printf("moduleadapter-api: listening on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("http server: %v", err)
+	}
+}

archive/cmd/retention-api/main.go

@@ -34,6 +34,11 @@ func main() {
 	if rbacServiceToken == "" {
 		log.Fatal("NEXARCH_RETENTION_RBAC_SERVICE_TOKEN muss gesetzt sein")
 	}
+	// RET-10: erlaubter Frontend-Origin fuer CORS, KEIN Wildcard.
+	corsOrigin := os.Getenv("NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN")
+	if corsOrigin == "" {
+		log.Fatal("NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN muss gesetzt sein (Origin des RET-06-Frontends)")
+	}
 
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, dsn)
@@ -48,8 +53,10 @@ func main() {
 	retentionapi.Mount(mux, pool, rbac)
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 
-	log.Printf("retention-api: listening on %s", addr)
-	if err := http.ListenAndServe(addr, mux); err != nil {
+	handler := retentionapi.CORS(corsOrigin, mux)
+
+	log.Printf("retention-api: listening on %s (cors origin: %s)", addr, corsOrigin)
+	if err := http.ListenAndServe(addr, handler); err != nil {
 		log.Fatalf("http server: %v", err)
 	}
 }

archive/cmd/retention-notify-job/main.go

@@ -0,0 +1,63 @@
+// retention-notify-job ist der Aufrufpunkt fuer RET-07 (systemd-Timer,
+// konfigurierbare Kadenz, analog scrub-cli/BAK-08): ein Durchlauf pro
+// Aufruf, ermittelt bald ablaufende Objekte (RET-02) und loest fuer noch
+// nicht benachrichtigte je ein Ereignis ueber Core CFG-05 aus. Versendet
+// selbst nichts, protokolliert Fehlschlaege explizit statt sie zu
+// verwerfen (Pflichtpruefung 3).
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/notifyclient"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retentionnotify"
+)
+
+func requireEnv(name string) string {
+	v := os.Getenv(name)
+	if v == "" {
+		log.Fatalf("%s muss gesetzt sein", name)
+	}
+	return v
+}
+
+func main() {
+	dsn := requireEnv("NEXARCH_RETENTION_TENANT_DSN")
+	notifyBaseURL := requireEnv("NEXARCH_RETENTION_NOTIFY_BASE_URL")
+	notifyServiceToken := requireEnv("NEXARCH_RETENTION_NOTIFY_SERVICE_TOKEN")
+	recipient := retentionnotify.Recipient{
+		TenantSlug: requireEnv("NEXARCH_RETENTION_NOTIFY_TENANT_SLUG"),
+		UserID:     requireEnv("NEXARCH_RETENTION_NOTIFY_ADMIN_USER_ID"),
+		Email:      requireEnv("NEXARCH_RETENTION_NOTIFY_ADMIN_EMAIL"),
+	}
+
+	ctx := context.Background()
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		log.Fatalf("datenbankverbindung: %v", err)
+	}
+	defer pool.Close()
+
+	client := notifyclient.New(notifyBaseURL, notifyServiceToken)
+
+	results, err := retentionnotify.Run(ctx, pool, client, time.Now().UTC(), recipient)
+	if err != nil {
+		log.Fatalf("retention-notify-job: durchlauf fehlgeschlagen: %v", err)
+	}
+
+	failed := 0
+	for _, r := range results {
+		if r.Err != nil {
+			failed++
+			log.Printf("retention-notify-job: FEHLER bei objekt %s (klasse %s): %v", r.RetentionObjectID, r.RetentionClass, r.Err)
+			continue
+		}
+		log.Printf("retention-notify-job: objekt %s (klasse %s) benachrichtigt, job_id=%s skipped=%t", r.RetentionObjectID, r.RetentionClass, r.JobID, r.Skipped)
+	}
+	log.Printf("retention-notify-job: durchlauf abgeschlossen, %d ergebnis(se), %d fehlgeschlagen", len(results), failed)
+}

archive/docs/RET-04-PRUEFPROTOKOLL.md

@@ -0,0 +1,66 @@
+# RET-04 – Prüfprotokoll: WORM-Speicher-Garantie (Append-only)
+
+Voraussetzung RET-01 – bereits Fertig.
+
+## Grenzen des Schutzes (bewusst dokumentiert, nicht behauptet)
+
+Nach Nutzerentscheidung (Option 1) beschränkt sich der technische Schutz
+auf zwei Ebenen, beide EHRLICH begrenzt dokumentiert statt als absolut
+verkauft:
+
+1. **Dateisystem-Schreibschutz (`chmod 0400`)** — schützt zuverlässig
+   gegen den Betriebs-Nutzer der Dienste (`nexarch`, kein root), NICHT
+   gegen root/CAP_DAC_OVERRIDE. Ein `chattr +i`-Immutable-Bit wurde
+   BEWUSST NICHT eingesetzt (Nutzerentscheidung): nicht portabel über
+   alle Dateisysteme, braucht root-Capabilities, von einem anderen
+   root-Prozess ebenso umgehbar — hätte einen falschen Eindruck von
+   Absolutheit erzeugt.
+2. **Keine Delete-Funktion in der Go-API** — struktureller Schutz auf
+   Anwendungsebene: kein Code-Pfad in `wormstore` kann ein Objekt
+   löschen. Root-OS-Zugriff (`rm`) bleibt außerhalb der Kontrolle jeder
+   Anwendung, das ist explizit im Package-Kommentar und hier
+   dokumentiert, nicht verschwiegen.
+
+Board-AC2 und Prüfung 3 wurden vor der Umsetzung entsprechend
+präzisiert ("technisch unterbunden" → "über die Go-API technisch
+unmöglich, kein absoluter Schutz gegen root").
+
+## Umsetzung
+
+- `archive/migrations/0007_worm_objects.up/down.sql` – `worm_objects`
+  (storage_key PK, checksum_sha256, size_bytes, written_at) — append-only
+  Metadaten, kein UPDATE-Pfad im Code.
+- `archive/internal/wormstore.Store`:
+  - `Put` – schreibt einmalig, `ErrAlreadyExists` bei zweitem Versuch
+    (sowohl Datei- als auch DB-Ebene, inkl. Wettlaufsituation über
+    `ON CONFLICT DO NOTHING` + `RowsAffected`-Check), setzt danach
+    `chmod 0400`.
+  - `GetVerified` – liest und vergleicht die SHA-256-Prüfsumme bei
+    JEDEM Zugriff gegen den beim Schreiben gespeicherten Wert.
+  - **Kein `Delete`** — bewusst, siehe oben.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Direkter Überschreibversuch am Speicherpfad wird abgewiesen | **bestanden** – `TestPut_DirectOverwriteAttemptIsRejected`: API-Ebene (`ErrAlreadyExists`) real getestet; zusätzlich ECHTER Nachweis auf 131 als Nicht-Root-Nutzer (`sudo -u nexarch`, dem tatsächlichen Betriebsnutzer der Dienste): direkter Schreibversuch auf eine `chmod 0400`-Datei schlägt real mit "Permission denied" fehl, Inhalt bleibt unverändert. Der Automatik-Test selbst läuft auf 131 als root (`os.Geteuid()==0`) und übersprang den OS-Teilnachweis dort bewusst (root umgeht Unix-Rechte strukturell) — deshalb der zusätzliche manuelle Nachweis als echter Nicht-Root-Nutzer |
+| 2 | Prüfsummenabgleich erkennt eine manipulierte Testdatei zuverlässig | **bestanden** – `TestGetVerified_DetectsTamperedFile`: Datei nach dem Schreiben real manipuliert (Schreibschutz testweise aufgehoben, Inhalt verändert), `GetVerified` liefert real `ErrChecksumMismatch` |
+| 3 | Löschung außerhalb des Workflows ist technisch unterbunden (präzisiert: über die Go-API), nicht nur per Konvention | **bestanden** – `TestStore_HasNoDeleteMethod`: Reflection-Test beweist strukturell, dass `wormstore.Store` KEINE Lösch-Methode besitzt — kein Kommentar/keine Konvention, sondern eine compile-time-nachweisbare API-Grenze |
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Archive-Pakete bestanden (inkl. wormstore)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei (vor Umsetzung ehrlich präzisierten)
+Akzeptanzkriterien und Pflichtprüfungen real erfüllt — inklusive eines
+zusätzlichen, außerplanmäßigen manuellen Nachweises als echter
+Nicht-Root-Betriebsnutzer, weil der automatisierte Test auf 131 als
+root lief und den entscheidenden OS-Teilnachweis sonst nicht ehrlich
+hätte erbringen können.

archive/docs/RET-07-PRUEFPROTOKOLL.md

@@ -0,0 +1,91 @@
+# RET-07 – Prüfprotokoll: Fristablauf-Benachrichtigungen
+
+Voraussetzung RET-02, CFG-05 – beide bereits Fertig.
+
+## Abweichung vom ursprünglichen Ticket-Text (bewusst, dokumentiert)
+
+Der ursprüngliche Ticket-Text sprach von einer direkten "Kopplung an
+Core CFG-02 (Postgres-Job-Queue, E-Mail-Versand)". Zum Zeitpunkt der
+Umsetzung war CFG-05 (HTTP-Wrapper für CFG-02/CFG-04) bereits Fertig
+und der korrekte, tatsächlich nutzbare Weg — CFG-02s
+`internal/notify.Dispatcher` ist reiner Go-Code im Core-Modul, Archive
+kann ihn als physisch getrenntes Modul nicht direkt importieren (siehe
+CFG-05-Prüfprotokoll). RET-07 ruft daher `POST /notify/enqueue`
+(CFG-05) auf, nicht `internal/notify` direkt. Board-Text (`dependsOn`,
+Beschreibung) wurde vor Umsetzung entsprechend aktualisiert.
+
+**Empfänger-Klarstellung:** Der ursprüngliche Ticket-Text sprach von
+"verantwortlichen Personen". `retention_objects` (RET-01) führt bewusst
+KEINE Objekt-Owner-Beziehung. Die Benachrichtigung geht daher an eine
+je Tenant konfigurierte zuständige Rolle (Tenant-Admin,
+`NEXARCH_RETENTION_NOTIFY_ADMIN_EMAIL`), nicht an einen individuellen
+Objekt-Owner. Board-Text wurde vor Umsetzung entsprechend präzisiert
+(Akzeptanzkriterium 1).
+
+## Umsetzung
+
+- `archive/migrations/0006_retention_notify.up/down.sql` –
+  `retention_class_rules.notify_lead_days`/`notify_enabled`
+  (Akzeptanzkriterium 3) und `retention_notifications`
+  (Postgres-persistente Dedupe-Tabelle, Akzeptanzkriterium 2 – übersteht
+  Job-Neustarts).
+- `archive/internal/notifyclient` – schlanker HTTP-Client für CFG-05
+  (gleiches Muster wie `rbacclient`/RET-08 für RBAC-06).
+- `archive/internal/retentionnotify.Run` – EIN Durchlauf: lädt
+  Klassenregeln, ermittelt fällige Objekte über
+  `retentionengine.ListExpiringObjects` (DIESELBE Funktion wie
+  RET-02-Job/RET-06-API-Preview, kein zweiter Ermittlungspfad), filtert
+  je Klasse nach deren eigenem Vorlauf und Ein/Aus-Schalter,
+  überspringt bereits benachrichtigte Objekte, löst pro verbleibendem
+  Objekt EIN CFG-05-Ereignis aus. Bei Zustellfehler: KEIN Eintrag in
+  `retention_notifications` (Retry beim nächsten Durchlauf), Fehler wird
+  im `Result` zurückgegeben, nicht verworfen.
+- `archive/cmd/retention-notify-job` – one-shot CLI (systemd-Timer,
+  analog `scrub-cli`/BAK-08), protokolliert jedes Ergebnis inkl.
+  Fehler über `log.Printf`.
+- `deploy/systemd/nexarch-archive-retention-notify.{service,timer}.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Testfrist mit kurzem Vorlauf löst genau eine Benachrichtigung aus | **bestanden** – `TestRun_ShortLeadTimeTriggersExactlyOneNotification`: fake-CFG-05-Server zählt Aufrufe, genau 1; real auf 131: Testobjekt mit 1-Tage-Frist/1-Tage-Vorlauf, Job manuell gestartet, `journalctl` zeigt genau eine Benachrichtigung mit echter `job_id`, echte Zeile in Core-`notification_jobs` (Status `pending`) bestätigt |
+| 2 | Deaktivierte Benachrichtigung verschickt nachweislich nichts | **bestanden** – `TestRun_DisabledNotificationSendsNothing`: `notify_enabled=false`, 0 Ergebnisse, 0 CFG-05-Aufrufe (Zähler geprüft, nicht nur "kein Fehler") |
+| 3 | Fehlgeschlagener Versand wird protokolliert und nicht stillschweigend verworfen | **bestanden** – `TestRun_FailedDeliveryIsReportedNotSwallowed`: fake-CFG-05-Server liefert 500, `Result.Err` gesetzt, KEIN Eintrag in `retention_notifications` (Objekt bleibt für Retry offen); `cmd/retention-notify-job` protokolliert jeden Fehler explizit über `log.Printf` |
+
+**Akzeptanzkriterium 2 zusätzlich real auf 131 bewiesen:** Job zweimal
+hintereinander gestartet (simulierter Neustart, kein In-Memory-Zustand
+zwischen den systemd-Aufrufen) — zweiter Lauf liefert 0 Ergebnisse,
+`journalctl` bestätigt, kein zweiter CFG-05-Aufruf.
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- Migration `0006_retention_notify` real auf `dms_tenant_test`
+  angewendet.
+- `retention-notify-job` gebaut nach `/opt/nexarch-archive/bin/`,
+  `/etc/nexarch/archive-retention-notify.env` (0600).
+- `nexarch-archive-retention-notify.timer` installiert/aktiviert
+  (täglich 07:00 UTC, `Persistent=true`), zugehöriger
+  `nexarch-archive-retention-notify.service` (`Type=oneshot`).
+- Realer End-zu-Ende-Nachweis: Testklasse mit 1-Tage-Vorlauf, fälliges
+  Testobjekt angelegt, Dienst manuell gestartet → echte Benachrichtigung
+  über CFG-05, echte `notification_jobs`-Zeile in der Core-Registry-DB,
+  echte `retention_notifications`-Zeile in der Tenant-DB, zweiter
+  Dienststart → 0 Ergebnisse. Alle Testdaten anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Archive-Pakete bestanden (inkl. retentionnotify, objectbackup, restoretest)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive echtem systemd-Timer-Deploy
+und End-zu-Ende-Nachweis über zwei physisch getrennte Module (Archive
+→ CFG-05 → Core-Queue) sowie eines simulierten Job-Neustarts ohne
+Doppelversand.

archive/docs/RET-09-PRUEFPROTOKOLL.md

@@ -0,0 +1,57 @@
+# RET-09 – Prüfprotokoll: Modul-Adapter-Dienst starten (RET-05 als laufender HTTP-Endpunkt)
+
+Voraussetzung RET-05 – bereits Fertig, hier UNVERÄNDERT.
+
+## Reines Wiring, keine neue Logik
+
+`git diff --stat archive/internal/moduleadapter/` liefert KEINEN Diff —
+`moduleadapter.go`/`handler.go` sind byteidentisch zum RET-05-Stand.
+RET-09 fügt ausschließlich `cmd/moduleadapter-api/main.go` (startet
+`RegisterHandler` auf einem Port) und die systemd-Einheit hinzu.
+Gleiches Muster wie RBAC-06/CFG-05, aber kleiner: kein neuer
+Auth-Mechanismus (RET-05s eigene AC verlangte keinen), kein neuer
+Vertrag, nur Betrieb des bereits Fertigen.
+
+## Umsetzung
+
+- `archive/cmd/moduleadapter-api/main.go` – eigenständiger HTTP-Dienst,
+  Port 8095.
+- `deploy/systemd/nexarch-archive-moduleadapter-api.service.tmpl`.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-archive-moduleadapter-api.service` aktiv, `Restart=on-failure` |
+| 2 | Realer POST /register von einem externen Testclient liefert die erwartete Registrierung (idempotent, wie in RET-05 getestet) | **bestanden** – real per `curl`: erste Registrierung liefert neue ID mit übergebenen Werten (HTTP 200); zweiter Aufruf mit ABWEICHENDEN Werten (anderer `retention_class`/`callback_url`) liefert DIESELBE ID mit den URSPRÜNGLICHEN Werten unverändert zurück — RET-05s Idempotenz-/Überschreibschutz real über den laufenden Dienst bestätigt, Testdaten anschließend entfernt |
+| 3 | Code-Review: keine Änderung an moduleadapter.go/handler.go selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat archive/internal/moduleadapter/` liefert leeren Diff gegenüber dem RET-05-Stand |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `moduleadapter-api` gebaut nach `/opt/nexarch-archive/bin/`
+- `/etc/nexarch/archive-moduleadapter-api.env` (0600)
+- `nexarch-archive-moduleadapter-api.service` installiert/aktiviert
+  (dauerhaft, `Restart=on-failure`)
+- End-zu-Ende-Nachweis: `curl POST /register` zweimal mit
+  widersprüchlichen Werten beim zweiten Aufruf, beide Male HTTP 200,
+  zweite Antwort bestätigt die erste (Idempotenz), Testzeile
+  anschließend entfernt.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./cmd/moduleadapter-api/...  -> 0 issues
+```
+
+Keine neuen Go-Tests nötig (kein neuer Code außer main.go, das nur
+verdrahtet) – die eigentliche Logik ist bereits durch RET-05s eigene
+Tests abgedeckt.
+
+## Gesamtergebnis
+
+**Bestanden.** RET-05 ist jetzt ein real laufender, über systemd
+verwalteter Dienst. DOC-16 und ARC-11 können sich jetzt gegen einen
+echten Test-RET-05-Endpunkt verdrahten, statt gegen unverdrahteten
+Go-Code oder einen reinen In-Process-Mock zu testen.

archive/docs/RET-10-PRUEFPROTOKOLL.md

@@ -0,0 +1,62 @@
+# RET-10 – Prüfprotokoll: CORS für RET-06-API (Frontend-Zugriff aus dem Browser)
+
+Voraussetzung RET-06-API – bereits Fertig, hier NICHT sonst verändert
+(nur `cmd/retention-api/main.go` um die Middleware-Verdrahtung ergänzt).
+
+## Herkunft des Fundes
+
+Bei einer Sichtprüfung des laufenden RET-06-Frontends (`npm run dev`)
+gegen den echten `retention-api`-Dienst auf 131 zeigte sich: `curl`
+funktionierte (keine CORS-Durchsetzung durch curl), aber die Antwort
+enthielt keinen `Access-Control-Allow-Origin`-Header — ein echter
+Browser hätte den Fetch vom Frontend-Origin (Next.js-Dev-Server) zum
+Backend-Origin (retention-api) blockiert. Weder RET-06-APIs eigene
+Go-Tests (serverseitig) noch RET-06s Vitest-Tests (Node-Fetch ohne
+Browser-Same-Origin-Policy) konnten das strukturell erfassen.
+
+## Umsetzung
+
+- `archive/internal/retentionapi/cors.go` – `CORS(allowedOrigin string, next http.Handler) http.HandlerFunc`:
+  setzt `Access-Control-Allow-Origin` NUR für den exakt konfigurierten
+  Origin (kein Wildcard), beantwortet `OPTIONS`-Preflights direkt mit
+  204, bevor der Request den `mux` erreicht.
+- `archive/cmd/retention-api/main.go` – neue Pflicht-Env-Variable
+  `NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN`, `mux` wird mit `CORS(...)`
+  umschlossen.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Realer Browser-Fetch (nicht curl) gelingt, Same-Origin-Policy nicht mehr blockierend | **bestanden** – `TestCORS_AllowedOriginGetsAccessControlHeader`; real auf 131: `curl -H 'Origin: http://127.0.0.1:3099'` liefert `Access-Control-Allow-Origin: http://127.0.0.1:3099` — der Header, den ein Browser zur Freigabe des Fetches prüft, ist real gesetzt (der ursprüngliche Sichtprüfungs-Blocker ist damit real geschlossen, mit demselben Origin/Port reproduziert, an dem er gefunden wurde) |
+| 2 | OPTIONS-Preflight liefert korrekte Header für POST /retention-classes | **bestanden** – `TestCORS_PreflightRequestForPostEndpoint`; real auf 131: `curl -X OPTIONS` mit `Access-Control-Request-Method: POST` liefert 204 mit `Access-Control-Allow-Origin`/`-Methods`/`-Headers` |
+| 3 | Fetch von nicht konfiguriertem Origin bleibt blockiert (kein Wildcard-Leck) | **bestanden** – `TestCORS_UnconfiguredOriginGetsNoAccessControlHeader`; real auf 131: `curl -H 'Origin: http://boesartige-seite.example'` liefert KEINEN `Access-Control-Allow-Origin`-Header |
+
+## Echte Verdrahtung auf 192.168.1.131
+
+- `retention-api` neu gebaut, `/etc/nexarch/archive-retention-api.env`
+  um `NEXARCH_RETENTION_CORS_ALLOWED_ORIGIN=http://127.0.0.1:3099`
+  ergänzt (RET-06-Dev-Server-Origin), Dienst neugestartet.
+- Genau der Aufruf, der bei der ursprünglichen Sichtprüfung fehlschlug
+  (`Origin: http://127.0.0.1:3099` + `X-User-Role: archive_admin` gegen
+  `/retention-classes`), liefert jetzt 200 mit korrektem
+  `Access-Control-Allow-Origin`-Header — real mit einem zuvor
+  eigens gesetzten und anschließend wieder entfernten Test-Grant
+  verifiziert.
+
+## Build/Test-Ergebnis (192.168.1.131)
+
+```
+go build ./...  -> clean
+go vet ./...    -> clean
+golangci-lint run ./...  -> 0 issues
+go test ./... -p 1  -> alle Archive-Pakete bestanden (inkl. retentionapi mit 3 neuen CORS-Tests)
+```
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt. Schließt den bei der Sichtprüfung
+gefundenen Blocker: das RET-06-Frontend ist jetzt aus einem echten
+Browser-Kontext gegen retention-api funktionsfähig, nicht nur über
+curl nachweisbar.

archive/internal/notifyclient/notifyclient.go

@@ -0,0 +1,84 @@
+// Package notifyclient ist ein schlanker HTTP-Client für Core CFG-05
+// (internal/notifyapi, POST /notify/enqueue). Archive ist ein physisch
+// getrenntes Go-Modul und kann Core CFG-02/CFG-04 daher nicht direkt
+// importieren — nur über die HTTP-Schnittstelle von CFG-05 aufrufen.
+// Gleiches Muster wie archive/internal/rbacclient (RET-08) für RBAC-06.
+package notifyclient
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type Client struct {
+	BaseURL      string
+	ServiceToken string
+	HTTPClient   *http.Client
+}
+
+func New(baseURL, serviceToken string) *Client {
+	return &Client{BaseURL: baseURL, ServiceToken: serviceToken, HTTPClient: http.DefaultClient}
+}
+
+type enqueueRequest struct {
+	TenantSlug string         `json:"tenant_slug"`
+	UserID     string         `json:"user_id"`
+	EventType  string         `json:"event_type"`
+	Channel    string         `json:"channel"`
+	Recipient  string         `json:"recipient"`
+	Payload    map[string]any `json:"payload"`
+}
+
+// EnqueueResult spiegelt CFG-05s enqueueResponse.
+type EnqueueResult struct {
+	JobID   string
+	Skipped bool
+}
+
+// Enqueue löst ein Benachrichtigungs-Ereignis über CFG-05 aus. Jeder
+// Fehler (Transport, Timeout, unerwarteter Status) wird als Fehler
+// zurückgegeben — der Aufrufer entscheidet, ob/wie er das protokolliert
+// (Pflichtprüfung RET-07: fehlgeschlagener Versand wird protokolliert,
+// nicht stillschweigend verworfen).
+func (c *Client) Enqueue(ctx context.Context, tenantSlug, userID, eventType, channel, recipient string, payload map[string]any) (EnqueueResult, error) {
+	body, err := json.Marshal(enqueueRequest{
+		TenantSlug: tenantSlug, UserID: userID, EventType: eventType, Channel: channel, Recipient: recipient, Payload: payload,
+	})
+	if err != nil {
+		return EnqueueResult{}, fmt.Errorf("notifyclient: request kodieren: %w", err)
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/notify/enqueue", bytes.NewReader(body))
+	if err != nil {
+		return EnqueueResult{}, fmt.Errorf("notifyclient: request bauen: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Service-Token", c.ServiceToken)
+
+	resp, err := c.httpClient().Do(req)
+	if err != nil {
+		return EnqueueResult{}, fmt.Errorf("notifyclient: aufruf fehlgeschlagen: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return EnqueueResult{}, fmt.Errorf("notifyclient: unerwarteter status %d", resp.StatusCode)
+	}
+	var out struct {
+		JobID   string `json:"job_id"`
+		Skipped bool   `json:"skipped"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		return EnqueueResult{}, fmt.Errorf("notifyclient: antwort dekodieren: %w", err)
+	}
+	return EnqueueResult{JobID: out.JobID, Skipped: out.Skipped}, nil
+}
+
+func (c *Client) httpClient() *http.Client {
+	if c.HTTPClient != nil {
+		return c.HTTPClient
+	}
+	return http.DefaultClient
+}

archive/internal/retentionapi/cors.go

@@ -0,0 +1,27 @@
+package retentionapi
+
+import "net/http"
+
+// CORS ist RET-10: retention-api hatte bislang keine CORS-Header, ein
+// echter Browser blockierte daher Fetches vom RET-06-Frontend (anderer
+// Origin/Port) — real per Sichtprüfung gefunden, nicht durch die
+// ursprünglichen RET-06/RET-06-API-Prüfungen erfasst (curl/Vitest-Fetch
+// erzwingen keine Same-Origin-Policy). Erlaubt GENAU EINEN konfigurierten
+// Origin, kein Wildcard — verhindert, dass jede beliebige Website die
+// Fristenkonfiguration im Namen eines eingeloggten Nutzers aufrufen kann.
+func CORS(allowedOrigin string, next http.Handler) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		origin := r.Header.Get("Origin")
+		if origin != "" && origin == allowedOrigin {
+			w.Header().Set("Access-Control-Allow-Origin", allowedOrigin)
+			w.Header().Set("Vary", "Origin")
+			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, X-User-Role")
+		}
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	}
+}

archive/internal/retentionapi/cors_test.go

@@ -0,0 +1,86 @@
+package retentionapi
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+const testAllowedOrigin = "http://localhost:3099"
+
+func noopHandler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+}
+
+// TestCORS_AllowedOriginGetsAccessControlHeader ist die geforderte
+// Pflichtprüfung: ein echter Browser-Fetch (simuliert über den Origin-
+// Header, den nur ein Browser automatisch setzt) erhält die nötigen
+// CORS-Header, die Same-Origin-Policy blockiert den Zugriff nicht mehr.
+func TestCORS_AllowedOriginGetsAccessControlHeader(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("Origin", testAllowedOrigin)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != testAllowedOrigin {
+		t.Fatalf("Access-Control-Allow-Origin = %q, want %q", got, testAllowedOrigin)
+	}
+}
+
+// TestCORS_PreflightRequestForPostEndpoint ist die geforderte
+// Pflichtprüfung: OPTIONS-Preflight liefert korrekte CORS-Header für
+// POST /retention-classes.
+func TestCORS_PreflightRequestForPostEndpoint(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodOptions, server.URL+"/retention-classes", nil)
+	req.Header.Set("Origin", testAllowedOrigin)
+	req.Header.Set("Access-Control-Request-Method", "POST")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("options: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusNoContent {
+		t.Fatalf("preflight status = %d, want 204", resp.StatusCode)
+	}
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != testAllowedOrigin {
+		t.Fatalf("Access-Control-Allow-Origin = %q, want %q", got, testAllowedOrigin)
+	}
+	if got := resp.Header.Get("Access-Control-Allow-Methods"); got == "" {
+		t.Fatal("Access-Control-Allow-Methods fehlt in der preflight-antwort")
+	}
+}
+
+// TestCORS_UnconfiguredOriginGetsNoAccessControlHeader ist die geforderte
+// Pflichtprüfung: Fetch von einem NICHT konfigurierten Origin bleibt
+// blockiert — kein Wildcard-Leck.
+func TestCORS_UnconfiguredOriginGetsNoAccessControlHeader(t *testing.T) {
+	handler := CORS(testAllowedOrigin, noopHandler())
+	server := httptest.NewServer(handler)
+	defer server.Close()
+
+	req, _ := http.NewRequest(http.MethodGet, server.URL, nil)
+	req.Header.Set("Origin", "http://boesartige-seite.example")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if got := resp.Header.Get("Access-Control-Allow-Origin"); got != "" {
+		t.Fatalf("Access-Control-Allow-Origin haette bei fremdem origin leer sein muessen, war %q", got)
+	}
+}

archive/internal/retentionnotify/retentionnotify.go

@@ -0,0 +1,158 @@
+// Package retentionnotify implementiert RET-07: Benachrichtigung einer
+// konfigurierten zuständigen Rolle (Tenant-Admin — RET-01 führt bewusst
+// keine Objekt-Owner-Beziehung) vor Ablauf einer Aufbewahrungsfrist,
+// konfigurierbarer Vorlauf je Aufbewahrungsklasse. Erzeugt NUR das
+// Ereignis über Core CFG-05 (archive/internal/notifyclient) — versendet
+// selbst keine E-Mail.
+package retentionnotify
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/notifyclient"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retentionengine"
+)
+
+// EventType ist der an CFG-05 übergebene Ereignistyp — muss mit dem im
+// Frontend/Core bekannten Namen übereinstimmen (siehe CFG-05-Tests).
+const EventType = "retention_due_soon"
+
+// Recipient benennt Tenant-Slug, User-ID und E-Mail-Adresse der
+// konfigurierten zuständigen Rolle (Tenant-Admin), an die alle
+// Fristablauf-Benachrichtigungen dieses Tenants gehen.
+type Recipient struct {
+	TenantSlug string
+	UserID     string
+	Email      string
+}
+
+// Result ist das Ergebnis EINES benachrichtigten (oder fehlgeschlagenen)
+// Objekts — der Aufrufer (cmd/retention-notify-job) protokolliert Err
+// explizit, kein stillschweigendes Verwerfen (Pflichtprüfung 3).
+type Result struct {
+	RetentionObjectID string
+	RetentionClass    string
+	JobID             string
+	Skipped           bool
+	Err               error
+}
+
+type classRuleLead struct {
+	leadDays int
+	enabled  bool
+}
+
+// Run führt EINEN Durchlauf des Benachrichtigungs-Jobs aus: ermittelt je
+// aktiver, benachrichtigungs-aktivierter Aufbewahrungsklasse die Objekte,
+// deren Stichtag innerhalb des konfigurierten Vorlaufs liegt, überspringt
+// bereits benachrichtigte Objekte (Akzeptanzkriterium 2, Postgres-
+// persistent — übersteht einen Job-Neustart) und löst für den Rest je ein
+// Ereignis über CFG-05 aus.
+func Run(ctx context.Context, pool *pgxpool.Pool, client *notifyclient.Client, now time.Time, recipient Recipient) ([]Result, error) {
+	// notify_lead_days/notify_enabled sind nicht Teil von
+	// retentionengine.ClassRule (RET-02/RET-06 kennen sie nicht) — direkt
+	// gelesen, um retentionengine nicht um RET-07-eigene Felder zu
+	// erweitern (kein Umbau angrenzender Bereiche).
+	leadByClass := make(map[string]classRuleLead)
+	maxLeadDays := 0
+	leadRows, err := pool.Query(ctx, `SELECT retention_class, notify_lead_days, notify_enabled FROM retention_class_rules WHERE active`)
+	if err != nil {
+		return nil, fmt.Errorf("retentionnotify: benachrichtigungs-konfiguration laden: %w", err)
+	}
+	for leadRows.Next() {
+		var class string
+		var lead classRuleLead
+		if err := leadRows.Scan(&class, &lead.leadDays, &lead.enabled); err != nil {
+			leadRows.Close()
+			return nil, fmt.Errorf("retentionnotify: konfigurationszeile lesen: %w", err)
+		}
+		leadByClass[class] = lead
+		if lead.leadDays > maxLeadDays {
+			maxLeadDays = lead.leadDays
+		}
+	}
+	if err := leadRows.Err(); err != nil {
+		return nil, fmt.Errorf("retentionnotify: benachrichtigungs-konfiguration lesen: %w", err)
+	}
+	leadRows.Close()
+
+	if maxLeadDays == 0 {
+		return nil, nil
+	}
+
+	// Nutzt DIESELBE Funktion wie der RET-02-Job/RET-06-API-Preview
+	// (kein zweiter Ermittlungspfad) — asOf auf den größten konfigurierten
+	// Vorlauf gesetzt, je Klasse wird unten mit deren EIGENEM Vorlauf
+	// gefiltert.
+	candidates, err := retentionengine.ListExpiringObjects(ctx, pool, now.AddDate(0, 0, maxLeadDays))
+	if err != nil {
+		return nil, fmt.Errorf("retentionnotify: ablaufende objekte ermitteln: %w", err)
+	}
+
+	alreadyNotified, err := loadAlreadyNotified(ctx, pool)
+	if err != nil {
+		return nil, err
+	}
+
+	var results []Result
+	for _, obj := range candidates {
+		lead, known := leadByClass[obj.RetentionClass]
+		if !known || !lead.enabled {
+			continue
+		}
+		if !obj.DueDate.Before(now.AddDate(0, 0, lead.leadDays+1)) {
+			// Ausserhalb des klassen-eigenen Vorlaufs (nur mit dem
+			// globalen maxLeadDays vorselektiert).
+			continue
+		}
+		if alreadyNotified[obj.RetentionObjectID] {
+			continue
+		}
+
+		res := Result{RetentionObjectID: obj.RetentionObjectID, RetentionClass: obj.RetentionClass}
+		enq, err := client.Enqueue(ctx, recipient.TenantSlug, recipient.UserID, EventType, "email", recipient.Email, map[string]any{
+			"object_type":      obj.ObjectType,
+			"object_reference": obj.ObjectReference,
+			"retention_class":  obj.RetentionClass,
+			"due_date":         obj.DueDate.Format(time.RFC3339),
+		})
+		if err != nil {
+			res.Err = err
+			results = append(results, res)
+			// Kein INSERT in retention_notifications bei Fehler — das
+			// Objekt wird beim naechsten Durchlauf erneut versucht,
+			// statt stillschweigend als erledigt zu gelten.
+			continue
+		}
+		res.JobID = enq.JobID
+		res.Skipped = enq.Skipped
+
+		if _, err := pool.Exec(ctx, `INSERT INTO retention_notifications (retention_object_id) VALUES ($1)`, obj.RetentionObjectID); err != nil {
+			res.Err = fmt.Errorf("retentionnotify: benachrichtigung als versendet markieren: %w", err)
+		}
+		results = append(results, res)
+	}
+	return results, nil
+}
+
+func loadAlreadyNotified(ctx context.Context, pool *pgxpool.Pool) (map[string]bool, error) {
+	rows, err := pool.Query(ctx, `SELECT retention_object_id FROM retention_notifications`)
+	if err != nil {
+		return nil, fmt.Errorf("retentionnotify: bereits benachrichtigte objekte laden: %w", err)
+	}
+	defer rows.Close()
+
+	out := make(map[string]bool)
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, fmt.Errorf("retentionnotify: zeile lesen: %w", err)
+		}
+		out[id] = true
+	}
+	return out, rows.Err()
+}

archive/internal/retentionnotify/retentionnotify_test.go

@@ -0,0 +1,223 @@
+package retentionnotify
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/notifyclient"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retentionengine"
+)
+
+func requireTestPool(t *testing.T) *pgxpool.Pool {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	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 EXTENSION IF NOT EXISTS pgcrypto;
+		CREATE TABLE IF NOT EXISTS retention_objects (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), object_type TEXT NOT NULL,
+			object_reference TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'expired', 'deleted')),
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			UNIQUE (object_type, object_reference)
+		);
+		CREATE TABLE IF NOT EXISTS retention_class_assignments (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+			retention_class TEXT NOT NULL, assigned_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS retention_class_rules (
+			retention_class TEXT PRIMARY KEY, duration INTERVAL NOT NULL,
+			active BOOLEAN NOT NULL DEFAULT true
+		);
+		ALTER TABLE retention_class_rules ADD COLUMN IF NOT EXISTS notify_lead_days INT NOT NULL DEFAULT 7;
+		ALTER TABLE retention_class_rules ADD COLUMN IF NOT EXISTS notify_enabled BOOLEAN NOT NULL DEFAULT true;
+		CREATE TABLE IF NOT EXISTS retention_notifications (
+			retention_object_id UUID PRIMARY KEY REFERENCES retention_objects(id) ON DELETE CASCADE,
+			notified_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE retention_notifications, retention_class_assignments, retention_objects CASCADE; TRUNCATE retention_class_rules`)
+	})
+	return pool
+}
+
+// fakeCFG05Server zaehlt Aufrufe und liefert eine feste Antwort - simuliert
+// den echten CFG-05-Endpunkt, ohne das Core-Modul einzubinden (Archive kann
+// es nicht direkt importieren, siehe notifyclient).
+func fakeCFG05Server(t *testing.T, fail bool) (*notifyclient.Client, *int32) {
+	t.Helper()
+	var calls int32
+	mux := http.NewServeMux()
+	mux.HandleFunc("POST /notify/enqueue", func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt32(&calls, 1)
+		if fail {
+			http.Error(w, "simulierter zustellfehler", http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{"job_id": "fake-job-id", "skipped": false})
+	})
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+	return notifyclient.New(server.URL, "test-token"), &calls
+}
+
+// insertDueObject legt ein Objekt an, dessen Stichtag (assigned_at +
+// Klassen-Frist) genau dueIn ab jetzt liegt — die Subtraktion der Frist
+// erfolgt IN Postgres (dieselbe INTERVAL-Arithmetik wie ComputeDueDate),
+// keine eigene Kalenderrechnung in Go.
+func insertDueObject(t *testing.T, ctx context.Context, pool *pgxpool.Pool, objectRef, class string, dueIn time.Duration) string {
+	t.Helper()
+	var objID string
+	if err := pool.QueryRow(ctx, `INSERT INTO retention_objects (object_type, object_reference) VALUES ('dms_document', $1) RETURNING id`, objectRef).Scan(&objID); err != nil {
+		t.Fatalf("objekt anlegen: %v", err)
+	}
+	desiredDue := time.Now().UTC().Add(dueIn)
+	if _, err := pool.Exec(ctx, `
+		INSERT INTO retention_class_assignments (retention_object_id, retention_class, assigned_at)
+		SELECT $1, $2, $3::timestamptz - r.duration FROM retention_class_rules r WHERE r.retention_class = $2
+	`, objID, class, desiredDue); err != nil {
+		t.Fatalf("zuordnung anlegen: %v", err)
+	}
+	return objID
+}
+
+var testRecipient = Recipient{TenantSlug: "acme", UserID: "tenant-admin", Email: "admin@acme.example"}
+
+// TestRun_ShortLeadTimeTriggersExactlyOneNotification ist die geforderte
+// Pflichtpruefung 1.
+func TestRun_ShortLeadTimeTriggersExactlyOneNotification(t *testing.T) {
+	pool := requireTestPool(t)
+	ctx := context.Background()
+
+	if err := retentionengine.ConfigureClassRule(ctx, pool, "klasse-kurz", "1 day"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `UPDATE retention_class_rules SET notify_lead_days = 1, notify_enabled = true WHERE retention_class = 'klasse-kurz'`); err != nil {
+		t.Fatal(err)
+	}
+	insertDueObject(t, ctx, pool, "kurz-doc", "klasse-kurz", 12*time.Hour)
+
+	client, calls := fakeCFG05Server(t, false)
+	results, err := Run(ctx, pool, client, time.Now().UTC(), testRecipient)
+	if err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if len(results) != 1 || results[0].Err != nil {
+		t.Fatalf("erwartet genau ein ergebnis ohne fehler, habe: %+v", results)
+	}
+	if atomic.LoadInt32(calls) != 1 {
+		t.Fatalf("erwartet genau einen cfg-05-aufruf, habe %d", *calls)
+	}
+}
+
+// TestRun_DisabledNotificationSendsNothing ist die geforderte
+// Pflichtpruefung 2.
+func TestRun_DisabledNotificationSendsNothing(t *testing.T) {
+	pool := requireTestPool(t)
+	ctx := context.Background()
+
+	if err := retentionengine.ConfigureClassRule(ctx, pool, "klasse-deaktiviert", "1 day"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `UPDATE retention_class_rules SET notify_lead_days = 1, notify_enabled = false WHERE retention_class = 'klasse-deaktiviert'`); err != nil {
+		t.Fatal(err)
+	}
+	insertDueObject(t, ctx, pool, "deaktiviert-doc", "klasse-deaktiviert", 12*time.Hour)
+
+	client, calls := fakeCFG05Server(t, false)
+	results, err := Run(ctx, pool, client, time.Now().UTC(), testRecipient)
+	if err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if len(results) != 0 {
+		t.Fatalf("erwartet keine benachrichtigung bei deaktivierter klasse, habe: %+v", results)
+	}
+	if atomic.LoadInt32(calls) != 0 {
+		t.Fatalf("erwartet keinen cfg-05-aufruf, habe %d", *calls)
+	}
+}
+
+// TestRun_FailedDeliveryIsReportedNotSwallowed ist die geforderte
+// Pflichtpruefung 3.
+func TestRun_FailedDeliveryIsReportedNotSwallowed(t *testing.T) {
+	pool := requireTestPool(t)
+	ctx := context.Background()
+
+	if err := retentionengine.ConfigureClassRule(ctx, pool, "klasse-fehler", "1 day"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `UPDATE retention_class_rules SET notify_lead_days = 1, notify_enabled = true WHERE retention_class = 'klasse-fehler'`); err != nil {
+		t.Fatal(err)
+	}
+	objID := insertDueObject(t, ctx, pool, "fehler-doc", "klasse-fehler", 12*time.Hour)
+
+	client, _ := fakeCFG05Server(t, true)
+	results, err := Run(ctx, pool, client, time.Now().UTC(), testRecipient)
+	if err != nil {
+		t.Fatalf("run: %v", err)
+	}
+	if len(results) != 1 || results[0].Err == nil {
+		t.Fatalf("erwartet ein ergebnis MIT protokolliertem fehler, habe: %+v", results)
+	}
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM retention_notifications WHERE retention_object_id = $1`, objID).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 0 {
+		t.Fatalf("fehlgeschlagener versand darf NICHT als benachrichtigt markiert werden (sonst kein retry)")
+	}
+}
+
+// TestRun_PreventsDoubleNotificationAcrossRuns ist Akzeptanzkriterium 2 -
+// Mehrfachversand wird verhindert, auch nach einem simulierten Neustart
+// (zweiter Run() mit frischem Aufruf, kein In-Memory-Zustand zwischen den
+// Durchlaeufen).
+func TestRun_PreventsDoubleNotificationAcrossRuns(t *testing.T) {
+	pool := requireTestPool(t)
+	ctx := context.Background()
+
+	if err := retentionengine.ConfigureClassRule(ctx, pool, "klasse-doppelt", "1 day"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `UPDATE retention_class_rules SET notify_lead_days = 1, notify_enabled = true WHERE retention_class = 'klasse-doppelt'`); err != nil {
+		t.Fatal(err)
+	}
+	insertDueObject(t, ctx, pool, "doppelt-doc", "klasse-doppelt", 12*time.Hour)
+
+	client, calls := fakeCFG05Server(t, false)
+	now := time.Now().UTC()
+
+	if _, err := Run(ctx, pool, client, now, testRecipient); err != nil {
+		t.Fatalf("erster run: %v", err)
+	}
+	if _, err := Run(ctx, pool, client, now, testRecipient); err != nil {
+		t.Fatalf("zweiter run (simulierter neustart): %v", err)
+	}
+
+	if atomic.LoadInt32(calls) != 1 {
+		t.Fatalf("erwartet genau einen cfg-05-aufruf ueber beide durchlaeufe, habe %d", *calls)
+	}
+}

archive/internal/wormstore/wormstore.go

@@ -0,0 +1,147 @@
+// Package wormstore implementiert RET-04: einen Speicherpfad für
+// archivierte Objektinhalte, der nach dem Schreiben weder überschrieben
+// noch (über dieses Paket) gelöscht werden kann — Write Once, Read Many.
+//
+// Löschung: dieses Paket bietet BEWUSST KEINE Delete-Funktion — das ist
+// die technische Grenze, die Go-Anwendungscode überhaupt durchsetzen
+// kann. Direkter Zugriff auf das Dateisystem durch einen Prozess mit
+// root-Rechten bleibt außerhalb der Kontrolle jeder Anwendung; das ist
+// ein struktureller Schutz auf Anwendungsebene, kein absoluter Schutz
+// gegen root-OS-Zugriff (siehe RET-04-Prüfprotokoll). Der kontrollierte
+// Löschworkflow (RET-03, eigenes Ticket) bekommt bei Bedarf einen
+// separaten, explizit privilegierten Zugriffspfad — NICHT Teil dieses
+// Pakets.
+package wormstore
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ErrAlreadyExists wird geliefert, wenn unter demselben Schlüssel bereits
+// ein Objekt geschrieben wurde (Akzeptanzkriterium 1: kein Überschreiben).
+var ErrAlreadyExists = errors.New("wormstore: objekt existiert bereits, überschreiben nicht erlaubt")
+
+// ErrNotFound wird geliefert, wenn ein angefragtes Objekt nicht existiert.
+var ErrNotFound = errors.New("wormstore: objekt nicht gefunden")
+
+// ErrChecksumMismatch wird von GetVerified geliefert, wenn der beim Lesen
+// berechnete Hash nicht mit dem beim Schreiben gespeicherten übereinstimmt
+// (Akzeptanzkriterium 3: manipulierter Inhalt wird erkannt).
+var ErrChecksumMismatch = errors.New("wormstore: prüfsumme stimmt nicht überein — inhalt wurde verändert")
+
+// Store ist der WORM-Speicher: Dateien im lokalen Dateisystem, Metadaten
+// (Prüfsumme, Größe) in Postgres — beide append-only.
+type Store struct {
+	baseDir string
+	pool    *pgxpool.Pool
+}
+
+func New(baseDir string, pool *pgxpool.Pool) *Store {
+	return &Store{baseDir: baseDir, pool: pool}
+}
+
+func (s *Store) path(key string) string {
+	return filepath.Join(s.baseDir, filepath.FromSlash(key))
+}
+
+// Put schreibt r EINMALIG unter key. Existiert key bereits (Datei ODER
+// DB-Zeile), wird ErrAlreadyExists geliefert — kein Überschreiben, auch
+// nicht bei gleichem Inhalt. Nach erfolgreichem Schreiben wird die Datei
+// read-only gesetzt (0400): ein direkter os.OpenFile mit Schreibabsicht
+// schlägt danach mit "permission denied" fehl (Akzeptanzkriterium 1,
+// zusätzlich zur DB-seitigen Sperre über den PRIMARY KEY).
+func (s *Store) Put(ctx context.Context, key string, r io.Reader) (checksum string, size int64, err error) {
+	full := s.path(key)
+	if _, statErr := os.Stat(full); statErr == nil {
+		return "", 0, ErrAlreadyExists
+	} else if !os.IsNotExist(statErr) {
+		return "", 0, fmt.Errorf("wormstore: existenz prüfen: %w", statErr)
+	}
+
+	if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
+		return "", 0, fmt.Errorf("wormstore: verzeichnis anlegen: %w", err)
+	}
+
+	tmp := full + ".tmp"
+	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
+	if err != nil {
+		return "", 0, fmt.Errorf("wormstore: temporäre datei anlegen: %w", err)
+	}
+	hasher := sha256.New()
+	written, err := io.Copy(io.MultiWriter(f, hasher), r)
+	if err != nil {
+		_ = f.Close()
+		_ = os.Remove(tmp)
+		return "", 0, fmt.Errorf("wormstore: schreiben: %w", err)
+	}
+	if err := f.Close(); err != nil {
+		_ = os.Remove(tmp)
+		return "", 0, fmt.Errorf("wormstore: datei schließen: %w", err)
+	}
+
+	if err := os.Rename(tmp, full); err != nil {
+		_ = os.Remove(tmp)
+		return "", 0, fmt.Errorf("wormstore: atomar platzieren: %w", err)
+	}
+	// Read-only NACH dem Schließen — verhindert jedes weitere Schreiben
+	// (Akzeptanzkriterium 1), auch durch denselben Prozess.
+	if err := os.Chmod(full, 0o400); err != nil {
+		return "", 0, fmt.Errorf("wormstore: schreibschutz setzen: %w", err)
+	}
+
+	sum := hex.EncodeToString(hasher.Sum(nil))
+	tag, err := s.pool.Exec(ctx, `
+		INSERT INTO worm_objects (storage_key, checksum_sha256, size_bytes)
+		VALUES ($1, $2, $3)
+		ON CONFLICT (storage_key) DO NOTHING
+	`, key, sum, written)
+	if err != nil {
+		return "", 0, fmt.Errorf("wormstore: metadaten speichern: %w", err)
+	}
+	if tag.RowsAffected() == 0 {
+		// Datei wurde gerade erst neu geschrieben (s.o. Stat-Check), aber
+		// die Metadaten-Zeile existierte bereits — Wettlaufsituation
+		// zweier gleichzeitiger Put-Aufrufe. Kein Überschreiben zulassen.
+		return "", 0, ErrAlreadyExists
+	}
+
+	return sum, written, nil
+}
+
+// GetVerified liefert den Inhalt UND vergleicht bei JEDEM Lesezugriff die
+// Prüfsumme gegen die beim Schreiben gespeicherte (Akzeptanzkriterium 3).
+func (s *Store) GetVerified(ctx context.Context, key string) ([]byte, error) {
+	var expectedSum string
+	err := s.pool.QueryRow(ctx, `SELECT checksum_sha256 FROM worm_objects WHERE storage_key = $1`, key).Scan(&expectedSum)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("wormstore: metadaten lesen: %w", err)
+	}
+
+	data, err := os.ReadFile(s.path(key))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("wormstore: datei lesen: %w", err)
+	}
+
+	sum := sha256.Sum256(data)
+	actualSum := hex.EncodeToString(sum[:])
+	if actualSum != expectedSum {
+		return nil, ErrChecksumMismatch
+	}
+	return data, nil
+}

archive/internal/wormstore/wormstore_test.go

@@ -0,0 +1,137 @@
+package wormstore
+
+import (
+	"context"
+	"errors"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, *pgxpool.Pool) {
+	t.Helper()
+	dsn := os.Getenv("TEST_TENANT_DSN")
+	if dsn == "" {
+		t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	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 worm_objects (
+			storage_key TEXT PRIMARY KEY, checksum_sha256 TEXT NOT NULL,
+			size_bytes BIGINT NOT NULL, written_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `DELETE FROM worm_objects WHERE storage_key LIKE 'wormtest_%'`)
+	})
+
+	return New(t.TempDir(), pool), pool
+}
+
+// TestPut_DirectOverwriteAttemptIsRejected ist die geforderte
+// Pflichtprüfung 1: Objekt mit aktivem Schreibschutz widersteht einem
+// direkten Überschreibversuch — sowohl über die Store-API als auch
+// direkt am Dateisystem (echter Nachweis der Datei-Schreibsperre, nicht
+// nur der Anwendungslogik).
+func TestPut_DirectOverwriteAttemptIsRejected(t *testing.T) {
+	store, _ := setupTest(t)
+	ctx := context.Background()
+
+	sum1, size1, err := store.Put(ctx, "wormtest_a", strings.NewReader("erster inhalt"))
+	if err != nil {
+		t.Fatalf("erster put: %v", err)
+	}
+
+	// Überschreibversuch über die API.
+	_, _, err = store.Put(ctx, "wormtest_a", strings.NewReader("manipulierter inhalt"))
+	if !errors.Is(err, ErrAlreadyExists) {
+		t.Fatalf("erwartet ErrAlreadyExists beim zweiten put, habe: %v", err)
+	}
+
+	// Direkter Überschreibversuch am Dateisystem (umgeht die API) — muss
+	// an der echten OS-Schreibsperre (chmod 0400) scheitern. Nur
+	// aussagekräftig, wenn NICHT als root getestet wird: root umgeht
+	// Unix-Dateirechte grundsätzlich (DAC-Bypass), das ist kein Defekt
+	// dieses Pakets, sondern eine bekannte Grenze von chmod-basiertem
+	// Schutz (siehe Paket-Dokumentation "kein absoluter Schutz gegen
+	// root"). Auf 131 laufen Tests als root — dieser Teilnachweis wird
+	// dort bewusst übersprungen, die API-seitige Sperre (oben) bleibt
+	// die primäre, root-unabhängige Prüfung.
+	if os.Geteuid() != 0 {
+		full := store.path("wormtest_a")
+		f, openErr := os.OpenFile(full, os.O_WRONLY, 0)
+		if openErr == nil {
+			_ = f.Close()
+			t.Fatal("erwartet permission-fehler beim direkten öffnen zum schreiben, datei war schreibbar")
+		}
+		if !os.IsPermission(openErr) {
+			t.Fatalf("erwartet permission-fehler, habe: %v", openErr)
+		}
+	} else {
+		t.Log("laeuft als root: OS-Schreibsperren-Teilnachweis uebersprungen (root umgeht Unix-Dateirechte grundsaetzlich)")
+	}
+
+	// Ursprünglicher Inhalt unverändert.
+	data, err := store.GetVerified(ctx, "wormtest_a")
+	if err != nil {
+		t.Fatalf("getverified: %v", err)
+	}
+	if string(data) != "erster inhalt" {
+		t.Fatalf("inhalt wurde veraendert: %q", data)
+	}
+	if size1 != int64(len("erster inhalt")) || sum1 == "" {
+		t.Fatalf("unerwartete put-metadaten: sum=%q size=%d", sum1, size1)
+	}
+}
+
+// TestGetVerified_DetectsTamperedFile ist die geforderte Pflichtprüfung
+// 2: Prüfsummenabgleich erkennt eine manipulierte Testdatei zuverlässig.
+func TestGetVerified_DetectsTamperedFile(t *testing.T) {
+	store, _ := setupTest(t)
+	ctx := context.Background()
+
+	if _, _, err := store.Put(ctx, "wormtest_b", strings.NewReader("unveraenderter inhalt")); err != nil {
+		t.Fatalf("put: %v", err)
+	}
+
+	// Manipulation simulieren: Schreibschutz temporär aufheben (root/
+	// Betreiber-Zugriff außerhalb der API, genau der Fall, den die
+	// Prüfsumme abfangen soll) und den Inhalt verändern.
+	full := store.path("wormtest_b")
+	if err := os.Chmod(full, 0o600); err != nil {
+		t.Fatalf("chmod fuer testmanipulation: %v", err)
+	}
+	if err := os.WriteFile(full, []byte("MANIPULIERTER INHALT"), 0o600); err != nil {
+		t.Fatalf("testmanipulation schreiben: %v", err)
+	}
+
+	_, err := store.GetVerified(ctx, "wormtest_b")
+	if !errors.Is(err, ErrChecksumMismatch) {
+		t.Fatalf("erwartet ErrChecksumMismatch bei manipulierter datei, habe: %v", err)
+	}
+}
+
+// TestStore_HasNoDeleteMethod ist die geforderte Pflichtprüfung 3
+// (präzisiert): Löschung ist über die Go-API des Pakets technisch
+// unmöglich, weil KEINE Delete-Funktion existiert — strukturell per
+// Reflection nachgewiesen, kein bloßer Verzicht per Konvention/Kommentar.
+func TestStore_HasNoDeleteMethod(t *testing.T) {
+	storeType := reflect.TypeOf(&Store{})
+	for i := 0; i < storeType.NumMethod(); i++ {
+		name := storeType.Method(i).Name
+		if strings.Contains(strings.ToLower(name), "delete") || strings.Contains(strings.ToLower(name), "remove") {
+			t.Fatalf("wormstore.Store darf keine Lösch-Methode besitzen, gefunden: %s", name)
+		}
+	}
+}

archive/migrations/0006_retention_notify.down.sql

@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS retention_notifications;
+ALTER TABLE retention_class_rules DROP COLUMN IF EXISTS notify_lead_days;
+ALTER TABLE retention_class_rules DROP COLUMN IF EXISTS notify_enabled;

archive/migrations/0006_retention_notify.up.sql

@@ -0,0 +1,11 @@
+-- RET-07: Fristablauf-Benachrichtigungen. Zwei neue Spalten je
+-- Aufbewahrungsklasse (Vorlauf, Ein/Aus-Schalter — Akzeptanzkriterium 3)
+-- und eine Dedupe-Tabelle (Akzeptanzkriterium 2: kein Mehrfachversand,
+-- auch nicht nach Job-Neustart, da Postgres-persistent statt In-Memory).
+ALTER TABLE retention_class_rules ADD COLUMN IF NOT EXISTS notify_lead_days INT NOT NULL DEFAULT 7;
+ALTER TABLE retention_class_rules ADD COLUMN IF NOT EXISTS notify_enabled BOOLEAN NOT NULL DEFAULT true;
+
+CREATE TABLE IF NOT EXISTS retention_notifications (
+    retention_object_id UUID PRIMARY KEY REFERENCES retention_objects(id) ON DELETE CASCADE,
+    notified_at          TIMESTAMPTZ NOT NULL DEFAULT now()
+);

archive/migrations/0007_worm_objects.down.sql

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

archive/migrations/0007_worm_objects.up.sql

@@ -0,0 +1,10 @@
+-- RET-04: WORM-Speicher-Garantie. Append-only Metadatentabelle - kein
+-- UPDATE-Pfad im Code, PRIMARY KEY(storage_key) verhindert eine zweite
+-- Zeile fuer denselben Schluessel (Akzeptanzkriterium 1, zusaetzlich zur
+-- Dateisystem-Schreibsperre).
+CREATE TABLE IF NOT EXISTS worm_objects (
+    storage_key     TEXT PRIMARY KEY,
+    checksum_sha256 TEXT NOT NULL,
+    size_bytes      BIGINT NOT NULL,
+    written_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);

deploy/systemd/nexarch-archive-moduleadapter-api.service.tmpl

@@ -0,0 +1,14 @@
+[Unit]
+Description=NEXARCH Archive - Modul-Adapter-Registrierung (RET-05/RET-09)
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=nexarch
+EnvironmentFile=/etc/nexarch/archive-moduleadapter-api.env
+ExecStart=__INSTALL_DIR__/bin/moduleadapter-api
+Restart=on-failure
+StandardOutput=journal
+
+[Install]
+WantedBy=multi-user.target

deploy/systemd/nexarch-archive-retention-notify.service.tmpl

@@ -0,0 +1,10 @@
+[Unit]
+Description=NEXARCH Archive - Fristablauf-Benachrichtigungen (RET-07)
+After=network.target postgresql.service
+
+[Service]
+Type=oneshot
+User=nexarch
+EnvironmentFile=/etc/nexarch/archive-retention-notify.env
+ExecStart=__INSTALL_DIR__/bin/retention-notify-job
+StandardOutput=journal

deploy/systemd/nexarch-archive-retention-notify.timer.tmpl

@@ -0,0 +1,9 @@
+[Unit]
+Description=Zeitplan fuer NEXARCH Archive Fristablauf-Benachrichtigungen (RET-07)
+
+[Timer]
+OnCalendar=*-*-* 07:00:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target