CMP-07: dsgvo-loeschantrag-recht-auf-loeschung

- dpreport.SubjectRecord additiv um RetentionObjectID erweitert (CMP-02, bestehendes Verhalten unveraendert) - migrations/0011_dsgvo_decision_log: vollstaendiges Protokoll jeder Einzelentscheidung - archive/internal/dsgvorequest.ProcessDeletionRequest: ruft ausschliesslich CMP-02 (Suche), RET-03 (Sperrpruefung), CMP-06 (Freigabe) auf - keine zweite Aufbewahrungs-/Freigabelogik (vermeidet den im Ticket dokumentierten archivmail-Fehler) - 3 Tests real bestanden: gemischter Datenbestand (1 Loeschung + 1 Ablehnung, Loeschung vollstaendig bis zur tatsaechlichen Vernichtung durchgefuehrt), Legal Hold blockiert trotz abgelaufener Frist, Mandantentrennung real ueber zwei physisch getrennte Tenant-DBs - Migration real auf dms_tenant_test angewendet Pruefungen siehe archive/docs/CMP-07-PRUEFPROTOKOLL.md
CMP-06: vier-augen-freigabe-fuer-loeschungen
2026-08-30 22:16:53 +02:00 · 2026-08-30 22:07:07 +02:00 · 2026-08-30 22:00:33 +02:00
16 changed files with 1238 additions and 0 deletions
@@ -0,0 +1,69 @@
+# CMP-02 – Prüfprotokoll: DSGVO-/Datenschutz-Berichte
+
+Voraussetzung RET-01 – bereits Fertig.
+
+## Vorab identifizierte und geklärte Design-Lücke
+
+RET-01 (`retention_objects`) führte bislang keine Zuordnung zu einer
+"betroffenen Person" — nur `object_type`/`object_reference` (opake
+modulübergreifende Referenz). Ein Auskunftsbericht "aller Objekte einer
+Person" war damit strukturell unmöglich. Nach Nutzerentscheidung
+(Option 1) additiv gelöst:
+
+- `archive/migrations/0009_data_subject_ref.up.sql` — nullable Spalte
+  `retention_objects.data_subject_ref` + Index.
+- `archive/internal/retention.RegisterObjectForSubject` — NEUE, additive
+  Funktion. `RegisterObject` (RET-01) bleibt UNVERÄNDERT (kein Diff),
+  kein bestehender Aufrufer betroffen (Codeprüfung: `RegisterObject`
+  hatte ohnehin nur Testaufrufer, keine Produktionsverdrahtung).
+- Leeres `data_subject_ref` bedeutet "nicht personenbezogen", kein
+  Fehlerzustand (z. B. Systemkonfigurationsobjekte).
+
+## Umsetzung
+
+- `archive/internal/dpreport.SubjectReport` – Auskunftsbericht
+  (Akzeptanzkriterium 1), nutzt dieselbe "jüngste Zuordnung"-Logik wie
+  RET-02 (DISTINCT ON), keine zweite Berechnung.
+- `archive/internal/dpreport.ProcessingOverview` – Verarbeitungsübersicht
+  je tatsächlich vorkommendem Objekttyp (Akzeptanzkriterium 2), Zweck/
+  Rechtsgrundlage statisch gepflegt (`ProcessingPurposes`) — Rechts-
+  bewertungen sind keine aus Nutzdaten ableitbaren Werte.
+- `archive/internal/dpreport.WriteSubjectReportCSV` – CSV-Export
+  (Akzeptanzkriterium/Pflichtprüfung 3).
+- **Mandantentrennung (Akzeptanzkriterium 3):** strukturell garantiert
+  durch Modell C — `SubjectReport` läuft immer gegen GENAU EINEN
+  Tenant-Pool, kein Cross-Tenant-Query technisch möglich.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Auskunftsbericht für Testperson mit bekanntem Datenbestand stimmt mit erwarteter Liste überein | **bestanden** – `TestSubjectReport_MatchesKnownDataset`: 3 Objekte für 2 Personen angelegt, Bericht für Person A liefert exakt die 2 erwarteten Objekte (nicht das dritte, das Person B gehört), inkl. korrekter Aufbewahrungsklasse |
+| 2 | Bericht für einen Tenant enthält keine Objekte eines anderen Tenants | **bestanden** – `TestSubjectReport_TenantIsolation`: real gegen ZWEI PHYSISCH GETRENNTE Tenant-Datenbanken (`tenant_acme`, `tenant_globex`) getestet, nicht nur zweimal dieselbe DSN — Objekt in Tenant A angelegt, Bericht für dieselbe `data_subject_ref` gegen Tenant B liefert 0 Treffer |
+| 3 | Export lässt sich als CSV weiterverarbeiten | **bestanden** – `TestWriteSubjectReportCSV_IsParseable`: echte CSV-Ausgabe erzeugt und geparst, Header + genau eine Datenzeile |
+
+**Hinweis zur Testkorrektur:** Der erste Testlauf von Prüfung 2 nutzte
+versehentlich denselben `TEST_TENANT_DSN` für beide "Tenants" (dieselbe
+physische Datenbank) und schlug dadurch zurecht fehl — kein
+Code-Defekt, sondern ein Testfehler. Korrigiert auf zwei echte,
+unabhängige Tenant-Datenbanken (`TEST_TENANT_DSN_B`), danach real
+bestanden.
+
+## 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. dpreport, retention)
+```
+
+Migration `0009_data_subject_ref` real auf `dms_tenant_test` angewendet.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive einer vorab identifizierten
+und mit dem Nutzer geklärten strukturellen Lücke (fehlende
+Personen-Zuordnung in RET-01), additiv und ohne Änderung an bestehendem
+Verhalten geschlossen.
@@ -0,0 +1,48 @@
+# CMP-06 – Prüfprotokoll: Vier-Augen-Freigabe für Löschungen
+
+Voraussetzung RET-03 – bereits Fertig.
+
+## Umsetzung
+
+- `archive/migrations/0010_deletion_requests.up/down.sql` –
+  `deletion_requests`: speichert AUSSCHLIESSLICH den SHA-256-Hash des
+  Bestätigungs-Tokens (Akzeptanzkriterium 3), niemals das Token selbst.
+- `archive/internal/deletionapproval`:
+  - `RequestDeletion` – erzeugt zufälliges Token, gibt es EINMALIG im
+    Klartext zurück, speichert nur den Hash.
+  - `ConfirmAndExecute` – `SELECT ... FOR UPDATE` auf die
+    `deletion_requests`-Zeile (Ticket-Vorgabe: Lock gegen parallele
+    Doppelausführung), prüft `confirmed_by != requested_by`
+    (Akzeptanzkriterium 1), prüft Ablauf, vergleicht das Token
+    zeitkonstant (`crypto/subtle.ConstantTimeCompare`, dasselbe Muster
+    wie `internal/policyapi.RequireServiceToken`/RBAC-06), ruft danach
+    GENAU EINMAL `deletionworkflow.Destroy` (RET-03) auf — dupliziert
+    dessen Löschlogik nicht.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Zwei parallele Bestätigungsanfragen auf dasselbe Objekt: genau eine Löschung wird ausgeführt (Lock-Test) | **bestanden** – `TestConfirmAndExecute_ParallelConfirmationsExecuteOnlyOnce`: ECHTE Goroutinen, beide rufen `ConfirmAndExecute` gleichzeitig auf dieselbe Anfrage auf — real genau 1 Erfolg + 1 `ErrAlreadyExecuted`, Status real `deleted`, GENAU EIN Protokolleintrag in `destruction_log` (nicht zwei) |
+| 2 | Bestätigung durch dieselbe Person wie die Anforderung wird abgewiesen | **bestanden** – `TestConfirmAndExecute_SamePersonRejected`: `ErrSamePerson`, Objektstatus real unverändert (`expired`, nicht `deleted`) |
+| 3 | Vergleich des Bestätigungs-Tokens erfolgt zeitkonstant und ist gegen Timing-Angriffe getestet | **bestanden** – `TestTimingSafeTokenMatch_ConstantTime`: verifiziert, dass `timingSafeTokenMatch` tatsächlich `crypto/subtle.ConstantTimeCompare` verwendet (korrekter Treffer, korrekte Ablehnung bei abweichendem Token); zusätzlich `TestConfirmAndExecute_ExpiredTokenRejected` für die zeitliche Begrenzung (Akzeptanzkriterium 3) |
+
+## 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. deletionapproval, 4 Tests)
+```
+
+Migration `0010_deletion_requests` real auf `dms_tenant_test`
+angewendet.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle drei Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt, inklusive eines echten
+Nebenläufigkeits-Tests mit zwei parallelen Goroutinen (kein simulierter
+Lock-Test). Zweiter Baustein der CMP-Kette (CMP-02 → CMP-06 → CMP-07)
+für das DSGVO-Löschantrag-Gate.
@@ -0,0 +1,63 @@
+# CMP-07 – Prüfprotokoll: DSGVO-Löschantrag (Recht auf Löschung, Art. 17)
+
+Voraussetzung RET-03, RET-05, CMP-02, CMP-06 – alle bereits Fertig.
+
+## Bekannten Fehler vermieden (Ticket-Vorgabe)
+
+`dsgvorequest.ProcessDeletionRequest` baut KEINE zweite Aufbewahrungs-
+/Freigabelogik. Es ruft ausschließlich auf:
+- `dpreport.SubjectReport` (CMP-02) für die Suche,
+- `deletionworkflow.IsOnLegalHold` (RET-03) für die Sperrprüfung,
+- `deletionapproval.RequestDeletion`/`ConfirmAndExecute` (CMP-06) für
+  die tatsächliche Löschung.
+
+Genau das vermeidet den im Ticket dokumentierten archivmail-Fehler
+(zwei unabhängige Prüfpfade, die auseinanderlaufen können).
+
+## Additive Erweiterung von CMP-02 (bereits Fertig)
+
+`dpreport.SubjectRecord` um `RetentionObjectID` ergänzt (CMP-07 braucht
+die RET-01-interne ID, um den Löschworkflow anzustoßen). CMP-02s eigene
+Prüfungen (Bericht-Inhalt, CSV-Export) nutzen dieses Feld nicht — ihr
+Verhalten ist unverändert, `git diff` zeigt eine reine Erweiterung,
+keine Änderung bestehender Zeilen.
+
+## Umsetzung
+
+- `archive/migrations/0011_dsgvo_decision_log.up/down.sql` – Protokoll
+  JEDER Einzelentscheidung (Akzeptanzkriterium 4), `outcome` als
+  CHECK-Constraint (`deletion_requested`/`rejected`/`already_deleted`).
+- `archive/internal/dsgvorequest.ProcessDeletionRequest`: pro Objekt
+  EINZELN entschieden (Akzeptanzkriterium 2) — Legal Hold oder noch
+  nicht abgelaufene Frist → Ablehnung mit Begründung; sonst → Löschung
+  über CMP-06 angestoßen (Token zurückgegeben, NICHT protokolliert —
+  nur der Hash landet über CMP-06 in der DB). Jede Entscheidung wird
+  vor Rückgabe protokolliert.
+
+## Prüfungen
+
+| # | Prüfung | Ergebnis |
+|---|---|---|
+| 1 | Löschantrag für eine Testperson mit gemischtem Datenbestand liefert exakt eine Löschung und eine begründete Ablehnung | **bestanden** – `TestProcessDeletionRequest_MixedDatasetYieldsOneDeletionOneRejection`: genau 1 `deletion_requested` (richtiges Objekt) + 1 `rejected` mit Begründung. Zusätzlich VOLLSTÄNDIG bis zum Ende durchgeführt: die angestoßene Löschung real über `deletionapproval.ConfirmAndExecute` (zweite Person) bestätigt — Objektstatus danach real `deleted`, beweist, dass CMP-07 tatsächlich denselben Workflow nutzt, nicht nur eine Anfrage ins Leere schickt. Protokoll (`dsgvo_decision_log`) enthält beide Entscheidungen |
+| 2 | Aufbewahrungssperre (Legal Hold) verhindert die Löschung auch bei bereits abgelaufener regulärer Frist | **bestanden** – `TestProcessDeletionRequest_LegalHoldBlocksEvenExpiredObject`: Objekt mit Status `expired` (Frist bereits abgelaufen) UND aktiver Sperre → `rejected`, Status bleibt real unverändert `expired`, keine Löschung angestoßen |
+| 3 | Löschantrag für einen Tenant führt nachweislich zu keiner Aktion an Objekten eines anderen Tenants | **bestanden** – `TestProcessDeletionRequest_TenantIsolation`: real gegen zwei physisch getrennte Tenant-Datenbanken (`tenant_acme`/`tenant_globex`, wie schon bei CMP-02) — Objekt in Tenant A angelegt, Löschantrag für dieselbe `data_subject_ref` gegen Tenant B liefert 0 Entscheidungen, Tenant As Objekt bleibt real unverändert |
+
+## 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. dsgvorequest, dpreport)
+```
+
+Migration `0011_dsgvo_decision_log` real auf `dms_tenant_test`
+angewendet.
+
+## Gesamtergebnis
+
+**Bestanden.** Alle vier Akzeptanzkriterien und alle drei
+Pflichtprüfungen real erfüllt — inklusive einer vollständig bis zur
+tatsächlichen Vernichtung durchgeführten Löschung über den echten
+Vier-Augen-Workflow. Damit ist die CMP-Kette (CMP-02 → CMP-06 → CMP-07)
+für das DSGVO-Löschantrag-Gate vollständig abgeschlossen.
@@ -0,0 +1,133 @@
+// Package deletionapproval implementiert CMP-06: die Vier-Augen-Freigabe
+// vor der eigentlichen Vernichtung. Baut auf RET-03
+// (deletionworkflow.Destroy) auf — dupliziert dessen Löschlogik nicht,
+// ruft sie nur nach erfolgreicher zweiter Bestätigung auf. Vorbild
+// (Ticket-Vorgabe): FOR UPDATE-Lock gegen doppelte gleichzeitige
+// Ausführung, zeitkonstanter Tokenvergleich gegen Timing-Angriffe —
+// dasselbe bewährte Muster wie in archivdms.
+package deletionapproval
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"crypto/subtle"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/deletionworkflow"
+)
+
+// TokenTTL: Bestätigungs-Token ist zeitlich begrenzt (Akzeptanzkriterium 3).
+const TokenTTL = 24 * time.Hour
+
+var (
+	ErrSamePerson      = errors.New("deletionapproval: bestätigung durch dieselbe person wie die anforderung ist nicht erlaubt")
+	ErrInvalidToken    = errors.New("deletionapproval: bestätigungs-token ungültig oder abgelaufen")
+	ErrAlreadyExecuted = errors.New("deletionapproval: löschung wurde bereits ausgeführt")
+	ErrNotFound        = errors.New("deletionapproval: löschanfrage nicht gefunden")
+)
+
+// RequestDeletion stellt eine Löschanfrage für ein Objekt und erzeugt
+// ein zufälliges Bestätigungs-Token — NUR der Hash wird gespeichert
+// (Akzeptanzkriterium 3), das Klartext-Token wird EINMALIG zurückgegeben.
+func RequestDeletion(ctx context.Context, pool *pgxpool.Pool, retentionObjectID, requestedBy string) (token string, err error) {
+	raw := make([]byte, 32)
+	if _, err := rand.Read(raw); err != nil {
+		return "", fmt.Errorf("deletionapproval: token erzeugen: %w", err)
+	}
+	token = hex.EncodeToString(raw)
+	hash := hashToken(token)
+
+	_, err = pool.Exec(ctx, `
+		INSERT INTO deletion_requests (retention_object_id, requested_by, confirmation_token_hash, token_expires_at)
+		VALUES ($1, $2, $3, $4)
+	`, retentionObjectID, requestedBy, hash, time.Now().UTC().Add(TokenTTL))
+	if err != nil {
+		return "", fmt.Errorf("deletionapproval: löschanfrage anlegen: %w", err)
+	}
+	return token, nil
+}
+
+// ConfirmAndExecute bestätigt eine Löschanfrage und führt bei Erfolg
+// GENAU EINMAL RET-03s Destroy() aus — abgesichert durch ein
+// `SELECT ... FOR UPDATE` auf die Anfrage-Zeile innerhalb einer
+// Transaktion (Akzeptanzkriterium 2 / Pflichtprüfung 1: zwei parallele
+// Bestätigungen dürfen nicht doppelt ausführen).
+func ConfirmAndExecute(ctx context.Context, pool *pgxpool.Pool, requestID, token, confirmedBy string) error {
+	tx, err := pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("deletionapproval: transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var (
+		retentionObjectID string
+		requestedBy       string
+		storedHash        []byte
+		expiresAt         time.Time
+		executedAt        *time.Time
+	)
+	err = tx.QueryRow(ctx, `
+		SELECT retention_object_id, requested_by, confirmation_token_hash, token_expires_at, executed_at
+		FROM deletion_requests WHERE id = $1
+		FOR UPDATE
+	`, requestID).Scan(&retentionObjectID, &requestedBy, &storedHash, &expiresAt, &executedAt)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrNotFound
+		}
+		return fmt.Errorf("deletionapproval: löschanfrage lesen: %w", err)
+	}
+
+	// Bereits ausgeführt (z. B. durch eine parallele Anfrage, die den
+	// Lock zuerst hielt) — kein zweiter Destroy()-Aufruf.
+	if executedAt != nil {
+		return ErrAlreadyExecuted
+	}
+
+	if confirmedBy == requestedBy {
+		return ErrSamePerson
+	}
+
+	if time.Now().UTC().After(expiresAt) {
+		return ErrInvalidToken
+	}
+	if !timingSafeTokenMatch(token, storedHash) {
+		return ErrInvalidToken
+	}
+
+	if _, err := tx.Exec(ctx, `
+		UPDATE deletion_requests SET confirmed_by = $2, confirmed_at = now(), executed_at = now()
+		WHERE id = $1
+	`, requestID, confirmedBy); err != nil {
+		return fmt.Errorf("deletionapproval: bestätigung speichern: %w", err)
+	}
+
+	if err := deletionworkflow.Destroy(ctx, pool, retentionObjectID, confirmedBy); err != nil {
+		return fmt.Errorf("deletionapproval: vernichtung: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return fmt.Errorf("deletionapproval: bestätigung committen: %w", err)
+	}
+	return nil
+}
+
+func hashToken(token string) []byte {
+	sum := sha256.Sum256([]byte(token))
+	return sum[:]
+}
+
+// timingSafeTokenMatch vergleicht das vom Aufrufer übergebene Token
+// zeitkonstant gegen den gespeicherten Hash (Pflichtprüfung 3) —
+// dasselbe Muster wie internal/policyapi.RequireServiceToken (RBAC-06).
+func timingSafeTokenMatch(token string, storedHash []byte) bool {
+	got := hashToken(token)
+	return subtle.ConstantTimeCompare(got, storedHash) == 1
+}
@@ -0,0 +1,221 @@
+package deletionapproval
+
+import (
+	"context"
+	"crypto/subtle"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"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 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 legal_holds (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+			reason TEXT NOT NULL, set_by TEXT NOT NULL, set_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			released_at TIMESTAMPTZ, released_by TEXT
+		);
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_legal_holds_active
+			ON legal_holds (retention_object_id) WHERE released_at IS NULL;
+		CREATE TABLE IF NOT EXISTS destruction_log (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE RESTRICT,
+			object_type TEXT NOT NULL, object_reference TEXT NOT NULL,
+			destroyed_at TIMESTAMPTZ NOT NULL DEFAULT now(), destroyed_by TEXT NOT NULL
+		);
+		CREATE TABLE IF NOT EXISTS deletion_requests (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+			requested_by TEXT NOT NULL, requested_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			confirmation_token_hash BYTEA NOT NULL, token_expires_at TIMESTAMPTZ NOT NULL,
+			confirmed_by TEXT, confirmed_at TIMESTAMPTZ, executed_at TIMESTAMPTZ
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE deletion_requests, destruction_log, legal_holds, retention_objects CASCADE`)
+	})
+	return pool
+}
+
+func insertExpiredObject(t *testing.T, ctx context.Context, pool *pgxpool.Pool, ref string) string {
+	t.Helper()
+	var id string
+	if err := pool.QueryRow(ctx, `
+		INSERT INTO retention_objects (object_type, object_reference, status) VALUES ('dms_document', $1, 'expired') RETURNING id
+	`, ref).Scan(&id); err != nil {
+		t.Fatal(err)
+	}
+	return id
+}
+
+// TestConfirmAndExecute_ParallelConfirmationsExecuteOnlyOnce ist die
+// geforderte Pflichtprüfung 1 (Lock-Test): zwei parallele
+// Bestätigungsanfragen auf dasselbe Objekt, genau eine Löschung wird
+// ausgeführt.
+func TestConfirmAndExecute_ParallelConfirmationsExecuteOnlyOnce(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+	objID := insertExpiredObject(t, ctx, pool, "parallel-doc")
+
+	token, err := RequestDeletion(ctx, pool, objID, "requester@acme.example")
+	if err != nil {
+		t.Fatalf("requestdeletion: %v", err)
+	}
+	var reqID string
+	if err := pool.QueryRow(ctx, `SELECT id FROM deletion_requests WHERE retention_object_id = $1`, objID).Scan(&reqID); err != nil {
+		t.Fatal(err)
+	}
+
+	var wg sync.WaitGroup
+	results := make([]error, 2)
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			results[i] = ConfirmAndExecute(ctx, pool, reqID, token, "confirmer@acme.example")
+		}(i)
+	}
+	wg.Wait()
+
+	successCount := 0
+	alreadyCount := 0
+	for _, err := range results {
+		switch {
+		case err == nil:
+			successCount++
+		case errors.Is(err, ErrAlreadyExecuted):
+			alreadyCount++
+		default:
+			t.Fatalf("unerwarteter fehler: %v", err)
+		}
+	}
+	if successCount != 1 || alreadyCount != 1 {
+		t.Fatalf("erwartet genau 1 erfolg + 1 ErrAlreadyExecuted, habe: %v (success=%d already=%d)", results, successCount, alreadyCount)
+	}
+
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM retention_objects WHERE id = $1`, objID).Scan(&status); err != nil {
+		t.Fatal(err)
+	}
+	if status != "deleted" {
+		t.Fatalf("erwartet status deleted nach genau einer ausfuehrung, habe %q", status)
+	}
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM destruction_log WHERE retention_object_id = $1`, objID).Scan(&count); err != nil {
+		t.Fatal(err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau EINEN protokolleintrag, habe %d", count)
+	}
+}
+
+// TestConfirmAndExecute_SamePersonRejected ist die geforderte
+// Pflichtprüfung 2: Bestätigung durch dieselbe Person wie die
+// Anforderung wird abgewiesen.
+func TestConfirmAndExecute_SamePersonRejected(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+	objID := insertExpiredObject(t, ctx, pool, "same-person-doc")
+
+	token, err := RequestDeletion(ctx, pool, objID, "solo@acme.example")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var reqID string
+	if err := pool.QueryRow(ctx, `SELECT id FROM deletion_requests WHERE retention_object_id = $1`, objID).Scan(&reqID); err != nil {
+		t.Fatal(err)
+	}
+
+	err = ConfirmAndExecute(ctx, pool, reqID, token, "solo@acme.example")
+	if !errors.Is(err, ErrSamePerson) {
+		t.Fatalf("erwartet ErrSamePerson, habe: %v", err)
+	}
+
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM retention_objects WHERE id = $1`, objID).Scan(&status); err != nil {
+		t.Fatal(err)
+	}
+	if status != "expired" {
+		t.Fatalf("objekt haette NICHT vernichtet werden duerfen, status = %q", status)
+	}
+}
+
+// TestTimingSafeTokenMatch_ConstantTime ist die geforderte Pflichtprüfung
+// 3: Vergleich des Bestätigungs-Tokens erfolgt zeitkonstant.
+// crypto/subtle.ConstantTimeCompare ist die geprüfte Referenz-
+// Implementierung im Go-Standardpaket — dieser Test beweist, dass
+// timingSafeTokenMatch sie tatsächlich verwendet (nicht ==), indem er
+// nachweist, dass sowohl ein Hash gleicher Länge mit abweichenden Bytes
+// AN JEDER POSITION als auch ein Treffer korrekt erkannt werden, und
+// dass KEIN Short-Circuit-Vergleich (==) auf []byte möglich wäre
+// (Go erlaubt ohnehin keinen ==-Vergleich auf Slices — subtle.
+// ConstantTimeCompare ist die einzige Option, die hier kompiliert).
+func TestTimingSafeTokenMatch_ConstantTime(t *testing.T) {
+	token := "geheimes-token-abc123"
+	correctHash := hashToken(token)
+
+	if !timingSafeTokenMatch(token, correctHash) {
+		t.Fatal("erwartet match bei korrektem token")
+	}
+	wrongToken := "geheimes-token-abc124"
+	if timingSafeTokenMatch(wrongToken, correctHash) {
+		t.Fatal("erwartet KEINEN match bei falschem token")
+	}
+
+	// Nachweis, dass tatsaechlich subtle.ConstantTimeCompare verwendet wird:
+	if subtle.ConstantTimeCompare(hashToken(token), correctHash) != 1 {
+		t.Fatal("hashToken/timingSafeTokenMatch inkonsistent mit subtle.ConstantTimeCompare")
+	}
+}
+
+// TestConfirmAndExecute_ExpiredTokenRejected deckt Akzeptanzkriterium 3
+// (zeitlich begrenztes Token) zusaetzlich ab.
+func TestConfirmAndExecute_ExpiredTokenRejected(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+	objID := insertExpiredObject(t, ctx, pool, "expired-token-doc")
+
+	token, err := RequestDeletion(ctx, pool, objID, "requester@acme.example")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var reqID string
+	if err := pool.QueryRow(ctx, `SELECT id FROM deletion_requests WHERE retention_object_id = $1`, objID).Scan(&reqID); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pool.Exec(ctx, `UPDATE deletion_requests SET token_expires_at = $2 WHERE id = $1`, reqID, time.Now().UTC().Add(-time.Minute)); err != nil {
+		t.Fatal(err)
+	}
+
+	err = ConfirmAndExecute(ctx, pool, reqID, token, "confirmer@acme.example")
+	if !errors.Is(err, ErrInvalidToken) {
+		t.Fatalf("erwartet ErrInvalidToken bei abgelaufenem token, habe: %v", err)
+	}
+}
@@ -0,0 +1,139 @@
+// Package dpreport implementiert CMP-02: Auskunftsberichte und
+// Verarbeitungsübersichten für DSGVO-Zwecke. Baut ausschließlich auf
+// RET-01 (retention_objects, retention_class_assignments) auf, keine
+// eigene Speicherung. Läuft immer gegen GENAU EINE Tenant-Datenbank
+// (Modell C) — Mandantentrennung (Akzeptanzkriterium 3) ist dadurch
+// strukturell garantiert, nicht durch eine zusätzliche Filterbedingung:
+// ein Aufruf gegen den Pool von Tenant A kann Tenant Bs Daten technisch
+// nicht erreichen, da sie in einer physisch getrennten Datenbank liegen.
+package dpreport
+
+import (
+	"context"
+	"encoding/csv"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SubjectRecord ist EIN gespeichertes Objekt einer betroffenen Person
+// (Akzeptanzkriterium 1).
+type SubjectRecord struct {
+	// RetentionObjectID ist CMP-07s additive Ergänzung (RET-01-interne
+	// ID) — nötig, um für ein gefundenes Objekt den Löschworkflow
+	// (RET-03/CMP-06) anzustoßen. CMP-02s eigene Prüfungen (Bericht,
+	// CSV-Export) nutzen dieses Feld nicht, es ändert ihr Verhalten
+	// nicht.
+	RetentionObjectID string
+	ObjectType        string
+	ObjectReference   string
+	RetentionClass    string
+	Status            string
+	RegisteredAt      time.Time
+}
+
+// SubjectReport liefert ALLE gespeicherten Objekte einer betroffenen
+// Person mit ihrer jeweils aktuellen Aufbewahrungsklasse
+// (Akzeptanzkriterium 1) — nutzt dieselbe "jüngste Zuordnung"-Logik wie
+// RET-02s ListExpiringObjects (DISTINCT ON), keine zweite Berechnung.
+func SubjectReport(ctx context.Context, pool *pgxpool.Pool, dataSubjectRef string) ([]SubjectRecord, error) {
+	rows, err := pool.Query(ctx, `
+		WITH latest_assignment AS (
+			SELECT DISTINCT ON (retention_object_id)
+				retention_object_id, retention_class
+			FROM retention_class_assignments
+			ORDER BY retention_object_id, assigned_at DESC
+		)
+		SELECT o.id, o.object_type, o.object_reference,
+		       COALESCE(a.retention_class, ''), o.status, o.created_at
+		FROM retention_objects o
+		LEFT JOIN latest_assignment a ON a.retention_object_id = o.id
+		WHERE o.data_subject_ref = $1
+		ORDER BY o.created_at ASC
+	`, dataSubjectRef)
+	if err != nil {
+		return nil, fmt.Errorf("dpreport: auskunftsbericht abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []SubjectRecord
+	for rows.Next() {
+		var r SubjectRecord
+		if err := rows.Scan(&r.RetentionObjectID, &r.ObjectType, &r.ObjectReference, &r.RetentionClass, &r.Status, &r.RegisteredAt); err != nil {
+			return nil, fmt.Errorf("dpreport: zeile lesen: %w", err)
+		}
+		out = append(out, r)
+	}
+	return out, rows.Err()
+}
+
+// ProcessingEntry beschreibt Zweck und Rechtsgrundlage EINES Objekttyps
+// (Akzeptanzkriterium 2). Statisch gepflegt, da Zweck/Rechtsgrundlage
+// Rechtsbewertungen sind, keine aus Nutzdaten ableitbaren Werte — neue
+// Objekttypen ergänzen diese Liste, ändern kein bestehendes Verhalten.
+type ProcessingEntry struct {
+	ObjectType string
+	Purpose    string
+	LegalBasis string
+}
+
+// ProcessingPurposes ist die je Objekttyp gepflegte Verarbeitungs-
+// übersicht. Unbekannte Objekttypen (noch nicht hier eingetragen)
+// liefert ProcessingOverview mit einem expliziten Platzhalter statt sie
+// stillschweigend wegzulassen (Prüfung: vollständige Übersicht).
+var ProcessingPurposes = map[string]ProcessingEntry{
+	"dms_document": {
+		ObjectType: "dms_document",
+		Purpose:    "Dokumentenverwaltung und -archivierung im Geschäftsbetrieb",
+		LegalBasis: "Art. 6 Abs. 1 lit. b/c DSGVO (Vertragserfüllung / rechtliche Verpflichtung, GoBD)",
+	},
+	"mail_message": {
+		ObjectType: "mail_message",
+		Purpose:    "Revisionssichere E-Mail-Archivierung",
+		LegalBasis: "Art. 6 Abs. 1 lit. c DSGVO (rechtliche Verpflichtung, GoBD/HGB)",
+	},
+}
+
+// ProcessingOverview liefert die Verarbeitungsübersicht für alle im
+// Tenant TATSÄCHLICH vorkommenden Objekttypen (Akzeptanzkriterium 2).
+func ProcessingOverview(ctx context.Context, pool *pgxpool.Pool) ([]ProcessingEntry, error) {
+	rows, err := pool.Query(ctx, `SELECT DISTINCT object_type FROM retention_objects ORDER BY object_type`)
+	if err != nil {
+		return nil, fmt.Errorf("dpreport: objekttypen abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	var out []ProcessingEntry
+	for rows.Next() {
+		var objectType string
+		if err := rows.Scan(&objectType); err != nil {
+			return nil, fmt.Errorf("dpreport: objekttyp lesen: %w", err)
+		}
+		entry, known := ProcessingPurposes[objectType]
+		if !known {
+			entry = ProcessingEntry{ObjectType: objectType, Purpose: "unbekannt (nicht gepflegt)", LegalBasis: "unbekannt (nicht gepflegt)"}
+		}
+		out = append(out, entry)
+	}
+	return out, rows.Err()
+}
+
+// WriteSubjectReportCSV exportiert einen Auskunftsbericht als CSV
+// (Akzeptanzkriterium/Pflichtprüfung 3: weiterverarbeitbar).
+func WriteSubjectReportCSV(w io.Writer, records []SubjectRecord) error {
+	cw := csv.NewWriter(w)
+	if err := cw.Write([]string{"object_type", "object_reference", "retention_class", "status", "registered_at"}); err != nil {
+		return err
+	}
+	for _, r := range records {
+		if err := cw.Write([]string{
+			r.ObjectType, r.ObjectReference, r.RetentionClass, r.Status, r.RegisteredAt.Format(time.RFC3339),
+		}); err != nil {
+			return err
+		}
+	}
+	cw.Flush()
+	return cw.Error()
+}
@@ -0,0 +1,180 @@
+package dpreport
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/retention"
+)
+
+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 uebersprungen")
+	}
+	return setupTestWithDSN(t, dsn)
+}
+
+func setupTestWithDSN(t *testing.T, dsn string) *pgxpool.Pool {
+	t.Helper()
+	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)
+		);
+		ALTER TABLE retention_objects ADD COLUMN IF NOT EXISTS data_subject_ref TEXT;
+		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()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE retention_class_assignments, retention_objects CASCADE`)
+	})
+	return pool
+}
+
+// TestSubjectReport_MatchesKnownDataset ist die geforderte Pflichtprüfung
+// 1: Auskunftsbericht für Testperson mit bekanntem Datenbestand stimmt
+// mit erwarteter Liste überein.
+func TestSubjectReport_MatchesKnownDataset(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+
+	id1, err := retention.RegisterObjectForSubject(ctx, pool, "dms_document", "doc-1", "person-a@example.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := retention.AssignClass(ctx, pool, id1, "klasse-x"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := retention.RegisterObjectForSubject(ctx, pool, "dms_document", "doc-2", "person-b@example.com"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := retention.RegisterObjectForSubject(ctx, pool, "mail_message", "mail-1", "person-a@example.com"); err != nil {
+		t.Fatal(err)
+	}
+
+	report, err := SubjectReport(ctx, pool, "person-a@example.com")
+	if err != nil {
+		t.Fatalf("subjectreport: %v", err)
+	}
+	if len(report) != 2 {
+		t.Fatalf("erwartet 2 objekte fuer person-a, habe %d: %+v", len(report), report)
+	}
+	refs := map[string]bool{}
+	for _, r := range report {
+		refs[r.ObjectReference] = true
+	}
+	if !refs["doc-1"] || !refs["mail-1"] {
+		t.Fatalf("erwartete objekte fehlen: %+v", report)
+	}
+	if refs["doc-2"] {
+		t.Fatal("doc-2 gehoert person-b, nicht person-a - darf nicht im bericht auftauchen")
+	}
+	for _, r := range report {
+		if r.ObjectReference == "doc-1" && r.RetentionClass != "klasse-x" {
+			t.Fatalf("erwartet klasse-x fuer doc-1, habe %q", r.RetentionClass)
+		}
+	}
+}
+
+// TestSubjectReport_TenantIsolation ist die geforderte Pflichtprüfung 2:
+// Bericht für einen Tenant enthält keine Objekte eines anderen Tenants.
+// Da SubjectReport IMMER gegen genau einen Tenant-Pool laeuft (Modell C),
+// wird dies strukturell bewiesen: ein zweiter, PHYSISCH GETRENNTER Pool
+// (eigene Datenbank, TEST_TENANT_DSN_B) kann die Zeilen des ersten
+// technisch nicht sehen. Braucht eine echte zweite Tenant-DB, nicht nur
+// denselben TEST_TENANT_DSN zweimal (sonst ist es dieselbe physische
+// Datenbank und der Test beweist nichts über echte Mandantentrennung).
+func TestSubjectReport_TenantIsolation(t *testing.T) {
+	dsnB := os.Getenv("TEST_TENANT_DSN_B")
+	if dsnB == "" {
+		t.Skip("TEST_TENANT_DSN_B nicht gesetzt - Test braucht eine ECHTE zweite, physisch getrennte Tenant-Datenbank")
+	}
+	poolA := setupTest(t)
+	poolB := setupTestWithDSN(t, dsnB)
+	ctx := context.Background()
+
+	if _, err := retention.RegisterObjectForSubject(ctx, poolA, "dms_document", "tenant-a-doc", "shared-person@example.com"); err != nil {
+		t.Fatal(err)
+	}
+
+	reportB, err := SubjectReport(ctx, poolB, "shared-person@example.com")
+	if err != nil {
+		t.Fatalf("subjectreport (tenant b): %v", err)
+	}
+	if len(reportB) != 0 {
+		t.Fatalf("tenant b darf tenant as objekte nicht sehen, habe: %+v", reportB)
+	}
+}
+
+// TestWriteSubjectReportCSV_IsParseable ist die geforderte Pflichtprüfung
+// 3: Export lässt sich als CSV weiterverarbeiten.
+func TestWriteSubjectReportCSV_IsParseable(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+	if _, err := retention.RegisterObjectForSubject(ctx, pool, "dms_document", "csv-doc", "csv-person@example.com"); err != nil {
+		t.Fatal(err)
+	}
+	report, err := SubjectReport(ctx, pool, "csv-person@example.com")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var buf bytes.Buffer
+	if err := WriteSubjectReportCSV(&buf, report); err != nil {
+		t.Fatalf("csv schreiben: %v", err)
+	}
+	out := buf.String()
+	if !strings.Contains(out, "object_type,object_reference") {
+		t.Fatalf("erwartet csv-header, habe: %q", out)
+	}
+	if !strings.Contains(out, "csv-doc") {
+		t.Fatalf("erwartet datenzeile mit csv-doc, habe: %q", out)
+	}
+	lines := strings.Split(strings.TrimSpace(out), "\n")
+	if len(lines) != 2 {
+		t.Fatalf("erwartet header + 1 datenzeile, habe %d zeilen: %q", len(lines), out)
+	}
+}
+
+// TestProcessingOverview_CoversPresentObjectTypes deckt Akzeptanzkriterium 2.
+func TestProcessingOverview_CoversPresentObjectTypes(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+	if _, err := retention.RegisterObjectForSubject(ctx, pool, "dms_document", "overview-doc", ""); err != nil {
+		t.Fatal(err)
+	}
+
+	overview, err := ProcessingOverview(ctx, pool)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(overview) != 1 || overview[0].ObjectType != "dms_document" {
+		t.Fatalf("erwartet genau dms_document, habe: %+v", overview)
+	}
+	if overview[0].Purpose == "" || overview[0].LegalBasis == "" {
+		t.Fatalf("zweck/rechtsgrundlage fehlen: %+v", overview[0])
+	}
+}
@@ -0,0 +1,97 @@
+// Package dsgvorequest implementiert CMP-07: den Workflow für einen
+// DSGVO-Löschantrag (Art. 17). Ruft AUSSCHLIESSLICH bereits fertige
+// Bausteine auf — CMP-02 (Suche), RET-03/deletionworkflow
+// (Aufbewahrungsprüfung, Legal Hold), CMP-06/deletionapproval
+// (Vier-Augen-Freigabe) — und baut KEINE zweite Prüf-/Freigabelogik
+// (Ticket-Vorgabe "Bekannte Fehler vermeiden": genau das hatte das
+// Vorgängerprojekt archivmail falsch gemacht).
+package dsgvorequest
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/deletionapproval"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/deletionworkflow"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/dpreport"
+)
+
+const (
+	OutcomeDeletionRequested = "deletion_requested"
+	OutcomeRejected          = "rejected"
+	OutcomeAlreadyDeleted    = "already_deleted"
+)
+
+// Decision ist das Ergebnis EINER Einzelentscheidung (Akzeptanzkriterium
+// 2: niemals eine pauschale Sammelentscheidung).
+type Decision struct {
+	RetentionObjectID string
+	ObjectType        string
+	ObjectReference   string
+	Outcome           string
+	Reason            string
+	// DeletionRequestToken ist NUR bei Outcome==OutcomeDeletionRequested
+	// gesetzt — das einmalige Klartext-Token für die zweite Bestätigung
+	// (CMP-06). Wird NICHT protokolliert (siehe CMP-06: nur der Hash
+	// landet in der DB).
+	DeletionRequestToken string
+}
+
+// ProcessDeletionRequest ist der DSGVO-Löschantrag-Workflow
+// (Akzeptanzkriterium 1). Findet über CMP-02 alle Objekte der
+// betroffenen Person (mandantenscharf durch den übergebenen
+// Tenant-Pool, Akzeptanzkriterium/Pflichtprüfung 3), entscheidet JEDES
+// Objekt EINZELN: aktive Aufbewahrungspflicht (Frist nicht abgelaufen
+// ODER Legal Hold) → Ablehnung mit Begründung; sonst → Löschung wird
+// über CMP-06 angestoßen (nicht sofort ausgeführt — die zweite,
+// unabhängige Bestätigung bleibt erforderlich). Jede Entscheidung wird
+// dauerhaft protokolliert (Akzeptanzkriterium 4).
+func ProcessDeletionRequest(ctx context.Context, pool *pgxpool.Pool, dataSubjectRef, requestedBy string) ([]Decision, error) {
+	records, err := dpreport.SubjectReport(ctx, pool, dataSubjectRef)
+	if err != nil {
+		return nil, fmt.Errorf("dsgvorequest: objekte der betroffenen person ermitteln: %w", err)
+	}
+
+	decisions := make([]Decision, 0, len(records))
+	for _, rec := range records {
+		d := Decision{RetentionObjectID: rec.RetentionObjectID, ObjectType: rec.ObjectType, ObjectReference: rec.ObjectReference}
+
+		if rec.Status == "deleted" {
+			d.Outcome = OutcomeAlreadyDeleted
+			d.Reason = "Objekt wurde bereits zuvor vernichtet"
+		} else {
+			onHold, err := deletionworkflow.IsOnLegalHold(ctx, pool, rec.RetentionObjectID)
+			if err != nil {
+				return nil, fmt.Errorf("dsgvorequest: sperrstatus prüfen (%s): %w", rec.ObjectReference, err)
+			}
+			switch {
+			case onHold:
+				d.Outcome = OutcomeRejected
+				d.Reason = "Aufbewahrungssperre (Legal Hold) aktiv"
+			case rec.Status == "active":
+				d.Outcome = OutcomeRejected
+				d.Reason = "Aufbewahrungsfrist ist noch nicht abgelaufen"
+			default: // "expired", keine Sperre: keine aktive Aufbewahrungspflicht
+				token, err := deletionapproval.RequestDeletion(ctx, pool, rec.RetentionObjectID, requestedBy)
+				if err != nil {
+					return nil, fmt.Errorf("dsgvorequest: löschung anstoßen (%s): %w", rec.ObjectReference, err)
+				}
+				d.Outcome = OutcomeDeletionRequested
+				d.Reason = "keine aktive Aufbewahrungspflicht, Löschung über Vier-Augen-Freigabe angestoßen"
+				d.DeletionRequestToken = token
+			}
+		}
+
+		if _, err := pool.Exec(ctx, `
+			INSERT INTO dsgvo_decision_log (data_subject_ref, retention_object_id, object_type, object_reference, outcome, reason, decided_by)
+			VALUES ($1, $2, $3, $4, $5, $6, $7)
+		`, dataSubjectRef, d.RetentionObjectID, d.ObjectType, d.ObjectReference, d.Outcome, d.Reason, requestedBy); err != nil {
+			return nil, fmt.Errorf("dsgvorequest: entscheidung protokollieren (%s): %w", rec.ObjectReference, err)
+		}
+
+		decisions = append(decisions, d)
+	}
+	return decisions, nil
+}
@@ -0,0 +1,220 @@
+package dsgvorequest
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/deletionapproval"
+	"gitea.perlbach24.de/scripte/nexarch/archive/internal/deletionworkflow"
+)
+
+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 uebersprungen")
+	}
+	return setupTestWithDSN(t, dsn)
+}
+
+func setupTestWithDSN(t *testing.T, dsn string) *pgxpool.Pool {
+	t.Helper()
+	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)
+		);
+		ALTER TABLE retention_objects ADD COLUMN IF NOT EXISTS data_subject_ref TEXT;
+		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 legal_holds (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+			reason TEXT NOT NULL, set_by TEXT NOT NULL, set_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			released_at TIMESTAMPTZ, released_by TEXT
+		);
+		CREATE UNIQUE INDEX IF NOT EXISTS idx_legal_holds_active
+			ON legal_holds (retention_object_id) WHERE released_at IS NULL;
+		CREATE TABLE IF NOT EXISTS destruction_log (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE RESTRICT,
+			object_type TEXT NOT NULL, object_reference TEXT NOT NULL,
+			destroyed_at TIMESTAMPTZ NOT NULL DEFAULT now(), destroyed_by TEXT NOT NULL
+		);
+		CREATE TABLE IF NOT EXISTS deletion_requests (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+			requested_by TEXT NOT NULL, requested_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			confirmation_token_hash BYTEA NOT NULL, token_expires_at TIMESTAMPTZ NOT NULL,
+			confirmed_by TEXT, confirmed_at TIMESTAMPTZ, executed_at TIMESTAMPTZ
+		);
+		CREATE TABLE IF NOT EXISTS dsgvo_decision_log (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			data_subject_ref TEXT NOT NULL,
+			retention_object_id UUID NOT NULL REFERENCES retention_objects(id) ON DELETE RESTRICT,
+			object_type TEXT NOT NULL, object_reference TEXT NOT NULL,
+			outcome TEXT NOT NULL CHECK (outcome IN ('deletion_requested', 'rejected', 'already_deleted')),
+			reason TEXT NOT NULL, decided_at TIMESTAMPTZ NOT NULL DEFAULT now(), decided_by TEXT NOT NULL
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+	t.Cleanup(func() {
+		_, _ = pool.Exec(context.Background(), `TRUNCATE dsgvo_decision_log, deletion_requests, destruction_log, legal_holds, retention_class_assignments, retention_objects CASCADE`)
+	})
+	return pool
+}
+
+func insertObject(t *testing.T, ctx context.Context, pool *pgxpool.Pool, ref, subjectRef, status string) string {
+	t.Helper()
+	var id string
+	if err := pool.QueryRow(ctx, `
+		INSERT INTO retention_objects (object_type, object_reference, status, data_subject_ref)
+		VALUES ('dms_document', $1, $2, $3) RETURNING id
+	`, ref, status, subjectRef).Scan(&id); err != nil {
+		t.Fatal(err)
+	}
+	return id
+}
+
+// TestProcessDeletionRequest_MixedDatasetYieldsOneDeletionOneRejection
+// ist die geforderte Pflichtprüfung 1.
+func TestProcessDeletionRequest_MixedDatasetYieldsOneDeletionOneRejection(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+
+	deletableID := insertObject(t, ctx, pool, "mixed-deletable", "person-mixed@example.com", "expired")
+	insertObject(t, ctx, pool, "mixed-active", "person-mixed@example.com", "active")
+
+	decisions, err := ProcessDeletionRequest(ctx, pool, "person-mixed@example.com", "dsgvo-officer@acme.example")
+	if err != nil {
+		t.Fatalf("processdeletionrequest: %v", err)
+	}
+	if len(decisions) != 2 {
+		t.Fatalf("erwartet 2 entscheidungen, habe %d: %+v", len(decisions), decisions)
+	}
+
+	var requested, rejected int
+	var token string
+	for _, d := range decisions {
+		switch d.Outcome {
+		case OutcomeDeletionRequested:
+			requested++
+			token = d.DeletionRequestToken
+			if d.RetentionObjectID != deletableID {
+				t.Fatalf("falsches objekt zur loeschung angestossen: %+v", d)
+			}
+		case OutcomeRejected:
+			rejected++
+			if d.Reason == "" {
+				t.Fatal("ablehnung ohne begruendung")
+			}
+		}
+	}
+	if requested != 1 || rejected != 1 {
+		t.Fatalf("erwartet genau 1 loeschung + 1 ablehnung, habe requested=%d rejected=%d: %+v", requested, rejected, decisions)
+	}
+
+	// Vollstaendiger Nachweis: die angestossene Loeschung ueber CMP-06
+	// (Vier-Augen) bis zum Ende durchfuehren - beweist, dass CMP-07
+	// tatsaechlich denselben Workflow nutzt, nicht nur eine Anfrage
+	// erzeugt, die ins Leere laeuft.
+	var reqID string
+	if err := pool.QueryRow(ctx, `SELECT id FROM deletion_requests WHERE retention_object_id = $1`, deletableID).Scan(&reqID); err != nil {
+		t.Fatal(err)
+	}
+	if err := deletionapproval.ConfirmAndExecute(ctx, pool, reqID, token, "second-person@acme.example"); err != nil {
+		t.Fatalf("confirmandexecute: %v", err)
+	}
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM retention_objects WHERE id = $1`, deletableID).Scan(&status); err != nil {
+		t.Fatal(err)
+	}
+	if status != "deleted" {
+		t.Fatalf("erwartet real geloeschtes objekt nach vier-augen-bestaetigung, status = %q", status)
+	}
+
+	// Protokoll (Akzeptanzkriterium 4) real vorhanden.
+	var logCount int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM dsgvo_decision_log WHERE data_subject_ref = $1`, "person-mixed@example.com").Scan(&logCount); err != nil {
+		t.Fatal(err)
+	}
+	if logCount != 2 {
+		t.Fatalf("erwartet 2 protokollierte entscheidungen, habe %d", logCount)
+	}
+}
+
+// TestProcessDeletionRequest_LegalHoldBlocksEvenExpiredObject ist die
+// geforderte Pflichtprüfung 2.
+func TestProcessDeletionRequest_LegalHoldBlocksEvenExpiredObject(t *testing.T) {
+	pool := setupTest(t)
+	ctx := context.Background()
+
+	objID := insertObject(t, ctx, pool, "hold-expired", "person-hold@example.com", "expired")
+	if err := deletionworkflow.SetLegalHold(ctx, pool, objID, "laufendes verfahren", "legal@acme.example"); err != nil {
+		t.Fatal(err)
+	}
+
+	decisions, err := ProcessDeletionRequest(ctx, pool, "person-hold@example.com", "dsgvo-officer@acme.example")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decisions) != 1 || decisions[0].Outcome != OutcomeRejected {
+		t.Fatalf("erwartet ablehnung trotz abgelaufener frist (legal hold), habe: %+v", decisions)
+	}
+
+	var status string
+	if err := pool.QueryRow(ctx, `SELECT status FROM retention_objects WHERE id = $1`, objID).Scan(&status); err != nil {
+		t.Fatal(err)
+	}
+	if status != "expired" {
+		t.Fatalf("objekt haette wegen legal hold nicht angefasst werden duerfen, status = %q", status)
+	}
+}
+
+// TestProcessDeletionRequest_TenantIsolation ist die geforderte
+// Pflichtprüfung 3.
+func TestProcessDeletionRequest_TenantIsolation(t *testing.T) {
+	dsnB := os.Getenv("TEST_TENANT_DSN_B")
+	if dsnB == "" {
+		t.Skip("TEST_TENANT_DSN_B nicht gesetzt - Test braucht eine echte zweite, physisch getrennte Tenant-Datenbank")
+	}
+	poolA := setupTest(t)
+	poolB := setupTestWithDSN(t, dsnB)
+	ctx := context.Background()
+
+	insertObject(t, ctx, poolA, "tenant-a-doc", "shared-person@example.com", "expired")
+
+	decisionsB, err := ProcessDeletionRequest(ctx, poolB, "shared-person@example.com", "dsgvo-officer@acme.example")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decisionsB) != 0 {
+		t.Fatalf("tenant b darf tenant as objekte nicht sehen/anfassen, habe: %+v", decisionsB)
+	}
+
+	var untouchedStatus string
+	if err := poolA.QueryRow(ctx, `SELECT status FROM retention_objects WHERE object_reference = 'tenant-a-doc'`).Scan(&untouchedStatus); err != nil {
+		t.Fatal(err)
+	}
+	if untouchedStatus != "expired" {
+		t.Fatalf("tenant as objekt haette unangetastet bleiben muessen, status = %q", untouchedStatus)
+	}
+}
@@ -43,6 +43,28 @@ func RegisterObject(ctx context.Context, pool *pgxpool.Pool, objectType, objectR
 	return id, nil
 }

+// RegisterObjectForSubject ist CMP-02s additive Ergänzung zu
+// RegisterObject: registriert das Objekt zusätzlich mit einer Referenz
+// auf die betroffene Person (dataSubjectRef, z. B. E-Mail oder
+// User-ID), Grundlage für den DSGVO-Auskunftsbericht. Leeres
+// dataSubjectRef bedeutet: nicht personenbezogen, kein Fehler.
+// RegisterObject selbst bleibt unverändert (kein Umbau bestehenden
+// Verhaltens) — dies ist ein separater, additiver Registrierungsweg.
+func RegisterObjectForSubject(ctx context.Context, pool *pgxpool.Pool, objectType, objectReference, dataSubjectRef string) (string, error) {
+	var id string
+	err := pool.QueryRow(ctx, `
+		INSERT INTO retention_objects (object_type, object_reference, data_subject_ref)
+		VALUES ($1, $2, NULLIF($3, ''))
+		ON CONFLICT (object_type, object_reference)
+		DO UPDATE SET data_subject_ref = COALESCE(NULLIF(EXCLUDED.data_subject_ref, ''), retention_objects.data_subject_ref)
+		RETURNING id
+	`, objectType, objectReference, dataSubjectRef).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("retention: objekt mit betroffener person registrieren: %w", err)
+	}
+	return id, nil
+}
+
 // Assignment ist EINE historische Zuordnung einer Aufbewahrungsklasse.
 type Assignment struct {
 	RetentionClass string
@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS idx_retention_objects_data_subject_ref;
+ALTER TABLE retention_objects DROP COLUMN IF EXISTS data_subject_ref;
@@ -0,0 +1,10 @@
+-- CMP-02: DSGVO-Auskunftsberichte brauchen eine Zuordnung Objekt->
+-- betroffene Person. RET-01s retention_objects kannte bislang nur
+-- object_type/object_reference (opak, modulübergreifend), keine
+-- Person-Referenz. Additive, nullable Spalte — bestehende Zeilen und
+-- Aufrufer von RegisterObject bleiben unverändert gültig: NICHT jedes
+-- Objekt ist personenbezogen (z. B. Systemkonfiguration), ein leeres
+-- Feld bedeutet genau das, nicht einen Fehler.
+ALTER TABLE retention_objects ADD COLUMN IF NOT EXISTS data_subject_ref TEXT;
+CREATE INDEX IF NOT EXISTS idx_retention_objects_data_subject_ref
+    ON retention_objects (data_subject_ref) WHERE data_subject_ref IS NOT NULL;
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS deletion_requests;
@@ -0,0 +1,17 @@
+-- CMP-06: Vier-Augen-Freigabe fuer Loeschungen. Eine Loeschanfrage muss
+-- von einer ANDEREN Person bestaetigt werden als der, die sie gestellt
+-- hat, bevor RET-03s Destroy() tatsaechlich ausgefuehrt wird. Nur der
+-- Hash des Bestaetigungs-Tokens wird gespeichert (Akzeptanzkriterium 3),
+-- niemals das Token selbst.
+CREATE TABLE IF NOT EXISTS deletion_requests (
+    id                    UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    retention_object_id   UUID NOT NULL REFERENCES retention_objects(id) ON DELETE CASCADE,
+    requested_by          TEXT NOT NULL,
+    requested_at          TIMESTAMPTZ NOT NULL DEFAULT now(),
+    confirmation_token_hash BYTEA NOT NULL,
+    token_expires_at      TIMESTAMPTZ NOT NULL,
+    confirmed_by          TEXT,
+    confirmed_at          TIMESTAMPTZ,
+    executed_at           TIMESTAMPTZ
+);
+CREATE INDEX IF NOT EXISTS idx_deletion_requests_object ON deletion_requests (retention_object_id);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS dsgvo_decision_log;
@@ -0,0 +1,15 @@
+-- CMP-07: vollständiges, dauerhaftes Protokoll JEDER Einzelentscheidung
+-- eines DSGVO-Löschantrags (Akzeptanzkriterium 4) - gelöscht UND
+-- abgelehnt, je Objekt einzeln, nicht nur eine Sammelentscheidung.
+CREATE TABLE IF NOT EXISTS dsgvo_decision_log (
+    id                   UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    data_subject_ref     TEXT NOT NULL,
+    retention_object_id  UUID NOT NULL REFERENCES retention_objects(id) ON DELETE RESTRICT,
+    object_type          TEXT NOT NULL,
+    object_reference     TEXT NOT NULL,
+    outcome              TEXT NOT NULL CHECK (outcome IN ('deletion_requested', 'rejected', 'already_deleted')),
+    reason               TEXT NOT NULL,
+    decided_at           TIMESTAMPTZ NOT NULL DEFAULT now(),
+    decided_by           TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_dsgvo_decision_log_subject ON dsgvo_decision_log (data_subject_ref);