feat: Ableitungen und harte Filter (Schritt 3 der Baureihenfolge)

Reine Auswertungslogik in internal/rules, operiert auf rules.Antworten
(geparst aus antrag.antworten) und den drei Regelwerken aus Schritt 1
— ohne DB-/Web-Zugriff, vollständig isoliert testbar.

- EvaluateDatenklasse: "höchste zutreffende Stufe gewinnt" (höherer
  Rang). Trifft keine Stufe zu (z. B. B7 fälschlich "nein" trotz keiner
  anderen Kategorie), wird konservativ "intern" angenommen statt
  "oeffentlich" — im Zweifel mehr Schutz. Nicht fachlich bestätigt,
  siehe rules/OPEN.md Punkt 5.
- EvaluateEinstufung: Prüfreihenfolge wie im Regelwerk (verboten zuerst
  = K.-o.-Prüfung), erste zutreffende Stufe/Variante gewinnt.
  IstVerboten prüft die K.-o.-Bedingung direkt.
- DeriveAnforderungen: Anforderungsprofil aus Datenklasse+Einstufung.
- FilterWerkzeuge/ErfuelltAnforderung: harter Filter gegen einen
  Werkzeugkatalog. WerkzeugEigenschaften ist ein eigener, schlanker Typ
  statt store.Werkzeug — internal/rules bleibt unabhängig von
  internal/store. Nur technische Werkzeug-Eigenschaften
  (avv_erforderlich, eu_verarbeitung, kein_training_auf_eingabe) werden
  hart gefiltert; Prozess-Anforderungen (menschliche_aufsicht,
  kennzeichnungspflicht, dsfa_erforderlich) sortieren kein Werkzeug
  aus, sondern werden später als Auflage vermerkt — Annahme, siehe
  rules/OPEN.md Punkt 6.

rules/OPEN.md um Punkt 4 (Auswirkung der fehlenden Löschfristen auf den
Filter), Punkt 5 (Datenklasse-Fallback) und Punkt 6 (welche
Anforderungen hart filtern) ergänzt — Annahmen dokumentiert statt
geraten, damit Schritt 3 nicht auf die fachliche Klärung warten musste.

16 neue Tests gegen die ECHTEN rules/*.yaml-Dateien (nicht nur
synthetische Fixtures) — deckt Rang-Konflikte, "Unsicher zählt wie Ja",
alle vier Einstufungsstufen inkl. Auffangregel, Anforderungs-Ableitung
und Werkzeug-Filterung ab. Noch nicht ans Web angebunden (Schritt 4).

CLAUDE.md

@@ -139,11 +139,18 @@ Werkzeug: `avv_erforderlich`, `eu_verarbeitung`,
 `menschliche_aufsicht`, `kennzeichnungspflicht`, `dsfa_erforderlich`.
 
 `internal/rules` lädt und validiert diese drei Dateien (eindeutige IDs,
-eindeutige Ränge, jede Anforderung braucht mindestens einen Auslöser).
-**Die Auswertung gegen echte Fragebogen-Antworten ist noch nicht
-gebaut** — das ist Schritt 3 der Baureihenfolge (siehe unten), bewusst
-erst, wenn der Fragebogen (Schritt 2) die exakten Fakten-Feldnamen
-festlegt.
+eindeutige Ränge, jede Anforderung braucht mindestens einen Auslöser)
+und wertet sie seit Schritt 3 auch aus: `EvaluateDatenklasse`,
+`EvaluateEinstufung`, `IstVerboten`, `DeriveAnforderungen` operieren auf
+`rules.Antworten` (geparst aus `antrag.antworten` via `ParseAntworten`)
+— reine, für sich getestete Funktionen ohne DB-/Web-Zugriff.
+`FilterWerkzeuge`/`ErfuelltAnforderung` filtern einen Werkzeugkatalog
+hart gegen die abgeleiteten Anforderungen (`WerkzeugEigenschaften` ist
+ein schlanker, von `store.Werkzeug` unabhängiger Typ, damit
+`internal/rules` weiterhin ohne `internal/store` auskommt). **Noch
+nicht verdrahtet:** eine Web-Seite, die das für einen konkreten Antrag
+tatsächlich aufruft und anzeigt — das ist Schritt 4
+("Ergebnisdarstellung mit Herleitung").
 
 ---
 
@@ -311,8 +318,17 @@ wiederverwendet aus dem alten Produkt). `bewertung`/`entscheidung`/
    `abteilung`/`werkzeug`/`werkzeug_sperre`/`antrag` in Postgres,
    `internal/rules` lädt und validiert die drei YAML-Regelwerke,
    Web-Layer kompiliert mit Auth + Plattform-Bereich-Gerüst).
-2. Fragebogen mit adaptiver Logik
-3. Ableitungen und harte Filter (Auswertung gegen echte Antworten)
+2. ~~Fragebogen mit adaptiver Logik~~ — **erledigt** (`GET /antraege/neu`
+   einseitiges Formular, `POST /antraege` legt an und reicht direkt ein,
+   `GET /antraege` eigene Anträge, `GET /antraege/{id}` Detail. Adaptive
+   Folgefragen C2/C3 rein per CSS `:has()` ein-/ausgeblendet, kein
+   JavaScript. `antworten`-JSON nutzt exakt die Fakten-Schlüssel aus
+   `rules/*.yaml` (b1-b7, c1-c5, c2_folge, c3_art) — das hat auch die
+   OPEN.md-Frage zu den "verboten"-Fragebogen-Feldern final geklärt.)
+3. ~~Ableitungen und harte Filter~~ — **erledigt** (`internal/rules`:
+   `EvaluateDatenklasse`/`EvaluateEinstufung`/`DeriveAnforderungen`/
+   `IstVerboten`/`FilterWerkzeuge`, vollständig getestet gegen die
+   echten `rules/*.yaml`-Dateien. Noch nicht ans Web angebunden.)
 4. Ergebnisdarstellung mit Herleitung
 5. Entscheidung, Snapshot, Audit-Log
 6. Registereintrag und Export
@@ -526,11 +542,15 @@ journalctl -u deklarix -f
 ## Offene Punkte
 
 - **Rangfolge der Datenklassen und Grenzfälle im Anforderungsprofil**
-  (siehe `rules/OPEN.md`) — vor Schritt 3 mit dem/der fachlich
-  Verantwortlichen (z. B. Datenschutzbeauftragte/r) bestätigen.
-- **Genaue Fragebogen-Felder für die drei "verboten"-Varianten** (KI-VO
-  Art. 5) — Fragebogen-Spezifikation nennt nur eine C3-Frage ohne die
-  nötige Unterscheidung, siehe `rules/OPEN.md`.
+  (siehe `rules/OPEN.md`, Punkte 1/2/5/6) — mit dem/der fachlich
+  Verantwortlichen (z. B. Datenschutzbeauftragte/r) bestätigen. Schritt
+  3 ist trotzdem schon umgesetzt (auf Basis dieser dokumentierten
+  Annahmen) — nicht auf die Klärung gewartet, um nicht blockiert zu
+  bleiben, aber die Ableitung kann sich noch ändern.
+- ~~Genaue Fragebogen-Felder für die drei "verboten"-Varianten~~ —
+  **erledigt in Schritt 2**, C3 hat jetzt eine Folgefrage `c3_art`.
+  Weiterhin offen: ob die drei Varianten fachlich vollständig sind
+  (siehe `rules/OPEN.md`, Punkt 3).
 - **Löschfristen je Datenklasse** (konkrete Tageswerte für
   `loeschfrist_max_tage`) — noch nicht fachlich festgelegt.
 - **Mandantenisolation auf Datenbankebene (Postgres Row-Level Security)**

internal/rules/evaluate.go

@@ -0,0 +1,207 @@
+package rules
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Antworten ist die im Antrag gespeicherte Fragebogen-Antwort-Menge —
+// dieselbe Struktur, die internal/web/antrag_handlers.go erzeugt
+// (antwortenFromForm): ein flaches JSON-Objekt mit denselben
+// Fakten-Schlüsseln wie in den Regelwerk-YAML-Dateien (b1..b7, c1..c5,
+// c2_folge, c3_art).
+type Antworten map[string]any
+
+// ParseAntworten liest antrag.antworten (rohes JSON aus der Datenbank).
+func ParseAntworten(raw []byte) (Antworten, error) {
+	if len(raw) == 0 {
+		return Antworten{}, nil
+	}
+	var m map[string]any
+	if err := json.Unmarshal(raw, &m); err != nil {
+		return nil, fmt.Errorf("rules: antworten parsen: %w", err)
+	}
+	return Antworten(m), nil
+}
+
+// istJaOderUnsicher prüft eine B-Frage. "Unsicher zählt wie Ja" ist eine
+// Auswertungsregel (siehe CLAUDE.md, Fragebogen-Abschnitt B) — deshalb
+// hier und nicht schon beim Speichern des Antrags angewendet.
+func (a Antworten) istJaOderUnsicher(key string) bool {
+	v, _ := a[key].(string)
+	return v == "ja" || v == "unsicher"
+}
+
+// EvaluateDatenklasse leitet die Datenklasse aus den B-Antworten ab.
+// "Höchste zutreffende Stufe gewinnt" (höherer Rang gewinnt). Trifft
+// keine Stufe zu (z. B. wenn versehentlich auch B7 mit "nein"
+// beantwortet wurde, obwohl keine andere Kategorie zutrifft — ein
+// eigentlich widersprüchlicher Fragebogen-Zustand), wird konservativ
+// "intern" angenommen statt "oeffentlich": im Zweifel mehr Schutz, nicht
+// weniger. Siehe rules/OPEN.md, Punkt 5.
+func EvaluateDatenklasse(regelwerk DatenklasseRegelwerk, antworten Antworten) string {
+	const fallback = "intern"
+	var gewinner *DatenklasseStufe
+	for i := range regelwerk.Stufen {
+		st := &regelwerk.Stufen[i]
+		for _, ausloeser := range st.Ausloeser {
+			if antworten.istJaOderUnsicher(ausloeser) {
+				if gewinner == nil || st.Rang > gewinner.Rang {
+					gewinner = st
+				}
+				break
+			}
+		}
+	}
+	if gewinner == nil {
+		return fallback
+	}
+	return gewinner.ID
+}
+
+// variantePasst prüft, ob alle Schlüssel-Werte-Paare einer Variante zu
+// den Antworten passen (UND-Verknüpfung innerhalb der Variante).
+func variantePasst(variante EinstufungVariante, antworten Antworten) bool {
+	for key, want := range variante {
+		got, ok := antworten[key]
+		if !ok {
+			return false
+		}
+		switch wantVal := want.(type) {
+		case bool:
+			gotBool, ok := got.(bool)
+			if !ok || gotBool != wantVal {
+				return false
+			}
+		case string:
+			gotStr, ok := got.(string)
+			if !ok || gotStr != wantVal {
+				return false
+			}
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// EvaluateEinstufung leitet die KI-VO-Einstufung aus den C-Antworten ab.
+// Prüfreihenfolge: die erste zutreffende Stufe gewinnt (siehe
+// Bewertungslogik, K.-o.-Prüfung) — deshalb steht "verboten" in
+// rules/kivo_einstufung.yaml an erster Stelle. Liefert einen Fehler nur,
+// wenn das Regelwerk selbst keine Auffangregel definiert (sollte durch
+// LoadEinstufung bereits verhindert sein).
+func EvaluateEinstufung(regelwerk EinstufungRegelwerk, antworten Antworten) (string, error) {
+	for _, st := range regelwerk.Stufen {
+		if len(st.Varianten) == 0 {
+			return st.ID, nil // Auffangregel, z. B. "minimal"
+		}
+		for _, variante := range st.Varianten {
+			if variantePasst(variante, antworten) {
+				return st.ID, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("rules: keine einstufung trifft zu und keine auffangregel definiert")
+}
+
+// IstVerboten prüft die K.-o.-Bedingung (Art. 5 KI-VO): bei "verboten"
+// erfolgt sofortige Ablehnung, keine Werkzeugsuche.
+func IstVerboten(einstufungID string) bool {
+	return einstufungID == "verboten"
+}
+
+// DeriveAnforderungen leitet aus Datenklasse und Einstufung die Menge
+// der Anforderungen ab, die ein Werkzeug erfüllen muss.
+func DeriveAnforderungen(regelwerk AnforderungsRegelwerk, datenklasseID, einstufungID string) []string {
+	var out []string
+	for _, a := range regelwerk.Anforderungen {
+		if containsString(a.AusDatenklassen, datenklasseID) || containsString(a.AusEinstufungen, einstufungID) {
+			out = append(out, a.ID)
+		}
+	}
+	return out
+}
+
+func containsString(list []string, v string) bool {
+	for _, x := range list {
+		if x == v {
+			return true
+		}
+	}
+	return false
+}
+
+// WerkzeugEigenschaften sind die für die harte Filterung relevanten
+// Felder eines Katalogeintrags — bewusst ein eigener, schlanker Typ
+// statt store.Werkzeug direkt zu verwenden: internal/rules bleibt so
+// unabhängig von internal/store und für sich allein testbar.
+type WerkzeugEigenschaften struct {
+	AVVVerfuegbar    bool
+	Verarbeitungsort string
+	TrainingOptOut   bool
+	TrainingStandard bool
+	AufbewahrungTage int
+}
+
+// ErfuelltAnforderung prüft, ob ein Werkzeug eine einzelne Anforderung
+// erfüllt. Anforderungen, die einen Prozess statt eine technische
+// Werkzeug-Eigenschaft betreffen (menschliche Aufsicht, Kennzeichnung,
+// DSFA) werden hier nicht hart gefiltert — sie werden als Auflage
+// vermerkt (spätere Ausbaustufe), nicht als Ausschlussgrund für das
+// Werkzeug selbst. loeschfrist_max_tage hat noch keine fachlich
+// festgelegten Tageswerte (rules/OPEN.md, Punkt 4) und wird deshalb
+// ebenfalls noch nicht hart gefiltert.
+func ErfuelltAnforderung(anforderungID string, w WerkzeugEigenschaften) bool {
+	switch anforderungID {
+	case "avv_erforderlich":
+		return w.AVVVerfuegbar
+	case "eu_verarbeitung":
+		return w.Verarbeitungsort == "EU"
+	case "kein_training_auf_eingabe":
+		return w.TrainingStandard
+	default:
+		return true
+	}
+}
+
+// AusschlussGrund hält fest, warum ein Werkzeug aussortiert wurde —
+// auch aussortierte Werkzeuge werden im Ergebnis gezeigt (siehe
+// Bewertungslogik), nie stillschweigend weggelassen.
+type AusschlussGrund struct {
+	WerkzeugID    string
+	NichtErfuellt []string
+}
+
+// WerkzeugKandidat ist ein Katalogeintrag im harten Filter.
+type WerkzeugKandidat struct {
+	ID            string
+	Eigenschaften WerkzeugEigenschaften
+}
+
+// FilterWerkzeuge sortiert Werkzeuge aus, die mindestens eine
+// Pflichtanforderung nicht erfüllen, und hält für jedes ausgeschlossene
+// Werkzeug fest, welche Anforderungen fehlten.
+func FilterWerkzeuge(kandidaten []WerkzeugKandidat, anforderungIDs []string) (zulaessig []string, ausgeschlossen []AusschlussGrund) {
+	for _, k := range kandidaten {
+		var fehlend []string
+		for _, reqID := range anforderungIDs {
+			if !ErfuelltAnforderung(reqID, k.Eigenschaften) {
+				fehlend = append(fehlend, reqID)
+			}
+		}
+		if len(fehlend) == 0 {
+			zulaessig = append(zulaessig, k.ID)
+		} else {
+			ausgeschlossen = append(ausgeschlossen, AusschlussGrund{WerkzeugID: k.ID, NichtErfuellt: fehlend})
+		}
+	}
+	return zulaessig, ausgeschlossen
+}
+
+// String liefert eine lesbare Begründung, z. B. für die spätere
+// Ergebnisdarstellung (Schritt 4).
+func (a AusschlussGrund) String() string {
+	return fmt.Sprintf("%s: erfüllt nicht %s", a.WerkzeugID, strings.Join(a.NichtErfuellt, ", "))
+}

internal/rules/evaluate_test.go

@@ -0,0 +1,208 @@
+package rules_test
+
+import (
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/rules"
+)
+
+func loadRealRegelwerke(t *testing.T) (rules.DatenklasseRegelwerk, rules.EinstufungRegelwerk, rules.AnforderungsRegelwerk) {
+	t.Helper()
+	fsys := realRulesFS(t)
+	dk, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml")
+	if err != nil {
+		t.Fatalf("LoadDatenklasse: %v", err)
+	}
+	ei, err := rules.LoadEinstufung(fsys, "kivo_einstufung.yaml")
+	if err != nil {
+		t.Fatalf("LoadEinstufung: %v", err)
+	}
+	an, err := rules.LoadAnforderungen(fsys, "anforderungen.yaml")
+	if err != nil {
+		t.Fatalf("LoadAnforderungen: %v", err)
+	}
+	return dk, ei, an
+}
+
+func TestEvaluateDatenklasseOnlyOeffentlich(t *testing.T) {
+	dk, _, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"b1": "nein", "b2": "nein", "b3": "nein", "b4": "nein", "b5": "nein", "b6": "nein", "b7": "ja"}
+	got := rules.EvaluateDatenklasse(dk, antworten)
+	if got != "oeffentlich" {
+		t.Fatalf("EvaluateDatenklasse = %q, want oeffentlich", got)
+	}
+}
+
+func TestEvaluateDatenklasseHighestWins(t *testing.T) {
+	dk, _, _ := loadRealRegelwerke(t)
+	// b1 (personenbezogen) UND b2 (besondere_kategorie) beide ja ->
+	// besondere_kategorie hat den hoeheren Rang und muss gewinnen.
+	antworten := rules.Antworten{"b1": "ja", "b2": "ja", "b7": "nein"}
+	got := rules.EvaluateDatenklasse(dk, antworten)
+	if got != "besondere_kategorie" {
+		t.Fatalf("EvaluateDatenklasse = %q, want besondere_kategorie", got)
+	}
+}
+
+func TestEvaluateDatenklasseUnsicherZaehltWieJa(t *testing.T) {
+	dk, _, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"b3": "unsicher"}
+	got := rules.EvaluateDatenklasse(dk, antworten)
+	if got != "berufsgeheimnis" {
+		t.Fatalf("EvaluateDatenklasse = %q, want berufsgeheimnis (unsicher zaehlt wie ja)", got)
+	}
+}
+
+func TestEvaluateDatenklasseFallsBackToInternWhenNothingMatches(t *testing.T) {
+	dk, _, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"b1": "nein", "b2": "nein", "b3": "nein", "b4": "nein", "b5": "nein", "b6": "nein", "b7": "nein"}
+	got := rules.EvaluateDatenklasse(dk, antworten)
+	if got != "intern" {
+		t.Fatalf("EvaluateDatenklasse = %q, want intern (konservativer Fallback)", got)
+	}
+}
+
+func TestEvaluateEinstufungVerboten(t *testing.T) {
+	_, ei, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"c3": true, "c3_art": "social_scoring"}
+	got, err := rules.EvaluateEinstufung(ei, antworten)
+	if err != nil {
+		t.Fatalf("EvaluateEinstufung: %v", err)
+	}
+	if got != "verboten" {
+		t.Fatalf("EvaluateEinstufung = %q, want verboten", got)
+	}
+	if !rules.IstVerboten(got) {
+		t.Error("IstVerboten sollte true liefern")
+	}
+}
+
+func TestEvaluateEinstufungHochrisiko(t *testing.T) {
+	_, ei, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"c2": true, "c2_folge": "kreditwuerdigkeit", "c3": false}
+	got, err := rules.EvaluateEinstufung(ei, antworten)
+	if err != nil {
+		t.Fatalf("EvaluateEinstufung: %v", err)
+	}
+	if got != "hochrisiko" {
+		t.Fatalf("EvaluateEinstufung = %q, want hochrisiko", got)
+	}
+}
+
+func TestEvaluateEinstufungTransparenzpflicht(t *testing.T) {
+	_, ei, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"c1": true, "c2": false, "c3": false, "c5": false}
+	got, err := rules.EvaluateEinstufung(ei, antworten)
+	if err != nil {
+		t.Fatalf("EvaluateEinstufung: %v", err)
+	}
+	if got != "transparenzpflicht" {
+		t.Fatalf("EvaluateEinstufung = %q, want transparenzpflicht", got)
+	}
+}
+
+func TestEvaluateEinstufungMinimalFallback(t *testing.T) {
+	_, ei, _ := loadRealRegelwerke(t)
+	antworten := rules.Antworten{"c1": false, "c2": false, "c3": false, "c4": false, "c5": true}
+	got, err := rules.EvaluateEinstufung(ei, antworten)
+	if err != nil {
+		t.Fatalf("EvaluateEinstufung: %v", err)
+	}
+	if got != "minimal" {
+		t.Fatalf("EvaluateEinstufung = %q, want minimal", got)
+	}
+	if rules.IstVerboten(got) {
+		t.Error("IstVerboten sollte fuer minimal false liefern")
+	}
+}
+
+func TestDeriveAnforderungenPersonenbezogen(t *testing.T) {
+	_, _, an := loadRealRegelwerke(t)
+	got := rules.DeriveAnforderungen(an, "personenbezogen", "minimal")
+	want := map[string]bool{"avv_erforderlich": true, "kein_training_auf_eingabe": true, "loeschfrist_max_tage": true}
+	gotSet := map[string]bool{}
+	for _, id := range got {
+		gotSet[id] = true
+	}
+	for id := range want {
+		if !gotSet[id] {
+			t.Errorf("expected Anforderung %q for personenbezogen/minimal, got %v", id, got)
+		}
+	}
+	if gotSet["eu_verarbeitung"] {
+		t.Error("eu_verarbeitung sollte fuer personenbezogen (ohne berufsgeheimnis/besondere_kategorie) nicht ausgeloest werden")
+	}
+}
+
+func TestDeriveAnforderungenHochrisikoAddsAufsichtUndDsfa(t *testing.T) {
+	_, _, an := loadRealRegelwerke(t)
+	got := rules.DeriveAnforderungen(an, "oeffentlich", "hochrisiko")
+	gotSet := map[string]bool{}
+	for _, id := range got {
+		gotSet[id] = true
+	}
+	if !gotSet["menschliche_aufsicht"] || !gotSet["dsfa_erforderlich"] {
+		t.Errorf("expected menschliche_aufsicht und dsfa_erforderlich fuer hochrisiko, got %v", got)
+	}
+}
+
+func TestErfuelltAnforderungAVV(t *testing.T) {
+	if rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: false}) {
+		t.Error("erwartet: nicht erfuellt ohne AVV")
+	}
+	if !rules.ErfuelltAnforderung("avv_erforderlich", rules.WerkzeugEigenschaften{AVVVerfuegbar: true}) {
+		t.Error("erwartet: erfuellt mit AVV")
+	}
+}
+
+func TestErfuelltAnforderungUnbekannteAnforderungIstUnkritisch(t *testing.T) {
+	if !rules.ErfuelltAnforderung("menschliche_aufsicht", rules.WerkzeugEigenschaften{}) {
+		t.Error("Prozess-Anforderungen duerfen ein Werkzeug nicht hart aussortieren")
+	}
+}
+
+func TestFilterWerkzeugeSortsOutMissingAVV(t *testing.T) {
+	kandidaten := []rules.WerkzeugKandidat{
+		{ID: "mit-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: true, Verarbeitungsort: "EU", TrainingStandard: true}},
+		{ID: "ohne-avv", Eigenschaften: rules.WerkzeugEigenschaften{AVVVerfuegbar: false, Verarbeitungsort: "EU", TrainingStandard: true}},
+	}
+	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, []string{"avv_erforderlich"})
+	if len(zulaessig) != 1 || zulaessig[0] != "mit-avv" {
+		t.Fatalf("zulaessig = %v, want [mit-avv]", zulaessig)
+	}
+	if len(ausgeschlossen) != 1 || ausgeschlossen[0].WerkzeugID != "ohne-avv" {
+		t.Fatalf("ausgeschlossen = %v, want genau ohne-avv", ausgeschlossen)
+	}
+	if len(ausgeschlossen[0].NichtErfuellt) != 1 || ausgeschlossen[0].NichtErfuellt[0] != "avv_erforderlich" {
+		t.Fatalf("NichtErfuellt = %v, want [avv_erforderlich]", ausgeschlossen[0].NichtErfuellt)
+	}
+}
+
+func TestFilterWerkzeugeNoRequirementsAllowsEverything(t *testing.T) {
+	kandidaten := []rules.WerkzeugKandidat{{ID: "x"}, {ID: "y"}}
+	zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, nil)
+	if len(zulaessig) != 2 || len(ausgeschlossen) != 0 {
+		t.Fatalf("zulaessig=%v ausgeschlossen=%v, want beide zulaessig", zulaessig, ausgeschlossen)
+	}
+}
+
+func TestParseAntwortenRoundTrip(t *testing.T) {
+	raw := []byte(`{"b1":"ja","c2":true,"c2_folge":"bildung"}`)
+	a, err := rules.ParseAntworten(raw)
+	if err != nil {
+		t.Fatalf("ParseAntworten: %v", err)
+	}
+	if a["b1"] != "ja" || a["c2_folge"] != "bildung" {
+		t.Fatalf("ParseAntworten = %+v, unerwartete Werte", a)
+	}
+}
+
+func TestParseAntwortenEmpty(t *testing.T) {
+	a, err := rules.ParseAntworten(nil)
+	if err != nil {
+		t.Fatalf("ParseAntworten: %v", err)
+	}
+	if len(a) != 0 {
+		t.Fatalf("ParseAntworten(nil) = %+v, want empty", a)
+	}
+}

internal/store/antrag.go

@@ -109,6 +109,33 @@ func (s *Store) SetAntragStatus(ctx context.Context, id, status string) error {
 	return nil
 }
 
+// ListAntraegeForUser liefert alle Anträge, die ein bestimmter Nutzer
+// gestellt hat, neueste zuerst — für Ebene 2 ("eigene Anträge
+// einsehen"), im Unterschied zu ListAntraegeForAccount, das alle
+// Anträge eines Mandanten liefert (Ebene 3, Posteingang).
+func (s *Store) ListAntraegeForUser(ctx context.Context, erstellerUserID string) ([]Antrag, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT `+antragColumns+` FROM antrag WHERE ersteller_user_id = $1 ORDER BY created_at DESC
+	`, erstellerUserID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list antraege for user: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Antrag
+	for rows.Next() {
+		a, err := scanAntrag(rows)
+		if err != nil {
+			return nil, fmt.Errorf("store: scan antrag: %w", err)
+		}
+		out = append(out, a)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list antraege for user: %w", err)
+	}
+	return out, nil
+}
+
 // ListAntraegeForAccount liefert alle Anträge eines Mandanten, neueste
 // zuerst.
 func (s *Store) ListAntraegeForAccount(ctx context.Context, accountID string) ([]Antrag, error) {

internal/store/antrag_test.go

@@ -82,6 +82,32 @@ func TestSetAntragStatusNotFound(t *testing.T) {
 	}
 }
 
+func TestListAntraegeForUserOnlyReturnsOwnAntraege(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	userA := testUserID(t, s, accID)
+	userB, err := s.CreateUser(ctx, accID, "zweiter-mitarbeiter-"+accID+"@example.com", "hash", "mitarbeiter")
+	if err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+
+	if _, err := s.CreateAntrag(ctx, accID, userA, nil, "Antrag von A"); err != nil {
+		t.Fatalf("CreateAntrag (A): %v", err)
+	}
+	if _, err := s.CreateAntrag(ctx, accID, userB.ID, nil, "Antrag von B"); err != nil {
+		t.Fatalf("CreateAntrag (B): %v", err)
+	}
+
+	listA, err := s.ListAntraegeForUser(ctx, userA)
+	if err != nil {
+		t.Fatalf("ListAntraegeForUser: %v", err)
+	}
+	if len(listA) != 1 || listA[0].Titel != "Antrag von A" {
+		t.Fatalf("ListAntraegeForUser(A) = %+v, want exactly Antrag von A", listA)
+	}
+}
+
 func TestListAntraegeForAccountIsolatesTenants(t *testing.T) {
 	s := openTestStore(t)
 	ctx := context.Background()

internal/store/migrations/0008_pivot_ki_antragspruefung.up.sql

@@ -29,9 +29,22 @@ ALTER TABLE account DROP COLUMN IF EXISTS verified;
 --   betreiber        Ebene 5 — Netcell-IT-Personal, plattformweit
 --                     (Werkzeugkatalog, Regelwerk, Mandantenverwaltung);
 --                     entspricht der alten "admin"-Rolle vor dieser Migration
--- Die alten Rollen (creator/agentur/marke/kanzlei) haben im neuen
--- Produkt keine Bedeutung mehr.
+--
+-- Die alte CHECK-Constraint muss zuerst weg, sonst lehnt sie die
+-- Datenmigration unten (die neue Rollenwerte wie "betreiber" schreibt)
+-- sofort ab — die alte Constraint kennt diese Werte ja noch nicht.
 ALTER TABLE app_user DROP CONSTRAINT app_user_role_check;
+
+-- Bestehende Zeilen auf gültige neue Werte umstellen, bevor die neue
+-- Constraint das erzwingt — sonst schlägt sie auf jeder Installation
+-- mit echten Nutzern fehl. Die alte Rolle "admin" war der Plattform-
+-- Betreiber (Netcell-IT) — wird zu "betreiber", nicht zum neuen,
+-- mandantenbezogenen "admin". Alle anderen alten Rollen (creator/agentur/
+-- marke/kanzlei) waren gewöhnliche Mandanten-Logins ohne Sonderrechte —
+-- werden zu "mitarbeiter", der schlankesten neuen Rolle.
+UPDATE app_user SET role = 'betreiber' WHERE role = 'admin';
+UPDATE app_user SET role = 'mitarbeiter' WHERE role IN ('creator', 'agentur', 'marke', 'kanzlei');
+
 ALTER TABLE app_user ADD CONSTRAINT app_user_role_check
     CHECK (role IN ('mitarbeiter', 'verantwortlicher', 'pruefer', 'admin', 'betreiber'));
 

internal/web/antrag_handlers.go

@@ -0,0 +1,213 @@
+package web
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+// antwortenB/C/D-Feldnamen sind bewusst identisch zu den Fakten-
+// Schlüsseln in rules/datenklasse.yaml (b1..b7) und
+// rules/kivo_einstufung.yaml (c1..c5, c2_folge, c3_art) — Schritt 3
+// (Ableitungen) liest dieselben Schlüssel direkt aus antrag.antworten,
+// ohne sie erst umbenennen zu müssen.
+var datenfragen = []struct {
+	Key   string
+	Label string
+}{
+	{"b1", "Namen, E-Mail-Adressen oder andere Angaben zu Personen"},
+	{"b2", "Angaben zu Gesundheit, Religion, Herkunft, Gewerkschaft, Sexualleben"},
+	{"b3", "Daten von Patienten, Mandanten oder Versicherten"},
+	{"b4", "Bewerbungs-, Personal- oder Leistungsdaten von Beschäftigten"},
+	{"b5", "Daten, die uns ein Kunde anvertraut hat"},
+	{"b6", "Konstruktions-, Kalkulations- oder Vertragsunterlagen"},
+	{"b7", "Nur allgemein zugängliche oder selbst erfundene Inhalte"},
+}
+
+type antragFormData struct {
+	Title       string
+	Nav         navData
+	Abteilungen []store.Abteilung
+	Datenfragen []struct {
+		Key   string
+		Label string
+	}
+	Error string
+}
+
+// handleAntragNewForm zeigt den Fragebogen (Ebene 2, "Antrag stellen").
+// Bewusst eine einzelne Seite statt eines mehrseitigen Assistenten —
+// jede zusätzliche Seite kostet Zeit, und "dauert der Antrag länger als
+// fünf Minuten, wird er umgangen" (siehe CLAUDE.md). Adaptive
+// Folgefragen (C2/C3) werden rein clientseitig per CSS ein-/ausgeblendet,
+// ohne zusätzlichen Server-Roundtrip.
+func (s *Server) handleAntragNewForm(w http.ResponseWriter, r *http.Request) {
+	if currentUser(r).Role == "betreiber" {
+		http.Redirect(w, r, "/betreiber", http.StatusSeeOther)
+		return
+	}
+	abteilungen, err := s.store.ListAbteilungenForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Abteilungen konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := antragFormData{Title: "Antrag stellen", Nav: navFor(r), Abteilungen: abteilungen, Datenfragen: datenfragen}
+	if err := s.templates.ExecuteTemplate(w, "antrag-neu", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// antworten ist die JSON-Struktur, die in antrag.antworten gespeichert
+// wird — ein flaches Objekt aus den Fragebogen-Fakten-Schlüsseln.
+// "Unsicher" wird für B unverändert als "unsicher" gespeichert, NICHT
+// zu "ja" normalisiert: diese Normalisierung ("Unsicher zählt wie Ja")
+// ist eine Auswertungsregel (Schritt 3), keine Speicherregel — was der
+// Mitarbeiter tatsächlich geantwortet hat, bleibt im Antrag unverändert
+// erhalten.
+func antwortenFromForm(r *http.Request) []byte {
+	m := map[string]any{}
+	for _, f := range datenfragen {
+		v := r.FormValue(f.Key)
+		if v == "" {
+			v = "nein"
+		}
+		m[f.Key] = v
+	}
+	m["c1"] = r.FormValue("c1") == "ja"
+	m["c2"] = r.FormValue("c2") == "ja"
+	m["c2_folge"] = r.FormValue("c2_folge")
+	m["c3"] = r.FormValue("c3") == "ja"
+	m["c3_art"] = r.FormValue("c3_art")
+	m["c4"] = r.FormValue("c4") == "ja"
+	m["c5"] = r.FormValue("c5") == "ja"
+	m["d_werkzeug_freitext"] = r.FormValue("d_werkzeug_freitext")
+	m["d_zugang"] = r.FormValue("d_zugang")
+	m["d_geraet"] = r.FormValue("d_geraet")
+
+	data, _ := json.Marshal(m) // map[string]any mit nur primitiven Werten kann nicht scheitern
+	return data
+}
+
+// handleAntragCreate legt einen Antrag an und reicht ihn direkt ein
+// (entwurf -> eingereicht in einem Schritt) — der Fragebogen ist eine
+// einzelne Seite, ein Zwischenspeichern als Entwurf ist für v1 nicht
+// vorgesehen.
+func (s *Server) handleAntragCreate(w http.ResponseWriter, r *http.Request) {
+	if currentUser(r).Role == "betreiber" {
+		http.Redirect(w, r, "/betreiber", http.StatusSeeOther)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	titel := r.FormValue("titel")
+	beschreibung := r.FormValue("beschreibung")
+	ergebnis := r.FormValue("ergebnis")
+	haeufigkeit := r.FormValue("haeufigkeit")
+	if titel == "" || beschreibung == "" || ergebnis == "" || haeufigkeit == "" {
+		http.Error(w, "Titel, Beschreibung, Ergebnis und Häufigkeit sind Pflichtfelder", http.StatusBadRequest)
+		return
+	}
+	var abteilungID *string
+	if v := r.FormValue("abteilung_id"); v != "" {
+		abteilungID = &v
+	}
+
+	ctx := r.Context()
+	user := currentUser(r)
+
+	antrag, err := s.store.CreateAntrag(ctx, user.AccountID, user.ID, abteilungID, titel)
+	if err != nil {
+		http.Error(w, "Antrag konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if _, err := s.store.UpdateAntragFelder(ctx, antrag.ID, titel, beschreibung, ergebnis, haeufigkeit, antwortenFromForm(r)); err != nil {
+		http.Error(w, "Antrag konnte nicht gespeichert werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if err := s.store.SetAntragStatus(ctx, antrag.ID, "eingereicht"); err != nil {
+		http.Error(w, "Antrag konnte nicht eingereicht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, "/antraege/"+antrag.ID, http.StatusSeeOther)
+}
+
+type antragListItem struct {
+	ID          string
+	Titel       string
+	Status      string
+	Haeufigkeit string
+	CreatedAt   string
+}
+
+type antragListData struct {
+	Title    string
+	Nav      navData
+	Antraege []antragListItem
+}
+
+// handleAntragList zeigt die eigenen Anträge (Ebene 2 — "Eigene
+// Anträge einsehen, Status verfolgen"), nicht die des ganzen Mandanten.
+func (s *Server) handleAntragList(w http.ResponseWriter, r *http.Request) {
+	if currentUser(r).Role == "betreiber" {
+		http.Redirect(w, r, "/betreiber", http.StatusSeeOther)
+		return
+	}
+	list, err := s.store.ListAntraegeForUser(r.Context(), currentUser(r).ID)
+	if err != nil {
+		http.Error(w, "Anträge konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := antragListData{Title: "Meine Anträge", Nav: navFor(r)}
+	for _, a := range list {
+		data.Antraege = append(data.Antraege, antragListItem{
+			ID: a.ID, Titel: a.Titel, Status: a.Status, Haeufigkeit: a.Haeufigkeit,
+			CreatedAt: a.CreatedAt.Format("02.01.2006 15:04"),
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "antraege-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+type antragDetailData struct {
+	Title        string
+	Nav          navData
+	ID           string
+	Titel        string
+	Beschreibung string
+	Ergebnis     string
+	Haeufigkeit  string
+	Status       string
+	CreatedAt    string
+	Antworten    map[string]any
+}
+
+// handleAntragDetail zeigt einen einzelnen Antrag mit allen Antworten.
+// Ein Antrag eines fremden Nutzers wird wie ein nicht existierender
+// behandelt (404), nie mit einer expliziten 403 bestätigt — dasselbe
+// Muster wie schon beim alten Produkt für fremde Mandanten.
+func (s *Server) handleAntragDetail(w http.ResponseWriter, r *http.Request) {
+	antrag, err := s.store.GetAntrag(r.Context(), r.PathValue("id"))
+	if err != nil || antrag.ErstellerUserID != currentUser(r).ID {
+		http.Error(w, "Antrag nicht gefunden", http.StatusNotFound)
+		return
+	}
+
+	var antworten map[string]any
+	if len(antrag.Antworten) > 0 {
+		_ = json.Unmarshal(antrag.Antworten, &antworten)
+	}
+
+	data := antragDetailData{
+		Title: "Antrag", Nav: navFor(r), ID: antrag.ID, Titel: antrag.Titel,
+		Beschreibung: antrag.Beschreibung, Ergebnis: antrag.Ergebnis, Haeufigkeit: antrag.Haeufigkeit,
+		Status: antrag.Status, CreatedAt: antrag.CreatedAt.Format("02.01.2006 15:04"), Antworten: antworten,
+	}
+	if err := s.templates.ExecuteTemplate(w, "antrag-detail", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}

internal/web/antrag_handlers_test.go

@@ -0,0 +1,136 @@
+package web_test
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func fullAntragForm() url.Values {
+	return url.Values{
+		"titel": {"Angebotstexte generieren"}, "beschreibung": {"KI schreibt Angebotstexte"},
+		"ergebnis": {"Fertiger Text zur Freigabe"}, "haeufigkeit": {"gelegentlich"},
+		"b1": {"ja"}, "b2": {"nein"}, "b3": {"nein"}, "b4": {"nein"}, "b5": {"nein"}, "b6": {"nein"}, "b7": {"nein"},
+		"c1": {"nein"}, "c2": {"nein"}, "c2_folge": {"keine"}, "c3": {"nein"}, "c3_art": {"keine"},
+		"c4": {"nein"}, "c5": {"ja"},
+		"d_werkzeug_freitext": {"ChatGPT"}, "d_zugang": {"firma"}, "d_geraet": {"firma"},
+	}
+}
+
+func TestAntragNewFormRendersFragebogen(t *testing.T) {
+	s, _, cookie := newAuthedTestServer(t)
+
+	resp := getWithCookie(t, s, cookie, "/antraege/neu")
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	body := resp.Body.String()
+	for _, want := range []string{`name="titel"`, `name="b1"`, `name="c2_folge"`, `name="d_zugang"`} {
+		if !strings.Contains(body, want) {
+			t.Errorf("expected %q in the Fragebogen, got: %s", want, body)
+		}
+	}
+}
+
+func TestAntragCreateThenDetailShowsAnswers(t *testing.T) {
+	s, fs, cookie := newAuthedTestServer(t)
+
+	resp := postForm(t, s, cookie, "/antraege", fullAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+	loc := resp.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/antraege/") {
+		t.Fatalf("Location = %q, want a redirect to the new antrag", loc)
+	}
+
+	var antragID string
+	for id := range fs.antraege {
+		antragID = id
+	}
+	antrag, err := fs.GetAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetAntrag: %v", err)
+	}
+	if antrag.Status != "eingereicht" {
+		t.Fatalf("Status = %q, want eingereicht", antrag.Status)
+	}
+	var antworten map[string]any
+	if err := json.Unmarshal(antrag.Antworten, &antworten); err != nil {
+		t.Fatalf("Antworten unmarshal: %v", err)
+	}
+	if antworten["b1"] != "ja" {
+		t.Errorf("b1 = %v, want ja", antworten["b1"])
+	}
+	if antworten["c5"] != true {
+		t.Errorf("c5 = %v, want true", antworten["c5"])
+	}
+
+	detailResp := getWithCookie(t, s, cookie, loc)
+	if detailResp.Code != http.StatusOK {
+		t.Fatalf("detail status = %d, body: %s", detailResp.Code, detailResp.Body.String())
+	}
+	if !strings.Contains(detailResp.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected the antrag title on the detail page, got: %s", detailResp.Body.String())
+	}
+}
+
+func TestAntragCreateRejectsMissingFields(t *testing.T) {
+	s, _, cookie := newAuthedTestServer(t)
+
+	resp := postForm(t, s, cookie, "/antraege", url.Values{"titel": {"Nur Titel"}})
+	if resp.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400 for missing required fields", resp.Code)
+	}
+}
+
+func TestAntragListShowsOnlyOwnAntraege(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookieA := seedAccount(t, fs, "Mandant A", "a@example.com")
+	cookieB := seedAccount(t, fs, "Mandant B", "b@example.com")
+
+	if resp := postForm(t, s, cookieA, "/antraege", fullAntragForm()); resp.Code != http.StatusSeeOther {
+		t.Fatalf("create (A) status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+
+	listA := getWithCookie(t, s, cookieA, "/antraege")
+	if !strings.Contains(listA.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected Mandant A to see their own antrag, got: %s", listA.Body.String())
+	}
+	listB := getWithCookie(t, s, cookieB, "/antraege")
+	if strings.Contains(listB.Body.String(), "Angebotstexte generieren") {
+		t.Errorf("expected Mandant B to see no antrag, got: %s", listB.Body.String())
+	}
+}
+
+func TestAntragDetailRejectsForeignUser(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookieA := seedAccount(t, fs, "Mandant A", "a@example.com")
+	cookieB := seedAccount(t, fs, "Mandant B", "b@example.com")
+
+	createResp := postForm(t, s, cookieA, "/antraege", fullAntragForm())
+	antragURL := createResp.Header().Get("Location")
+
+	resp := getWithCookie(t, s, cookieB, antragURL)
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a foreign user's antrag", resp.Code)
+	}
+}
+
+func TestBetreiberRedirectedAwayFromAntragPages(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	for _, path := range []string{"/antraege", "/antraege/neu"} {
+		resp := getWithCookie(t, s, betreiberCookie, path)
+		if resp.Code != http.StatusSeeOther {
+			t.Errorf("GET %s status = %d, want 303 redirect for a betreiber", path, resp.Code)
+		}
+	}
+}

internal/web/server.go

@@ -39,6 +39,13 @@ type Store interface {
 	DeleteSession(ctx context.Context, token string) error
 	CreateAuditEntry(ctx context.Context, actorUserID, action, targetType, targetID, details string) (store.AuditEntry, error)
 	ListAuditLog(ctx context.Context, limit int) ([]store.AuditEntry, error)
+
+	ListAbteilungenForAccount(ctx context.Context, accountID string) ([]store.Abteilung, error)
+	CreateAntrag(ctx context.Context, accountID, erstellerUserID string, abteilungID *string, titel string) (store.Antrag, error)
+	GetAntrag(ctx context.Context, id string) (store.Antrag, error)
+	UpdateAntragFelder(ctx context.Context, id, titel, beschreibung, ergebnis, haeufigkeit string, antworten []byte) (store.Antrag, error)
+	SetAntragStatus(ctx context.Context, id, status string) error
+	ListAntraegeForUser(ctx context.Context, erstellerUserID string) ([]store.Antrag, error)
 }
 
 // Server bündelt Routing und Abhängigkeiten der Web-Schicht.
@@ -68,6 +75,10 @@ func NewServer(st Store) (*Server, error) {
 	mux.HandleFunc("POST /login", s.handleLogin)
 	mux.HandleFunc("POST /logout", s.handleLogout)
 	mux.HandleFunc("GET /{$}", s.requirePage(s.handleIndex))
+	mux.HandleFunc("GET /antraege", s.requirePage(s.handleAntragList))
+	mux.HandleFunc("GET /antraege/neu", s.requirePage(s.handleAntragNewForm))
+	mux.HandleFunc("POST /antraege", s.requirePage(s.handleAntragCreate))
+	mux.HandleFunc("GET /antraege/{id}", s.requirePage(s.handleAntragDetail))
 	mux.HandleFunc("GET /betreiber", s.requireBetreiber(s.handleBetreiberDashboard))
 	mux.HandleFunc("GET /betreiber/accounts", s.requireBetreiber(s.handleBetreiberAccountList))
 	mux.HandleFunc("GET /betreiber/accounts/{id}", s.requireBetreiber(s.handleBetreiberAccountDetail))

internal/web/server_test.go

@@ -29,6 +29,8 @@ type fakeStore struct {
 	usersByEmail map[string]string // email -> user id
 	sessions     map[string]store.Session
 	auditLog     []store.AuditEntry
+	abteilungen  map[string][]store.Abteilung // accountID -> Abteilungen
+	antraege     map[string]store.Antrag
 }
 
 func newFakeStore() *fakeStore {
@@ -37,6 +39,8 @@ func newFakeStore() *fakeStore {
 		users:        map[string]store.User{},
 		usersByEmail: map[string]string{},
 		sessions:     map[string]store.Session{},
+		abteilungen:  map[string][]store.Abteilung{},
+		antraege:     map[string]store.Antrag{},
 	}
 }
 
@@ -169,6 +173,70 @@ func (f *fakeStore) ListAuditLog(ctx context.Context, limit int) ([]store.AuditE
 	return out, nil
 }
 
+func (f *fakeStore) ListAbteilungenForAccount(ctx context.Context, accountID string) ([]store.Abteilung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.abteilungen[accountID], nil
+}
+
+func (f *fakeStore) CreateAntrag(ctx context.Context, accountID, erstellerUserID string, abteilungID *string, titel string) (store.Antrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	a := store.Antrag{
+		ID: f.newID(), AccountID: accountID, ErstellerUserID: erstellerUserID, AbteilungID: abteilungID,
+		Titel: titel, Status: "entwurf", Antworten: []byte(`{}`), CreatedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	f.antraege[a.ID] = a
+	return a, nil
+}
+
+func (f *fakeStore) GetAntrag(ctx context.Context, id string) (store.Antrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	a, ok := f.antraege[id]
+	if !ok {
+		return store.Antrag{}, store.ErrNotFound
+	}
+	return a, nil
+}
+
+func (f *fakeStore) UpdateAntragFelder(ctx context.Context, id, titel, beschreibung, ergebnis, haeufigkeit string, antworten []byte) (store.Antrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	a, ok := f.antraege[id]
+	if !ok {
+		return store.Antrag{}, store.ErrNotFound
+	}
+	a.Titel, a.Beschreibung, a.Ergebnis, a.Haeufigkeit, a.Antworten = titel, beschreibung, ergebnis, haeufigkeit, antworten
+	a.UpdatedAt = time.Now()
+	f.antraege[id] = a
+	return a, nil
+}
+
+func (f *fakeStore) SetAntragStatus(ctx context.Context, id, status string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	a, ok := f.antraege[id]
+	if !ok {
+		return store.ErrNotFound
+	}
+	a.Status = status
+	f.antraege[id] = a
+	return nil
+}
+
+func (f *fakeStore) ListAntraegeForUser(ctx context.Context, erstellerUserID string) ([]store.Antrag, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Antrag
+	for _, a := range f.antraege {
+		if a.ErstellerUserID == erstellerUserID {
+			out = append(out, a)
+		}
+	}
+	return out, nil
+}
+
 // ─── Test-Setup ───────────────────────────────────────────────────────
 
 func newServer(t *testing.T, fs *fakeStore) *web.Server {

internal/web/static/app.css

@@ -384,6 +384,46 @@ button.entfernen {
   background: #fff;
 }
 
+.fragebogen fieldset {
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  padding: 12px 14px;
+  margin: 12px 0;
+}
+
+.fragebogen legend {
+  font-weight: 500;
+  font-size: 0.9375rem;
+  padding: 0 4px;
+}
+
+.fragebogen fieldset label {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-weight: 400;
+  margin: 4px 12px 4px 0;
+}
+
+.fragebogen fieldset input[type="radio"] {
+  width: auto;
+  min-height: 0;
+}
+
+/* Adaptive Folgefragen: rein clientseitig per :has() ein-/ausgeblendet,
+   kein JavaScript nötig. Siehe templates/antrag_neu.html — die "Ja"-
+   Antwort trägt eine eigene Klasse (c2-ja/c3-ja), damit sich die
+   jeweilige Folgefrage gezielt zuordnen lässt. */
+.mit-folgefrage .folgefrage {
+  display: none;
+  margin-top: 8px;
+}
+
+.mit-folgefrage:has(.c2-ja input:checked) .folgefrage,
+.mit-folgefrage:has(.c3-ja input:checked) .folgefrage {
+  display: block;
+}
+
 /* Ab hier mehr Platz (Tablet/Desktop) — der Container bekommt spürbaren
    Rand statt volle Breite, sonst bleibt alles identisch. */
 @media (min-width: 640px) {

internal/web/templates/antraege_liste.html

@@ -0,0 +1,26 @@
+{{define "antraege-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Meine Anträge</h1>
+{{if not .Antraege}}
+<p class="hinweis">Noch keine Anträge gestellt.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Antraege}}
+  <li>
+    <a href="/antraege/{{.ID}}">
+      <strong>{{.Titel}}</strong> · {{.Haeufigkeit}} · {{.CreatedAt}}
+      <span class="status status-{{.Status}}">{{.Status}}</span>
+    </a>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+<p><a href="/antraege/neu">Neuen Antrag stellen</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/antrag_detail.html

@@ -0,0 +1,24 @@
+{{define "antrag-detail"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/antraege">&larr; Meine Anträge</a></p>
+<h1>{{.Titel}}</h1>
+<p class="hinweis">Eingereicht am {{.CreatedAt}} — Status: <span class="status status-{{.Status}}">{{.Status}}</span></p>
+
+<h2>Vorhaben</h2>
+<p><strong>Was soll die KI tun?</strong><br>{{.Beschreibung}}</p>
+<p><strong>Was soll herauskommen?</strong><br>{{.Ergebnis}}</p>
+<p><strong>Häufigkeit:</strong> {{.Haeufigkeit}}</p>
+
+<p class="hinweis">
+  Die Bewertung (Datenklasse, KI-VO-Einstufung, Werkzeugvorschlag) folgt
+  in einer späteren Ausbaustufe — dieser Antrag ist gespeichert und
+  eingereicht.
+</p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/antrag_neu.html

@@ -0,0 +1,122 @@
+{{define "antrag-neu"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Antrag stellen</h1>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+
+<form method="post" action="/antraege" class="fragebogen">
+  <h2>Vorhaben</h2>
+  <label for="titel">Kurzbezeichnung</label>
+  <input type="text" id="titel" name="titel" required>
+
+  <label for="beschreibung">Was soll die KI tun?</label>
+  <textarea id="beschreibung" name="beschreibung" rows="3" required></textarea>
+
+  <label for="ergebnis">Was soll herauskommen?</label>
+  <textarea id="ergebnis" name="ergebnis" rows="2" required></textarea>
+
+  <label for="haeufigkeit">Häufigkeit</label>
+  <select id="haeufigkeit" name="haeufigkeit" required>
+    <option value="einmalig">einmalig</option>
+    <option value="gelegentlich">gelegentlich</option>
+    <option value="taeglich">täglich</option>
+    <option value="automatisiert">automatisiert</option>
+  </select>
+
+  {{if .Abteilungen}}
+  <label for="abteilung_id">Abteilung</label>
+  <select id="abteilung_id" name="abteilung_id">
+    <option value="">— keine Angabe —</option>
+    {{range .Abteilungen}}
+    <option value="{{.ID}}">{{.Name}}</option>
+    {{end}}
+  </select>
+  {{end}}
+
+  <h2>Daten</h2>
+  <p class="hinweis">Bei Unsicherheit "Unsicher" wählen — das wird wie "Ja" behandelt.</p>
+  {{range .Datenfragen}}
+  <fieldset class="datenfrage">
+    <legend>{{.Label}}</legend>
+    <label><input type="radio" name="{{.Key}}" value="ja" required> Ja</label>
+    <label><input type="radio" name="{{.Key}}" value="nein"> Nein</label>
+    <label><input type="radio" name="{{.Key}}" value="unsicher"> Unsicher</label>
+  </fieldset>
+  {{end}}
+
+  <h2>Verwendung des Ergebnisses</h2>
+  <fieldset>
+    <legend>Wird das Ergebnis unverändert nach außen gegeben?</legend>
+    <label><input type="radio" name="c1" value="ja" required> Ja</label>
+    <label><input type="radio" name="c1" value="nein"> Nein</label>
+  </fieldset>
+
+  <fieldset class="mit-folgefrage">
+    <legend>Beeinflusst es eine Entscheidung über einen Menschen?</legend>
+    <label class="c2-ja"><input type="radio" name="c2" value="ja" required> Ja</label>
+    <label><input type="radio" name="c2" value="nein"> Nein</label>
+    <div class="folgefrage">
+      <label for="c2_folge">Welche Art von Entscheidung?</label>
+      <select id="c2_folge" name="c2_folge">
+        <option value="beschaeftigung">Einstellung, Beförderung, Kündigung</option>
+        <option value="kreditwuerdigkeit">Kreditwürdigkeit</option>
+        <option value="leistungsbewilligung">Leistungsbewilligung</option>
+        <option value="bildung">Zugang zu Bildung</option>
+        <option value="gesundheit">medizinische Beurteilung</option>
+        <option value="keine">keins davon</option>
+      </select>
+    </div>
+  </fieldset>
+
+  <fieldset class="mit-folgefrage">
+    <legend>Erkennt oder bewertet es Emotionen, Verhalten oder biometrische Merkmale?</legend>
+    <label class="c3-ja"><input type="radio" name="c3" value="ja" required> Ja</label>
+    <label><input type="radio" name="c3" value="nein"> Nein</label>
+    <div class="folgefrage">
+      <label for="c3_art">Welche Art?</label>
+      <select id="c3_art" name="c3_art">
+        <option value="emotionserkennung_arbeitsplatz">Emotionserkennung am Arbeitsplatz</option>
+        <option value="social_scoring">Social Scoring</option>
+        <option value="biometrische_kategorisierung">Biometrische Kategorisierung</option>
+        <option value="keine">etwas anderes</option>
+      </select>
+    </div>
+  </fieldset>
+
+  <fieldset>
+    <legend>Läuft es ohne dass ein Mensch das Ergebnis prüft?</legend>
+    <label><input type="radio" name="c4" value="ja" required> Ja</label>
+    <label><input type="radio" name="c4" value="nein"> Nein</label>
+  </fieldset>
+
+  <fieldset>
+    <legend>Merkt der Empfänger, dass ein Ergebnis von einer KI stammt?</legend>
+    <label><input type="radio" name="c5" value="ja" required> Ja</label>
+    <label><input type="radio" name="c5" value="nein"> Nein</label>
+  </fieldset>
+
+  <h2>Werkzeug</h2>
+  <label for="d_werkzeug_freitext">Haben Sie schon ein Werkzeug im Sinn? (optional)</label>
+  <input type="text" id="d_werkzeug_freitext" name="d_werkzeug_freitext">
+
+  <fieldset>
+    <legend>Firmenkonto oder privater Zugang?</legend>
+    <label><input type="radio" name="d_zugang" value="firma" required> Firmenkonto</label>
+    <label><input type="radio" name="d_zugang" value="privat"> Privater Zugang</label>
+  </fieldset>
+
+  <fieldset>
+    <legend>Auf Firmengerät oder Privatgerät?</legend>
+    <label><input type="radio" name="d_geraet" value="firma" required> Firmengerät</label>
+    <label><input type="radio" name="d_geraet" value="privat"> Privatgerät</label>
+  </fieldset>
+
+  <button type="submit">Antrag einreichen</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/index.html

@@ -5,10 +5,10 @@
 {{template "nav" .Nav}}
 <div class="page">
 <h1>Willkommen bei Deklarix</h1>
-<p class="hinweis">
-  Der geführte Fragebogen für die Antragsprüfung folgt in der nächsten
-  Ausbaustufe. Datenmodell, Regelwerk und Werkzeugkatalog stehen bereits.
-</p>
+<ul class="admin-kacheln">
+  <li><a href="/antraege/neu">Antrag stellen</a></li>
+  <li><a href="/antraege">Meine Anträge</a></li>
+</ul>
 </div>
 </body>
 </html>

internal/web/templates/layout.html

@@ -9,6 +9,7 @@
 {{define "nav"}}
 <nav>
   <a href="/">Start</a>
+  {{if not .IsBetreiber}}<a href="/antraege">Meine Anträge</a>{{end}}
   {{if .IsBetreiber}}<a href="/betreiber">Plattform</a>{{end}}
   <form method="post" action="/logout" style="display:inline">
     <button type="submit">Abmelden</button>

rules/OPEN.md

@@ -35,24 +35,17 @@ das lässt offen, ob `auftragsdaten` (zwischen `intern` und
 ein (Kundendaten sollten aus denselben Gründen wie Geschäftsgeheimnisse
 nicht zum Training verwendet werden) — **Annahme, nicht bestätigt.**
 
-## 3. Genaue Fragebogen-Fakten für "verboten" (KI-VO Art. 5)
+## 3. Genaue Fragebogen-Fakten für "verboten" (KI-VO Art. 5) — ERLEDIGT
 
-Fragebogen-Abschnitt C stellt nur eine einzelne Frage (C3: "Erkennt
-oder bewertet es Emotionen, Verhalten oder biometrische Merkmale?")
-ohne Folgefragen, die zwischen den drei in der Bewertungslogik
-genannten Auslösern für "verboten" unterscheiden:
-
-- Emotionserkennung am Arbeitsplatz
-- Social Scoring
-- Biometrische Kategorisierung
-
-`rules/kivo_einstufung.yaml` geht davon aus, dass Phase 2 (Fragebogen)
-für C3 eine Folgefrage ergänzt, die zwischen diesen dreien (und "keins
-davon") unterscheidet — analog zur bereits spezifizierten Folgefrage
-bei C2. Die Feldnamen `c3_art` und dessen Werte
-(`emotionserkennung_arbeitsplatz`, `social_scoring`,
-`biometrische_kategorisierung`) sind Platzhalter, bis Phase 2 das
-festlegt.
+~~Fragebogen-Abschnitt C stellt nur eine einzelne Frage...~~ Mit Phase 2
+(Fragebogen, `internal/web/templates/antrag_neu.html`) gelöst: C3 hat
+jetzt eine Folgefrage `c3_art` mit den Werten
+`emotionserkennung_arbeitsplatz`, `social_scoring`,
+`biometrische_kategorisierung` und `keine` — exakt die Werte, die
+`rules/kivo_einstufung.yaml` bereits erwartete. Feldnamen sind damit
+final, nicht mehr Platzhalter. **Weiterhin offen:** ob diese drei
+Varianten fachlich vollständig sind (deckt das wirklich alle "verboten"-
+Fälle aus Art. 5 KI-VO ab?) — das war nie Teil dieser Klärung.
 
 ## 4. `loeschfrist_max_tage` — konkrete Fristen je Datenklasse
 
@@ -61,4 +54,32 @@ Datenklasse", ohne die konkreten Tageswerte pro Stufe zu nennen.
 `rules/anforderungen.yaml` listet die Anforderung nur als grundsätzlich
 anwendbar (welche Datenklassen sie überhaupt auslösen), ohne
 Zahlenwerte — die eigentlichen Fristen (z. B. "personenbezogen: 90
-Tage") müssen vor Phase 3 fachlich festgelegt werden.
+Tage") müssen vor Phase 3 fachlich festgelegt werden. **Auswirkung auf
+Schritt 3 (`internal/rules.ErfuelltAnforderung`):** ohne Zahlenwerte
+wird diese Anforderung aktuell NICHT hart gegen Werkzeuge gefiltert
+(jedes Werkzeug gilt hier als "erfüllt") — sobald Fristen feststehen,
+muss die Filterfunktion entsprechend erweitert werden.
+
+## 5. Fallback, wenn keine Datenklasse zutrifft
+
+Wenn ein Antrag bei allen B-Fragen "nein" beantwortet — auch bei B7
+("nur allgemein zugängliche/erfundene Inhalte") — trifft laut Tabelle
+keine Stufe zu (ein eigentlich widersprüchlicher Zustand: irgendeine
+Kategorie sollte immer zutreffen). `internal/rules.EvaluateDatenklasse`
+nimmt in diesem Fall konservativ `intern` an, nicht `oeffentlich` — im
+Zweifel mehr Schutzanforderungen, nicht weniger. **Nicht fachlich
+bestätigt**, nur eine sichere Standardannahme.
+
+## 6. Welche Anforderungen werden hart gegen ein Werkzeug gefiltert?
+
+`internal/rules.ErfuelltAnforderung` filtert aktuell hart nur
+`avv_erforderlich`, `eu_verarbeitung` und `kein_training_auf_eingabe` —
+das sind technische Eigenschaften eines Werkzeugs
+(`werkzeug.avv_verfuegbar`, `verarbeitungsort`, `training_standard`).
+`menschliche_aufsicht`, `kennzeichnungspflicht` und `dsfa_erforderlich`
+betreffen dagegen einen Prozess rund um die Nutzung, nicht das Werkzeug
+selbst — ein Werkzeug wird deswegen nicht aussortiert, das wird
+stattdessen als Auflage vermerkt (geplant für Schritt 4/5). **Diese
+Aufteilung ist eine Annahme von Schritt 3, nicht ausdrücklich in der
+Spezifikation so festgelegt** — vor Schritt 4 gegenprüfen, ob das der
+gewünschten Produktlogik entspricht.