@cosmicdrift/kumiko-bundled-features 0.2.2 → 0.3.0

package/src/user-data-rights/COMPLIANCE.md

@@ -0,0 +1,182 @@
+# DSGVO Compliance — Operator-Guide
+
+Dieses Dokument bündelt die **technischen Fakten** zur DSGVO-Pipeline
+(Art. 15/17/18/20) als Grundlage für:
+
+- **Verarbeitungsverzeichnis** (Art. 30) — was wird wo wie lange gespeichert
+- **Datenschutzerklärung** — welche Endpoints decken welchen Artikel ab
+- **AVV mit Sub-Processors** — welche TOM sind eingebaut
+- **Operator-Runbook** — was triggert wann, wer kann was sehen
+
+> Juristische Texte (AVV-Wortlaut, Datenschutzerklärung-Bausteine,
+> Verarbeitungsverzeichnis-Strukturierung) gehören zu Marc + Anwalt —
+> dieses Dokument liefert nur die technischen Fakten dafür.
+
+---
+
+## 1. Endpoint → Artikel-Mapping
+
+| Artikel | Endpoint / Runner | Wer ruft auf | Was passiert |
+|---------|-------------------|--------------|--------------|
+| **Art. 15 (Auskunft, light)** | `user-data-rights:query:my-audit-log` | User | Liest eigene Framework-Events aus `kumiko_events` (account-weit über alle Memberships). Filterbar nach `eventType`, `aggregateType`, `from`/`to`. Domain-Entities ohne `ctx.appendEvent` erscheinen NICHT — die kommen im Export-Bundle (Art. 20). |
+| **Art. 15 + 20 (Auskunft + Portabilität)** | `user-data-rights:write:request-export` | User | Async Job → ZIP mit user-Profil + fileRefs + alle EXT_USER_DATA-Provider-Daten (cross-tenant) + signed Magic-Link per Email. Idempotent: nur 1 active Job pro User (`ACTIVE_JOB_CONSTRAINT`). |
+| **Art. 15 + 20** | `GET /user-export/by-token?token=…` | Anonym (Magic-Link-Pfad) | Token-Hash-Lookup → 302-Redirect auf signed Storage-URL. Multi-use innerhalb TTL. Audit: `lastUsedAt`, `lastUsedFromIp`, `lastUsedUserAgent`. |
+| **Art. 15 + 20** | `GET /user-export/by-job/:jobId` | User (Session-Auth) | UI-Klick-Pfad. Cross-tenant-same-user: User in Tenant B kann Job aus Tenant A laden wenn er der Owner ist. |
+| **Art. 17 (Löschung)** | `user-data-rights:write:request-deletion` | User | Soft-Delete: `status=DeletionRequested` + `gracePeriodEnd = now + profile.gracePeriod`. Cron `run-forget-cleanup` führt nach Grace die Anonymisierung durch. |
+| **Art. 17** | `user-data-rights:write:cancel-deletion` | User | Während Grace: status zurück auf `Active`. |
+| **Art. 17** | `run-forget-cleanup` (Cron) | System | Findet User mit `status=DeletionRequested AND gracePeriodEnd < now`. Pro User Sub-TX über alle EXT_USER_DATA-Provider mit Strategy aus `retention.policyFor`. user-Hook anonymisiert (PII raus, Sentinel-Email). |
+| **Art. 18 (Restriction)** | `user-data-rights:write:restrict-account` | Admin / SystemAdmin | Status-Flip → Auth-Middleware-Guard blockt Logins. `sessions.revokeAllForUser` killt aktive Sessions. |
+| **Art. 18** | `user-data-rights:write:lift-restriction` | Admin / SystemAdmin | Restriction aufheben. |
+| **Operator (DPO)** | `user-data-rights:query:list-download-attempts` | Admin / SystemAdmin | Brute-Force-Detection: zeigt invalid Download-Versuche (notFound / expired / failed / signedUrlNotSupported) gefiltert nach Result, IP, Zeitraum. |
+
+---
+
+## 2. Speicherorte (Verarbeitungsverzeichnis Art. 30)
+
+| Tabelle | Inhalt | Personenbezug | Retention | Zweck |
+|---------|--------|---------------|-----------|-------|
+| `read_users` | User-Profil (email, displayName, passwordHash, locale, status, gracePeriodEnd, roles) | direkt | per Domain (typ. blockDelete bei Aufbewahrungspflicht, sonst hardDelete via Forget-Pipeline) | Authentifizierung, Nutzer-Profil |
+| `read_tenant_memberships` | User↔Tenant-Verknüpfung + Rollen | direkt (via userId) | per Tenant-Lifecycle | Mehrmandant-Zuordnung |
+| `kumiko_events` | Event-Store (alle write-Events) | direkt (`createdBy = userId`) | per Domain-Policy via `data-retention` | Audit-Trail (Art. 15-Selbstauskunft Quelle), Event-Sourcing |
+| `read_export_jobs` | Async Export-Status (queued/running/done/failed), userId, requestedAt, doneAt, storageKey | direkt (userId) | per `compliance-profiles` Profil-Default | Idempotenz + Status-Polling |
+| `read_export_download_tokens` | Magic-Link-Hash (SHA-256), TTL, useCount, lastUsedAt, lastUsedFromIp, lastUsedUserAgent | indirekt (Token→Job→User) | `compliance-profiles.userRights.exportDownloadTtl` (default 7d) | Magic-Link-Auth + Multi-Use-Audit |
+| `read_download_attempts` | Invalid Download-Versuche: result, via, tokenHash, ip, userAgent, attemptedAt | indirekt (IP) | **90d hardDelete** (Entity-Default, Disk-Bomb-Schutz) | DPO-Brute-Force-Detection |
+| `read_tenant_compliance_profiles` | Per-Tenant Profile-Wahl + Override | nein | unbounded (Konfiguration) | Region-/Branchen-Defaults |
+| `read_tenant_retention_overrides` | Per-Tenant Retention-Override pro Entity | nein | unbounded (Konfiguration) | Aufbewahrungspflicht-Edge-Cases |
+| Storage-Provider (Local / S3) | Export-ZIPs + File-Binaries | indirekt (Inhalt) | Local: per `exportDownloadTtl` Cleanup. S3: lifecycle-Policy (App-Author-Verantwortung) | Daten-Export-Auslieferung |
+
+---
+
+## 3. Compliance-Profile
+
+| Profil | gracePeriod | exportDownloadTtl | Stale-After | Sub-Processors |
+|--------|-------------|-------------------|-------------|----------------|
+| `eu-dsgvo` | 30d | 7d | 30d | per Tenant konfigurierbar |
+| `swiss-dsg` | 30d | 7d | 30d | + EDÖB-Meldepfad |
+| `de-hr-dsgvo-hgb` | 30d | 7d | 30d | + HR-Aufbewahrung 10y für HR-Entities (anonymize statt delete) |
+| `minimal-no-region` | 30d | 7d | 30d | Migration-Edge-Case ohne Region |
+
+Tenant kann via `compliance-profiles:write:set-profile` + Override (`override.userRights.gracePeriod={ days: N }` etc.) eigene Werte setzen.
+
+---
+
+## 4. Technische und Organisatorische Maßnahmen (TOM)
+
+Eingebaute Schutzmaßnahmen — können 1:1 in den AVV-Anhang "Technische
+und Organisatorische Maßnahmen" übernommen werden:
+
+### Vertraulichkeit / Zugriffskontrolle
+
+- **Magic-Link-Token-Hashing**: Plain-Token landet NIE in DB / Event-Store. SHA-256-Hash via `crypto.subtle.digest` (Web-Crypto-API). Plain-Token kommt nur ephemeral via Email-Callback an die App-Author-Implementation.
+- **Download-Token Multi-Use within TTL**: kein consume-on-use (Pattern Google Takeout) — User kann ZIP mehrfach laden, aber TTL gilt absolut.
+- **Audit-Felder am Token**: useCount, lastUsedAt, lastUsedFromIp, lastUsedUserAgent. Operator sieht ob Token mehrfach verwendet wurde, von welcher IP.
+- **Account-weite Auskunft via `ctx.db.raw`**: `my-audit-log` umgeht TenantDb-Auto-Filter explizit (Account-weite Sicht für Art. 15 ist Pflicht); Sicherung über hard-coded `WHERE createdBy = ctx.user.id` (kein userId-Parameter, kein Cross-User-Snooping möglich).
+- **Cross-User-Schutz im Download-Pfad**: `download-by-job` checkt `jobRow.userId === session.user.id` — User kann nur eigene Jobs laden.
+- **Restriction killt Sessions**: `restrict-account` triggert `sessions.revokeAllForUser` — restricted User kann existierende Tabs nicht weiternutzen.
+
+### Integrität
+
+- **Event-Sourcing first-class**: alle DSGVO-Schreib-Operationen (request-deletion, restrict, lift, request-export) sind Events im `kumiko_events`-Store mit `version_conflict`-Schutz.
+- **Forget-Strategy aus `data-retention`**: Cleanup-Runner konsultiert `retention.policyFor` pro Entity — `blockDelete` für gesetzliche Aufbewahrungspflicht (HR/HGB), `anonymize` als Alternative zu `hardDelete`.
+- **Strategy-respect-Pattern in Default-Hooks**: user-Hook anonymisiert mit Sentinel-Pattern `deleted-<id>@anonymized.invalid` — Unique-Constraint + FK-Refs bleiben intakt.
+
+### Verfügbarkeit / Belastbarkeit
+
+- **Best-Effort-Audit beim Download**: Audit-INSERT in `read_download_attempts` ist `try/catch` swallowed — Audit-Failure killt nicht den User-facing 4xx.
+- **Idempotenz im Export-Job**: `ACTIVE_JOB_CONSTRAINT` (UNIQUE-Index auf `(userId, status='active')`) verhindert Doppel-Jobs. Worker-Crash → Job bleibt `running`, Recovery-Pfad via Job-Run-Tracking aus `jobs`-Feature.
+- **Per-User Sub-TX im Forget-Runner**: Ein User-Hook-Throw rollback'd nur diesen User; andere User im Batch laufen weiter.
+- **Best-Effort-Notification-Callbacks**: send-Throw für Job A killt nicht Batch B/C (Memory: Atom 5.fix3).
+
+### Brute-Force-Schutz
+
+- **Edge-Rate-Limit auf Download-Endpoint**: `rateLimit: { per: "ip", limit: 30, windowSeconds: 60 }` für `download-by-token`.
+- **Download-Attempt-Audit** mit 90d hardDelete: invalid Versuche werden persistiert für DPO-Detection, Tabelle ist begrenzt → kein Disk-Bomb durch Brute-Force.
+- **Token-Hash-Suchraum**: 32-Byte-Random = 256 Bit, Brute-Force über Edge-Limit praktisch nicht möglich.
+
+### Zweckbindung / Datenminimierung
+
+- **Export-Bundle Default-PII-Filter**: user-Hook entfernt `passwordHash`, `roles`, `status` aus dem Bundle (App-Author kann das per Custom-Hook überschreiben).
+- **fileRefs separat**: Export-Bundle enthält Datei-Metadaten (id, fileName, mimeType, size); Binaries werden via signed-URL separat ins ZIP gepackt — kein Inline-Base64-Memory-Druck.
+
+### Auftragskontrolle (gegenüber Sub-Processors)
+
+- **Storage-Provider als Plugin** (`file-foundation` + `file-provider-{s3,inmemory}`): App-Author wählt Provider; AVV mit S3-Hoster (Hetzner / AWS) ist vom Provider abhängig.
+- **Email-Transport als Plugin** (`mail-foundation` + `mail-transport-{smtp,inmemory}`): SMTP / SES / Resend per Plugin austauschbar.
+- **`compliance-profiles:query:sub-processors`**: Per-Tenant Liste der aktiven Sub-Processors, abrufbar für AVV-Anhang.
+
+---
+
+## 5. Cron-Jobs / Operationale Trigger
+
+| Job | Trigger | Was passiert | Operator-Sichtbarkeit |
+|-----|---------|--------------|------------------------|
+| `run-forget-cleanup` | Cron (per App-Author konfigurierbar, typisch täglich) | Findet User mit abgelaufener Grace, ruft `EXT_USER_DATA.delete` pro Provider, anonymisiert User, sendet `sendDeletionExecutedEmail`-Callback | `read_job_runs` (success/fail), Hook-Errors als `errors[]` im Result |
+| `run-export-jobs` | Cron + Event-getriggert | Findet pending Export-Jobs, ruft `runUserExport` → ZIP-Bau → Storage-Upload → Magic-Link-Token → `sendExportReadyEmail` | `read_job_runs`, `read_export_jobs.status` |
+| `data-retention-cleanup` | Cron (in `data-retention`) | Cleant abgelaufene Rows pro Entity per `retention.keepFor` | `read_job_runs` |
+| Token-Cleanup (implizit) | Per `compliance-profiles.userRights.exportDownloadTtl` | Worker-Job entfernt expired Magic-Link-Tokens + Storage-Binaries | `read_export_download_tokens` |
+| Download-Attempt-Cleanup | Per Entity-Default 90d | Cleant `read_download_attempts` | — |
+
+App-Author registriert die Cron-Trigger im run-config; `jobs`-Feature
+persistiert Run-Tracking + Retry-Pfad.
+
+---
+
+## 6. Doku-Snippets für Marc
+
+### Datenschutzerklärung — Betroffenenrechte
+
+> **Recht auf Auskunft (Art. 15 DSGVO):** Sie können jederzeit eine
+> Kopie aller bei uns über Sie gespeicherten Daten anfordern. Über die
+> Funktion "Daten exportieren" in den Account-Einstellungen erhalten
+> Sie ein vollständiges JSON-/ZIP-Bundle Ihrer Profildaten, hochgeladenen
+> Dateien und [App-Author: Domain-Daten ergänzen] per signed Magic-Link
+> auf Ihre hinterlegte E-Mail-Adresse. Der Link ist 7 Tage gültig.
+
+> **Recht auf Löschung (Art. 17 DSGVO):** Über "Account löschen" können
+> Sie Ihren Account jederzeit zur Löschung vormerken. Es gilt eine
+> Karenzzeit von 30 Tagen, in der Sie den Antrag widerrufen können
+> (Funktion "Löschung widerrufen"). Nach Ablauf werden Ihre Daten
+> automatisch gelöscht oder anonymisiert. Daten mit gesetzlicher
+> Aufbewahrungspflicht (z. B. Rechnungen nach §147 AO) bleiben bis zum
+> Fristablauf gesperrt erhalten und werden danach automatisch gelöscht.
+
+> **Recht auf Einschränkung (Art. 18 DSGVO):** Auf begründeten Antrag
+> kann Ihr Account temporär gesperrt werden. Während der Sperre können
+> Sie sich nicht mehr einloggen, Ihre Daten werden aber nicht gelöscht
+> oder verändert.
+
+### AVV-TOM-Anhang
+
+Für den AVV-Anhang "Technische und Organisatorische Maßnahmen" siehe
+**Abschnitt 4** dieses Dokuments — komplette Liste mit Verweisen auf
+die Code-Implementierung.
+
+### Verarbeitungsverzeichnis
+
+Spalte "Speicherorte / Empfänger" → siehe **Abschnitt 2** (Tabellen-
+Übersicht). Spalte "Löschfristen" → siehe **Abschnitt 3** + Spalte
+"Retention" in Abschnitt 2.
+
+---
+
+## 7. Was NICHT in diesem Framework abgedeckt ist
+
+Bewusst ausserhalb — App-Author-Verantwortung:
+
+- **Auswahl + AVV mit konkretem Storage-Provider** (Hetzner / AWS / etc.)
+- **Auswahl + AVV mit konkretem Email-Provider** (SMTP-Host / SES / Resend)
+- **Datenpannen-Meldung** an Aufsichtsbehörde (organisatorisch, nicht technisch)
+- **DSFA** (Datenschutz-Folgenabschätzung) — Framework liefert die TOM-Inputs, App-Author macht die Bewertung
+- **Cookie-Consent-Layer** (das ist Frontend-Sache + separate consent-Feature, nicht Teil von user-data-rights)
+- **Tenant-Lifecycle-Destroy** (Account-Löschung des Tenants selbst, nicht der User darin) — kommt als separates `tenant-lifecycle`-Feature in Sprint 5
+
+---
+
+## Referenzen
+
+- Code: `packages/bundled-features/src/user-data-rights/`
+- Default-Hooks: `packages/bundled-features/src/user-data-rights-defaults/`
+- Compliance-Profile: `packages/bundled-features/src/compliance-profiles/`
+- Retention-Engine: `packages/bundled-features/src/data-retention/`
+- Sample-App: `samples/apps/user-data-rights-demo/`
+- Tests: `packages/bundled-features/src/user-data-rights/__tests__/` (188 Tests)

package/src/user-data-rights/README.md

@@ -0,0 +1,109 @@
+# user-data-rights
+
+DSGVO Art. 15 (Auskunft) + Art. 17 (Löschung) + Art. 18 (Restriction) +
+Art. 20 (Portabilität) als Core-Feature.
+
+**Status:** S2 abgeschlossen — alle Endpoints, Hooks, Default-Provider,
+Cron-Pipeline, Tests + Sample wired.
+
+## Pattern
+
+Statt jedes Feature seine eigene Forget-/Export-Logik schreibt, hängt
+es sich via `r.useExtension(EXT_USER_DATA, "<entity>", { export, delete })`
+an. user-data-rights orchestriert Export- und Forget-Pipeline:
+
+```ts
+defineFeature("tasks", (r) => {
+  r.requires("user-data-rights");
+  r.useExtension(EXT_USER_DATA, "task", {
+    export: async (ctx) => ({
+      entity: "task",
+      rows: await ctx.db.select().from(tasksTable)
+        .where(eq(tasksTable.authorId, ctx.userId)),
+    }),
+    delete: async (ctx, strategy) => {
+      if (strategy === "anonymize") {
+        await ctx.db.update(tasksTable).set({ authorId: null })
+          .where(eq(tasksTable.authorId, ctx.userId));
+      } else {
+        await ctx.db.delete(tasksTable)
+          .where(eq(tasksTable.authorId, ctx.userId));
+      }
+    },
+  });
+});
+```
+
+Hook-Signaturen in `framework/src/engine/extensions/user-data.ts`:
+
+- `UserDataExportHook(ctx) => Promise<UserDataExportSnippet | null>`
+- `UserDataDeleteHook(ctx, strategy) => Promise<void>`
+- `UserDataDeleteStrategy = "delete" | "anonymize"`
+
+## Endpoints
+
+| Article | Handler | Zweck |
+|---------|---------|-------|
+| Art. 15 | `user-data-rights:query:my-audit-log` | User sieht eigene Framework-Events (account-weit über alle Memberships). Domain-Entities ohne `ctx.appendEvent` erscheinen NICHT — nur im Export-Bundle. |
+| Art. 15+20 | `user-data-rights:write:request-export` | Async Job → ZIP mit user-Profil + fileRefs + alle EXT_USER_DATA-Provider-Daten + signed Magic-Link |
+| Art. 17 | `user-data-rights:write:request-deletion` | Soft-Delete mit Grace-Period, anschließend Cron anonymisiert User + cleant Domain-Entities |
+| Art. 17 | `user-data-rights:write:cancel-deletion` | User widerruft seinen Forget-Request während der Grace |
+| Art. 18 | `user-data-rights:write:restrict-account` | Auth-Middleware blockt Logins bis Lift |
+| Art. 18 | `user-data-rights:write:lift-restriction` | Admin/SystemAdmin hebt Restriction auf |
+| Operator | `user-data-rights:query:list-download-attempts` | DPO-Sicht auf invalid Download-Versuche (Brute-Force-Detection, Admin/SystemAdmin only) |
+
+Plus 2 anonyme HTTP-Routes für Export-Download (Magic-Link-Pfad +
+session-auth-Pfad), siehe `handlers/download-by-{token,job}.query.ts`.
+
+## Cross-Feature-API
+
+**Exposes:**
+- `userDataRights.runExport` — über die public Runner-Exports
+  (`runUserExport`, `runForgetCleanup`)
+- `userDataRights.runForget`
+
+**Uses:**
+- `compliance.forTenant` (Grace-Period aus Profile)
+- `retention.policyFor` (blockDelete-Konsultation, anonymize statt delete)
+- `sessions.revokeAllForUser` (Restriction killt aktive Sessions)
+
+## Default-Hooks (`user-data-rights-defaults`)
+
+Optional-mountbares Sub-Feature liefert Default-Hooks für
+Core-Entities `user` (anonymize: email→`deleted-<id>@anonymized.invalid`,
+displayName→`(deleted)`, passwordHash=null) und `fileRef` (delete: row +
+storage-binary; anonymize: insertedById=null). App-Author kann es
+weglassen wenn er Custom-Hooks registrieren will.
+
+## Audit-Trail
+
+| Tabelle | Zweck | Retention |
+|---------|-------|-----------|
+| `kumiko_events` | Framework-Event-Store, Quelle für `my-audit-log` | per Domain-Policy |
+| `read_export_jobs` | Async Export-Status (queued / done / failed) | per `compliance-profiles` |
+| `read_export_download_tokens` | Magic-Link-Hash + TTL + lastUsed-Audit | per `compliance-profiles` (default `exportDownloadTtl`) |
+| `read_download_attempts` | Invalid-Download-Versuche für DPO-Brute-Force-Detection | **90d hardDelete** (Entity-Default — schützt vor Disk-Bomb bei aktiven Angriffen) |
+
+## Tests
+
+18 Testdateien, 188 Tests, alle grün:
+
+| Datei | Pinst |
+|-------|-------|
+| `audit-log.integration.ts` | Cross-User-Isolation, Account-weite Sicht, eventType-Filter, Admin-only operator-query, download-attempt 90d-retention |
+| `cross-data-matrix.integration.ts` | 3-Provider-Pipeline (user + fileRef + custom-domain), Cross-Tenant Forget mit user-anonymize, Other-User-Isolation |
+| `download.integration.ts` | HTTP-e2e via `r.httpRoute`: Magic-Link, multi-use, expired, failed-job, storage-cleared, cross-tenant-same-user, malicious-filename |
+| `request-export.integration.ts` | Idempotency, active-job-constraint, cross-tenant-anyMember-userId-pattern |
+| `request-deletion-callback.integration.ts` + `request-cancel-deletion.integration.ts` | Grace + Cancel-Pfad + Email-Callback best-effort |
+| `restriction-flow.integration.ts` | Status-Flip + Auth-Middleware-Block + Lift |
+| `run-{export-jobs,forget-cleanup,user-export}.integration.ts` | Worker-Logic + Idempotency + Email-Callbacks |
+| `policy-to-strategy.test.ts` | Retention.strategy → UserDataDeleteStrategy mapping |
+| `user-data-rights.integration.ts` | Boot-Smoke + Feature-Meta |
+| `token-helpers.test.ts` + `zip-path.test.ts` | Token-Hashing + Path-Traversal-Schutz |
+| `export-job-{idempotency,schema}.test.ts` | Active-job-uniqueness + Schema-Constraints |
+
+## Sample
+
+`samples/apps/user-data-rights-demo` — runnable Demo mit todos-Domain,
+EXT_USER_DATA-Hook für strategy-aware delete (anonymize → authorId=null,
+delete → DROP), 3 living-doc Integration-Tests.

package/src/user-data-rights/__tests__/audit-log.integration.ts

@@ -0,0 +1,199 @@
+// S2.U7 — my-audit-log + invalid-attempt-audit + list-download-attempts.
+
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createTestUser,
+  setupTestStack,
+  type TestStack,
+  testTenantId,
+  unsafeCreateEntityTable,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { sql } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import {
+  createComplianceProfilesFeature,
+  tenantComplianceProfileEntity,
+} from "../../compliance-profiles";
+import { createDataRetentionFeature } from "../../data-retention";
+import { USER_STATUS, userEntity, userTable } from "../../user";
+import { createUserFeature } from "../../user/feature";
+import { createUserDataRightsFeature } from "../feature";
+import { downloadAttemptEntity, downloadAttemptsTable } from "../schema/download-attempt";
+
+const MY_AUDIT = "user-data-rights:query:my-audit-log";
+const LIST_ATTEMPTS = "user-data-rights:query:list-download-attempts";
+
+let stack: TestStack;
+
+const tenantA = testTenantId(1);
+const alice = createTestUser({ id: 42, tenantId: tenantA, roles: ["Member"] });
+const bob = createTestUser({ id: 43, tenantId: tenantA, roles: ["Member"] });
+const admin = createTestUser({ id: 1, tenantId: tenantA, roles: ["Admin"] });
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [
+      createUserFeature(),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      createUserDataRightsFeature(),
+    ],
+  });
+  await unsafeCreateEntityTable(stack.db, userEntity);
+  await unsafeCreateEntityTable(stack.db, tenantComplianceProfileEntity);
+  await unsafeCreateEntityTable(stack.db, downloadAttemptEntity);
+  await createEventsTable(stack.db);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  await stack.db.delete(userTable);
+  await stack.db.execute(sql`DELETE FROM read_tenant_compliance_profiles`);
+  await stack.db.execute(sql`DELETE FROM read_download_attempts`);
+  await stack.db.execute(sql`DELETE FROM kumiko_events`);
+});
+
+async function seedUser(u: typeof alice, email: string): Promise<void> {
+  await stack.db.insert(userTable).values({
+    id: u.id,
+    tenantId: u.tenantId,
+    email,
+    passwordHash: "h",
+    displayName: email,
+    locale: "de",
+    emailVerified: true,
+    roles: '["Member"]',
+    status: USER_STATUS.Active,
+  });
+}
+
+let _eventVersion = 0;
+async function seedEvent(
+  createdBy: string,
+  tenantId: string,
+  type: string,
+  payload: object,
+): Promise<void> {
+  _eventVersion += 1;
+  await stack.db.execute(sql`
+    INSERT INTO kumiko_events
+    (tenant_id, aggregate_type, aggregate_id, version, type, payload, metadata, created_at, created_by)
+    VALUES (${tenantId}, ${"test-aggregate"}, ${"00000000-0000-4000-8000-00000000aaaa"},
+            ${_eventVersion}, ${type}, ${JSON.stringify(payload)}, ${"{}"}, now(), ${createdBy})
+  `);
+}
+
+describe("my-audit-log", () => {
+  test("user sieht nur seine eigenen events (cross-user-Isolation)", async () => {
+    await seedEvent(alice.id, tenantA, "user.requested-deletion", { foo: "alice" });
+    await seedEvent(bob.id, tenantA, "user.requested-deletion", { foo: "bob" });
+
+    const aliceLog = await stack.http.queryOk<{ rows: Array<{ payload: unknown }> }>(
+      MY_AUDIT,
+      {},
+      alice,
+    );
+    const bobLog = await stack.http.queryOk<{ rows: Array<{ payload: unknown }> }>(
+      MY_AUDIT,
+      {},
+      bob,
+    );
+    expect(aliceLog.rows.length).toBe(1);
+    expect(bobLog.rows.length).toBe(1);
+    // Payload-pinning beweist die Cross-User-Filterung: alice sieht nur
+    // ihre Payload, bob nur seine.
+    expect((aliceLog.rows[0]?.payload as { foo: string }).foo).toBe("alice");
+    expect((bobLog.rows[0]?.payload as { foo: string }).foo).toBe("bob");
+  });
+
+  test("Account-weite Sicht: User sieht events aus anderen Tenants (DSGVO Art. 15)", async () => {
+    const tenantB = testTenantId(2);
+    await seedEvent(alice.id, tenantA, "user.x", { from: "tenantA" });
+    await seedEvent(alice.id, tenantB, "user.y", { from: "tenantB" });
+
+    const log = await stack.http.queryOk<{
+      rows: Array<{ payload: { from: string } }>;
+    }>(MY_AUDIT, {}, alice);
+
+    expect(log.rows.length).toBe(2);
+    const fromTenants = log.rows.map((r) => r.payload.from).sort();
+    expect(fromTenants).toEqual(["tenantA", "tenantB"]);
+  });
+
+  test("filter eventType + payload kommt mit", async () => {
+    await seedEvent(alice.id, tenantA, "user.requested-deletion", { gracePeriodEnd: "2026-06-01" });
+    await seedEvent(alice.id, tenantA, "user.lifted-restriction", {});
+
+    const filtered = await stack.http.queryOk<{ rows: Array<{ type: string }> }>(
+      MY_AUDIT,
+      { eventType: "user.requested-deletion" },
+      alice,
+    );
+    expect(filtered.rows.length).toBe(1);
+    expect(filtered.rows[0]?.type).toBe("user.requested-deletion");
+  });
+});
+
+describe("download-attempt retention :: disk-bomb-Schutz bei Brute-Force", () => {
+  test("Entity-Default ist 90d hardDelete (kein unbounded growth)", () => {
+    expect(downloadAttemptEntity.retention).toBeDefined();
+    expect(downloadAttemptEntity.retention?.keepFor).toBe("90d");
+    expect(downloadAttemptEntity.retention?.strategy).toBe("hardDelete");
+    expect(downloadAttemptEntity.retention?.reference).toBe("attemptedAt");
+  });
+});
+
+describe("list-download-attempts (DPO operator-query)", () => {
+  test("Admin kann queryen, Member nicht", async () => {
+    await seedUser(alice, "alice@example.com");
+    // Admin allowed
+    const ok = await stack.http.queryOk<{ rows: unknown[] }>(LIST_ATTEMPTS, {}, admin);
+    expect(Array.isArray(ok.rows)).toBe(true);
+    // Member blocked
+    const res = await stack.http.query(LIST_ATTEMPTS, {}, alice);
+    expect([401, 403]).toContain(res.status);
+  });
+
+  test("filter result=notFound", async () => {
+    // Direct-INSERT in attempts (simuliert was die download-handler schreiben).
+    const T = await import("@cosmicdrift/kumiko-framework/time");
+    const now = T.getTemporal().Now.instant();
+    await stack.db.insert(downloadAttemptsTable).values([
+      {
+        id: "11111111-1111-4111-8111-111111111111",
+        tenantId: tenantA,
+        result: "notFound",
+        via: "token",
+        tokenHash: "abc",
+        jobId: null,
+        attemptedByUserId: null,
+        ip: "1.2.3.4",
+        userAgent: "test",
+        attemptedAt: now,
+      },
+      {
+        id: "22222222-2222-4222-8222-222222222222",
+        tenantId: tenantA,
+        result: "expired",
+        via: "token",
+        tokenHash: "def",
+        jobId: null,
+        attemptedByUserId: null,
+        ip: "1.2.3.4",
+        userAgent: "test",
+        attemptedAt: now,
+      },
+    ]);
+
+    const filtered = await stack.http.queryOk<{ rows: Array<{ result: string }> }>(
+      LIST_ATTEMPTS,
+      { result: "notFound" },
+      admin,
+    );
+    expect(filtered.rows.length).toBe(1);
+    expect(filtered.rows[0]?.result).toBe("notFound");
+  });
+});