feat: Ergebnisdarstellung mit Herleitung (Schritt 4 der Baureihenfolge)

POST /antraege berechnet und speichert direkt beim Einreichen eine
append-only bewertung (Datenklasse, KI-VO-Einstufung, Anforderungen,
zulässige/ausgeschlossene Werkzeuge), GET /antraege/{id} zeigt sie
inklusive Herleitung und dem Pflicht-Hinweis, dass das System nicht
entscheidet, sondern nur vorbereitet.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

internal/web/server_test.go

@@ -7,12 +7,14 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
 	"github.com/netcell-it/deklarix/internal/auth"
+	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 	"github.com/netcell-it/deklarix/internal/web"
 )
@@ -31,6 +33,8 @@ type fakeStore struct {
 	auditLog     []store.AuditEntry
 	abteilungen  map[string][]store.Abteilung // accountID -> Abteilungen
 	antraege     map[string]store.Antrag
+	werkzeuge    map[string]store.Werkzeug
+	bewertungen  map[string][]store.Bewertung // antragID -> Bewertungen, älteste zuerst
 }
 
 func newFakeStore() *fakeStore {
@@ -41,6 +45,8 @@ func newFakeStore() *fakeStore {
 		sessions:     map[string]store.Session{},
 		abteilungen:  map[string][]store.Abteilung{},
 		antraege:     map[string]store.Antrag{},
+		werkzeuge:    map[string]store.Werkzeug{},
+		bewertungen:  map[string][]store.Bewertung{},
 	}
 }
 
@@ -237,11 +243,87 @@ func (f *fakeStore) ListAntraegeForUser(ctx context.Context, erstellerUserID str
 	return out, nil
 }
 
+func (f *fakeStore) ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Werkzeug
+	for _, w := range f.werkzeuge {
+		if w.AccountID == nil || *w.AccountID == accountID {
+			out = append(out, w)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w, ok := f.werkzeuge[id]
+	if !ok {
+		return store.Werkzeug{}, store.ErrNotFound
+	}
+	return w, nil
+}
+
+func (f *fakeStore) CurrentKatalogVersion(ctx context.Context) (string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return fmt.Sprintf("fake-%d", len(f.werkzeuge)), nil
+}
+
+func (f *fakeStore) CreateBewertung(ctx context.Context, in store.BewertungInput) (store.Bewertung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	b := store.Bewertung{
+		ID: f.newID(), AntragID: in.AntragID,
+		Datenklasse: in.Datenklasse, DatenklasseHerleitung: in.DatenklasseHerleitung,
+		Einstufung: in.Einstufung, EinstufungHerleitung: in.EinstufungHerleitung,
+		Verboten: in.Verboten, Anforderungen: in.Anforderungen,
+		ZulaessigeWerkzeuge: in.ZulaessigeWerkzeuge, AusgeschlosseneWerkzeuge: in.AusgeschlosseneWerkzeuge,
+		RegelwerkVersion: in.RegelwerkVersion, KatalogVersion: in.KatalogVersion,
+		CreatedAt: time.Now(),
+	}
+	f.bewertungen[in.AntragID] = append(f.bewertungen[in.AntragID], b)
+	return b, nil
+}
+
+func (f *fakeStore) GetLatestBewertungForAntrag(ctx context.Context, antragID string) (store.Bewertung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	bs := f.bewertungen[antragID]
+	if len(bs) == 0 {
+		return store.Bewertung{}, store.ErrNotFound
+	}
+	return bs[len(bs)-1], nil
+}
+
 // ─── Test-Setup ───────────────────────────────────────────────────────
 
+// loadTestRegelwerk lädt die echten rules/*.yaml-Dateien — dieselben,
+// die auch main.go beim Start lädt. Handler-Tests laufen so gegen das
+// tatsächliche Regelwerk statt gegen ein Test-Fixture, das getrennt
+// von rules/ gepflegt werden müsste.
+func loadTestRegelwerk(t *testing.T) web.Regelwerk {
+	t.Helper()
+	fsys := os.DirFS("../../rules")
+	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 web.Regelwerk{Datenklasse: dk, Einstufung: ei, Anforderungen: an}
+}
+
 func newServer(t *testing.T, fs *fakeStore) *web.Server {
 	t.Helper()
-	s, err := web.NewServer(fs)
+	s, err := web.NewServer(fs, loadTestRegelwerk(t))
 	if err != nil {
 		t.Fatalf("NewServer: %v", err)
 	}