feat: Filter und Paginierung für den Werkzeugkatalog, Claude Code als Katalogeintrag

Beide Katalog-Ansichten (Betreiber + Mandant) haben jetzt eine
Filterleiste (Freitext über Name/Anbieter/Verarbeitungsländer,
Zweck-Dropdown) und serverseitige Paginierung (20/Seite) über ein
GET-Formular, kein JavaScript. pagination.go ist generisch gehalten
(Go-Generics) für Wiederverwendung in weiteren Listen.

Claude Code als eigener Katalogeintrag ergänzt (nicht identisch mit
Claude for Work: läuft lokal, hat Dateizugriff, lokale Sitzungs-
protokolle mit eigenem Aufbewahrungsrisiko).

CLAUDE.md

@@ -39,8 +39,8 @@ Regelbasiert, nicht ML: die Ableitungsregeln (Datenklasse, KI-VO-
 Einstufung, Anforderungsprofil) liegen als versionierte YAML-Dateien
 vor, nicht im Code — ein fachlich Verantwortlicher soll sie anpassen
 können, ohne Go-Code anzufassen. Ein LLM ist v1 höchstens optional zur
-Zweckerkennung aus dem Freitext vorgesehen (Textgenerierung/Übersetzung/
+Zweckerkennung aus dem Freitext vorgesehen (die zwölf Zweck-Kategorien
-Code/Bild/Transkription/Recherche erkennen), nie für die Einstufung
+erkennen, siehe `gueltigeZwecke` weiter unten), nie für die Einstufung
 selbst — und auch dort nur als Vorschlag, den der Mensch bestätigt.
 
 ---
@@ -251,7 +251,7 @@ Sperrungen zentraler Einträge (`werkzeug_sperre`) führen, ohne den
 zentralen Katalog zu verändern.
 
 **Pflicht:** `letzte_pruefung` und `quelle` sind NOT NULL — jede
-Zusicherung im Katalog (AVV verfügbar, Verarbeitungsort, Training-Opt-
+Zusicherung im Katalog (AVV verfügbar, Verarbeitungsländer, Training-Opt-
 out, Zertifizierungen) muss belegbar sein, sonst haftet Deklarix für
 eine Aussage, die nicht nachweisbar ist. Beide Katalogansichten zeigen
 eine dreistufige Ampel zum Prüfalter (`pruefStatus()` in
@@ -269,13 +269,23 @@ aussahen — `formatAufbewahrung()` zeigt entsprechend "unbekannt" statt
 "0 Tage".
 
 `geeignete_zwecke` ist seit derselben Migration ein kontrolliertes
-Vokabular statt Freitext: das Formular zeigt Checkboxen für genau die
+Vokabular statt Freitext: das Formular zeigt Checkboxen statt eines
-sechs Zweck-Kategorien aus dem Fragebogen (Textgenerierung,
+Freitextfelds (`gueltigeZwecke` in `betreiber_werkzeug_handlers.go`,
-Übersetzung, Code, Bild, Transkription, Recherche — `gueltigeZwecke` in
+serverseitig validiert via `istGueltigerZweck`). Grund: ein künftiger
-`betreiber_werkzeug_handlers.go`), serverseitig validiert
+automatischer Zweckabgleich (Bewertungslogik Schritt 3, weiterhin nicht
-(`istGueltigerZweck`). Grund: ein künftiger automatischer Zweckabgleich
+gebaut) würde an inkonsistentem Freitext ("Text" statt
-(Bewertungslogik Schritt 3, weiterhin nicht gebaut) würde an
+"Textgenerierung") scheitern. Am 2026-08-31 von sechs auf zwölf
-inkonsistentem Freitext ("Text" statt "Textgenerierung") scheitern.
+Kategorien erweitert, nachdem der Nutzer zurecht einwandte, dass sechs
+Kategorien die tatsächliche Bandbreite an Einsatzgebieten nicht
+abdecken: Textgenerierung, Übersetzung, Code, Bild, Transkription,
+Recherche, **Datenanalyse, Video, Audio/Sprache,
+Kundenservice/Chatbot, Präsentation/Design, Automatisierung/Agenten**.
+Es gibt keinen einheitlichen Branchenstandard für KI-Funktions-
+kategorien (regulatorische Taxonomien wie die KI-VO selbst oder OECD/
+NIST klassifizieren nach Risiko, nicht nach Funktion; Marktplatz-
+Kategorien wie bei G2 sind Marketing, kein Standard) — diese zwölf
+sind Deklarix' eigene, bewusst begrenzte Liste für den künftigen
+Zweckabgleich, keine allgemeine KI-Taxonomie.
 
 Neues Feld `subprozessoren` (TEXT[], Migration 0015) macht
 Unterauftragsverarbeiter (z. B. Anthropic bei Microsoft 365 Copilot,
@@ -285,24 +295,94 @@ scheinbar EU-verarbeitetes Werkzeug die USA doch nicht ausschließt.
 
 Sowohl der zentrale Katalog (`GET /betreiber/werkzeuge`) als auch die
 mandantenseitige Sicht (`GET /verwaltung/werkzeuge`) zeigen den Katalog
-als Tabelle (Name, Anbieter, Verarbeitungsort, AVV, Training aus,
+als Tabelle (Name, Anbieter, Verarbeitungsländer, DPF, AVV, Training aus,
 Aufbewahrung, Zertifizierungen, Geeignete Zwecke, Zuletzt geprüft) statt
 als Liste — vorher waren nur Name/Anbieter/Ort auf einen Blick sichtbar,
 der Rest war erst nach Klick auf den Detaileintrag zu sehen.
 
-Der zentrale Katalog ist aktuell mit 10 recherchierten Einträgen befüllt
+**Filter & Paginierung** (seit 2026-08-31, `pagination.go` +
-(ChatGPT Enterprise, Microsoft 365 Copilot, Claude for Work, GitHub
+`werkzeugFilter` in `betreiber_werkzeug_handlers.go`): beide
-Copilot Business, DeepL Pro/API, Google Gemini für Google Workspace,
+Katalog-Tabellen haben eine Filterleiste (Freitext über Name/Anbieter/
-Le Chat Enterprise, Perplexity Enterprise Pro, Adobe Firefly Enterprise,
+Verarbeitungsländer, Dropdown über die zwölf Zweck-Kategorien) und
-Otter.ai Business) — deckt damit erstmals alle sechs Zweck-Kategorien
+serverseitige Paginierung (20 Einträge/Seite, `page`-Query-Parameter).
-ab (vorher fehlten Bild und Transkription vollständig, Recherche hatte
+Alles über ein einziges GET-Formular, ohne JavaScript — Prev/Next-
-kein dediziertes Werkzeug). Jede Zusicherung ist mit einer echten,
+Buttons setzen `page` per `<button type="submit" name="page"
+value="...">`, damit q/zweck beim Blättern erhalten bleiben. Auf der
+Mandanten-Seite (die pro Zeile zusätzlich Sperren/Entsperren-Formulare
+hat) sind Filter und Paginierungs-Buttons bewusst in getrennte
+`<form>`-Elemente aufgeteilt statt in eines um die ganze Tabelle —
+verschachtelte `<form>`-Elemente sind ungültiges HTML, die
+Paginierungs-Buttons tragen `q`/`zweck` deshalb als Hidden-Felder
+nach. `pagination.go` ist bewusst generisch (Go-Generics,
+`paginate[T any]`) für Wiederverwendung in weiteren Listen (Register,
+Fälle, ...) — bisher nur auf den Werkzeugkatalog angewendet, das war
+die von den beiden am dringendsten wachsende Tabelle.
+
+Der zentrale Katalog ist aktuell mit 20 recherchierten Einträgen
+befüllt (u. a. ChatGPT Enterprise, Microsoft 365 Copilot, Claude for
+Work, Claude Code, GitHub Copilot Business, DeepL Pro/API, Google
+Gemini für Google Workspace, Le Chat Enterprise, Perplexity Enterprise
+Pro, Adobe Firefly Enterprise, Otter.ai Business, Notion AI, Grammarly
+Business, Midjourney, Julius AI, Synthesia, ElevenLabs, Zendesk AI,
+Canva Magic Studio, Zapier) — deckt damit alle zwölf Zweck-Kategorien mit
+mindestens einem Eintrag ab. **Claude Code ist bewusst ein eigener
+Eintrag neben Claude for Work**, kein Duplikat: es läuft lokal auf
+Entwicklerrechnern mit direktem Zugriff auf Dateien/Codebasen und
+speichert Sitzungsprotokolle lokal im Klartext (bis zu 30 Tage,
+konfigurierbar) — ein zusätzliches lokales Aufbewahrungsrisiko, das bei
+einer reinen Web-Chat-Anwendung wie Claude for Work nicht existiert,
+obwohl beide über dieselben Commercial Terms/DPA laufen. Jede
+Zusicherung ist mit einer echten,
 offiziellen Anbieter-Quelle belegt (Stand 2026-08-31), nicht geraten —
-zwei Einträge (Adobe Firefly: Trainingsausschluss ist nicht Standard;
+und zwar auch dann, wenn keine Quelle eine positive Zusicherung
-Otter.ai: Training auf de-identifizierten Aufnahmen, laufende
+hergibt: Synthesia und Zapier haben `training_standard`/
-Rechtsstreitigkeiten) sind bewusst mit kritischen Einschränkungen
+`training_opt_out` bewusst NICHT gesetzt, weil keine belegte Aussage
-versehen statt schöngefärbt, das ist die vorgesehene Funktion des
+zum Trainingsausschluss gefunden wurde (nicht mit "trainiert
-Katalogs.
+nachweislich" verwechseln — es ist ein "wissen wir nicht, deshalb
+keine Haken"). Mehrere Einträge sind bewusst mit kritischen
+Einschränkungen versehen statt schöngefärbt, das ist die vorgesehene
+Funktion des Katalogs: Adobe Firefly (Trainingsausschluss ist nicht
+Standard), Otter.ai (Training auf de-identifizierten Aufnahmen,
+laufende Rechtsstreitigkeiten), **Midjourney (kein AVV, keine
+EU-Datenresidenz, unbegrenzte Speicherung inkl. Training — laut
+CLAUDE.md-Leitplanken für personenbezogene/vertrauliche Daten nicht
+geeignet, absichtlich als Negativbeispiel im Katalog, nicht
+weggelassen)**.
+
+**Schema-Lücke behoben (2026-08-31, Migration 0016):** der grobe
+`verarbeitungsort`-Eimer (`EU`/`USA`/`gemischt`/`on-prem`) wurde durch
+`verarbeitungslaender TEXT[]` ersetzt — echte Länder statt Buckets.
+Grund: "USA" war schon immer ein Drittland im Sinne der DSGVO (Art. 44
+ff.) wie jedes andere auch, das Wort "Drittland" für einen fünften
+Bucket-Wert wäre also verwirrend gewesen, nicht erhellend. Das Formular
+bietet dafür eine echte Weltländerliste (`weltLaenderliste` in
+`laenderliste.go`, `<select multiple>`, Mehrfachauswahl per Strg/Cmd-
+Klick — kein JavaScript nötig) plus zwei Pseudo-Einträge ("EU-Region
+(kein einzelnes Land benannt)" für Anbieter, die nur eine Region statt
+eines Staates zusichern, z. B. Microsofts EU Data Boundary; "On-Premise
+(selbst gehostet)"). Der harte Filter `eu_verarbeitung`
+(`internal/rules/evaluate.go`, `alleLaenderInEUEWR`) verlangt jetzt,
+dass ALLE genannten Länder EU/EWR-Mitgliedstaaten sind — eine leere
+Liste gilt als nicht erfüllt, nicht als Freifahrtschein. Zusätzlich neues
+Feld `dpf_zertifiziert` (Checkbox "EU-US Data Privacy Framework
+zertifiziert"): DPF ist eine schmalere, gerichtlich schon zweimal
+gekippte Rechtsgrundlage (Safe Harbor, Privacy Shield) für USA-Transfers,
+bisher nur als Fließtext in "Einschränkungen" erwähnt, jetzt strukturiert
+und damit künftig filterbar. Alle 19 Katalogeinträge wurden mit den
+tatsächlichen, bereits recherchierten Ländern nachgepflegt (z. B.
+Mistral → Frankreich, DeepL → Deutschland, Synthesia → Irland, Claude
+for Work → USA) statt der pauschalen alten Buckets.
+
+Das öffnet jetzt auch DeepSeek (Verarbeitung in China) für einen
+künftigen Katalogeintrag — die Sperre lag ausschließlich am alten
+Wertebereich, nicht an einer fachlichen Entscheidung.
+
+**Offen:** `dpf_zertifiziert` ist bei allen 19 Einträgen noch `false` —
+für keinen wurde bisher gezielt recherchiert, ob der jeweilige
+US-Anbieter tatsächlich DPF-zertifiziert ist (das Feld wurde erst mit
+dieser Migration eingeführt, `false` heißt hier "nicht recherchiert",
+nicht "nachweislich nicht zertifiziert"). Nachrecherche pro Anbieter
+noch zu tun.
 
 `CurrentKatalogVersion` liefert eine reproduzierbare Kennung des
 aktuellen Katalogzustands (Anzahl Einträge + letzte Änderung) — wird in
@@ -319,8 +399,8 @@ bleibt, mit welchem Katalogstand ein Vorschlag erzeugt wurde.
    nicht erfüllen — Grund je Werkzeug festhalten, auch aussortierte
    Werkzeuge werden im Ergebnis mit Begründung gezeigt.
 3. **Zweckabgleich.** Aus `beschreibung`/`ergebnis` den Zweck ableiten
-   (Textgenerierung, Übersetzung, Code, Bild, Transkription, Recherche)
+   (die zwölf Kategorien aus `gueltigeZwecke`, siehe Werkzeugkatalog
-   und gegen `geeignete_zwecke` filtern.
+   weiter unten) und gegen `geeignete_zwecke` filtern.
 4. **Rangfolge.** Verbleibende Werkzeuge sortieren: EU-Verarbeitung,
    Training standardmäßig aus, kurze Aufbewahrung, Aktualität der
    Prüfung.
@@ -378,7 +458,7 @@ wenn mindestens einer zutrifft: (1) `gueltig_bis` ist erreicht oder
 liegt innerhalb von 30 Tagen, (2) das zugesagte Werkzeug wurde aus dem
 Katalog entfernt, (3) `werkzeugDiff` erkennt eine Abweichung zwischen
 dem eingefrorenen `werkzeug_snapshot` und dem aktuellen Katalogeintrag
-bei AVV-Verfügbarkeit, Training-Standard oder Verarbeitungsort. Keine
+bei AVV-Verfügbarkeit, Training-Standard oder Verarbeitungsländern. Keine
 gefundene Abweichung → die Genehmigung erscheint nicht (kein stiller
 Blanko-Eintrag für jede Genehmigung). `store.ListAktiveGenehmigungenForAccount`
 liefert dafür alle `genehmigt`/`genehmigt_mit_auflagen`-Entscheidungen
@@ -467,7 +547,56 @@ kein separates Desktop-Template.
 **Tabellen** (`table`/`th`/`td` in `app.css`) sind seit dieser Änderung
 gestylt (vorher komplett ungestylt, betraf v. a. `register_liste.html`);
 breite Tabellen stehen in einem `.table-scroll`-Wrapper (horizontales
-Scrollen auf dem Handy statt gequetschter Spalten).
+Scrollen auf dem Handy statt gequetschter Spalten). Seit 2026-08-31 hat
+`.table-scroll` zusätzlich einen rechten Fade-Rand (`mask-image`) —
+ohne den sah eine am Fensterrand abgeschnittene breite Tabelle wie ein
+Rendering-Fehler aus statt wie "hier geht's mit Scrollen weiter" (per
+Screenshot am Werkzeugkatalog beobachtet: die letzten zwei Spalten
+waren nur als einzelne Buchstaben sichtbar, ganz ohne Hinweis auf mehr
+Inhalt).
+
+**Formulare** (`.form-card`/`.form-section`/`.form-grid`/`.chip-group`
+in `app.css`, seit 2026-08-31, erstmals angewendet auf
+`betreiber_werkzeug_form.html`): vorher war jedes Formular eine flache
+Spalte aus `<label>`+`<input>` ohne Gruppierung — bei einem Formular
+mit über einem Dutzend Feldern (Werkzeug anlegen) wirkte das "klobig,
+einfach nur untereinander" (O-Ton Nutzer). Jetzt: `.form-card` (weiße
+Karte mit Rahmen/Schatten, Ant-Design-Tokens aus `design/enterprise.css`
+übernommen) enthält mehrere `<fieldset class="form-section">`
+(thematische Abschnitte mit Titel, per `border-top` getrennt), darin
+`.form-grid` (2 Spalten ab 640px für kurze Felder wie Name/Anbieter
+nebeneinander, `.form-full` erzwingt volle Breite für lange Felder).
+Checkbox-Gruppen mit überschaubar vielen Optionen (Zusicherungen, die
+zwölf Zwecke) sind `.chip-group` — abgerundete Pillen statt einer
+langen Untereinander-Liste, ausgewählte Chips werden über
+`:has(input:checked)` blau hervorgehoben (kein JavaScript). Ein
+Löschen-Button steht nicht mehr einfach unter dem Formular, sondern in
+einer abgesetzten `.form-gefahrenzone`-Fußzeile der Karte. Dieselben
+Klassen sind bewusst generisch (nicht an ein Formular gebunden) — noch
+nicht auf andere Formulare (Login/Registrierung, Fragebogen, übrige
+Admin-Formulare) angewendet, das wäre der nächste Schritt, falls
+gewünscht. Beim Umbau auffällig gewordener, vorbestehender Bug: das
+Lösch-Formular in `betreiber_werkzeug_form.html` war fest auf
+`/betreiber/werkzeuge/{id}/loeschen` verdrahtet, obwohl dieselbe
+Vorlage auch vom Mandanten-Formular (`/verwaltung/werkzeuge/...`)
+genutzt wird — ein Mandant hätte beim Löschen eines eigenen Werkzeugs
+403 bekommen. Jetzt `{{.ActionBase}}/{{.ID}}/loeschen`, wie die
+Formular-`action` selbst.
+
+**Typografie-Nachbesserung (2026-08-31):** Nutzer-Feedback nach dem
+ersten Formular-Redesign: Überschriften wirkten zu klein und zu dicht
+am Rand. Ursache für Letzteres: `<legend>` in `<fieldset
+class="form-section">` positioniert sich per Spec an der Border-Box
+des Fieldsets, nicht an dessen Padding-Box — ohne eigenes Padding sitzt
+die Abschnittsüberschrift optisch enger am Kartenrand als der übrige,
+per `.form-section { padding: 20px }` eingerückte Inhalt. `.form-section
+> legend` hat jetzt selbst `padding: 0 0 16px 0` und eine größere
+Schrift (1.0625rem/700 statt 0.9375rem/600). Gleichzeitig `h2`
+(1.25rem) und `h3` (1.0625rem) erstmals explizit gesetzt (vorher reiner
+Browser-Default) und `.fragebogen legend` auf dieselbe Gewichtsstufe
+wie die Formular-Abschnitte angehoben (600/1rem statt 500/0.9375rem) —
+für eine einheitliche Überschriften-Hierarchie statt Zufallsgrößen je
+nach UA-Stylesheet.
 
 **Verifikationsmethode für CSS-Änderungen:** Live-Cookie-Auth per
 Chromium-Headless/CDP ist im Sandbox-Environment nicht möglich (kein

internal/rules/evaluate.go

@@ -187,12 +187,48 @@ func containsString(list []string, v string) bool {
 // unabhängig von internal/store und für sich allein testbar.
 type WerkzeugEigenschaften struct {
 	AVVVerfuegbar bool
-	Verarbeitungsort string
+	// Verarbeitungslaender nennt die tatsächlichen Länder statt eines
+	// groben "EU"/"USA"-Eimers (siehe CLAUDE.md, Werkzeugkatalog) — die
+	// eu_verarbeitung-Anforderung gilt nur als erfüllt, wenn ALLE
+	// genannten Länder EU/EWR-Mitgliedstaaten sind.
+	Verarbeitungslaender []string
 	TrainingOptOut       bool
 	TrainingStandard     bool
 	AufbewahrungTage     int
 }
 
+// euEwrLaender sind die Staaten, für die eine Verarbeitung nicht als
+// Drittlandtransfer gilt (Art. 44 ff. DSGVO) — die 27 EU-Mitgliedstaaten
+// plus die drei über den EWR-Vertrag gleichgestellten Staaten. Die USA
+// gehören bewusst NICHT dazu — sie sind ein Drittland wie jedes andere,
+// unabhängig vom EU-US Data Privacy Framework (das mildert die
+// Transfer-Grundlage, macht die USA aber nicht zum EU/EWR-Gebiet).
+var euEwrLaender = map[string]bool{
+	"Belgien": true, "Bulgarien": true, "Dänemark": true, "Deutschland": true,
+	"Estland": true, "Finnland": true, "Frankreich": true, "Griechenland": true,
+	"Irland": true, "Italien": true, "Kroatien": true, "Lettland": true,
+	"Litauen": true, "Luxemburg": true, "Malta": true, "Niederlande": true,
+	"Österreich": true, "Polen": true, "Portugal": true, "Rumänien": true,
+	"Schweden": true, "Slowakei": true, "Slowenien": true, "Spanien": true,
+	"Tschechien": true, "Ungarn": true, "Zypern": true,
+	"Island": true, "Liechtenstein": true, "Norwegen": true,
+}
+
+// alleLaenderInEUEWR prüft, ob jedes genannte Land EU/EWR ist. Eine
+// leere Liste (kein Land benannt) gilt als NICHT erfüllt — "wissen wir
+// nicht" darf nie stillschweigend als "ist okay" durchgehen.
+func alleLaenderInEUEWR(laender []string) bool {
+	if len(laender) == 0 {
+		return false
+	}
+	for _, l := range laender {
+		if !euEwrLaender[l] {
+			return false
+		}
+	}
+	return true
+}
+
 // ErfuelltAnforderung prüft, ob ein Werkzeug eine einzelne Anforderung
 // erfüllt. Anforderungen, die einen Prozess statt eine technische
 // Werkzeug-Eigenschaft betreffen (menschliche Aufsicht, Kennzeichnung,
@@ -206,7 +242,7 @@ func ErfuelltAnforderung(anforderungID string, w WerkzeugEigenschaften) bool {
 	case "avv_erforderlich":
 		return w.AVVVerfuegbar
 	case "eu_verarbeitung":
-		return w.Verarbeitungsort == "EU"
+		return alleLaenderInEUEWR(w.Verarbeitungslaender)
 	case "kein_training_auf_eingabe":
 		return w.TrainingStandard
 	default:

internal/rules/evaluate_test.go

@@ -158,6 +158,21 @@ func TestErfuelltAnforderungAVV(t *testing.T) {
 	}
 }
 
+func TestErfuelltAnforderungEUVerarbeitung(t *testing.T) {
+	if !rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland"}}) {
+		t.Error("erwartet: erfuellt bei einem einzelnen EU/EWR-Land")
+	}
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"USA"}}) {
+		t.Error("erwartet: nicht erfuellt bei USA - die USA sind ein Drittland wie jedes andere")
+	}
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{Verarbeitungslaender: []string{"Irland", "USA"}}) {
+		t.Error("erwartet: nicht erfuellt, sobald auch nur ein Land nicht EU/EWR ist")
+	}
+	if rules.ErfuelltAnforderung("eu_verarbeitung", rules.WerkzeugEigenschaften{}) {
+		t.Error("erwartet: nicht erfuellt ohne benanntes Land - 'wissen wir nicht' darf nicht als 'ist okay' durchgehen")
+	}
+}
+
 func TestErfuelltAnforderungUnbekannteAnforderungIstUnkritisch(t *testing.T) {
 	if !rules.ErfuelltAnforderung("menschliche_aufsicht", rules.WerkzeugEigenschaften{}) {
 		t.Error("Prozess-Anforderungen duerfen ein Werkzeug nicht hart aussortieren")
@@ -166,8 +181,8 @@ func TestErfuelltAnforderungUnbekannteAnforderungIstUnkritisch(t *testing.T) {
 
 func TestFilterWerkzeugeSortsOutMissingAVV(t *testing.T) {
 	kandidaten := []rules.WerkzeugKandidat{
-		{ID: "mit-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: true, Verarbeitungsort: "EU", TrainingStandard: true}},
+		{ID: "mit-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: true, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
-		{ID: "ohne-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: false, Verarbeitungsort: "EU", TrainingStandard: true}},
+		{ID: "ohne-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: false, Verarbeitungslaender: []string{"Deutschland"}, TrainingStandard: true}},
 	}
 	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, []string{"avv_erforderlich"})
 	if len(zulaessig) != 1 || zulaessig[0] != "mit-avv" {

internal/store/migrations/0016_werkzeug_verarbeitungslaender.down.sql

@@ -0,0 +1,20 @@
+ALTER TABLE werkzeug ADD COLUMN verarbeitungsort TEXT;
+
+-- Ein Rückbau von Freitext-Ländern auf den alten Vier-Werte-Eimer ist
+-- verlustbehaftet (welches Land genau "gemischt" war, geht verloren) —
+-- bestmögliche Näherung statt Datenverlust durch NULL.
+UPDATE werkzeug SET verarbeitungsort =
+  CASE
+    WHEN verarbeitungslaender = ARRAY['On-Premise (selbst gehostet)'] THEN 'on-prem'
+    WHEN verarbeitungslaender = ARRAY['USA'] THEN 'USA'
+    WHEN array_length(verarbeitungslaender, 1) IS NULL OR array_length(verarbeitungslaender, 1) = 0 THEN 'gemischt'
+    WHEN 'USA' = ANY(verarbeitungslaender) THEN 'gemischt'
+    ELSE 'EU'
+  END;
+
+ALTER TABLE werkzeug ALTER COLUMN verarbeitungsort SET NOT NULL;
+ALTER TABLE werkzeug ADD CONSTRAINT werkzeug_verarbeitungsort_check
+  CHECK (verarbeitungsort IN ('EU', 'USA', 'gemischt', 'on-prem'));
+
+ALTER TABLE werkzeug DROP COLUMN verarbeitungslaender;
+ALTER TABLE werkzeug DROP COLUMN dpf_zertifiziert;

internal/store/migrations/0016_werkzeug_verarbeitungslaender.up.sql

@@ -0,0 +1,29 @@
+-- "EU"/"USA"/"gemischt"/"on-prem" als grobe Eimer verschleierten, dass
+-- auch die USA bereits ein Drittland sind (DSGVO Art. 44 ff. kennt nur
+-- EU/EWR vs. Drittland) und dass "gemischt" nichts über die tatsächlich
+-- beteiligten Länder aussagt (z. B. Irland+USA bei Microsoft 365
+-- Copilot vs. Frankreich bei Mistral) — beides macht einen Unterschied
+-- für die Einschätzung, nicht nur für die Anzeige. Ersetzt durch eine
+-- Liste tatsächlicher Länder (oder einer Region, wenn der Anbieter
+-- selbst keinen einzelnen Staat benennt, z. B. "EU-Region" bei
+-- OpenAI/Microsoft).
+ALTER TABLE werkzeug ADD COLUMN verarbeitungslaender TEXT[] NOT NULL DEFAULT '{}';
+
+ALTER TABLE werkzeug DROP CONSTRAINT werkzeug_verarbeitungsort_check;
+
+UPDATE werkzeug SET verarbeitungslaender =
+  CASE verarbeitungsort
+    WHEN 'EU' THEN ARRAY['EU-Region (Land nicht migriert, bitte prüfen)']
+    WHEN 'USA' THEN ARRAY['USA']
+    WHEN 'on-prem' THEN ARRAY['On-Premise (selbst gehostet)']
+    ELSE ARRAY['nicht spezifiziert (bitte prüfen)']
+  END;
+
+ALTER TABLE werkzeug DROP COLUMN verarbeitungsort;
+
+-- Ob ein US-Anbieter unter dem EU-US Data Privacy Framework zertifiziert
+-- ist (schmalere, für Schrems-Nachfolgeverfahren anfällige Rechtsgrundlage)
+-- oder sich rein auf Standardvertragsklauseln stützt, stand bisher nur als
+-- Fließtext in "einschraenkungen" — jetzt strukturiert und damit künftig
+-- filterbar.
+ALTER TABLE werkzeug ADD COLUMN dpf_zertifiziert BOOLEAN NOT NULL DEFAULT false;

internal/store/werkzeug.go

@@ -20,11 +20,23 @@ type Werkzeug struct {
 	AccountID *string
 	Name      string
 	Anbieter  string
-	Verarbeitungsort string
+	// Verarbeitungslaender nennt die tatsächlichen Länder (oder, wenn
+	// der Anbieter selbst keinen einzelnen Staat zusichert, eine Region
+	// wie "EU-Region") statt eines groben EU/USA/gemischt-Eimers — die
+	// USA sind DSGVO-rechtlich bereits ein Drittland wie jedes andere,
+	// "gemischt" verschleierte, welche Länder konkret beteiligt sind.
+	Verarbeitungslaender []string
 	AVVVerfuegbar        bool
 	AVVURL               string
 	TrainingOptOut       bool
 	TrainingStandard     bool
+	// DPFZertifiziert: EU-US Data Privacy Framework — schmalere,
+	// gerichtlich schon zweimal gekippte Rechtsgrundlage (Safe Harbor,
+	// Privacy Shield) für Transfers in die USA, gilt nur für zertifizierte
+	// Unternehmen. false bedeutet nicht "nicht zertifiziert" im Sinne von
+	// widerlegt, sondern "nicht als Zusicherung belegt" — wie bei den
+	// übrigen Booleans hier.
+	DPFZertifiziert  bool
 	AufbewahrungTage *int // nil = vom Anbieter nicht beziffert, NICHT gleichbedeutend mit 0 Tagen
 	Zertifizierungen []string
 	Subprozessoren   []string
@@ -43,11 +55,12 @@ type WerkzeugInput struct {
 	AccountID            *string
 	Name                 string
 	Anbieter             string
-	Verarbeitungsort string
+	Verarbeitungslaender []string
 	AVVVerfuegbar        bool
 	AVVURL               string
 	TrainingOptOut       bool
 	TrainingStandard     bool
+	DPFZertifiziert      bool
 	AufbewahrungTage     *int
 	Zertifizierungen     []string
 	Subprozessoren       []string
@@ -57,8 +70,8 @@ type WerkzeugInput struct {
 	Quelle               string
 }
 
-const werkzeugColumns = `id, account_id, name, anbieter, verarbeitungsort, avv_verfuegbar, avv_url,
+const werkzeugColumns = `id, account_id, name, anbieter, verarbeitungslaender, avv_verfuegbar, avv_url,
-	training_opt_out, training_standard, aufbewahrung_tage, zertifizierungen, subprozessoren,
+	training_opt_out, training_standard, dpf_zertifiziert, aufbewahrung_tage, zertifizierungen, subprozessoren,
 	geeignete_zwecke, einschraenkungen, letzte_pruefung, quelle, created_at, updated_at`
 
 func scanWerkzeug(row interface {
@@ -66,8 +79,8 @@ func scanWerkzeug(row interface {
 }) (Werkzeug, error) {
 	var w Werkzeug
 	err := row.Scan(
-		&w.ID, &w.AccountID, &w.Name, &w.Anbieter, &w.Verarbeitungsort, &w.AVVVerfuegbar, &w.AVVURL,
+		&w.ID, &w.AccountID, &w.Name, &w.Anbieter, &w.Verarbeitungslaender, &w.AVVVerfuegbar, &w.AVVURL,
-		&w.TrainingOptOut, &w.TrainingStandard, &w.AufbewahrungTage, &w.Zertifizierungen, &w.Subprozessoren,
+		&w.TrainingOptOut, &w.TrainingStandard, &w.DPFZertifiziert, &w.AufbewahrungTage, &w.Zertifizierungen, &w.Subprozessoren,
 		&w.GeeigneteZwecke, &w.Einschraenkungen, &w.LetztePruefung, &w.Quelle, &w.CreatedAt, &w.UpdatedAt,
 	)
 	return w, err
@@ -79,6 +92,9 @@ func scanWerkzeug(row interface {
 // einer wenig hilfreichen Constraint-Fehlermeldung abgelehnt (derselbe
 // Fall wie früher bei finding.sources).
 func normalizeWerkzeugSlices(in *WerkzeugInput) {
+	if in.Verarbeitungslaender == nil {
+		in.Verarbeitungslaender = []string{}
+	}
 	if in.Zertifizierungen == nil {
 		in.Zertifizierungen = []string{}
 	}
@@ -98,13 +114,13 @@ func (s *Store) CreateWerkzeug(ctx context.Context, in WerkzeugInput) (Werkzeug,
 	normalizeWerkzeugSlices(&in)
 	row := s.Pool.QueryRow(ctx, `
 		INSERT INTO werkzeug (
-			account_id, name, anbieter, verarbeitungsort, avv_verfuegbar, avv_url,
+			account_id, name, anbieter, verarbeitungslaender, avv_verfuegbar, avv_url,
-			training_opt_out, training_standard, aufbewahrung_tage, zertifizierungen, subprozessoren,
+			training_opt_out, training_standard, dpf_zertifiziert, aufbewahrung_tage, zertifizierungen, subprozessoren,
 			geeignete_zwecke, einschraenkungen, letzte_pruefung, quelle
-		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
 		RETURNING `+werkzeugColumns,
-		in.AccountID, in.Name, in.Anbieter, in.Verarbeitungsort, in.AVVVerfuegbar, in.AVVURL,
+		in.AccountID, in.Name, in.Anbieter, in.Verarbeitungslaender, in.AVVVerfuegbar, in.AVVURL,
-		in.TrainingOptOut, in.TrainingStandard, in.AufbewahrungTage, in.Zertifizierungen, in.Subprozessoren,
+		in.TrainingOptOut, in.TrainingStandard, in.DPFZertifiziert, in.AufbewahrungTage, in.Zertifizierungen, in.Subprozessoren,
 		in.GeeigneteZwecke, in.Einschraenkungen, in.LetztePruefung, in.Quelle,
 	)
 	w, err := scanWerkzeug(row)
@@ -123,14 +139,14 @@ func (s *Store) UpdateWerkzeug(ctx context.Context, id string, in WerkzeugInput)
 	normalizeWerkzeugSlices(&in)
 	row := s.Pool.QueryRow(ctx, `
 		UPDATE werkzeug SET
-			name = $2, anbieter = $3, verarbeitungsort = $4, avv_verfuegbar = $5, avv_url = $6,
+			name = $2, anbieter = $3, verarbeitungslaender = $4, avv_verfuegbar = $5, avv_url = $6,
-			training_opt_out = $7, training_standard = $8, aufbewahrung_tage = $9,
+			training_opt_out = $7, training_standard = $8, dpf_zertifiziert = $9, aufbewahrung_tage = $10,
-			zertifizierungen = $10, subprozessoren = $11, geeignete_zwecke = $12, einschraenkungen = $13,
+			zertifizierungen = $11, subprozessoren = $12, geeignete_zwecke = $13, einschraenkungen = $14,
-			letzte_pruefung = $14, quelle = $15, updated_at = now()
+			letzte_pruefung = $15, quelle = $16, updated_at = now()
 		WHERE id = $1
 		RETURNING `+werkzeugColumns,
-		id, in.Name, in.Anbieter, in.Verarbeitungsort, in.AVVVerfuegbar, in.AVVURL,
+		id, in.Name, in.Anbieter, in.Verarbeitungslaender, in.AVVVerfuegbar, in.AVVURL,
-		in.TrainingOptOut, in.TrainingStandard, in.AufbewahrungTage, in.Zertifizierungen, in.Subprozessoren,
+		in.TrainingOptOut, in.TrainingStandard, in.DPFZertifiziert, in.AufbewahrungTage, in.Zertifizierungen, in.Subprozessoren,
 		in.GeeigneteZwecke, in.Einschraenkungen, in.LetztePruefung, in.Quelle,
 	)
 	w, err := scanWerkzeug(row)

internal/store/werkzeug_test.go

@@ -16,7 +16,7 @@ func testWerkzeugInput(accountID *string, name string) store.WerkzeugInput {
 		AccountID:            accountID,
 		Name:                 name,
 		Anbieter:             "Beispiel-Anbieter GmbH",
-		Verarbeitungsort: "EU",
+		Verarbeitungslaender: []string{"Deutschland"},
 		AVVVerfuegbar:        true,
 		AVVURL:               "https://beispiel.example/avv",
 		TrainingOptOut:       true,

internal/web/antrag_handlers.go

@@ -294,7 +294,7 @@ func (s *Server) bewerteAntrag(ctx context.Context, antragID, accountID string,
 				aufbewahrungTage = *w.AufbewahrungTage
 			}
 			kandidaten[i] = rules.WerkzeugKandidat{ID: w.ID, Eigenschaften: rules.WerkzeugEigenschaften{
-				AVVVerfuegbar: w.AVVVerfuegbar, Verarbeitungsort: w.Verarbeitungsort,
+				AVVVerfuegbar: w.AVVVerfuegbar, Verarbeitungslaender: w.Verarbeitungslaender,
 				TrainingOptOut: w.TrainingOptOut, TrainingStandard: w.TrainingStandard, AufbewahrungTage: aufbewahrungTage,
 			}}
 		}

internal/web/betreiber_werkzeug_handlers.go

@@ -14,11 +14,57 @@ import (
 	"github.com/netcell-it/deklarix/internal/store"
 )
 
-var gueltigeVerarbeitungsorte = []string{"EU", "USA", "gemischt", "on-prem"}
+// werkzeugFilter bündelt die Filterkriterien für die Katalog-Listen
+// (Betreiber wie Mandant) — ein einziges GET-Formular setzt "q"
+// (Freitext über Name/Anbieter/Länder) und optional "zweck".
+type werkzeugFilter struct {
+	Suche string
+	Zweck string
+}
 
-func istGueltigerVerarbeitungsort(v string) bool {
+func werkzeugFilterFromRequest(r *http.Request) werkzeugFilter {
-	for _, o := range gueltigeVerarbeitungsorte {
+	return werkzeugFilter{
-		if o == v {
+		Suche: strings.TrimSpace(r.URL.Query().Get("q")),
+		Zweck: r.URL.Query().Get("zweck"),
+	}
+}
+
+// Aktiv meldet, ob mindestens ein Filter gesetzt ist — steuert, ob ein
+// "Zurücksetzen"-Link angezeigt wird. Exportiert, weil html/template
+// nur exportierte Methoden per Reflection aufrufen kann.
+func (f werkzeugFilter) Aktiv() bool {
+	return f.Suche != "" || f.Zweck != ""
+}
+
+func (f werkzeugFilter) matches(wz store.Werkzeug) bool {
+	if f.Zweck != "" {
+		gefunden := false
+		for _, z := range wz.GeeigneteZwecke {
+			if z == f.Zweck {
+				gefunden = true
+				break
+			}
+		}
+		if !gefunden {
+			return false
+		}
+	}
+	if f.Suche != "" {
+		q := strings.ToLower(f.Suche)
+		heuhaufen := strings.ToLower(wz.Name + " " + wz.Anbieter + " " + strings.Join(wz.Verarbeitungslaender, " "))
+		if !strings.Contains(heuhaufen, q) {
+			return false
+		}
+	}
+	return true
+}
+
+// istGueltigesLand validiert gegen weltLaenderliste (laenderliste.go)
+// — dieselbe kontrollierte-Vokabular-Logik wie bei istGueltigerZweck,
+// nur für Verarbeitungsländer statt Zwecke.
+func istGueltigesLand(v string) bool {
+	for _, l := range weltLaenderliste {
+		if l == v {
 			return true
 		}
 	}
@@ -26,12 +72,17 @@ func istGueltigerVerarbeitungsort(v string) bool {
 }
 
 // gueltigeZwecke ist das kontrollierte Vokabular für "geeignete Zwecke"
-// — exakt die sechs Zweck-Kategorien aus dem Fragebogen/der geplanten
+// (siehe CLAUDE.md, Bewertungslogik Schritt 3). Vorher war das Feld
-// Zweckabgleich-Stufe (siehe CLAUDE.md, Bewertungslogik Schritt 3).
+// Freitext; ein Tippfehler ("Text" statt "Textgenerierung") hätte den
-// Vorher war das Feld Freitext; ein Tippfehler ("Text" statt
+// künftigen automatischen Zweckabgleich unbemerkt kaputt gemacht. Am
-// "Textgenerierung") hätte den künftigen automatischen Zweckabgleich
+// 2026-08-31 von sechs auf zwölf Kategorien erweitert (bewusste
-// unbemerkt kaputt gemacht.
+// v1-Scope-Entscheidung überarbeitet, nicht stillschweigend geändert)
-var gueltigeZwecke = []string{"Textgenerierung", "Übersetzung", "Code", "Bild", "Transkription", "Recherche"}
+// — die ursprünglichen sechs deckten nur klassische Wissensarbeit ab,
+// nicht Datenanalyse/Video/Audio/Kundenservice/Design/Automatisierung.
+var gueltigeZwecke = []string{
+	"Textgenerierung", "Übersetzung", "Code", "Bild", "Transkription", "Recherche",
+	"Datenanalyse", "Video", "Audio/Sprache", "Kundenservice/Chatbot", "Präsentation/Design", "Automatisierung/Agenten",
+}
 
 func istGueltigerZweck(v string) bool {
 	for _, z := range gueltigeZwecke {
@@ -60,7 +111,8 @@ type werkzeugListItem struct {
 	ID                   string
 	Name                 string
 	Anbieter             string
-	Verarbeitungsort string
+	Verarbeitungslaender string
+	DPFZertifiziert      bool
 	AVVVerfuegbar        bool
 	TrainingStandard     bool
 	Aufbewahrung         string
@@ -88,6 +140,9 @@ type werkzeugListeData struct {
 	Title          string
 	Nav            navData
 	Werkzeuge      []werkzeugListItem
+	Filter         werkzeugFilter
+	ZweckeOptionen []string
+	Pagination     pagination
 }
 
 // werkzeugPruefungVeraltetNach ist die Schwelle, ab der ein
@@ -125,11 +180,25 @@ func (s *Server) handleBetreiberWerkzeugListe(w http.ResponseWriter, r *http.Req
 		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	data := werkzeugListeData{Title: "Werkzeugkatalog", Nav: navFor(r)}
+	filter := werkzeugFilterFromRequest(r)
+	var gefiltert []store.Werkzeug
 	for _, wz := range werkzeuge {
+		if filter.matches(wz) {
+			gefiltert = append(gefiltert, wz)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	seite := paginate(gefiltert, pag)
+
+	data := werkzeugListeData{
+		Title: "Werkzeugkatalog", Nav: navFor(r),
+		Filter: filter, ZweckeOptionen: gueltigeZwecke, Pagination: pag,
+	}
+	for _, wz := range seite {
 		label, css := pruefStatus(wz.LetztePruefung)
 		data.Werkzeuge = append(data.Werkzeuge, werkzeugListItem{
-			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungslaender: strings.Join(wz.Verarbeitungslaender, ", "),
+			DPFZertifiziert: wz.DPFZertifiziert,
 			AVVVerfuegbar:   wz.AVVVerfuegbar, TrainingStandard: wz.TrainingStandard,
 			Aufbewahrung:     formatAufbewahrung(wz.AufbewahrungTage),
 			Zertifizierungen: strings.Join(wz.Zertifizierungen, ", "), GeeigneteZwecke: strings.Join(wz.GeeigneteZwecke, ", "),
@@ -153,8 +222,9 @@ type werkzeugFormData struct {
 	ID                 string // leer bei "neu"
 	Name               string
 	Anbieter           string
-	Verarbeitungsorte []string
+	LaenderOptionen    []string
-	Verarbeitungsort  string
+	LaenderAusgewaehlt map[string]bool
+	DPFZertifiziert    bool
 	AVVVerfuegbar      bool
 	AVVURL             string
 	TrainingOptOut     bool
@@ -170,9 +240,9 @@ type werkzeugFormData struct {
 	Error              string
 }
 
-// zweckeAusgewaehltVon baut die Checkbox-Vorbelegung aus einer bereits
+// auswahlSet baut die Checkbox-Vorbelegung aus einer bereits
 // gespeicherten oder erneut eingereichten Liste von Zwecken.
-func zweckeAusgewaehltVon(ausgewaehlt []string) map[string]bool {
+func auswahlSet(ausgewaehlt []string) map[string]bool {
 	m := make(map[string]bool, len(ausgewaehlt))
 	for _, z := range ausgewaehlt {
 		m[z] = true
@@ -189,12 +259,13 @@ func werkzeugFormDataFromWerkzeug(r *http.Request, wz store.Werkzeug, title, act
 		aufbewahrung = strconv.Itoa(*wz.AufbewahrungTage)
 	}
 	return werkzeugFormData{
-		Title: title, Nav: navFor(r), ActionBase: actionBase, ID: wz.ID, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Title: title, Nav: navFor(r), ActionBase: actionBase, ID: wz.ID,
-		Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+		LaenderOptionen: weltLaenderliste, LaenderAusgewaehlt: auswahlSet(wz.Verarbeitungslaender), DPFZertifiziert: wz.DPFZertifiziert,
+		Name: wz.Name, Anbieter: wz.Anbieter,
 		AVVVerfuegbar: wz.AVVVerfuegbar, AVVURL: wz.AVVURL,
 		TrainingOptOut: wz.TrainingOptOut, TrainingStandard: wz.TrainingStandard, AufbewahrungTage: aufbewahrung,
 		Zertifizierungen: strings.Join(wz.Zertifizierungen, ", "), Subprozessoren: strings.Join(wz.Subprozessoren, ", "),
-		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: zweckeAusgewaehltVon(wz.GeeigneteZwecke),
+		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: auswahlSet(wz.GeeigneteZwecke),
 		Einschraenkungen: strings.Join(wz.Einschraenkungen, ", "), LetztePruefung: wz.LetztePruefung.Format("2006-01-02"),
 		Quelle: wz.Quelle,
 	}
@@ -203,7 +274,8 @@ func werkzeugFormDataFromWerkzeug(r *http.Request, wz store.Werkzeug, title, act
 func (s *Server) handleBetreiberWerkzeugNeuForm(w http.ResponseWriter, r *http.Request) {
 	data := werkzeugFormData{
 		Title: "Werkzeug anlegen", Nav: navFor(r), ActionBase: "/betreiber/werkzeuge",
-		Verarbeitungsorte: gueltigeVerarbeitungsorte, ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: map[string]bool{},
+		LaenderOptionen: weltLaenderliste, LaenderAusgewaehlt: map[string]bool{},
+		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: map[string]bool{},
 	}
 	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
@@ -218,9 +290,14 @@ func werkzeugInputFromForm(r *http.Request, accountID *string) (store.WerkzeugIn
 	if err != nil {
 		return store.WerkzeugInput{}, "Datum der letzten Prüfung ist ungültig oder fehlt"
 	}
-	verarbeitungsort := r.FormValue("verarbeitungsort")
+	var verarbeitungslaender []string
-	if !istGueltigerVerarbeitungsort(verarbeitungsort) {
+	for _, l := range r.Form["verarbeitungslaender"] {
-		return store.WerkzeugInput{}, "ungültiger Verarbeitungsort"
+		if istGueltigesLand(l) {
+			verarbeitungslaender = append(verarbeitungslaender, l)
+		}
+	}
+	if len(verarbeitungslaender) == 0 {
+		return store.WerkzeugInput{}, "mindestens ein Verarbeitungsland ist Pflicht"
 	}
 	name := r.FormValue("name")
 	anbieter := r.FormValue("anbieter")
@@ -248,11 +325,12 @@ func werkzeugInputFromForm(r *http.Request, accountID *string) (store.WerkzeugIn
 		AccountID:            accountID,
 		Name:                 name,
 		Anbieter:             anbieter,
-		Verarbeitungsort: verarbeitungsort,
+		Verarbeitungslaender: verarbeitungslaender,
 		AVVVerfuegbar:        r.FormValue("avv_verfuegbar") == "on",
 		AVVURL:               r.FormValue("avv_url"),
 		TrainingOptOut:       r.FormValue("training_opt_out") == "on",
 		TrainingStandard:     r.FormValue("training_standard") == "on",
+		DPFZertifiziert:      r.FormValue("dpf_zertifiziert") == "on",
 		AufbewahrungTage:     aufbewahrungTage,
 		Zertifizierungen:     splitListe(r.FormValue("zertifizierungen")),
 		Subprozessoren:       splitListe(r.FormValue("subprozessoren")),
@@ -268,13 +346,15 @@ func werkzeugInputFromForm(r *http.Request, accountID *string) (store.WerkzeugIn
 // statt das Formular zu leeren.
 func werkzeugFormDataFromRequest(r *http.Request, title, actionBase, id, errMsg string) werkzeugFormData {
 	return werkzeugFormData{
-		Title: title, Nav: navFor(r), ActionBase: actionBase, ID: id, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Title: title, Nav: navFor(r), ActionBase: actionBase, ID: id,
-		Name: r.FormValue("name"), Anbieter: r.FormValue("anbieter"), Verarbeitungsort: r.FormValue("verarbeitungsort"),
+		LaenderOptionen: weltLaenderliste, LaenderAusgewaehlt: auswahlSet(r.Form["verarbeitungslaender"]),
+		DPFZertifiziert: r.FormValue("dpf_zertifiziert") == "on",
+		Name:            r.FormValue("name"), Anbieter: r.FormValue("anbieter"),
 		AVVVerfuegbar: r.FormValue("avv_verfuegbar") == "on", AVVURL: r.FormValue("avv_url"),
 		TrainingOptOut: r.FormValue("training_opt_out") == "on", TrainingStandard: r.FormValue("training_standard") == "on",
 		AufbewahrungTage: strings.TrimSpace(r.FormValue("aufbewahrung_tage")),
 		Zertifizierungen: r.FormValue("zertifizierungen"), Subprozessoren: r.FormValue("subprozessoren"),
-		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: zweckeAusgewaehltVon(r.Form["geeignete_zwecke"]),
+		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: auswahlSet(r.Form["geeignete_zwecke"]),
 		Einschraenkungen: r.FormValue("einschraenkungen"), LetztePruefung: r.FormValue("letzte_pruefung"),
 		Quelle: r.FormValue("quelle"), Error: errMsg,
 	}

internal/web/betreiber_werkzeug_handlers_test.go

@@ -2,17 +2,19 @@ package web_test
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/netcell-it/deklarix/internal/store"
 )
 
 func werkzeugForm() url.Values {
 	return url.Values{
-		"name": {"ChatGPT Enterprise"}, "anbieter": {"OpenAI"}, "verarbeitungsort": {"EU"},
+		"name": {"ChatGPT Enterprise"}, "anbieter": {"OpenAI"}, "verarbeitungslaender": {"Irland"},
 		"avv_verfuegbar": {"on"}, "avv_url": {"https://example.com/avv"},
 		"training_opt_out": {"on"}, "training_standard": {"on"}, "aufbewahrung_tage": {"30"},
 		"zertifizierungen": {"ISO 27001, SOC 2"}, "geeignete_zwecke": {"Textgenerierung"},
@@ -116,3 +118,71 @@ func TestBetreiberCannotEditMandantenEigenesWerkzeug(t *testing.T) {
 		t.Fatalf("status = %d, want 404 for a mandanten-eigenes werkzeug", resp.Code)
 	}
 }
+
+func TestBetreiberWerkzeugListeFiltertNachSucheUndZweck(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	fs.werkzeuge["a"] = store.Werkzeug{
+		ID: "a", Name: "ChatGPT Enterprise", Anbieter: "OpenAI",
+		Verarbeitungslaender: []string{"USA"}, GeeigneteZwecke: []string{"Textgenerierung"},
+		LetztePruefung: time.Now(),
+	}
+	fs.werkzeuge["b"] = store.Werkzeug{
+		ID: "b", Name: "DeepL Pro", Anbieter: "DeepL SE",
+		Verarbeitungslaender: []string{"Deutschland"}, GeeigneteZwecke: []string{"Übersetzung"},
+		LetztePruefung: time.Now(),
+	}
+
+	resp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge?q=deepl")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d", resp.Code)
+	}
+	if strings.Contains(resp.Body.String(), "ChatGPT Enterprise") || !strings.Contains(resp.Body.String(), "DeepL Pro") {
+		t.Fatalf("q=deepl sollte nur DeepL Pro zeigen, body: %s", resp.Body.String())
+	}
+
+	resp = getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge?zweck=Textgenerierung")
+	if !strings.Contains(resp.Body.String(), "ChatGPT Enterprise") || strings.Contains(resp.Body.String(), "DeepL Pro") {
+		t.Fatalf("zweck=Textgenerierung sollte nur ChatGPT Enterprise zeigen, body: %s", resp.Body.String())
+	}
+
+	resp = getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge?q=nichts-passt")
+	if !strings.Contains(resp.Body.String(), "Keine Treffer") {
+		t.Fatalf("erwartet 'Keine Treffer' bei erfolgloser Suche, body: %s", resp.Body.String())
+	}
+}
+
+func TestBetreiberWerkzeugListePaginiert(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	for i := 0; i < 25; i++ {
+		id := fmt.Sprintf("wz-%02d", i)
+		fs.werkzeuge[id] = store.Werkzeug{
+			ID: id, Name: fmt.Sprintf("Werkzeug %02d", i), Anbieter: "Testanbieter",
+			LetztePruefung: time.Now(),
+		}
+	}
+
+	resp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d", resp.Code)
+	}
+	if !strings.Contains(resp.Body.String(), "Seite 1 von 2") {
+		t.Fatalf("erwartet 'Seite 1 von 2' bei 25 Einträgen (20 pro Seite), body: %s", resp.Body.String())
+	}
+	if !strings.Contains(resp.Body.String(), "Weiter") || strings.Contains(resp.Body.String(), "Zurück") {
+		t.Fatalf("Seite 1 sollte einen Weiter-, aber keinen Zurück-Button zeigen")
+	}
+
+	resp = getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge?page=2")
+	if !strings.Contains(resp.Body.String(), "Seite 2 von 2") {
+		t.Fatalf("erwartet 'Seite 2 von 2', body: %s", resp.Body.String())
+	}
+	if strings.Contains(resp.Body.String(), "Weiter") || !strings.Contains(resp.Body.String(), "Zurück") {
+		t.Fatalf("Seite 2 sollte einen Zurück-, aber keinen Weiter-Button zeigen")
+	}
+}

internal/web/laenderliste.go

@@ -0,0 +1,53 @@
+package web
+
+// weltLaenderliste ist die kontrollierte Auswahl für "Verarbeitungsländer"
+// im Werkzeugkatalog — eine echte Länderliste statt grober Eimer wie
+// "EU"/"USA"/"gemischt" (die USA sind DSGVO-rechtlich bereits ein
+// Drittland wie jedes andere, siehe CLAUDE.md). Enthält zusätzlich zwei
+// Pseudo-Einträge für Fälle, in denen der Anbieter selbst keinen
+// einzelnen Staat zusichert bzw. keine Cloud-Verarbeitung stattfindet.
+var weltLaenderliste = []string{
+	"EU-Region (kein einzelnes Land benannt)",
+	"On-Premise (selbst gehostet)",
+
+	"Afghanistan", "Ägypten", "Albanien", "Algerien", "Andorra", "Angola",
+	"Antigua und Barbuda", "Äquatorialguinea", "Argentinien", "Armenien",
+	"Aserbaidschan", "Äthiopien", "Australien", "Bahamas", "Bahrain",
+	"Bangladesch", "Barbados", "Belgien", "Belize", "Benin", "Bhutan",
+	"Bolivien", "Bosnien und Herzegowina", "Botsuana", "Brasilien",
+	"Brunei", "Bulgarien", "Burkina Faso", "Burundi", "Chile", "China",
+	"Costa Rica", "Dänemark", "Deutschland", "Dominica",
+	"Dominikanische Republik", "Dschibuti", "Ecuador", "El Salvador",
+	"Elfenbeinküste", "Eritrea", "Estland", "Eswatini", "Fidschi",
+	"Finnland", "Frankreich", "Gabun", "Gambia", "Georgien", "Ghana",
+	"Grenada", "Griechenland", "Guatemala", "Guinea", "Guinea-Bissau",
+	"Guyana", "Haiti", "Honduras", "Indien", "Indonesien", "Irak",
+	"Iran", "Irland", "Island", "Israel", "Italien", "Jamaika", "Japan",
+	"Jemen", "Jordanien", "Kambodscha", "Kamerun", "Kanada", "Kap Verde",
+	"Kasachstan", "Katar", "Kenia", "Kirgisistan", "Kiribati",
+	"Kolumbien", "Komoren", "Kongo (Republik)",
+	"Kongo (Demokratische Republik)", "Kosovo", "Kroatien", "Kuba",
+	"Kuwait", "Laos", "Lesotho", "Lettland", "Libanon", "Liberia",
+	"Libyen", "Liechtenstein", "Litauen", "Luxemburg", "Madagaskar",
+	"Malawi", "Malaysia", "Malediven", "Mali", "Malta", "Marokko",
+	"Marshallinseln", "Mauretanien", "Mauritius", "Mexiko",
+	"Mikronesien", "Moldau", "Monaco", "Mongolei", "Montenegro",
+	"Mosambik", "Myanmar", "Namibia", "Nauru", "Nepal", "Neuseeland",
+	"Nicaragua", "Niederlande", "Niger", "Nigeria", "Nordkorea",
+	"Nordmazedonien", "Norwegen", "Oman", "Österreich", "Osttimor",
+	"Pakistan", "Palau", "Palästina", "Panama", "Papua-Neuguinea",
+	"Paraguay", "Peru", "Philippinen", "Polen", "Portugal", "Ruanda",
+	"Rumänien", "Russland", "Salomonen", "Sambia", "Samoa",
+	"San Marino", "São Tomé und Príncipe", "Saudi-Arabien", "Schweden",
+	"Schweiz", "Senegal", "Serbien", "Seychellen", "Sierra Leone",
+	"Simbabwe", "Singapur", "Slowakei", "Slowenien", "Somalia",
+	"Spanien", "Sri Lanka", "St. Kitts und Nevis", "St. Lucia",
+	"St. Vincent und die Grenadinen", "Südafrika", "Sudan", "Südkorea",
+	"Südsudan", "Suriname", "Syrien", "Tadschikistan", "Taiwan",
+	"Tansania", "Thailand", "Togo", "Tonga", "Trinidad und Tobago",
+	"Tschad", "Tschechien", "Tunesien", "Türkei", "Turkmenistan",
+	"Tuvalu", "Uganda", "Ukraine", "Ungarn", "Uruguay", "USA",
+	"Usbekistan", "Vanuatu", "Vatikanstadt", "Venezuela",
+	"Vereinigte Arabische Emirate", "Vereinigtes Königreich", "Vietnam",
+	"Zentralafrikanische Republik", "Zypern",
+}

internal/web/mandant_werkzeug_handlers.go

@@ -11,13 +11,15 @@ package web
 import (
 	"net/http"
 	"strings"
+
+	"github.com/netcell-it/deklarix/internal/store"
 )
 
 type mandantWerkzeugItem struct {
 	ID                   string
 	Name                 string
 	Anbieter             string
-	Verarbeitungsort string
+	Verarbeitungslaender string
 	AVVVerfuegbar        bool
 	TrainingStandard     bool
 	Aufbewahrung         string
@@ -32,7 +34,7 @@ type eigenesWerkzeugItem struct {
 	ID                   string
 	Name                 string
 	Anbieter             string
-	Verarbeitungsort string
+	Verarbeitungslaender string
 	LetztePruefung       string
 }
 
@@ -40,6 +42,9 @@ type mandantWerkzeugListeData struct {
 	Title           string
 	Nav             navData
 	Werkzeuge       []mandantWerkzeugItem
+	Filter          werkzeugFilter
+	ZweckeOptionen  []string
+	Pagination      pagination
 	EigeneWerkzeuge []eigenesWerkzeugItem
 }
 
@@ -69,11 +74,24 @@ func (s *Server) handleMandantWerkzeugListe(w http.ResponseWriter, r *http.Reque
 		gesperrt[sp.WerkzeugID] = true
 	}
 
-	data := mandantWerkzeugListeData{Title: "Werkzeugkatalog", Nav: navFor(r)}
+	filter := werkzeugFilterFromRequest(r)
+	var gefiltert []store.Werkzeug
 	for _, wz := range zentral {
+		if filter.matches(wz) {
+			gefiltert = append(gefiltert, wz)
+		}
+	}
+	pag := paginationFromRequest(r, len(gefiltert))
+	seite := paginate(gefiltert, pag)
+
+	data := mandantWerkzeugListeData{
+		Title: "Werkzeugkatalog", Nav: navFor(r),
+		Filter: filter, ZweckeOptionen: gueltigeZwecke, Pagination: pag,
+	}
+	for _, wz := range seite {
 		label, css := pruefStatus(wz.LetztePruefung)
 		data.Werkzeuge = append(data.Werkzeuge, mandantWerkzeugItem{
-			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungslaender: strings.Join(wz.Verarbeitungslaender, ", "),
 			AVVVerfuegbar: wz.AVVVerfuegbar, TrainingStandard: wz.TrainingStandard,
 			Aufbewahrung:     formatAufbewahrung(wz.AufbewahrungTage),
 			GeeigneteZwecke:  strings.Join(wz.GeeigneteZwecke, ", "),
@@ -87,7 +105,7 @@ func (s *Server) handleMandantWerkzeugListe(w http.ResponseWriter, r *http.Reque
 			continue // zentral, oben schon gelistet
 		}
 		data.EigeneWerkzeuge = append(data.EigeneWerkzeuge, eigenesWerkzeugItem{
-			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungslaender: strings.Join(wz.Verarbeitungslaender, ", "),
 			LetztePruefung: wz.LetztePruefung.Format("02.01.2006"),
 		})
 	}
@@ -99,7 +117,8 @@ func (s *Server) handleMandantWerkzeugListe(w http.ResponseWriter, r *http.Reque
 func (s *Server) handleMandantWerkzeugNeuForm(w http.ResponseWriter, r *http.Request) {
 	data := werkzeugFormData{
 		Title: "Eigenes Werkzeug anlegen", Nav: navFor(r), ActionBase: "/verwaltung/werkzeuge",
-		Verarbeitungsorte: gueltigeVerarbeitungsorte, ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: map[string]bool{},
+		LaenderOptionen: weltLaenderliste, LaenderAusgewaehlt: map[string]bool{},
+		ZweckeOptionen: gueltigeZwecke, ZweckeAusgewaehlt: map[string]bool{},
 	}
 	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)

internal/web/pagination.go

@@ -0,0 +1,75 @@
+// pagination.go — wiederverwendbare serverseitige Paginierung für
+// Listen-Seiten (Werkzeugkatalog, Register, ...). Bewusst ohne
+// JavaScript: Seiten-/Filterwechsel läuft über ein einziges GET-Formular,
+// das Query-Parameter (q, zweck, page, ...) setzt — siehe CLAUDE.md,
+// Frontend.
+package web
+
+import (
+	"net/http"
+	"strconv"
+)
+
+const defaultPerPage = 20
+
+// pagination beschreibt die aktuelle Seite einer Liste. Templates lesen
+// daraus Seitenzahl, Gesamtzahl und ob Vor/Zurück-Buttons sichtbar sein
+// sollen.
+type pagination struct {
+	Page       int
+	PerPage    int
+	Total      int
+	TotalPages int
+	HasPrev    bool
+	HasNext    bool
+	PrevPage   int
+	NextPage   int
+}
+
+// paginationFromRequest liest "page" aus der Query (Standard: 1, nie
+// kleiner 1, nie größer als die letzte tatsächlich vorhandene Seite).
+// per_page ist bewusst nicht vom Nutzer einstellbar (kein Query-Param
+// dafür) — eine feste Seitengröße hält die Filter-URLs einfach und
+// verhindert versehentlich riesige Anfragen.
+func paginationFromRequest(r *http.Request, total int) pagination {
+	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+	if page < 1 {
+		page = 1
+	}
+	perPage := defaultPerPage
+	totalPages := (total + perPage - 1) / perPage
+	if totalPages < 1 {
+		totalPages = 1
+	}
+	if page > totalPages {
+		page = totalPages
+	}
+	return pagination{
+		Page: page, PerPage: perPage, Total: total, TotalPages: totalPages,
+		HasPrev: page > 1, HasNext: page < totalPages,
+		PrevPage: page - 1, NextPage: page + 1,
+	}
+}
+
+// bounds liefert den Start-/End-Index für die aktuelle Seite innerhalb
+// der (bereits gefilterten) Gesamtliste.
+func (p pagination) bounds() (start, end int) {
+	start = (p.Page - 1) * p.PerPage
+	end = start + p.PerPage
+	if end > p.Total {
+		end = p.Total
+	}
+	if start > end {
+		start = end
+	}
+	return start, end
+}
+
+// paginate schneidet den Ausschnitt für die aktuelle Seite aus einer
+// bereits gefilterten/sortierten Liste heraus — generisch, damit jede
+// Listen-Seite (Werkzeuge, Register, ...) dieselbe Funktion nutzt statt
+// eigene Slice-Arithmetik zu wiederholen.
+func paginate[T any](items []T, p pagination) []T {
+	start, end := p.bounds()
+	return items[start:end]
+}

internal/web/server_test.go

@@ -408,9 +408,9 @@ func (f *fakeStore) CreateWerkzeug(ctx context.Context, in store.WerkzeugInput)
 	defer f.mu.Unlock()
 	w := store.Werkzeug{
 		ID: f.newID(), AccountID: in.AccountID, Name: in.Name, Anbieter: in.Anbieter,
-		Verarbeitungsort: in.Verarbeitungsort, AVVVerfuegbar: in.AVVVerfuegbar, AVVURL: in.AVVURL,
+		Verarbeitungslaender: in.Verarbeitungslaender, AVVVerfuegbar: in.AVVVerfuegbar, AVVURL: in.AVVURL,
-		TrainingOptOut: in.TrainingOptOut, TrainingStandard: in.TrainingStandard, AufbewahrungTage: in.AufbewahrungTage,
+		TrainingOptOut: in.TrainingOptOut, TrainingStandard: in.TrainingStandard, DPFZertifiziert: in.DPFZertifiziert, AufbewahrungTage: in.AufbewahrungTage,
-		Zertifizierungen: in.Zertifizierungen, GeeigneteZwecke: in.GeeigneteZwecke, Einschraenkungen: in.Einschraenkungen,
+		Zertifizierungen: in.Zertifizierungen, Subprozessoren: in.Subprozessoren, GeeigneteZwecke: in.GeeigneteZwecke, Einschraenkungen: in.Einschraenkungen,
 		LetztePruefung: in.LetztePruefung, Quelle: in.Quelle, CreatedAt: time.Now(), UpdatedAt: time.Now(),
 	}
 	f.werkzeuge[w.ID] = w
@@ -424,10 +424,10 @@ func (f *fakeStore) UpdateWerkzeug(ctx context.Context, id string, in store.Werk
 	if !ok {
 		return store.Werkzeug{}, store.ErrNotFound
 	}
-	w.Name, w.Anbieter, w.Verarbeitungsort = in.Name, in.Anbieter, in.Verarbeitungsort
+	w.Name, w.Anbieter, w.Verarbeitungslaender = in.Name, in.Anbieter, in.Verarbeitungslaender
 	w.AVVVerfuegbar, w.AVVURL = in.AVVVerfuegbar, in.AVVURL
-	w.TrainingOptOut, w.TrainingStandard, w.AufbewahrungTage = in.TrainingOptOut, in.TrainingStandard, in.AufbewahrungTage
+	w.TrainingOptOut, w.TrainingStandard, w.DPFZertifiziert, w.AufbewahrungTage = in.TrainingOptOut, in.TrainingStandard, in.DPFZertifiziert, in.AufbewahrungTage
-	w.Zertifizierungen, w.GeeigneteZwecke, w.Einschraenkungen = in.Zertifizierungen, in.GeeigneteZwecke, in.Einschraenkungen
+	w.Zertifizierungen, w.Subprozessoren, w.GeeigneteZwecke, w.Einschraenkungen = in.Zertifizierungen, in.Subprozessoren, in.GeeigneteZwecke, in.Einschraenkungen
 	w.LetztePruefung, w.Quelle, w.UpdatedAt = in.LetztePruefung, in.Quelle, time.Now()
 	f.werkzeuge[id] = w
 	return w, nil

internal/web/static/app.css

@@ -59,7 +59,15 @@ h1, h2, h3 {
   color: var(--color-heading);
   font-weight: 600;
   letter-spacing: -0.02em;
-  margin: 0 0 0.5em;
+  margin: 0 0 0.6em;
+}
+
+h2 {
+  font-size: 1.25rem;
+}
+
+h3 {
+  font-size: 1.0625rem;
 }
 
 h1 {
@@ -542,8 +550,8 @@ button.entfernen {
 }
 
 .fragebogen legend {
-  font-weight: 500;
+  font-weight: 600;
-  font-size: 0.9375rem;
+  font-size: 1rem;
   padding: 0 4px;
 }
 
@@ -555,6 +563,130 @@ button.entfernen {
   margin: 4px 12px 4px 0;
 }
 
+/* ── Formular-Karten (Enterprise-Look, siehe design/enterprise.css
+   .ant-card/.ant-form-item) ─────────────────────────────────────────
+   Ersetzt "ein Formular = eine flache, ununterbrochene Spalte" durch
+   klar abgegrenzte Abschnitte mit Titel und ein Grid für kurze Felder
+   nebeneinander statt jedes Feld einzeln untereinander. */
+.form-card {
+  background: #fff;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-sm);
+  margin-bottom: 24px;
+  overflow: hidden;
+}
+
+.form-card form {
+  margin-bottom: 0;
+}
+
+.form-section {
+  border: none;
+  margin: 0;
+  padding: 20px;
+  min-width: 0;
+}
+
+.form-section + .form-section {
+  border-top: 1px solid var(--color-border);
+}
+
+/* <legend> ignoriert das padding des umschließenden <fieldset> (es
+   positioniert sich an dessen Border-Box, nicht an der Padding-Box) —
+   ohne eigenes padding-left säße die Abschnittsüberschrift bündig am
+   Kartenrand, während der restliche Inhalt eingerückt ist. */
+.form-section > legend {
+  padding: 0 0 16px 0;
+  font-size: 1.0625rem;
+  font-weight: 700;
+  color: var(--color-heading);
+  width: 100%;
+}
+
+.form-grid {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 0 16px;
+}
+
+@media (min-width: 640px) {
+  .form-grid {
+    grid-template-columns: 1fr 1fr;
+  }
+
+  .form-grid .form-full {
+    grid-column: 1 / -1;
+  }
+}
+
+/* Checkbox-/Radio-Gruppen als Chips statt einer langen
+   Untereinander-Liste — v. a. bei den zwölf Zweck-Kategorien war das
+   vorher eine kaum überblickbare Spalte. */
+.chip-group {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 4px;
+}
+
+.chip-group label {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 0;
+  padding: 7px 14px;
+  border: 1px solid var(--color-border);
+  border-radius: 999px;
+  font-size: 0.8125rem;
+  font-weight: 500;
+  color: var(--color-text);
+  background: var(--color-bg);
+  cursor: pointer;
+}
+
+.chip-group input[type="checkbox"],
+.chip-group input[type="radio"] {
+  width: auto;
+  min-height: 0;
+  margin: 0;
+}
+
+.chip-group label:has(input:checked) {
+  border-color: var(--branding-primary);
+  background: rgba(22, 119, 255, 0.08);
+  color: var(--branding-primary);
+}
+
+.form-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 16px 20px;
+  background: var(--color-bg);
+}
+
+.form-actions form,
+.form-actions button {
+  margin: 0;
+}
+
+.form-gefahrenzone {
+  border-top: 1px solid var(--color-border);
+  padding: 16px 20px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.form-gefahrenzone form {
+  margin: 0;
+}
+
 .fragebogen fieldset input[type="radio"] {
   width: auto;
   min-height: 0;
@@ -618,6 +750,48 @@ tbody tr:hover {
   mask-image: linear-gradient(to right, black calc(100% - 24px), transparent 100%);
 }
 
+/* Filter-/Paginierungsleiste für Listen-Seiten (Werkzeugkatalog,
+   Register, ...) — ein einziges GET-Formular ohne JavaScript, siehe
+   pagination.go. */
+.filter-bar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 16px;
+}
+
+.filter-bar input[type="search"] {
+  flex: 1 1 220px;
+  min-height: 40px;
+}
+
+.filter-bar select {
+  flex: 0 1 200px;
+  min-height: 40px;
+}
+
+.filter-bar button {
+  margin-top: 0;
+  min-height: 40px;
+}
+
+.pagination {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.pagination button {
+  margin-top: 0;
+  min-height: 36px;
+  padding: 6px 14px;
+  font-size: 0.875rem;
+}
+
 /* Ab hier mehr Platz (Tablet) — der Container bekommt spürbaren
    Rand statt volle Breite, sonst bleibt alles identisch. */
 @media (min-width: 640px) {

internal/web/templates/betreiber_werkzeug_form.html

@@ -7,66 +7,113 @@
 <p><a href="{{.ActionBase}}">&larr; Werkzeugkatalog</a></p>
 <h1>{{.Title}}</h1>
 <p class="hinweis">
-  Jede Zusicherung hier (AVV, Verarbeitungsort, Training-Opt-out,
+  Jede Zusicherung hier (AVV, Verarbeitungsländer, Training-Opt-out,
   Zertifizierungen) muss belegbar sein — Quelle und letzte Prüfung sind
   Pflicht.
 </p>
 {{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<div class="form-card">
 <form method="post" action="{{if .ID}}{{.ActionBase}}/{{.ID}}{{else}}{{.ActionBase}}{{end}}">
+  <fieldset class="form-section">
+    <legend>Grunddaten</legend>
+    <div class="form-grid">
+      <div>
         <label for="name">Name</label>
         <input type="text" id="name" name="name" value="{{.Name}}" required>
-
+      </div>
+      <div>
         <label for="anbieter">Anbieter</label>
         <input type="text" id="anbieter" name="anbieter" value="{{.Anbieter}}" required>
-
+      </div>
-  <fieldset>
+      <div class="form-full">
-    <legend>Verarbeitungsort</legend>
+        <label for="verarbeitungslaender">Verarbeitungsländer (Mehrfachauswahl: Strg/Cmd-Klick)</label>
-    {{$gewaehlt := .Verarbeitungsort}}
+        <select id="verarbeitungslaender" name="verarbeitungslaender" multiple size="8" required>
-    {{range .Verarbeitungsorte}}
+          {{range .LaenderOptionen}}
-    <label><input type="radio" name="verarbeitungsort" value="{{.}}" {{if eq . $gewaehlt}}checked{{end}} required> {{.}}</label>
+          <option value="{{.}}" {{if index $.LaenderAusgewaehlt .}}selected{{end}}>{{.}}</option>
           {{end}}
+        </select>
+        <p class="hinweis">Tatsächliche Länder benennen, nicht "EU"/"Drittland" — die USA sind DSGVO-rechtlich bereits ein Drittland wie jedes andere.</p>
+      </div>
+    </div>
   </fieldset>
 
+  <fieldset class="form-section">
+    <legend>Rechtliches &amp; Datenschutz</legend>
+    <div class="form-grid">
+      <div class="form-full">
+        <label>Zusicherungen</label>
+        <div class="chip-group">
           <label><input type="checkbox" name="avv_verfuegbar" {{if .AVVVerfuegbar}}checked{{end}}> AVV verfügbar</label>
-  <label for="avv_url">AVV-URL</label>
-  <input type="text" id="avv_url" name="avv_url" value="{{.AVVURL}}">
-
           <label><input type="checkbox" name="training_opt_out" {{if .TrainingOptOut}}checked{{end}}> Training-Opt-out möglich</label>
           <label><input type="checkbox" name="training_standard" {{if .TrainingStandard}}checked{{end}}> Training standardmäßig aus</label>
-
+          <label><input type="checkbox" name="dpf_zertifiziert" {{if .DPFZertifiziert}}checked{{end}}> EU-US Data Privacy Framework (DPF) zertifiziert</label>
+        </div>
+      </div>
+      <div class="form-full">
+        <label for="avv_url">AVV-URL</label>
+        <input type="text" id="avv_url" name="avv_url" value="{{.AVVURL}}">
+      </div>
+      <div>
         <label for="aufbewahrung_tage">Aufbewahrung (Tage, leer lassen wenn vom Anbieter nicht beziffert)</label>
         <input type="number" id="aufbewahrung_tage" name="aufbewahrung_tage" min="0" value="{{.AufbewahrungTage}}">
-
+      </div>
+      <div>
         <label for="zertifizierungen">Zertifizierungen (kommagetrennt)</label>
         <input type="text" id="zertifizierungen" name="zertifizierungen" value="{{.Zertifizierungen}}">
-
+      </div>
+      <div class="form-full">
         <label for="subprozessoren">Subprozessoren (kommagetrennt, z. B. Anthropic, AWS)</label>
         <input type="text" id="subprozessoren" name="subprozessoren" value="{{.Subprozessoren}}">
+      </div>
+    </div>
+  </fieldset>
 
-  <fieldset>
+  <fieldset class="form-section">
-    <legend>Geeignete Zwecke</legend>
+    <legend>Einsatzbereich</legend>
+    <div class="form-grid">
+      <div class="form-full">
+        <label>Geeignete Zwecke</label>
+        <div class="chip-group">
           {{range .ZweckeOptionen}}
           <label><input type="checkbox" name="geeignete_zwecke" value="{{.}}" {{if index $.ZweckeAusgewaehlt .}}checked{{end}}> {{.}}</label>
           {{end}}
-  </fieldset>
+        </div>
-
+      </div>
+      <div class="form-full">
         <label for="einschraenkungen">Einschränkungen (kommagetrennt)</label>
         <input type="text" id="einschraenkungen" name="einschraenkungen" value="{{.Einschraenkungen}}">
+      </div>
+    </div>
+  </fieldset>
 
+  <fieldset class="form-section">
+    <legend>Beleg</legend>
+    <div class="form-grid">
+      <div>
         <label for="letzte_pruefung">Letzte Prüfung</label>
         <input type="date" id="letzte_pruefung" name="letzte_pruefung" value="{{.LetztePruefung}}" required>
-
+      </div>
+      <div>
         <label for="quelle">Quelle (Beleg)</label>
         <input type="text" id="quelle" name="quelle" value="{{.Quelle}}" required>
+      </div>
+    </div>
+  </fieldset>
 
+  <div class="form-actions">
     <button type="submit">Speichern</button>
+  </div>
 </form>
 {{if .ID}}
-<form method="post" action="/betreiber/werkzeuge/{{.ID}}/loeschen" onsubmit="return confirm('Werkzeug wirklich löschen?')">
+<div class="form-gefahrenzone">
+  <span class="hinweis">Ein gelöschtes Werkzeug kann nicht wiederhergestellt werden.</span>
+  <form method="post" action="{{.ActionBase}}/{{.ID}}/loeschen" onsubmit="return confirm('Werkzeug wirklich löschen?')">
     <button type="submit" class="entfernen">Werkzeug löschen</button>
-</form>
+  </form>
+</div>
 {{end}}
 </div>
+</div>
 </body>
 </html>
 {{end}}

internal/web/templates/betreiber_werkzeuge.html

@@ -6,14 +6,28 @@
 <div class="page">
 <p><a href="/betreiber">&larr; Plattform</a></p>
 <h1>Werkzeugkatalog</h1>
-{{if not .Werkzeuge}}
+<form method="get">
-<p class="hinweis">Noch keine zentralen Katalogeinträge.</p>
+  <div class="filter-bar">
-{{else}}
+    <input type="search" name="q" value="{{.Filter.Suche}}" placeholder="Suche (Name, Anbieter, Land)">
-<div class="table-scroll">
+    <select name="zweck">
-<table>
+      <option value="">Alle Zwecke</option>
+      {{$zweck := .Filter.Zweck}}
+      {{range .ZweckeOptionen}}
+      <option value="{{.}}" {{if eq . $zweck}}selected{{end}}>{{.}}</option>
+      {{end}}
+    </select>
+    <button type="submit">Filtern</button>
+    {{if .Filter.Aktiv}}<a href="/betreiber/werkzeuge">Zurücksetzen</a>{{end}}
+  </div>
+
+  {{if not .Werkzeuge}}
+  <p class="hinweis">{{if .Filter.Aktiv}}Keine Treffer für diese Filter.{{else}}Noch keine zentralen Katalogeinträge.{{end}}</p>
+  {{else}}
+  <div class="table-scroll">
+  <table>
     <thead>
       <tr>
-      <th>Name</th><th>Anbieter</th><th>Verarbeitungsort</th><th>AVV</th>
+        <th>Name</th><th>Anbieter</th><th>Verarbeitungsländer</th><th>DPF</th><th>AVV</th>
         <th>Training aus</th><th>Aufbewahrung</th><th>Zertifizierungen</th><th>Geeignete Zwecke</th>
         <th>Zuletzt geprüft</th>
       </tr>
@@ -23,7 +37,8 @@
       <tr>
         <td><a href="/betreiber/werkzeuge/{{.ID}}">{{.Name}}</a></td>
         <td>{{.Anbieter}}</td>
-      <td>{{.Verarbeitungsort}}</td>
+        <td>{{.Verarbeitungslaender}}</td>
+        <td>{{if .DPFZertifiziert}}ja{{else}}nein{{end}}</td>
         <td>{{if .AVVVerfuegbar}}ja{{else}}nein{{end}}</td>
         <td>{{if .TrainingStandard}}ja{{else}}nein{{end}}</td>
         <td>{{.Aufbewahrung}}</td>
@@ -33,9 +48,17 @@
       </tr>
       {{end}}
     </tbody>
-</table>
+  </table>
-</div>
+  </div>
-{{end}}
+  <div class="pagination">
+    <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+    <span>
+      {{if .Pagination.HasPrev}}<button type="submit" name="page" value="{{.Pagination.PrevPage}}">&larr; Zurück</button>{{end}}
+      {{if .Pagination.HasNext}}<button type="submit" name="page" value="{{.Pagination.NextPage}}">Weiter &rarr;</button>{{end}}
+    </span>
+  </div>
+  {{end}}
+</form>
 <p><a href="/betreiber/werkzeuge/neu">Werkzeug anlegen</a></p>
 </div>
 </body>

internal/web/templates/mandant_werkzeuge.html

@@ -12,14 +12,26 @@
   zentralen Katalog unverändert — es wird nur für diesen Mandanten aus
   der Werkzeugsuche ausgeblendet.
 </p>
+<form method="get" class="filter-bar">
+  <input type="search" name="q" value="{{.Filter.Suche}}" placeholder="Suche (Name, Anbieter, Land)">
+  <select name="zweck">
+    <option value="">Alle Zwecke</option>
+    {{$zweck := .Filter.Zweck}}
+    {{range .ZweckeOptionen}}
+    <option value="{{.}}" {{if eq . $zweck}}selected{{end}}>{{.}}</option>
+    {{end}}
+  </select>
+  <button type="submit">Filtern</button>
+  {{if .Filter.Aktiv}}<a href="/verwaltung/werkzeuge">Zurücksetzen</a>{{end}}
+</form>
 {{if not .Werkzeuge}}
-<p class="hinweis">Der zentrale Katalog ist noch leer.</p>
+<p class="hinweis">{{if .Filter.Aktiv}}Keine Treffer für diese Filter.{{else}}Der zentrale Katalog ist noch leer.{{end}}</p>
 {{else}}
 <div class="table-scroll">
 <table>
   <thead>
     <tr>
-      <th>Name</th><th>Anbieter</th><th>Verarbeitungsort</th><th>AVV</th>
+      <th>Name</th><th>Anbieter</th><th>Verarbeitungsländer</th><th>AVV</th>
       <th>Training aus</th><th>Aufbewahrung</th><th>Geeignete Zwecke</th><th>Zuletzt geprüft</th><th>Status</th>
     </tr>
   </thead>
@@ -28,7 +40,7 @@
     <tr>
       <td>{{.Name}}</td>
       <td>{{.Anbieter}}</td>
-      <td>{{.Verarbeitungsort}}</td>
+      <td>{{.Verarbeitungslaender}}</td>
       <td>{{if .AVVVerfuegbar}}ja{{else}}nein{{end}}</td>
       <td>{{if .TrainingStandard}}ja{{else}}nein{{end}}</td>
       <td>{{.Aufbewahrung}}</td>
@@ -52,6 +64,27 @@
   </tbody>
 </table>
 </div>
+<div class="pagination">
+  <span class="hinweis">Seite {{.Pagination.Page}} von {{.Pagination.TotalPages}} ({{.Pagination.Total}} Einträge)</span>
+  <span>
+    {{if .Pagination.HasPrev}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Filter.Suche}}">
+      <input type="hidden" name="zweck" value="{{.Filter.Zweck}}">
+      <input type="hidden" name="page" value="{{.Pagination.PrevPage}}">
+      <button type="submit">&larr; Zurück</button>
+    </form>
+    {{end}}
+    {{if .Pagination.HasNext}}
+    <form method="get" style="display:inline">
+      <input type="hidden" name="q" value="{{.Filter.Suche}}">
+      <input type="hidden" name="zweck" value="{{.Filter.Zweck}}">
+      <input type="hidden" name="page" value="{{.Pagination.NextPage}}">
+      <button type="submit">Weiter &rarr;</button>
+    </form>
+    {{end}}
+  </span>
+</div>
 {{end}}
 
 <h2>Eigene Werkzeuge</h2>
@@ -65,14 +98,14 @@
 <div class="table-scroll">
 <table>
   <thead>
-    <tr><th>Name</th><th>Anbieter</th><th>Verarbeitungsort</th><th>Zuletzt geprüft</th></tr>
+    <tr><th>Name</th><th>Anbieter</th><th>Verarbeitungsländer</th><th>Zuletzt geprüft</th></tr>
   </thead>
   <tbody>
     {{range .EigeneWerkzeuge}}
     <tr>
       <td><a href="/verwaltung/werkzeuge/{{.ID}}">{{.Name}}</a></td>
       <td>{{.Anbieter}}</td>
-      <td>{{.Verarbeitungsort}}</td>
+      <td>{{.Verarbeitungslaender}}</td>
       <td>{{.LetztePruefung}}</td>
     </tr>
     {{end}}

internal/web/wiedervorlage_handlers.go

@@ -9,6 +9,8 @@ package web
 import (
 	"fmt"
 	"net/http"
+	"slices"
+	"strings"
 	"time"
 
 	"github.com/netcell-it/deklarix/internal/store"
@@ -30,8 +32,9 @@ func werkzeugDiff(snapshot, current store.Werkzeug) []string {
 	if snapshot.TrainingStandard != current.TrainingStandard {
 		diffs = append(diffs, fmt.Sprintf("Training standardmäßig aus: %v → %v", snapshot.TrainingStandard, current.TrainingStandard))
 	}
-	if snapshot.Verarbeitungsort != current.Verarbeitungsort {
+	if !slices.Equal(snapshot.Verarbeitungslaender, current.Verarbeitungslaender) {
-		diffs = append(diffs, fmt.Sprintf("Verarbeitungsort: %s → %s", snapshot.Verarbeitungsort, current.Verarbeitungsort))
+		diffs = append(diffs, fmt.Sprintf("Verarbeitungsländer: %s → %s",
+			strings.Join(snapshot.Verarbeitungslaender, ", "), strings.Join(current.Verarbeitungslaender, ", ")))
 	}
 	return diffs
 }