CI: dangling images und alten build cache aufraeumen

Vermerkt als offener Folge-Befund unter AP 1 (1e) und in der
Umsetzungsstatus-Zeile: die aus dem Dark-Mode uebernommenen Glow-Effekte
(Karten-`--glow-s`, Spiel-`*-glow`, `.mf-theme`-Toggle) wirken im Light
Mode stoerend und brauchen eine helle Alternative. Dark Mode unveraendert.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EJvMTd7Vuedech24dy5kDY

.gitea/workflows/mindflux.yml

@@ -25,6 +25,7 @@ jobs:
           MINDFLUX_DB_PASSWORD: ${{ secrets.MINDFLUX_DB_PASSWORD }}
           MINDFLUX_ADMIN_PASSWORD: ${{ secrets.MINDFLUX_ADMIN_PASSWORD }}
           MINDFLUX_ADMIN2_PASSWORD: ${{ secrets.MINDFLUX_ADMIN2_PASSWORD }}
+          MAIL_PASSWORD: ${{ secrets.MAIL_PASSWORD }}
         run: |
           test -n "$MINDFLUX_DB_PASSWORD" || { echo "MINDFLUX_DB_PASSWORD fehlt" >&2; exit 1; }
           docker exec -i -e NEW_DB_PASSWORD="$MINDFLUX_DB_PASSWORD" postgres \
@@ -33,4 +34,15 @@ jobs:
           ALTER USER mindflux WITH PASSWORD :'new_db_password';
           SQL
           docker compose -f docker-compose.yml pull
+<<<<<<< HEAD
+          docker compose -f docker-compose.yml up -d --wait --wait-timeout 90 || {
+            docker logs --tail 200 mindflux >&2
+            exit 1
+          }
+=======
           docker compose -f docker-compose.yml up -d
+      - name: Cleanup
+        run: |
+          docker image prune -f
+          docker builder prune -f --filter "until=168h"
+>>>>>>> f79df17 (CI: dangling images und alten build cache aufraeumen)

CHANGELOG.md

@@ -1,9 +1,307 @@
 # Changelog
 
-Alle nennenswerten Änderungen an **Mindflux** werden hier dokumentiert.
+Alle nennenswerten Änderungen an **SysnaptiK Neural** werden hier dokumentiert.
 Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/),
 Versionierung [semantisch](https://semver.org/lang/de/).
 
+## [Unreleased] – 2026-07-21 · Gesamt-Audit: Light Mode, Barrierefreiheit, AP2-Inhalte, DSGVO
+
+### Registrierung & Kontozugang
+- **Sofort nutzbare Accounts:** Die Registrierung hängt nicht mehr an der Zustellung
+  einer Bestätigungs-E-Mail. Neue Accounts können sich direkt anmelden; bereits
+  wartende Konten werden mit Migration V23 aktiviert. Nicht mehr benötigte
+  Bestätigungs-Token werden gelöscht. E-Mail bleibt für den Passwort-Reset erhalten.
+
+### Light Mode & Design
+- **Browser-Icon:** Das Neural-Emblem wird unter `/favicon.ico` ausgeliefert und
+  direkt auf der Startseite verlinkt. Die Versionierung der Bild-URL ersetzt auch
+  bereits gecachte Standard-Globus-Symbole im Browser-Tab.
+- **Preismodell offen formuliert:** Die öffentliche Einstiegsseite verspricht keine
+  kostenlose Nutzung mehr; Beschreibung, Registrierungs-Teaser und Account-Hinweis
+  bleiben bewusst preisneutral.
+- **Produktzweck klarer:** Die Login-Seite erklärt nun Zielgruppe, Lernformen und
+  den Nutzen eines Accounts; im Dashboard fasst ein kompakter Einstieg den Lernzweck
+  zusammen.
+- **TechTacular-Fragen überspringbar:** Eine noch nicht beantwortete Frage kann per
+  ×, Klick außerhalb oder Escape folgenlos geschlossen und später wieder geöffnet
+  werden.
+- **Light-Mode-Fundament:** zentrale UI-Effekte sind jetzt als Theme-Primitives
+  organisiert. Dark Mode behält Neon-Emissionen; Light Mode nutzt warme Elevation,
+  entfernt Text-/Icon-Halos und erhält einen sichtbaren Scrollbar-Thumb. Native
+  Controls folgen über `color-scheme` dem gewählten Theme.
+- **Theme-Start & FinalProtocol:** Erstbesucher folgen der OS-Farbpräferenz, die
+  Browser-Chrome erhält ein passendes `theme-color` und FinalProtocol lädt keinen
+  ungenutzten Legacy-Style mehr; die statischen Lernseiten erhalten daraus nur noch
+  eine minimale Reset-Basis.
+- **Kritische Light-Mode-Fälle behoben:** Login-Overlay, SyntaxSaga-Bühne,
+  CodeEscape-Terminal, NetWorker-Guide und die Farbenblind-Palette sind in heller
+  Darstellung wieder lesbar und kontraststark. A11y-Widget und FinalProtocol
+  verwenden ebenfalls themefähige Farben.
+- **Ansichtswechsel abgesichert:** zentrale SPA-Übergänge starten oben, ohne laufendes
+  Antwortfeedback zu versetzen. FinalProtocol scrollt Ergebnisse und Neustarts gezielt
+  ins Sichtfeld; SyntaxSaga und DevLab fokussieren ohne Scrollsprung.
+- **Echter Light Mode statt Invertierung:** Light-Tokens auf WCAG AA nachgeschärft
+  (Akzent, Muted, Sekundär, Spielakzente), neues `--warn`-Token. Die Spielkarten der
+  Plattform-Hülle erhalten im Light Mode farbton-treu abgedunkelte Akzente statt
+  durchschlagender Neon-Werte.
+- **ServiceClash, NetWorker und BugHunter** haben jetzt eine echte helle Variante
+  (zuvor dauerhaft dunkel): alle Farben laufen über scoped CSS-Custom-Properties auf
+  der Body-Klasse, Dark bleibt pixelgleich, die Light-Paletten sind handentworfen und
+  vollständig WCAG-AA-geprüft; der Theme-Umschalter wurde im Header ergänzt. Der bei
+  NetWorker fälschlich globale `var(--text)`/`var(--muted)`-Zugriff ist behoben.
+- **Header-Icons vereinheitlicht:** alle Icon-Buttons einheitlich 42×42 px, Radius 10,
+  Glyphe 20×20, Outline-Stil (Surface-Fill, Akzent nur über Farbe/Rahmen).
+
+### Barrierefreiheit
+- **Widget perfektioniert:** Fokus-Falle im Panel, `aria-modal`, Schließen per Klick
+  außerhalb; der Textgrößen-Button nutzt ein dynamisches `aria-label` statt eines
+  falschen `aria-pressed`, der Reset-Button ist als Aktion ausgezeichnet; Hochkontrast
+  ist als „immer dunkel" kenntlich gemacht. Toter Legacy-Dock-Code entfernt.
+- **Spielanleitungen & Hints:** gemeinsames „So funktioniert's"-Overlay mit ?-Button
+  und automatischem Erstaufruf für sieben Spiele (NetWorker behält seinen Inline-Guide);
+  MindMatch erhält einen „Paar-Blitz"-Tipp, der kurz ein Paar aufdeckt und dafür einen
+  Zug kostet (rein clientseitig, keine Backend-Änderung).
+
+### FinalProtocol – Abschlussprüfung Teil 2
+- **200 neue Prüfungsfragen:** je fünf Themen für Systemintegration (Netzwerkplanung,
+  IT-Sicherheit, Virtualisierung, Monitoring & Backup, Skripting) und Anwendungs-
+  entwicklung (SQL, UML, OOP, Algorithmen, Testverfahren) mit je 20 Fragen, fünf
+  Kategorien und ausgewogener Antwortverteilung. Titel und Navigation decken jetzt
+  AP1 **und** AP2 ab.
+
+### DSGVO & Recht
+- **Rechtslinks von jeder Seite erreichbar:** das bislang ungenutzte Footer-Fragment
+  wird jetzt auf allen Seiten inkl. Spiel-, Fehler- und Anmeldeseiten verwendet
+  (26 duplizierte Inline-Footer ersetzt, 11 fehlende ergänzt).
+- **Datenschutzerklärung** um NeuralNet-Nachrichten, E-Mail-Token (SHA-256, 24 h),
+  SMTP-Versand und konkrete Speicherfristen ergänzt; **Impressum** nach § 5 DDG
+  strukturiert (auffällig markierte Pflichtfeld-Platzhalter).
+- **Datenexport (Art. 20):** `/profile/export` liefert alle Kontodaten (ohne Passwort)
+  als JSON-Download.
+- **Demo-Konto „NeuralTest"** wird per Migration aus produktiven Datenbanken entfernt.
+
+### Technik & Qualität
+- **E-Mail-Versand diagnostizierbar:** Bestätigungs- und Reset-Mails schreiben jetzt
+  datensparsame, korrelierbare Ereignislogs für Token-Erstellung, SMTP-Übergabe,
+  Fehler, erneute Anforderung und Verifikation. Roh-Tokens und Bestätigungslinks
+  werden nie protokolliert; eine SMTP-Annahme wird nicht als Postfachzustellung
+  ausgegeben.
+- **Legacy aufgeräumt:** die nicht referenzierten Styles für Achievements, Progress,
+  Settings und Soziales sowie `finalflux-check.js` entfernt; der Styleguide dokumentiert
+  die neuen Effekt-Primitives.
+- **Chart.js lokal ausgeliefert** statt vom CDN – das einzige externe Asset entfällt,
+  wodurch die Datenschutzerklärung wieder zur Realität passt.
+- **Security-Header** ergänzt: Content-Security-Policy (self-hosted), Referrer-Policy;
+  HSTS bleibt auf HTTPS beschränkt.
+- **Umlaute** in den Spielinhalten flächendeckend korrigiert (wort-/morphemgenau,
+  Slugs und Code-Bezeichner geschont), mit Reseed-Migration für bereits befüllte
+  Datenbanken.
+- **AvatarService** aus dem ProfileController extrahiert (Bildverarbeitung und
+  Pfad-Logik zentralisiert); **Bean Validation** eingeführt (Start mit ScoreSubmission).
+- Aufräumen: totes Scaffolding (`DummyController`, `dummy.html`, `hello.txt`) und
+  obsoleter CSS-Code entfernt.
+
+## [Unreleased] – 2026-07-14 · SysnaptiK Neural Rebrand
+
+### TechTacular
+- **50:50-Joker:** Pro Runde kann im Frage-Overlay ein Joker zwei garantiert falsche
+  Antworten ausblenden und deaktivieren. Die Lösung bleibt vollständig serverseitig;
+  ein verwendeter Joker halbiert die Punkte der betreffenden Frage nur, wenn der
+  serverseitige Rundenzustand den Einsatz bestätigt.
+
+### Konto & Sicherheit
+- **E-Mail-Bestätigung:** Neue Accounts erhalten einen einmaligen, 24 Stunden
+  gültigen Bestätigungslink und werden erst nach erfolgreicher Verifikation zum
+  Login freigeschaltet. Bestehende Accounts bleiben ohne Unterbrechung bestätigt.
+- **Passwort-Reset per E-Mail:** Über „Passwort vergessen?“ können bestätigte
+  Nutzerinnen und Nutzer einen zeitlich begrenzten Reset-Link anfordern und ihr
+  Passwort selbst neu vergeben. Token werden ausschließlich gehasht gespeichert.
+- **Admin-Reset vereinheitlicht:** Manuelle Passwort-Resets im Adminbereich
+  verwenden jetzt verdeckte Eingabefelder und dieselbe Mindestlänge von acht Zeichen.
+- **Zustellungsweg repariert:** Mindflux verwendet für SMTP den Zertifikatsnamen
+  `mail.sysnaptik.de`, der im internen `backend_network` direkt auf den
+  Mailserver aufgelöst wird. STARTTLS prüft damit den korrekten Hostnamen,
+  ohne die interne Container-Verbindung zu verlassen.
+- **Deployment verifiziert:** Der Deployment-Workflow wartet jetzt bis zu 90
+  Sekunden auf den Container-Healthcheck und bricht mit den App-Logs ab, falls
+  die Anwendung nicht gesund startet. Dadurch werden fehlerhafte Deployments
+  nicht mehr fälschlich als erfolgreich angezeigt.
+- **Registrierung kompakter:** „Bestätigungslink erneut senden“ ist nun eine
+  einklappbare Aktion; das Eingabefeld erscheint erst auf Klick. Bei längeren
+  Formularen bleibt der Registrierungsbereich innerhalb des Panels scrollbar.
+- **Registrierung eindeutig bestätigt:** Nach einer erfolgreichen Anmeldung
+  bleibt der Registrierungsbereich geöffnet und zeigt die Versandbestätigung
+  direkt am Formular, statt unauffällig zum Login zu wechseln.
+- **Registrierungsroute korrigiert:** Der direkte Aufruf von `/register` öffnet
+  nun wieder den Registrierungsmodus statt auf dem Login zu landen.
+- **Passwort-Reset sichtbar verlinkt:** „Passwort vergessen?“ steht jetzt direkt
+  unter dem Passwortfeld im Login-Bereich.
+- **Token-Schema nachgeschärft:** Folge-Migrationen richten UTC-Zeitstempel und
+  den Token-Hash-Typ an das JPA-Modell aus, damit Schema-Validierung und
+  Container-Start zuverlässig funktionieren.
+
+### Marke & Plattform
+- **Neural Lightmode & Kontrast:** Die helle Plattformvariante ist wieder ein
+  vollständiges Mint-/Blau-Neural-Theme, inklusive Sidebar, Karten und Login.
+  Hochkontrast nutzt jetzt dieselbe Mint-/Cyan-Sprache statt der alten Amber-Palette.
+- **NeuralNet aufgeräumt:** Der leere Gesprächshinweis verschwindet beim Öffnen
+  wirklich, die letzte Verbindung wird pro Konto gespeichert und beim nächsten
+  Besuch direkt wieder geöffnet. Die Sprechblase bleibt neutral und invertiert
+  nur bei ungelesenen Nachrichten.
+- **NeuralNet-Benachrichtigung:** Die Dashboard-Glocke ist jetzt eine
+  Sprechblase. Sie zeigt den echten Zähler ungelesener Direktnachrichten und
+  leuchtet in der Neural-Akzentfarbe, bis die Nachrichten gelesen sind.
+- **NeuralNet-Chatlayout geschlossen:** Chatkopf, Nachrichtenliste und Eingabefeld
+  bilden nun eine feste Flex-Spalte im Panel. Der Footer kann nicht mehr zwischen
+  Gespräch und Eingabe rutschen.
+- **NeuralNet-Buttons direkt gebunden:** Kontakt- und Chat-Buttons erhalten nach
+  jedem Rendern eigene Handler. Damit öffnet eine Verbindung unabhängig von der
+  Ereignisweitergabe des umgebenden Panels zuverlässig den Nachrichtenbereich.
+- **NeuralNet-Chat öffnet sofort:** Der Klick auf eine Verbindung schaltet das
+  Gespräch samt Eingabefeld nun unabhängig vom anschließenden Verlaufsabruf frei;
+  Chat-Aktionen sind explizit als Buttons markiert.
+- **NeuralNet-Chat repariert:** Leere, erfolgreiche API-Antworten werden nicht mehr
+  fälschlich als JSON gelesen. Kontaktaktionen aktualisieren die Oberfläche wieder
+  zuverlässig und bestätigte Verbindungen lassen sich direkt im Chat öffnen.
+- **NeuralNet-Testkonto:** Ein klar benanntes, für NeuralNet aktiviertes Dummykonto
+  erleichtert das Prüfen von Kontaktanfragen und privaten Nachrichten.
+- **NeuralNet-MVP:** Der frühere Soziales-Platzhalter ist jetzt ein Opt-in-Hub für
+  Kontaktanfragen, Annahme/Ablehnung/Rückzug und private 1:1-Nachrichten. Ohne
+  bestätigte Verbindung lässt der Server keine Nachrichten zu.
+- **NeuralNet geplant:** Der kommende soziale Bereich heißt NeuralNet und priorisiert
+  private Lernverbindungen: Kontaktanfragen müssen erst ausdrücklich angenommen werden,
+  bevor private Nachrichten möglich sind.
+- **Farbschema ohne Aufblitzen:** Die Neural-Hülle wird nun statisch mit dem
+  Grundtheme geladen und ihre Klasse bereits im `<head>` gesetzt. Theme- und
+  Bootstrap-Dateien tragen neue Versionsparameter, damit Login, Logout und jede
+  Navigation direkt im SysnaptiK-Neural-Schema zeichnen.
+- **Fortschritt & Barrierefreiheit repariert:** Die Diagramme warten jetzt auf die
+  Neural-Plattformklasse und erscheinen dadurch in Mint statt im alten Orange.
+  Hochkontrast und Farbenblind-Modus überschreiben nun auch lokale Plattform- und
+  Spieltokens; der Farbenblind-Modus nutzt eine klar unterscheidbare Palette.
+- **Echter Lernnetz-Status:** Der Dashboard-Status prüft nun serverseitig den
+  Fortschrittsspeicher und zeigt nachvollziehbar „bereit“ oder „eingeschränkt“ samt
+  Zeitstempel und registrierten Lernmodulen. Der dekorative 100%-Ring wurde entfernt.
+- **Akzente klar getrennt:** MindMatch ist nun Magenta, SyntaxSaga ein kühleres Violett,
+  SystemEscape Gelb-Bernstein und FinalProtocol Koralle. Die Plattformkarten sind damit
+  auf einen Blick unterscheidbar, ohne die Farben in den Spielen selbst anzutasten.
+- **Fortschrittsdiagramme korrigiert:** Donut- und Wochenchart lesen den Neural-Akzent
+  nun von der Plattformhülle statt den alten globalen Orange-Token zu verwenden.
+- **Alte Platzhalter-Copy entfernt:** Die Registrierungsrakete und der Zeitreise-Spruch
+  auf der Vorbereitungsseite wurden durch neutrale SysnaptiK-Neural-Texte ersetzt.
+- **Admin-Umfang transparent:** Das Admin-Dashboard benennt jetzt klar, welche
+  Inhaltsverwaltungen vorhanden sind und dass ServiceClash, NetWorker und FinalProtocol
+  noch direkt mit der Anwendung ausgeliefert werden.
+- **Bestehendes Emblem bewahrt:** Die kurzfristig ergänzte CSS-Knotenmarke wurde
+  zurückgenommen. Das vorhandene Emblem bleibt als Wiedererkennungszeichen bestehen,
+  weil es die neue neuronale Metapher bereits passend transportiert.
+- **Sichtbarer Markenwechsel:** Mindflux heißt auf der Plattform nun **SysnaptiK Neural**;
+  FinalFlux wurde zu **FinalProtocol**. Bestehende technische Routen, Datenbanktabellen,
+  Spiel-Keys und Paketnamen bleiben für Kompatibilität unverändert.
+- **Neue Plattformwelt:** Die bisherige Zeitreise-/BTTF-Anmutung wurde durch ein dunkles
+  neuronales Netzwerk mit Knoten, Verbindungen, Petrolflächen und grünen Glows ersetzt.
+  Login/Registrierung, Dashboard, Profilseiten, Admin- und Rechtsseiten nutzen dieselbe Hülle.
+- **Dashboard nach Spielknoten:** Jede Plattform-Spielkarte trägt einen eigenen Akzent
+  (u. a. DevLab Mint, SyntaxSaga Violett, BugHunter Crimson, NetWorker Blau,
+  FinalProtocol Orange) – ohne die internen Spieloberflächen zu verändern.
+- **Zeitreise-Copy entfernt:** Die sichtbare Pausenfunktion heißt nun **NeuralPause**;
+  BTTF-Referenzen und Sprüche wurden durch neutrale Lernpausen-Texte ersetzt.
+- **FinalProtocol durchgängig benannt:** Hub, Lernseiten, Navigation, Rücklinks und
+  Seitentitel zeigen den neuen Namen, während die bestehende FinalFlux-URL als kompatibler
+  technischer Pfad erhalten bleibt.
+
+## [Unreleased] – 2026-07-13 · BugHunter, NetWorker & echter Lernfortschritt
+
+### Planung
+- **S3-Sicherheitsstand nachgezogen:** Der Zukunftsplan markiert die serverseitige
+  Spielwertung nun korrekt als umgesetzt: alle vier neuen Spiele halten Lösungen,
+  Reveal- und Versuchsstatus serverseitig und berechnen Ergebnisse unabhängig vom Client.
+
+### Eigenständige Spielwelten
+- **Bestandsspiele gestalterisch getrennt:** MindMatch erhielt ein Violett-/Mint-
+  „Neural Archive“, TechTacular eine Magenta-/Blaue Cyber-Quizshow, SyntaxSaga ein
+  phosphoriges Terminal und FinalFlux eine ruhige Gold-/Indigo-Prüfungszentrale.
+- **DevLab als Werkstatt:** Petrol/Orange, Schaltkreisraster und Build-Pipeline-Akzente
+  schärfen die Oberfläche nach. Die schwebende Kolben-/dlFloat-Animation bleibt
+  unverändert erhalten.
+- **Zugänglichkeit bleibt stimmig:** Das Accessibility-Widget erkennt und verwendet nun
+  auch für diese fünf Lernwelten automatisch deren lokalen Akzent; Statusfarben und
+  Spielmechaniken bleiben unverändert.
+
+### ServiceClash
+- **Auswertung repariert:** Nach dem letzten Ticket wurde die Abschlussansicht nicht
+  geöffnet, weil der Renderer noch auf ein nicht vorhandenes Folgeticket zugriff. Die
+  Abschlussprüfung erfolgt nun vor jeder Ticketzustands-Abfrage.
+- **Letztes geplantes Spiel ausgeliefert:** drei Service-Desk-Schichten mit insgesamt
+  **24 kuratierten Tickets** aus Incident-, Request-, Change-, Monitoring-, Backup- und
+  Security-Szenarien. Jede Aufgabe führt verständlich durch Art, Priorität und passende
+  Erstmaßnahme.
+- **Echte Wertung und Fortschritt:** V15-Datenmodell, lösungsfreie Sessions und
+  serverseitige Prüfung bewerten jeden der drei Schritte samt Versuchsleiter. Score,
+  Sterne, Highscore, Dauer und Fortschritt werden gespeichert; „Leitstand-Einsatz“ und
+  der fehlerfreie „Incident Commander“ sind als Achievements integriert.
+- **Eigenständiger Leitstand:** Cyanfarbene Queue, Wellen, Fortschrittsanzeige,
+  Ticket-Debriefs sowie bewusstes Weiterklicken nach einer Lösung. Die Lobby erklärt
+  Incident vs. Anfrage und die Priorisierung vor der ersten Schicht.
+- **Integration abgeschlossen:** Dashboard-Karte öffnet `/serviceclash`, die API ist
+  CSRF-konform eingebunden und das Accessibility-Widget übernimmt den ServiceClash-Akzent.
+
+### BugHunter
+- **Vollständiges Fallakten-Spiel ausgeliefert:** serverautoritatives Drei-Phasen-Debugging
+  (Orten → Klassifizieren → Fixen), Score, Combo, Sterne, Highscore, Admin-Pflege und
+  lösungsfreie Sessions über eigene V12-Tabellen, Seeder und API.
+- **Inhalte ausgebaut und nach Schwierigkeit sortiert:** 12 schlüssige Fallakten von Junior
+  über Senior bis Principal mit längeren Briefings, Mehrdatei-Fällen und mehreren Bugs.
+- **Archiv und Ablauf verfeinert:** Die Lobby ist ein Aktenschrank statt eines unlesbaren
+  Kartenstapels; Akten lassen sich klar öffnen. Nach jeder Prüfung bleibt das Debriefing
+  stehen und der nächste Schritt erfolgt bewusst per Klick.
+- **Wiederholbarkeit:** Eine fehlerfrei gelöste Akte erhält einen diagonalen „GELÖST“-Stempel.
+  Ein Reset startet eine passende Variantenlage, sodass Fehler und Hinweise nicht immer an
+  derselben Stelle liegen.
+- **Sprache und Gestaltung bereinigt:** Fallakten- statt „Investigation Bureau“-Vokabular,
+  korrigierte Schreibfehler sowie Crimson-Akzent ohne auffällig eingefärbte Dashboard-Karte.
+
+### NetWorker
+- **Neues Netzwerk-Puzzle ausgeliefert:** V14-Datenmodell, Seeder, Server-API und
+  serverseitiger `NetSimulator` prüfen IPv4-/CIDR-, Host-/Broadcast-, Gateway-,
+  Duplikat-IP- und Routing-Fälle unabhängig vom Client.
+- **15 Aufgaben in drei Welten:** adressieren, diagnostizieren und routen; Ergebnisse,
+  Highscores und Fortschritt werden wie bei den übrigen Spielen gespeichert.
+- **Blaupausen-Optik nachgeschärft:** korrekte Schreibweise „NetWorker“, sichtbares Raster
+  auf Seiten- und Netzwerkboard-Hintergrund sowie blaues Accessibility-Widget.
+- **Einsteigerführung ergänzt:** Lobby, Weltstart und die Levelansicht erklären Ablauf,
+  IP-Adresse, Präfix, Gateway und Ping. Je Aufgabentyp gibt es konkrete Handlungsanweisungen
+  samt Beispielen für `/24`, Hostadressen und statische Routen.
+- **Direkter Rückweg:** Die Kopfzeile führt mit „NETZPLÄNE“ zurück zur NetWorker-Übersicht,
+  ohne den Umweg über das Dashboard.
+
+### Navigation & Fehlerbehebung
+- **BugHunter und NetWorker:** „AKTENSCHRANK“ bzw. „NETZPLÄNE“ brechen einen laufenden,
+  noch nicht gespeicherten Durchgang bewusst ab und öffnen direkt die jeweilige Übersicht.
+- **Fortschrittsseite repariert:** Der JavaScript-Inliner in `progress.html` konnte zwei
+  Ausdrücke in einer Rechenoperation nicht parsen und erzeugte deshalb einen Fehler 500.
+  Die Werte werden nun erst in JavaScript-Konstanten übergeben.
+
+### Fortschritt, Achievements & Knowledge Core
+- **Spielbezogene Achievements ergänzt:** MindMatch, TechTacular, DevLab, SyntaxSaga,
+  SystemEscape, BugHunter und NetWorker können nun passende Erfolge auslösen; zusätzliche
+  Spezialerfolge belohnen perfekte SystemEscape-/BugHunter-/NetWorker-Runden.
+- **Dashboard und Statistik von Platzhaltern befreit:** Wochen-XP, Verlauf und Top-Spiele
+  kommen aus `game_scores`; die Statistik zeigt den realen XP-Fortschritt und die gemessene
+  Dauer abgeschlossener Runden. Nicht messbare Runden werden bewusst nicht als Spielzeit
+  behauptet.
+- **Bezeichnungen präzisiert:** Das Level ist transparent ein XP-Level (1.000 XP je Stufe),
+  und die frühere Zahl „korrekte Antworten“ heißt nun „erfasste Spielaktionen“.
+- **Knowledge Core aufgebaut:** Lernzentrale mit AP1-, Netzwerk-/Systemintegration- sowie
+  Debugging-/Security-Pfaden, Verweisen auf passende Module und persönlichem, datenbasiertem
+  Status statt vorgetäuschter Themenanalyse.
+
+### Barrierefreiheit & Qualität
+- Accessibility-Steuerung übernimmt in SystemEscape, BugHunter und NetWorker den jeweiligen
+  Spielakzent und bleibt in der Kopfzeile reserviert.
+- Zusätzliche Tests sichern den Wochenaggregator und den kompletten `/progress`-Renderpfad;
+  insgesamt **46 Tests** grün.
+
 ## [Unreleased] – 2026-07-12 · Großer Verbesserungs-Sweep (Sicherheit, Daten, Navigation)
 
 Weitgehende Umsetzung des Verbesserungskatalogs aus `mindfluxfuture.md` (Teil 2;
@@ -11,6 +309,32 @@ bewusst zurückgestellte Restpunkte sind dort weiterhin als offen markiert):
 Sicherheit, Datenintegrität, echtes XP/Achievement-System, Navigations-Umbau,
 Docker/CI-Härtung und erste Tests.
 
+### Responsive Darstellung & Barrierefreiheit
+- Logout-Navigation in Dashboard, DevLab, MindMatch, SyntaxSaga und TechTacular auf ein
+  einheitliches Icon mit zugänglichem Namen und Tooltip „Abmelden“ vereinheitlicht.
+- **Globales Accessibility-Widget:** Ein schwebender Rollstuhl-Button öffnet auf jeder Seite
+  ein tastaturbedienbares Panel. Einstellungen werden ausschließlich lokal im Browser gespeichert.
+- Enthalten sind vier Textgrößen, Hochkontrast, farbenblindfreundliche Statusfarben, Monochrom,
+  einen Lesemodus für Dyslexie mit Verdana und angepassten Abständen, unterstrichene Links, reduzierte Animationen,
+  großer Cursor und ein zentraler Reset.
+- Floating-Button an die Mindflux-Palette angepasst; der Schrift-Schalter heißt nun transparent
+  „Lesemodus (Dyslexie)“ und weist auf Verdana plus vergrößerte Abstände hin.
+- Der dauerhaft erreichbare Auslöser besitzt nun reservierten Layoutplatz statt Spielkarten oder
+  Formulare zu überdecken: seitlich auf Desktop und in einer unteren Schutzzone auf kleinen Displays.
+- Accessibility-Zugriff in die jeweilige sticky Kopfzeile neben Theme/Logout verschoben; Seiten
+  ohne Werkzeugleiste erhalten eine eigene reservierte Utility-Zeile statt eines Inhalts-Overlays.
+- Accessibility-Schaltfläche auf dieselben 38 px Außen- und 18 px Iconmaße wie die übrigen
+  Kopfzeilen-Werkzeuge vereinheitlicht.
+- SystemEscape behält seine Terminal-Typografie im Spiel, verwendet für globale Navigation und
+  Werkzeuge aber die einheitliche Mindflux-Sans-Serif-Schrift.
+- TechTacular-Kategoriekarten auf identische Höhe gesetzt und zweizeilige Titel mittig ausgerichtet.
+- Das Panel besitzt Dialogsemantik, sichtbaren Tastaturfokus, Escape-Schließen und verständliche
+  Aktivzustände; Spielzustände oder Benutzerkonten werden dabei nicht verändert.
+- **DevLab-Spielansicht nutzt große Bildschirme aus:** Die bisherige starre Begrenzung auf
+  1100 px wurde durch ein fluides, bis 2200 px breites Viewport-Layout ersetzt. Hauptbereich,
+  Seitenpanel, Abstände und Grundschrift skalieren mit der verfügbaren Bildschirmgröße.
+- Auf Mobilgeräten bleibt das Layout einspaltig und setzt die Grundschrift auf mindestens 16 px.
+
 ### Sicherheit
 - **DB-Passwort aus dem Repo entfernt:** `docker-compose.yml` liest jetzt `${MINDFLUX_DB_PASSWORD}`
   aus einem Gitea-Secret (wie die Admin-Passwörter).
@@ -64,7 +388,7 @@ Docker/CI-Härtung und erste Tests.
   `theme.js`/localStorage); funktionslose Sprach-/Benachrichtigungs-Attrappen entfernt;
   `SettingsController` in den `ProfileController` gemergt; Token-Farbe statt Hardcode.
 - **Spielnamen vereinheitlicht** (englisch, zusammengeschrieben): DevLab, SyntaxSaga sowie
-  CodeEscape, ServiceClash, BugHunter, NetWorker für die geplanten Spiele (Keys in
+  SystemEscape, ServiceClash, BugHunter, NetWorker für die geplanten Spiele (Keys in
   `KNOWN_GAMES`/`ProgressService` mit umbenannt – noch keine Scores vorhanden).
 - **DevLab erscheint jetzt auf der Statistik-Seite** (fehlte in `ProgressService.GAMES`).
 - Tote Templates entfernt: `login.html`, `register.html` (Formular lebt auf der Startseite),
@@ -86,6 +410,53 @@ Docker/CI-Härtung und erste Tests.
 - **`pw_anleitung.md`:** Betriebsanleitung für DB-Secret, automatische Runner-Rotation,
   manuellen Notfallweg und Verifikation nach dem Deployment.
 
+### Zukunftsfundament & FluxTimer
+- **Plan technisch aktualisiert:** freie Flyway-Reihenfolge V11–V14, persistiertes
+  `exam_scope`-Tagging und verbindlicher S3-Anti-Cheat-Vertrag für alle neuen Spiele.
+- **Spiel-Akzentbasis:** Dark-/Light-Tokens für SystemEscape, BugHunter, ServiceClash und NetWorker.
+- **FluxTimer-MVP:** lokaler Pausentimer mit 5–240 Minuten Intervall, rotierenden Erinnerungen,
+  eigenem Text, Snooze, Probelauf, optionalem Sound und lokaler Browser-Benachrichtigung.
+  Countdown und Overlay laufen über Navigationen weiter; ein eigener Topbar-Button öffnet den
+  Schnellzugriff und die Einstellungen enthalten die vollständige Konfiguration.
+- **Dashboard-Topbar aufgeräumt:** generische Winkehand und dekorative Pulsline entfernt.
+  FluxTimer besitzt statt der Glocke jetzt ein eigenes Uhr-mit-Blitz-Icon im Zeitreise-Look;
+  die Glocke bleibt frei für spätere echte Benachrichtigungen.
+- **Login entschlackt:** das generische Schloss-Emoji aus dem Login-Button entfernt; die klare
+  Beschriftung reicht als Handlungsaufforderung und passt besser zur eigenständigen Designsprache.
+- Datenschutzerklärung um lokale Speicherung und Browser-Benachrichtigung ergänzt.
+
+### SystemEscape (interner Key `codeescape`)
+- **Variable SystemEscape-Runs:** Jedes Szenario besitzt nun acht Räume; ein Durchlauf wählt
+  serverseitig vier davon in zufälliger Reihenfolge. Der Pool wächst damit auf 24 Räume und
+  69 Rätsel, mit 1.680 möglichen geordneten Raumkombinationen je Szenario.
+- Die konkrete Raum- und Rätselauswahl wird im Server-Run festgeschrieben. Checks, Hinweise,
+  Türen, Finish, Maximalpunktzahl und Sterne akzeptieren ausschließlich IDs dieses Runs.
+- Lobby erklärt Poolgröße und Run-Länge; ein neuer Start erzeugt ausdrücklich eine neue Route.
+- **Sichtbarer Name zu SystemEscape geändert:** Der neue Name bildet Netzwerk-, Security-,
+  Hardware-, Backup- und Entwicklungsthemen besser ab. Interner Key, Route und Datenmodell
+  bleiben für bestehende Scores und Migrationen kompatibel bei `codeescape`.
+- **Spielablauf verdeutlicht und Schleusenfehler behoben:** dauerhafte Drei-Schritt-Führung
+  „Rätsel lösen → Fragmente sammeln → Türcode bilden“, nummerierte Fragmentreihenfolge,
+  optionales automatisches Einsetzen und klare Rückmeldungen bei Prüfung, Erfolg und Fehler.
+- **Produktive Türcodes repariert:** ergänzende V11.1-Datenmigration gleicht alle neun Türcodes
+  mit ihren sichtbaren Fragmenten ab. Die Lösereihenfolge der Rätsel bleibt bewusst frei.
+- Schleusen lassen sich serverseitig erst nach Abschluss aller Rätsel öffnen; ein zusätzlicher
+  Test sichert diesen Ablauf und die hilfreiche Fehlermeldung ab.
+- **Neues vollständiges Spiel:** drei Facility-Szenarien mit neun Räumen und 24 IT-Rätseln
+  von AP1 bis AP2 (FIAE/FISI/Cross), Fragment-Inventar, Türcodes, Countdown, Alarmzustand,
+  Hinweise, Reveal, Zeitbonus, Sterne, Highscore und Ergebnis-Debriefing.
+- **Serverautoritativ:** V11-Schema mit `exam_scope`, lösungsfreie Session-DTOs, serverseitig
+  protokollierte Versuche/Hinweise/Reveals/Türen und vollständige Score-Neuberechnung beim Finish.
+  Fremde oder doppelte IDs, überlange Listen und unplausible Zeiten werden abgewiesen.
+- **Vier Mechaniken:** freie Code-Eingabe, Choice, Reihenfolge und Matching; alle Lösungen bleiben
+  bis zur expliziten Auflösung auf dem Server.
+- **Eigene visuelle Welt:** dunkle Facility-/CRT-Optik, Scanlines, Terminal-Dialoge,
+  Fragment-Chips und SystemEscape-Akzent im Dashboard; responsive für mobile Ansichten.
+- **Admin-CRUD:** Szenarien, Räume und Rätsel inklusive JSON-Payload und Prüfungsbereich pflegbar.
+- Dashboard, Security-CSRF-Ausnahme, Score-/XP-/Achievement-System und Admin-Dashboard integriert.
+- Vier neue Service-Tests prüfen Lösungsfreiheit, serverseitige Hint-/Versuchsabrechnung sowie
+  Schutz vor fremden IDs und unplausiblen Laufzeiten.
+
 ## [Unreleased] – 2026-06-30 · Login, Registrierung & Konten
 
 Reihe von Fixes und Verbesserungen rund um Anmeldung, Registrierung und

STYLEGUIDE.md

@@ -36,17 +36,18 @@ Theme-Umschaltung: über das Attribut `<html data-theme="dark|light">` (gesetzt/
 | `--surface-2` | `#1b1610` | `#fbf4e6` | erhöhte Fläche, Hover, Felder |
 | `--border` | `#2a2117` | `#ece1cf` | Standard-Rahmen |
 | `--line` | `#221b12` | `#f1e8d8` | feine Linien, Scrollbar, Chart-Achsen |
-| `--border-accent` | `rgba(240,168,26,.45)` | `rgba(214,81,22,.40)` | akzentuierte Rahmen |
+| `--border-accent` | `rgba(240,168,26,.45)` | `rgba(194,65,12,.40)` | akzentuierte Rahmen |
-| `--accent` | `#f0a81a` | `#d65116` | **Primärakzent**: Buttons, aktive Nav, Icons, Headline-Akzent |
+| `--accent` | `#f0a81a` | `#c2410c` | **Primärakzent**: Buttons, aktive Nav, Icons, Headline-Akzent |
-| `--accent-2` | `#f7dc11` | `#e4801d` | Sekundär-Akzent für Verläufe (Gelb-Glow) |
+| `--accent-2` | `#f7dc11` | `#b45309` | Sekundär-Akzent für Verläufe (Gelb-Glow) |
 | `--accent-ink` | `#1c1100` | `#ffffff` | Textfarbe **auf** Akzentflächen |
-| `--secondary` | `#2d9cce` | `#1f86b8` | **Flux-Blau**: Links + „richtig" |
+| `--secondary` | `#2d9cce` | `#146b96` | **Flux-Blau**: Links + „richtig" |
-| `--secondary-2` | `#5cc4e8` | `#2d9cce` | helleres Blau (Hover/Variante) |
+| `--secondary-2` | `#5cc4e8` | `#0f5a80` | helleres Blau (Hover/Variante) |
 | `--text` | `#ece3d2` | `#33271c` | Fließtext |
-| `--muted` | `#8c8170` | `#8a7d6c` | gedämpfter Text, Labels, Captions |
+| `--muted` | `#8c8170` | `#6b5f4c` | gedämpfter Text, Labels, Captions |
 | `--heading` | `#ffffff` | `#241a12` | Überschriften |
-| `--success` | `#2d9cce` | `#1f86b8` | **„richtig"** (= Flux-Blau, bewusst kein Grün) |
+| `--success` | `#2d9cce` | `#146b96` | **„richtig"** (= Flux-Blau, bewusst kein Grün) |
 | `--danger` | `#ff4d6d` | `#be123c` | **„falsch"** / Fehler / Löschen (kühles Crimson) |
+| `--warn` | `#edcb4c` | `#8a6a06` | **„eingeschränkt"** / Warnstatus (Light-Wert WCAG-AA) |
 | `--glow-s` | `rgba(240,168,26,.55)` | `rgba(214,81,22,.40)` | **starker** Glow (Text-/Drop-Shadow auf Akzent) |
 | `--glow-w` | `rgba(240,168,26,.16)` | `rgba(214,81,22,.12)` | **weicher** Ambient-Glow |
 | `--g-soft` | `0 0 18px var(--glow-w)` | `0 6px 18px var(--glow-w)` | Standard-Panel-Schatten |
@@ -94,6 +95,10 @@ Muster (siehe z. B. `syntaxsaga.css` / `techtacular.css`):
 - **Panel-Schatten:** `box-shadow: var(--g-soft)`.
 - **Radien (Konvention):** Badges/Buttons ~`7–9px`, Inputs/Icon-Buttons `10px`, Nav `11px`,
   Panels `13–14px`, Standalone-Karten `16–18px`, Pills/Bars `99px`.
+- **Header-Icon-Buttons** (`.mf-iconbtn`, `.mf-theme`, `.mf-a11y-trigger`, `.ft-trigger`):
+  einheitlich **`42×42px`**, Radius `10px`, **Outline-Stil** (Surface-Fill, 1px Border,
+  Akzent nur über `color`/`border-color`), Glyphe **`20×20px`**. Der `.mf-theme`-Toggle behält
+  Akzentfarbe + Glow als Erkennungsmerkmal.
 - **Spielkarten** (`.mf-card`) haben eine **abgeschrägte Ecke** via `clip-path` (`--n:18px`) statt
   rundem Radius – ein bewusstes „HUD"-Detail.
 
@@ -157,16 +162,18 @@ Feedback-Konvention (Blau/Rot) einhalten.
 ## Do / Don't
 
 **Do**
-- Farben/Schatten/Glow ausschließlich über Tokens.
+- Farben, Schatten und Effekte ausschließlich über Tokens. Für Effekte die
+  Primitives `--g-text`, `--g-icon`, `--g-strong`, `--g-amb`, `--g-card`,
+  `--g-card-hover`, `--g-overlay` und `--g-focus` verwenden; keine direkten
+  Glow-Geometrien in Komponenten schreiben.
 - Auf Akzentflächen Text in `--accent-ink`.
 - Erfolg = Blau, Fehler = Rot (nie Grün/Orange für „richtig/falsch").
 - Neue Komponenten an den `.mf-*`-Bausteinen orientieren.
 
 **Don't**
 - Keine hart kodierten Hex-/RGBA-Werte in Templates oder Spiele-CSS.
-- Nicht die **Legacy-Dateien** als Stil-Referenz nehmen: `achievements.css`, `progress.css`,
+- Keine direkten `0 0 … var(--glow-*)`-, `text-shadow`- oder `drop-shadow`-Werte
-  `settings.css`, `soziales.css` (ungenutzt) sowie alte Schrift-Deklarationen
+  in Komponenten. Maßgeblich ist `theme.css`.
-  (`'Segoe UI'`/`'Poppins'`) entsprechen **nicht** dem aktuellen System. Maßgeblich ist `theme.css`.
 
 ---
 

docker-compose.yml

@@ -9,12 +9,10 @@ services:
       SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/mindfluxdb
       SPRING_DATASOURCE_USERNAME: mindflux
       SPRING_DATASOURCE_PASSWORD: "${MINDFLUX_DB_PASSWORD:?MINDFLUX_DB_PASSWORD muss als Secret gesetzt sein}"
-
       # --- App: lauscht intern auf 8080 (nginx -> mindflux:8080) ---
       SERVER_PORT: "8080"
       MINDFLUX_PUBLIC_URL: "https://mindflux.sysnaptik.de"
       MINDFLUX_COOKIE_SECURE: "true"
-
       # --- Bootstrap-Admins: Passwörter kommen aus Gitea-Secrets (siehe Workflow) ---
       MINDFLUX_ADMIN_USERNAME: "AliceDarkest"
       MINDFLUX_ADMIN_EMAIL: "AliceDarkest@gmail.com"
@@ -22,6 +20,13 @@ services:
       MINDFLUX_ADMIN2_USERNAME: "KevCipher"
       MINDFLUX_ADMIN2_EMAIL: "kevcipher@proton.me"
       MINDFLUX_ADMIN2_PASSWORD: "${MINDFLUX_ADMIN2_PASSWORD}"
+      # --- Mailversand ---
+      # Der Zertifikatsname des SMTP-Servers; der interne Docker-Alias "mailserver"
+      # würde die STARTTLS-Hostname-Prüfung scheitern lassen.
+      MAIL_HOST: mail.sysnaptik.de
+      MAIL_PORT: "587"
+      MAIL_USERNAME: "noreply@sysnaptik.de"
+      MAIL_PASSWORD: "${MAIL_PASSWORD}"
 
     healthcheck:
       test: ["CMD", "curl", "-fs", "http://localhost:8080/actuator/health"]

mindfluxfuture.md

@@ -2,20 +2,20 @@
 
 ## Kontext
 
-Das Dashboard von Mindflux (`mindflux2`, Spring Boot 3.4.4 / Java 17 / PostgreSQL + Flyway / Thymeleaf / Vanilla-JS) zeigt 9 Spiele. Vier davon sind nur Platzhalter-Karten, die auf `/comingsoon` (`dummy.html`) zeigen und **keinerlei Mechanik, Controller, Tabellen oder Inhalte** besitzen:
+Das Dashboard von Mindflux (`mindflux2`, Spring Boot 3.4.4 / Java 21 / PostgreSQL + Flyway / Thymeleaf / Vanilla-JS) zeigt 9 Spiele. Vier Spiele waren bei Erstellung dieses Plans Platzhalter-Karten. **Alle vier – SystemEscape, BugHunter, NetWorker und ServiceClash – sind inzwischen umgesetzt.**
 
-1. **Code Escape Room** – „Entkomme mit IT-Rätseln aus digitalen Räumen – sei schnell und clever."
+1. **SystemEscape** – „Löse IT-Rätsel, sammle Zugriffsfragmente und entkomme dem System."
 2. **Service Clash** – „Der chaotische Admin-Alltag als Spiel – meistere Anfragen & halte Systeme am Laufen!"
 3. **Bug Hunter** – „Finde Fehler im Code, denke wie ein Debugger und löse knifflige Bugs."
 4. **Netzwerker – Das Router-Rätselspiel** – „Verbinde Netzwerke, konfiguriere IPs und löse Routing-Herausforderungen."
 
-Die Infrastruktur wartet bereits auf sie: Die Spiel-Keys `escape-room`, `service-clash`, `bug-hunter`, `netzwerker` stehen schon in der Score-Allowlist (`GameScoreController.KNOWN_GAMES`, Zeile 23–25) und in `ProgressService.GAMES` (Zeile 23–26); die Dashboard-Icons (`lock`, `sword`, `bug`, `network`) existieren in `dashboard.html`. Ziel dieses Plans: detaillierte, umsetzungsreife Designs für alle vier Spiele nach dem etablierten Architektur-Rezept der vorhandenen Spiele (MindMatch, TechTacular, Syntax Saga, Dev Lab) sowie ein priorisierter Verbesserungs-/Optimierungskatalog für den Rest der Plattform.
+Die Spiel-Keys `codeescape`, `serviceclash`, `bughunter`, `networker` stehen in der Score-Allowlist (`GameScoreController.KNOWN_GAMES`) und in `ProgressService.GAMES`; die Dashboard-Icons (`lock`, `sword`, `bug`, `network`) existieren in `dashboard.html`. Dieser Plan dokumentiert den erreichten Stand und bleibt Referenz für spätere Content- und Visual-Vertiefungen.
 
 **Zielgruppe & inhaltlicher Anspruch: die GESAMTE Fachinformatiker-Ausbildung.** Nicht nur AP1 – abgedeckt werden muss die komplette Ausbildung bis einschließlich **AP2** (beide Fachrichtungen: Anwendungsentwicklung/FIAE und Systemintegration/FISI). Konsequenzen für alle Spiele und Inhalte:
 
 - **Schwierigkeitsstufen = Ausbildungsprogression.** Die in allen vier Designs vorhandenen Stufen (Junior/Senior/Principal, leicht/mittel/schwer, Welten 1–3, Schicht 1–3) werden inhaltlich gemappt: untere Stufen ≈ 1. Lehrjahr/AP1-Stoff, obere Stufen ≈ AP2-Niveau. Kein Schema-Umbau nötig – die `difficulty`-Felder existieren in allen Datenmodellen bereits; es ist eine **Content-Kuratierungs-Regel**.
-- **AP2-Content pro Spiel (Startrichtung):** CodeEscape → Szenarien zu Verschlüsselung/Zertifikaten, Virtualisierung/Container, Backup-Strategien; BugHunter → Principal-Fälle auf FIAE-AP2-Niveau (Nebenläufigkeit/Threads, Transaktions-/SQL-Fehler, Design-Pattern-Missbrauch, OWASP-Lücken); ServiceClash → Schichten mit Change-Management, Monitoring/Eskalationsketten, Security-Incidents (FISI-AP2); NetWorker → Welten zu VLAN, statischem Routing über mehrere Hops, Firewall-Regeln und (Ausbau) IPv6/Subnetting-Transfer.
+- **AP2-Content pro Spiel (Startrichtung):** SystemEscape → Szenarien zu Verschlüsselung/Zertifikaten, Virtualisierung/Container, Backup-Strategien; BugHunter → Principal-Fälle auf FIAE-AP2-Niveau (Nebenläufigkeit/Threads, Transaktions-/SQL-Fehler, Design-Pattern-Missbrauch, OWASP-Lücken); ServiceClash → Schichten mit Change-Management, Monitoring/Eskalationsketten, Security-Incidents (FISI-AP2); NetWorker → Welten zu VLAN, statischem Routing über mehrere Hops, Firewall-Regeln und (Ausbau) IPv6/Subnetting-Transfer.
-- **Content-Tagging:** Beim Kuratieren jedes Inhalts (Seeder-JSONs, Admin-Eingaben) wird vermerkt, ob er AP1-, AP2/FIAE- oder AP2/FISI-relevant ist – zunächst als Konvention im Titel/`description` (z. B. Präfix „[AP2]"), später optional als eigenes Feld + Filter in den Lobbys („Zeige nur AP2-Stoff").
+- **Content-Tagging:** Neue Parent-Inhalte erhalten von Anfang an ein persistiertes Feld `exam_scope VARCHAR(20) NOT NULL DEFAULT 'AP1'` mit der Allowlist `AP1 | AP2_FIAE | AP2_FISI | CROSS`. Seeder und Admin validieren dieses Feld; Katalog-DTOs geben es aus. Titelpräfixe sind nur Anzeige, nie Datenquelle. Lobby-Filter können dadurch später ohne Migration ergänzt werden.
 - **FinalFlux erweitern:** Das bestehende Lernmodul ist rein AP1-fokussiert (28 Seiten + FluxChecks). Die Struktur (statische Themenseiten + Frage-JSONs) trägt problemlos einen **AP2-Ast** – als eigener Sidebar-Block „AP2 Anwendungsentwicklung" / „AP2 Systemintegration" (in Teil 2 als Punkt S10 aufgenommen).
 - Die vorhandenen FinalFlux-Inhalte (IP-Berechnung, VLAN, OSI, Wirtschaft) bleiben die AP1-Basis, auf der die Spiele aufsetzen.
 
@@ -36,18 +36,22 @@ Vorgabe: Alle Spielnamen folgen dem MindMatch-Muster – **ein Wort, englisch, C
 | Dev Lab | **DevLab** | `/devlab` | `devlab` |
 | Syntax Saga | **SyntaxSaga** | `/syntaxsaga` | `syntax-saga` (Key behalten – es existieren bereits Scores) |
 | FinalFlux | **FinalFlux** ✓ | `/finalflux` | – |
-| Code Escape Room | **CodeEscape** | `/codeescape` | `codeescape` |
+| SystemEscape | **SystemEscape** | `/codeescape` | `codeescape` |
 | Service Clash | **ServiceClash** | `/serviceclash` | `serviceclash` |
 | Bug Hunter | **BugHunter** | `/bughunter` | `bughunter` |
 | Netzwerker – Das Router-Rätselspiel | **NetWorker** | `/networker` | `networker` |
 
-Begründung Keys: Die vorhandenen Routen sind alle klein und zusammengeschrieben (`/mindmatch`, `/syntaxsaga` …) – die neuen Routen folgen dem. Die vier reservierten Keys (`escape-room`, `service-clash`, `bug-hunter`, `netzwerker`) haben **noch keine Scores in der DB** und werden daher jetzt kostenlos auf das einheitliche Schema umbenannt (`codeescape`, `serviceclash`, `bughunter`, `networker`) – zu ändern in `GameScoreController.KNOWN_GAMES`, `ProgressService.GAMES` und den jeweiligen Service-`GAME`-Konstanten. Nur `syntax-saga` behält seinen Key (Bestandsdaten), Anzeigename wird trotzdem `SyntaxSaga`. Anzeigenamen anpassen in: `dashboard.html`-`GAMES`-Array, `ProgressService.GAMES`, Seitentiteln/Templates der neuen Spiele. _Alle nachfolgenden Abschnitte verwenden bereits die neuen Namen; wo im Text noch V9–V12-Design-Details Alt-Keys nennen, gilt die Tabelle hier._
+Begründung Keys: Die vorhandenen Routen sind alle klein und zusammengeschrieben (`/mindmatch`, `/syntaxsaga` …) – die neuen Routen folgen dem. Die historischen Plan-Aliasse `escape-room`, `service-clash`, `bug-hunter` und `netzwerker` hatten noch keine Scores und wurden deshalb vor der Implementierung auf `codeescape`, `serviceclash`, `bughunter` und `networker` vereinheitlicht. Nur `syntax-saga` behält seinen Key wegen möglicher Bestandsdaten. Die Tabelle und der Abschnitt „Gemeinsames Architektur-Rezept" sind die verbindliche Quelle; verbliebene Altbegriffe in erklärenden Designpassagen sind keine Routen- oder Schema-Vorgaben.
 
 ---
 
-## Visuelle Identität: vier Spiele, vier Welten
+## Visuelle Identität: neun Lernwelten
 
-> ☐ **Noch offen** – wird mit dem Bau der Spiele umgesetzt; auch die Spiel-Akzent-Tokens in `theme.css` sind noch nicht angelegt.
+> ◐ **Stand 2026-07-13:** Die Dark-/Light-Akzent-Tokens für alle vier Spiele sind in
+> `theme.css` angelegt. SystemEscape, BugHunter und NetWorker haben eigene Spiel-Layouts;
+> BugHunter nutzt Fallakten-/Aktenschrank-Optik, NetWorker ein sichtbares Blaupausenraster.
+> ServiceClash ist nun als eigenständiger cyanfarbener Leitstand umgesetzt; optionale
+> Echtzeit-SLA-Animationen bleiben ein möglicher Ausbau.
 
 Vorgabe: Die Spiele sollen **grafisch stark ausgeprägt** sein und sich **sehr deutlich** voneinander unterscheiden – nicht nur mechanisch, sondern auf den ersten Blick. Dazu zwei Maßnahmen:
 
@@ -57,12 +61,100 @@ Vorgabe: Die Spiele sollen **grafisch stark ausgeprägt** sein und sich **sehr d
 
 | Spiel | Welt-Metapher | Farbstimmung | Prägende visuelle Elemente |
 |-------|---------------|--------------|---------------------------|
-| **CodeEscape** | Dunkle Facility bei Nacht | Bernstein/Orange auf Tiefschwarz | CRT-Terminals mit Scanline-Overlay, physisches Keypad mit Tasten-Feedback, Raum-„Bühnenbild" als SVG-Illustration (Racks, Türen, flackernde Neonröhre), Fragment-Chips wie Hardware-Token, Alarm-Puls bei Zeitablauf, Tür-Öffnungs-Animation zwischen Räumen |
+| **SystemEscape** | Dunkle Facility bei Nacht | Bernstein/Orange auf Tiefschwarz | CRT-Terminals mit Scanline-Overlay, physisches Keypad mit Tasten-Feedback, Raum-„Bühnenbild" als SVG-Illustration (Racks, Türen, flackernde Neonröhre), Fragment-Chips wie Hardware-Token, Alarm-Puls bei Zeitablauf, Tür-Öffnungs-Animation zwischen Räumen |
 | **BugHunter** | Noir-Detektivbüro | Entsättigt + Crimson-Akzente | Fallakten-Optik (Aktendeckel, Büroklammer, „VERTRAULICH"-Stempel), IDE-Look mit Zeilennummern-Gutter und Tab-Reitern, roter Ermittlungsfaden zum markierten Bug, „GELÖST"-Stempel-Animation im Debriefing, Schreibmaschinen-Typo für Briefings |
 | **ServiceClash** | Hektischer Leitstand/Cockpit | Kühles Cyan + Warnrot | Kanban-artige Ticket-Queue mit einfliegenden Karten, große SLA-Ring-Gauges und Gesundheits-Meter, laufender Event-Ticker unten, Wellen-Countdown-Banner, komisch überzeichnete Ticket-Icons (brennender Drucker 🔥), Screen-Shake bei Major Incidents |
 | **NetWorker** | Technische Blaupause | Blueprint-Blau auf Millimeterpapier | Raster-Hintergrund wie Konstruktionszeichnung, Geräte als Schematic-Glyphen, Gummiband-Kabelzug, leuchtende Paket-Punkte, die den echten Trace entlangfliegen und am Fehler-Hop rot zerplatzen, Diagnose-Callouts wie Plan-Anmerkungen |
 
-Dazu je Spiel ein eigenes Karten-Design auf dem Dashboard (Hover-Animation im jeweiligen Spiel-Akzent), damit die Unterscheidbarkeit schon in der Übersicht beginnt. Die Interaktionsformen sind ohnehin grundverschieden: Modal-Rätsel + Keypad (CodeEscape), klickbarer Code-Viewer (BugHunter), Echtzeit-Queue (ServiceClash), frei bespielbare SVG-Canvas (NetWorker).
+Dazu je Spiel ein eigenes Karten-Design auf dem Dashboard (Hover-Animation im jeweiligen Spiel-Akzent), damit die Unterscheidbarkeit schon in der Übersicht beginnt. Die Interaktionsformen sind ohnehin grundverschieden: Modal-Rätsel + Keypad (SystemEscape), klickbarer Code-Viewer (BugHunter), Echtzeit-Queue (ServiceClash), frei bespielbare SVG-Canvas (NetWorker).
+
+### Eigenständige Skins für die Bestandsmodule ✅ umgesetzt
+
+Die gemeinsame Mindflux-Grundlage bleibt erhalten: Typografie, Fokuszustände, Buttons,
+Fehler-/Erfolgsfarben und das Accessibility-Widget werden nicht pro Spiel neu erfunden.
+Jede Lernwelt erhält aber eigene Akzent-Tokens, Hintergrundstruktur und eine passende
+Oberflächenmetapher – im Dark- wie im Light-Theme.
+
+| Modul | Skin | Akzent & Metapher | Umsetzungshinweis |
+|---|---|---|---|
+| **MindMatch** | Neural Archive | Violett/Mint, Synapsenlinien und schwebende Gedächtniskarten | Paare bleiben klar lesbar; Verbindungen sind dekorativ, nicht alleiniger Status. |
+| **TechTacular** | Cyber-Quizshow | Magenta/Blau, LED-Raster und Punktetafel | Das Jeopardy-Board wird zur Show-Bühne, ohne die Kachelkontraste zu verlieren. |
+| **DevLab** | Werkstatt & Build-Pipeline | Petrol/Orange, Werkbank- und Schaltkreisstruktur | **Der schwebende Kolben samt \`dlFloat\`-Animation bleibt unverändert erhalten.** Nur Farben, Umgebung und Panels werden nachgeschärft. |
+| **SyntaxSaga** | Textadventure-Terminal | Phosphorgrün/Bernstein, dezente CRT-Scanlines und Log-Charakter | Grün dient ausschließlich der Atmosphäre; richtig bleibt Plattform-Blau, falsch bleibt Rot. |
+| **FinalFlux** | Prüfungszentrale | Gold/Indigo, ruhige Sternkarten-/Konstellationsstruktur | Bewusst weniger spielig: die Lernzentrale verbindet alle Welten und priorisiert Lesbarkeit. |
+
+**Technische Leitplanken:** zentrale Token in \`theme.css\`, lokale Überschreibung nur am
+jeweiligen Seiten-Root (\`mm-\`, \`tt-\`, \`dl-\`/\`dlg-\`, \`ss-\`, \`finalflux-\`), keine
+Änderung der Spielmechanik; Cache-Busting bei jeder CSS-Auslieferung. Das
+Accessibility-Widget soll anschließend jeweils den lokalen Akzent übernehmen.
+
+> ✅ **Stand 2026-07-13:** Die fünf Skins sind als lokale Token-Überschreibungen mit
+> Cache-Busting umgesetzt. MindMatch, TechTacular, DevLab samt Aufgabenraum, SyntaxSaga
+> und FinalFlux haben jeweils eigene Hintergründe und Akzente; das Accessibility-Widget
+> übernimmt die neue Farbe. Die bestehende Kolben-/dlFloat-Animation in DevLab blieb
+> unverändert.
+
+---
+
+## Plattform-Rebrand: SysnaptiK Neural ⏳ in Umsetzung
+
+> ✅ **Stand 2026-07-14:** Die sichtbare Plattformhülle ist auf SysnaptiK Neural
+> umgestellt: zentrale Neural-Schicht, Wortmarke, Login/Registrierung, Dashboard,
+> Plattformseiten und FinalProtocol. Die Spielwurzeln sind explizit vom Plattform-Scope
+> ausgeschlossen und behalten ihre jeweiligen internen Skins. NeuralPause ersetzt die
+> sichtbare FluxTimer-/Zeitreise-Copy. Domain-/DNS-Umzug und technische Paket-/Tabellennamen
+> bleiben bewusst separate Schritte. Der Dashboard-Status ist als echter Lernnetz-Status
+> umgesetzt: Er prüft den Fortschrittsspeicher statt eine feste Verfügbarkeit vorzutäuschen.
+> Die Plattformdiagramme und Accessibility-Modi berücksichtigen die Neural-Tokens auch
+> dann, wenn einzelne Seiten oder Spiele eigene lokale Akzente setzen.
+> Die Hülle ist zudem renderblockierend und mit früher HTML-Klasse eingebunden, damit beim
+> Navigationwechsel kein früheres Plattformfarbschema aufblitzt.
+
+### Ziel und Abgrenzung
+
+Mindflux wird vor dem öffentlichen Launch als **SysnaptiK Neural** positioniert. Die Plattform
+wechselt vom bisherigen Zeitreise-/Back-to-the-Future-Anklang zu einer eigenständigen
+neuronalen Netzwerk-Metapher. Das Lernmodul **FinalFlux** heißt künftig **FinalProtocol**.
+
+Der Rebrand betrifft ausschließlich die Plattformhülle: Startseite, Login/Registrierung,
+Dashboard, Profil, Fortschritt, Erfolge, Einstellungen, Knowledge Core, FinalProtocol,
+Admin- und Rechtsseiten, Seitentitel sowie öffentliche Metadaten. Die eigenständigen
+Spielwelten und ihre internen Farben bleiben unverändert.
+
+### Visuelles System
+
+- **Grundwelt:** tiefes Petrol/Schwarz, leise Netzwerklinien, Knoten, weiche Glows und
+  klare technische Panels statt Zeitreise-, DeLorean-, Fluxkompensator- oder BTTF-Verweise.
+- **Marke:** CSS-/SVG-Wortmarke „SYSNAPTIK NEURAL“ mit abstraktem neuronalen Knoten statt
+  einer abgeleiteten Popkultur-Ästhetik.
+- **Statusfarben:** Erfolg bleibt Plattform-Blau, Fehler Rot; Knotenstatus wird zusätzlich
+  über Symbol, Text und Form vermittelt.
+- **Knotenfarben auf der Plattform:** MindMatch Magenta/Violett, TechTacular Gelb,
+  DevLab Mint, SyntaxSaga Violett, SystemEscape Bernstein, ServiceClash Türkis,
+  BugHunter Crimson, NetWorker Blau und FinalProtocol Orange. Diese Zuordnung gilt für
+  Dashboard, Lernnetz, Fortschritt und Erfolge – nicht als Änderung der Spieloberflächen.
+
+### Umsetzungsphasen
+
+1. **Fundament:** zentrale Neural-Tokens und Markenbausteine in theme.css, BTTF-/Zeitreise-
+   Copy aus Plattform-Tokens und FluxTimer entfernen; Accessibility auf die neutrale
+   Plattformfarbe ausrichten.
+2. **Referenzoberflächen:** Start/Authentifizierung und Dashboard als neuraler Leitstand:
+   neue Sidebar, Spielknoten-Karten, Systemstatus, echter Fortschritt und ein
+   Lernnetz statt dekorativer Platzhalter.
+3. **Plattformseiten:** Profil, Fortschritt, Erfolge, Einstellungen, Knowledge Core,
+   Fehler-, Rechts- und Admin-Seiten auf das gemeinsame Layout und die Wortmarke ziehen.
+4. **FinalProtocol:** Anzeigename, Hub, Lernseiten, Navigation, Titel und Verweise von
+   FinalFlux auf FinalProtocol umstellen; URLs bleiben zunächst kompatibel bei
+   /finalflux, um bestehende Links nicht zu brechen.
+5. **Öffentliche Identität & Rollout:** Dokumentation, Titel/Meta-/OpenGraph-Texte,
+   Datenschutz/Impressum und Konfiguration auf SysnaptiK Neural umstellen. Ein möglicher
+   Domainwechsel auf neural.sysnaptik.de erfolgt separat zusammen mit DNS, nginx,
+   Cookie-Domain und einer Weiterleitung von mindflux.sysnaptik.de.
+6. **Abnahme:** Dark/Light, Mobilansicht, Tastatur-/Lesemodus, Kontraste und alle
+   Spielrouten prüfen. Technische Paketnamen, Datenbanktabellen, Score-Keys und Secrets
+   bleiben im ersten Schritt bewusst stabil; eine spätere technische Umbenennung ist ein
+   separates Migrationsprojekt.
 
 ---
 
@@ -70,7 +162,7 @@ Dazu je Spiel ein eigenes Karten-Design auf dem Dashboard (Hover-Animation im je
 
 Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan: **Dev Lab**, `DevLabService.java` + `devlabgame.js`):
 
-1. **Flyway-Migration** `db/migration/V9__…` ff. (V8 ist die letzte; `ddl-auto=validate` ⇒ Migration ist Pflicht). SQL-Stil: `BIGINT GENERATED BY DEFAULT AS IDENTITY`, `slug VARCHAR UNIQUE`, `sort_order INT DEFAULT 0`, `active BOOLEAN DEFAULT TRUE`, `FK … ON DELETE CASCADE`, Indizes.
+1. **Flyway-Migration** ab `db/migration/V11__…` (V9/V10 sind durch User-/Datenintegrität belegt; `ddl-auto=validate` ⇒ Migration ist Pflicht). Umgesetzt: V11 SystemEscape, V12 BugHunter, V13 BugHunter-Fortschritt, V14 NetWorker und V15 ServiceClash. SQL-Stil: `BIGINT GENERATED BY DEFAULT AS IDENTITY`, `slug VARCHAR UNIQUE`, `exam_scope VARCHAR(20)`, `sort_order INT DEFAULT 0`, `active BOOLEAN DEFAULT TRUE`, `FK … ON DELETE CASCADE`, Indizes.
 2. **Entities** in `model/` (Parent mit `@OneToMany(cascade=ALL, orphanRemoval=true)`, Lösungs-Logik nur serverseitig auf der Entity).
 3. **Repository** in `repository/` (`findAllByActiveTrueOrderBySortOrderAscIdAsc()`, `findBySlug`, `countBy…Id`).
 4. **Service** in `service/` mit Konstante `GAME = "<key>"`, injiziert `GameScoreService`; `@Transactional(readOnly=true)` für Build/Check, `@Transactional` für `finish`. **Score wird ausschließlich serverseitig berechnet** (`gameScoreService.recordScore(user, GAME, deck, score, moves, seconds)`); Client sendet nur Roh-Antworten.
@@ -82,13 +174,37 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 10. **Frontend:** Template in `templates/`, eigenes CSS mit eindeutigem Präfix (nur `theme.css`-Tokens, Erfolg = blaues ✓, Fehler = rotes ✗, **nie grün**), JS als IIFE in `static/js/`, Highscore via `GET /api/games/<key>/stats`, Cache-Busting `?v=N`.
 11. **Integration:** Route in `SecurityConfig`-CSRF-Ignore-Liste aufnehmen, Dashboard-Karte in `dashboard.html` von `/comingsoon` auf die echte Route umstellen. (`KNOWN_GAMES` + `ProgressService` enthalten die Keys bereits.)
 
+### Verbindlicher Sicherheitsvertrag für neue Spiele (S3)
+
+1. Session-/Katalogantworten enthalten nur opaque IDs und lösungsfreie DTOs; Lösung, Reveal-Status und Scoring-Metadaten bleiben serverseitig.
+2. `finish` akzeptiert nur IDs aus der angeforderten Runde und verwirft fremde, doppelte oder nicht zum Parent gehörende IDs.
+3. Punkte, Sterne, Highscore, gelöste Anzahl und Boni werden ausschließlich serverseitig aus kanonischen Daten neu berechnet.
+4. `durationSeconds` muss plausibel sein (`>= 1` und höchstens das konfigurierte Limit plus dokumentierte Toleranz); Listen und Zähler erhalten fachliche Obergrenzen.
+5. Reveal-/Hint-Nutzung wird serverseitig protokolliert oder beim Finish erneut validiert und kann nicht durch Weglassen im Request verborgen werden.
+6. Deterministische Seeds werden spätestens bei ServiceClash mit einem serverseitigen HMAC signiert; der Client darf keinen frei wählbaren Seed zur Wertung einreichen.
+7. Für jedes Spiel entstehen Negativtests: fremde IDs, Duplikate, überlange Listen, unmögliche Zeiten, manipulierte gesperrte Felder und Reveal-vor-Finish.
+
 ---
 
 ## Teil 1: Spieldesigns
 
-### Spiel 1: Code Escape Room (Key: `escape-room`, Migration V9)
+### Plattformweite Barrierefreiheit ✅ Grundwidget umgesetzt
 
-**Konzept:** Der Spieler ist in einer digitalen Umgebung eingesperrt (Serverraum, Admin-Büro, Rechenzentrum). Ein **Szenario** = ein Durchlauf mit 3 Räumen in fester Reihenfolge; jeder Raum enthält 2–3 IT-Rätsel plus ein **Tür-Keypad**. Jedes gelöste Rätsel liefert ein **Code-Fragment** (Ziffern/Hex-Chunk in einer Inventar-Leiste); die Fragmente ergeben zusammen den Türcode zum nächsten Raum. Countdown erzeugt Zeitdruck; ein 2-stufiges Hinweis-System tauscht Punkte gegen Hilfe.
+- Globales, per Tastatur erreichbares Accessibility-Panel über einen schwebenden Rollstuhl-Button.
+- Schriftgröße in vier nachvollziehbaren Stufen (100 %, 115 %, 130 %, 150 %), lokal gespeichert
+  und auf Dashboard, Lernseiten sowie allen Spielen identisch angewendet.
+- Enthalten: erhöhter Kontrast, farbenblindfreundliches Statusfarbprofil, Monochrommodus,
+  Lesemodus für Dyslexie mit Verdana und angepassten Abständen, unterstrichene Links, reduzierte Bewegungen, großer
+  Cursor, gut sichtbare Fokusmarkierungen und zentraler Reset.
+- Noch offen bleibt die systematische Prüfung aller Spielmechaniken auf vollständige
+  Tastaturbedienbarkeit sowie ein WCAG-Audit mit Kontrastmessung und Screenreader-Tests.
+- Layouts dürfen bei Textvergrößerung weder Inhalte abschneiden noch horizontales Scrollen der
+  gesamten Seite erzwingen; Codebereiche dürfen weiterhin gezielt horizontal scrollen.
+- Das Panel ergänzt semantisches HTML und WCAG-Prüfungen, ersetzt diese aber nicht.
+
+### Spiel 1: SystemEscape (interner Key: `codeescape`, Migration V11 + Datenfix V11.1) ✅ MVP inklusive Spielführung umgesetzt
+
+**Konzept:** Der Spieler ist in einer digitalen Umgebung eingesperrt (Serverraum, Admin-Büro, Rechenzentrum). Ein **Szenario** besitzt einen Pool aus 8 Räumen; jeder Run zieht daraus 4 Räume in zufälliger Reihenfolge. Jeder Raum enthält 2–3 IT-Rätsel plus ein **Tür-Keypad**. Jedes gelöste Rätsel liefert ein **Code-Fragment**; die Fragmente ergeben zusammen den Türcode zum nächsten Raum. Countdown erzeugt Zeitdruck; ein 2-stufiges Hinweis-System tauscht Punkte gegen Hilfe.
 
 **Lernziele (AP1 → AP2):** Zahlensysteme (Bin/Hex/Dez), Ports & Protokolle, Subnetting, TCP-Handshake/Boot-Reihenfolgen, RAID, Hardware, SQL/Shell-Grundlagen – als Rätsel verpackt statt als Quiz. Schwere Szenarien tragen AP2-Stoff (Verschlüsselung/Zertifikate, Virtualisierung/Container, Backup-Strategien).
 
@@ -103,9 +219,9 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 - Pro Rätsel: `punkte × versuchsfaktor × hinweisfaktor` (Versuch: 1.0/0.6/0.3, aufgedeckt 0; Hinweis: keiner ×1.0, Stufe 1 ×0.8, Stufe 2 ×0.6). Hinweis-Nutzung wird **serverseitig in der HttpSession** protokolliert (der `/hint`-Endpoint merkt sich die höchste gelieferte Stufe pro Rätsel) – der Client kann sie nicht unterschlagen. _(Einzige bewusste Abweichung vom sonst zustandslosen Muster.)_
 - Pro geöffneter Tür: pauschal **+50**.
 - Sterne aus `baseScore/maxScore` (≥0.8→3, ≥0.5→2). **Zeitbonus danach**, nur bei Flucht: `max(0, round(500 × (zeitlimit − sekunden) / zeitlimit))` – die MindMatch-Idee, auf 15-Minuten-Läufe skaliert. Timer auf 0 bricht nicht ab: HUD wechselt in „ALARM"-Zustand (pulsierendes `var(--danger)`), der Bonus ist nur weg.
-- `recordScore(user, "escape-room", szenarioSlug, baseScore + zeitbonus, gelösteRätsel, sekunden)`.
+- `recordScore(user, "codeescape", szenarioSlug, baseScore + zeitbonus, gelösteRätsel, sekunden)`.
 
-**Datenmodell (`V9__escape_room.sql`):** 3 Tabellen im V8-Stil:
+**Datenmodell (`V11__codeescape.sql`):** 3 Tabellen im V8-Stil:
 - `escape_scenarios` (id, slug UNIQUE, title, difficulty, description, time_limit_seconds INT DEFAULT 900, sort_order, active)
 - `escape_rooms` (id, scenario_id FK CASCADE, title, intro, door_prompt, **door_code VARCHAR(50)**, success_text, sort_order)
 - `escape_puzzles` (id, room_id FK CASCADE, puzzle_type VARCHAR(30), prompt, points INT DEFAULT 100, **code_fragment VARCHAR(20)**, sort_order, payload VARCHAR(8000))
@@ -116,7 +232,7 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 - `check(puzzleId, reveal, submission)` – Typ `code`: neuer trivialer Checker via `anyEquals(payload.solutions, answer, caseSensitive)`; **`choice`/`order`/`match`: Checker 1:1 aus `DevLabService` kopieren.** Bei `correct || reveal` kommt `"fragment"` in die Antwort.
 - `openDoor(roomId, code)`, `hint(session, puzzleId, level)`, `finish(...)` wie oben; plus Admin-Methoden nach Dev-Lab-Vorbild.
 
-**API (`/api/escape-room`):** `GET /scenarios`, `GET /session/{slug}`, `POST /check` (`{puzzleId, reveal, submission:{answer}}` → `{correct, fragment, successText}`), `POST /door` (`{roomId, code}` → `{open, successText}`), `POST /hint` (`{puzzleId, level}` → `{text, level}`), `POST /finish` (`{slug, durationSeconds, escaped, items:[{puzzleId, submission, attempts, revealed}], doors:[{roomId, code}]}` → `{score, baseScore, maxScore, timeBonus, solvedPuzzles, roomsOpened, escaped, stars, highscore, newHighscore, plays}`).
+**API (`/api/codeescape`):** `GET /scenarios`, `GET /session/{slug}`, `POST /check` (`{puzzleId, reveal, submission:{answer}}` → `{correct, fragment, successText}`), `POST /door` (`{roomId, code}` → `{open, successText}`), `POST /hint` (`{puzzleId, level}` → `{text, level}`), `POST /finish` (`{slug, durationSeconds, escaped, items:[{puzzleId, submission, attempts, revealed}], doors:[{roomId, code}]}` → `{score, baseScore, maxScore, timeBonus, solvedPuzzles, roomsOpened, escaped, stars, highscore, newHighscore, plays}`).
 
 **Frontend:** `templates/escape-room.html`, `static/js/escaperoom.js` (IIFE-State-Machine `LOBBY → INTRO → ROOM(i) → PUZZLE_MODAL → DOOR_TRY → TRANSITION → … → RESULT`), `static/css/escaperoom.css` mit Präfix `esc-`. **Die `choice`/`order`/`match`-Renderer aus `devlabgame.js` (Vertrag `{render, collect, lock, mark}`) portieren**, nur ein `code`-Renderer (Terminal-Artefakt + Textfeld) kommt neu dazu. Layout: HUD oben (Raumtitel, Raum-Punkte ● ● ○, Timer-Chip), Mitte Rätselkarten, unten Fragment-Chips + Keypad-Button. Nur Theme-Tokens, Erfolg blau ✓, Fehler rot ✗.
 
@@ -128,7 +244,12 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 
 ---
 
-### Spiel 2: Bug Hunter (Key: `bug-hunter`, Migration V10)
+### Spiel 2: BugHunter (Key: `bughunter`, Migration V12) ✅ umgesetzt und ausgebaut
+
+> ✅ **Stand 2026-07-13:** Das serverautoritative Spiel, Seeder, Admin-CRUD und Dashboard-Route
+> sind umgesetzt. Der Katalog umfasst jetzt **12 Fallakten**, nach Junior/Senior/Principal
+> gruppiert. Die Akten liegen im Aktenschrank; nach einer perfekten Lösung erscheint ein
+> „GELÖST“-Stempel. Ein Reset startet eine inhaltlich passende Fallvariante.
 
 **Konzept:** Der Spieler ist Debugging-Detektiv und arbeitet **Fallakten** ab. Ein Fall („Hunt") ist ein Mini-Projekt aus 2–4 Dateien, das sich falsch verhält; Beweismittel sind simulierte Konsolen-Ausgabe / Stacktrace / Ticket-Text. Pro Bug eine Drei-Phasen-Schleife: **ORTEN** (fehlerhafte Zeile im Tab-Code-Viewer anklicken) → **KLASSIFIZIEREN** (Syntax / Logik / Laufzeit / Sicherheit) → **FIXEN** (korrigierte Zeile aus 4 Kandidaten wählen). Saubere Bugs bauen eine **Combo-Serie** auf. Stufen: Junior / Senior / Principal.
 
@@ -138,10 +259,10 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 - Phasengewichte pro Bug: Orten 40 %, Klassifizieren 20 %, Fixen 40 %. Phasen-Award = `gewicht × punkte × versuchsfaktor` (1.0/0.6/0.3, aufgedeckt 0).
 - Sterne aus `baseScore/maxScore` (Genauigkeitsmaß, ohne Combo).
 - **Combo:** Ein Bug ist _sauber_, wenn alle 3 Phasen im 1. Versuch ohne Aufdecken gelingen. Serienposition n bringt `(min(n,4) − 1) × 10 % × punkte` Bonus (2. saubere in Folge +10 %, … 4.+ +30 %); Bonus wird **nach** der Sternberechnung addiert. Kein Timer – Bug Hunter belohnt Präzision, Zeitdruck gehört dem Escape Room.
-- Basispunkte pro Bug nach Stufe: Junior 100, Senior 150, Principal 200. `recordScore(user, "bug-hunter", huntSlug, baseScore + comboBonus, gelösteBugs, sekunden)`.
+- Basispunkte pro Bug nach Stufe: Junior 100, Senior 150, Principal 200. `recordScore(user, "bughunter", huntSlug, baseScore + comboBonus, gelösteBugs, sekunden)`.
 
-**Datenmodell (`V10__bug_hunter.sql`):**
+**Datenmodell (`V12__bughunter.sql`):**
-- `bughunter_hunts` (id, slug UNIQUE, title, code_language, difficulty DEFAULT 'junior', description, briefing VARCHAR(2000), console_output VARCHAR(4000), sort_order, active)
+- `bughunter_hunts` (id, slug UNIQUE, title, code_language, difficulty DEFAULT 'junior', exam_scope, description, briefing VARCHAR(2000), console_output VARCHAR(4000), sort_order, active)
 - `bughunter_files` (id, hunt_id FK CASCADE, filename, content VARCHAR(8000), sort_order) – eigene Tabelle, damit der Code-Viewer-Inhalt von allen Bugs geteilt wird und im Admin als Textarea editierbar ist
 - `bughunter_bugs` (id, hunt_id FK CASCADE, points DEFAULT 100, sort_order, payload VARCHAR(8000)) – Payload: `{"file","line","category","evidence","fixOptions":[4],"fixIndex","explanation"}`
 - Indizes auf beide FKs.
@@ -151,19 +272,26 @@ Jedes neue Spiel folgt exakt dem Muster der vorhandenen Spiele (bester Bauplan:
 - `checkPhase(bugId, phase, reveal, submission)`: `locate` vergleicht file+line, liefert bei Erfolg/Aufdecken `location` zurück; `classify` vergleicht die Kategorie und liefert bei Auflösung erst die **gemischten `fixOptions`** (Phasen-Gate: der Fix-Text würde sonst die Position verraten); `fix` prüft die Wahl (Logik = Dev Labs `checkChoice`) und liefert `fixedLine` + `explanation` fürs Debriefing.
 - `finish(...)`: prüft alle Phasen aus den Roh-Antworten neu, Gewichte + Versuchsfaktoren, Streak/Combo, Sterne, `recordScore`.
 
-**API (`/api/bug-hunter`):** `GET /hunts`, `GET /session/{slug}`, `POST /check` (`{bugId, phase, reveal, submission}`), `POST /finish` (`{slug, durationSeconds, items:[{bugId, locate:{file,line,attempts,revealed}, classify:{category,…}, fix:{choice,…}}]}` → `{score, baseScore, maxScore, comboBonus, maxCombo, bugsSolved, totalBugs, stars, highscore, newHighscore, plays}`).
+**API (`/api/bughunter`):** `GET /hunts`, `GET /session/{slug}`, `POST /check` (`{bugId, phase, reveal, submission}`), `POST /finish` (`{slug, durationSeconds, items:[{bugId, locate:{file,line,attempts,revealed}, classify:{category,…}, fix:{choice,…}}]}` → `{score, baseScore, maxScore, comboBonus, maxCombo, bugsSolved, totalBugs, stars, highscore, newHighscore, plays}`).
 
-**Frontend:** `templates/bug-hunter.html`, `static/js/bughunter.js` (State-Machine `LOBBY → BRIEFING → HUNT {pro Bug: LOCATE → CLASSIFY → FIX → DEBRIEF} → RESULT`), `static/css/bughunter.css` Präfix `bh-`. Layout: **links 60 %** Datei-Tabs + Monospace-Code-Viewer mit Zeilennummern-Gutter (Zeilenklick nur in LOCATE aktiv); **rechts 40 %** Beweis-Karte (Terminal-Style `consoleOutput`, Briefing, Bug-Hinweis), Aktions-Panel (wechselt pro Phase; Kategorie-/Fix-Buttons nutzen das `choice`-Renderer-Muster aus `devlabgame.js`), Combo-Chip + Fortschritt („Bug 2/3"). Debriefing tauscht die Bug-Zeile sichtbar gegen `fixedLine` (blaues Diff-Highlight).
+**Frontend:** `templates/bughunter.html`, `static/js/bughunter.js` (State-Machine `LOBBY → BRIEFING → HUNT {pro Bug: LOCATE → CLASSIFY → FIX → DEBRIEF} → RESULT`), `static/css/bughunter.css` Präfix `bh-`. Layout: **links 60 %** Datei-Tabs + Monospace-Code-Viewer mit Zeilennummern-Gutter (Zeilenklick nur in LOCATE aktiv); **rechts 40 %** Beweis-Karte (Terminal-Style `consoleOutput`, Briefing, Bug-Hinweis), Aktions-Panel (wechselt pro Phase; Kategorie-/Fix-Buttons nutzen das `choice`-Renderer-Muster aus `devlabgame.js`), Combo-Chip + Fortschritt („Bug 2/3"). Debriefing tauscht die Bug-Zeile sichtbar gegen `fixedLine` (blaues Diff-Highlight).
 
-**Content & Seeder:** `BugHunterSeeder` liest `resources/bughunter/content.json`; der komplette Bug-Knoten wird wie bei `DevLabSeeder` per `toString()` zum Payload. Startumfang: **6 Fälle** – 3 Junior (1 Datei, 1–2 Bugs: Off-by-one, `=` vs. `==`, fehlendes `break`), 2 Senior (2 Dateien: NPE via Stacktrace, SQL-Injection, Integer-Division), 1 Principal (3 Dateien, Symptom in Datei A, Ursache in Datei B) ≈ 13–15 Bugs. Drei Beispiel-Fälle sind im Design voll ausgearbeitet („Fall #1: Die falsche Rechnung" – Off-by-one in Java; „Fall #2: Das offene Login" – SQL-Injection in PHP; „Fall #3: Der Absturz um Mitternacht" – NPE mit Stacktrace-Lesen), inkl. Code, Fix-Optionen und Erklärungen.
+**Content & Seeder:** `BugHunterSeeder` liest `resources/bughunter/content.json`; der komplette Bug-Knoten wird wie bei `DevLabSeeder` per `toString()` zum Payload. Der Katalog enthält **12 Fälle** in den Stufen Junior, Senior und Principal mit mehreren Dateien und mehreren Bugs pro Akte. Neue Seed-Akten werden idempotent auch in eine bereits bestehende Datenbank nachgeladen.
 
-**Admin:** `AdminBugHunterController` (`/admin/bug-hunter`), 2 Templates (Fall-Liste + Fall-Detail mit Datei-Textareas und Bug-Payload-JSON). Service validiert beim Speichern, dass `file` im Fall existiert und `line` im Zeilenbereich liegt.
+**Admin:** `AdminBugHunterController` (`/admin/bughunter`), 2 Templates (Fall-Liste + Fall-Detail mit Datei-Textareas und Bug-Payload-JSON). Service validiert beim Speichern, dass `file` im Fall existiert und `line` im Zeilenbereich liegt.
 
 **Aufwand:** MVP ≈ 4,5 PT. Ausbau 1 (+1 PT): Freitext-Fix statt Optionen (`anyEquals` mit Whitespace-Normalisierung wie Dev-Lab-`cloze`), „Sauber gelöst"-Badge. Ausbau 2 (+1 PT): „Blitzjagd"-Tagesmodus (3 zufällige Junior-Bugs, 90-s-Soft-Timer).
 
 ---
 
-### Spiel 3: Service Clash (Key: `service-clash`, Migration V11)
+### Spiel 3: ServiceClash (Key: `serviceclash`, Migration V15) ✅ umgesetzt
+
+> ✅ **Stand 2026-07-13:** V15-Datenmodell, Entities, Repository, Seeder, API und ein
+> serverautoritatives Drei-Schritte-Scoring sind umgesetzt. Das Spiel enthält drei
+> Schichten mit je acht Tickets (24 insgesamt), eine einsteigerfreundliche Briefing-Ansicht,
+> Queue-/Wellen-Leitstand, Debriefs, Score-/Highscore-Speicherung und die Achievements
+> „Leitstand-Einsatz“ sowie „Incident Commander“. Die technische Echtzeit-SLA-Simulation,
+> zufällige Seed-Pläne und Admin-CRUD bleiben bewusste Ausbauschritte.
 
 **Konzept: „Deine Schicht am Service Desk."** Der Spieler ist Junior-Admin im First-Level-Support. Tickets treffen auf einer Zeitleiste ein; jedes muss **eingeordnet** (Incident vs. Service Request), **priorisiert** (Hoch/Mittel/Niedrig anhand von Impact-×-Dringlichkeit-Hinweisen im Tickettext) und **gelöst** werden (richtige Erstmaßnahme aus 3–4 Optionen) – bevor sein SLA-Timer abläuft. Unbehandelte Tickets beschädigen die „Systemgesundheit"; bei 0 endet die Schicht vorzeitig.
 
@@ -188,28 +316,52 @@ maxScore     = Σ B + 200 ;  Sterne nach Plattform-Konvention
 - Jeder Klick geht an `POST /check` (sofortiges ✓/✗-Feedback; Lösungen verlassen den Server nie).
 - `POST /finish` sendet `{slug, seed, decisions[], durationSeconds}`; der Server **regeneriert die Schicht aus dem Seed und re-simuliert das Entscheidungslog** (Plausibilitätschecks: Zeitstempel ≥ Spawn-Offset, ≤ Schichtdauer, monoton pro Ticket) und berechnet Gesundheit, SLA-Faktoren und Score neu. Härtungs-Ausbau: HMAC-signierter Seed.
 
-**Datenmodell (`V11__service_clash.sql`):**
+**Datenmodell (`V15__serviceclash.sql`, umgesetzt):**
-- `service_clash_shifts` (id, slug UNIQUE, title, description, difficulty INT, wave_count INT DEFAULT 3, wave_seconds INT DEFAULT 60, spawn_count INT DEFAULT 12, settings VARCHAR(4000) /* JSON: SLA-Defaults, Health-Regeln, Prio-Stufe an/aus */, sort_order, active)
+- `service_clash_shifts` (id, slug UNIQUE, title, description, difficulty, exam_scope,
-- `service_clash_tickets` (id, shift_id FK CASCADE, wave INT, base_points INT DEFAULT 100, sort_order, payload VARCHAR(8000)) + FK-Index
+  sort_order, active)
-- Ticket-Payload: `{title, requester, text, kind (normal|phishing), options[], correctIndex✂, category✂, priority✂, slaSeconds, explanation✂, successText}` (✂ = wird von `sanitize()` entfernt).
+- `service_clash_tickets` (id, shift_id FK CASCADE, title, wave, points, sort_order,
+  payload VARCHAR(8000)) + FK-Index
+- Ticket-Payload enthält Antragsteller, Sachverhalt, Optionen und die ausschließlich
+  serverseitig ausgewerteten Felder `category`, `priority`, `solution`, `explanation`.
 
-**Backend:** Entities `ServiceClashShift`/`ServiceClashTicket`, Standard-Repos (`findAllByShiftIdOrderByWaveAscSortOrderAscIdAsc`, `countByShiftId`). `ServiceClashService`: `buildCatalog()`, `buildSession(slug)` (Seed + `generatePlan()`), `check(templateId, step, value, reveal)` mit `step ∈ classify|priority|solve` (Vergleich immer über Options-**Text**, nie Indizes – immun gegen Mischungs-Versatz), `finish(...)` (Plan aus Seed regenerieren, Log re-simulieren, `recordScore(user, "service-clash", slug, score, gelöste, sekunden)`), Admin-Methoden nach Dev-Lab-Vorbild.
+**Backend (umgesetzt):** Entities `ServiceClashShift`/`ServiceClashTicket` und
+`ServiceClashShiftRepository`; `ServiceClashService` baut den Katalog und eine lösungsfreie
+Session, prüft `classify|priority|solve` ausschließlich gegen den serverseitig gehaltenen
+Payload und berechnet beim Abschluss Score, Sterne und Highscore mit
+`recordScore(user, "serviceclash", slug, score, gelöste, sekunden)`.
 
-**API (`/api/service-clash`):** `GET /catalog`, `GET /session/{slug}` (liefert `seed`, Wellen-Konfiguration, Ticket-Instanzen `{instanceId, templateId, wave, spawnAtMs, …}`), `POST /check`, `POST /finish` → `{score, maxScore, stars, resolved, total, slaBreaches, health, highscore, newHighscore, plays, tickets[Debrief-Aufschlüsselung]}`.
+**API (`/api/serviceclash`, umgesetzt):** `GET /catalog`, `GET /session/{slug}` (lösungsfreie
+Ticket-Instanzen mit Welle und Auswahlmöglichkeiten), `POST /check` sowie `POST /finish` →
+`{score, maxScore, stars, resolved, total, health, highscore, newHighscore, plays}`.
 
-**Frontend:** `templates/service-clash.html`, `static/js/serviceclash.js` (State-Machine `SHIFT_SELECT → BRIEFING → RUNNING ⇄ WAVE_BREAK → DEBRIEF`; **ein** `setInterval(250 ms)`-Tick: fällige Tickets spawnen, SLA-Ringe aktualisieren), `static/css/service-clash.css` Präfix `sc-`. Layout: Topbar (Schicht-Uhr, Wellen-Pips, Gesundheits-Meter, „Gelöst 4/8"), links die Ticket-Queue (Karten mit SLA-Ring, pulsierender roter Rand bei Überfälligkeit), Mitte das aktive Ticket mit 3-Stufen-Flow, unten ein Event-Log („14:02 Ticket ‚ERP down' eingegangen"). SLA-Ringe: `var(--accent)`, unter 25 % `var(--danger)`.
+**Frontend (umgesetzt):** `templates/serviceclash.html`, `static/js/serviceclash.js` und
+`static/css/serviceclash.css` (Präfix `sc-`). Die Zustände Katalog → Briefing → Leitstand →
+Debrief zeigen links Queue und Wellenfortschritt, in der Mitte den dreistufigen Ticket-Flow
+und am Ende eine klare Score-Auswertung. Eine Echtzeit-SLA-Uhr ist als späterer Ausbau notiert.
 
-**Schwierigkeitskurve:** Schicht 1 „Erster Arbeitstag" (8 Tickets, großzügige SLAs, Prio-Stufe deaktiviert), Schicht 2 „Normalbetrieb" (12 Tickets, Prio aktiv, erster Phishing-Köder), Schicht 3 „Patch Day Chaos" (16 Tickets, knappe SLAs, Major Incident mit Folgetickets in Welle 3). **Replay-Wert:** Ticket-Pool größer als `spawnCount` → jede Runde ein anderer Mix (Seed).
+**Schwierigkeitskurve (umgesetzt):** „Frühschicht: Stabiler Start“ vermittelt Routinefälle,
+„Tagesschicht: Prioritäten unter Druck“ ergänzt Phishing und Monitoring, „Bereitschaft:
+Kritische Lage“ behandelt Ransomware, Changes, Backups, Zertifikate und DNS. Jede Schicht
+enthält acht Tickets in drei Wellen; ein Reset startet die Wertung neu.
 
-**Content & Seeder:** `ServiceClashSeeder` liest `resources/service-clash/content.json`. Startumfang: **3 Schichten × 18–20 Ticket-Vorlagen ≈ 55 Tickets.** Vier Beispiel-Tickets sind voll ausgearbeitet (Drucker-Queue/Incident-mittel, Azubi-Onboarding/Service-Request-niedrig, ERP-Totalausfall/Major-Incident-hoch mit Sofort-Eskalation, Phishing-Mail mit verdächtiger Absenderdomain).
+**Content & Seeder (umgesetzt):** `ServiceClashSeeder` versorgt beim ersten Start drei
+Schichten mit jeweils acht kuratierten Tickets (**24 insgesamt**). Enthalten sind u. a.
+Drucker-Queue, Azubi-Onboarding, ERP-Totalausfall, Phishing, Change-Management,
+Backup-/Zertifikats- und DNS-Störungen.
 
-**Admin:** `AdminServiceClashController` (`/admin/service-clash`), Schicht-Liste + Detailseite (Schicht-Formular inkl. Settings-JSON, Ticket-Tabelle, Payload-JSON-Textarea mit Schema-Hinweis; Speichern validiert `correctIndex` gegen `options`).
+**Admin:** Die Admin-Pflege bleibt ein Ausbau; der produktive Startkatalog wird aktuell über
+den idempotenten Seeder versorgt.
 
 **Aufwand:** MVP ≈ 7,5 PT (Service inkl. Seed-Plan + Re-Simulation 2 · Frontend 3 · Content 1 · Admin 1 · Rest 0,5+0,5). Ausbau (+3 PT): Major-Incident-Folgeketten, Combo-Serien, HMAC-Seed, Endlosmodus „Überstunden".
 
 ---
 
-### Spiel 4: Netzwerker – Das Router-Rätselspiel (Key: `netzwerker`, Migration V12)
+### Spiel 4: NetWorker (Key: `networker`, Migration V14) ✅ umgesetzt
+
+> ✅ **Stand 2026-07-13:** V14-Datenmodell, Entities, Repositories, Seeder, API,
+> serverautoritativer `NetSimulator`, Ergebnis-/Score-Integration und 15 Aufgaben in drei Welten
+> sind umgesetzt. Das UI nutzt eine SVG-Topologie mit blauem Blaupausenraster. Erweiterungen wie
+> VLAN, DHCP, Sandbox und visueller Editor bleiben bewusst als Ausbau markiert.
 
 **Konzept:** Netzwerk-Puzzle in der Tradition von Schaltkreis-Spielen. Jedes Level zeigt eine **SVG-Topologie** (PCs, Switch, Router, Server, Cloud). Geräte haben fehlende oder kaputte Konfiguration (IP, Maske, Gateway, Kabel, statische Routen). Ziel: alle **Ping-Ziele** erfüllen („PC1 muss SRV1 erreichen", später auch negativ: „Gast-PC darf den Server NICHT erreichen"). „Pings testen" ruft einen **serverseitigen Netzwerk-Simulator**, der jeden Ping Hop-für-Hop auflöst und Pass/Fail plus didaktische Diagnose liefert („Das Paket verlässt PC1 nicht: Laut Maske liegt das Ziel im eigenen Netz – stimmt die Maske?").
 
@@ -217,28 +369,28 @@ maxScore     = Σ B + 200 ;  Sterne nach Plattform-Konvention
 
 **Spielablauf:** Session = eine **Welt** aus 4–6 Leveln in Folge (Dev-Lab-Session-Form). Fünf Level-Typen bei einheitlichem Datenmodell: `assign` (leere IP/Maske/Gateway-Felder ausfüllen), `cable` (fehlende Verbindungen ziehen), `fix` (1–3 eingebaute Fehler finden: falsche Maske, Gateway außerhalb des Subnetzes, doppelte IP, Host auf Netzadresse), `route` (statische Routen-Zeilen: Zielnetz-CIDR + Next Hop), `vlan` (Ausbau, mit Negativ-Zielen).
 
-**Versuche & Punkte:** Jeder „Pings testen"-Klick mit mindestens einem roten Ziel verbraucht einen Versuch (1.0/0.6/0.3, `MAX_ATTEMPTS=3`, danach „Lösung anzeigen" = 0 Punkte). **Bewertet wird ausschließlich per Simulation, nie per Exact-Match** – viele Konfigurationen sind gültig (jede freie Host-IP funktioniert); die Musterlösung dient nur dem Aufdecken. Levelpunkte 100–200; Sterne am Weltende nach Konvention; `/finish` re-simuliert die final eingereichten Konfigurationen serverseitig. `recordScore(user, "netzwerker", weltSlug, score, gelöste, sekunden)`.
+**Versuche & Punkte:** Jeder „Pings testen"-Klick mit mindestens einem roten Ziel verbraucht einen Versuch (1.0/0.6/0.3, `MAX_ATTEMPTS=3`, danach „Lösung anzeigen" = 0 Punkte). **Bewertet wird ausschließlich per Simulation, nie per Exact-Match** – viele Konfigurationen sind gültig (jede freie Host-IP funktioniert); die Musterlösung dient nur dem Aufdecken. Levelpunkte 100–200; Sterne am Weltende nach Konvention; `/finish` re-simuliert die final eingereichten Konfigurationen serverseitig. `recordScore(user, "networker", weltSlug, score, gelöste, sekunden)`.
 
-**Datenmodell (`V12__netzwerker.sql`):**
+**Datenmodell (`V14__networker.sql`):**
-- `netzwerker_worlds` (id, slug UNIQUE, title, description, difficulty INT, sort_order, active)
+- `network_worlds` (id, slug UNIQUE, title, description, difficulty INT, sort_order, active)
-- `netzwerker_levels` (id, world_id FK CASCADE, title, level_type VARCHAR(30) /* assign|cable|fix|route|vlan */, points INT DEFAULT 100, sort_order, payload VARCHAR(8000) /* JSON-Topologie inkl. Musterlösung */) + FK-Index
+- `network_levels` (id, world_id FK CASCADE, title, level_type VARCHAR(30) /* assign|cable|fix|route|vlan */, points INT DEFAULT 100, sort_order, payload VARCHAR(8000) /* JSON-Topologie inkl. Musterlösung */) + FK-Index
 
 **Der Simulator – `service/NetSimulator.java` (Herzstück, pures Java ohne Spring, voll unit-testbar):**
 - Records: `Net(nodes, links, routes, vlans)`, `NodeCfg`, `IfaceCfg(ipLong, prefix, gatewayLong)`, `Route(destNet, prefix, nextHop)`.
 - `ping(net, from, to)`: (1) Validierung: unparsebare IP/Maske, Host-Teil 0/alles-1 → `network_address`/`broadcast_address`, doppelte IP im L2-Segment → `duplicate_ip`. (2) Gleiches Subnetz aus Quellsicht (`(ip & maske) == (ziel & maske)`) → L2-BFS über Links durch Switches (nie durch Router; VLAN-gefiltert). (3) Anderes Subnetz → Gateway nötig: gesetzt? im Quell-Subnetz? L2-erreichbar? Dann leitet der Router weiter: Ziel in direkt verbundenem Subnetz → zustellen; sonst statische Routen (Longest-Prefix-Match) → Next Hop → Rekursion mit TTL 8 (`routing_loop`-Schutz). Kein Treffer → `no_route`.
 - Fehlergründe werden im Service auf didaktische deutsche Meldungen gemappt.
 
-**`NetzwerkerService`:** `buildCatalog()`, `buildSession(slug)` (Level per `sanitizeLevel()`: Werte editierbarer Felder, zu ziehende Links, Routen-Lösungszeilen und `solution`-Block entfernt; gesperrte Werte, Positionen, Ziele, Hints gehen mit), `check(levelId, reveal, config)` (`mergeSubmission()` legt eingereichte Werte **nur über editierbare Felder** – Manipulation gesperrter Felder wird ignoriert; alle Ziele durch `NetSimulator.ping`; Antwort mit Trace/Diagnose pro Ziel), `finish(...)`, Admin-CRUD **plus Qualitäts-Gate beim Speichern: die hinterlegte Musterlösung wird durch den Simulator geschickt – Speichern wird abgelehnt, wenn sie nicht alle Ziele erfüllt.**
+**`NetworkerService`:** `buildCatalog()`, `buildSession(slug)` (Level per `sanitizeLevel()`: Werte editierbarer Felder, zu ziehende Links, Routen-Lösungszeilen und `solution`-Block entfernt; gesperrte Werte, Positionen, Ziele, Hints gehen mit), `check(levelId, reveal, config)` (`mergeSubmission()` legt eingereichte Werte **nur über editierbare Felder** – Manipulation gesperrter Felder wird ignoriert; alle Ziele durch `NetSimulator.ping`; Antwort mit Trace/Diagnose pro Ziel), `finish(...)`.
 
-**API (`/api/netzwerker`):** `GET /catalog`, `GET /session/{slug}`, `POST /check` (`{levelId, reveal, config:{ifaces[], links[], routes[], vlans[]}}` → `{allPassed, validation[], goals:[{id, passed, trace[] | failAt, reason, message}]}`; Masken-Eingabe akzeptiert `24`, `/24` oder `255.255.255.0` – Server normalisiert), `POST /finish` → Dev-Lab-Result-Form.
+**API (`/api/networker`):** `GET /catalog`, `GET /session/{slug}`, `POST /check` (`{levelId, reveal, config:{ifaces[], links[], routes[], vlans[]}}` → `{allPassed, validation[], goals:[{id, passed, trace[] | failAt, reason, message}]}`; Masken-Eingabe akzeptiert `24`, `/24` oder `255.255.255.0` – Server normalisiert), `POST /finish` → Dev-Lab-Result-Form.
 
-**Frontend:** `templates/netzwerker.html`, `static/js/netzwerker.js` (State-Machine `WORLD_SELECT → LEVEL_INTRO → EDITING ⇄ CHECKING → LEVEL_DONE → SUMMARY`), `static/css/netzwerker.css` Präfix `nw-`. **SVG-Ansatz:** ein `<svg viewBox="0 0 1000 620">`, Geräte-Glyphen als `<symbol>`-Defs im Strichstil der Dashboard-Icons, Positionen aus dem Payload; Links als `<path>`, Ports als Kreise an der Gerätekante. **Die Paket-Animation ist die Belohnung:** bei Erfolg wandert ein leuchtender Punkt entlang des tatsächlich vom Server gelieferten `trace`-Pfads (`requestAnimationFrame`); bei Fehlschlag stirbt er exakt am `failAt`-Hop mit rotem Burst. Kabelmodus: Port A klicken → Gummiband-Linie → Port B; gezogenes Kabel per Klick löschen. Layout: Canvas links/Mitte, rechts Ziel-Liste (mit Diagnosetexten unter roten Zielen) + Konfigurations-Panel des gewählten Geräts, Footer mit „Pings testen" / „Lösung anzeigen" / Hinweis-Toggle.
+**Frontend:** `templates/networker.html`, `static/js/networker.js` (State-Machine `WORLD_SELECT → LEVEL_INTRO → EDITING ⇄ CHECKING → LEVEL_DONE → SUMMARY`), `static/css/networker.css` Präfix `nw-`. **SVG-Ansatz:** ein `<svg viewBox="0 0 1000 620">`, Geräte-Glyphen als `<symbol>`-Defs im Strichstil der Dashboard-Icons, Positionen aus dem Payload; Links als `<path>`, Ports als Kreise an der Gerätekante. Die aktuelle Umsetzung zeigt die Topologie mit sichtbarem Raster, Ping-Prüfung und Diagnose-Panel; Paket-Animation, Kabelmodus und Hinweis-Toggle bleiben Ausbau. Layout: Canvas links/Mitte, rechts Ziel-Liste (mit Diagnosetexten unter roten Zielen) + Konfigurations-Panel des gewählten Geräts, Footer mit „Pings testen" / „Lösung anzeigen".
 
 **Schwierigkeitskurve (Welten):** 1. „Ein Netz für alle" (Same-Subnet-Basics), 2. „Über den Router" (Gateways, zwei Subnetze, erstes Negativ-Ziel), 3. „Routen & Fehlersuche" (zwei Router, statische Routen, Duplikat-IP-Jagd), 4. (Ausbau) „VLAN-Werkstatt".
 
-**Content & Seeder:** `NetzwerkerSeeder` liest `resources/netzwerker/content.json`. Startumfang: **3 Welten × 5 Level = 15 Level.** Drei Beispiel-Level voll ausgearbeitet: „Erste Verbindung" (assign: PC1 passend zu 192.168.10.20/24 konfigurieren), „Die falsche Maske" (fix: /25-vs-/24-Konflikt, .200 liegt außerhalb des ersten /25-Teilnetzes), „Tor zum Serverraum" (assign: IP+Maske+Gateway über Router zwischen 192.168.1.0/24 und 192.168.2.0/24).
+**Content & Seeder:** `NetworkerSeeder` liest `resources/networker/content.json`. Startumfang: **3 Welten × 5 Level = 15 Level.** Drei Beispiel-Level voll ausgearbeitet: „Erste Verbindung" (assign: PC1 passend zu 192.168.10.20/24 konfigurieren), „Die falsche Maske" (fix: /25-vs-/24-Konflikt, .200 liegt außerhalb des ersten /25-Teilnetzes), „Tor zum Serverraum" (assign: IP+Maske+Gateway über Router zwischen 192.168.1.0/24 und 192.168.2.0/24).
 
-**Admin:** `AdminNetzwerkerController` (`/admin/netzwerker`), Welt-Liste + Detailseite mit Level-Payload-JSON-Textarea (eingeklapptes Schema-Cheatsheet) und dem Musterlösungs-Validierungs-Gate.
+**Admin:** Admin-Pflege ist als Ausbau vorgesehen; der produktive Spielkatalog wird aktuell über den Seeder versorgt.
 
 **Aufwand:** MVP ≈ 9,5 PT (**NetSimulator + Unit-Tests zuerst: 2,5** · Migration/Entities/Service/API 1,5 · SVG-Frontend 3,5 · Content 1 · Admin 1). Ausbau (+4,5 PT): VLAN-Welt, DHCP-Modus, Sandbox, visueller Level-Editor.
 
@@ -246,11 +398,18 @@ maxScore     = Σ B + 200 ;  Sterne nach Plattform-Konvention
 
 ### Empfohlene Baureihenfolge & Gesamtaufwand
 
-0. **Vorarbeiten:** Namensschema umsetzen (Dashboard-Namen, Keys, `devlab` in `ProgressService` = W1) · K2 (Legacy-Endpunkt löschen) und W8 (N+1-Muster) beheben, damit die neuen Services das saubere Muster übernehmen · Spiel-Akzent-Tokens in `theme.css` anlegen. ≈ 1 PT — **✅ erledigt bis auf die Spiel-Akzent-Tokens.**
+0. **Vorarbeiten ✅:** Namensschema, Dashboard-Namen und Keys, `devlab` in `ProgressService`, K2,
-1. **CodeEscape (V9)** – validiert die Wiederverwendung der DevLab-Checker/-Renderer mit minimalem Risiko. ≈ 5,5 PT
+   W8, V11–V14-Migrationsreservierung, `exam_scope`-Konvention, S3-Sicherheitsvertrag und
-2. **BugHunter (V10)** – übernimmt Terminal-Styling und Choice-Renderer aus Schritt 1. ≈ 4,5 PT
+   Spiel-Akzent-Tokens in `theme.css` sind umgesetzt.
-3. **NetWorker (V12)** – **Simulator zuerst, testgetrieben** (pures Java, kein UI-Risiko), dann SVG-Frontend. ≈ 9,5 PT
+1. **FluxTimer ✅** – risikoarmer, rein lokaler Ausbau; validiert den globalen UI-Bootstrap und belegt die Glocke vor NeuralNet. ≈ 1,5–2 PT
-4. **ServiceClash (V11)** – komplexestes Frontend (Echtzeit-Tick); profitiert von allen Vorarbeiten. ≈ 7,5 PT
+2. **SystemEscape (V11) ✅** – serverautoritatives Spiel mit 3 Szenarien, 24 Räumen, 69 Rätseln
+   und vier zufälligen Räumen pro Run; Admin-CRUD, `exam_scope`, festgeschriebene Run-Auswahl,
+   dynamische Wertung und Anti-Cheat-Negativtests umgesetzt.
+3. **BugHunter (V12) ✅** – Fallakten, serverautoritatives Drei-Phasen-Debugging, Combo-Wertung, Admin-CRUD und zwölf Fälle mit Reset-Varianten umgesetzt.
+4. **NetWorker (V14) ✅** – testgetriebener Simulator, SVG-Frontend, drei Welten mit 15 Aufgaben, Score-/Achievement-Integration und Blaupausenraster umgesetzt.
+5. **ServiceClash (V15) ✅** – drei Schichten, 24 Tickets, serverautoritatives Triage-Scoring,
+   Score-/Achievement-Integration und cyanfarbener Leitstand sind umgesetzt. Echtzeit-SLA,
+   Seed-Mischung und Admin-Pflege bleiben als Ausbau markiert.
 
 **Gesamt-MVP aller vier Spiele: ≈ 28 Personentage.** Der Navigations-Umbau (Abschnitt 2.3) und die restlichen Teil-2-Punkte können parallel oder dazwischen erfolgen; empfohlen ist der Sidebar-/Tab-Umbau **vor** dem vierten Spiel, damit alle neuen Seiten die Fragmente nutzen.
 
@@ -258,7 +417,14 @@ maxScore     = Σ B + 200 ;  Sterne nach Plattform-Konvention
 
 ## Teil 2: Verbesserungen & Optimierungen am Bestand
 
-> ✅ **Umgesetzt am 2026-07-12** (K1–K3, W1–W8, N1–N6, S1–S8, S10 – Details im CHANGELOG). Offen bleiben: S9/i18n (bewusst zurückgestellt), S3 (Regel für die neuen Spiele) sowie die schrittweise Fragment-Migration der restlichen Spiel-/Admin-Templates. **K1 vollständig abgeschlossen:** Gitea-Secret angelegt, Produktionspasswort rotiert und Runner-Abgleich erfolgreich deployt (Workflow 43, Commit `4f5042d`). Das Verfahren und der manuelle Notfallweg stehen in [`pw_anleitung.md`](pw_anleitung.md).
+> ✅ **Umgesetzt am 2026-07-12/13** (K1–K3, W1–W8, N1–N6, S1–S8, S10 – Details im CHANGELOG). Offen bleiben nur S9/i18n (bewusst zurückgestellt) sowie die schrittweise Fragment-Migration der restlichen Spiel-/Admin-Templates. **S3 ist für SystemEscape, BugHunter, ServiceClash und NetWorker umgesetzt:** lösungsfreie Sessions, serverseitige Checks, Reveal-/Versuchsprotokollierung und serverseitige Abschlusswertung sind integriert. **K1 vollständig abgeschlossen:** Gitea-Secret angelegt, Produktionspasswort rotiert und Runner-Abgleich erfolgreich deployt (Workflow 43, Commit `4f5042d`). Das Verfahren und der manuelle Notfallweg stehen in [`pw_anleitung.md`](pw_anleitung.md).
+
+> ✅ **Ergänzung am 2026-07-13:** Dashboard-Wochenwerte, Verlauf und Top-Spiele sind aus
+> `game_scores` abgeleitet; die Statistik zeigt ausschließlich gemessene Spielzeit.
+> Spielbezogene Achievements für die vorhandenen Spiele sowie Spezialerfolge für SystemEscape,
+> BugHunter und NetWorker sind verdrahtet. Der Knowledge Core ist als datenbasierte Lernzentrale
+> mit AP1-, Netzwerk- und Debugging-/Security-Pfaden umgesetzt. Das Accessibility-Widget nutzt
+> in SystemEscape, BugHunter und NetWorker jeweils den passenden Spielakzent.
 
 ### 2.1 Kritisch (vor/mit dem nächsten Release beheben)
 
@@ -307,7 +473,7 @@ Der Verdacht „Profilbutton fehlt / Einstellungen nicht im Profil / irgendwas i
 |---|-------|----------|
 | S1 ✅ teilweise | **Template-Duplikation** – 33 Templates ohne ein einziges `th:fragment`; jede Seite dupliziert `<head>`, Sidebar, Footer | `templates/fragments/layout.html` mit `head`, `sidebar`, `footer`-Fragmenten einführen; schrittweise umstellen (zuerst bei den 4 neuen Spielen verwenden, dann Bestand migrieren). |
 | S2 ✅ | **4 parallele User-Anlage-Pfade** mit inkonsistenten Regeln (`RegisterController`, REST-`UserController`, `AdminUserController`, `UserViewController`) | Nach Löschung von K2: Restlogik in einen `UserService` konsolidieren (ein Ort für Encoding, Rollen, Uniqueness). |
-| S3 ☐ | **Score-Manipulation durch eigene Nutzer möglich** (Roh-Werte fälschbar, Reveal-vor-Finish) | Akzeptables Risiko (nur eigener Highscore), aber bei den neuen Spielen von Anfang an minimieren: Server generiert Runden-Daten mit IDs, `finish` validiert nur bekannte IDs, Zeit-Plausibilitätscheck (z. B. `durationSeconds ≥ 1`, Obergrenzen für `pairs`/`moves`). |
+| S3 ✅ | **Score-Manipulation durch eigene Nutzer möglich** (Roh-Werte fälschbar, Reveal-vor-Finish) | Der verbindliche Sicherheitsvertrag ist für SystemEscape, BugHunter, ServiceClash und NetWorker umgesetzt: lösungsfreie Sessions, serverseitige Checks sowie serverseitige Score-/Reveal-Auswertung. Weiterführende Negativtests werden bei künftigen Spieltypen ergänzt. |
 | S4 ✅ | **Infrastruktur**: kein Actuator/Healthcheck, Dockerfile läuft als root, kein Dependency-Layer-Caching, CI ohne Tests, Java-Versionskonflikt (pom: 17, Dockerfile: 21) | `spring-boot-starter-actuator` (+ `HEALTHCHECK` in compose), `USER`-Directive, Dockerfile zweistufig mit `dependency:go-offline`-Layer, Test-Stage in `.gitea/workflows/mindflux.yml`, Java-Version angleichen (empfohlen: beide auf 21). |
 | S5 ✅ | **Datenmodell**: `game_scores`/`achievements` referenzieren `username` ohne FK; `email` ohne UNIQUE | FK auf `users(username)` + `UNIQUE(email)` per Migration ergänzen (vorher Dubletten bereinigen). |
 | S6 ✅ | **Logout per GET** (`SecurityConfig.java:36`) – kleiner Logout-CSRF-Vektor | Auf POST-Logout mit CSRF-Token umstellen (kleines Formular im Sidebar-Footer). |
@@ -318,7 +484,18 @@ Der Verdacht „Profilbutton fehlt / Einstellungen nicht im Profil / irgendwas i
 
 ---
 
-## Teil 3: FluxNet – Community & Soziales
+## Teil 3: NeuralNet – private Lernverbindungen & Nachrichten ⏳ in Umsetzung
+
+> ✅ **MVP-Stand 2026-07-14:** Opt-in, Kontaktanfragen (annehmen, ablehnen,
+> zurückziehen) und private Nachrichten nach bestätigter Verbindung sind umgesetzt.
+> Leere Erfolgsantworten des API-Backends werden im Client robust verarbeitet.
+> Der Gesprächsbereich öffnet unmittelbar beim Auswählen einer bestätigten Verbindung.
+> Die dynamisch gerenderten Kontakt- und Chat-Aktionen werden direkt gebunden.
+> Der Chatbereich hält Kopf, Verlauf und Eingabe als zusammenhängende Spalte.
+> Die Dashboard-Sprechblase zeigt im 30-Sekunden-Takt echte ungelesene Nachrichten.
+> Die zuletzt geöffnete bestätigte Verbindung wird pro Konto lokal wiederhergestellt.
+> Der Plattform-Lightmode und der Hochkontrastmodus nutzen die Neural-Palette.
+> Blockieren, Melden/Moderation, Duelle und Lernlobby bleiben die nächsten Ausbauschritte.
 
 > Ersetzt den `/soziales`-Platzhalter („Straßen? Wo wir hingehen, brauchen wir keine Straßen!"). Ziel: User können sich befreunden, intern miteinander schreiben, gemeinsam lernen und Achievements vergleichen – **vollständig selbst gehostet, ohne einen einzigen externen Dienst**, und DSGVO-konform von Grund auf.
 
@@ -326,8 +503,8 @@ Der Verdacht „Profilbutton fehlt / Einstellungen nicht im Profil / irgendwas i
 
 | Funktion | Beschreibung |
 |----------|--------------|
-| **Freundschaften** | Anfrage per Username-Suche senden → Gegenseite bestätigt/lehnt ab. Nur bestätigte Freunde sehen einander im FluxNet. |
+| **Kontaktanfragen** | Anfrage per Username-Suche senden → Gegenseite nimmt ausdrücklich an oder lehnt ab. Nur bestätigte Verbindungen sehen einander im NeuralNet. Gesendete Anfragen lassen sich zurückziehen. |
-| **Interner Messenger** | 1:1-Direktnachrichten zwischen bestätigten Freunden. Ungelesen-Badge am Glocken-Icon der Topbar. Kein Gruppenchat in Phase 1. |
+| **Privatnachrichten** | 1:1-Direktnachrichten ausschließlich zwischen bestätigten Verbindungen. Ungelesen-Badge am Glocken-Icon der Topbar. Kein Gruppenchat in Phase 1. |
 | **Blockieren** | Blockiert = keine Anfragen, keine Nachrichten, keine Profileinsicht – in beide Richtungen serverseitig geprüft. Bestehende Freundschaft wird getrennt. Der Blockierte erhält **keine** Benachrichtigung (still). Entblocken jederzeit über die Einstellungen. |
 | **Achievements vergleichen** | Freundesprofil zeigt den Achievement-Katalog nebeneinander (meine/seine freigeschalteten) und die Spiel-Highscores im Vergleich – nur, was die Privacy-Einstellungen des anderen erlauben. |
 | **Gemeinsam lernen** | Phase 2: **Lern-Duell** – einen Freund zu Spiel + Deck herausfordern, beide spielen binnen Frist, der Server vergleicht die echten `game_scores`-Ergebnisse. Phase 3: gemeinsame Lernräume (identisches Board für beide über die Seed-Mechanik aus dem ServiceClash-Design). |
@@ -414,14 +591,14 @@ Eine Freundschaft zwischen A und B liegt genau einmal vor (Anfrage-Richtung = re
 | **Löschung (Art. 17)** | Konto-Löschung kaskadiert per FK automatisch über Freundschaften, Blocks, Nachrichten und Challenges – nichts bleibt zurück. Einzelne eigene Nachrichten kann der Nutzer selbst löschen. |
 | **Auskunft/Portabilität (Art. 15/20)** | Ausbau Phase 3: „Meine Daten exportieren"-Button (JSON-Dump der eigenen Profil-, Freundes-, Nachrichten- und Score-Daten). |
 | **Vertraulichkeit (Art. 32)** | Transport via TLS (nginx). Speicherung serverseitig im Klartext in der eigenen Postgres – bewusste, dokumentierte Entscheidung (Moderationsfähigkeit); keine Weitergabe an Dritte, kein externer Dienst, keine Analytik. |
-| **Transparenz (Art. 13)** | `datenschutz.html` um den Abschnitt FluxNet erweitern (Zwecke, Speicherdauer, Empfängerkreis „nur befreundete Nutzer", Moderationsregel); `nutzungsbedingungen.html` um Verhaltensregeln + Melde-/Sperrprozess. |
+| **Transparenz (Art. 13)** | `datenschutz.html` um den Abschnitt NeuralNet erweitern (Zwecke, Speicherdauer, Empfängerkreis „nur befreundete Nutzer", Moderationsregel); `nutzungsbedingungen.html` um Verhaltensregeln + Melde-/Sperrprozess. |
 | **Betroffenenschutz** | Blockieren ist still (kein „X hat dich blockiert"); Melden einer Nachricht legt nur DIESE Nachricht dem Admin vor. |
 
 ### 3.6 Frontend
 
-- `soziales.html` wird zum **FluxNet-Hub** (der Profil-Tab „Soziales" existiert schon): links Freundesliste (mit Online-Reihenfolge nach letzter Aktivität) + offene Anfragen + Username-Suche; rechts Chat-Panel des gewählten Freundes (Verlauf, Eingabefeld, „Nachricht melden/löschen" im Kontextmenü).
+- `soziales.html` wird zum **NeuralNet-Hub** (der Profil-Tab „Soziales" existiert schon): links Freundesliste (mit Online-Reihenfolge nach letzter Aktivität) + offene Anfragen + Username-Suche; rechts Chat-Panel des gewählten Freundes (Verlauf, Eingabefeld, „Nachricht melden/löschen" im Kontextmenü).
 - Freundesprofil: Avatar, Level, Streak, Achievement-Vergleich (zwei Spalten, gemeinsame freigeschaltete hervorgehoben), Highscore-Tabelle je Spiel, Buttons „Herausfordern" / „Blockieren".
-- Neue Dateien: `static/js/fluxnet.js` (IIFE, Polling-Logik, Render-Funktionen), `static/css/fluxnet.css` (Präfix `fn-`, nur Theme-Tokens, Erfolg blau ✓ / Fehler rot ✗). Ungelesen-Badge am Glocken-Icon der Dashboard-Topbar (zusammen mit dem FluxTimer-Popover aus Teil 4).
+- Neue Dateien: `static/js/neuralnet.js` (IIFE, Polling-Logik, Render-Funktionen), `static/css/neuralnet.css` (Präfix `fn-`, nur Theme-Tokens, Erfolg blau ✓ / Fehler rot ✗). Ungelesen-Badge am Glocken-Icon der Dashboard-Topbar (zusammen mit dem FluxTimer-Popover aus Teil 4).
 
 ### 3.7 Phasen & Aufwand
 
@@ -433,11 +610,17 @@ Eine Freundschaft zwischen A und B liegt genau einmal vor (Anfrage-Richtung = re
 
 ## Teil 4: FluxTimer – Der Pausen-Lerntimer
 
+> ✅ **MVP umgesetzt:** lokaler Zustand, globaler Countdown, Einstellungen, eigener Uhr-mit-Blitz-
+> Schnellzugriff in der Topbar, In-App-Overlay, Snooze, Probelauf sowie optionale Browser-
+> Benachrichtigung und Web-Audio-Signal. Die Glocke bleibt für NeuralNet-/Systembenachrichtigungen
+> reserviert. Eine serverseitige Synchronisation bleibt bewusst optional.
+
 > Opt-in-Erinnerungstimer im Look der Zeitschaltkreise des DeLorean: Nach frei wählbarer Zeit erinnert Mindflux ans Aufstehen, Trinken, Essen – oder was immer man einträgt. Standardmäßig **deaktiviert**, jederzeit abschaltbar, komplett frei einstellbar.
 
 ### 4.1 Funktionsumfang
 
-- **Aktivieren/Deaktivieren** per Toggle (Einstellungen + Schnellzugriff über das Glocken-Icon der Dashboard-Topbar).
+- **Aktivieren/Deaktivieren ✅** per Toggle in den Einstellungen und über das eigene
+  Uhr-mit-Blitz-Icon der Dashboard-Topbar.
 - **Intervall frei wählbar:** freie Minuteneingabe, sinnvolle Grenzen 5–240 Minuten (Default-Vorschlag 45).
 - **Erinnerungsarten wählbar** (Mehrfachauswahl, Rotation): Aufstehen 🧍 · Trinken 💧 · Essen 🍎 · Augenpause 👀 · **eigener Text** (Freitextfeld).
 - **Snooze** (+5 Minuten) und „Pause erledigt“ (startet das Intervall neu).
@@ -465,10 +648,10 @@ Eine Freundschaft zwischen A und B liegt genau einmal vor (Anfrage-Richtung = re
 
 | Ort | Änderung |
 |-----|----------|
-| `settings.html` | Neue Sektion „FluxTimer“: Toggle, Minuten-Eingabe, Erinnerungs-Checkboxen, Freitext, Benachrichtigung/Sound-Optionen, Probelauf-Button |
+| `settings.html` ✅ | Sektion „FluxTimer“: Toggle, Minuten-Eingabe, Erinnerungs-Checkboxen, Freitext, Benachrichtigung/Sound-Optionen, Probelauf-Button |
-| `dashboard.html` (Topbar) | Das bislang funktionslose Glocken-Icon öffnet ein FluxTimer-Popover: Status, Countdown, Schnell-Toggle, Link zu den Einstellungen |
+| `dashboard.html` (Topbar) ✅ | Eigenes Uhr-mit-Blitz-Icon öffnet das Popover mit Status, Countdown, Schnell-Toggle und Link zu den Einstellungen; Glocke bleibt frei |
-| `templates/fragments/layout.html` | Script-Einbindung, damit der Timer auf allen eingeloggten Seiten weiterläuft |
+| `theme.js` ✅ | Zentraler, idempotenter Asset-Bootstrap, damit der Timer über Seitennavigationen weiterläuft |
-| NEU `static/js/fluxtimer.js`, `static/css/fluxtimer.css` | Timer-Logik + Zeitschaltkreis-Optik |
+| `static/js/fluxtimer.js`, `static/css/fluxtimer.css` ✅ | Timer-Logik + Zeitschaltkreis-Optik |
 
 ### 4.5 Aufwand
 
@@ -484,7 +667,7 @@ Eine Freundschaft zwischen A und B liegt genau einmal vor (Anfrage-Richtung = re
 | `src/main/resources/static/js/devlabgame.js` | Renderer-Vertrag `{render, collect, lock, mark}`, Versuchsleiter-Frontend-Muster |
 | `src/main/resources/db/migration/V8__devlab.sql` | SQL-Stilvorlage für V9–V12 |
 | `src/main/java/com/example/mindflux/config/SecurityConfig.java` (Zeile 43) | CSRF-Ignore-Liste: `/api/codeescape/**`, `/api/bughunter/**`, `/api/serviceclash/**`, `/api/networker/**` ergänzen |
-| `src/main/resources/templates/dashboard.html` (Zeilen 186–196) | `GAMES`-Array: Namen aufs neue Schema umstellen (DevLab, SyntaxSaga, CodeEscape, ServiceClash, BugHunter, NetWorker) und die vier `'/comingsoon'`-Hrefs gegen echte Routen tauschen (Icons `lock`/`sword`/`bug`/`network` existieren bereits) |
+| `src/main/resources/templates/dashboard.html` (Zeilen 186–196) | `GAMES`-Array: Namen aufs neue Schema umstellen (DevLab, SyntaxSaga, SystemEscape, ServiceClash, BugHunter, NetWorker) und die verbliebenen `'/comingsoon'`-Hrefs gegen echte Routen tauschen (Icons `lock`/`sword`/`bug`/`network` existieren bereits) |
 | `GameScoreController.KNOWN_GAMES` + `ProgressService.GAMES` | Vier reservierte Keys aufs neue Schema umbenennen (`codeescape`, `serviceclash`, `bughunter`, `networker`), `devlab` in `ProgressService` ergänzen (W1) |
 | `src/main/java/com/example/mindflux/service/GameScoreService.java` | `recordScore(...)`-Anschlusspunkt aller Spiele |
 | `STYLEGUIDE.md`, `CHANGELOG.md` | Design-Regeln (blau ✓ / rot ✗, nie grün; Theme-Tokens; `?v=N`) und Pflege der Historie |

mindfluxrefine.md

@@ -0,0 +1,190 @@
+# Mindflux / SysnaptiK Neural — Gesamt-Audit & Umsetzungsplan
+
+## Kontext
+
+Vollständiges Audit der Plattform (Spring Boot 3.4.4, Java 21, Thymeleaf, PostgreSQL, Flyway) mit Fokus auf: Light Mode, Barrierefreiheits-Widget, Header-Icons, Spielanleitungen/Hints, AP2-Inhalte in FinalProtocol, Umlaute, DSGVO und Best Practices. Ziel: ein Light Mode, der wie ein „Geschwister" des Dark Mode wirkt (gleiche Farbidentität, aber für hell entworfen statt invertiert), konsistente UI, Hilfen in jedem Spiel, prüfungstauglicher AP2-Umfang für **beide** Fachrichtungen, saubere Umlaute, DSGVO-Konformität.
+
+**Entscheidungen:** ServiceClash/BugHunter/Networker bekommen **echte Light-Varianten** (nicht dauerhaft dunkel). AP2: **5 Themen je Fachrichtung** à 20 Fragen. Impressum bleibt **strukturierter Platzhalter** (Daten werden vor Launch geliefert).
+
+**Audit-Kurzantworten:**
+- **A11y-Widget:** Gut (9 Funktionen, ARIA, Escape, Fokus-Rückgabe), aber nicht perfekt: kein Focus-Trap, falsche `aria-pressed`-Semantik am 4-stufigen Font-Button, toter Legacy-CSS-Code, spielfremde Regeln in `accessibility-placement.css`.
+- **Spiele ohne Hilfe:** MindMatch + TechTacular haben **weder Anleitung noch Hints**. SyntaxSaga, DevLab, CodeEscape haben Hints, aber keine Anleitung. BugHunter nur Auflösen-Button. Networker ist Vorbild (Guide-Panel + Lexikon).
+- **AP2:** Nur je 1 Thema / 6 Fragen pro Richtung (vs. ~742 Fragen AP1/Wirtschaft). Der Ordner `systemintegration/` ist AP1-Stoff („Systeme & Netzwerke"), nicht AP2.
+- **Umlaute:** `static/finalflux/questions/usv.json` und `devlab/content.json` systematisch ohne Umlaute; Einzelfälle in `zahlensysteme.html:78`, `techtacular/content.json:4250`; Mojibake (`für`) in `style.css`-Kommentaren (Z. 19/29/220).
+- **DSGVO:** Chart.js von jsDelivr-CDN (`progress.html:9`) = einziges externes Asset, widerspricht eigener Datenschutzerklärung. Impressum = Platzhalter. NeuralNet-Messaging fehlt in der Datenschutzerklärung. Kein Datenexport (Art. 20). Footer mit Rechtslinks fehlt auf allen Spielseiten + Error/Auth-Seiten. Demo-User `NeuralTest` wird per Flyway (V17) in Prod eingespielt. Positiv: kein Tracking, keine Cookies außer Session, Secrets sauber, Löschkonzept (Art. 17) vorhanden.
+- **Best Practices:** `@Valid`/Bean-Validation nirgends genutzt (obwohl Starter + Handler verdrahtet), keine CSP/HSTS, Spring Boot 3.4.4 veraltet, Avatar-Logik im Controller statt Service, Footer 26× dupliziert statt Fragment, `DummyController`/`hello.txt`-Reste. Positiv: kein IDOR, saubere Schichten sonst, 51 Tests, Flyway, Brute-Force-Schutz.
+
+Basis-Pfad: `RES` = `src\main\resources`
+
+---
+
+## Umsetzungsstatus (Stand 2026-07-21, auf `main`)
+
+- ✅ **AP 0** Quick Wins — vollständig (inkl. V21-Reseed-Migration für Alt-DBs)
+- ✅ **AP 1** Light Mode — vollständig, alle Kontraste WCAG-AA rechnerisch geprüft. ⚠️ **Nachtrag (2026-07-21):** Glow-Effekte wirken im Light Mode störend → Alternative nötig, s. AP 1e.
+- ✅ **AP 2** Header-Icons — vollständig
+- ✅ **AP 3** Barrierefreiheits-Widget — vollständig
+- ✅ **AP 4** Spielanleitungen & Hints — vollständig (AP 4c TechTacular-Joker war bereits erledigt)
+- ✅ **AP 5** AP2-Ausbau — vollständig (10 Themen × 20 = 200 Fragen)
+- ✅ **AP 6** DSGVO — vollständig (Footer auf 35 Seiten, Datenschutz/Impressum, Export, V22)
+- 🟡 **AP 7** Best Practices — **teilweise**: Security-Header/CSP, AvatarService-Extraktion und Bean-Validation-Start erledigt. **Offen:** Validierung auf alle Request-DTOs + NeuralNet-`Map`→DTO, Spring-Boot-Patch-Bump, Cookie-basiertes CSRF, Web-Layer-Test für `/profile/export`.
+
+Automatisiert verifiziert: `mvn test` 54/54 grün, Build grün, Umlaut-QA sauber, alle 200 AP2-Fragen strukturell validiert. **Noch nicht durchgeführt (braucht laufende App + DB + Browser):** visuelle Light-Mode-Prüfung aller Spiele hell/dunkel, A11y-Widget-Handtest, Guide-Auto-Open, Export-Download- und DSGVO-Netzwerk-Check; die 8 Vollbild-Spielseiten haben nun ebenfalls einen Footer (ggf. schlanke CSS-Anpassung). Vor Launch offen: echte Impressumsdaten, Support-/Feedback-Zieladresse.
+
+---
+
+## AP 0 — Quick Wins (zuerst, alles klein)
+
+1. **Chart.js lokal vendoren**: nach `RES\static\js\vendor\chart.umd.min.js` laden, `RES\templates\progress.html:9` auf lokalen Pfad umstellen. Schließt das einzige DSGVO-Datenleck.
+2. **Scaffolding löschen**: `controller/DummyController.java`, `templates/dummy.html`, `RES\static\hello.txt`.
+3. **Umlaute fixen**:
+   - `RES\static\finalflux\questions\usv.json` — kompletter Durchgang (fuer→für, ueberbrueckt→überbrückt, heisst→heißt, …).
+   - `RES\devlab\content.json` — ~30 Stellen (hints/instructions/successText). **Achtung:** DevLab wird per `DevLabSeeder` in die DB geseedet (existenzgeprüft = idempotent) → prüfen, ob Fixes im JSON bestehende DB-Zeilen erreichen; falls nicht: Seeder auf Upsert umstellen **oder** Flyway-Migration `V21__fix_devlab_umlauts.sql`.
+   - `RES\static\finalflux\ap1\zahlensysteme.html:78` (`fuer`), `RES\techtacular\content.json:4250` (`zusaetzlich`, gleiche Seeder-Prüfung), `RES\static\css\style.css` Z. 19/29/220 (Mojibake-Kommentare).
+   - QA-Grep danach: `fuer|ueber|heisst|koennen|moechte|zurueck|loeschen|zusaetzlich` über resources → nur URLs/Slugs/IDs dürfen übrig bleiben.
+4. **FinalProtocol-Titel**: `RES\templates\finalflux.html:5` „FinalProtocol AP1" → „FinalProtocol", Hero (Z. 75–83) auf AP1 **und** AP2 umformulieren.
+
+---
+
+## AP 1 — Light Mode (Kern des Redesigns)
+
+Architektur bleibt: Tokens via `data-theme` auf `<html>`, zwei Ebenen (`theme.css` Amber-Palette, `platform-neural.css` Grün-Override für Plattform-Shell). Alle Werte unten sind arithmetisch auf WCAG AA geprüft (≥4,5:1 Text, ≥3:1 UI).
+
+### 1a. `RES\static\css\theme.css` — Light-Block (Z. 33–54) nachschärfen
+Kein Token-Split (`--accent-text`), stattdessen Light-Akzente abdunkeln, bis ein Token Text + Grafik + weiße Ink trägt:
+
+| Token | Alt | Neu | Kontrast |
+|---|---|---|---|
+| `--accent` | #d65116 | **#c2410c** | 5,18 (auch weiße Ink darauf: 5,18) |
+| `--accent-2` | #e4801d | **#b45309** | 5,02 (heilt `.login-box h2`) |
+| `--muted` | #8a7d6c | **#6b5f4c** | 6,24 / 5,79 auf #fbf6ec |
+| `--secondary` (+`--success`) | #1f86b8 | **#146b96** | 5,88 / 5,46 |
+| `--secondary-2` | #2d9cce | **#0f5a80** | passt |
+| NEU `--warn` | — | hell **#8a6a06** / dunkel **#edcb4c** | 5,07 |
+
+Spiel-Tokens im selben Block, nur die Durchfaller: `--esc-accent`→#a85408, `--sc-accent`→#0e7c86, `--dl-accent`→#9c4d0f, `--ss-secondary`→#8a5710, `--ff-accent`→#8c5e10. Zugehörige `*-glow`-rgba nachziehen.
+
+### 1b. `RES\static\css\platform-neural.css` — Light-Kartenakzente (der Hauptbug)
+Z. 41–49 leaken Neon-Akzente auf fast-weiße Karten. Neuer Block `html[data-theme="light"].sn-platform body .mf-card-<name>` mit farbton-treu abgedunkelten Akzenten (alle ≥4,65:1 auf Kartengrund):
+mindmatch **#a62c74**, techtacular **#67700a**, devlab **#167a52**, syntaxsaga **#6742d6**, codeescape **#8a6a06**, serviceclash **#0e7c86**, bughunter **#c22736**, networker **#1668a8**, finalprotocol **#b5490f** — je mit `--glow-s: rgba(<hex>,.22)` und hellerem `--accent-2` für Grafik-Deko. Dazu Light-Variante des finalflux-Shell-Overrides (Z. 57–60).
+
+### 1c. Hardcodes
+`RES\templates\dashboard.html:19–20`: `#edcb4c` → `var(--warn)` + `color-mix(in srgb, var(--warn) 48%, transparent)`.
+
+### 1d. Echte Light-Varianten für die 3 hardgecodeten Spiele
+Vorgehen je Spiel: alle Roh-Hexwerte in scoped Custom Properties überführen (`.sc-body{--sc-*}` usw. auf `<body>`-Klasse, damit A11y-Skin-Variablen sie sehen), Dark-Defaults = heutige Werte, Light-Block `[data-theme="light"] .xx-body{…}` mit handentworfener Palette gleicher Farbidentität:
+
+- **ServiceClash** (`serviceclash.css`, heute bg #071015 / accent #2bb6d7): Light = kühles NOC-Hell: bg **#eef6f8**, surface #ffffff, surface-2 #e2eff2, text **#10333b**, muted #52707a (4,6:1), accent **#0e7c86**, border #cfe3e8. Zusätzlich: `RES\templates\serviceclash.html` bekommt den fehlenden `.mf-theme`-Toggle in den Header (`.sc-nav`).
+- **Networker** (`networker.css`, dunkelblauer Gradient + fälschlich `var(--text)`): Light = helles Netz-Blau: bg **#eef4fb**, surface #ffffff, text **#16324a**, muted #54708c, accent **#1668a8**, border #d3e2f0. Alle `var(--text)`/`var(--muted)`-Nutzungen auf `--nw-text`/`--nw-muted` umstellen.
+- **BugHunter** (`bughunter.css`, Holz-Braun #231b18/#3a2d28): Light = Papier/Archiv-Look: bg **#f7f1e8**, surface #fffaf2, Schubladen helles Holz #e8d9c4/#d9c5a8, text **#33261d**, muted #6f5f4e, accent **#c22736**, border #e2d3bd. Die BugHunter/Networker-Regeln aus `accessibility-placement.css:21–23` in die jeweiligen Spiel-CSS verschieben (ohne `!important`).
+
+**Check:** jeder Spiel-Header, dessen Spiel jetzt theme-fähig ist, braucht den `.mf-theme`-Toggle (theme.js verdrahtet ihn automatisch); mindestens serviceclash.html fehlt er.
+
+### 1e. Nachtrag: Glow im Light Mode überarbeiten (offen, 2026-07-21)
+**Befund:** Die aus dem Dark-Mode-Neon-Look übernommenen Glow-Effekte wirken im Light Mode störend (auf fast-weißem Grund lesen sie sich als Schmutz-/Haze-Rand statt als Akzent). Betrifft die durchgereichten Glow-Tokens der Kartenakzente (`--glow-s: rgba(<hex>,.22)`, s. 1b), die spielspezifischen `*-glow`-rgba (s. 1a) und den Glow am `.mf-theme`-Toggle (s. AP 2, `theme.css:120–121`).
+**Wir brauchen eine Alternative** für den hellen Modus — noch zu entscheiden, z. B. Glow-Alpha im Light-Block deutlich reduzieren/auf 0 setzen, oder den Neon-Glow durch ein dezentes Mittel ersetzen (weicher Schatten / abgesetzter Border / leichter Farbverlauf), das die Erkennungsfunktion behält, ohne den hellen Grund zu trüben. Dark Mode bleibt unverändert.
+
+---
+
+## AP 2 — Header-Icons vereinheitlichen
+
+Eine Spezifikation für alle: **42×42 px, border-radius 10px, Glyphe 20×20, Outline-Stil** (Surface-Fill, 1px Border, Akzent nur über `color`/`border-color`):
+1. `theme.css:112` `.mf-iconbtn` → 42×42; `:114` svg → 20×20.
+2. `theme.css:120–121` `.mf-theme` → 42×42, radius 10px (Ellipse weg), svg 20×20; Akzentfarbe/Glow bleibt als Erkennungsmerkmal.
+3. `accessibility-placement.css:2–3` Trigger → 42×42, svg 20×20; Z. 16: gefüllten Gradient entfernen → `background:var(--surface); color:var(--mf-a11y-accent); border-color:color-mix(…)`.
+4. `accessibility.css:26` Legacy-56px-Kreis-Trigger löschen, saubere Basisregel im `.mf-iconbtn`-Look (Fokus-Outline behalten).
+5. `fluxtimer.css:3` `!important` entfernen; `.ft-trigger-icon` 20×20, `stroke-width:1.5`.
+6. Sichtprüfung: `.nn-unread`-Badge-Position bei 42px, `.mf-search`-Höhe angleichen. `STYLEGUIDE.md` aktualisieren.
+
+---
+
+## AP 3 — Barrierefreiheits-Widget perfektionieren
+
+In `RES\static\js\accessibility.js` / `accessibility.css`:
+1. **Focus-Trap** im Panel (Tab/Shift+Tab zyklisch über Close + 9 Options-Buttons), `aria-modal="true"`, Klick-außerhalb schließt. Escape + Fokus-Rückgabe existieren schon.
+2. **Font-Button**: boolean `aria-pressed` ersetzen durch dynamisches `aria-label` („Textgröße ändern – aktuell 115 %") + `.is-active`-Klasse ab >100 %; `aria-pressed` vom Reset-Button entfernen (Aktion, kein Toggle).
+3. **Toten Dock-CSS löschen** (`accessibility.css:25` body-padding-72px, `.mf-a11y-dock`, Fixed-Trigger) und die dadurch obsoleten Resets in `accessibility-placement.css` einkürzen.
+4. **Hochkontrast bleibt bewusst dunkel** auch im Light Mode (maximaler Kontrast, deterministisch) — im Button-Untertitel kenntlich machen („immer dunkel") + CSS-Kommentar.
+5. Cache-Buster bumpen (theme.js: accessibility.css v6, placement v10, accessibility.js v9, fluxtimer.css v5; theme.css v4 in allen Templates).
+
+---
+
+## AP 4 — Spielanleitungen & Hints
+
+### 4a. Gemeinsames Guide-Modul „So funktioniert's"
+Neu: `RES\static\js\game-guide.js` + `RES\static\css\game-guide.css`, nach Vorbild `networker-guide.js` (IIFE, deutsches Inline-Registry als Template-Literals, kein Fetch). Injektion über `theme.js` nur auf Game-Routen (Liste existiert dort in `isGameRoute`, Z. 15) — null Template-Edits, wie FluxTimer.
+- „?"-Button (`aria-label="Spielanleitung öffnen"`) in die jeweilige Header-Tools-Leiste; Erstbesuch öffnet Overlay automatisch (localStorage `mf-guide-seen:<slug>`), danach per „?" reopenbar; Escape/Backdrop schließt.
+- API `window.MindfluxGuide = {open, close, registerHintProvider({label, remaining, onHint})}` für einheitliche Tipp-Buttons.
+- Rollout: MindMatch, TechTacular, SyntaxSaga, DevLab-Game, CodeEscape, BugHunter, ServiceClash (kondensiert, Intro-Screen bleibt). **Networker bleibt unangetastet** (Inline-Guide ist stärker).
+
+### 4b. MindMatch-Hint „Paar-Blitz"
+Button „Tipp (3)" in `.mm-bar-group` (`mindmatch.html` ~Z. 35): deckt ein ungematchtes Paar ~1 s auf (wenn `firstCard` liegt: dessen Partner), kostet **+1 Zug** → Score/Sterne degradieren über die bestehende Formel, **null Backend-Änderungen** (Server rechnet aus `moves`). Hooks in `mindmatch.js`: State Z. 27–35, `newGame` Z. 241–265 (Reset auf 3), `finish`/`cancelGame` verstecken. CSS `.mm-card.hinted`-Glow.
+
+### 4c. TechTacular „50:50-Joker" ✅ umgesetzt (2026-07-19)
+`GET /api/techtacular/hint?questionId=` liefert ausschließlich bis zu zwei falsche Antwort-IDs; die korrekte ID verlässt den Service nie. Der Joker ist serverseitig pro Runde auf einen Einsatz begrenzt, markiert die konkrete Frage in der Session und wird beim Laden eines neuen Boards bzw. nach dem Abschluss zurückgesetzt. Im Antwort-Overlay werden die entfernten Optionen deaktiviert und durchgestrichen. `hintUsed` ist Teil der Answer-/Finish-DTOs; die Halbierung wird jedoch nur gewertet, wenn die Session den Joker-Einsatz für genau diese Frage bestätigt. Ein Endpoint-Test sichert JSON-Form und Weiterleitung ab.
+
+### 4d. Optional (Phase 2): BugHunter progressive Hinweise (2 Stufen vor „Auflösen", nach CodeEscape-Vorbild).
+
+---
+
+## AP 5 — FinalProtocol: AP2-Ausbau (5 Themen je Richtung, je 20 Fragen)
+
+Skelett exakt von `RES\static\finalflux\ap2-fisi\hochverfuegbarkeit.html` übernehmen (Lernfokus mit 3 Zielen, 2–4 Inhaltssektionen mit `key-list` + Merksätzen, Prüfungsmodus-Block verbatim, `finalflux-test.js` mit `data-questions-src`). JSON-Schema wie bestehende Dateien: `{category, hint, text, answers[3], correct (rotierend), explanation (nennt auch die Distraktor-Fallen)}`, 4–6 Kategorien pro Datei, „du"-Ansprache, **echte Umlaute (UTF-8 ohne BOM)**.
+
+**AP2 Systemintegration** (`RES\static\finalflux\ap2-fisi\` + `questions\`):
+| Seite | Inhalt |
+|---|---|
+| netzwerkplanung | Subnetting/VLSM, IPv6, WLAN-Planung, Routing |
+| it-sicherheit | Firewall/DMZ, VPN (IPsec/TLS), sym./asym. Verschlüsselung, Zertifikate, CIA, 2FA |
+| virtualisierung | Typ-1/2-Hypervisor, Container vs. VM, Snapshots, IaaS/PaaS/SaaS |
+| monitoring-backup | SNMP/Schwellwerte, 3-2-1-Regel, Generationenprinzip, Wiederherstellungs-Szenarien, Serverdimensionierung |
+| skripting | Shell/PowerShell-Konstrukte, Pseudocode, Cron/Aufgabenplanung, Exit-Codes |
+
+**AP2 Anwendungsentwicklung** (`ap2-fiae\`): **uml** (Klassen-/Sequenz-/Aktivitätsdiagramm, Multiplizitäten), **sql** (Joins, GROUP BY/HAVING, DDL/DML, Normalisierung), **oop** (Kapselung, Vererbung vs. Komposition, Polymorphie, Interfaces), **algorithmen** (Pseudocode/Struktogramm, Sortieren/Suchen, O-Notation, Rekursion), **testverfahren** (Blackbox/Whitebox, Äquivalenzklassen/Grenzwerte, Testebenen; + Kategorie REST/JSON/XML).
+
+→ je Richtung ~106 Fragen inkl. Bestand. Navigation: `RES\templates\finalflux.html` Z. 62–70 um je 5 Links erweitern; optional „AP2-Kompass"-Panel neben dem AP1-Kompass. `systemintegration/`-Sektion bleibt als AP1 „Systeme & Netzwerke" unverändert.
+
+---
+
+## AP 6 — DSGVO
+
+1. **Footer-Fragment rollout**: `fragments/layout.html:87–94` (`th:fragment="footer"`) existiert, wird 0× genutzt → alle ~26 Inline-Footer durch `th:replace="~{fragments/layout :: footer}"` ersetzen **und** auf die 7 Spielseiten + `error.html` + `forgot-password.html`/`reset-password.html` bringen (Spielseiten ggf. schlanke CSS-Anpassung, damit der Look nicht bricht). Rechtslinks damit von jeder Seite erreichbar.
+2. **Datenschutzerklärung vervollständigen** (`templates/legal/datenschutz.html`): NeuralNet-Messaging als Verarbeitungstätigkeit (Inhalte, Sender/Empfänger, Zeitstempel, Lesebestätigungen, Löschung via Kaskade), E-Mail-Token (SHA-256, 24 h TTL) + SMTP-Versand über `mail.sysnaptik.de` als Empfänger, konkrete Speicherfristen (Konto, Logs, Login-Versuche, Nachrichten), Drittland-Aussage nach CDN-Entfernung wieder korrekt.
+3. **Impressum strukturieren** (`templates/impressum.html`): saubere Struktur mit klar markierten Pflichtfeldern (Name, Anschrift, E-Mail, Vertretung) als auffällige Platzhalter — werden vor Launch ausgefüllt.
+4. **Support/Feedback-Links** (`fragments/layout.html:88–89`, `href="#"`): auf `mailto:`-Platzhalter konsistent zum Impressum umstellen oder bis dahin entfernen (Betroffenenrechte brauchen einen Kanal).
+5. **Datenexport Art. 20**: `GET /profile/export` in `ProfileController` → Service sammelt User-Stammdaten, Scores, Achievements, Fortschritt, NeuralNet-Daten → JSON-Download. Test ergänzen.
+6. **Demo-User `NeuralTest` entschärfen**: neue Migration `V22__remove_neuraltest_demo_user.sql` (Löschen, Kaskaden räumen auf); falls für Dev nötig, als profile-gebundenen Runner (`@Profile("dev")`) neu anlegen.
+
+---
+
+## AP 7 — Best Practices
+
+1. **Bean Validation aktivieren**: `@Valid` + `@NotBlank/@Size/@Email` auf Request-DTOs (`ScoreSubmission`, BugHunter/Techtacular-Requests); die rohen `Map<String,String>`-Bodies in `NeuralNetApiController` durch typisierte DTOs ersetzen. Handler (`ApiExceptionHandler:45–51`) ist schon verdrahtet.
+2. **Security-Header** (`SecurityConfig.java`): `.headers()`-Block mit CSP (nach Chart.js-Vendoring machbar; pragmatisch starten mit `default-src 'self'` + `style-src 'self' 'unsafe-inline'` wegen Inline-Styles in Templates), HSTS (nur Prod), Referrer-Policy.
+3. **Spring Boot bumpen**: 3.4.4 → aktuellstes 3.4.x-Patch (`pom.xml:11`), Testlauf.
+4. **Avatar-Logik aus `ProfileController` (Z. 115–172) in einen `AvatarService`** extrahieren (Bild-Dekodierung/Skalierung/Datei-I/O, Pfad-Logik heute 3× dupliziert).
+5. **CSRF** (niedrige Prio): Blanket-Exemption für `/api/**` (SecurityConfig:42–46) durch Cookie-basierten CSRF-Token für JSON ersetzen.
+6. **Tests**: Web-Layer-Tests für neue Endpoints (Techtacular-Hint, Profil-Export).
+
+---
+
+## Reihenfolge
+
+1. AP 0 Quick Wins → 2. AP 1 Light Mode (Tokens → Kartenakzente → 3 Spiele) → 3. AP 2 Icons → 4. AP 3 Widget → 5. AP 4 Guides/Hints → 6. AP 5 AP2-Content (parallelisierbar zu 2–5) → 7. AP 6 DSGVO → 8. AP 7 Best Practices → 9. Gesamtverifikation.
+
+## Verifikation
+
+- **Build/Run**: `mvn spring-boot:run` in `mindflux2` (oder `docker-compose up`); `mvn test` muss grün bleiben.
+- **Light Mode visuell**: Screenshots hell **und** dunkel: Dashboard (Kartengrid + `.mf-play`-Hover), Login, Settings, Progress, Soziales und **alle 9 Spiele** (insb. ServiceClash/Networker/BugHunter in beiden Themes); Hochkontrast- und Farbenblind-Modus je einmal gegenprüfen.
+- **Icons**: Topbar Dashboard + ein Spiel-Header, beide Themes; Badge-Positionen.
+- **Widget manuell**: Tab-Zyklus im Panel, Escape, Fokus-Rückgabe, Screenreader-Label des Font-Buttons.
+- **Guides**: `localStorage` `mf-guide-seen:*` löschen → jedes Spiel: Auto-Open einmalig, „?" reopenbar, `/networker` unverändert. MindMatch: Tipp zählt Zug hoch, Server-Score stimmt. TechTacular: Joker eliminiert Falsche, halbe Punkte bei `hintUsed`, `/hint` leakt nie die richtige ID.
+- **AP2**: alle 10 neuen Links erreichbar, je ein kompletter Quiz-Durchlauf (antworten, überspringen, neu starten, Kategorien-Summary), JSON-Validierung (`python -m json.tool`), `0 <= correct < answers.length`.
+- **Umlaut-QA**: Grep-Muster (s. AP 0) ohne Treffer in sichtbaren Texten; Browser-Darstellung stichprobenartig.
+- **DSGVO**: Netzwerk-Tab auf `/progress` → keine externen Requests; Footer-Links auf jeder Seite; Export-Download enthält alle Datenkategorien; `NeuralTest` nach Migration weg.
+
+## Offene Punkte (vor Launch)
+
+- Impressumsdaten (Name, Anschrift, E-Mail) liefern → Impressum + §1 Datenschutzerklärung.
+- Support-/Feedback-Zieladresse bestätigen.
+- Gesamtumfang ist groß (v. a. AP 5 Content-Arbeit) — bei Bedarf über mehrere Sitzungen umsetzen; die Arbeitspakete sind unabhängig genug.

mindfluxrefine2.md

@@ -0,0 +1,314 @@
+# Mindflux — Refine 2: Light-Mode-Konzept, Scroll-Verhalten, Restpunkte
+
+## Kontext
+
+Folgeplan zu `mindfluxrefine.md`. Die Code-Verifikation (2026-07-21) bestätigt: **alle „vollständig"-Claims aus Refine 1 halten der Prüfung stand**; offen sind AP 1e (Glow im Light Mode), der AP-7-Rest sowie einige Zusatzfunde (s. AP R5). Dieser Plan liefert das, was Refine 1 offen ließ: ein **echtes Light-Mode-Konzept**, das alle Probleme an der Wurzel behebt (statt Glow-Alphas weiter zu dimmen), plus das neue Thema **Scroll-Verhalten** (Ergebnisanzeigen u. ä. müssen oben starten, nicht unten).
+
+**Audit-Kurzbefunde (2026-07-21, drei unabhängige Durchgänge):**
+
+- **Light-Mode-Strukturfehler:** Der Light-Block in `theme.css` tauscht nur *Farbwerte/Alphas* der Glow-Tokens. Die *Geometrie* der Effekte (`box-shadow:0 0 20px …`, `text-shadow:0 0 12px …`, `drop-shadow(0 0 8px …)`) steht hart in ~70 Komponentenregeln quer durch `theme.css`, alle Spiele-CSS und Template-`<style>`-Blöcke. Ein Halo mit reduziertem Alpha bleibt ein Halo — auf Fast-Weiß liest er sich als Schmutz/Haze. Einzige strukturell adaptierte Stelle heute: `--g-soft` (`0 0 18px` dark → `0 6px 18px` light, `theme.css:31/53`). Genau **eine** Regel neutralisiert einen Glow explizit im Light Mode (`auth.css:127–128`).
+- **5 im Light Mode kaputte Stellen:** Login-Overlay weiß-auf-weiß (auth.css:123–127 × platform-neural.css:94), SyntaxSaga-Bühne bleibt schwarz (`syntaxsaga.css:250–251`), CodeEscape-Eingaben dunkel-auf-dunkel (`codeescape.css` `.esc-input` `#080604`), NetWorker-Guide-Panel dunkelnavy mit Light-`--muted` (`networker-guide.css`), Farbenblind-Palette × Light = Hellgelb/Hellblau auf Weiß (`accessibility.css:15–23`, `!important` schlägt die Light-Kartenakzente).
+- **Theme-Bootstrap-Lücken:** `color-scheme` fehlt komplett (native Scrollbars/Form-Controls folgen dem UA-Default), kein `theme-color`-Meta, kein `prefers-color-scheme`-Fallback (Erstbesucher mit OS-Light starten dunkel), alle Templates hardcoden `data-theme="dark"`.
+- **Scroll:** Im gesamten Projekt existiert **kein einziger** `scrollTo`/`scrollIntoView`/`scrollRestoration`-Aufruf (außer Chat-Autoscroll `neuralnet.js:84`, der korrekt ist). Die vier SPA-Spiele (BugHunter, CodeEscape, NetWorker, ServiceClash) ersetzen Views per `innerHTML` ohne Reset; der FinalProtocol-Quiz kollabiert am Ende einer langen Lernseite (Browser clampt ans neue Seitenende); SyntaxSaga/DevLab fokussieren Inputs ohne `preventScroll`.
+- **CSS-Leichen:** `achievements.css`, `progress.css`, `settings.css`, `soziales.css` werden nirgends mehr referenziert (repo-weiter Grep leer); `style.css` wird nur noch von `finalflux.html` geladen, ~90 % davon ist toter Dark-Code.
+
+Basis-Pfad: `RES` = `src\main\resources`
+
+---
+
+## Das Konzept: „Licht statt Leuchten"
+
+**Prinzip:** Dark Mode und Light Mode sind Geschwister mit derselben Farbidentität, aber unterschiedlicher *Physik*:
+
+| | Dark Mode | Light Mode |
+|---|---|---|
+| Metapher | Neon in der Nacht — Elemente **emittieren** Licht | Druck/Material am Tag — Elemente **werfen Schatten** |
+| Betonung | farbiger Glow (Halo) | **Elevation** (weicher, warm getönter neutraler Schatten) |
+| Identität/Wiedererkennung | Glow-Farbe | **Akzentfarbe direkt am Element** (Border, Text, Icon) — ist durch `--border-accent`, Icon-Farben und Kartenakzente bereits überall vorhanden |
+| Text-Halos | ja (`text-shadow`) | **nie** (liest sich als Unschärfe) |
+| Fokus-Ringe | farbig, weich | farbig, **crisp** (Ring statt Blur — funktional, bleibt farbig) |
+| Scrims/Overlays | dunkel | dunkel (funktional), aber leicht entschärft |
+
+**Mechanik:** Effekte werden zu **Primitives** — komplette `box-shadow`/`filter`/`text-shadow`-*Werte* als Tokens, nicht nur Farben. Komponenten schreiben nie mehr `0 0 20px var(--glow-s)`, sondern `var(--g-strong)`. Der Light-Block tauscht dann die *Kategorie* des Effekts (Glow → Elevation), nicht nur die Farbe. Dark bleibt visuell gleich (Blur-Radien werden auf die Primitive normalisiert; ±4 px sind nicht unterscheidbar). `--glow-s`/`--glow-w` bleiben als Farb-Tokens bestehen — die Spiele-CSS remappen sie bereits per `color-mix` auf ihre Akzente, und die Primitives referenzieren sie per `var()`, sodass Spiel-Glows im Dark Mode automatisch die Spielfarbe behalten.
+
+---
+
+## AP R0 — Aufräumen (erledigt 2026-07-22)
+
+1. **Erledigt:** Verwaiste CSS gelöscht: `achievements.css`, `progress.css`, `settings.css`, `soziales.css`. Die Referenzprüfung ergab 0 Treffer; STYLEGUIDE bereinigt.
+2. **Erledigt:** `style.css` auf eine vierzeilige Basis für die 40 statischen
+   FinalProtocol-Lernseiten reduziert; FinalProtocol-Hub lädt sie nicht mehr.
+3. **Erledigt:** Nicht eingebundenes `finalflux-check.js` entfernt. `fluxtimer.css` bleibt separat offen, da die Datei in diesem Paket nicht geändert wurde.
+
+---
+
+## AP R1 — Effekt-Primitives (Kern des Light-Konzepts)
+
+### R1a. Tokens in `RES\static\css\theme.css` — erledigt 2026-07-22
+
+In den Dark-Block (Z. 11–32) und Light-Block (Z. 33–54) ergänzen. Schattenfarbe Light ist **warmes Braun** `rgb(67,48,26)` (zur Creme-Palette passend, kein totes Grau/Schwarz):
+
+```css
+:root, [data-theme="dark"] {
+  /* … bestehende Tokens … */
+  color-scheme:dark;
+  --g-text:0 0 12px var(--glow-s);              /* Text-Halo: Logo, Headline-Akzent, *-brand b   */
+  --g-icon:drop-shadow(0 0 8px var(--glow-s));  /* leuchtende Glyphen/Embleme                    */
+  --g-strong:0 0 20px var(--glow-s);            /* starke Betonung: aktive Nav/Tabs, Primär-Btn  */
+  --g-amb:0 0 14px var(--glow-w);               /* dezenter Schein: Icon-Hover, Toggle, Burger   */
+  --g-card:drop-shadow(0 0 7px var(--glow-w));  /* Spielkarten-Grundzustand                      */
+  --g-card-hover:drop-shadow(0 0 16px var(--glow-s));
+  --g-overlay:0 24px 60px rgba(0,0,0,.5);       /* schwebende Panels: Guide, Drawer, A11y        */
+  --g-focus:0 0 0 3px var(--glow-w);            /* Fokus-Ring (bleibt in beiden Themes farbig)   */
+  --scroll-thumb:var(--line);
+}
+[data-theme="light"] {
+  /* … bestehende Tokens … */
+  color-scheme:light;
+  --bg-glow: radial-gradient(900px 420px at 60% -10%, rgba(214,81,22,.05), transparent 60%); /* statt .10 — Haze halbieren */
+  --g-text:none;
+  --g-icon:none;
+  --g-strong:0 2px 10px rgba(67,48,26,.18), 0 1px 3px rgba(67,48,26,.10);
+  --g-amb:0 1px 5px rgba(67,48,26,.10);
+  --g-card:drop-shadow(0 2px 5px rgba(67,48,26,.10));
+  --g-card-hover:drop-shadow(0 8px 18px rgba(67,48,26,.16));
+  --g-overlay:0 18px 44px rgba(67,48,26,.20);
+  --g-focus:0 0 0 3px color-mix(in srgb, var(--accent) 28%, transparent);
+  --scroll-thumb:#d9cbb2;   /* --line #f1e8d8 ist auf #fbf6ec unsichtbar */
+}
+```
+
+Scrollbar-Regel `theme.css:64` auf `background:var(--scroll-thumb)` umstellen.
+
+### R1b. Mechanische Migration in `theme.css`
+
+| Zeile | Selektor | Alt | Neu |
+|---|---|---|---|
+| 79 | `.mf-logo .mark` | `drop-shadow(0 0 8px var(--glow-s))` | `filter:var(--g-icon)` |
+| 80 | `.mf-logo .txt b` | `text-shadow:0 0 12px var(--glow-s)` | `text-shadow:var(--g-text)` |
+| 87 | `.mf-nav a.active` | `0 0 20px var(--glow-s)` | `box-shadow:var(--g-strong)` |
+| 94 | `.mf-avatar` | `0 0 14px var(--glow-s)` | `box-shadow:var(--g-strong)` (gleiche Farbstärke-Familie wie heute) |
+| 102/104 | `.mf-streak .fire` / `.mf-brain` | drop-shadows | `filter:var(--g-icon)` |
+| 109 | `.mf-hello h1 .nm` | `text-shadow:0 0 16px var(--glow-s)` | `text-shadow:var(--g-text)` |
+| 113/120/202 | iconbtn-Hover / `.mf-theme` / `.mf-burger` | `0 0 14px var(--glow-w)` | `box-shadow:var(--g-amb)` |
+| 128/130 | `.mf-card` / `:hover` | drop-shadow 7/16px | `filter:var(--g-card)` / `var(--g-card-hover)` |
+| 131 | `.mf-card .ico` | drop-shadow | `filter:var(--g-icon)` |
+| 136 | `.mf-card:hover .mf-play` | `0 0 16px var(--glow-s)` | `box-shadow:var(--g-strong)` |
+| 146 | `.mf-panel.accent` | `0 0 20px var(--glow-w)` | `box-shadow:var(--g-amb)` |
+| 151 | `.mf-bar > i` | `0 0 10px var(--glow-s)` | eigenes Primitive `--g-bar` (dark `0 0 10px var(--glow-s)` / light `none`) — der Balken trägt seine Farbe selbst, im Light braucht er keinen Hof |
+| 154 | `.mf-btn` | `0 0 18px var(--glow-s)` | `box-shadow:var(--g-strong)` |
+| 168 | Input-Fokus | `0 0 0 3px var(--glow-w)` | `box-shadow:var(--g-focus)` |
+| 182 | `.mf-cardbox` | `0 0 30px var(--glow-w)` | Hero-Aura: Zweizeiler — Basis `box-shadow:var(--g-strong)`, plus `[data-theme="dark"] .mf-cardbox{box-shadow:0 0 30px var(--glow-w)}` |
+| 223 | Mobile `.mf-sidebar` | `0 18px 50px rgba(0,0,0,.55)` | `box-shadow:var(--g-overlay)` |
+| 238 | `.mf-tab.active` | `0 0 18px var(--glow-s)` | `box-shadow:var(--g-strong)` |
+
+### R1c. `platform-neural.css`
+
+Hat als einzige Datei schon gute Struktur-Overrides (Z. 91 ersetzt Schwarz- durch Grünschatten — Vorbild). Nachziehen: Z. 87 Logo-Drop-Shadow im Light auf `filter:none`; Z. 90 äußeren `0 0 13px`-Glow der aktiven Nav im Light streichen (Inset-Ring reicht). Die `--glow-s`-Kartenwerte (Z. 41–49/99–107) bleiben — sie speisen nach R1b nur noch Dark-Effekte.
+
+### R1d. Spiele-CSS + Guide/Widget-CSS migrieren
+
+Gleiches Muster in allen Dateien; die Spiel-`--glow-s`-Remaps (z. B. `mindmatch.css:364`) bleiben unverändert und speisen die Primitives automatisch mit der Spielfarbe. Betroffene Stellen (Audit-Inventar):
+
+- **Text-Halos** → `text-shadow:var(--g-text)`: `syntaxsaga.css:40`, `mindmatch.css:53`, `techtacular.css:48`, `devlab.css` (`.dl-tube span`), `devlabgame.css` (Header-Titel), `codeescape.css` (`.esc-brand b`, `.esc-result .score`), `bughunter.css` (`.bh-brand b`, Stamp), `networker.css` (`.nw-brand b`, `.nw-final-score`), `serviceclash.css` (`.sc-brand b`, `.sc-score`), `auth.css:74` (`.auth-head b`), `style.css:89` (falls nach R0 noch vorhanden), Template-`<style>`: `progress.html:14` (Prozentzahl).
+- **Box-Glows** → `var(--g-strong)`/`var(--g-amb)` nach Gewicht: `syntaxsaga.css:37/70/100/125/136/200/229/233`, `mindmatch.css:40/106/226/237/280/287/299/324`, `techtacular.css:39/75/174/207/299`, `devlab.css:102/158/173`, `devlabgame.css:10/12/23/49/61/70/78/106/108`, `codeescape.css` (Buttons/Dialog/Hero — Hero-`0 0 50px` als Dark-only-Zweizeiler wie `.mf-cardbox`), `codeescape-guide.css` (`.esc-how .active`, `.esc-door.ready`, `.esc-input.bad`), `bughunter.css`, `networker.css`, `serviceclash.css` (`.sc-meter i`), `fluxtimer.css:6/7`, `accessibility.css:29`, `accessibility-placement.css:2/16`, `auth.css:14/34/88/98` (`.neon-btn` inkl.: den `::before`-Conic-Blur-Rotor Z. 95/99 im Light per `display:none`).
+- **Fokus-Ringe** → `var(--g-focus)`: `syntaxsaga.css:160`, `devlabgame.css:35/39`, CodeEscape-Inputs.
+- **Schwarz-Schatten** → `var(--g-overlay)` bzw. warm getönt: `game-guide.css:72`, `accessibility.css:30`, `accessibility-placement.css:17`, `fluxtimer.css:8` (+ Z. 14 `inset`-Schwarz auf hellem Display im Light entfernen), `serviceclash.css` (`.sc-card`), `bughunter.css` (Drawer, dort auch die im Light unsichtbaren `rgba(255,255,255,.09–.16)`-Inset-Highlights auf Light-Varianten umstellen).
+- **Scrims** (funktional, bleiben dunkel, aber vereinheitlichen): `mindmatch.css:309`, `techtacular.css:192`, `syntaxsaga.css:216`, `devlabgame.css:104` — im Light auf das Muster `game-guide.css:138` (`rgba(15,23,42,.5)`) wechseln, damit sich nicht zusätzlich der warme `--bg-glow`-Radial über den Scrim legt (`var(--bg-glow)` aus den Scrim-Deklarationen entfernen).
+- **Hint-Glow** `game-guide.css:155/160–161` (`#ffd54a`): Light-Override `[data-theme="light"] .mm-card.hinted { box-shadow:0 0 0 2px #8a6a06, 0 4px 12px rgba(67,48,26,.18); filter:none; }` (Warn-Ton aus dem Light-Block).
+
+### R1e. Chart/Dashboard-`<style>`-Blöcke
+
+`dashboard.html:14/16/18/20/29/31/43/46/171`, `achievements.html:12–16`, `admin/dashboard.html:17–19`, `impressum.html:12`, `profile.html:11`: alle `text-shadow`/`drop-shadow`/`0 0 Npx`-Vorkommen auf die Primitives umstellen (Suchmuster: `grep -n "glow\|text-shadow\|drop-shadow" RES\templates -r`).
+
+---
+
+## AP R2 — Kaputte Light-Stellen (kritische Punkte erledigt 2026-07-22)
+
+### R2a. Login/Registrierung: Overlay weiß-auf-weiß (kritisch)
+
+Ursache: `auth.css:123–127` setzt für Light `#fff`-Text/weiße Ghost-Border (Annahme: kräftiges Orange-Panel), aber auf der Plattform übersteuert `platform-neural.css:94` den Overlay-Grund mit Fast-Weiß. Fix in `platform-neural.css` (Light-Sektion, höhere Spezifität durch `.sn-platform` gewinnt gegen auth.css):
+
+```css
+html[data-theme="light"].sn-platform body .overlay-panel h3 { color:#10291f; text-shadow:none; }
+html[data-theme="light"].sn-platform body .overlay-panel p  { color:#3c554a; }
+html[data-theme="light"].sn-platform body .ghost-btn        { color:#167a52; border-color:rgba(22,122,82,.55); }
+html[data-theme="light"].sn-platform body .ghost-btn:hover  { background:rgba(22,122,82,.10); }
+```
+
+### R2b. SyntaxSaga: Bühne bleibt schwarz (kritisch)
+
+`syntaxsaga.css:250–251` hardcodet `#07100b` + grüne Scanlines. Light-Block ergänzen (Palette: helles Bühnen-Grün zur Light-`--ss-accent` `#277d49`):
+
+```css
+[data-theme="light"] body.ss-body {
+  background:radial-gradient(1100px 500px at 50% -10%, rgba(39,125,73,.08), transparent 60%), #eef6f0;
+}
+[data-theme="light"] body.ss-body::before {
+  background:repeating-linear-gradient(0deg, rgba(16,64,40,.05) 0 1px, transparent 1px 4px);
+}
+```
+
+### R2c. CodeEscape: Terminal-Eingaben & Dark-Inks (kritisch)
+
+- `.esc-input, .esc-select` (`#080604`): Light-Override `[data-theme="light"] .esc-input, [data-theme="light"] .esc-select { background:#fffaf0; color:var(--text); border-color:var(--border); }` — Dark behält den Terminal-Look.
+- Hardcodierte Dark-Inks auf Akzentflächen durch das Token ersetzen (funktioniert in beiden Themes): `.esc-btn:hover`/`.primary` `#160d00` → `var(--accent-ink)`; `codeescape-guide.css` `.esc-fragment small` `#160d00` → `var(--accent-ink)`; `.esc-how .done b` `#06120a` → `var(--accent-ink)`.
+- Tote Scanlines `rgba(255,255,255,.018)` (`codeescape.css`, `theme.css:138`): im Light-Override auf `rgba(67,48,26,.04)` drehen oder streichen.
+
+### R2d. NetWorker-Guide: dunkles Panel (kritisch)
+
+`networker-guide.css` (`.nw-guide` `color-mix(#0b2540 74%, var(--surface))`): Light-Block ergänzen:
+
+```css
+[data-theme="light"] .nw-guide { background:var(--surface); border-color:#d3e2f0; box-shadow:var(--g-soft); }
+```
+
+(Textfarben laufen dort über `var(--muted)`/`var(--text)` und stimmen dann automatisch.)
+
+### R2e. Farbenblind-Palette × Light (kritisch)
+
+`accessibility.css:15–23` erzwingt helle Okabe-Ito-Akzente per `!important` — auf weißen Karten < 1.5:1. Neuen Satz `html[data-theme="light"][data-mf-color="safe"]` mit **abgedunkelten** Okabe-Ito-Entsprechungen ergänzen (gleiche Zuordnung Spiel→Farbfamilie wie im Dark-Satz, Werte rechnerisch ≥ 4.5:1 auf Weiß, beim Umsetzen mit Kontrast-Tool gegenprüfen):
+
+| Okabe-Ito (dark) | Light-safe |
+|---|---|
+| `#e69f00` Orange | `#8a5f00` |
+| `#56b4e9` Himmelblau | `#19607f` |
+| `#009e73` Grün | `#007054` |
+| `#f0e442` Gelb | `#7a6a00` |
+| `#0072b2` Blau | `#0072b2` (bleibt) |
+| `#d55e00` Vermillion | `#a94500` |
+| `#cc79a7` Purpur | `#9c4f79` |
+
+Die zugehörigen Glow-Alphas entfallen im Light automatisch über die Primitives (R1).
+
+### R2f. Kleinere Light-Fixes
+
+1. **Cancel-Hover** `mindmatch.css:128–129`, `techtacular.css:94` (`#fff` auf Blassrosa): Light-Override `[data-theme="light"] .mm-cancel:hover, …` → `background:var(--danger); color:#fff;` (Light-Danger `#be123c`, 7:1). Dark bleibt unverändert.
+2. **A11y-Widget-Inks:** `accessibility-placement.css:7–15` hardcodet dunkle `--mf-a11y-ink`-Werte — im Light sind die Akzente selbst dunkel. Eine Regel ergänzt: `html[data-theme="light"] body { --mf-a11y-ink:#fff; }` (gewinnt per Spezifität gegen die Skin-Zuweisungen). Panel-Kopf optional angleichen: `[data-theme="light"] .mf-a11y-head { background:var(--surface-2); color:var(--heading); }`.
+3. **finalflux-Altlast:** `finalflux.css:345` (`#0b0d1b`-Hardcode) funktioniert nur über die fragile `background:transparent`-Kaskade aus `platform-neural.css:61`. Hardcode durch `var(--bg)`-basierte Deklaration ersetzen, damit die Seite auch ohne `sn-platform` beide Themes überlebt.
+
+**Erledigt:** Login-Overlay, SyntaxSaga-Bühne, CodeEscape-Eingaben und Akzent-Inks,
+NetWorker-Guide, Farbenblind-Palette für Light Mode, A11y-Widget-Inks sowie der
+FinalProtocol-Hintergrund. Die noch offenen kleineren Cancel-Hover- und Detaileffekte
+werden zusammen mit der vollständigen CSS-Migration aus R1 abgeschlossen.
+
+---
+
+## AP R3 — Theme-Bootstrap (erledigt 2026-07-22)
+
+In `RES\static\js\theme.js`:
+
+1. **Erledigt:** `prefers-color-scheme` wird verwendet, wenn noch keine lokale Auswahl gespeichert ist.
+2. **Erledigt:** `theme-color` wird beim initialen Anwenden und Umschalten auf `#0a0806` bzw. `#fbf6ec` aktualisiert.
+3. **Erledigt:** `color-scheme` wird im Dark-/Light-Tokenblock gesetzt.
+4. **Teilweise erledigt:** geänderte FinalProtocol-Assets tragen neue Versionen; die übrigen Template-Referenzen werden bei ihrer jeweiligen Migration angehoben.
+
+---
+
+## AP R4 — Scroll: Ergebnisanzeigen & Ansichten starten oben (weitgehend erledigt 2026-07-22)
+
+Es gibt projektweit keinen Scroll-Reset. Drei Schichten (zentraler Helper + gezielte Aufrufe), Chat-Autoscroll `neuralnet.js:84` bleibt unangetastet:
+
+### R4a. Helper in `theme.js` (läuft auf jeder Seite)
+
+```js
+window.MindfluxUX = {
+  toTop: function () { window.scrollTo(0, 0); },
+  focusQuiet: function (el) { if (el) el.focus({ preventScroll: true }); }
+};
+```
+
+**Umsetzungshinweis:** Der zentrale Helper ist vorhanden. Die vier SPA-Spiele setzen
+`history.scrollRestoration` nur auf Spielrouten auf `manual`; ein zentraler,
+ereignisbasierter Übergangs-Reset deckt Ansichtswechsel ab und lässt Antwort- bzw.
+Zeilenfeedback unverändert. FinalProtocol, SyntaxSaga, DevLab, MindMatch und
+TechTacular haben die zusätzlich beschriebenen gezielten Resets/Fokusoptionen.
+**Offen für die visuelle E2E-Prüfung:** die asynchron gerenderten Ergebniswechsel von
+CodeEscape, NetWorker und BugHunter müssen im Browser gegen die Scroll-Checkliste
+validiert und bei Bedarf direkt in den jeweiligen Render-Funktionen präzisiert werden.
+
+### R4b. SPA-Spiele — Reset bei jedem Ansichtswechsel
+
+Muster pro Spiel: Mini-Wrapper `function setView(html){ view.innerHTML = html; window.scrollTo(0,0); }`, alle Render-Funktionen darüber. Zusätzlich **nur in diesen vier Skripten** beim Init: `if ('scrollRestoration' in history) history.scrollRestoration = 'manual'; window.scrollTo(0,0);` — verhindert, dass der Browser nach Reload/Back die alte, untere Position auf den neu aufgebauten Katalog anwendet. (Nicht global in `theme.js`: auf Lernseiten/Dashboard ist die Back-Position erwünscht.)
+
+| Spiel | Funktionen |
+|---|---|
+| BugHunter (`bughunter.js`) | `renderBriefing` :29, `renderHunt` :36 (nur bei Fallwechsel, nicht bei Zeilen-Re-Render), `showDebrief` :82, `renderResult` :88 |
+| CodeEscape (`codeescape.js`) | `renderLobby` :6, `renderRoom` :8, `renderResult` :17 |
+| NetWorker (`networker.js`) | `renderCatalog` :3, `renderIntro` :5, `renderLevel` :6, `finish` :11 |
+| ServiceClash (`serviceclash.js`) | `renderCatalog` :2, `renderRun` :4 (**nur bei Ticket-/Indexwechsel**, nicht beim Feedback-Re-Render), `finish` :9 |
+
+### R4c. FinalProtocol-Quiz (`finalflux-test.js`)
+
+- `finishIfDone()` Z. 101–104: nach `testResult.hidden = false` → `elements.testResult.scrollIntoView({ block: 'start' });` (Auswertung beginnt oben im Blick, statt dass der Viewport ans geclampte Seitenende fällt).
+- `restartTest()` Z. 151–158: nach dem Wiedereinblenden → `elements.testRoot.scrollIntoView({ block: 'start' });`
+
+### R4d. Fokus ohne Scroll-Sprung
+
+- `syntaxsaga.js`: `renderMission()` — `window.scrollTo(0,0)` vor Z. 209, dann Z. 210 `first.focus({preventScroll:true})`. (`nextBtn.focus()` Z. 297 bleibt — Nutzeraktion am selben Ort.)
+- `devlabgame.js`: `renderTask()` Z. 243 — `window.scrollTo(0,0)` am Ende; Z. 83 und Z. 233 `focus({preventScroll:true})`.
+- `codeescape.js:8/15` bleiben (Fokus am Türterminal ist dort korrekt).
+
+### R4e. Niedrige Prio (nur Mobile relevant)
+
+`mindmatch.js` `newGame()` :332 und `techtacular.js` `newGame()` :265: `window.scrollTo(0,0)` — Desktop-Bodys sind `overflow:hidden`, mobil scrollt die Seite.
+
+---
+
+## AP R5 — Carry-over: Rest aus Refine 1 + Zusatzfunde der Verifikation
+
+Aus Refine 1 (dort AP 7 / offen):
+1. **Bean Validation:** `@Valid` + Constraints auf alle Request-DTOs — `BugHunterApiController:17–18`, `DevLabApiController:37/43`, `SyntaxSagaApiController:32/38`, `TechtacularApiController:50/75`, `CodeEscapeApiController` (4 DTOs), `NetworkerApiController` (2), `ServiceClashApiController` (2); `NeuralNetApiController:14/19` `Map<String,String>` → typisierte DTOs.
+2. **Spring Boot** 3.4.4 → aktuelles 3.4.x-Patch (`pom.xml:11`), Testlauf.
+3. **CSRF:** Blanket-Exemption `/api/**` (`SecurityConfig:46`) durch Cookie-basierte Tokens ersetzen.
+4. **Web-Layer-Test** für `GET /profile/export`.
+
+Zusatzfunde (neu):
+5. **`UserController:25/45`** bindet die **Entity `User`** direkt als `@RequestBody` ohne Validierung → auf DTO + `@Valid` umstellen (gehört in die Runde von Punkt 1).
+6. **5 Admin-Templates ohne Footer:** `admin\bughunter.html`, `admin\bughunter-hunt.html`, `admin\codeescape.html`, `admin\codeescape-room.html`, `admin\codeescape-scenario.html` → `th:replace="~{fragments/layout :: footer}"` ergänzen.
+7. **HSTS** explizit für Prod konfigurieren statt Spring-Default (`SecurityConfig:56–57`).
+8. Optional (unverändert Phase 2): BugHunter progressive Hinweise (Refine 1, AP 4d).
+
+---
+
+## Reihenfolge
+
+1. **AP R0** Aufräumen → 2. **AP R1** Primitives + Migration (theme.css zuerst, dann platform-neural, dann Spiele-CSS, dann Templates) → 3. **AP R2** kaputte Light-Stellen → 4. **AP R3** Bootstrap → 5. **AP R4** Scroll (unabhängig von 1–4, parallelisierbar) → 6. **AP R5** Carry-over → 7. Gesamtverifikation. STYLEGUIDE.md (Abschnitt „Glow, Schatten & Radien" → Primitives-Tabelle) und CHANGELOG nach R1–R3 nachziehen.
+
+## Verifikation
+
+- **Build:** `mvn test` bleibt grün (54/54); App-Boot gegen Wegwerf-Postgres wie gehabt.
+- **Grep-Gates nach R1:** `grep -rnE "0 0 [0-9]+px var\(--" RES\static\css` → Treffer nur noch in den Primitive-Definitionen von `theme.css`; `grep -rn "text-shadow:0 0" RES\static\css RES\templates` → nur `--g-text`-Definition; `grep -rn "rgba(0,0,0,.5" RES\static\css` → nur Scrims/`--g-overlay`-Definition.
+- **Visuell (hell UND dunkel):** Dashboard (Karten + Hover), Login/Registrierung (insb. Overlay-Panel!), Settings, Progress, Soziales, NeuralNet, alle 9 Spiele (insb. SyntaxSaga-Bühne, CodeEscape-Eingaben, NetWorker-Guide), FinalProtocol-Lernseite + Quiz, A11y-Panel. Dark Mode muss vor/nach R1 visuell deckungsgleich sein (Stichprobe per Screenshot-Vergleich).
+- **A11y-Kombinationen:** Light × Hochkontrast (bleibt bewusst dunkel), Light × Farbenblind (neue dunkle Okabe-Ito-Werte sichtbar, Kontrast-Tool ≥ 4.5:1), Light × Mono.
+- **Native Controls:** Light Mode → helle Scrollbars und helle `<select>`-Dropdowns (Chrome + Firefox); mobile Adressleiste folgt `theme-color`.
+- **Erstbesuch:** localStorage leeren, OS auf Light stellen → Seite startet hell; OS Dark → dunkel; Umschalter persistiert weiter.
+- **Scroll:** je SPA-Spiel: langes Board nach unten scrollen → Aktion abschließen → Ergebnis-/Folge-View beginnt **oben**; ServiceClash-Antwort-Feedback und BugHunter-Zeilenauswahl dürfen **nicht** nach oben springen; FinalProtocol: langen Lernartikel bis zum Quiz scrollen, Quiz abschließen → Auswertung oben im Viewport; Reload mitten im Spiel → Katalog startet oben; SyntaxSaga/DevLab: Missions-/Taskwechsel startet oben, Fokus springt nicht; NeuralNet-Chat scrollt weiterhin ans Ende.
+
+## Offene Punkte (unverändert aus Refine 1, vor Launch)
+
+- Echte Impressumsdaten (`impressum.html:44–52`) + §1 Datenschutzerklärung.
+- Support-/Feedback-Adressen bestätigen (`fragments/layout.html:88–89`).
+
+## Nachtrag 2026-07-22 — E-Mail-Diagnose (erledigt)
+
+- Der Versand von Bestätigungs- und Reset-Links protokolliert nun korrelierbare
+  Ereignisse: Token-Ausstellung, SMTP-Übergabe begonnen/angenommen/fehlgeschlagen,
+  erneute Anforderung und erfolgreiche Verifikation. Logs enthalten User-/Token-IDs
+  sowie einen gekürzten E-Mail-Fingerprint, niemals den Link oder das Roh-Token.
+- Wichtig für die Analyse: `SMTP_SUBMISSION_ACCEPTED` bedeutet nur, dass der
+  konfigurierte SMTP-Server die Nachricht angenommen hat. Spamfilter, Bounces und
+  die finale Postfachzustellung müssen zusätzlich im Mailserver bzw. über DSN geprüft
+  werden.
+- Der Registrierungsabschluss meldet keinen Versand-Erfolg mehr, falls der gerade
+  angelegte Benutzer beim Versand nicht geladen werden kann oder bereits als bestätigt
+  vorliegt; der Grund erscheint als `VERIFICATION_SKIPPED` im Betriebslog.
+
+## Nachtrag 2026-07-22 — Nutzerfeedback (erledigt)
+
+- **TechTacular:** Unbeantwortete Fragen lassen sich per ×, Klick auf den Hintergrund
+  oder Escape schließen und später erneut öffnen; sie werden dabei weder gewertet noch
+  als beantwortet markiert.
+- **Produktverständnis:** Vor dem Login erklärt eine sichtbare Einordnung Zielgruppe,
+  Lernformen und Nutzen der Plattform. Das Dashboard wiederholt den Zweck mit einem
+  kompakten „Was du hier machst“-Abschnitt.

pom.xml

@@ -60,6 +60,12 @@
       <artifactId>spring-boot-starter-validation</artifactId>
     </dependency>
 
+    <!-- SMTP-Versand für Bestätigungs- und Passwort-Reset-Mails -->
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-mail</artifactId>
+    </dependency>
+
     <!-- Health/Monitoring (Container-Healthcheck auf /actuator/health) -->
     <dependency>
       <groupId>org.springframework.boot</groupId>

src/main/java/com/example/mindflux/config/BugHunterSeeder.java

@@ -0,0 +1,31 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.BugHunterHuntRepository;
+import com.fasterxml.jackson.databind.*;
+import org.slf4j.*;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/** Erstbefüllung der Fallakten. Der vollständige Bug-Knoten bleibt als serverseitiger Payload erhalten. */
+@Component
+public class BugHunterSeeder implements CommandLineRunner {
+    private static final Logger log = LoggerFactory.getLogger(BugHunterSeeder.class);
+    private final BugHunterHuntRepository hunts; private final ObjectMapper mapper;
+    public BugHunterSeeder(BugHunterHuntRepository hunts, ObjectMapper mapper) { this.hunts = hunts; this.mapper = mapper; }
+    @Override @Transactional public void run(String... args) {
+        try {
+            JsonNode root = mapper.readTree(new ClassPathResource("bughunter/content.json").getInputStream()); int order = (int) hunts.count(), count = 0, added = 0;
+            for (JsonNode node : root.path("hunts")) {
+                if (hunts.existsBySlug(node.path("slug").asText())) continue;
+                BugHunterHunt hunt = new BugHunterHunt(node.path("slug").asText(), node.path("title").asText(), node.path("language").asText("Java"), node.path("difficulty").asText("junior"), node.path("examScope").asText("AP1"), node.path("description").asText(""), node.path("briefing").asText(""), node.path("consoleOutput").asText(""), order++);
+                int fileOrder = 0; for (JsonNode file : node.path("files")) hunt.addFile(new BugHunterFile(file.path("filename").asText(), file.path("content").asText(), fileOrder++));
+                int bugOrder = 0; for (JsonNode bug : node.path("bugs")) { String payload = mapper.writeValueAsString(bug); if (payload.length() <= 8000) { hunt.addBug(new BugHunterBug(bug.path("points").asInt(100), bugOrder++, payload)); count++; } }
+                if (!hunt.getFiles().isEmpty() && !hunt.getBugs().isEmpty()) { hunts.save(hunt); added++; }
+            }
+            log.info("BugHunter: {} neue Fallakten / {} Bugs geladen.", added, count);
+        } catch (Exception ex) { log.error("BugHunter-Seed fehlgeschlagen", ex); }
+    }
+}

src/main/java/com/example/mindflux/config/CodeEscapeSeeder.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.config; import com.example.mindflux.model.*;import com.example.mindflux.repository.EscapeScenarioRepository;import com.fasterxml.jackson.databind.*;import org.slf4j.*;import org.springframework.boot.CommandLineRunner;import org.springframework.core.io.ClassPathResource;import org.springframework.stereotype.Component;import org.springframework.transaction.annotation.Transactional;
+@Component public class CodeEscapeSeeder implements CommandLineRunner {private static final Logger log=LoggerFactory.getLogger(CodeEscapeSeeder.class);private final EscapeScenarioRepository repo;private final ObjectMapper mapper;public CodeEscapeSeeder(EscapeScenarioRepository r,ObjectMapper m){repo=r;mapper=m;}@Override @Transactional public void run(String...a){if(repo.count()>0)return;try{JsonNode root=mapper.readTree(new ClassPathResource("codeescape/content.json").getInputStream());int si=0,pc=0;for(JsonNode sn:root.path("scenarios")){EscapeScenario s=new EscapeScenario(sn.path("slug").asText(),sn.path("title").asText(),sn.path("difficulty").asText(),sn.path("examScope").asText("AP1"),sn.path("description").asText(),sn.path("timeLimitSeconds").asInt(900),si++);int ri=0;for(JsonNode rn:sn.path("rooms")){EscapeRoom r=new EscapeRoom(rn.path("title").asText(),rn.path("intro").asText(),rn.path("doorPrompt").asText(),rn.path("doorCode").asText(),rn.path("successText").asText(),ri++);int pi=0;for(JsonNode pn:rn.path("puzzles")){r.addPuzzle(new EscapePuzzle(pn.path("type").asText(),pn.path("prompt").asText(),pn.path("points").asInt(100),pn.path("fragment").asText(),pi++,mapper.writeValueAsString(pn.path("payload"))));pc++;}s.addRoom(r);}repo.save(s);}log.info("CodeEscape: {} Szenarien / {} Rätsel geladen.",si,pc);}catch(Exception e){log.error("CodeEscape-Seed fehlgeschlagen",e);}}}

src/main/java/com/example/mindflux/config/NetworkerSeeder.java

@@ -0,0 +1,16 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.NetworkWorldRepository;
+import com.fasterxml.jackson.databind.*;
+import org.slf4j.*;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component public class NetworkerSeeder implements CommandLineRunner {
+    private static final Logger log=LoggerFactory.getLogger(NetworkerSeeder.class); private final NetworkWorldRepository worlds; private final ObjectMapper mapper;
+    public NetworkerSeeder(NetworkWorldRepository worlds,ObjectMapper mapper){this.worlds=worlds;this.mapper=mapper;}
+    @Override @Transactional public void run(String...args){if(worlds.count()>0)return;try{JsonNode root=mapper.readTree(new ClassPathResource("networker/content.json").getInputStream());int wi=0,li=0;for(JsonNode world:root.path("worlds")){NetworkWorld item=new NetworkWorld(world.path("slug").asText(),world.path("title").asText(),world.path("description").asText(),world.path("difficulty").asText("junior"),world.path("examScope").asText("AP1"),wi++);int order=0;for(JsonNode level:world.path("levels")){String payload=mapper.writeValueAsString(level.path("payload"));if(payload.length()<=8000){item.addLevel(new NetworkLevel(level.path("title").asText(),level.path("type").asText("assign"),level.path("points").asInt(100),order++,payload));li++;}}worlds.save(item);}log.info("NetWorker: {} Welten / {} Level geladen.",wi,li);}catch(Exception e){log.error("NetWorker-Seed fehlgeschlagen",e);}}
+}

src/main/java/com/example/mindflux/config/SecurityConfig.java

@@ -12,6 +12,7 @@ import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.core.userdetails.*;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.header.writers.ReferrerPolicyHeaderWriter;
 
 @Configuration
 public class SecurityConfig {
@@ -20,7 +21,7 @@ public class SecurityConfig {
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http
             .authorizeHttpRequests(auth -> auth
-                .requestMatchers("/", "/login", "/register", "/impressum", "/nutzungsbedingungen", "/datenschutz", "/richtlinien", "/css/**", "/js/**", "/img/**").permitAll()
+                .requestMatchers("/", "/login", "/register", "/forgot-password", "/reset-password", "/verify-email", "/verification/resend", "/impressum", "/nutzungsbedingungen", "/datenschutz", "/richtlinien", "/favicon.ico", "/css/**", "/js/**", "/img/**").permitAll()
                 .requestMatchers("/actuator/health").permitAll() // Container-Healthcheck
                 .requestMatchers("/admin/**").hasRole("ADMIN")
                 .requestMatchers("/api/users/**").hasRole("ADMIN")
@@ -42,7 +43,18 @@ public class SecurityConfig {
             .csrf(csrf -> csrf
                 // Spiele-APIs werden per fetch (application/json) ohne Token aufgerufen -> ausnehmen.
                 // Reine JSON-Endpunkte sind nicht über klassische HTML-Formulare CSRF-ausnutzbar.
-                .ignoringRequestMatchers("/api/games/**", "/api/techtacular/**", "/api/mindmatch/**", "/api/syntaxsaga/**", "/api/devlab/**")
+                .ignoringRequestMatchers("/api/games/**", "/api/techtacular/**", "/api/mindmatch/**", "/api/syntaxsaga/**", "/api/devlab/**", "/api/codeescape/**", "/api/bughunter/**", "/api/serviceclash/**", "/api/networker/**", "/api/neuralnet/**")
+            )
+            .headers(headers -> headers
+                // CSP: pragmatischer Start – alle Assets sind self-hosted (Chart.js lokal
+                // gevendort). 'unsafe-inline' bleibt vorerst nötig, weil Templates Inline-
+                // Styles und einzelne Inline-Skripte enthalten (später auf Nonces umstellbar).
+                .contentSecurityPolicy(csp -> csp.policyDirectives(
+                    "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; "
+                    + "img-src 'self' data:; font-src 'self'; connect-src 'self'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'"))
+                .referrerPolicy(referrer -> referrer.policy(ReferrerPolicyHeaderWriter.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN))
+                // HSTS bleibt auf Spring-Default: wird nur über HTTPS gesendet, greift also
+                // faktisch nur in Produktion (Dev läuft über HTTP).
             );
 
         return http.build();

src/main/java/com/example/mindflux/config/ServiceClashSeeder.java

@@ -0,0 +1,51 @@
+package com.example.mindflux.config;
+
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.ServiceClashShiftRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+
+@Component
+public class ServiceClashSeeder implements CommandLineRunner {
+    private final ServiceClashShiftRepository shifts; private final ObjectMapper mapper;
+    public ServiceClashSeeder(ServiceClashShiftRepository shifts,ObjectMapper mapper){this.shifts=shifts;this.mapper=mapper;}
+    @Override @Transactional public void run(String... args) {
+        if(shifts.count()>0)return;
+        seed("fruehschicht","Frühschicht: Stabiler Start","Lerne das Triage-Prinzip: erst Art, dann Dringlichkeit, dann die passende erste Maßnahme.","Junior",0,List.of(
+            t("Druckerwarteschlange brennt","Buchhaltung","Drei Druckaufträge hängen seit dem Neustart fest; niemand kann Rechnungen drucken.","incident","medium","queue",1,100,"Störung: Die Warteschlange zurücksetzen und einen Testdruck starten.","queue","Druckwarteschlange prüfen und bereinigen","restart","Drucker ohne Prüfung neu starten","buy","Sofort ein neues Gerät bestellen"),
+            t("Azubi braucht Zugang","Ausbildung","Die neue Auszubildende startet heute und braucht Zugriff auf das Lernportal.","request","low","access",1,100,"Anfrage: Berechtigung nach Freigabe über den Standardprozess einrichten.","access","Zugang nach Freigabe einrichten","security","Sicherheitsincident ausrufen","ignore","Auf nächste Woche verschieben"),
+            t("WLAN im Besprechungsraum weg","Vertrieb","Seit 20 Minuten ist das Firmen-WLAN im Raum Elbe nicht sichtbar.","incident","medium","diagnose",1,110,"Störung: AP-Status und Stromversorgung prüfen, dann gezielt eskalieren.","diagnose","Access Point und Uplink prüfen","password","Alle WLAN-Passwörter zurücksetzen","replace","Das gesamte WLAN ersetzen"),
+            t("Neue Verteilerliste","Personal","Für das Onboarding wird eine Mailgruppe für zehn neue Kolleg:innen benötigt.","request","low","group",1,100,"Anfrage: Gruppe anhand der genehmigten Liste anlegen und Besitzer benennen.","group","Verteilerliste nach Vorlage anlegen","broadcast","An alle Mitarbeitenden mailen","escalate","Sofort an den CISO eskalieren"),
+            t("Zeiterfassung meldet Fehler","Produktion","Terminals zeigen beim Buchen nur noch „Dienst nicht erreichbar“.","incident","high","escalate",2,130,"Hohe Auswirkung: Incident dokumentieren, Dienst prüfen und an den Bereitschaftsdienst eskalieren.","escalate","Incident eröffnen und Bereitschaft informieren","wait","Bis morgen abwarten","delete","Terminals aus dem Verzeichnis löschen"),
+            t("USB-Tastatur defekt","Empfang","Eine einzelne Tastatur reagiert nicht mehr; Ersatz liegt im Schrank.","request","low","swap",2,90,"Standard-Request: Ersatzgerät ausgeben und Inventar nachführen.","swap","Ersatz ausgeben und Inventar buchen","outage","Großstörung ausrufen","format","Den Empfangs-PC formatieren"),
+            t("Dateiserver langsam","Konstruktion","Große CAD-Dateien öffnen seit einer Stunde extrem langsam, kleinere Dateien funktionieren.","incident","medium","monitor",2,120,"Störung: Auslastung und Netzwerkpfad messen, Befund in das Incident aufnehmen.","monitor","Last und Netzwerkpfad prüfen","reboot","Ohne Befund alle Server neu starten","close","Ticket als erledigt schließen"),
+            t("Meetingraum-Display buchen","Projektbüro","Für morgen soll das Display im Raum Nord für eine Präsentation reserviert werden.","request","low","booking",3,90,"Anfrage: Ressource im Buchungssystem reservieren und bestätigen.","booking","Display im Buchungssystem reservieren","incident","Display als Störung melden","handover","An die Nachtwache delegieren")
+        ));
+        seed("tagesschicht","Tagesschicht: Prioritäten unter Druck","Mehr parallele Tickets: Schütze zuerst Menschen, Daten und geschäftskritische Dienste.","Fortgeschritten",1,List.of(
+            t("ERP nicht erreichbar","Finanzen","Alle Standorte melden beim ERP nur noch Zeitüberschreitungen. Rechnungsfreigaben stehen.","incident","high","major",1,150,"Major Incident: Lagebild eröffnen, Eigentümer informieren und Wiederherstellung koordinieren.","major","Major Incident eröffnen und eskalieren","restart","Einzelne Clients neu starten","close","Ohne Prüfung schließen"),
+            t("Neue Software beantragt","Marketing","Ein Team möchte eine bereits freigegebene Bildbearbeitung auf fünf Notebooks installieren.","request","medium","deploy",1,110,"Anfrage: Freigegebenes Paket über die Softwareverteilung bereitstellen.","deploy","Paket über Softwareverteilung ausrollen","admin","Allen lokale Adminrechte geben","ignore","Anfrage ignorieren"),
+            t("Verdächtige Phishing-Mail","Support","Mehrere Mitarbeitende erhielten eine Rechnung von einer ähnlich aussehenden Absenderdomain.","incident","high","contain",1,150,"Security-Incident: Nachricht sichern, Empfänger warnen und den Meldeprozess starten.","contain","Mail sichern, warnen und Security informieren","reply","Auf die Mail antworten","delete","Nur den eigenen Posteingang leeren"),
+            t("VPN für Dienstreise","Vertrieb","Eine Kollegin reist nächste Woche und benötigt den Standard-VPN-Zugang.","request","medium","vpn",1,110,"Anfrage: VPN nach Richtlinie und Freigabe aktivieren, MFA erklären.","vpn","VPN mit MFA nach Richtlinie einrichten","share","Kolleg:innen-Zugang teilen","exception","MFA dauerhaft umgehen"),
+            t("Monitoring meldet Platte voll","Monitoring","Das Monitoring meldet 94 % Belegung auf dem Log-Volume eines Anwendungsservers.","incident","high","capacity",2,140,"Hohe Priorität: Wachstum prüfen, sichere Bereinigung oder Erweiterung planen und Dienst beobachten.","capacity","Belegung prüfen und Kapazität sichern","rmall","Alle Logs blind löschen","silence","Alarm dauerhaft stummschalten"),
+            t("Namensschild-Drucker","Office Management","Für eine Veranstaltung wird ein temporärer Druckerzugang für den Empfang benötigt.","request","low","temporary",2,90,"Anfrage: zeitlich begrenzte Berechtigung dokumentiert einrichten.","temporary","Temporären Zugang dokumentiert einrichten","global","Drucker global freigeben","incident","Als Sicherheitsincident melden"),
+            t("CRM zeigt falsche Kundendaten","Vertrieb","Einige Kundensätze wirken veraltet, während Änderungen anderer Teams sichtbar sind.","incident","medium","investigate",2,120,"Störung: Reproduzierbarkeit, betroffene Datenquelle und letzte Synchronisation prüfen.","investigate","Datenquelle und Synchronisation prüfen","overwrite","Daten ohne Backup überschreiben","wait","Ticket ohne Rückmeldung parken"),
+            t("Projektablage anlegen","PMO","Ein neues Projekt braucht eine Teamablage mit den Rollen Lesen, Bearbeiten und Leitung.","request","medium","roles",3,110,"Anfrage: Ablage nach Berechtigungsvorlage erstellen und Rollen testen.","roles","Ablage mit Rollenmodell erstellen","public","Ablage öffentlich freigeben","owner","Alle zu Eigentümer:innen machen")
+        ));
+        seed("bereitschaft","Bereitschaft: Kritische Lage","Für die Abschluss-Schicht kombinierst du Security, Changes und Wiederanlauf unter klarer Kommunikation.","Profi",2,List.of(
+            t("Ransomware-Verdacht","Monitoring","Ein Fileserver erzeugt ungewöhnlich viele umbenannte Dateien; EDR meldet verdächtige Prozesse.","incident","high","isolate",1,160,"Security-Incident: System isolieren, Beweise sichern und Incident-Response alarmieren.","isolate","System isolieren und Incident Response alarmieren","reboot","Server sofort neu starten","delete","Betroffene Dateien ohne Sicherung löschen"),
+            t("Firewall-Change vor Wartung","Netzwerk","Für ein genehmigtes Wartungsfenster muss eine dokumentierte Regel temporär geöffnet werden.","request","high","change",1,140,"Change: Genehmigung, Zeitfenster, Rückfallplan und Protokoll vor Umsetzung prüfen.","change","Change mit Rückfallplan kontrolliert umsetzen","permanent","Regel dauerhaft und ohne Prüfung öffnen","delegate","Anfrage ohne Dokumentation weitergeben"),
+            t("Backup-Job fehlgeschlagen","Backup","Der nächtliche Backup-Job für zwei Datenbanken endete mit Fehler; die Produktion läuft noch.","incident","high","restore",1,150,"Hohe Priorität: Fehlerursache und letzte erfolgreiche Sicherung prüfen, Wiederanlauf planen.","restore","Backup-Kette prüfen und Wiederanlauf planen","ignore","Bis zum nächsten Lauf warten","purge","Alte Sicherungen sofort löschen"),
+            t("Notfall-Handy ausgeben","Bereitschaft","Eine neu eingeteilte Person braucht das Bereitschaftshandy inklusive Rufumleitung.","request","medium","handover",1,110,"Anfrage: Gerät, Rufumleitung und Übergabe nachvollziehbar dokumentieren.","handover","Übergabe und Rufumleitung dokumentieren","share","PIN unverschlüsselt in den Chat posten","skip","Gerät ohne Einweisung übergeben"),
+            t("Zertifikat läuft heute ab","Webteam","Das TLS-Zertifikat des Kundenportals läuft laut Monitoring um 23:59 Uhr ab.","incident","high","renew",2,150,"Dringend: Zertifikatskette und Erneuerung prüfen, Rollback und Monitoring vorbereiten.","renew","Zertifikat erneuern und Ablauf testen","disable","HTTPS abschalten","wait","Erst nach Ablauf reagieren"),
+            t("Neue Adminrolle","Entwicklung","Eine Entwicklerin beantragt für einen Testzeitraum erhöhte Rechte auf einem Staging-System.","request","high","least",2,130,"Anfrage: zeitlich begrenzte Least-Privilege-Rolle mit Genehmigung einrichten.","least","Befristete Minimalrechte nach Freigabe geben","root","Dauerhafte Root-Rechte vergeben","shared","Gemeinsames Admin-Konto nutzen"),
+            t("DNS-Ausfall in Außenstelle","Filiale Ost","Clients können interne Namen nicht auflösen, direkte IP-Verbindungen funktionieren noch.","incident","high","dns",2,150,"Störung: DNS-Pfad und Resolver prüfen, Auswirkung kommunizieren und Eskalation steuern.","dns","Resolver und DNS-Pfad prüfen","format","Alle Clients neu installieren","close","Ticket schließen, weil IPs gehen"),
+            t("Wartungsfenster verschieben","Change Management","Ein freigegebener Patch kollidiert mit einem wichtigen Kunden-Workshop und soll verschoben werden.","request","medium","reschedule",3,110,"Change-Anfrage: Auswirkungen bewerten, Beteiligte informieren und neues Fenster dokumentieren.","reschedule","Change dokumentiert neu terminieren","patch","Patch trotz Konflikt ausrollen","cancel","Alle offenen Changes löschen")
+        ));
+    }
+    private void seed(String slug,String title,String description,String difficulty,int order,List<ServiceClashTicket> tickets){ServiceClashShift shift=new ServiceClashShift(slug,title,description,difficulty,"AP2_FISI",order);tickets.forEach(shift::addTicket);shifts.save(shift);}
+    private ServiceClashTicket t(String title,String requester,String text,String category,String priority,String solution,int wave,int points,String explanation,String... options){try{ObjectNode p=mapper.createObjectNode();p.put("requester",requester);p.put("text",text);p.put("category",category);p.put("priority",priority);p.put("solution",solution);p.put("explanation",explanation);var array=p.putArray("options");for(int i=0;i<options.length;i+=2){ObjectNode option=array.addObject();option.put("id",options[i]);option.put("text",options[i+1]);}return new ServiceClashTicket(title,wave,points,wave*10+options.length,mapper.writeValueAsString(p));}catch(Exception e){throw new IllegalStateException(e);}}
+}

src/main/java/com/example/mindflux/config/SystemEscapePoolSeeder.java

@@ -0,0 +1,25 @@
+package com.example.mindflux.config;
+import com.example.mindflux.model.*;import com.example.mindflux.repository.EscapeScenarioRepository;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ObjectNode;import org.springframework.boot.context.event.ApplicationReadyEvent;import org.springframework.context.event.EventListener;import org.springframework.stereotype.Component;import org.springframework.transaction.annotation.Transactional;import java.util.*;
+@Component public class SystemEscapePoolSeeder{
+ private final EscapeScenarioRepository repo;private final ObjectMapper mapper;public SystemEscapePoolSeeder(EscapeScenarioRepository r,ObjectMapper m){repo=r;mapper=m;}
+ @EventListener(ApplicationReadyEvent.class) @Transactional public void expand()throws Exception{
+  add("verlassener-serverraum","DNS-Kammer","Ein Resolver hält die nächste Schleuse gesperrt.",q("DNS-Record für IPv4-Adresse?","A","A"),q("DNS-Record für Mailserver?","MX","MX"),q("DNS-Standardport?","53","53"));
+  add("verlassener-serverraum","VLAN-Brücke","Getrennte Segmente müssen korrekt verbunden werden.",q("VLAN-Tagging-Standard IEEE 802.?","1Q","1Q"),q("Gerät zwischen IP-Netzen?","Router","RTR"),q("VLAN ohne Tag am Trunk?","Native VLAN","NAT"));
+  add("verlassener-serverraum","Routing-Schacht","Das Gateway erwartet drei Routing-Grundlagen.",q("Route für alle unbekannten Ziele?","Default Route","DEF"),q("IPv4-Loopback-Adresse?","127.0.0.1","127"),q("Befehl zum Weg eines Pakets?","traceroute","TRC"));
+  add("verlassener-serverraum","Firewall-Gang","Nur korrekt gefilterter Verkehr öffnet den Gang.",q("Prinzip: alles verbieten, nur Nötiges erlauben?","Default Deny","DENY"),q("Firewall mit Verbindungszustand?","Stateful","STATE"),q("HTTPS-Protokoll über TCP-Port?","443","443"));
+  add("verlassener-serverraum","Monitoring-Zentrale","Metriken und Ereignisse liefern die Fragmente.",q("Protokoll für Geräteüberwachung?","SNMP","SNMP"),q("Zentrales Systemprotokoll?","Syslog","LOG"),q("ICMP-Werkzeug für Erreichbarkeit?","ping","PING"));
+  add("notfall-im-rechenzentrum","Identity-Vault","Der Identitätsdienst verlangt sichere Grundlagen.",q("Zweiter Faktor neben Passwort?","MFA","MFA"),q("Zentraler Verzeichnisdienst von Microsoft?","Active Directory","AD"),q("Minimal notwendige Rechte?","Least Privilege","LP"));
+  add("notfall-im-rechenzentrum","Container-Dock","Isolierte Workloads blockieren den Ausgang.",q("Container teilen den Kernel des?","Hosts","HOST"),q("Deklarative Container-Zusammenstellung?","Compose","COMP"),q("Persistenter Containerspeicher?","Volume","VOL"));
+  add("notfall-im-rechenzentrum","Patch-Leitstand","Ein ungepatchtes System hält die Tür verriegelt.",q("Bewertung bekannter Schwachstellen?","CVSS","CVSS"),q("Kennung einer veröffentlichten Schwachstelle?","CVE","CVE"),q("Testumgebung vor Produktion?","Staging","STG"));
+  add("notfall-im-rechenzentrum","Cluster-Korridor","Hochverfügbarkeit muss wiederhergestellt werden.",q("Automatischer Rollenwechsel bei Ausfall?","Failover","FAIL"),q("Verteilung von Anfragen?","Load Balancing","LB"),q("Prüfung der Dienstverfügbarkeit?","Health Check","HC"));
+  add("notfall-im-rechenzentrum","Storage-Array","Das Speichernetz fordert drei Begriffe.",q("Blockzugriff über IP?","iSCSI","ISCSI"),q("Dateifreigabe für Linux/Unix?","NFS","NFS"),q("Redundanz ist kein Ersatz für ein?","Backup","BAK"));
+  add("blackout-protokoll","PKI-Tresor","Die Zertifikatskette muss rekonstruiert werden.",q("Widerrufsliste für Zertifikate?","CRL","CRL"),q("Online-Prüfung eines Zertifikatsstatus?","OCSP","OCSP"),q("Oberste Vertrauensinstanz?","Root CA","ROOT"));
+  add("blackout-protokoll","API-Gateway","Die Schnittstelle akzeptiert nur sichere Antworten.",q("HTTP-Methode zum Lesen?","GET","GET"),q("Statuscode für nicht autorisiert?","401","401"),q("Datenformat mit Objekten und Arrays?","JSON","JSON"));
+  add("blackout-protokoll","Git-Archiv","Die Versionshistorie enthält den nächsten Schlüssel.",q("Lokale Änderungen vorm Commit vormerken?","git add","ADD"),q("Neuen Entwicklungszweig anlegen?","git branch","BR"),q("Historie eines Repositories anzeigen?","git log","LOG"));
+  add("blackout-protokoll","Datenbank-Kern","Transaktionen und Indizes sichern den Weg.",q("SQL-Befehl zum Lesen?","SELECT","SEL"),q("Index mit eindeutigen Werten?","UNIQUE","UNQ"),q("Transaktion zurücknehmen?","ROLLBACK","RB"));
+  add("blackout-protokoll","Zero-Trust-Schleuse","Jeder Zugriff muss erneut bewiesen werden.",q("Zero-Trust-Grundsatz: never trust, always?","verify","VERIFY"),q("Netze in kleine Zonen teilen?","Microsegmentation","MICRO"),q("Zugriffsentscheidung anhand von Rollen?","RBAC","RBAC"));
+ }
+ private Q q(String p,String a,String f){return new Q(p,a,f);}
+ private void add(String slug,String title,String intro,Q...qs)throws Exception{EscapeScenario s=repo.findBySlug(slug).orElse(null);if(s==null||s.getRooms().stream().anyMatch(r->r.getTitle().equals(title)))return;String code=Arrays.stream(qs).map(Q::fragment).reduce("",String::concat);EscapeRoom r=new EscapeRoom(title,intro,"Setze alle Fragmente von links nach rechts ohne Leerzeichen zusammen.",code,"Die Schleuse entriegelt und gibt den nächsten Abschnitt frei.",s.getRooms().size());int i=0;for(Q q:qs){ObjectNode p=mapper.createObjectNode();p.put("instruction",q.prompt());p.putArray("solutions").add(q.answer());p.putArray("hints").add("Ordne den gesuchten Begriff dem IT-Kontext zu.").add("Der gesuchte Wert lautet: "+q.answer()+".");p.put("explanation",q.answer()+" ist die korrekte Lösung.");r.addPuzzle(new EscapePuzzle("code",q.prompt(),120,q.fragment(),i++,mapper.writeValueAsString(p)));}s.addRoom(r);repo.save(s);}
+ private record Q(String prompt,String answer,String fragment){}
+}

src/main/java/com/example/mindflux/controller/AccountRecoveryController.java

@@ -0,0 +1,75 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.service.AccountMailService;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+@Controller
+public class AccountRecoveryController {
+
+    private final AccountMailService accountMailService;
+
+    public AccountRecoveryController(AccountMailService accountMailService) {
+        this.accountMailService = accountMailService;
+    }
+
+    @GetMapping("/forgot-password")
+    public String forgotPassword() {
+        return "forgot-password";
+    }
+
+    @PostMapping("/forgot-password")
+    public String requestPasswordReset(@RequestParam String email) {
+        try {
+            accountMailService.requestPasswordReset(email);
+        } catch (RuntimeException ignored) {
+            // Die Antwort bleibt absichtlich identisch: keine E-Mail- oder Account-Informationen preisgeben.
+        }
+        // Einheitliche Antwort, damit nicht erkennbar ist, welche Adressen registriert sind.
+        return "redirect:/forgot-password?sent";
+    }
+
+    @PostMapping("/verification/resend")
+    public String resendVerification(@RequestParam String email) {
+        try {
+            accountMailService.resendVerification(email);
+        } catch (RuntimeException ignored) {
+            // Auch bei einem SMTP-Fehler keine Information über einen möglichen Account verraten.
+        }
+        return "redirect:/?verificationSent";
+    }
+
+    @GetMapping("/verify-email")
+    public String verifyEmail(@RequestParam(required = false) String token) {
+        return accountMailService.verifyEmail(token)
+                ? "redirect:/?emailVerified"
+                : "redirect:/?verificationInvalid";
+    }
+
+    @GetMapping("/reset-password")
+    public String showResetPassword(@RequestParam(required = false) String token, Model model) {
+        if (!accountMailService.isResetTokenValid(token)) {
+            return "redirect:/?resetInvalid";
+        }
+        model.addAttribute("token", token);
+        return "reset-password";
+    }
+
+    @PostMapping("/reset-password")
+    public String resetPassword(@RequestParam String token,
+                                @RequestParam String password,
+                                @RequestParam String confirmPassword) {
+        if (password.length() < 8) {
+            return "redirect:/reset-password?token=" + token + "&error=policy";
+        }
+        if (!password.equals(confirmPassword)) {
+            return "redirect:/reset-password?token=" + token + "&error=mismatch";
+        }
+        return accountMailService.resetPassword(token, password, confirmPassword)
+                ? "redirect:/?passwordReset"
+                : "redirect:/?resetInvalid";
+    }
+}

src/main/java/com/example/mindflux/controller/AdminBugHunterController.java

@@ -0,0 +1,21 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.service.BugHunterService;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.*;
+
+@Controller @RequestMapping("/admin/bughunter")
+public class AdminBugHunterController {
+    private final BugHunterService service;
+    public AdminBugHunterController(BugHunterService service) { this.service = service; }
+    @GetMapping public String list(Model model) { model.addAttribute("hunts", service.all()); return "admin/bughunter"; }
+    @PostMapping("/add") public String add(@RequestParam String title, @RequestParam String language, @RequestParam String difficulty, @RequestParam String examScope, @RequestParam(required = false) String description, @RequestParam(required = false) String briefing, @RequestParam(required = false) String consoleOutput) { Long id = service.addHunt(title, language, difficulty, examScope, description, briefing, consoleOutput); return id == null ? "redirect:/admin/bughunter" : "redirect:/admin/bughunter/" + id; }
+    @GetMapping("/{id}") public String detail(@PathVariable Long id, Model model) { model.addAttribute("hunt", service.hunt(id)); return "admin/bughunter-hunt"; }
+    @PostMapping("/{id}/files") public String addFile(@PathVariable Long id, @RequestParam String filename, @RequestParam String content) { service.addFile(id, filename, content); return "redirect:/admin/bughunter/" + id; }
+    @PostMapping("/{id}/bugs") public String addBug(@PathVariable Long id, @RequestParam(defaultValue = "100") int points, @RequestParam String payload) { service.addBug(id, points, payload); return "redirect:/admin/bughunter/" + id; }
+    @PostMapping("/{id}/toggle") public String toggle(@PathVariable Long id) { service.toggle(id); return "redirect:/admin/bughunter"; }
+    @PostMapping("/{id}/delete") public String delete(@PathVariable Long id) { service.deleteHunt(id); return "redirect:/admin/bughunter"; }
+    @PostMapping("/files/{id}/delete") public String deleteFile(@PathVariable Long id, @RequestParam Long huntId) { service.deleteFile(id); return "redirect:/admin/bughunter/" + huntId; }
+    @PostMapping("/bugs/{id}/delete") public String deleteBug(@PathVariable Long id, @RequestParam Long huntId) { service.deleteBug(id); return "redirect:/admin/bughunter/" + huntId; }
+}

src/main/java/com/example/mindflux/controller/AdminCodeEscapeController.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.controller; import com.example.mindflux.service.CodeEscapeService;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.*;
+@Controller @RequestMapping("/admin/codeescape") public class AdminCodeEscapeController {private final CodeEscapeService service;public AdminCodeEscapeController(CodeEscapeService s){service=s;}@GetMapping public String list(Model m){m.addAttribute("scenarios",service.all());return"admin/codeescape";}@PostMapping("/add")public String add(@RequestParam String title,@RequestParam String difficulty,@RequestParam String examScope,@RequestParam(required=false)String description,@RequestParam(defaultValue="900")int timeLimitSeconds){Long id=service.addScenario(title,difficulty,examScope,description,timeLimitSeconds);return"redirect:/admin/codeescape/"+id;}@GetMapping("/{id}")public String scenario(@PathVariable Long id,Model m){m.addAttribute("scenario",service.scenario(id));return"admin/codeescape-scenario";}@PostMapping("/{id}/rooms")public String room(@PathVariable Long id,@RequestParam String title,@RequestParam String intro,@RequestParam String doorPrompt,@RequestParam String doorCode,@RequestParam String successText){service.addRoom(id,title,intro,doorPrompt,doorCode,successText);return"redirect:/admin/codeescape/"+id;}@GetMapping("/rooms/{id}")public String roomPage(@PathVariable Long id,Model m){m.addAttribute("room",service.room(id));return"admin/codeescape-room";}@PostMapping("/rooms/{id}/puzzles")public String puzzle(@PathVariable Long id,@RequestParam String type,@RequestParam String prompt,@RequestParam int points,@RequestParam String codeFragment,@RequestParam String payload){service.addPuzzle(id,type,prompt,points,codeFragment,payload);return"redirect:/admin/codeescape/rooms/"+id;}@PostMapping("/{id}/toggle")public String toggle(@PathVariable Long id){service.toggle(id);return"redirect:/admin/codeescape";}@PostMapping("/{id}/delete")public String del(@PathVariable Long id){service.deleteScenario(id);return"redirect:/admin/codeescape";}@PostMapping("/rooms/{id}/delete")public String delRoom(@PathVariable Long id){var r=service.room(id);Long sid=r.getScenario().getId();service.deleteRoom(id);return"redirect:/admin/codeescape/"+sid;}@PostMapping("/puzzles/{id}/delete")public String delPuzzle(@PathVariable Long id,@RequestParam Long roomId){service.deletePuzzle(id);return"redirect:/admin/codeescape/rooms/"+roomId;}}

src/main/java/com/example/mindflux/controller/AdminUserController.java

@@ -64,12 +64,13 @@ public class AdminUserController {
     /** Direktes Zurücksetzen des Passworts eines Nutzers (Admin-Recovery, ohne E-Mail). */
     @PostMapping("/users/{id}/reset-password")
     public String resetPassword(@PathVariable Long id, @RequestParam String newPassword) {
-        if (newPassword != null && !newPassword.isBlank()) {
+        if (newPassword == null || newPassword.trim().length() < 8) {
-            User user = userService.findById(id)
+            return "redirect:/admin/users?passwordPolicy";
-                    .orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + id));
-            user.setPassword(passwordEncoder.encode(newPassword.trim()));
-            userService.save(user);
         }
+        User user = userService.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Ungültige User-ID: " + id));
+        user.setPassword(passwordEncoder.encode(newPassword.trim()));
+        userService.save(user);
         return "redirect:/admin/users";
     }
 

src/main/java/com/example/mindflux/controller/BugHunterApiController.java

@@ -0,0 +1,19 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.dto.*;
+import com.example.mindflux.service.BugHunterService;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.springframework.web.bind.annotation.*;
+import jakarta.servlet.http.HttpSession;
+import java.security.Principal;
+
+@RestController @RequestMapping("/api/bughunter")
+public class BugHunterApiController {
+    private final BugHunterService service;
+    public BugHunterApiController(BugHunterService service) { this.service = service; }
+    @GetMapping("/hunts") public JsonNode catalog(Principal principal) { return service.catalog(principal == null ? null : principal.getName()); }
+    @GetMapping("/session/{slug}") public JsonNode session(@PathVariable String slug, Principal principal, HttpSession httpSession) { return service.session(slug, principal == null ? null : principal.getName(), httpSession); }
+    @PostMapping("/reset/{slug}") public void reset(@PathVariable String slug, Principal principal) { service.reset(principal.getName(), slug); }
+    @PostMapping("/check") public JsonNode check(@RequestBody BugHunterCheckRequest request, HttpSession httpSession) { return service.check(request.getBugId(), request.getPhase(), request.isReveal(), request.getSubmission(), httpSession); }
+    @PostMapping("/finish") public BugHunterResult finish(@RequestBody BugHunterFinishRequest request, Principal principal, HttpSession httpSession) { return service.finish(principal.getName(), request, httpSession); }
+}

src/main/java/com/example/mindflux/controller/BugHunterController.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.controller;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+@Controller public class BugHunterController { @GetMapping("/bughunter") public String page() { return "bughunter"; } }

src/main/java/com/example/mindflux/controller/CodeEscapeApiController.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.controller; import com.example.mindflux.dto.*;import com.example.mindflux.service.CodeEscapeService;import com.fasterxml.jackson.databind.JsonNode;import jakarta.servlet.http.HttpSession;import org.springframework.web.bind.annotation.*;import java.security.Principal;
+@RestController @RequestMapping("/api/codeescape") public class CodeEscapeApiController {private final CodeEscapeService service;public CodeEscapeApiController(CodeEscapeService s){service=s;}@GetMapping("/scenarios")public JsonNode catalog(){return service.catalog();}@GetMapping("/session/{slug}")public JsonNode session(@PathVariable String slug,HttpSession s){return service.session(slug,s);}@PostMapping("/check")public JsonNode check(@RequestBody EscapeCheckRequest r,HttpSession s){return service.check(r.getPuzzleId(),r.isReveal(),r.getSubmission(),s);}@PostMapping("/door")public JsonNode door(@RequestBody EscapeDoorRequest r,HttpSession s){return service.door(r.getRoomId(),r.getCode(),s);}@PostMapping("/hint")public JsonNode hint(@RequestBody EscapeHintRequest r,HttpSession s){return service.hint(r.getPuzzleId(),r.getLevel(),s);}@PostMapping("/finish")public EscapeResult finish(@RequestBody EscapeFinishRequest r,Principal p,HttpSession s){return service.finish(p.getName(),r,s);}}

src/main/java/com/example/mindflux/controller/CodeEscapeController.java

@@ -0,0 +1 @@
+package com.example.mindflux.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; @Controller public class CodeEscapeController{@GetMapping("/codeescape")public String page(){return "codeescape";}}

src/main/java/com/example/mindflux/controller/DashboardController.java

@@ -6,6 +6,8 @@ import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.GetMapping;
 
 import java.security.Principal;
+import java.util.List;
+import com.example.mindflux.dto.WeeklyActivity;
 
 @Controller
 public class DashboardController {
@@ -20,6 +22,14 @@ public class DashboardController {
     public String showDashboard(Model model, Principal principal) {
         // Echte XP/Level/Streak-Werte für die Sidebar-Widgets (statt Dummy-Daten im Template).
         model.addAttribute("overall", progressService.getOverallProgress(principal.getName()));
+        WeeklyActivity weekly = progressService.getCurrentWeekActivity(principal.getName());
+        model.addAttribute("weekly", weekly != null ? weekly : emptyWeekly());
+        var topGames = progressService.getTopGames(principal.getName(), 4);
+        model.addAttribute("topGames", topGames != null ? topGames : List.of());
         return "dashboard";
     }
+
+    private WeeklyActivity emptyWeekly() {
+        return new WeeklyActivity(List.of(0, 0, 0, 0, 0, 0, 0), List.of(0, 0, 0, 0, 0, 0, 0), 0, 0);
+    }
 }

src/main/java/com/example/mindflux/controller/DummyController.java

@@ -1,13 +0,0 @@
-package com.example.mindflux.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.GetMapping;
-
-@Controller
-public class DummyController {
-
-    @GetMapping("/comingsoon")
-    public String comingSoon() {
-        return "dummy"; // verweist auf dummy.html in src/main/resources/templates
-    }
-}

src/main/java/com/example/mindflux/controller/FaviconController.java

@@ -0,0 +1,23 @@
+package com.example.mindflux.controller;
+
+import java.time.Duration;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.CacheControl;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class FaviconController {
+
+    @GetMapping(value = "/favicon.ico", produces = MediaType.IMAGE_PNG_VALUE)
+    public ResponseEntity<Resource> favicon() {
+        Resource emblem = new ClassPathResource("static/img/mindflux-emblem.png");
+        return ResponseEntity.ok()
+                .cacheControl(CacheControl.maxAge(Duration.ofDays(30)).cachePublic())
+                .body(emblem);
+    }
+}

src/main/java/com/example/mindflux/controller/GameScoreController.java

@@ -4,6 +4,7 @@ import com.example.mindflux.dto.GameStats;
 import com.example.mindflux.dto.ScoreResult;
 import com.example.mindflux.dto.ScoreSubmission;
 import com.example.mindflux.service.GameScoreService;
+import jakarta.validation.Valid;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
@@ -32,7 +33,7 @@ public class GameScoreController {
 
     @PostMapping("/{game}/scores")
     public ResponseEntity<ScoreResult> submitScore(@PathVariable String game,
-                                                   @RequestBody ScoreSubmission submission,
+                                                   @Valid @RequestBody ScoreSubmission submission,
                                                    Principal principal) {
         if (!KNOWN_GAMES.contains(game)) {
             return ResponseEntity.notFound().build();

src/main/java/com/example/mindflux/controller/NetworkerApiController.java

@@ -0,0 +1,8 @@
+package com.example.mindflux.controller;
+import com.example.mindflux.dto.*;
+import com.example.mindflux.service.NetworkerService;
+import com.fasterxml.jackson.databind.JsonNode;
+import jakarta.servlet.http.HttpSession;
+import org.springframework.web.bind.annotation.*;
+import java.security.Principal;
+@RestController @RequestMapping("/api/networker") public class NetworkerApiController { private final NetworkerService service; public NetworkerApiController(NetworkerService service){this.service=service;} @GetMapping("/catalog") public JsonNode catalog(){return service.catalog();} @GetMapping("/session/{slug}") public JsonNode session(@PathVariable String slug,HttpSession session){return service.session(slug,session);} @PostMapping("/check") public JsonNode check(@RequestBody NetworkCheckRequest request,HttpSession session){return service.check(request,session);} @PostMapping("/finish") public NetworkResult finish(@RequestBody NetworkFinishRequest request,Principal principal,HttpSession session){return service.finish(principal.getName(),request,session);} }

src/main/java/com/example/mindflux/controller/NetworkerController.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.controller;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+@Controller public class NetworkerController { @GetMapping("/networker") public String page(){return "networker";} }

src/main/java/com/example/mindflux/controller/NeuralNetApiController.java

@@ -0,0 +1,20 @@
+package com.example.mindflux.controller;
+import com.example.mindflux.service.NeuralNetService;
+import org.springframework.web.bind.annotation.*;
+import java.security.Principal;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/neuralnet")
+public class NeuralNetApiController {
+    private final NeuralNetService service;
+    public NeuralNetApiController(NeuralNetService service) { this.service=service; }
+    @GetMapping("/overview") public NeuralNetService.Overview overview(Principal p) { return service.overview(p.getName()); }
+    @PostMapping("/enable") public void enable(Principal p) { service.enable(p.getName()); }
+    @PostMapping("/requests") public void request(Principal p,@RequestBody Map<String,String> body) { service.request(p.getName(),body.get("username")); }
+    @PostMapping("/requests/{username}/accept") public void accept(Principal p,@PathVariable String username) { service.accept(p.getName(),username); }
+    @PostMapping("/requests/{username}/decline") public void decline(Principal p,@PathVariable String username) { service.decline(p.getName(),username); }
+    @DeleteMapping("/requests/{username}") public void cancel(Principal p,@PathVariable String username) { service.cancel(p.getName(),username); }
+    @GetMapping("/messages/{username}") public Object messages(Principal p,@PathVariable String username) { return service.conversation(p.getName(),username); }
+    @PostMapping("/messages") public Object send(Principal p,@RequestBody Map<String,String> body) { return service.send(p.getName(),body.get("recipient"),body.get("body")); }
+}

src/main/java/com/example/mindflux/controller/PlatformStatusController.java

@@ -0,0 +1,24 @@
+package com.example.mindflux.controller;
+
+import com.example.mindflux.dto.PlatformStatus;
+import com.example.mindflux.service.PlatformStatusService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class PlatformStatusController {
+
+    private final PlatformStatusService platformStatusService;
+
+    public PlatformStatusController(PlatformStatusService platformStatusService) {
+        this.platformStatusService = platformStatusService;
+    }
+
+    @GetMapping("/api/platform/status")
+    public ResponseEntity<PlatformStatus> status() {
+        PlatformStatus status = platformStatusService.currentStatus();
+        return ResponseEntity.status(status.ready() ? HttpStatus.OK : HttpStatus.SERVICE_UNAVAILABLE).body(status);
+    }
+}

src/main/java/com/example/mindflux/controller/ProfileController.java

@@ -2,6 +2,7 @@ package com.example.mindflux.controller;
 
 import com.example.mindflux.model.User;
 import com.example.mindflux.service.UserService;
+import com.example.mindflux.service.ProgressService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -16,17 +17,15 @@ import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
-import java.awt.Color;
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
-import java.awt.image.BufferedImage;
-import javax.imageio.ImageIO;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.security.Principal;
-import java.util.UUID;
+import java.util.List;
+import java.util.Map;
+import com.example.mindflux.dto.WeeklyActivity;
+import com.example.mindflux.service.AvatarService;
+import com.example.mindflux.service.ProfileExportService;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 
 @Controller
 public class ProfileController {
@@ -39,7 +38,14 @@ public class ProfileController {
     @Autowired
     private BCryptPasswordEncoder passwordEncoder;
 
-    private static final String UPLOAD_DIR = System.getProperty("user.dir") + "/uploads/profiles/";
+    @Autowired
+    private ProgressService progressService;
+
+    @Autowired
+    private AvatarService avatarService;
+
+    @Autowired
+    private ProfileExportService profileExportService;
 
     @GetMapping("/profile")
     public String profile(Model model, Principal principal, @RequestParam(value = "success", required = false) Boolean success) {
@@ -61,24 +67,8 @@ public class ProfileController {
         User existingUser = userService.findByUsername(username);
 
         if (existingUser != null) {
-            String profilePicture = existingUser.getProfilePicture();
+            avatarService.delete(existingUser.getProfilePicture());
-            if (profilePicture != null && !profilePicture.trim().isEmpty()) {
+            existingUser.setProfilePicture(null); // auch wenn keine Datei existierte
-                try {
-                    Path picturePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", profilePicture);
-                    if (Files.exists(picturePath)) {
-                        Files.delete(picturePath);
-                        log.info("Profilbild gelöscht: {}", picturePath.getFileName());
-                    } else {
-                        log.warn("Profilbild-Datei existiert nicht: {}", picturePath.toAbsolutePath());
-                    }
-                } catch (IOException e) {
-                    log.error("Fehler beim Löschen der Profilbild-Datei", e);
-                }
-            } else {
-                log.debug("Kein Profilbild gesetzt, nichts zu löschen.");
-            }
-
-            existingUser.setProfilePicture(null); // Wichtig: auch wenn Datei nicht existiert
             userService.save(existingUser);
         }
 
@@ -91,12 +81,28 @@ public class ProfileController {
         return "settings";
     }
 
+    /** DSGVO-Datenexport (Art. 20): alle Kontodaten als JSON-Download. */
+    @GetMapping("/profile/export")
+    public ResponseEntity<Map<String, Object>> exportData(Principal principal) {
+        Map<String, Object> data = profileExportService.export(principal.getName());
+        return ResponseEntity.ok()
+                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"mindflux-datenexport.json\"")
+                .contentType(MediaType.APPLICATION_JSON)
+                .body(data);
+    }
+
     @GetMapping("/profile/knowledge")
     public String knowledgeCenter(Model model, Principal principal) {
         String username = principal.getName();
         User user = userService.findByUsername(username);
 
         model.addAttribute("user", user);
+        model.addAttribute("overall", progressService.getOverallProgress(username));
+        WeeklyActivity weekly = progressService.getCurrentWeekActivity(username);
+        model.addAttribute("weekly", weekly != null ? weekly : new WeeklyActivity(
+                List.of(0, 0, 0, 0, 0, 0, 0), List.of(0, 0, 0, 0, 0, 0, 0), 0, 0));
+        var topGames = progressService.getTopGames(username, 3);
+        model.addAttribute("topGames", topGames != null ? topGames : List.of());
         return "knowledge";
     }
 
@@ -110,47 +116,9 @@ public class ProfileController {
         if (existingUser != null) {
             existingUser.setEmail(email); // Email aktualisieren
 
-            if (file != null && !file.isEmpty()) {
+            String newAvatar = avatarService.store(file, existingUser.getProfilePicture());
-                try {
+            if (newAvatar != null) {
-                    BufferedImage original = ImageIO.read(file.getInputStream());
+                existingUser.setProfilePicture(newAvatar);
-                    if (original == null) {
-                        // Keine lesbare Bilddatei -> Upload ignorieren, restliches Profil trotzdem speichern.
-                        log.warn("Profilbild-Upload ignoriert: keine lesbare Bilddatei.");
-                    } else {
-                        // Auf max. Kantenlänge herunterskalieren (kein Hochskalieren).
-                        final int MAX_DIM = 400;
-                        int w = original.getWidth();
-                        int h = original.getHeight();
-                        double scale = Math.min(1.0, (double) MAX_DIM / Math.max(w, h));
-                        int nw = Math.max(1, (int) Math.round(w * scale));
-                        int nh = Math.max(1, (int) Math.round(h * scale));
-
-                        BufferedImage scaled = new BufferedImage(nw, nh, BufferedImage.TYPE_INT_RGB);
-                        Graphics2D g = scaled.createGraphics();
-                        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-                        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
-                        g.setColor(Color.WHITE); // JPEG kennt kein Alpha -> Transparenz auf weißem Grund
-                        g.fillRect(0, 0, nw, nh);
-                        g.drawImage(original, 0, 0, nw, nh, null);
-                        g.dispose();
-
-                        // Altes Profilbild löschen (falls vorhanden)
-                        if (existingUser.getProfilePicture() != null && !existingUser.getProfilePicture().isEmpty()) {
-                            Path oldFilePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", existingUser.getProfilePicture());
-                            Files.deleteIfExists(oldFilePath);
-                        }
-
-                        // Normalisiert als JPEG speichern
-                        String fileName = UUID.randomUUID() + ".jpg";
-                        Path uploadPath = Paths.get(UPLOAD_DIR);
-                        Files.createDirectories(uploadPath);
-                        ImageIO.write(scaled, "jpg", uploadPath.resolve(fileName).toFile());
-
-                        existingUser.setProfilePicture(fileName);
-                    }
-                } catch (IOException e) {
-                    log.error("Fehler beim Speichern des Profilbilds", e);
-                }
             }
 
             userService.save(existingUser);
@@ -191,15 +159,7 @@ public class ProfileController {
         // Profilbild-Datei von der Platte entfernen (DB-Daten löscht der Service in einer Transaktion).
         User user = userService.findByUsername(username);
         if (user != null) {
-            String profilePicture = user.getProfilePicture();
+            avatarService.delete(user.getProfilePicture());
-            if (profilePicture != null && !profilePicture.trim().isEmpty()) {
-                try {
-                    Path picturePath = Paths.get(System.getProperty("user.dir"), "uploads", "profiles", profilePicture);
-                    Files.deleteIfExists(picturePath);
-                } catch (IOException e) {
-                    log.error("Fehler beim Löschen des Profilbilds", e);
-                }
-            }
         }
 
         userService.deleteByUsername(username);

src/main/java/com/example/mindflux/controller/ProgressController.java

@@ -11,6 +11,7 @@ import org.springframework.web.bind.annotation.GetMapping;
 
 import java.security.Principal;
 import java.util.List;
+import com.example.mindflux.dto.WeeklyActivity;
 
 @Controller
 public class ProgressController {
@@ -41,6 +42,9 @@ public class ProgressController {
         }
 
         model.addAttribute("gameProgress", games != null ? games : List.of()); // leere Liste, falls null
+        WeeklyActivity weekly = progressService.getCurrentWeekActivity(username);
+        model.addAttribute("weekly", weekly != null ? weekly : new WeeklyActivity(
+                List.of(0, 0, 0, 0, 0, 0, 0), List.of(0, 0, 0, 0, 0, 0, 0), 0, 0));
 
         return "progress"; // ruft progress.html auf
     }

src/main/java/com/example/mindflux/controller/RegisterController.java

@@ -18,8 +18,8 @@ public class RegisterController {
 
     @GetMapping("/register")
     public String showRegistrationForm() {
-        // Die eigenständige Registrierungsseite wurde entfernt – das Formular lebt auf der Startseite.
+        // Das Formular lebt auf der Startseite, muss dort aber im Registrierungsmodus erscheinen.
-        return "redirect:/";
+        return "redirect:/?signup";
     }
 
     @PostMapping("/register")
@@ -29,10 +29,13 @@ public class RegisterController {
                                       @RequestParam(required = false) String confirmPassword) {
         RegistrationResult result = userService.register(username, email, password, confirmPassword);
         return switch (result) {
+            // Ein SMTP-Problem darf die Nutzung eines neu angelegten Accounts nicht blockieren.
+            // Die E-Mail-Adresse wird weiterhin für den Passwort-Reset gespeichert.
             case SUCCESS -> "redirect:/?registerSuccess";
             case PASSWORD_MISMATCH -> "redirect:/?passwordMismatch";
             case PASSWORD_TOO_SHORT -> "redirect:/?passwordPolicy";
             case EMAIL_INVALID -> "redirect:/?emailInvalid";
+            case EMAIL_TAKEN -> "redirect:/?emailTaken";
             case USERNAME_INVALID, USERNAME_TAKEN -> "redirect:/?registerError";
         };
     }

src/main/java/com/example/mindflux/controller/ServiceClashApiController.java

@@ -0,0 +1,3 @@
+package com.example.mindflux.controller;
+import com.example.mindflux.dto.*; import com.example.mindflux.service.ServiceClashService; import com.fasterxml.jackson.databind.JsonNode; import jakarta.servlet.http.HttpSession; import java.security.Principal; import org.springframework.web.bind.annotation.*;
+@RestController @RequestMapping("/api/serviceclash") public class ServiceClashApiController {private final ServiceClashService service;public ServiceClashApiController(ServiceClashService service){this.service=service;}@GetMapping("/catalog") public JsonNode catalog(){return service.catalog();}@GetMapping("/session/{slug}") public JsonNode session(@PathVariable String slug,HttpSession http){return service.session(slug,http);}@PostMapping("/check") public JsonNode check(@RequestBody ServiceClashCheckRequest request,HttpSession http){return service.check(request,http);}@PostMapping("/finish") public ServiceClashResult finish(@RequestBody ServiceClashFinishRequest request,Principal principal,HttpSession http){return service.finish(principal.getName(),request,http);}}

src/main/java/com/example/mindflux/controller/ServiceClashController.java

@@ -0,0 +1,3 @@
+package com.example.mindflux.controller;
+import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping;
+@Controller public class ServiceClashController { @GetMapping("/serviceclash") public String page(){return "serviceclash";} }

src/main/java/com/example/mindflux/controller/TechtacularApiController.java

@@ -7,12 +7,16 @@ import org.springframework.web.bind.annotation.*;
 import java.security.Principal;
 import java.util.HashSet;
 import java.util.Set;
+import jakarta.servlet.http.HttpSession;
 
 /** Spieler-API für TechTacular: Board laden, Antwort prüfen, Runde abschließen. */
 @RestController
 @RequestMapping("/api/techtacular")
 public class TechtacularApiController {
 
+    private static final String JOKER_USED = "techtacular.fiftyFiftyUsed";
+    private static final String HINTED_QUESTION_IDS = "techtacular.hintedQuestionIds";
+
     private final TechtacularService techtacularService;
 
     public TechtacularApiController(TechtacularService techtacularService) {
@@ -21,7 +25,10 @@ public class TechtacularApiController {
 
     /** exclude = komma-separierte Frage-IDs der Vorrunde, die möglichst nicht erneut kommen sollen. */
     @GetMapping("/board")
-    public TechtacularBoardView board(@RequestParam(required = false) String exclude) {
+    public TechtacularBoardView board(@RequestParam(required = false) String exclude, HttpSession session) {
+        // Ein neues Board beginnt immer eine neue Runde mit genau einem Joker.
+        session.removeAttribute(JOKER_USED);
+        session.removeAttribute(HINTED_QUESTION_IDS);
         return techtacularService.buildBoard(parseIds(exclude));
     }
 
@@ -40,12 +47,41 @@ public class TechtacularApiController {
     }
 
     @PostMapping("/answer")
-    public AnswerResult answer(@RequestBody AnswerRequest request) {
+    public AnswerResult answer(@RequestBody AnswerRequest request, HttpSession session) {
-        return techtacularService.checkAnswer(request.getQuestionId(), request.getAnswerId());
+        // Das Client-Flag dient der UI und dem Finish-Payload. Ob die Punkte halbiert
+        // werden, entscheidet jedoch allein der serverseitige Rundenzustand.
+        boolean validHint = hintedQuestionIds(session).contains(request.getQuestionId());
+        return techtacularService.checkAnswer(request.getQuestionId(), request.getAnswerId(), validHint);
+    }
+
+    /** Liefert zwei eliminierbare, garantiert falsche Antworten ohne die Loesung offenzulegen. */
+    @GetMapping("/hint")
+    public FiftyFiftyHint hint(@RequestParam Long questionId, HttpSession session) {
+        if (Boolean.TRUE.equals(session.getAttribute(JOKER_USED))) {
+            return new FiftyFiftyHint(java.util.List.of());
+        }
+
+        FiftyFiftyHint hint = techtacularService.fiftyFifty(questionId);
+        if (!hint.removeAnswerIds().isEmpty()) {
+            session.setAttribute(JOKER_USED, true);
+            Set<Long> hinted = new HashSet<>();
+            hinted.add(questionId);
+            session.setAttribute(HINTED_QUESTION_IDS, hinted);
+        }
+        return hint;
     }
 
     @PostMapping("/finish")
-    public TechtacularResult finish(@RequestBody FinishRequest request, Principal principal) {
+    public TechtacularResult finish(@RequestBody FinishRequest request, Principal principal, HttpSession session) {
-        return techtacularService.finish(principal.getName(), request);
+        TechtacularResult result = techtacularService.finish(principal.getName(), request, hintedQuestionIds(session));
+        session.removeAttribute(JOKER_USED);
+        session.removeAttribute(HINTED_QUESTION_IDS);
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    private Set<Long> hintedQuestionIds(HttpSession session) {
+        Object value = session.getAttribute(HINTED_QUESTION_IDS);
+        return value instanceof Set<?> ? (Set<Long>) value : Set.of();
     }
 }

src/main/java/com/example/mindflux/dto/AnswerRequest.java

@@ -4,10 +4,15 @@ package com.example.mindflux.dto;
 public class AnswerRequest {
     private Long questionId;
     private Long answerId;
+    private boolean hintUsed;
 
     public Long getQuestionId() { return questionId; }
     public void setQuestionId(Long questionId) { this.questionId = questionId; }
 
     public Long getAnswerId() { return answerId; }
     public void setAnswerId(Long answerId) { this.answerId = answerId; }
+
+    /** Der Client zeigt damit an, dass fuer diese Antwort der 50:50-Joker aktiv war. */
+    public boolean isHintUsed() { return hintUsed; }
+    public void setHintUsed(boolean hintUsed) { this.hintUsed = hintUsed; }
 }

src/main/java/com/example/mindflux/dto/BugHunterCheckRequest.java

@@ -0,0 +1,14 @@
+package com.example.mindflux.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+public class BugHunterCheckRequest {
+    private Long bugId;
+    private String phase;
+    private boolean reveal;
+    private JsonNode submission;
+    public Long getBugId() { return bugId; } public void setBugId(Long value) { bugId = value; }
+    public String getPhase() { return phase; } public void setPhase(String value) { phase = value; }
+    public boolean isReveal() { return reveal; } public void setReveal(boolean value) { reveal = value; }
+    public JsonNode getSubmission() { return submission; } public void setSubmission(JsonNode value) { submission = value; }
+}

src/main/java/com/example/mindflux/dto/BugHunterFinishRequest.java

@@ -0,0 +1,32 @@
+package com.example.mindflux.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.List;
+
+/** Rohantworten eines BugHunter-Durchlaufs; die Wertung wird komplett serverseitig rekonstruiert. */
+public class BugHunterFinishRequest {
+    private String slug;
+    private int durationSeconds;
+    private List<Item> items;
+    public String getSlug() { return slug; } public void setSlug(String value) { slug = value; }
+    public int getDurationSeconds() { return durationSeconds; } public void setDurationSeconds(int value) { durationSeconds = value; }
+    public List<Item> getItems() { return items; } public void setItems(List<Item> value) { items = value; }
+    public static class Item {
+        private Long bugId;
+        private Phase locate;
+        private Phase classify;
+        private Phase fix;
+        public Long getBugId() { return bugId; } public void setBugId(Long value) { bugId = value; }
+        public Phase getLocate() { return locate; } public void setLocate(Phase value) { locate = value; }
+        public Phase getClassify() { return classify; } public void setClassify(Phase value) { classify = value; }
+        public Phase getFix() { return fix; } public void setFix(Phase value) { fix = value; }
+    }
+    public static class Phase {
+        private JsonNode submission;
+        private int attempts;
+        private boolean revealed;
+        public JsonNode getSubmission() { return submission; } public void setSubmission(JsonNode value) { submission = value; }
+        public int getAttempts() { return attempts; } public void setAttempts(int value) { attempts = value; }
+        public boolean isRevealed() { return revealed; } public void setRevealed(boolean value) { revealed = value; }
+    }
+}

src/main/java/com/example/mindflux/dto/BugHunterResult.java

@@ -0,0 +1,5 @@
+package com.example.mindflux.dto;
+
+public record BugHunterResult(int score, int baseScore, int maxScore, int comboBonus, int maxCombo,
+                              int bugsSolved, int totalBugs, int stars, int highscore,
+                              boolean newHighscore, long plays, boolean cleanSolve) { }

src/main/java/com/example/mindflux/dto/EscapeCheckRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; import com.fasterxml.jackson.databind.JsonNode; public class EscapeCheckRequest {private Long puzzleId;private boolean reveal;private JsonNode submission;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public boolean isReveal(){return reveal;}public void setReveal(boolean v){reveal=v;}public JsonNode getSubmission(){return submission;}public void setSubmission(JsonNode v){submission=v;}}

src/main/java/com/example/mindflux/dto/EscapeDoorRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public class EscapeDoorRequest {private Long roomId;private String code;public Long getRoomId(){return roomId;}public void setRoomId(Long v){roomId=v;}public String getCode(){return code;}public void setCode(String v){code=v;}}

src/main/java/com/example/mindflux/dto/EscapeFinishRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; import com.fasterxml.jackson.databind.JsonNode; import java.util.*; public class EscapeFinishRequest {private String slug;private int durationSeconds;private boolean escaped;private List<Item> items=new ArrayList<>();private List<Door> doors=new ArrayList<>();public String getSlug(){return slug;}public void setSlug(String v){slug=v;}public int getDurationSeconds(){return durationSeconds;}public void setDurationSeconds(int v){durationSeconds=v;}public boolean isEscaped(){return escaped;}public void setEscaped(boolean v){escaped=v;}public List<Item> getItems(){return items;}public void setItems(List<Item> v){items=v;}public List<Door> getDoors(){return doors;}public void setDoors(List<Door> v){doors=v;}public static class Item{private Long puzzleId;private JsonNode submission;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public JsonNode getSubmission(){return submission;}public void setSubmission(JsonNode v){submission=v;}}public static class Door{private Long roomId;private String code;public Long getRoomId(){return roomId;}public void setRoomId(Long v){roomId=v;}public String getCode(){return code;}public void setCode(String v){code=v;}}}

src/main/java/com/example/mindflux/dto/EscapeHintRequest.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public class EscapeHintRequest {private Long puzzleId;private int level;public Long getPuzzleId(){return puzzleId;}public void setPuzzleId(Long v){puzzleId=v;}public int getLevel(){return level;}public void setLevel(int v){level=v;}}

src/main/java/com/example/mindflux/dto/EscapeResult.java

@@ -0,0 +1 @@
+package com.example.mindflux.dto; public record EscapeResult(int score,int baseScore,int maxScore,int timeBonus,int solvedPuzzles,int roomsOpened,boolean escaped,int stars,int highscore,boolean newHighscore,long plays){}

src/main/java/com/example/mindflux/dto/FiftyFiftyHint.java

@@ -0,0 +1,7 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/** Antwort des 50:50-Jokers. Die korrekte Antwort-ID wird niemals uebertragen. */
+public record FiftyFiftyHint(List<Long> removeAnswerIds) {
+}

src/main/java/com/example/mindflux/dto/NetworkCheckRequest.java

@@ -0,0 +1,3 @@
+package com.example.mindflux.dto;
+import com.fasterxml.jackson.databind.JsonNode;
+public class NetworkCheckRequest { private Long levelId; private boolean reveal; private JsonNode config; public Long getLevelId(){return levelId;} public void setLevelId(Long value){levelId=value;} public boolean isReveal(){return reveal;} public void setReveal(boolean value){reveal=value;} public JsonNode getConfig(){return config;} public void setConfig(JsonNode value){config=value;} }

src/main/java/com/example/mindflux/dto/NetworkFinishRequest.java

@@ -0,0 +1,3 @@
+package com.example.mindflux.dto;
+import java.util.*;
+public class NetworkFinishRequest { private String slug; private int durationSeconds; private List<Long> levelIds; public String getSlug(){return slug;} public void setSlug(String value){slug=value;} public int getDurationSeconds(){return durationSeconds;} public void setDurationSeconds(int value){durationSeconds=value;} public List<Long> getLevelIds(){return levelIds;} public void setLevelIds(List<Long> value){levelIds=value;} }

src/main/java/com/example/mindflux/dto/NetworkResult.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.dto;
+public record NetworkResult(int score, int maxScore, int solved, int total, int stars, int highscore, boolean newHighscore, long plays, boolean perfect) { }

src/main/java/com/example/mindflux/dto/PlatformStatus.java

@@ -0,0 +1,18 @@
+package com.example.mindflux.dto;
+
+import java.time.Instant;
+
+/**
+ * Ein bewusst kleiner, nachvollziehbarer Plattformzustand für das Dashboard.
+ * Er behauptet keine fiktive Verfügbarkeit, sondern prüft den Speicher, der
+ * Spielstände und Fortschritt tatsächlich trägt.
+ */
+public record PlatformStatus(
+        boolean storageConnected,
+        int registeredModules,
+        Instant checkedAt
+) {
+    public boolean ready() {
+        return storageConnected;
+    }
+}

src/main/java/com/example/mindflux/dto/ScoreSubmission.java

@@ -1,14 +1,24 @@
 package com.example.mindflux.dto;
 
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
 /**
  * Was der Client nach einem abgeschlossenen Spiel sendet. Der Score wird
  * bewusst NICHT mitgeschickt, sondern serverseitig aus diesen Rohwerten
  * berechnet, damit ein manipulierter Client keinen Fantasie-Score speichern kann.
+ * Die Constraints fangen offensichtlich unsinnige Eingaben schon vor der Logik ab.
  */
 public class ScoreSubmission {
+    @NotBlank @Size(max = 100)
     private String deck;
+    @Min(0) @Max(1000)
     private int pairs;
+    @Min(0) @Max(100000)
     private int moves;
+    @Min(0) @Max(86400)
     private int durationSeconds;
 
     public String getDeck() { return deck; }

src/main/java/com/example/mindflux/dto/ServiceClashCheckRequest.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.dto;
+public class ServiceClashCheckRequest { private Long ticketId; private String step; private String value; private boolean reveal; public Long getTicketId(){return ticketId;} public void setTicketId(Long value){ticketId=value;} public String getStep(){return step;} public void setStep(String value){step=value;} public String getValue(){return value;} public void setValue(String value){this.value=value;} public boolean isReveal(){return reveal;} public void setReveal(boolean value){reveal=value;} }

src/main/java/com/example/mindflux/dto/ServiceClashFinishRequest.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.dto;
+public class ServiceClashFinishRequest { private String slug; private int durationSeconds; public String getSlug(){return slug;} public void setSlug(String value){slug=value;} public int getDurationSeconds(){return durationSeconds;} public void setDurationSeconds(int value){durationSeconds=value;} }

src/main/java/com/example/mindflux/dto/ServiceClashResult.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.dto;
+public record ServiceClashResult(int score,int maxScore,int stars,int resolved,int total,int health,int highscore,boolean newHighscore,long plays,boolean flawless) { }

src/main/java/com/example/mindflux/dto/WeeklyActivity.java

@@ -0,0 +1,7 @@
+package com.example.mindflux.dto;
+
+import java.util.List;
+
+/** Tatsächlich aufgezeichnete Aktivität von Montag bis Sonntag. */
+public record WeeklyActivity(List<Integer> minutes, List<Integer> xp, int totalMinutes, int totalXp) {
+}

src/main/java/com/example/mindflux/model/AccountEmailToken.java

@@ -0,0 +1,43 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.time.Instant;
+
+@Entity
+@Table(name = "account_email_tokens")
+public class AccountEmailToken {
+    public enum Purpose { EMAIL_VERIFICATION, PASSWORD_RESET }
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(optional = false, fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @Column(name = "token_hash", nullable = false, unique = true, length = 64)
+    private String tokenHash;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false, length = 32)
+    private Purpose purpose;
+
+    @Column(name = "expires_at", nullable = false)
+    private Instant expiresAt;
+
+    @Column(name = "consumed_at")
+    private Instant consumedAt;
+
+    public Long getId() { return id; }
+    public User getUser() { return user; }
+    public void setUser(User user) { this.user = user; }
+    public String getTokenHash() { return tokenHash; }
+    public void setTokenHash(String tokenHash) { this.tokenHash = tokenHash; }
+    public Purpose getPurpose() { return purpose; }
+    public void setPurpose(Purpose purpose) { this.purpose = purpose; }
+    public Instant getExpiresAt() { return expiresAt; }
+    public void setExpiresAt(Instant expiresAt) { this.expiresAt = expiresAt; }
+    public Instant getConsumedAt() { return consumedAt; }
+    public void setConsumedAt(Instant consumedAt) { this.consumedAt = consumedAt; }
+}

src/main/java/com/example/mindflux/model/BugHunterBug.java

@@ -0,0 +1,19 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+@Entity @Table(name = "bughunter_bugs")
+public class BugHunterBug {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "hunt_id", nullable = false) private BugHunterHunt hunt;
+    private int points = 100;
+    @Column(name = "sort_order") private int sortOrder;
+    @Column(length = 8000) private String payload;
+    public BugHunterBug() { }
+    public BugHunterBug(int points, int sortOrder, String payload) { this.points = points; this.sortOrder = sortOrder; this.payload = payload; }
+    public Long getId() { return id; } public void setId(Long value) { id = value; }
+    public BugHunterHunt getHunt() { return hunt; } public void setHunt(BugHunterHunt value) { hunt = value; }
+    public int getPoints() { return points; } public void setPoints(int value) { points = value; }
+    public int getSortOrder() { return sortOrder; } public void setSortOrder(int value) { sortOrder = value; }
+    public String getPayload() { return payload; } public void setPayload(String value) { payload = value; }
+}

src/main/java/com/example/mindflux/model/BugHunterFile.java

@@ -0,0 +1,19 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+@Entity @Table(name = "bughunter_files")
+public class BugHunterFile {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "hunt_id", nullable = false) private BugHunterHunt hunt;
+    private String filename;
+    @Column(length = 8000) private String content;
+    @Column(name = "sort_order") private int sortOrder;
+    public BugHunterFile() { }
+    public BugHunterFile(String filename, String content, int sortOrder) { this.filename = filename; this.content = content; this.sortOrder = sortOrder; }
+    public Long getId() { return id; } public void setId(Long value) { id = value; }
+    public BugHunterHunt getHunt() { return hunt; } public void setHunt(BugHunterHunt value) { hunt = value; }
+    public String getFilename() { return filename; } public void setFilename(String value) { filename = value; }
+    public String getContent() { return content; } public void setContent(String value) { content = value; }
+    public int getSortOrder() { return sortOrder; } public void setSortOrder(int value) { sortOrder = value; }
+}

src/main/java/com/example/mindflux/model/BugHunterHunt.java

@@ -0,0 +1,45 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.*;
+
+@Entity @Table(name = "bughunter_hunts")
+public class BugHunterHunt {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @Column(nullable = false, unique = true) private String slug;
+    @Column(nullable = false) private String title;
+    @Column(name = "code_language") private String codeLanguage;
+    private String difficulty;
+    @Column(name = "exam_scope") private String examScope = "AP1";
+    private String description;
+    @Column(length = 2000) private String briefing;
+    @Column(name = "console_output", length = 4000) private String consoleOutput;
+    @Column(name = "sort_order") private int sortOrder;
+    private boolean active = true;
+    @OneToMany(mappedBy = "hunt", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("sortOrder ASC, id ASC") private List<BugHunterFile> files = new ArrayList<>();
+    @OneToMany(mappedBy = "hunt", cascade = CascadeType.ALL, orphanRemoval = true)
+    @OrderBy("sortOrder ASC, id ASC") private List<BugHunterBug> bugs = new ArrayList<>();
+
+    public BugHunterHunt() { }
+    public BugHunterHunt(String slug, String title, String codeLanguage, String difficulty, String examScope,
+                         String description, String briefing, String consoleOutput, int sortOrder) {
+        this.slug = slug; this.title = title; this.codeLanguage = codeLanguage; this.difficulty = difficulty;
+        this.examScope = examScope; this.description = description; this.briefing = briefing;
+        this.consoleOutput = consoleOutput; this.sortOrder = sortOrder;
+    }
+    public void addFile(BugHunterFile file) { file.setHunt(this); files.add(file); }
+    public void addBug(BugHunterBug bug) { bug.setHunt(this); bugs.add(bug); }
+    public Long getId() { return id; } public void setId(Long id) { this.id = id; }
+    public String getSlug() { return slug; } public void setSlug(String slug) { this.slug = slug; }
+    public String getTitle() { return title; } public void setTitle(String title) { this.title = title; }
+    public String getCodeLanguage() { return codeLanguage; } public void setCodeLanguage(String value) { codeLanguage = value; }
+    public String getDifficulty() { return difficulty; } public void setDifficulty(String value) { difficulty = value; }
+    public String getExamScope() { return examScope; } public void setExamScope(String value) { examScope = value; }
+    public String getDescription() { return description; } public void setDescription(String value) { description = value; }
+    public String getBriefing() { return briefing; } public void setBriefing(String value) { briefing = value; }
+    public String getConsoleOutput() { return consoleOutput; } public void setConsoleOutput(String value) { consoleOutput = value; }
+    public int getSortOrder() { return sortOrder; } public void setSortOrder(int value) { sortOrder = value; }
+    public boolean isActive() { return active; } public void setActive(boolean value) { active = value; }
+    public List<BugHunterFile> getFiles() { return files; } public List<BugHunterBug> getBugs() { return bugs; }
+}

src/main/java/com/example/mindflux/model/BugHunterHuntProgress.java

@@ -0,0 +1,27 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "bughunter_hunt_progress", uniqueConstraints = @UniqueConstraint(columnNames = {"username", "hunt_slug"}))
+public class BugHunterHuntProgress {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @Column(nullable = false) private String username;
+    @Column(name = "hunt_slug", nullable = false) private String huntSlug;
+    @Column(name = "solved_clean", nullable = false) private boolean solvedClean;
+    @Column(name = "variant_index", nullable = false) private int variantIndex;
+    @Column(name = "solved_at") private LocalDateTime solvedAt;
+
+    public BugHunterHuntProgress() { }
+    public BugHunterHuntProgress(String username, String huntSlug) { this.username = username; this.huntSlug = huntSlug; }
+    public Long getId() { return id; }
+    public String getUsername() { return username; }
+    public String getHuntSlug() { return huntSlug; }
+    public boolean isSolvedClean() { return solvedClean; }
+    public void setSolvedClean(boolean value) { solvedClean = value; }
+    public int getVariantIndex() { return variantIndex; }
+    public void setVariantIndex(int value) { variantIndex = value; }
+    public LocalDateTime getSolvedAt() { return solvedAt; }
+    public void setSolvedAt(LocalDateTime value) { solvedAt = value; }
+}

src/main/java/com/example/mindflux/model/EscapePuzzle.java

@@ -0,0 +1,7 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*;
+@Entity @Table(name="escape_puzzles") public class EscapePuzzle {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="room_id") private EscapeRoom room;
+ @Column(name="puzzle_type") private String type; private String prompt; private int points=100; @Column(name="code_fragment") private String codeFragment; @Column(name="sort_order") private int sortOrder; private String payload;
+ public EscapePuzzle(){} public EscapePuzzle(String t,String p,int pts,String f,int o,String j){type=t;prompt=p;points=pts;codeFragment=f;sortOrder=o;payload=j;} public Long getId(){return id;} public void setId(Long v){id=v;} public EscapeRoom getRoom(){return room;} public void setRoom(EscapeRoom v){room=v;} public String getType(){return type;} public void setType(String v){type=v;} public String getPrompt(){return prompt;} public void setPrompt(String v){prompt=v;} public int getPoints(){return points;} public void setPoints(int v){points=v;} public String getCodeFragment(){return codeFragment;} public void setCodeFragment(String v){codeFragment=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public String getPayload(){return payload;} public void setPayload(String v){payload=v;}
+}

src/main/java/com/example/mindflux/model/EscapeRoom.java

@@ -0,0 +1,9 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*; import java.util.*;
+@Entity @Table(name="escape_rooms")
+public class EscapeRoom {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id; @ManyToOne(fetch=FetchType.LAZY) @JoinColumn(name="scenario_id") private EscapeScenario scenario;
+ private String title; private String intro; @Column(name="door_prompt") private String doorPrompt; @Column(name="door_code") private String doorCode; @Column(name="success_text") private String successText; @Column(name="sort_order") private int sortOrder;
+ @OneToMany(mappedBy="room",cascade=CascadeType.ALL,orphanRemoval=true) @OrderBy("sortOrder ASC, id ASC") private List<EscapePuzzle> puzzles=new ArrayList<>();
+ public EscapeRoom(){} public EscapeRoom(String t,String i,String p,String c,String s,int o){title=t;intro=i;doorPrompt=p;doorCode=c;successText=s;sortOrder=o;} public void addPuzzle(EscapePuzzle p){p.setRoom(this);puzzles.add(p);} public Long getId(){return id;} public void setId(Long v){id=v;} public EscapeScenario getScenario(){return scenario;} public void setScenario(EscapeScenario v){scenario=v;} public String getTitle(){return title;} public void setTitle(String v){title=v;} public String getIntro(){return intro;} public void setIntro(String v){intro=v;} public String getDoorPrompt(){return doorPrompt;} public void setDoorPrompt(String v){doorPrompt=v;} public String getDoorCode(){return doorCode;} public void setDoorCode(String v){doorCode=v;} public String getSuccessText(){return successText;} public void setSuccessText(String v){successText=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public List<EscapePuzzle> getPuzzles(){return puzzles;}
+}

src/main/java/com/example/mindflux/model/EscapeScenario.java

@@ -0,0 +1,13 @@
+package com.example.mindflux.model;
+import jakarta.persistence.*; import java.util.*;
+@Entity @Table(name="escape_scenarios")
+public class EscapeScenario {
+ @Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Long id;
+ @Column(unique=true,nullable=false) private String slug; private String title; private String difficulty;
+ @Column(name="exam_scope") private String examScope="AP1"; private String description;
+ @Column(name="time_limit_seconds") private int timeLimitSeconds=900;
+ @Column(name="sort_order") private int sortOrder; private boolean active=true;
+ @OneToMany(mappedBy="scenario",cascade=CascadeType.ALL,orphanRemoval=true) @OrderBy("sortOrder ASC, id ASC") private List<EscapeRoom> rooms=new ArrayList<>();
+ public EscapeScenario(){} public EscapeScenario(String slug,String title,String difficulty,String examScope,String description,int limit,int order){this.slug=slug;this.title=title;this.difficulty=difficulty;this.examScope=examScope;this.description=description;this.timeLimitSeconds=limit;this.sortOrder=order;}
+ public void addRoom(EscapeRoom r){r.setScenario(this);rooms.add(r);} public Long getId(){return id;} public void setId(Long v){id=v;} public String getSlug(){return slug;} public void setSlug(String v){slug=v;} public String getTitle(){return title;} public void setTitle(String v){title=v;} public String getDifficulty(){return difficulty;} public void setDifficulty(String v){difficulty=v;} public String getExamScope(){return examScope;} public void setExamScope(String v){examScope=v;} public String getDescription(){return description;} public void setDescription(String v){description=v;} public int getTimeLimitSeconds(){return timeLimitSeconds;} public void setTimeLimitSeconds(int v){timeLimitSeconds=v;} public int getSortOrder(){return sortOrder;} public void setSortOrder(int v){sortOrder=v;} public boolean isActive(){return active;} public void setActive(boolean v){active=v;} public List<EscapeRoom> getRooms(){return rooms;}
+}

src/main/java/com/example/mindflux/model/NetworkLevel.java

@@ -0,0 +1,17 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+@Entity @Table(name = "networker_levels")
+public class NetworkLevel {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "world_id", nullable = false) private NetworkWorld world;
+    @Column(nullable = false) private String title;
+    @Column(name = "level_type") private String levelType;
+    private int points;
+    @Column(name = "sort_order") private int sortOrder;
+    @Column(length = 8000, nullable = false) private String payload;
+    public NetworkLevel() { }
+    public NetworkLevel(String title, String levelType, int points, int sortOrder, String payload) { this.title=title; this.levelType=levelType; this.points=points; this.sortOrder=sortOrder; this.payload=payload; }
+    public Long getId(){return id;} public void setId(Long value){id=value;} public NetworkWorld getWorld(){return world;} public void setWorld(NetworkWorld value){world=value;} public String getTitle(){return title;} public String getLevelType(){return levelType;} public int getPoints(){return points;} public int getSortOrder(){return sortOrder;} public String getPayload(){return payload;}
+}

src/main/java/com/example/mindflux/model/NetworkWorld.java

@@ -0,0 +1,21 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.*;
+
+@Entity @Table(name = "networker_worlds")
+public class NetworkWorld {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @Column(nullable = false, unique = true) private String slug;
+    @Column(nullable = false) private String title;
+    private String description;
+    private String difficulty;
+    @Column(name = "exam_scope") private String examScope;
+    @Column(name = "sort_order") private int sortOrder;
+    private boolean active = true;
+    @OneToMany(mappedBy = "world", cascade = CascadeType.ALL, orphanRemoval = true) @OrderBy("sortOrder ASC, id ASC") private List<NetworkLevel> levels = new ArrayList<>();
+    public NetworkWorld() { }
+    public NetworkWorld(String slug, String title, String description, String difficulty, String examScope, int sortOrder) { this.slug=slug; this.title=title; this.description=description; this.difficulty=difficulty; this.examScope=examScope; this.sortOrder=sortOrder; }
+    public void addLevel(NetworkLevel level) { level.setWorld(this); levels.add(level); }
+    public Long getId(){return id;} public void setId(Long value){id=value;} public String getSlug(){return slug;} public String getTitle(){return title;} public String getDescription(){return description;} public String getDifficulty(){return difficulty;} public String getExamScope(){return examScope;} public int getSortOrder(){return sortOrder;} public boolean isActive(){return active;} public void setActive(boolean value){active=value;} public List<NetworkLevel> getLevels(){return levels;}
+}

src/main/java/com/example/mindflux/model/NeuralNetConnection.java

@@ -0,0 +1,21 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "neuralnet_connections")
+public class NeuralNetConnection {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    private String requester;
+    private String addressee;
+    private String status;
+    @Column(name = "created_at") private LocalDateTime createdAt;
+    @Column(name = "responded_at") private LocalDateTime respondedAt;
+    public NeuralNetConnection() {}
+    public NeuralNetConnection(String requester, String addressee) { this.requester=requester; this.addressee=addressee; this.status="PENDING"; this.createdAt=LocalDateTime.now(); }
+    public Long getId() { return id; } public String getRequester() { return requester; } public String getAddressee() { return addressee; }
+    public String getStatus() { return status; } public void setStatus(String status) { this.status=status; }
+    public LocalDateTime getCreatedAt() { return createdAt; } public LocalDateTime getRespondedAt() { return respondedAt; }
+    public void setRespondedAt(LocalDateTime respondedAt) { this.respondedAt=respondedAt; }
+}

src/main/java/com/example/mindflux/model/NeuralNetMessage.java

@@ -0,0 +1,21 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "neuralnet_messages")
+public class NeuralNetMessage {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    private String sender;
+    private String recipient;
+    private String body;
+    @Column(name = "sent_at") private LocalDateTime sentAt;
+    @Column(name = "read_at") private LocalDateTime readAt;
+    private boolean reported;
+    public NeuralNetMessage() {}
+    public NeuralNetMessage(String sender, String recipient, String body) { this.sender=sender; this.recipient=recipient; this.body=body; this.sentAt=LocalDateTime.now(); }
+    public Long getId() { return id; } public String getSender() { return sender; } public String getRecipient() { return recipient; }
+    public String getBody() { return body; } public LocalDateTime getSentAt() { return sentAt; } public LocalDateTime getReadAt() { return readAt; }
+    public void setReadAt(LocalDateTime readAt) { this.readAt=readAt; } public boolean isReported() { return reported; } public void setReported(boolean reported) { this.reported=reported; }
+}

src/main/java/com/example/mindflux/model/NeuralNetPrivacy.java

@@ -0,0 +1,17 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "neuralnet_privacy")
+public class NeuralNetPrivacy {
+    @Id private String username;
+    private boolean enabled;
+    public NeuralNetPrivacy() {}
+    public NeuralNetPrivacy(String username, boolean enabled) { this.username = username; this.enabled = enabled; }
+    public String getUsername() { return username; }
+    public boolean isEnabled() { return enabled; }
+    public void setEnabled(boolean enabled) { this.enabled = enabled; }
+}

src/main/java/com/example/mindflux/model/ServiceClashShift.java

@@ -0,0 +1,21 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+import java.util.*;
+
+@Entity @Table(name = "service_clash_shifts")
+public class ServiceClashShift {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @Column(nullable = false, unique = true) private String slug;
+    @Column(nullable = false) private String title;
+    private String description;
+    private String difficulty;
+    @Column(name = "exam_scope") private String examScope;
+    @Column(name = "sort_order") private int sortOrder;
+    private boolean active = true;
+    @OneToMany(mappedBy = "shift", cascade = CascadeType.ALL, orphanRemoval = true) @OrderBy("wave ASC, sortOrder ASC, id ASC") private List<ServiceClashTicket> tickets = new ArrayList<>();
+    public ServiceClashShift() { }
+    public ServiceClashShift(String slug, String title, String description, String difficulty, String examScope, int sortOrder) { this.slug=slug;this.title=title;this.description=description;this.difficulty=difficulty;this.examScope=examScope;this.sortOrder=sortOrder; }
+    public void addTicket(ServiceClashTicket ticket) { ticket.setShift(this); tickets.add(ticket); }
+    public Long getId(){return id;} public void setId(Long value){id=value;} public String getSlug(){return slug;} public String getTitle(){return title;} public String getDescription(){return description;} public String getDifficulty(){return difficulty;} public String getExamScope(){return examScope;} public int getSortOrder(){return sortOrder;} public boolean isActive(){return active;} public List<ServiceClashTicket> getTickets(){return tickets;}
+}

src/main/java/com/example/mindflux/model/ServiceClashTicket.java

@@ -0,0 +1,17 @@
+package com.example.mindflux.model;
+
+import jakarta.persistence.*;
+
+@Entity @Table(name = "service_clash_tickets")
+public class ServiceClashTicket {
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
+    @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "shift_id", nullable = false) private ServiceClashShift shift;
+    @Column(nullable = false) private String title;
+    private int wave;
+    private int points;
+    @Column(name = "sort_order") private int sortOrder;
+    @Column(length = 8000, nullable = false) private String payload;
+    public ServiceClashTicket() { }
+    public ServiceClashTicket(String title,int wave,int points,int sortOrder,String payload){this.title=title;this.wave=wave;this.points=points;this.sortOrder=sortOrder;this.payload=payload;}
+    public Long getId(){return id;} public void setId(Long value){id=value;} public void setShift(ServiceClashShift value){shift=value;} public ServiceClashShift getShift(){return shift;} public String getTitle(){return title;} public int getWave(){return wave;} public int getPoints(){return points;} public String getPayload(){return payload;}
+}

src/main/java/com/example/mindflux/model/User.java

@@ -16,6 +16,9 @@ public class User {
     private String email;
     private String role;
 
+    @Column(name = "email_verified", nullable = false)
+    private boolean emailVerified = true;
+
     @Column(name = "profile_picture")
     private String profilePicture;
 
@@ -47,6 +50,9 @@ public class User {
     public String getRole()               { return role; }
     public void   setRole(String r)       { this.role = r; }
 
+    public boolean isEmailVerified()      { return emailVerified; }
+    public void setEmailVerified(boolean emailVerified) { this.emailVerified = emailVerified; }
+
     public String getProfilePicture()                  { return profilePicture; }
     public void   setProfilePicture(String pictureUrl) { this.profilePicture = pictureUrl; }
 }

src/main/java/com/example/mindflux/repository/AccountEmailTokenRepository.java

@@ -0,0 +1,14 @@
+package com.example.mindflux.repository;
+
+import com.example.mindflux.model.AccountEmailToken;
+import com.example.mindflux.model.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface AccountEmailTokenRepository extends JpaRepository<AccountEmailToken, Long> {
+    Optional<AccountEmailToken> findByTokenHashAndPurposeAndConsumedAtIsNull(
+            String tokenHash, AccountEmailToken.Purpose purpose);
+
+    void deleteByUserAndPurpose(User user, AccountEmailToken.Purpose purpose);
+}

src/main/java/com/example/mindflux/repository/BugHunterBugRepository.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.BugHunterBug;
+import org.springframework.data.jpa.repository.JpaRepository;
+public interface BugHunterBugRepository extends JpaRepository<BugHunterBug, Long> { long countByHuntId(Long huntId); }

src/main/java/com/example/mindflux/repository/BugHunterFileRepository.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.BugHunterFile;
+import org.springframework.data.jpa.repository.JpaRepository;
+public interface BugHunterFileRepository extends JpaRepository<BugHunterFile, Long> { long countByHuntId(Long huntId); }

src/main/java/com/example/mindflux/repository/BugHunterHuntProgressRepository.java

@@ -0,0 +1,10 @@
+package com.example.mindflux.repository;
+
+import com.example.mindflux.model.BugHunterHuntProgress;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.*;
+
+public interface BugHunterHuntProgressRepository extends JpaRepository<BugHunterHuntProgress, Long> {
+    Optional<BugHunterHuntProgress> findByUsernameAndHuntSlug(String username, String huntSlug);
+    List<BugHunterHuntProgress> findAllByUsername(String username);
+}

src/main/java/com/example/mindflux/repository/BugHunterHuntRepository.java

@@ -0,0 +1,10 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.BugHunterHunt;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.*;
+public interface BugHunterHuntRepository extends JpaRepository<BugHunterHunt, Long> {
+    List<BugHunterHunt> findAllByActiveTrueOrderBySortOrderAscIdAsc();
+    List<BugHunterHunt> findAllByOrderBySortOrderAscIdAsc();
+    Optional<BugHunterHunt> findBySlug(String slug);
+    boolean existsBySlug(String slug);
+}

src/main/java/com/example/mindflux/repository/EscapePuzzleRepository.java

@@ -0,0 +1 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapePuzzle; import org.springframework.data.jpa.repository.JpaRepository; public interface EscapePuzzleRepository extends JpaRepository<EscapePuzzle,Long>{long countByRoomId(Long id);}

src/main/java/com/example/mindflux/repository/EscapeRoomRepository.java

@@ -0,0 +1 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapeRoom; import org.springframework.data.jpa.repository.JpaRepository; public interface EscapeRoomRepository extends JpaRepository<EscapeRoom,Long>{long countByScenarioId(Long id);}

src/main/java/com/example/mindflux/repository/EscapeScenarioRepository.java

@@ -0,0 +1,2 @@
+package com.example.mindflux.repository; import com.example.mindflux.model.EscapeScenario; import org.springframework.data.jpa.repository.JpaRepository; import java.util.*;
+public interface EscapeScenarioRepository extends JpaRepository<EscapeScenario,Long>{List<EscapeScenario> findAllByActiveTrueOrderBySortOrderAscIdAsc();List<EscapeScenario> findAllByOrderBySortOrderAscIdAsc();Optional<EscapeScenario> findBySlug(String slug);boolean existsBySlug(String slug);}

src/main/java/com/example/mindflux/repository/GameScoreRepository.java

@@ -7,6 +7,7 @@ import org.springframework.data.repository.query.Param;
 
 import java.util.List;
 import java.util.Optional;
+import java.time.LocalDateTime;
 
 public interface GameScoreRepository extends JpaRepository<GameScore, Long> {
 
@@ -19,9 +20,16 @@ public interface GameScoreRepository extends JpaRepository<GameScore, Long> {
     /** Wie oft ein Spieler ein Spiel abgeschlossen hat. */
     long countByUsernameAndGame(String username, String game);
 
+    /** Abgeschlossene Runden eines Zeitraums – Basis für Spielzeit und Wochenverlauf. */
+    List<GameScore> findByUsernameAndPlayedAtGreaterThanEqualAndPlayedAtLessThanOrderByPlayedAtAsc(
+            String username, LocalDateTime from, LocalDateTime until);
+
     /** Alle Spielstände eines Spielers löschen (z. B. beim Löschen des Kontos). */
     void deleteByUsername(String username);
 
+    /** Alle Spielstände eines Spielers (für den DSGVO-Datenexport). */
+    List<GameScore> findByUsernameOrderByPlayedAtDesc(String username);
+
     /** Gesamtsumme aller Scores eines Spielers (XP-Basis). */
     @Query("select coalesce(sum(g.score), 0) from GameScore g where g.username = :username")
     long sumScoreByUsername(@Param("username") String username);

src/main/java/com/example/mindflux/repository/NetworkLevelRepository.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.NetworkLevel;
+import org.springframework.data.jpa.repository.JpaRepository;
+public interface NetworkLevelRepository extends JpaRepository<NetworkLevel, Long> { }

src/main/java/com/example/mindflux/repository/NetworkWorldRepository.java

@@ -0,0 +1,5 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.NetworkWorld;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.*;
+public interface NetworkWorldRepository extends JpaRepository<NetworkWorld, Long> { List<NetworkWorld> findAllByActiveTrueOrderBySortOrderAscIdAsc(); Optional<NetworkWorld> findBySlug(String slug); }

src/main/java/com/example/mindflux/repository/NeuralNetConnectionRepository.java

@@ -0,0 +1,16 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.NeuralNetConnection;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.data.repository.query.Param;
+import java.util.*;
+public interface NeuralNetConnectionRepository extends JpaRepository<NeuralNetConnection, Long> {
+    Optional<NeuralNetConnection> findByRequesterAndAddressee(String requester, String addressee);
+    List<NeuralNetConnection> findByAddresseeAndStatusOrderByCreatedAtAsc(String addressee, String status);
+    List<NeuralNetConnection> findByRequesterAndStatusOrderByCreatedAtAsc(String requester, String status);
+    @Query("select c from NeuralNetConnection c where c.status='ACCEPTED' and ((c.requester=:username) or (c.addressee=:username)) order by c.respondedAt desc")
+    List<NeuralNetConnection> acceptedFor(@Param("username") String username);
+    @Query("select c from NeuralNetConnection c where c.status='ACCEPTED' and ((c.requester=:a and c.addressee=:b) or (c.requester=:b and c.addressee=:a))")
+    Optional<NeuralNetConnection> acceptedBetween(@Param("a") String a, @Param("b") String b);
+    @Query("select c from NeuralNetConnection c where c.requester=:u or c.addressee=:u order by c.createdAt asc")
+    List<NeuralNetConnection> findAllInvolving(@Param("u") String u);
+}

src/main/java/com/example/mindflux/repository/NeuralNetMessageRepository.java

@@ -0,0 +1,12 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.NeuralNetMessage;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.data.repository.query.Param;
+import java.util.*;
+public interface NeuralNetMessageRepository extends JpaRepository<NeuralNetMessage, Long> {
+    @Query("select m from NeuralNetMessage m where (m.sender=:a and m.recipient=:b) or (m.sender=:b and m.recipient=:a) order by m.sentAt asc")
+    List<NeuralNetMessage> conversation(@Param("a") String a, @Param("b") String b);
+    long countByRecipientAndReadAtIsNull(String recipient);
+    @Query("select m from NeuralNetMessage m where m.sender=:u or m.recipient=:u order by m.sentAt asc")
+    List<NeuralNetMessage> findAllInvolving(@Param("u") String u);
+}

src/main/java/com/example/mindflux/repository/NeuralNetPrivacyRepository.java

@@ -0,0 +1,4 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.NeuralNetPrivacy;
+import org.springframework.data.jpa.repository.JpaRepository;
+public interface NeuralNetPrivacyRepository extends JpaRepository<NeuralNetPrivacy, String> {}

src/main/java/com/example/mindflux/repository/ServiceClashShiftRepository.java

@@ -0,0 +1,5 @@
+package com.example.mindflux.repository;
+import com.example.mindflux.model.ServiceClashShift;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.*;
+public interface ServiceClashShiftRepository extends JpaRepository<ServiceClashShift,Long> { Optional<ServiceClashShift> findBySlug(String slug); List<ServiceClashShift> findAllByActiveTrueOrderBySortOrderAscIdAsc(); }

src/main/java/com/example/mindflux/repository/UserRepository.java

@@ -2,6 +2,7 @@ package com.example.mindflux.repository;
 
 import com.example.mindflux.model.User;
 import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.List;
 import java.util.Optional;
 
 public interface UserRepository extends JpaRepository<User, Long> {
@@ -12,6 +13,8 @@ public interface UserRepository extends JpaRepository<User, Long> {
     // Case-insensitive Suche: Login und Registrierung sollen unabhängig von Groß-/Kleinschreibung greifen
     Optional<User> findByUsernameIgnoreCase(String username);
 
+    List<User> findAllByEmailIgnoreCase(String email);
+
     // Benutzer anhand des Benutzernamens löschen
     void deleteByUsername(String username);
-}
+}

src/main/java/com/example/mindflux/service/AccountMailService.java

@@ -0,0 +1,217 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.model.AccountEmailToken;
+import com.example.mindflux.model.User;
+import com.example.mindflux.repository.AccountEmailTokenRepository;
+import com.example.mindflux.repository.UserRepository;
+import jakarta.transaction.Transactional;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.SimpleMailMessage;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Base64;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class AccountMailService {
+
+    private static final Duration TOKEN_LIFETIME = Duration.ofHours(24);
+    private static final Logger log = LoggerFactory.getLogger(AccountMailService.class);
+    private final AccountEmailTokenRepository tokenRepository;
+    private final UserRepository userRepository;
+    private final JavaMailSender mailSender;
+    private final BCryptPasswordEncoder passwordEncoder;
+    private final SecureRandom secureRandom = new SecureRandom();
+    private final String publicUrl;
+    private final String fromAddress;
+
+    public AccountMailService(AccountEmailTokenRepository tokenRepository,
+                              UserRepository userRepository,
+                              JavaMailSender mailSender,
+                              BCryptPasswordEncoder passwordEncoder,
+                              @Value("${mindflux.public-url}") String publicUrl,
+                              @Value("${mindflux.mail.from}") String fromAddress) {
+        this.tokenRepository = tokenRepository;
+        this.userRepository = userRepository;
+        this.mailSender = mailSender;
+        this.passwordEncoder = passwordEncoder;
+        this.publicUrl = publicUrl.replaceAll("/+$", "");
+        this.fromAddress = fromAddress;
+    }
+
+    @Transactional
+    public boolean sendVerificationFor(User user) {
+        if (user == null) {
+            log.error("mail_event=VERIFICATION_SKIPPED reason=USER_NOT_FOUND_AFTER_REGISTRATION");
+            return false;
+        }
+        if (user.isEmailVerified()) {
+            log.info("mail_event=VERIFICATION_SKIPPED reason=ALREADY_VERIFIED userId={}", user.getId());
+            return false;
+        }
+        IssuedToken issued = issueToken(user, AccountEmailToken.Purpose.EMAIL_VERIFICATION);
+        send(user, issued, "Bestätige deinen Mindflux-Account",
+                "Hallo " + user.getUsername() + ",\n\n"
+                        + "bitte bestätige deine E-Mail-Adresse, um deinen Account freizuschalten:\n"
+                        + publicUrl + "/verify-email?token=" + issued.rawToken() + "\n\n"
+                        + "Der Link ist 24 Stunden gültig und kann nur einmal verwendet werden.\n\n"
+                        + "Falls du dich nicht registriert hast, kannst du diese E-Mail ignorieren.");
+        return true;
+    }
+
+    @Transactional
+    public void resendVerification(String email) {
+        Optional<User> user = uniqueUserForEmail(email);
+        if (user.isEmpty()) {
+            log.info("mail_event=VERIFICATION_RESEND_IGNORED reason=NO_UNIQUE_USER recipientFingerprint={}", recipientFingerprint(email));
+            return;
+        }
+        if (user.get().isEmailVerified()) {
+            log.info("mail_event=VERIFICATION_RESEND_IGNORED reason=ALREADY_VERIFIED userId={}", user.get().getId());
+            return;
+        }
+        log.info("mail_event=VERIFICATION_RESEND_REQUESTED userId={}", user.get().getId());
+        sendVerificationFor(user.get());
+    }
+
+    @Transactional
+    public void requestPasswordReset(String email) {
+        uniqueUserForEmail(email).filter(User::isEmailVerified).ifPresent(user -> {
+            IssuedToken issued = issueToken(user, AccountEmailToken.Purpose.PASSWORD_RESET);
+            send(user, issued, "Passwort für deinen Mindflux-Account zurücksetzen",
+                    "Hallo " + user.getUsername() + ",\n\n"
+                            + "über diesen Link kannst du ein neues Passwort vergeben:\n"
+                            + publicUrl + "/reset-password?token=" + issued.rawToken() + "\n\n"
+                            + "Der Link ist 24 Stunden gültig und kann nur einmal verwendet werden.\n\n"
+                            + "Falls du diese Anfrage nicht gestellt hast, kannst du diese E-Mail ignorieren.");
+        });
+    }
+
+    @Transactional
+    public boolean verifyEmail(String rawToken) {
+        Optional<AccountEmailToken> token = validToken(rawToken, AccountEmailToken.Purpose.EMAIL_VERIFICATION);
+        if (token.isEmpty()) {
+            return false;
+        }
+        AccountEmailToken value = token.get();
+        User user = value.getUser();
+        user.setEmailVerified(true);
+        value.setConsumedAt(Instant.now());
+        userRepository.save(user);
+        tokenRepository.save(value);
+        log.info("mail_event=VERIFICATION_CONFIRMED userId={} tokenId={}", user.getId(), value.getId());
+        return true;
+    }
+
+    @Transactional
+    public boolean resetPassword(String rawToken, String password, String confirmPassword) {
+        if (password == null || password.length() < 8 || !password.equals(confirmPassword)) {
+            return false;
+        }
+        Optional<AccountEmailToken> token = validToken(rawToken, AccountEmailToken.Purpose.PASSWORD_RESET);
+        if (token.isEmpty()) {
+            return false;
+        }
+        AccountEmailToken value = token.get();
+        User user = value.getUser();
+        user.setPassword(passwordEncoder.encode(password));
+        value.setConsumedAt(Instant.now());
+        userRepository.save(user);
+        tokenRepository.save(value);
+        return true;
+    }
+
+    public boolean isResetTokenValid(String rawToken) {
+        return validToken(rawToken, AccountEmailToken.Purpose.PASSWORD_RESET).isPresent();
+    }
+
+    private Optional<User> uniqueUserForEmail(String email) {
+        if (email == null || email.isBlank()) {
+            return Optional.empty();
+        }
+        List<User> users = userRepository.findAllByEmailIgnoreCase(email.trim());
+        return users.size() == 1 ? Optional.of(users.getFirst()) : Optional.empty();
+    }
+
+    private IssuedToken issueToken(User user, AccountEmailToken.Purpose purpose) {
+        tokenRepository.deleteByUserAndPurpose(user, purpose);
+        byte[] bytes = new byte[32];
+        secureRandom.nextBytes(bytes);
+        String rawToken = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
+        AccountEmailToken token = new AccountEmailToken();
+        token.setUser(user);
+        token.setPurpose(purpose);
+        token.setTokenHash(hash(rawToken));
+        token.setExpiresAt(Instant.now().plus(TOKEN_LIFETIME));
+        tokenRepository.save(token);
+        log.info("mail_event=TOKEN_ISSUED purpose={} userId={} tokenId={} expiresAt={}",
+                purpose, user.getId(), token.getId(), token.getExpiresAt());
+        return new IssuedToken(rawToken, token.getId(), purpose);
+    }
+
+    private Optional<AccountEmailToken> validToken(String rawToken, AccountEmailToken.Purpose purpose) {
+        if (rawToken == null || rawToken.isBlank()) {
+            return Optional.empty();
+        }
+        return tokenRepository.findByTokenHashAndPurposeAndConsumedAtIsNull(hash(rawToken), purpose)
+                .filter(token -> token.getExpiresAt().isAfter(Instant.now()));
+    }
+
+    private void send(User user, IssuedToken issued, String subject, String body) {
+        SimpleMailMessage message = new SimpleMailMessage();
+        message.setFrom(fromAddress);
+        message.setTo(user.getEmail());
+        message.setSubject(subject);
+        message.setText(body);
+        log.info("mail_event=SMTP_SUBMISSION_STARTED purpose={} userId={} tokenId={} recipientFingerprint={}",
+                issued.purpose(), user.getId(), issued.tokenId(), recipientFingerprint(user.getEmail()));
+        try {
+            mailSender.send(message);
+            // JavaMail bestätigt hier nur die Annahme durch den konfigurierten SMTP-Server,
+            // nicht die spätere Zustellung im Postfach. Für Bounces sind dessen Logs/DSN nötig.
+            log.info("mail_event=SMTP_SUBMISSION_ACCEPTED purpose={} userId={} tokenId={}",
+                    issued.purpose(), user.getId(), issued.tokenId());
+        } catch (RuntimeException exception) {
+            log.error("mail_event=SMTP_SUBMISSION_FAILED purpose={} userId={} tokenId={} errorType={} detail={}",
+                    issued.purpose(), user.getId(), issued.tokenId(), exception.getClass().getSimpleName(),
+                    safeFailureDetail(exception.getMessage()));
+            throw exception;
+        }
+    }
+
+    private String recipientFingerprint(String email) {
+        return hash(email == null ? "" : email.trim().toLowerCase()).substring(0, 12);
+    }
+
+    private String safeFailureDetail(String detail) {
+        if (detail == null || detail.isBlank()) {
+            return "none";
+        }
+        String sanitized = detail.replaceAll("(?i)[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}", "[redacted-email]")
+                .replaceAll("[\\r\\n]+", " ");
+        return sanitized.substring(0, Math.min(sanitized.length(), 240));
+    }
+
+    private record IssuedToken(String rawToken, Long tokenId, AccountEmailToken.Purpose purpose) { }
+
+    private String hash(String value) {
+        try {
+            byte[] digest = MessageDigest.getInstance("SHA-256")
+                    .digest(value.getBytes(StandardCharsets.UTF_8));
+            return java.util.HexFormat.of().formatHex(digest);
+        } catch (NoSuchAlgorithmException e) {
+            throw new IllegalStateException("SHA-256 ist nicht verfügbar", e);
+        }
+    }
+}

src/main/java/com/example/mindflux/service/AchievementService.java

@@ -14,4 +14,5 @@ public interface AchievementService {
      * Achievements idempotent. Wird aus GameScoreService.recordScore() aufgerufen.
      */
     void checkAndAward(String username, String game, int score, boolean newHighscore, long playsInGame);
+    void awardSpecial(String username, String title, String description);
 }

src/main/java/com/example/mindflux/service/AchievementServiceImpl.java

@@ -25,6 +25,15 @@ public class AchievementServiceImpl implements AchievementService {
         CATALOG.put("Dauerbrenner", "Spiele dasselbe Spiel zehnmal.");
         CATALOG.put("Punktesammler", "Sammle insgesamt 5000 Punkte.");
         CATALOG.put("Allrounder", "Spiele vier verschiedene Spiele.");
+        CATALOG.put("Gedächtnis-Impuls", "Schließe eine MindMatch-Runde mit Punkten ab.");
+        CATALOG.put("Quiz-Kapitän", "Schließe eine TechTacular-Runde mit Punkten ab.");
+        CATALOG.put("Werkbank aktiv", "Schließe eine DevLab-Runde mit Punkten ab.");
+        CATALOG.put("Syntax-Spur", "Schließe eine SyntaxSaga-Runde mit Punkten ab.");
+        CATALOG.put("Fluchtprotokoll", "Schließe eine SystemEscape-Runde mit Punkten ab.");
+        CATALOG.put("Erste Fallakte", "Schließe eine BugHunter-Akte mit Punkten ab.");
+        CATALOG.put("Leitstand-Einsatz", "Schließe eine ServiceClash-Schicht mit Punkten ab.");
+        CATALOG.put("Incident Commander", "Löse eine ServiceClash-Schicht ohne Fehler oder Aufdecken.");
+        CATALOG.put("Netzwerk-Neustart", "Schließe eine NetWorker-Welt mit Punkten ab.");
     }
 
     private final AchievementRepository achievementRepository;
@@ -70,6 +79,17 @@ public class AchievementServiceImpl implements AchievementService {
                 gameScoreRepository.sumScoreByUsername(username) >= 5000);
         award(existing, username, "Allrounder",
                 gameScoreRepository.countDistinctGamesByUsername(username) >= 4);
+        String gameAchievement = Map.of(
+                "mindmatch", "Gedächtnis-Impuls", "techtacular", "Quiz-Kapitän", "devlab", "Werkbank aktiv",
+                "syntax-saga", "Syntax-Spur", "codeescape", "Fluchtprotokoll", "bughunter", "Erste Fallakte",
+                "serviceclash", "Leitstand-Einsatz", "networker", "Netzwerk-Neustart").get(game);
+        if (gameAchievement != null) award(existing, username, gameAchievement, score > 0);
+    }
+
+    @Override @Transactional
+    public void awardSpecial(String username, String title, String description) {
+        Set<String> existing = achievementRepository.findByUsername(username).stream().map(Achievement::getTitle).collect(Collectors.toSet());
+        if (!existing.contains(title)) { Achievement achievement = new Achievement(title, description, null, true); achievement.setUsername(username); achievementRepository.save(achievement); }
     }
 
     private void award(Set<String> existing, String username, String title, boolean condition) {

src/main/java/com/example/mindflux/service/AvatarService.java

@@ -0,0 +1,99 @@
+package com.example.mindflux.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.UUID;
+
+import javax.imageio.ImageIO;
+
+/**
+ * Kapselt die gesamte Profilbild-Logik (Dekodierung, Skalierung, Datei-I/O, Pfad-Auflösung),
+ * die zuvor mehrfach im ProfileController dupliziert war. Der Controller bleibt so schlank
+ * und die Bildverarbeitung ist an einer Stelle testbar/änderbar.
+ */
+@Service
+public class AvatarService {
+
+    private static final Logger log = LoggerFactory.getLogger(AvatarService.class);
+    private static final int MAX_DIM = 400;
+
+    /** Basisverzeichnis der Profilbilder – eine einzige Quelle der Wahrheit für den Pfad. */
+    private Path baseDir() {
+        return Paths.get(System.getProperty("user.dir"), "uploads", "profiles");
+    }
+
+    /** Voller Pfad zu einem gespeicherten Profilbild. */
+    public Path resolve(String fileName) {
+        return baseDir().resolve(fileName);
+    }
+
+    /**
+     * Verarbeitet einen Bild-Upload: liest das Bild, skaliert auf max. Kantenlänge herunter,
+     * löscht ein evtl. vorhandenes altes Bild und speichert normalisiert als JPEG.
+     *
+     * @return der neue Dateiname, oder {@code null}, wenn kein/kein lesbares Bild geliefert wurde.
+     */
+    public String store(MultipartFile file, String oldFileName) {
+        if (file == null || file.isEmpty()) {
+            return null;
+        }
+        try {
+            BufferedImage original = ImageIO.read(file.getInputStream());
+            if (original == null) {
+                log.warn("Profilbild-Upload ignoriert: keine lesbare Bilddatei.");
+                return null;
+            }
+            int w = original.getWidth();
+            int h = original.getHeight();
+            double scale = Math.min(1.0, (double) MAX_DIM / Math.max(w, h));
+            int nw = Math.max(1, (int) Math.round(w * scale));
+            int nh = Math.max(1, (int) Math.round(h * scale));
+
+            BufferedImage scaled = new BufferedImage(nw, nh, BufferedImage.TYPE_INT_RGB);
+            Graphics2D g = scaled.createGraphics();
+            g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+            g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+            g.setColor(Color.WHITE); // JPEG kennt kein Alpha -> Transparenz auf weißem Grund
+            g.fillRect(0, 0, nw, nh);
+            g.drawImage(original, 0, 0, nw, nh, null);
+            g.dispose();
+
+            delete(oldFileName); // altes Bild aufräumen
+
+            String fileName = UUID.randomUUID() + ".jpg";
+            Path dir = baseDir();
+            Files.createDirectories(dir);
+            ImageIO.write(scaled, "jpg", dir.resolve(fileName).toFile());
+            return fileName;
+        } catch (IOException e) {
+            log.error("Fehler beim Speichern des Profilbilds", e);
+            return null;
+        }
+    }
+
+    /** Löscht ein Profilbild, falls Name gesetzt und Datei vorhanden. Fehler werden nur geloggt. */
+    public void delete(String fileName) {
+        if (fileName == null || fileName.trim().isEmpty()) {
+            return;
+        }
+        try {
+            Path path = resolve(fileName);
+            if (Files.deleteIfExists(path)) {
+                log.info("Profilbild gelöscht: {}", path.getFileName());
+            }
+        } catch (IOException e) {
+            log.error("Fehler beim Löschen der Profilbild-Datei", e);
+        }
+    }
+}

src/main/java/com/example/mindflux/service/BugHunterService.java

@@ -0,0 +1,202 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.dto.*;
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.*;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.*;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import jakarta.servlet.http.HttpSession;
+import java.time.LocalDateTime;
+import java.util.*;
+
+/** Serverseitige Drei-Phasen-Ermittlung für BugHunter. Lösungsdaten bleiben im Bug-Payload. */
+@Service
+public class BugHunterService {
+    private static final String GAME = "bughunter";
+    private static final Set<String> CATEGORIES = Set.of("syntax", "logik", "laufzeit", "sicherheit");
+    private static final Set<String> SCOPES = Set.of("AP1", "AP2_FIAE", "AP2_FISI", "CROSS");
+    private static final Map<String, Integer> DIFFICULTY_ORDER = Map.of("junior", 1, "senior", 2, "principal", 3);
+    private static final int MAX_DURATION_SECONDS = 14_400;
+    private final BugHunterHuntRepository hunts;
+    private final BugHunterFileRepository files;
+    private final BugHunterBugRepository bugs;
+    private final BugHunterHuntProgressRepository progress;
+    private final GameScoreService scores;
+    private final AchievementService achievements;
+    private final ObjectMapper mapper;
+    private final Random random = new Random();
+
+    public BugHunterService(BugHunterHuntRepository hunts, BugHunterFileRepository files, BugHunterBugRepository bugs,
+                            BugHunterHuntProgressRepository progress, GameScoreService scores, AchievementService achievements, ObjectMapper mapper) {
+        this.hunts = hunts; this.files = files; this.bugs = bugs; this.progress = progress; this.scores = scores; this.achievements = achievements; this.mapper = mapper;
+    }
+
+    @Transactional(readOnly = true)
+    public JsonNode catalog(String username) {
+        ObjectNode root = mapper.createObjectNode(); ArrayNode result = root.putArray("hunts");
+        Map<String, BugHunterHuntProgress> bySlug = new HashMap<>();
+        if (!blank(username)) for (BugHunterHuntProgress item : progress.findAllByUsername(username)) bySlug.put(item.getHuntSlug(), item);
+        List<BugHunterHunt> ordered = new ArrayList<>(hunts.findAllByActiveTrueOrderBySortOrderAscIdAsc());
+        ordered.sort(Comparator.comparingInt((BugHunterHunt hunt) -> DIFFICULTY_ORDER.getOrDefault(hunt.getDifficulty(), Integer.MAX_VALUE)).thenComparingInt(BugHunterHunt::getSortOrder));
+        for (BugHunterHunt hunt : ordered) {
+            if (hunt.getBugs().isEmpty() || hunt.getFiles().isEmpty()) continue;
+            ObjectNode row = result.addObject(); row.put("slug", hunt.getSlug()); row.put("title", hunt.getTitle());
+            row.put("language", hunt.getCodeLanguage()); row.put("difficulty", hunt.getDifficulty());
+            row.put("examScope", hunt.getExamScope()); row.put("description", hunt.getDescription());
+            row.put("bugCount", hunt.getBugs().size()); row.put("fileCount", hunt.getFiles().size());
+            row.put("solved", Optional.ofNullable(bySlug.get(hunt.getSlug())).map(BugHunterHuntProgress::isSolvedClean).orElse(false));
+        }
+        return root;
+    }
+
+    @Transactional(readOnly = true)
+    public JsonNode session(String slug, String username, HttpSession httpSession) {
+        ObjectNode root = mapper.createObjectNode();
+        BugHunterHunt hunt = hunts.findBySlug(slug).filter(BugHunterHunt::isActive).orElse(null);
+        if (hunt == null) { root.put("found", false); return root; }
+        root.put("found", true); root.put("slug", hunt.getSlug()); root.put("title", hunt.getTitle());
+        root.put("language", hunt.getCodeLanguage()); root.put("difficulty", hunt.getDifficulty()); root.put("examScope", hunt.getExamScope());
+        root.put("description", nullToEmpty(hunt.getDescription())); root.put("briefing", nullToEmpty(hunt.getBriefing()));
+        root.put("consoleOutput", nullToEmpty(hunt.getConsoleOutput()));
+        int variant = variantFor(username, hunt.getSlug()); root.put("variant", variant);
+        Map<String, Integer> offsets = new HashMap<>(); for (BugHunterFile file : hunt.getFiles()) offsets.put(file.getFilename(), lineOffset(file.getFilename(), variant));
+        List<BugHunterFile> orderedFiles = new ArrayList<>(hunt.getFiles()); if (orderedFiles.size() > 1 && variant > 0) Collections.rotate(orderedFiles, -Math.floorMod(variant, orderedFiles.size()));
+        ArrayNode fs = root.putArray("files");
+        for (BugHunterFile file : orderedFiles) { ObjectNode f = fs.addObject(); f.put("filename", file.getFilename()); ArrayNode lines = f.putArray("lines"); for (String line : variantContent(file.getContent(), variant, offsets.get(file.getFilename())).split("\\R", -1)) lines.add(line); }
+        ArrayNode bs = root.putArray("bugs"); int maxScore = 0;
+        Map<Long, JsonNode> effectivePayloads = new HashMap<>();
+        for (BugHunterBug bug : hunt.getBugs()) { JsonNode payload = parse(bug.getPayload()); if (payload == null) continue; ObjectNode effective = payload.deepCopy(); effective.put("line", payload.path("line").asInt() + offsets.getOrDefault(payload.path("file").asText(), 0)); effectivePayloads.put(bug.getId(), effective); ObjectNode b = bs.addObject(); b.put("bugId", bug.getId()); b.put("points", bug.getPoints()); b.put("evidence", effective.path("evidence").asText("")); maxScore += bug.getPoints(); }
+        root.put("totalBugs", bs.size()); root.put("maxScore", maxScore);
+        Set<Long> bugIds = new HashSet<>(); bs.forEach(b -> bugIds.add(b.path("bugId").asLong()));
+        httpSession.setAttribute("bughunter.run", new RunState(hunt.getSlug(), bugIds, effectivePayloads, System.currentTimeMillis()));
+        return root;
+    }
+
+    @Transactional(readOnly = true)
+    public JsonNode check(Long bugId, String phase, boolean reveal, JsonNode submission, HttpSession httpSession) {
+        if (!isPhase(phase)) throw new IllegalArgumentException("Unbekannte Ermittlungsphase.");
+        RunState run = run(httpSession);
+        if (bugId == null || !run.bugIds.contains(bugId)) throw new IllegalArgumentException("Bug gehört nicht zu dieser Fallakte.");
+        JsonNode payload = run.payload(bugId);
+        if (payload == null) throw new IllegalArgumentException("Fallakte nicht gefunden.");
+        PhaseState phaseState = run.state(bugId, phase);
+        if ((phase.equals("classify") && !run.state(bugId, "locate").done) || (phase.equals("fix") && !run.state(bugId, "classify").done)) throw new IllegalArgumentException("Schließe zuerst die vorherige Ermittlungsphase ab.");
+        if (phaseState.done) throw new IllegalArgumentException("Diese Ermittlungsphase ist bereits abgeschlossen.");
+        if (!reveal && phaseState.attempts >= 3) throw new IllegalArgumentException("Nach drei Fehlversuchen kannst du die Auflösung anzeigen.");
+        JsonNode sub = submission == null ? mapper.createObjectNode() : submission;
+        boolean correct = switch (phase) { case "locate" -> locationMatches(payload, sub); case "classify" -> categoryMatches(payload, sub); case "fix" -> fixMatches(payload, sub); default -> false; };
+        if (reveal) { phaseState.revealed = true; phaseState.done = true; }
+        else { phaseState.attempts++; phaseState.submission = sub.toString(); if (correct) phaseState.done = true; }
+        ObjectNode result = mapper.createObjectNode(); result.put("correct", correct); result.put("resolved", correct || reveal); result.put("phase", phase);
+        if (correct && payload.hasNonNull("successText")) result.put("successText", payload.get("successText").asText());
+        if (correct || reveal) addPhaseResolution(result, payload, phase);
+        return result;
+    }
+
+    @Transactional
+    public BugHunterResult finish(String username, BugHunterFinishRequest request, HttpSession httpSession) {
+        if (request == null || request.getSlug() == null || request.getSlug().isBlank()) throw new IllegalArgumentException("Fallakte fehlt.");
+        if (request.getDurationSeconds() < 1 || request.getDurationSeconds() > MAX_DURATION_SECONDS) throw new IllegalArgumentException("Unplausible Spieldauer.");
+        BugHunterHunt hunt = hunts.findBySlug(request.getSlug()).filter(BugHunterHunt::isActive)
+                .orElseThrow(() -> new IllegalArgumentException("Fallakte nicht gefunden."));
+        RunState run = run(httpSession);
+        if (!hunt.getSlug().equals(run.slug)) throw new IllegalArgumentException("Die Fallakte wurde nicht angefordert.");
+        List<BugHunterFinishRequest.Item> submitted = request.getItems() == null ? List.of() : request.getItems();
+        if (submitted.size() > hunt.getBugs().size()) throw new IllegalArgumentException("Zu viele Bugs eingereicht.");
+        Map<Long, BugHunterFinishRequest.Item> byId = new HashMap<>();
+        Set<Long> allowed = new HashSet<>(); for (BugHunterBug bug : hunt.getBugs()) allowed.add(bug.getId());
+        for (BugHunterFinishRequest.Item item : submitted) {
+            if (item == null || item.getBugId() == null || !allowed.contains(item.getBugId()) || byId.putIfAbsent(item.getBugId(), item) != null)
+                throw new IllegalArgumentException("Ungültige oder doppelte Bug-ID.");
+        }
+        int base = 0, max = 0, solved = 0, combo = 0, maxCombo = 0, comboBonus = 0;
+        for (BugHunterBug bug : hunt.getBugs()) {
+            max += bug.getPoints(); BugHunterFinishRequest.Item item = byId.get(bug.getId());
+            if (item == null) { combo = 0; continue; }
+            JsonNode payload = run.payload(bug.getId()); if (payload == null) { combo = 0; continue; }
+            PhaseState located = run.state(bug.getId(), "locate"), classified = run.state(bug.getId(), "classify"), fixed = run.state(bug.getId(), "fix");
+            boolean locate = phaseCorrect(payload, "locate", located);
+            boolean classify = phaseCorrect(payload, "classify", classified);
+            boolean fix = phaseCorrect(payload, "fix", fixed);
+            base += award(bug.getPoints(), .4, located, locate);
+            base += award(bug.getPoints(), .2, classified, classify);
+            base += award(bug.getPoints(), .4, fixed, fix);
+            if (locate && classify && fix) solved++;
+            if (isClean(located, locate) && isClean(classified, classify) && isClean(fixed, fix)) {
+                combo++; maxCombo = Math.max(maxCombo, combo); comboBonus += (int) Math.round(bug.getPoints() * (Math.min(combo, 4) - 1) * .1);
+            } else combo = 0;
+        }
+        boolean cleanSolve = solved == hunt.getBugs().size() && maxCombo == hunt.getBugs().size();
+        if (cleanSolve && !blank(username)) { markCleanSolved(username, hunt.getSlug()); achievements.awardSpecial(username, "Fallakten-Perfektionist", "Schließe eine BugHunter-Akte ohne Fehlversuch und ohne Auflösung ab."); }
+        int stars = stars(base, max); ScoreResult saved = scores.recordScore(username, GAME, hunt.getSlug(), base + comboBonus, solved, request.getDurationSeconds());
+        httpSession.removeAttribute("bughunter.run");
+        return new BugHunterResult(base + comboBonus, base, max, comboBonus, maxCombo, solved, hunt.getBugs().size(), stars, saved.getHighscore(), saved.isNewHighscore(), saved.getPlays(), cleanSolve);
+    }
+
+    @Transactional public void reset(String username, String slug) {
+        if (blank(username) || blank(slug)) throw new IllegalArgumentException("Fallakte fehlt.");
+        hunts.findBySlug(slug).filter(BugHunterHunt::isActive).orElseThrow(() -> new IllegalArgumentException("Fallakte nicht gefunden."));
+        BugHunterHuntProgress item = progress.findByUsernameAndHuntSlug(username, slug).orElseGet(() -> new BugHunterHuntProgress(username, slug));
+        item.setVariantIndex(item.getVariantIndex() + 1); progress.save(item);
+    }
+
+    @Transactional(readOnly = true) public List<BugHunterHunt> all() { return hunts.findAllByOrderBySortOrderAscIdAsc(); }
+    @Transactional(readOnly = true) public BugHunterHunt hunt(Long id) { BugHunterHunt hunt = hunts.findById(id).orElse(null); if (hunt != null) { hunt.getFiles().size(); hunt.getBugs().size(); } return hunt; }
+    @Transactional
+    public Long addHunt(String title, String language, String difficulty, String examScope, String description, String briefing, String consoleOutput) {
+        if (blank(title)) return null; String clean = title.trim();
+        BugHunterHunt hunt = new BugHunterHunt(uniqueSlug(clean), clean, cap(language, 50, "Java"), normalizeDifficulty(difficulty), normalizeScope(examScope), cap(description, 1200, ""), cap(briefing, 2000, ""), cap(consoleOutput, 4000, ""), (int) hunts.count() + 1);
+        return hunts.save(hunt).getId();
+    }
+    @Transactional public void addFile(Long huntId, String filename, String content) { hunts.findById(huntId).ifPresent(hunt -> { if (!blank(filename) && content != null && content.length() <= 8000) { hunt.addFile(new BugHunterFile(cap(filename, 255, ""), content, hunt.getFiles().size())); hunts.save(hunt); } }); }
+    @Transactional public void addBug(Long huntId, int points, String payload) { hunts.findById(huntId).ifPresent(hunt -> { if (validPayload(hunt, payload)) { hunt.addBug(new BugHunterBug(normalizePoints(points), hunt.getBugs().size(), payload.trim())); hunts.save(hunt); } }); }
+    @Transactional public void deleteHunt(Long id) { hunts.deleteById(id); }
+    @Transactional public void deleteFile(Long id) { files.deleteById(id); }
+    @Transactional public void deleteBug(Long id) { bugs.deleteById(id); }
+    @Transactional public void toggle(Long id) { hunts.findById(id).ifPresent(h -> h.setActive(!h.isActive())); }
+
+    private boolean validPayload(BugHunterHunt hunt, String raw) {
+        JsonNode p = parse(raw); if (p == null || raw.length() > 8000 || blank(p.path("file").asText()) || p.path("line").asInt(0) < 1 || !CATEGORIES.contains(p.path("category").asText()) || !p.path("fixOptions").isArray()) return false;
+        BugHunterFile file = hunt.getFiles().stream().filter(f -> f.getFilename().equals(p.path("file").asText())).findFirst().orElse(null);
+        int index = p.path("fixIndex").asInt(-1); return file != null && p.path("line").asInt() <= file.getContent().split("\\R", -1).length && index >= 0 && index < p.path("fixOptions").size();
+    }
+    private boolean phaseCorrect(JsonNode p, String phase, PhaseState answer) { return answer != null && !answer.revealed && answer.submission != null && matches(p, phase, parse(answer.submission)); }
+    private boolean isClean(PhaseState answer, boolean correct) { return correct && answer != null && answer.attempts == 1 && !answer.revealed; }
+    private int award(int points, double weight, PhaseState answer, boolean correct) { if (!correct || answer == null) return 0; int attempts = Math.max(1, Math.min(answer.attempts, 3)); double factor = attempts == 1 ? 1 : attempts == 2 ? .6 : .3; return (int) Math.round(points * weight * factor); }
+    private boolean matches(JsonNode p, String phase, JsonNode sub) { return switch (phase) { case "locate" -> locationMatches(p, sub); case "classify" -> categoryMatches(p, sub); case "fix" -> fixMatches(p, sub); default -> false; }; }
+    private boolean locationMatches(JsonNode p, JsonNode sub) { return textEquals(p.path("file").asText(), sub.path("file").asText()) && p.path("line").asInt(-1) == sub.path("line").asInt(-2); }
+    private boolean categoryMatches(JsonNode p, JsonNode sub) { return textEquals(p.path("category").asText(), sub.path("category").asText()); }
+    private boolean fixMatches(JsonNode p, JsonNode sub) { int index = p.path("fixIndex").asInt(-1); JsonNode options = p.path("fixOptions"); return index >= 0 && index < options.size() && textEquals(options.get(index).asText(), sub.path("choice").asText()); }
+    private void addPhaseResolution(ObjectNode target, JsonNode p, String phase) {
+        if (phase.equals("locate")) { ObjectNode location = target.putObject("location"); location.put("file", p.path("file").asText()); location.put("line", p.path("line").asInt()); }
+        else if (phase.equals("classify")) { target.put("category", p.path("category").asText()); ArrayNode options = target.putArray("fixOptions"); List<String> shuffled = new ArrayList<>(); p.path("fixOptions").forEach(o -> shuffled.add(o.asText())); Collections.shuffle(shuffled, random); shuffled.forEach(options::add); }
+        else { target.put("fixedLine", p.path("fixedLine").asText()); target.put("explanation", p.path("explanation").asText()); }
+    }
+    private JsonNode parse(String raw) { try { return raw == null || raw.isBlank() ? null : mapper.readTree(raw); } catch (Exception e) { return null; } }
+    private int variantFor(String username, String slug) { return blank(username) ? 0 : progress.findByUsernameAndHuntSlug(username, slug).map(BugHunterHuntProgress::getVariantIndex).orElse(0); }
+    private int lineOffset(String filename, int variant) { return variant <= 0 ? 0 : 1 + Math.floorMod(filename.hashCode() + variant, 3); }
+    private String variantContent(String content, int variant, int offset) { return offset <= 0 ? content : "// Aktenvermerk · Variante " + (variant + 1) + "\n".repeat(offset) + content; }
+    private void markCleanSolved(String username, String slug) { BugHunterHuntProgress item = progress.findByUsernameAndHuntSlug(username, slug).orElseGet(() -> new BugHunterHuntProgress(username, slug)); item.setSolvedClean(true); item.setSolvedAt(LocalDateTime.now()); progress.save(item); }
+    private String uniqueSlug(String title) { String base = title.toLowerCase().replace("ä", "ae").replace("ö", "oe").replace("ü", "ue").replace("ß", "ss").replaceAll("[^a-z0-9]+", "-").replaceAll("(^-|-$)", ""); if (base.isBlank()) base = "hunt"; String result = base; int n = 2; while (hunts.existsBySlug(result)) result = base + "-" + n++; return result; }
+    private int stars(int score, int max) { if (max <= 0 || score <= 0) return 0; double ratio = (double) score / max; return ratio >= .8 ? 3 : ratio >= .5 ? 2 : 1; }
+    private int normalizePoints(int value) { return value <= 0 ? 100 : Math.min(value, 1000); }
+    private String normalizeDifficulty(String value) { return Set.of("junior", "senior", "principal").contains(value) ? value : "junior"; }
+    private String normalizeScope(String value) { return SCOPES.contains(value) ? value : "AP1"; }
+    private boolean isPhase(String value) { return Set.of("locate", "classify", "fix").contains(value); }
+    private boolean blank(String value) { return value == null || value.isBlank(); }
+    private String cap(String value, int max, String fallback) { if (value == null || value.isBlank()) return fallback; String clean = value.trim(); return clean.length() <= max ? clean : clean.substring(0, max); }
+    private String nullToEmpty(String value) { return value == null ? "" : value; }
+    private boolean textEquals(String first, String second) { return normalize(first).equalsIgnoreCase(normalize(second)); }
+    private String normalize(String value) { return value == null ? "" : value.trim().replaceAll("\\s+", " "); }
+    private RunState run(HttpSession session) { Object value = session.getAttribute("bughunter.run"); if (!(value instanceof RunState run)) throw new IllegalArgumentException("Fordere zuerst eine Fallakte an."); return run; }
+    public static class RunState {
+        final String slug; final Set<Long> bugIds; final Map<Long, JsonNode> payloads; final long startedAt; final Map<Long, Map<String, PhaseState>> phases = new HashMap<>();
+        RunState(String slug, Set<Long> bugIds, Map<Long, JsonNode> payloads, long startedAt) { this.slug = slug; this.bugIds = Set.copyOf(bugIds); this.payloads = Map.copyOf(payloads); this.startedAt = startedAt; }
+        JsonNode payload(Long bugId) { return payloads.get(bugId); }
+        PhaseState state(Long bugId, String phase) { return phases.computeIfAbsent(bugId, ignored -> new HashMap<>()).computeIfAbsent(phase, ignored -> new PhaseState()); }
+    }
+    static class PhaseState { int attempts; boolean revealed; boolean done; String submission; }
+}

src/main/java/com/example/mindflux/service/CodeEscapeService.java

@@ -0,0 +1,26 @@
+package com.example.mindflux.service;
+import com.example.mindflux.dto.*; import com.example.mindflux.model.*; import com.example.mindflux.repository.*; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.node.*; import jakarta.servlet.http.HttpSession; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.*;
+@Service public class CodeEscapeService {
+ public static final String GAME="codeescape"; private static final Set<String>TYPES=Set.of("code","choice","order","match"),SCOPES=Set.of("AP1","AP2_FIAE","AP2_FISI","CROSS"); private static final int MAX_ITEMS=40;
+ private final EscapeScenarioRepository scenarios;private final EscapeRoomRepository rooms;private final EscapePuzzleRepository puzzles;private final GameScoreService scores;private final AchievementService achievements;private final ObjectMapper mapper;
+ public CodeEscapeService(EscapeScenarioRepository s,EscapeRoomRepository r,EscapePuzzleRepository p,GameScoreService g,AchievementService a,ObjectMapper m){scenarios=s;rooms=r;puzzles=p;scores=g;achievements=a;mapper=m;}
+ public static class RunState implements java.io.Serializable {public Long scenarioId;public String slug;public final List<Long>roomIds=new ArrayList<>();public final Set<Long>puzzleIds=new HashSet<>();public final Map<Long,Integer> attempts=new HashMap<>(),hints=new HashMap<>();public final Set<Long> revealed=new HashSet<>(),resolved=new HashSet<>(),opened=new LinkedHashSet<>();}
+ private RunState state(HttpSession session){Object o=session.getAttribute("codeescape.run");if(o instanceof RunState s&&s.scenarioId!=null)return s;throw new IllegalArgumentException("Kein aktiver SystemEscape-Run.");}
+ @Transactional(readOnly=true) public JsonNode catalog(){ArrayNode a=mapper.createArrayNode();for(EscapeScenario s:scenarios.findAllByActiveTrueOrderBySortOrderAscIdAsc()){if(s.getRooms().isEmpty())continue;ObjectNode n=a.addObject();n.put("slug",s.getSlug());n.put("title",s.getTitle());n.put("difficulty",s.getDifficulty());n.put("examScope",s.getExamScope());n.put("description",s.getDescription());n.put("timeLimitSeconds",s.getTimeLimitSeconds());n.put("roomCount",Math.min(4,s.getRooms().size()));n.put("poolSize",s.getRooms().size());}return mapper.createObjectNode().set("scenarios",a);}
+ @Transactional(readOnly=true) public JsonNode session(String slug,HttpSession http){EscapeScenario s=scenarios.findBySlug(slug).filter(EscapeScenario::isActive).orElseThrow(()->new IllegalArgumentException("Szenario nicht gefunden."));List<EscapeRoom>selected=new ArrayList<>(s.getRooms());Collections.shuffle(selected);selected=selected.subList(0,Math.min(4,selected.size()));RunState st=new RunState();st.scenarioId=s.getId();st.slug=s.getSlug();selected.forEach(r->{st.roomIds.add(r.getId());r.getPuzzles().forEach(p->st.puzzleIds.add(p.getId()));});http.setAttribute("codeescape.run",st);ObjectNode root=mapper.createObjectNode();root.put("slug",s.getSlug());root.put("title",s.getTitle());root.put("difficulty",s.getDifficulty());root.put("examScope",s.getExamScope());root.put("description",s.getDescription());root.put("timeLimitSeconds",s.getTimeLimitSeconds());root.put("poolSize",s.getRooms().size());ArrayNode rs=root.putArray("rooms");int max=0;for(EscapeRoom r:selected){ObjectNode rv=rs.addObject();rv.put("roomId",r.getId());rv.put("title",r.getTitle());rv.put("intro",r.getIntro());rv.put("doorPrompt",r.getDoorPrompt());ArrayNode ps=rv.putArray("puzzles");for(EscapePuzzle p:r.getPuzzles()){ObjectNode pv=sanitize(p);if(pv!=null){ps.add(pv);max+=p.getPoints();}}}root.put("maxScore",max+selected.size()*50);return root;}
+ private ObjectNode sanitize(EscapePuzzle p){JsonNode j=parse(p.getPayload());if(j==null||!TYPES.contains(p.getType()))return null;ObjectNode v=mapper.createObjectNode();v.put("puzzleId",p.getId());v.put("type",p.getType());v.put("prompt",p.getPrompt());v.put("points",p.getPoints());copy(j,v,"narrative");copy(j,v,"instruction");switch(p.getType()){case"code"->copy(j,v,"placeholder");case"choice"->v.set("options",shuffle(strings(j,"options")));case"order"->v.set("items",shuffle(strings(j,"items")));case"match"->{ArrayNode l=v.putArray("left"),r=v.putArray("right");List<String>rr=new ArrayList<>();for(JsonNode pair:array(j,"pairs"))if(pair.isArray()&&pair.size()>1){l.add(pair.get(0).asText());rr.add(pair.get(1).asText());}Collections.shuffle(rr);rr.forEach(r::add);}}return v;}
+ @Transactional(readOnly=true) public JsonNode check(Long id,boolean reveal,JsonNode submission,HttpSession session){RunState st=state(session);if(!st.puzzleIds.contains(id))throw new IllegalArgumentException("Rätsel gehört nicht zu diesem Run.");EscapePuzzle p=puzzles.findById(id).orElseThrow(()->new IllegalArgumentException("Rätsel nicht gefunden."));int attempts=st.attempts.merge(id,1,Integer::sum);if(attempts>3&&!reveal)throw new IllegalArgumentException("Maximale Versuchszahl erreicht.");boolean correct=matches(p,submission);if(reveal)st.revealed.add(id);if(correct||reveal)st.resolved.add(id);ObjectNode out=mapper.createObjectNode();out.put("correct",correct);out.put("resolved",correct||reveal);out.put("attempts",attempts);if(correct||reveal)out.put("fragment",p.getCodeFragment());if(reveal){JsonNode j=parse(p.getPayload());if(j!=null&&j.has("explanation"))out.put("explanation",j.get("explanation").asText());}return out;}
+ @Transactional(readOnly=true) public JsonNode hint(Long id,int level,HttpSession session){RunState st=state(session);if(!st.puzzleIds.contains(id))throw new IllegalArgumentException("Rätsel gehört nicht zu diesem Run.");EscapePuzzle p=puzzles.findById(id).orElseThrow(()->new IllegalArgumentException("Rätsel nicht gefunden."));int lv=Math.max(1,Math.min(2,level));st.hints.merge(id,lv,Math::max);List<String>h=strings(parse(p.getPayload()),"hints");ObjectNode o=mapper.createObjectNode();o.put("level",lv);o.put("text",h.isEmpty()?"Prüfe die Aufgabenstellung noch einmal.":h.get(Math.min(lv-1,h.size()-1)));return o;}
+ @Transactional(readOnly=true) public JsonNode door(Long id,String code,HttpSession session){RunState st=state(session);int next=st.opened.size();if(next>=st.roomIds.size()||!Objects.equals(st.roomIds.get(next),id))throw new IllegalArgumentException("Raum gehört nicht zum aktuellen Abschnitt dieses Runs.");EscapeRoom r=rooms.findById(id).orElseThrow(()->new IllegalArgumentException("Raum nicht gefunden."));boolean complete=r.getPuzzles().stream().allMatch(p->st.resolved.contains(p.getId()));boolean open=complete&&eq(r.getDoorCode(),code,false);if(open)st.opened.add(id);ObjectNode o=mapper.createObjectNode();o.put("open",open);o.put("complete",complete);if(open)o.put("successText",r.getSuccessText());else o.put("message",complete?"Code abgelehnt. Setze die Fragmente von links nach rechts ohne Leerzeichen zusammen.":"Löse zuerst alle Rätsel dieses Raums.");return o;}
+ @Transactional public EscapeResult finish(String user,EscapeFinishRequest req,HttpSession session){RunState st=state(session);EscapeScenario s=scenarios.findBySlug(req.getSlug()).orElseThrow(()->new IllegalArgumentException("Szenario nicht gefunden."));if(!Objects.equals(st.scenarioId,s.getId())||!Objects.equals(st.slug,req.getSlug()))throw new IllegalArgumentException("Szenario gehört nicht zu diesem Run.");if(req.getDurationSeconds()<1||req.getDurationSeconds()>s.getTimeLimitSeconds()*4)throw new IllegalArgumentException("Unplausible Spieldauer.");if(req.getItems()==null||req.getItems().size()>MAX_ITEMS)throw new IllegalArgumentException("Ungültige Rätselliste.");Map<Long,EscapePuzzle>byId=new HashMap<>();Map<Long,EscapeRoom>selectedRooms=new HashMap<>();for(EscapeRoom r:s.getRooms())if(st.roomIds.contains(r.getId())){selectedRooms.put(r.getId(),r);for(EscapePuzzle p:r.getPuzzles())byId.put(p.getId(),p);}Set<Long>seen=new HashSet<>();int base=0,solved=0;for(EscapeFinishRequest.Item i:req.getItems()){if(i.getPuzzleId()==null||!st.puzzleIds.contains(i.getPuzzleId())||!seen.add(i.getPuzzleId()))throw new IllegalArgumentException("Fremde oder doppelte Rätsel-ID.");EscapePuzzle p=byId.get(i.getPuzzleId());if(p!=null&&matches(p,i.getSubmission())&&!st.revealed.contains(p.getId())){solved++;int a=Math.max(1,st.attempts.getOrDefault(p.getId(),1));double af=a==1?1:a==2?.6:.3;int hl=st.hints.getOrDefault(p.getId(),0);double hf=hl==0?1:hl==1?.8:.6;base+=(int)Math.round(p.getPoints()*af*hf);}}
+ int opened=st.opened.size();base+=opened*50;int max=selectedRooms.values().stream().mapToInt(r->r.getPuzzles().stream().mapToInt(EscapePuzzle::getPoints).sum()+50).sum();boolean escaped=req.isEscaped()&&opened==st.roomIds.size();int bonus=escaped?Math.max(0,(int)Math.round(500.0*(s.getTimeLimitSeconds()-req.getDurationSeconds())/s.getTimeLimitSeconds())):0;int total=base+bonus;int stars=stars(base,max);ScoreResult saved=scores.recordScore(user,GAME,s.getSlug(),total,solved,req.getDurationSeconds());if(escaped&&stars==3)achievements.awardSpecial(user,"Schleusenmeister","Entkomme aus SystemEscape mit drei Sternen.");httpClear(session);return new EscapeResult(total,base,max,bonus,solved,opened,escaped,stars,saved.getHighscore(),saved.isNewHighscore(),saved.getPlays());}
+ private void httpClear(HttpSession s){s.removeAttribute("codeescape.run");}
+ private boolean matches(EscapePuzzle p,JsonNode sub){JsonNode j=parse(p.getPayload());if(j==null||sub==null)return false;return switch(p.getType()){case"code"->strings(j,"solutions").stream().anyMatch(x->eq(x,sub.path("answer").asText(""),j.path("caseSensitive").asBoolean(false)));case"choice"->eq(j.path("correct").asText(),sub.path("answer").asText(),false);case"order"->listEq(strings(j,"solution"),strings(sub,"items"));case"match"->pairEq(j,sub);default->false;};}
+ private boolean pairEq(JsonNode j,JsonNode s){Map<String,String>w=new HashMap<>();for(JsonNode p:array(j,"pairs"))if(p.size()>1)w.put(norm(p.get(0).asText()),norm(p.get(1).asText()));for(JsonNode p:array(s,"pairs"))if(p.size()>1&&!Objects.equals(w.get(norm(p.get(0).asText())),norm(p.get(1).asText())))return false;return arraySize(s,"pairs")==w.size();}private int arraySize(JsonNode n,String f){JsonNode a=n==null?null:n.get(f);return a!=null&&a.isArray()?a.size():0;}private boolean listEq(List<String>a,List<String>b){if(a.size()!=b.size())return false;for(int i=0;i<a.size();i++)if(!eq(a.get(i),b.get(i),false))return false;return true;}private static boolean eq(String a,String b,boolean cs){return cs?norm(a).equals(norm(b)):norm(a).equalsIgnoreCase(norm(b));}private static String norm(String s){return s==null?"":s.trim().replaceAll("\\s+"," ");}private int stars(int s,int m){if(s<=0||m<=0)return 0;double r=(double)s/m;return r>=.8?3:r>=.5?2:1;}private JsonNode parse(String j){try{return mapper.readTree(j);}catch(Exception e){return null;}}private Iterable<JsonNode> array(JsonNode n,String f){JsonNode a=n==null?null:n.get(f);return a!=null&&a.isArray()?a:mapper.createArrayNode();}private List<String> strings(JsonNode n,String f){List<String>o=new ArrayList<>();for(JsonNode x:array(n,f))o.add(x.asText());return o;}private ArrayNode shuffle(List<String>x){List<String>c=new ArrayList<>(x);Collections.shuffle(c);ArrayNode a=mapper.createArrayNode();c.forEach(a::add);return a;}private void copy(JsonNode s,ObjectNode t,String f){if(s.hasNonNull(f))t.put(f,s.get(f).asText());}
+ // Admin
+ @Transactional(readOnly=true) public List<EscapeScenario> all(){return scenarios.findAllByOrderBySortOrderAscIdAsc();}@Transactional(readOnly=true) public EscapeScenario scenario(Long id){EscapeScenario s=scenarios.findById(id).orElseThrow();s.getRooms().size();return s;}@Transactional(readOnly=true) public EscapeRoom room(Long id){EscapeRoom r=rooms.findById(id).orElseThrow();r.getPuzzles().size();return r;}
+ @Transactional public Long addScenario(String title,String difficulty,String scope,String description,int limit){String slug=title.toLowerCase().replaceAll("[^a-z0-9]+","-").replaceAll("(^-|-$)","");if(slug.isBlank())slug="scenario";String b=slug;int i=2;while(scenarios.existsBySlug(slug))slug=b+"-"+i++;EscapeScenario s=new EscapeScenario(slug,title.trim(),difficulty,SCOPES.contains(scope)?scope:"AP1",description,Math.max(300,Math.min(3600,limit)),(int)scenarios.count()+1);return scenarios.save(s).getId();}
+ @Transactional public void addRoom(Long sid,String title,String intro,String prompt,String code,String success){EscapeScenario s=scenarios.findById(sid).orElseThrow();s.addRoom(new EscapeRoom(title,intro,prompt,code,success,s.getRooms().size()));}
+ @Transactional public void addPuzzle(Long rid,String type,String prompt,int points,String fragment,String payload){if(!TYPES.contains(type)||parse(payload)==null)throw new IllegalArgumentException("Ungültiger Rätseltyp oder Payload.");EscapeRoom r=rooms.findById(rid).orElseThrow();r.addPuzzle(new EscapePuzzle(type,prompt,Math.max(10,Math.min(1000,points)),fragment,r.getPuzzles().size(),payload));}
+ @Transactional public void deleteScenario(Long id){scenarios.deleteById(id);}@Transactional public void deleteRoom(Long id){rooms.deleteById(id);}@Transactional public void deletePuzzle(Long id){puzzles.deleteById(id);}@Transactional public void toggle(Long id){scenarios.findById(id).ifPresent(s->s.setActive(!s.isActive()));}
+}

src/main/java/com/example/mindflux/service/GameScoreService.java

@@ -10,6 +10,10 @@ import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import com.example.mindflux.dto.WeeklyActivity;
 
 /**
  * Speichert Spielergebnisse und liefert Statistiken. Der Score wird hier
@@ -110,4 +114,39 @@ public class GameScoreService {
                 .orElse(null);
         return new GameStats(highscore, plays, lastPlayed);
     }
+
+    /**
+     * Aggregiert ausschließlich gespeicherte Abschlusszeiten. Runden ohne gemessene
+     * Dauer zählen für XP, aber bewusst nicht als Spielzeit.
+     */
+    public WeeklyActivity weeklyActivity(String username, LocalDate monday) {
+        LocalDateTime from = monday.atStartOfDay();
+        LocalDateTime until = monday.plusDays(7).atStartOfDay();
+        int[] seconds = new int[7];
+        int[] xp = new int[7];
+
+        for (GameScore score : repository
+                .findByUsernameAndPlayedAtGreaterThanEqualAndPlayedAtLessThanOrderByPlayedAtAsc(username, from, until)) {
+            int day = (int) (score.getPlayedAt().toLocalDate().toEpochDay() - monday.toEpochDay());
+            if (day < 0 || day >= 7) {
+                continue;
+            }
+            xp[day] += Math.max(score.getScore(), 0);
+            if (score.getDurationSeconds() != null) {
+                seconds[day] += Math.max(score.getDurationSeconds(), 0);
+            }
+        }
+
+        List<Integer> minutes = new ArrayList<>(7);
+        List<Integer> weeklyXp = new ArrayList<>(7);
+        int totalSeconds = 0;
+        int totalXp = 0;
+        for (int day = 0; day < 7; day++) {
+            minutes.add((int) Math.ceil(seconds[day] / 60.0));
+            weeklyXp.add(xp[day]);
+            totalSeconds += seconds[day];
+            totalXp += xp[day];
+        }
+        return new WeeklyActivity(minutes, weeklyXp, (int) Math.ceil(totalSeconds / 60.0), totalXp);
+    }
 }

src/main/java/com/example/mindflux/service/NetSimulator.java

@@ -0,0 +1,71 @@
+package com.example.mindflux.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.util.*;
+
+/** Kleine, deterministische IPv4-Simulation für NetWorker. Sie bewertet Erreichbarkeit statt Mustertexte. */
+public final class NetSimulator {
+    private NetSimulator() { }
+    public record Goal(String id, boolean passed, boolean reachable, List<String> trace, String reason, String message) { }
+    public record Simulation(List<Goal> goals) { public boolean allPassed() { return goals.stream().allMatch(Goal::passed); } }
+
+    public static Simulation simulate(JsonNode net) {
+        Map<String, Node> nodes = nodes(net); List<Goal> result = new ArrayList<>();
+        String validation = validation(nodes);
+        for (JsonNode goal : net.path("goals")) {
+            String id = goal.path("id").asText("ziel"), from = goal.path("from").asText(), to = goal.path("to").asText(); boolean expected = goal.path("shouldReach").asBoolean(true);
+            if (validation != null) { result.add(new Goal(id, false, false, List.of(from), "invalid_config", validation)); continue; }
+            Node source = nodes.get(from), target = nodes.get(to);
+            if (source == null || target == null) { result.add(new Goal(id, false, false, List.of(from), "missing_node", "Ein Zielgerät fehlt in der Topologie.")); continue; }
+            Route route = route(nodes, source, target, new LinkedHashSet<>(), 8);
+            boolean passed = route.reachable == expected;
+            String message = passed ? (expected ? "Paket zugestellt." : "Der Sperrpfad bleibt korrekt geschlossen.") : route.message;
+            result.add(new Goal(id, passed, route.reachable, route.trace, route.reason, message));
+        }
+        return new Simulation(result);
+    }
+
+    private static Route route(Map<String, Node> nodes, Node from, Node target, LinkedHashSet<String> seen, int ttl) {
+        if (ttl <= 0) return Route.fail(List.copyOf(seen), "routing_loop", "Die Route endet in einer Schleife.");
+        if (sameSubnet(from.ip, from.prefix, target.ip)) return Route.ok(List.of(from.id, target.id));
+        if (from.gateway == null) return Route.fail(List.of(from.id), "missing_gateway", "Das Paket verlässt das lokale Netz nicht: Es fehlt ein Gateway.");
+        Node router = routerForGateway(nodes, from.gateway);
+        if (router == null || !sameSubnet(from.ip, from.prefix, from.gateway)) return Route.fail(List.of(from.id), "gateway_unreachable", "Das eingetragene Gateway liegt nicht im lokalen Subnetz.");
+        List<String> trace = new ArrayList<>(); trace.add(from.id); trace.add(router.id);
+        Route next = routerRoute(nodes, router, target.ip, seen, ttl - 1);
+        trace.addAll(next.trace);
+        return next.reachable ? Route.ok(trace) : Route.fail(trace, next.reason, next.message);
+    }
+
+    private static Route routerRoute(Map<String, Node> nodes, Node router, long destination, LinkedHashSet<String> seen, int ttl) {
+        if (!seen.add(router.id)) return Route.fail(List.of(router.id), "routing_loop", "Die Router verweisen im Kreis aufeinander.");
+        for (long gateway : router.gateways) if (sameSubnet(gateway, router.gatewayPrefix, destination)) return Route.ok(List.of());
+        JsonNode best = null; int bestPrefix = -1;
+        for (JsonNode route : router.routes) { int prefix = route.path("prefix").asInt(-1); Long network = ip(route.path("network").asText()); if (network != null && prefix >= 0 && sameSubnet(network, prefix, destination) && prefix > bestPrefix) { best = route; bestPrefix = prefix; } }
+        if (best == null) return Route.fail(List.of(), "no_route", "Der Router kennt keine Route zum Zielnetz.");
+        Node next = nodes.get(best.path("nextRouter").asText());
+        if (next == null || !"router".equals(next.type)) return Route.fail(List.of(), "invalid_route", "Die statische Route zeigt auf keinen erreichbaren Router.");
+        Route onward = routerRoute(nodes, next, destination, seen, ttl - 1);
+        List<String> trace = new ArrayList<>(); trace.add(next.id); trace.addAll(onward.trace); return onward.reachable ? Route.ok(trace) : Route.fail(trace, onward.reason, onward.message);
+    }
+
+    private static String validation(Map<String, Node> nodes) {
+        Map<String, String> ips = new HashMap<>();
+        for (Node node : nodes.values()) {
+            if (!"router".equals(node.type) && node.ip == null) return node.id + " enthält keine gültige IPv4-Adresse.";
+            if (node.ip == null || node.prefix < 0 || node.prefix > 30) continue;
+            if (hostPart(node.ip, node.prefix) == 0) return node.id + " nutzt eine Netzadresse statt einer Hostadresse.";
+            if (hostPart(node.ip, node.prefix) == hostMask(node.prefix)) return node.id + " nutzt eine Broadcast-Adresse statt einer Hostadresse.";
+            String previous = ips.putIfAbsent(node.ip + "/" + node.prefix, node.id); if (previous != null) return previous + " und " + node.id + " besitzen dieselbe IP-Adresse.";
+        }
+        return null;
+    }
+    private static Map<String, Node> nodes(JsonNode net) { Map<String, Node> result = new LinkedHashMap<>(); for (JsonNode raw : net.path("nodes")) { String id=raw.path("id").asText(); if(id.isBlank()) continue; List<Long> gateways=new ArrayList<>(); for(JsonNode value:raw.path("gateways")){Long parsed=ip(value.asText());if(parsed!=null)gateways.add(parsed);} List<JsonNode> routes=new ArrayList<>(); raw.path("routes").forEach(routes::add); Long address=ip(raw.path("ip").asText()); Long gateway=ip(raw.path("gateway").asText()); result.put(id,new Node(id,raw.path("type").asText("host"),address,raw.path("prefix").asInt(-1),gateway,gateways,raw.path("gatewayPrefix").asInt(24),routes)); } return result; }
+    private static Node routerForGateway(Map<String, Node> nodes, long gateway) { return nodes.values().stream().filter(n -> n.gateways.contains(gateway)).findFirst().orElse(null); }
+    private static Long ip(String raw) { try { String[] p=raw.trim().split("\\."); if(p.length!=4)return null; long n=0; for(String part:p){int v=Integer.parseInt(part);if(v<0||v>255)return null;n=(n<<8)|v;} return n; } catch(Exception ignored){return null;} }
+    private static boolean sameSubnet(long first,int prefix,long second){ if(prefix<0||prefix>32)return false; long mask=prefix==0?0:(0xffffffffL<<(32-prefix))&0xffffffffL; return (first&mask)==(second&mask); }
+    private static long hostPart(long address,int prefix){long mask=prefix==0?0:(0xffffffffL<<(32-prefix))&0xffffffffL;return address&~mask&0xffffffffL;}
+    private static long hostMask(int prefix){return prefix==32?0:(1L<<(32-prefix))-1;}
+    private record Node(String id,String type,Long ip,int prefix,Long gateway,List<Long> gateways,int gatewayPrefix,List<JsonNode> routes) { }
+    private record Route(boolean reachable,List<String> trace,String reason,String message) { static Route ok(List<String> trace){return new Route(true,trace,"","Paket zugestellt.");} static Route fail(List<String> trace,String reason,String message){return new Route(false,trace,reason,message);} }
+}

src/main/java/com/example/mindflux/service/NetworkerService.java

@@ -0,0 +1,28 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.dto.*;
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.*;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.node.*;
+import jakarta.servlet.http.HttpSession;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+
+@Service
+public class NetworkerService {
+    private static final String GAME="networker"; private static final int MAX_DURATION=14_400;
+    private final NetworkWorldRepository worlds; private final NetworkLevelRepository levels; private final GameScoreService scores; private final AchievementService achievements; private final ObjectMapper mapper;
+    public NetworkerService(NetworkWorldRepository worlds, NetworkLevelRepository levels, GameScoreService scores, AchievementService achievements, ObjectMapper mapper){this.worlds=worlds;this.levels=levels;this.scores=scores;this.achievements=achievements;this.mapper=mapper;}
+    @Transactional(readOnly=true) public JsonNode catalog(){ObjectNode root=mapper.createObjectNode();ArrayNode rows=root.putArray("worlds");for(NetworkWorld w:worlds.findAllByActiveTrueOrderBySortOrderAscIdAsc()){ObjectNode row=rows.addObject();row.put("slug",w.getSlug());row.put("title",w.getTitle());row.put("description",w.getDescription());row.put("difficulty",w.getDifficulty());row.put("examScope",w.getExamScope());row.put("levelCount",w.getLevels().size());}return root;}
+    @Transactional(readOnly=true) public JsonNode session(String slug,HttpSession http){NetworkWorld world=worlds.findBySlug(slug).filter(NetworkWorld::isActive).orElseThrow(()->new IllegalArgumentException("Netzwelt nicht gefunden."));ObjectNode root=mapper.createObjectNode();root.put("slug",world.getSlug());root.put("title",world.getTitle());root.put("description",world.getDescription());root.put("difficulty",world.getDifficulty());root.put("examScope",world.getExamScope());ArrayNode rows=root.putArray("levels");Map<Long,JsonNode> payloads=new HashMap<>();int max=0;for(NetworkLevel level:world.getLevels()){JsonNode raw=parse(level.getPayload());if(!(raw instanceof ObjectNode node))continue;payloads.put(level.getId(),node);ObjectNode row=rows.addObject();row.put("levelId",level.getId());row.put("title",level.getTitle());row.put("type",level.getLevelType());row.put("points",level.getPoints());row.set("network",sanitize(node));max+=level.getPoints();}root.put("maxScore",max);http.setAttribute("networker.run",new Run(world.getSlug(),payloads));return root;}
+    @Transactional(readOnly=true) public JsonNode check(NetworkCheckRequest request,HttpSession http){if(request==null||request.getLevelId()==null)throw new IllegalArgumentException("Level fehlt.");Run run=run(http);JsonNode raw=run.payloads.get(request.getLevelId());if(raw==null)throw new IllegalArgumentException("Level gehört nicht zu dieser Welt.");State state=run.states.computeIfAbsent(request.getLevelId(),ignored->new State());if(state.done)throw new IllegalArgumentException("Dieses Level ist bereits abgeschlossen.");if(!request.isReveal()&&state.attempts>=3)throw new IllegalArgumentException("Nach drei Versuchen kannst du die Lösung anzeigen.");ObjectNode merged=request.isReveal()?solution(raw):merge(raw,request.getConfig());NetSimulator.Simulation simulation=NetSimulator.simulate(merged);boolean passed=simulation.allPassed();if(request.isReveal()){state.revealed=true;state.done=true;}else{state.attempts++;if(passed)state.done=true;}state.passed=passed;ObjectNode result=mapper.createObjectNode();result.put("allPassed",passed);result.put("resolved",state.done);result.put("attempts",state.attempts);result.put("revealed",state.revealed);ArrayNode goals=result.putArray("goals");for(NetSimulator.Goal goal:simulation.goals()){ObjectNode row=goals.addObject();row.put("id",goal.id());row.put("passed",goal.passed());row.put("reachable",goal.reachable());row.put("reason",goal.reason());row.put("message",goal.message());ArrayNode trace=row.putArray("trace");goal.trace().forEach(trace::add);}if(request.isReveal())result.set("solution",sanitize(solution(raw)));return result;}
+    @Transactional public NetworkResult finish(String username,NetworkFinishRequest request,HttpSession http){if(request==null||blank(request.getSlug())||request.getDurationSeconds()<1||request.getDurationSeconds()>MAX_DURATION)throw new IllegalArgumentException("Unplausibler Abschluss.");Run run=run(http);if(!run.slug.equals(request.getSlug()))throw new IllegalArgumentException("Diese Welt wurde nicht angefordert.");NetworkWorld world=worlds.findBySlug(request.getSlug()).filter(NetworkWorld::isActive).orElseThrow(()->new IllegalArgumentException("Netzwelt nicht gefunden."));int score=0,max=0,solved=0;boolean perfect=true;for(NetworkLevel level:world.getLevels()){max+=level.getPoints();State state=run.states.get(level.getId());if(state!=null&&state.done&&state.passed&&!state.revealed){solved++;score+=(int)Math.round(level.getPoints()*(state.attempts==1?1:state.attempts==2?.6:.3));if(state.attempts!=1)perfect=false;}else perfect=false;}int stars=stars(score,max);ScoreResult saved=scores.recordScore(username,GAME,world.getSlug(),score,solved,request.getDurationSeconds());if(solved>0)achievements.awardSpecial(username,"Paketbote","Schließe deine erste NetWorker-Welt ab.");if(perfect&&solved==world.getLevels().size())achievements.awardSpecial(username,"Blueprint-Profi","Löse eine NetWorker-Welt fehlerfrei.");http.removeAttribute("networker.run");return new NetworkResult(score,max,solved,world.getLevels().size(),stars,saved.getHighscore(),saved.isNewHighscore(),saved.getPlays(),perfect);}
+    private ObjectNode sanitize(ObjectNode raw){ObjectNode safe=raw.deepCopy();safe.remove("solution");return safe;}
+    private ObjectNode solution(JsonNode raw){ObjectNode result=((ObjectNode)raw).deepCopy();JsonNode solution=result.path("solution");if(solution.isObject())apply(result,(ObjectNode)solution);result.remove("solution");return result;}
+    private ObjectNode merge(JsonNode raw,JsonNode submitted){ObjectNode result=((ObjectNode)raw).deepCopy();if(submitted instanceof ObjectNode node)apply(result,node);result.remove("solution");return result;}
+    private void apply(ObjectNode target,ObjectNode submitted){Map<String,ObjectNode> incoming=new HashMap<>();submitted.path("nodes").forEach(node->{if(node instanceof ObjectNode value&&!value.path("id").asText().isBlank())incoming.put(value.path("id").asText(),value);});for(JsonNode node:target.path("nodes")){if(!(node instanceof ObjectNode editable))continue;ObjectNode value=incoming.get(editable.path("id").asText());if(value==null)continue;Set<String> fields=new HashSet<>();editable.path("editable").forEach(field->fields.add(field.asText()));for(String field:fields){if(!value.has(field))continue;if(field.equals("routes")&&value.path(field).isArray())editable.set(field,value.get(field));else if(value.get(field).isValueNode())editable.set(field,value.get(field));}}}
+    private JsonNode parse(String raw){try{return mapper.readTree(raw);}catch(Exception e){return null;}} private int stars(int score,int max){if(max<=0||score<=0)return 0;double ratio=(double)score/max;return ratio>=.8?3:ratio>=.5?2:1;}private boolean blank(String value){return value==null||value.isBlank();}private Run run(HttpSession session){Object value=session.getAttribute("networker.run");if(value instanceof Run run)return run;throw new IllegalArgumentException("Fordere zuerst eine Netzwelt an.");}
+    static class Run {final String slug;final Map<Long,JsonNode> payloads;final Map<Long,State> states=new HashMap<>();Run(String slug,Map<Long,JsonNode> payloads){this.slug=slug;this.payloads=Map.copyOf(payloads);}} static class State{int attempts;boolean done,revealed,passed;}
+}

src/main/java/com/example/mindflux/service/NeuralNetService.java

@@ -0,0 +1,62 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.model.*;
+import com.example.mindflux.repository.*;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class NeuralNetService {
+    private final NeuralNetPrivacyRepository privacy;
+    private final NeuralNetConnectionRepository connections;
+    private final NeuralNetMessageRepository messages;
+    private final UserRepository users;
+    public NeuralNetService(NeuralNetPrivacyRepository privacy, NeuralNetConnectionRepository connections, NeuralNetMessageRepository messages, UserRepository users) {
+        this.privacy=privacy; this.connections=connections; this.messages=messages; this.users=users;
+    }
+    public record Overview(String username, boolean enabled, List<String> connections, List<String> incoming, List<String> outgoing, long unread) {}
+    public record ChatMessage(long id, String sender, String body, LocalDateTime sentAt) {}
+    private boolean enabled(String username) { return privacy.findById(username).map(NeuralNetPrivacy::isEnabled).orElse(false); }
+    private void requireEnabled(String username) { if (!enabled(username)) throw new ResponseStatusException(HttpStatus.FORBIDDEN, "NeuralNet ist für dieses Konto nicht aktiviert."); }
+    private void requireConnection(String a, String b) { if (connections.acceptedBetween(a,b).isEmpty()) throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Private Nachrichten sind erst nach bestätigter Verbindung möglich."); }
+    public void enable(String username) { privacy.save(new NeuralNetPrivacy(username, true)); }
+    @Transactional(readOnly = true)
+    public Overview overview(String username) {
+        if (!enabled(username)) return new Overview(username, false, List.of(), List.of(), List.of(), 0);
+        List<String> accepted=connections.acceptedFor(username).stream().map(c -> c.getRequester().equals(username) ? c.getAddressee() : c.getRequester()).toList();
+        List<String> incoming=connections.findByAddresseeAndStatusOrderByCreatedAtAsc(username,"PENDING").stream().map(NeuralNetConnection::getRequester).toList();
+        List<String> outgoing=connections.findByRequesterAndStatusOrderByCreatedAtAsc(username,"PENDING").stream().map(NeuralNetConnection::getAddressee).toList();
+        return new Overview(username, true, accepted, incoming, outgoing, messages.countByRecipientAndReadAtIsNull(username));
+    }
+    public void request(String username, String target) {
+        requireEnabled(username); target=cleanUser(target);
+        var targetUser=users.findByUsernameIgnoreCase(target).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Dieses NeuralNet-Mitglied ist nicht verfügbar."));
+        target=targetUser.getUsername();
+        if (username.equalsIgnoreCase(target) || !enabled(target)) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Dieses NeuralNet-Mitglied ist nicht verfügbar.");
+        if (connections.findByRequesterAndAddressee(username,target).isPresent() || connections.findByRequesterAndAddressee(target,username).isPresent()) throw new ResponseStatusException(HttpStatus.CONFLICT, "Zwischen euch besteht bereits eine Anfrage oder Verbindung.");
+        connections.save(new NeuralNetConnection(username,target));
+    }
+    public void accept(String username, String requester) { var c=pendingFor(username,requester); c.setStatus("ACCEPTED"); c.setRespondedAt(LocalDateTime.now()); connections.save(c); }
+    public void decline(String username, String requester) { connections.delete(pendingFor(username,requester)); }
+    public void cancel(String username, String target) { connections.delete(connections.findByRequesterAndAddressee(username,cleanUser(target)).filter(c -> c.getStatus().equals("PENDING")).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "Anfrage nicht gefunden."))); }
+    @Transactional
+    public List<ChatMessage> conversation(String username, String other) {
+        requireEnabled(username); other=cleanUser(other); requireConnection(username,other);
+        var result=messages.conversation(username,other);
+        result.stream().filter(m -> m.getRecipient().equals(username) && m.getReadAt()==null).forEach(m -> m.setReadAt(LocalDateTime.now()));
+        return result.stream().map(m -> new ChatMessage(m.getId(),m.getSender(),m.getBody(),m.getSentAt())).toList();
+    }
+    public ChatMessage send(String username, String recipient, String body) {
+        requireEnabled(username); recipient=cleanUser(recipient); requireConnection(username,recipient);
+        String text=body==null ? "" : body.trim();
+        if (text.isBlank() || text.length()>2000) throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Eine Nachricht benötigt 1 bis 2000 Zeichen.");
+        var m=messages.save(new NeuralNetMessage(username,recipient,text));
+        return new ChatMessage(m.getId(),m.getSender(),m.getBody(),m.getSentAt());
+    }
+    private NeuralNetConnection pendingFor(String addressee,String requester) { return connections.findByRequesterAndAddressee(cleanUser(requester),addressee).filter(c -> c.getStatus().equals("PENDING")).orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND,"Anfrage nicht gefunden.")); }
+    private String cleanUser(String username) { if (username==null || username.trim().isBlank() || username.trim().length()>100) throw new ResponseStatusException(HttpStatus.BAD_REQUEST,"Ungültiger Benutzername."); return username.trim(); }
+}

src/main/java/com/example/mindflux/service/PlatformStatusService.java

@@ -0,0 +1,37 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.dto.PlatformStatus;
+import com.example.mindflux.repository.GameScoreRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataAccessException;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+
+@Service
+public class PlatformStatusService {
+
+    private static final Logger log = LoggerFactory.getLogger(PlatformStatusService.class);
+    private static final int REGISTERED_MODULES = 9;
+
+    private final GameScoreRepository gameScoreRepository;
+
+    public PlatformStatusService(GameScoreRepository gameScoreRepository) {
+        this.gameScoreRepository = gameScoreRepository;
+    }
+
+    /**
+     * Die Abfrage ist absichtlich echt: Nur wenn der Fortschrittsspeicher lesbar
+     * ist, meldet das Dashboard das Lernnetz als bereit.
+     */
+    public PlatformStatus currentStatus() {
+        try {
+            gameScoreRepository.count();
+            return new PlatformStatus(true, REGISTERED_MODULES, Instant.now());
+        } catch (DataAccessException exception) {
+            log.warn("Fortschrittsspeicher ist für den Lernnetz-Status nicht erreichbar: {}", exception.getMessage());
+            return new PlatformStatus(false, REGISTERED_MODULES, Instant.now());
+        }
+    }
+}

src/main/java/com/example/mindflux/service/ProfileExportService.java

@@ -0,0 +1,114 @@
+package com.example.mindflux.service;
+
+import com.example.mindflux.model.Achievement;
+import com.example.mindflux.model.GameScore;
+import com.example.mindflux.model.NeuralNetConnection;
+import com.example.mindflux.model.NeuralNetMessage;
+import com.example.mindflux.model.User;
+import com.example.mindflux.repository.AchievementRepository;
+import com.example.mindflux.repository.GameScoreRepository;
+import com.example.mindflux.repository.NeuralNetConnectionRepository;
+import com.example.mindflux.repository.NeuralNetMessageRepository;
+import com.example.mindflux.repository.NeuralNetPrivacyRepository;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Sammelt alle personenbezogenen Daten eines Kontos für den DSGVO-Datenexport
+ * (Art. 20 – Datenübertragbarkeit). Bewusst OHNE das Passwort-Hash; nur Daten,
+ * die die betroffene Person selbst erzeugt hat.
+ */
+@Service
+public class ProfileExportService {
+
+    private final UserService userService;
+    private final GameScoreRepository scores;
+    private final AchievementRepository achievements;
+    private final NeuralNetPrivacyRepository privacy;
+    private final NeuralNetConnectionRepository connections;
+    private final NeuralNetMessageRepository messages;
+
+    public ProfileExportService(UserService userService, GameScoreRepository scores,
+                                AchievementRepository achievements, NeuralNetPrivacyRepository privacy,
+                                NeuralNetConnectionRepository connections, NeuralNetMessageRepository messages) {
+        this.userService = userService;
+        this.scores = scores;
+        this.achievements = achievements;
+        this.privacy = privacy;
+        this.connections = connections;
+        this.messages = messages;
+    }
+
+    public Map<String, Object> export(String username) {
+        Map<String, Object> out = new LinkedHashMap<>();
+        out.put("exportiertAm", LocalDateTime.now().toString());
+        out.put("hinweis", "DSGVO-Datenexport (Art. 20). Enthält alle zu diesem Konto gespeicherten "
+                + "personenbezogenen Daten außer dem Passwort-Hash.");
+
+        User user = userService.findByUsername(username);
+        Map<String, Object> account = new LinkedHashMap<>();
+        if (user != null) {
+            account.put("benutzername", user.getUsername());
+            account.put("email", user.getEmail());
+            account.put("rolle", user.getRole());
+            account.put("emailBestaetigt", user.isEmailVerified());
+            account.put("hatProfilbild", user.getProfilePicture() != null && !user.getProfilePicture().isBlank());
+        }
+        out.put("konto", account);
+
+        List<Map<String, Object>> scoreList = new ArrayList<>();
+        for (GameScore s : scores.findByUsernameOrderByPlayedAtDesc(username)) {
+            Map<String, Object> m = new LinkedHashMap<>();
+            m.put("spiel", s.getGame());
+            m.put("deck", s.getDeck());
+            m.put("punkte", s.getScore());
+            m.put("zuege", s.getMoves());
+            m.put("dauerSekunden", s.getDurationSeconds());
+            m.put("gespieltAm", s.getPlayedAt() != null ? s.getPlayedAt().toString() : null);
+            scoreList.add(m);
+        }
+        out.put("spielstaende", scoreList);
+
+        List<Map<String, Object>> achievementList = new ArrayList<>();
+        for (Achievement a : achievements.findByUsername(username)) {
+            Map<String, Object> m = new LinkedHashMap<>();
+            m.put("titel", a.getTitle());
+            m.put("beschreibung", a.getDescription());
+            m.put("erreichtAm", a.getDateAchieved() != null ? a.getDateAchieved().toString() : null);
+            achievementList.add(m);
+        }
+        out.put("erfolge", achievementList);
+
+        Map<String, Object> neural = new LinkedHashMap<>();
+        neural.put("nachrichtenAktiviert", privacy.findById(username).map(p -> p.isEnabled()).orElse(false));
+        List<Map<String, Object>> connList = new ArrayList<>();
+        for (NeuralNetConnection c : connections.findAllInvolving(username)) {
+            Map<String, Object> m = new LinkedHashMap<>();
+            m.put("anfragender", c.getRequester());
+            m.put("empfaenger", c.getAddressee());
+            m.put("status", c.getStatus());
+            m.put("erstelltAm", c.getCreatedAt() != null ? c.getCreatedAt().toString() : null);
+            connList.add(m);
+        }
+        neural.put("verbindungen", connList);
+        List<Map<String, Object>> msgList = new ArrayList<>();
+        for (NeuralNetMessage msg : messages.findAllInvolving(username)) {
+            Map<String, Object> m = new LinkedHashMap<>();
+            m.put("von", msg.getSender());
+            m.put("an", msg.getRecipient());
+            m.put("text", msg.getBody());
+            m.put("gesendetAm", msg.getSentAt() != null ? msg.getSentAt().toString() : null);
+            m.put("gelesen", msg.getReadAt() != null);
+            msgList.add(m);
+        }
+        neural.put("nachrichten", msgList);
+        out.put("neuralNet", neural);
+
+        return out;
+    }
+}

src/main/java/com/example/mindflux/service/ProgressService.java

@@ -3,6 +3,7 @@ package com.example.mindflux.service;
 import com.example.mindflux.dto.GameProgress;
 import com.example.mindflux.dto.GameStats;
 import com.example.mindflux.dto.ProgressData;
+import com.example.mindflux.dto.WeeklyActivity;
 
 import org.springframework.stereotype.Service;
 
@@ -11,6 +12,9 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Comparator;
+import java.time.temporal.TemporalAdjusters;
+import java.time.DayOfWeek;
 
 @Service
 public class ProgressService {
@@ -22,7 +26,7 @@ public class ProgressService {
         GAMES.put("techtacular", "TechTacular");
         GAMES.put("devlab", "DevLab");
         GAMES.put("syntax-saga", "SyntaxSaga");
-        GAMES.put("codeescape", "CodeEscape");
+        GAMES.put("codeescape", "SystemEscape");
         GAMES.put("serviceclash", "ServiceClash");
         GAMES.put("bughunter", "BugHunter");
         GAMES.put("networker", "NetWorker");
@@ -91,6 +95,25 @@ public class ProgressService {
         return result;
     }
 
+    /** Aktuelle Wochenwerte, jeweils Montag bis Sonntag. */
+    public WeeklyActivity getCurrentWeekActivity(String username) {
+        LocalDate monday = LocalDate.now().with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
+        return gameScoreService.weeklyActivity(username, monday);
+    }
+
+    /** Die tatsächlich gespielten Spiele, nach ihrem Highscore sortiert. */
+    public List<GameProgress> getTopGames(String username, int limit) {
+        List<GameProgress> games = getGameProgress(username).stream()
+                .filter(game -> game.getPlays() > 0)
+                .sorted(Comparator.comparingInt(GameProgress::getHighscore).reversed()
+                        .thenComparing(Comparator.comparingInt(GameProgress::getPlays).reversed()))
+                .limit(limit)
+                .toList();
+        int topScore = games.stream().mapToInt(GameProgress::getHighscore).max().orElse(1);
+        games.forEach(game -> game.setProgressPercent(Math.round(game.getHighscore() * 100f / topScore)));
+        return games;
+    }
+
     private GameProgress toGameProgress(String displayName, GameStats stats) {
         GameProgress game = new GameProgress();
         game.setName(displayName);