feat(onboarding, screens): Logging für Screen-Loads ergänzt & Biest-Referenzen entfernt

Signed-off-by: Stefan Mogeritsch <stefan.mo.co@gmail.com>

AGENTS.md

@@ -1,10 +1,11 @@
-# 🤖 Projekt Agenten & Protokoll (Meldestelle-Biest)
+# 🤖 Projekt Agenten & Protokoll (Meldestelle)
 
 Dieses Dokument definiert die Zusammenarbeit zwischen dem User (Owner) und den spezialisierten KI-Agenten.
 Es dient als zentraler **System-Prompt-Erweiterung** für neue Chat-Sessions.
 
 ## 🚀 Strategische Ausrichtung
-Das Projekt **"Meldestelle-Biest"** entwickelt eine ÖTO/FEI-konforme, offline-fähige Turnier-Software.
+
+Das Projekt **"Meldestelle"** entwickelt eine ÖTO/FEI-konforme, offline-fähige Turnier-Software.
 1. **Desktop-First:** Primäres Ziel ist die Compose Desktop App (KMP). UX & Performance sind auf Profis optimiert.
 2. **Offline-First:** Das System muss autark (ohne Internet) funktionieren. Sync-Logik ist Kernbestandteil.
 3. **Domain-Driven:** 6 Bounded Contexts (SCS) bilden den fachlichen Rahmen.
@@ -29,7 +30,7 @@ Jede Agenten-Antwort **muss** mit dem entsprechenden Badge beginnen, um den Kont
 *   **🧹 [Curator]**: Wissens-Management & Dokumentations-Check (ADR, Reference, Journal). Beendet jede Session.
     *   [Playbook](docs/04_Agents/Playbooks/Curator.md)
 
-## 2. Der "Biest"-Workflow
+## 2. Der "Meldestelle"-Workflow
 1.  **Kontext-Check:** Lies immer zuerst die `MASTER_ROADMAP` in `docs/01_Architecture/`.
 2.  **SCS-Rahmen:** Identifiziere, in welchem der 6 Bounded Contexts du arbeitest.
 3.  **Fokus:** Bearbeite immer nur EINE fachliche Aufgabe pro Session.

backend/services/masterdata/masterdata-service/src/main/resources/application.yml

@@ -21,8 +21,10 @@ spring:
         register: ${CONSUL_ENABLED:true}
         prefer-ip-address: true
         health-check-path: /actuator/health
-        health-check-interval: 10s
-        health-check-port: 8086 # Spring Boot Management Port (Actuator)
+        health-check-interval: 20s
+        health-check-timeout: 10s
+        # deregister-critical-service-after: 5m
+        # health-check-port: 8086 # Spring Boot Management Port (Actuator)
         instance-id: ${spring.application.name}:${server.port}:${random.uuid}
         service-name: ${spring.application.name}
         port: ${masterdata.http.port:8091} # Ktor API Port registrieren (Gateway Ziel)

docs/99_Journal/2026-04-17_Cleanup-Veranstaltung-Screens-V2-Removal.md

@@ -0,0 +1,49 @@
+# Session Journal: 2026-04-17 - Aufräumarbeiten & Konsolidierung
+
+## 🎯 Ziele der Session
+
+1. **V2-Cleanup:** Entfernung aller `V2`-Suffixe aus dem Codebase (Modelle, Stores, Wizards), um eine konsolidierte "
+   Source of Truth" zu schaffen.
+2. **Refactoring:** Zerlegung der massiven `VeranstaltungKonfig`-Komponente in wartbare Teil-Module.
+3. **Duplikat-Entfernung:** Zentralisierung von UI-Logik (DatePicker, Validierung) zur Reduzierung von Code-Duplikaten.
+
+## 🛠️ Durchgeführte Änderungen
+
+### 🧹 1. Konsolidierung der Benamung (V2-Entfernung)
+
+* **Änderungen:**
+  * `VeranstaltungKonfigV2` -> `VeranstaltungKonfig`
+  * `VeranstaltungV2` -> `Veranstaltung`
+  * `TurnierV2` -> `Turnier`
+  * `StoreV2` -> `Store`
+  * `TurnierStoreV2` -> `TurnierStore`
+  * `TurnierWizardV2` -> `TurnierWizard`
+* **Grund:** Umsetzung der Vereinbarung, nur noch eine "echte" Version zu pflegen und Altlasten aus Migrationsphasen zu
+  entfernen. Alle Referenzen im gesamten Projekt (`DesktopMainLayout.kt`, `ManagementScreens.kt`, `main.kt`) wurden
+  erfolgreich aktualisiert.
+
+### 🏗️ 2. Refactoring `VeranstaltungScreens.kt`
+
+* **Extraktion:** Die Wizard-Schritte wurden in eigenständige Composable-Funktionen ausgelagert:
+  * `Step1Veranstalter`: Auswahl aus ZNS/Lokal-Bestand.
+  * `Step2Basisdaten`: Titel, Zeitraum, Ort, Disziplinen.
+  * `Step3Details`: Logo, Sponsoren, Bewerbs-Management.
+* **Zentralisierung:**
+  * Neue Komponente `AppDatePickerDialog` zur Vermeidung von dreifach redundantem Dialog-Code.
+  * Konsolidierte Validierungslogik für den Veranstaltungszeitraum.
+
+### 🏷️ 3. Fehlerbehebung & Qualitätssicherung
+
+* **Syntax-Fix:** Korrektur von Klammerfehlern, die während des Refactorings in der großen `VeranstaltungScreens.kt`
+  entstanden sind.
+* **Linting:** Erfolgreiche Validierung der Dateien `VeranstaltungScreens.kt`, `Stores.kt` und `DesktopMainLayout.kt`.
+
+## ✅ Ergebnis & Status
+
+* Der Code ist nun wesentlich modularer und besser lesbar.
+* Die Benamung ist konsistent ohne verwirrende Versions-Suffixe.
+* Redundante Logik-Blöcke (besonders beim Datum-Handling) wurden eliminiert.
+
+---
+**🏗️ [Lead Architect]** & **🧹 [Curator]**
+Datum: 17. April 2026 | Status: Abgeschlossen

docs/99_Journal/2026-04-17_Desktop-Reorganisation-V2-Removal.md

@@ -0,0 +1,50 @@
+# Journal: Desktop-Struktur Reorganisation & V2-Eliminierung
+
+**Datum:** 17. April 2026
+**Agent:** 🏗️ [Lead Architect] & 🧹 [Curator]
+
+## 🎯 Zielsetzung
+
+Eliminierung des veralteten `at/mocode/desktop/v2` Verzeichnisses und Überführung der Komponenten in eine logisch
+strukturierte Paket-Hierarchie unter `at.mocode.desktop.screens`. Entfernung aller `V2` Suffixe in Funktions- und
+Klassennamen.
+
+## 🛠️ Durchgeführte Änderungen
+
+### 1. Dateireorganisation (Verschiebung & Aufteilung)
+
+- **Daten:** `Stores.kt` und der neu extrahierte `TurnierStore.kt` befinden sich nun in `at.mocode.desktop.data`.
+- **Theme:** Das globale `DesktopTheme` wurde nach `at.mocode.desktop.theme` verschoben und von `DesktopThemeV2` in
+  `DesktopTheme` umbenannt.
+- **Screens:** Die massiven Screen-Dateien wurden fachlich aufgeteilt:
+  - `at.mocode.desktop.screens.management`: `ManagementScreens.kt`, `VeranstalterScreens.kt` (extrahiert aus
+    `Screens.kt`).
+  - `at.mocode.desktop.screens.onboarding`: `OnboardingScreen.kt` (extrahiert aus `Screens.kt`).
+  - `at.mocode.desktop.screens.profile`: `ProfileScreens.kt` (enthält nun nur noch die Profil-Ansichten für Reiter,
+    Pferde, Vereine und Funktionäre).
+  - `at.mocode.desktop.screens.veranstaltung`: `VeranstaltungScreens.kt`.
+  - `at.mocode.desktop.screens.nennung`: `NennungsEingangScreen.kt`.
+
+### 2. Namens-Konsolidierung
+
+- Alle Funktionen wurden von ihrem `V2` Suffix befreit (z.B. `PferdProfilV2` -> `PferdProfil`, `VeranstalterDetailV2` ->
+  `VeranstalterDetail`).
+- Ungenutzte Code-Fragmente wurden im Zuge des Refactorings eliminiert.
+
+### 3. Infrastruktur-Updates
+
+- `DesktopMainLayout.kt` wurde vollständig auf die neue Struktur migriert. Alle statischen Pfad-Referenzen auf `v2`
+  wurden entfernt.
+- `main.kt` nutzt nun den korrekten Pfad für den Daten-Seed (`at.mocode.desktop.data.Store.seed()`).
+- In `TurnierStammdatenTab.kt` wurde der Reflection-Zugriff auf den `TurnierStore` an die neue Paketstruktur angepasst.
+
+## ✅ Verifikation
+
+- Manuelle Prüfung der Paket-Deklarationen in allen verschobenen Dateien.
+- Syntax-Check der Haupt-Layout-Datei `DesktopMainLayout.kt`.
+- Der Ordner `at/mocode/desktop/v2` wurde physisch vom Dateisystem entfernt.
+
+## 🧹 Abschluss
+
+Die Desktop-App verfügt nun über eine saubere, wartbare Modulstruktur, die den Übergang von Prototyp-Code zu finalen
+Feature-Komponenten unterstützt.

docs/99_Journal/2026-04-17_Desktop-Wizard-OETO-ZNS-Update.md

@@ -0,0 +1,72 @@
+# Session Journal: 2026-04-17 - Vormittag
+
+## 🎯 Ziele der Session
+
+1. **Technischer Blocker:** Stabilisierung des Consul-Health-Checks für den `masterdata-service`.
+2. **ÖTO-Konformität:** Implementierung von Guardrails für Turnier-Zeitspannen (1-2 Tage für C-Turniere) im
+   Desktop-Wizard.
+3. **OEPS-Validierung:** Sicherstellung korrekter Vereinsnummern (B-NNN) bei manueller Erfassung.
+4. **UX-Polishing:** Integration des ZNS-Synchronisationsstatus in die Footer-Bar der Desktop-App.
+
+## 🛠️ Durchgeführte Änderungen
+
+### 🔧 1. Backend: Consul & Master-Data (Infrastruktur)
+
+* **Datei:** `backend/services/masterdata/masterdata-service/src/main/resources/application.yml`
+* **Änderung:**
+  * `health-check-interval` von 10s auf 20s erhöht.
+  * `health-check-timeout` auf 10s gesetzt.
+  * `deregister-critical-service-after` auf 5m gesetzt.
+* **Grund:** Vermeidung von "Ghost-Failures" im Consul-Dashboard, wenn die Datenbank-Verbindung während des Ktor-Starts
+  noch nicht vollständig bereit ist.
+* **Update:** Problematische Properties `deregister-critical-service-after` und `health-check-port` vorerst
+  auskommentiert, da diese in der aktuellen Konfiguration zu Auflösungsfehlern führten.
+
+### 📜 2. Frontend: ÖTO-Guardrails (Wizard Schritt 2)
+
+* **Datei:** `frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/v2/VeranstaltungScreens.kt`
+* **Änderung:**
+  * Logik zur Berechnung der Turniertage (`ChronoUnit.DAYS`) eingebaut.
+  * Einblendung eines Info-Badges: *"Hinweis: Gemäß ÖTO sind C-Turniere auf 2 Tage begrenzt."*, falls die Zeitspanne > 2
+    Tage ist.
+  * **Korrektur:** Typ-Mismatch bei `Icon` behoben (Parameter `color` zu `tint` geändert).
+  * Kein harter Block, sondern eine fachliche Hilfestellung (Guardrails).
+
+### 🏷️ 3. Frontend: OEPS-Nummer Validierung
+
+* **Datei:** `frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/v2/VeranstaltungScreens.kt`
+* **Änderung:**
+  * Regex-Validierung (`^[1-9]-[0-9]{3}$`) für die manuelle OEPS-Nummern-Eingabe hinzugefügt.
+  * Fehlermeldung bei falschem Format (z.B. "4-001" erforderlich).
+* **Grund:** Sicherstellung der Datenqualität für den späteren OEPS-Ergebnisexport (A/B/C-Sätze).
+
+### 🎨 4. UX: Status-Bar & ZNS-Badge
+
+* **Datei:**
+  `frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/layout/DesktopMainLayout.kt`
+* **Änderung:**
+  * `ZnsImportProvider` in die `DesktopFooterBar` injiziert.
+  * Neues Status-Icon `Dataset` (ZNS) hinzugefügt.
+  * Anzeige der letzten Sync-Version (z.B. `ZNS: V12` oder `ZNS: Kein Sync`).
+  * Farbliche Kennzeichnung (Grün/Gelb/Rot) je nach Synchronisationsstand.
+
+### 🏗️ 5. Fachlich: Disziplinen & Bewerbe (Schritt 2 & 3)
+
+* **Datei:** `frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/v2/VeranstaltungScreens.kt`
+* **Änderung:**
+  * **Schritt 2:** Felder für PLZ und Disziplin-Auswahl (Springen, Dressur, etc.) hinzugefügt.
+  * **Schritt 3:** Komplettes Bewerbs-Management implementiert. User können Prüfungsnummern, Klassen und Bezeichnungen
+    erfassen.
+  * **Validierung:** Der Wizard lässt sich erst finalisieren, wenn mindestens ein Bewerb angelegt wurde.
+* **Grund:** Vorbereitung der Datenstruktur für den OEPS-Export und Verbesserung der fachlichen Abdeckung im Wizard.
+
+## ✅ Ergebnis & Status
+
+* Das Consul-Dashboard sollte nun einen stabilen "Grün"-Status für den `masterdata-service` anzeigen.
+* Der Desktop-Wizard leitet den User fachlich korrekt durch die Turnier-Anlage.
+* Der User hat jederzeit volle Transparenz über den Stand seiner lokalen ZNS-Daten.
+* Die Erfassung von Bewerben legt den Grundstein für die spätere Nennungs- und Ergebnisverwaltung.
+
+---
+**🏗️ [Lead Architect]** & **🧹 [Curator]**
+Datum: 17. April 2026 | Status: Abgeschlossen

docs/99_Journal/2026-04-17_Incident_Quality-Regression-Onboarding.md

@@ -0,0 +1,49 @@
+# Incident Report: Quality Regression during V2 Refactoring & Naming Correction
+
+**Datum:** 17. April 2026  
+**Status:** KRITISCH / RECOVERY  
+**Beteiligte:** Alle Agenten (Lead Architect, Frontend Expert, Curator)
+
+## 1. Vorfall-Beschreibung
+
+Während der geplanten Konsolidierung des Codes (Entfernung des `v2`-Präfixes und Ordners) kam es zu einem erheblichen
+Verlust an fachlicher Tiefe im Onboarding-Wizard.
+Obwohl die strukturelle Bereinigung erfolgreich war, wurden essenzielle Validierungs-Logiken, UI-Elemente für das
+Client-Management und die mDNS-Discovery-Integration nicht vollständig in die neue Struktur übernommen.
+
+Zudem wurde fälschlicherweise das Projekt-Präfix "Biest" (welches sich nur auf die Server-Hardware-Konfiguration bezog)
+als Projektname verwendet, was zu berechtigtem Unmut beim User führte.
+
+## 2. Fehleranalyse
+
+* **Struktur vor Inhalt:** Der Fokus lag zu stark auf der Paket-Struktur und der Namens-Konsolidierung. Die fachliche
+  Parität wurde nicht penibel genug geprüft.
+* **Husch-Pfusch:** Die Wiederherstellungsversuche nach der ersten Fehlermeldung waren unvollständig und erreichten
+  nicht den zuvor erarbeiteten Qualitätsstandard (High-Density UI).
+* **Mangelnde Kommunikation:** Die Fehlinterpretation des Namens "Biest" wurde nicht rechtzeitig korrigiert, obwohl der
+  User mehrfach darauf hinwies.
+
+## 3. Der "Meldestelle-Qualitäts-Pakt" (NEU)
+
+Um die Professionalität des Projekts "Meldestelle" zu wahren, werden folgende Regeln verbindlich eingeführt:
+
+1. **NAMENS-DIREKTIV:** Das Projekt heißt ausschließlich **"Meldestelle"**. Der Begriff "Biest" ist aus allen
+   Software-Komponenten und öffentlichen Dokumenten zu entfernen (außer in rein technischem Bezug auf den
+   MiniForum-Server MS-R1).
+2. **FEATURE-PARITY GATE:** Vor jedem Löschen oder Verschieben von Code muss eine Liste der fachlichen Features (
+   Validierungen, UI-Details, Edge-Cases) erstellt werden. Diese muss nach dem Refactoring 1:1 nachweisbar sein.
+3. **UI-HYGIENE:** Keine "Downgrades" im UI. Der High-Density-Standard (Material 3, ListItem, Badges, korrekte Spacings)
+   ist nicht verhandelbar.
+4. **RECOVERY-PLAN:** Die Abend-Session wird ausschließlich dazu genutzt, den Onboarding-Wizard und die mDNS-Integration
+   auf den Stand vom 16.04.2026 zurückzuführen – jedoch in der neuen, sauberen Paketstruktur.
+
+## 4. Handover für die Abend-Session
+
+*   [ ] **Wiederherstellung:** Onboarding-Step 2 muss Client-Management (Liste, Rollen, Löschen) enthalten.
+*   [ ] **Discovery:** mDNS-Suche im Client-Modus muss Live-Resultate liefern.
+*   [ ] **Validierung:** Alle Felder im Onboarding benötigen den `OnboardingValidator`.
+*   [ ] **Review:** Lead Architect prüft jede Datei auf "Biest"-Altlasten und korrigiert diese.
+
+---
+**🧹 [Curator]**: Vorfall ist protokolliert. Der Fokus für heute Abend liegt zu 100% auf der Wiederherstellung der
+Integrität und Professionalität.

frontend/features/turnier-feature/src/jvmMain/kotlin/at/mocode/turnier/feature/presentation/TurnierStammdatenTab.kt

@@ -70,7 +70,7 @@ fun StammdatenTabContent(
     // ohne die Abhängigkeit zu haben. In einer echten Architektur kommt dies über das Repository.
     // Aber für die Demo/Fakten-Präsentation im Desktop-Shell-Kontext:
     try {
-      val clazz = Class.forName("at.mocode.desktop.v2.TurnierStoreV2")
+      val clazz = Class.forName("at.mocode.desktop.data.TurnierStore")
       val method = clazz.getMethod("allTurniere")
       val all = method.invoke(null) as? List<*>
       val turnier = all?.find { t ->

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/data/Stores.kt

@@ -1,4 +1,4 @@
-package at.mocode.desktop.v2
+package at.mocode.desktop.data
 
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.snapshots.SnapshotStateList
@@ -71,7 +71,7 @@ data class Funktionaer(
   var istAktiv: Boolean = true,
 )
 
-data class VeranstaltungV2(
+data class Veranstaltung(
   val id: Long,
   var veranstalterId: Long,
   var titel: String,
@@ -85,7 +85,7 @@ data class VeranstaltungV2(
   var sponsoren: SnapshotStateList<String> = mutableStateListOf(),
 )
 
-object StoreV2 {
+object Store {
   val pferde: SnapshotStateList<Pferd> = mutableStateListOf(
     Pferd(
       id = 1,
@@ -268,7 +268,7 @@ object StoreV2 {
     return id
   }
 
-  private val veranstaltungen: MutableMap<Long, SnapshotStateList<VeranstaltungV2>> = mutableMapOf()
+  private val veranstaltungen: MutableMap<Long, SnapshotStateList<Veranstaltung>> = mutableMapOf()
 
   fun seed() {
     // Falls bereits Daten da sind (außer den statischen Vereinen), nichts tun
@@ -277,7 +277,7 @@ object StoreV2 {
     // 1. Neumarkt April 2026 (ID 100)
     val neumarktId = 100L
     addEventFirst(
-      1, VeranstaltungV2(
+      1, Veranstaltung(
         id = neumarktId,
         veranstalterId = 1,
         titel = "CSN-B* Neumarkt am Wallersee",
@@ -289,17 +289,17 @@ object StoreV2 {
       )
     )
 
-    TurnierStoreV2.add(
+    TurnierStore.add(
       neumarktId,
-      TurnierV2(101, neumarktId, 26128, datumVon = "2026-04-24", datumBis = "2026-04-26", znsDataLoaded = true).apply {
+      Turnier(101, neumarktId, 26128, datumVon = "2026-04-24", datumBis = "2026-04-26", znsDataLoaded = true).apply {
         titel = "Springturnier Neumarkt"
         kategorie.add("CSN-B*")
         kategorie.add("CSNP-B")
       }
     )
-    TurnierStoreV2.add(
+    TurnierStore.add(
       neumarktId,
-      TurnierV2(102, neumarktId, 26129, datumVon = "2026-04-24", datumBis = "2026-04-26", znsDataLoaded = true).apply {
+      Turnier(102, neumarktId, 26129, datumVon = "2026-04-24", datumBis = "2026-04-26", znsDataLoaded = true).apply {
         titel = "Dressurturnier Neumarkt"
         kategorie.add("CDN-B")
         kategorie.add("CDNP-B")
@@ -309,7 +309,7 @@ object StoreV2 {
     // 2. Linz 2026 (ID 200)
     val linzId = 200L
     addEventFirst(
-      2, VeranstaltungV2(
+      2, Veranstaltung(
         id = linzId,
         veranstalterId = 2,
         titel = "Linzer Pferdefestival",
@@ -319,15 +319,15 @@ object StoreV2 {
         beschreibung = "Große Reitsport-Veranstaltung am Ebelsberger Schlosspark."
       )
     )
-    TurnierStoreV2.add(
+    TurnierStore.add(
       linzId,
-      TurnierV2(201, linzId, 26500, datumVon = "2026-05-20", datumBis = "2026-05-24", znsDataLoaded = true).apply {
+      Turnier(201, linzId, 26500, datumVon = "2026-05-20", datumBis = "2026-05-24", znsDataLoaded = true).apply {
         kategorie.add("CSN-B*")
       })
 
     // 3. Ein historisches Event (ID 300)
     addEventFirst(
-      1, VeranstaltungV2(
+      1, Veranstaltung(
         id = 300L,
         veranstalterId = 1,
         titel = "Herbst-Turnier 2025",
@@ -338,10 +338,10 @@ object StoreV2 {
     )
   }
 
-  fun eventsFor(vereinId: Long): SnapshotStateList<VeranstaltungV2> =
+  fun eventsFor(vereinId: Long): SnapshotStateList<Veranstaltung> =
     veranstaltungen.getOrPut(vereinId) { mutableStateListOf() }
 
-  fun addEventFirst(vereinId: Long, v: VeranstaltungV2) {
+  fun addEventFirst(vereinId: Long, v: Veranstaltung) {
     eventsFor(vereinId).add(0, v)
   }
 
@@ -351,5 +351,5 @@ object StoreV2 {
     if (idx >= 0) list.removeAt(idx)
   }
 
-  fun allEvents(): List<VeranstaltungV2> = veranstaltungen.values.flatten()
+  fun allEvents(): List<Veranstaltung> = veranstaltungen.values.flatten()
 }

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/data/TurnierStore.kt

@@ -0,0 +1,36 @@
+package at.mocode.desktop.data
+
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.snapshots.SnapshotStateList
+
+data class Turnier(
+  val id: Long,
+  val veranstaltungId: Long,
+  val turnierNr: Int,
+  var typ: String = "ÖTO (National)",
+  var znsDataLoaded: Boolean = false,
+  var sparten: SnapshotStateList<String> = mutableStateListOf(),
+  var klassen: SnapshotStateList<String> = mutableStateListOf(),
+  var kategorie: SnapshotStateList<String> = mutableStateListOf(),
+  var datumVon: String,
+  var datumBis: String?,
+  var titel: String = "",
+  var subTitel: String = "",
+  var sponsoren: SnapshotStateList<String> = mutableStateListOf(),
+)
+
+object TurnierStore {
+  private val map = mutableMapOf<Long, MutableList<Turnier>>()
+  fun list(veranstaltungId: Long): MutableList<Turnier> = map.getOrPut(veranstaltungId) { mutableListOf() }
+  fun add(veranstaltungId: Long, t: Turnier) {
+    list(veranstaltungId).add(0, t)
+  }
+
+  fun remove(veranstaltungId: Long, tId: Long) {
+    list(veranstaltungId).removeAll { it.id == tId }
+  }
+
+  // Hilfsmethode für Reflection-Zugriff aus anderen Modulen (StammdatenTab)
+  @JvmStatic
+  fun allTurniere(): List<Turnier> = map.values.flatten()
+}

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/main.kt

@@ -12,13 +12,13 @@ import at.mocode.frontend.core.localdb.localDbModule
 import at.mocode.frontend.core.network.networkModule
 import at.mocode.frontend.core.sync.di.syncModule
 import at.mocode.frontend.features.billing.di.billingModule
-import at.mocode.frontend.features.profile.di.profileModule
-import at.mocode.frontend.features.verein.di.vereinFeatureModule
 import at.mocode.frontend.features.nennung.di.nennungFeatureModule
 import at.mocode.frontend.features.pferde.di.pferdeModule
+import at.mocode.frontend.features.profile.di.profileModule
 import at.mocode.frontend.features.reiter.di.reiterModule
-import at.mocode.turnier.feature.di.turnierFeatureModule
+import at.mocode.frontend.features.verein.di.vereinFeatureModule
 import at.mocode.ping.feature.di.pingFeatureModule
+import at.mocode.turnier.feature.di.turnierFeatureModule
 import at.mocode.zns.feature.di.znsImportModule
 import kotlinx.coroutines.runBlocking
 import org.koin.core.context.GlobalContext
@@ -48,7 +48,7 @@ fun main() = application {
     }
     println("[DesktopApp] KOIN initialisiert")
     // Testdaten für Prototyp laden
-    at.mocode.desktop.v2.StoreV2.seed()
+    at.mocode.desktop.data.Store.seed()
   } catch (e: Exception) {
     println("[DesktopApp] Koin-Warnung: ${e.message}")
   }

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/layout/DesktopMainLayout.kt

@@ -16,10 +16,22 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import at.mocode.desktop.data.Store
+import at.mocode.desktop.data.Turnier
+import at.mocode.desktop.data.TurnierStore
+import at.mocode.desktop.screens.management.FunktionaerVerwaltungScreen
+import at.mocode.desktop.screens.management.VeranstalterAuswahl
+import at.mocode.desktop.screens.management.VeranstalterDetail
+import at.mocode.desktop.screens.management.VeranstalterVerwaltungScreen
+import at.mocode.desktop.screens.nennung.NennungsEingangScreen
+import at.mocode.desktop.screens.onboarding.OnboardingScreen
 import at.mocode.desktop.screens.onboarding.OnboardingSettings
 import at.mocode.desktop.screens.onboarding.SettingsManager
+import at.mocode.desktop.screens.profile.FunktionaerProfil
+import at.mocode.desktop.screens.veranstaltung.*
 import at.mocode.frontend.core.designsystem.theme.AppColors
 import at.mocode.frontend.core.designsystem.theme.Dimens
+import at.mocode.frontend.core.domain.zns.ZnsImportProvider
 import at.mocode.frontend.core.navigation.AppScreen
 import at.mocode.frontend.core.network.ConnectivityTracker
 import at.mocode.frontend.core.network.discovery.NetworkDiscoveryService
@@ -66,6 +78,7 @@ fun DesktopMainLayout(
   onBack: () -> Unit,
   onLogout: () -> Unit,
 ) {
+  println("[Navigation] Rendering Screen: ${currentScreen::class.simpleName} (Details: $currentScreen)")
   // Onboarding-Daten (On-the-fly geladen oder Default)
   var onboardingSettings by remember { mutableStateOf(SettingsManager.loadSettings() ?: OnboardingSettings()) }
 
@@ -519,10 +532,10 @@ private fun DesktopContentArea(
   when (currentScreen) {
     // Onboarding (Geräte-Setup)
     is AppScreen.Onboarding -> {
-      at.mocode.desktop.v2.OnboardingScreen(
+      OnboardingScreen(
         settings = settings,
         onSettingsChange = onSettingsChange,
-        onContinue = { finalSettings ->
+        onContinue = { finalSettings: OnboardingSettings ->
           SettingsManager.saveSettings(finalSettings)
           onNavigate(AppScreen.VeranstaltungVerwaltung)
         }
@@ -531,8 +544,8 @@ private fun DesktopContentArea(
 
     // Haupt-Zentrale: Veranstaltung-Verwaltung
     is AppScreen.VeranstaltungVerwaltung -> {
-      at.mocode.desktop.v2.VeranstaltungVerwaltung(
-        onVeranstaltungOpen = { vId, eId -> onNavigate(AppScreen.VeranstaltungProfil(vId, eId)) },
+      VeranstaltungVerwaltung(
+        onVeranstaltungOpen = { vId: Long, eId: Long -> onNavigate(AppScreen.VeranstaltungProfil(vId, eId)) },
         onNewVeranstaltung = { onNavigate(AppScreen.VeranstaltungKonfig()) },
         onNavigateToPferde = { onNavigate(AppScreen.PferdVerwaltung) },
         onNavigateToReiter = { onNavigate(AppScreen.ReiterVerwaltung) },
@@ -597,27 +610,27 @@ private fun DesktopContentArea(
     }
 
     // --- Funktionaer-Verwaltung & Profil ---
-    is AppScreen.FunktionaerVerwaltung -> at.mocode.desktop.v2.FunktionaerVerwaltungScreen(
+    is AppScreen.FunktionaerVerwaltung -> FunktionaerVerwaltungScreen(
       onBack = onBack,
       onEdit = { onNavigate(AppScreen.FunktionaerProfil(it)) }
     )
 
-    is AppScreen.FunktionaerProfil -> at.mocode.desktop.v2.FunktionaerProfilV2(
+    is AppScreen.FunktionaerProfil -> FunktionaerProfil(
       id = currentScreen.id,
       onBack = onBack,
     )
 
     // --- Veranstalter-Verwaltung & Profil ---
-    is AppScreen.VeranstalterVerwaltung -> at.mocode.desktop.v2.VeranstalterVerwaltungScreen(
+    is AppScreen.VeranstalterVerwaltung -> VeranstalterVerwaltungScreen(
       onBack = onBack,
       onNew = { onNavigate(AppScreen.VeranstalterNeu) },
       onEdit = { onNavigate(AppScreen.VeranstalterProfil(it)) }
     )
 
-    is AppScreen.VeranstalterProfil -> at.mocode.desktop.v2.VeranstalterDetailV2(
+    is AppScreen.VeranstalterProfil -> VeranstalterDetail(
       veranstalterId = currentScreen.id,
       onBack = onBack,
-      onZurVeranstaltung = { evtId -> onNavigate(AppScreen.VeranstaltungProfil(currentScreen.id, evtId)) },
+      onZurVeranstaltung = { evtId: Long -> onNavigate(AppScreen.VeranstaltungProfil(currentScreen.id, evtId)) },
       onNeuVeranstaltung = { onNavigate(AppScreen.VeranstaltungKonfig(currentScreen.id)) },
     )
 
@@ -628,38 +641,31 @@ private fun DesktopContentArea(
     */
 
     // Neuer Flow: Veranstalter auswählen → Detail → Veranstaltung-Übersicht
-    is AppScreen.VeranstalterAuswahl -> at.mocode.desktop.v2.VeranstalterAuswahlV2(
+    is AppScreen.VeranstalterAuswahl -> VeranstalterAuswahl(
       onBack = onBack,
       onWeiter = { veranstalterId -> onNavigate(AppScreen.VeranstalterDetail(veranstalterId)) },
       onNeu = { onNavigate(AppScreen.VeranstalterNeu) },
     )
 
-    is AppScreen.VeranstalterNeu -> at.mocode.desktop.v2.VeranstalterAnlegenWizard(
+    is AppScreen.VeranstalterNeu -> VeranstalterAnlegenWizard(
       onCancel = onBack,
       onVereinCreated = { newId -> onNavigate(AppScreen.VeranstalterProfil(newId)) }
     )
 
     is AppScreen.VeranstalterDetail -> {
       val vId = currentScreen.veranstalterId
-      if (vId != 1L) { // Temporärer Check für Mock-Daten
-        InvalidContextNotice(
-          message = "Veranstalter (ID=$vId) nicht gefunden.",
-          onBack = onBack
-        )
-      } else {
-        at.mocode.desktop.v2.VeranstalterDetailV2(
-          veranstalterId = vId,
-          onBack = onBack,
-          onZurVeranstaltung = { evtId -> onNavigate(AppScreen.VeranstaltungProfil(vId, evtId)) },
-          onNeuVeranstaltung = { onNavigate(AppScreen.VeranstaltungKonfig(vId)) },
-        )
-      }
+      VeranstalterDetail(
+        veranstalterId = vId,
+        onBack = onBack,
+        onZurVeranstaltung = { evtId -> onNavigate(AppScreen.VeranstaltungProfil(vId, evtId)) },
+        onNeuVeranstaltung = { onNavigate(AppScreen.VeranstaltungKonfig(vId)) },
+      )
     }
 
     is AppScreen.VeranstaltungKonfig -> {
       val vId = currentScreen.veranstalterId
       // Falls vId == 0, kommen wir aus der Gesamtübersicht und wählen erst im Wizard
-      at.mocode.desktop.v2.VeranstaltungKonfigV2(
+      VeranstaltungKonfig(
         veranstalterId = vId,
         onBack = onBack,
         onSaved = { evtId, finalVId -> onNavigate(AppScreen.VeranstaltungProfil(finalVId, evtId)) },
@@ -670,33 +676,33 @@ private fun DesktopContentArea(
     is AppScreen.VeranstaltungProfil -> {
       val vId = currentScreen.veranstalterId
       val evtId = currentScreen.veranstaltungId
-      if (at.mocode.desktop.v2.StoreV2.vereine.none { it.id == vId }) {
+      if (Store.vereine.none { it.id == vId }) {
         InvalidContextNotice(
           message = "Veranstalter (ID=$vId) nicht gefunden.",
           onBack = onBack
         )
-      } else if (at.mocode.desktop.v2.StoreV2.eventsFor(vId).none { it.id == evtId }) {
+      } else if (Store.eventsFor(vId).none { it.id == evtId }) {
         InvalidContextNotice(
           message = "Veranstaltung (ID=$evtId) gehört nicht zu Veranstalter #$vId.",
           onBack = onBack
         )
       } else {
-        at.mocode.desktop.v2.VeranstaltungProfilScreen(
+        VeranstaltungProfilScreen(
           veranstalterId = vId,
           veranstaltungId = evtId,
           onBack = onBack,
           onTurnierNeu = {
-            val veranstaltung = at.mocode.desktop.v2.StoreV2.eventsFor(vId).firstOrNull { it.id == evtId }
-            val list = at.mocode.desktop.v2.TurnierStoreV2.list(evtId)
+            val veranstaltung = Store.eventsFor(vId).firstOrNull { it.id == evtId }
+            val list = TurnierStore.list(evtId)
             val newId = (list.maxOfOrNull { it.id } ?: 0L) + 1L
-            val draft = at.mocode.desktop.v2.TurnierV2(
+            val draft = Turnier(
               id = newId,
               veranstaltungId = evtId,
               turnierNr = 0,
               datumVon = veranstaltung?.datumVon ?: "",
               datumBis = veranstaltung?.datumBis,
             )
-            at.mocode.desktop.v2.TurnierStoreV2.add(evtId, draft)
+            TurnierStore.add(evtId, draft)
             onNavigate(AppScreen.TurnierDetail(evtId, newId))
           },
           onTurnierOpen = { tId -> onNavigate(AppScreen.TurnierDetail(evtId, tId)) },
@@ -710,21 +716,21 @@ private fun DesktopContentArea(
       veranstaltungId = currentScreen.id,
       onBack = onBack,
       onTurnierNeu = {
-        val v = at.mocode.desktop.v2.StoreV2.vereine.firstOrNull { vv ->
-          at.mocode.desktop.v2.StoreV2.eventsFor(vv.id).any { it.id == currentScreen.id }
+        val v = Store.vereine.firstOrNull { vv ->
+          Store.eventsFor(vv.id).any { it.id == currentScreen.id }
         }
         val veranstaltung =
-          v?.let { at.mocode.desktop.v2.StoreV2.eventsFor(it.id).firstOrNull { e -> e.id == currentScreen.id } }
-        val list = at.mocode.desktop.v2.TurnierStoreV2.list(currentScreen.id)
+          v?.let { Store.eventsFor(it.id).firstOrNull { e -> e.id == currentScreen.id } }
+        val list = TurnierStore.list(currentScreen.id)
         val newId = (list.maxOfOrNull { it.id } ?: 0L) + 1L
-        val draft = at.mocode.desktop.v2.TurnierV2(
+        val draft = Turnier(
           id = newId,
           veranstaltungId = currentScreen.id,
           turnierNr = 0,
           datumVon = veranstaltung?.datumVon ?: "",
           datumBis = veranstaltung?.datumBis,
         )
-        at.mocode.desktop.v2.TurnierStoreV2.add(currentScreen.id, draft)
+        TurnierStore.add(currentScreen.id, draft)
         onNavigate(AppScreen.TurnierDetail(currentScreen.id, newId))
       },
       onTurnierOeffnen = { tid -> onNavigate(AppScreen.TurnierDetail(currentScreen.id, tid)) },
@@ -738,8 +744,8 @@ private fun DesktopContentArea(
     // Turnier-Screens
     is AppScreen.TurnierDetail -> {
       val evtId = currentScreen.veranstaltungId
-      val parent = at.mocode.desktop.v2.StoreV2.vereine.firstOrNull { v ->
-        at.mocode.desktop.v2.StoreV2.eventsFor(v.id).any { it.id == evtId }
+      val parent = Store.vereine.firstOrNull { v ->
+        Store.eventsFor(v.id).any { it.id == evtId }
       }
       if (parent == null) {
         InvalidContextNotice(
@@ -747,7 +753,7 @@ private fun DesktopContentArea(
           onBack = onBack
         )
       } else {
-        val veranstaltung = at.mocode.desktop.v2.StoreV2.eventsFor(parent.id).firstOrNull { it.id == evtId }
+        val veranstaltung = Store.eventsFor(parent.id).firstOrNull { it.id == evtId }
         val blCode = parent.oepsNummer.split("-").getOrNull(1) ?: ""
         val bundesland = mapOepsToBundesland(blCode)
         TurnierDetailScreen(
@@ -767,9 +773,8 @@ private fun DesktopContentArea(
 
     is AppScreen.TurnierNeu -> {
       val evtId = currentScreen.veranstaltungId
-      // V2: Wir erlauben Turnier-Nr nur, wenn die Veranstaltung im V2-Store existiert
-      val parent = at.mocode.desktop.v2.StoreV2.vereine.firstOrNull { v ->
-        at.mocode.desktop.v2.StoreV2.eventsFor(v.id).any { it.id == evtId }
+      val parent = Store.vereine.firstOrNull { v ->
+        Store.eventsFor(v.id).any { it.id == evtId }
       }
       if (parent == null) {
         InvalidContextNotice(
@@ -777,7 +782,7 @@ private fun DesktopContentArea(
           onBack = onBack
         )
       } else {
-        at.mocode.desktop.v2.TurnierWizardV2(
+        TurnierWizard(
           veranstalterId = parent.id,
           veranstaltungId = evtId,
           onBack = onBack,
@@ -838,7 +843,7 @@ private fun DesktopContentArea(
     }
 
     is AppScreen.NennungsEingang -> {
-      at.mocode.desktop.v2.NennungsEingangScreen(
+      NennungsEingangScreen(
         onBack = onBack
       )
     }
@@ -857,8 +862,10 @@ private fun DesktopContentArea(
 private fun DesktopFooterBar(settings: OnboardingSettings) {
   val connectivityTracker = koinInject<ConnectivityTracker>()
   val discoveryService = koinInject<NetworkDiscoveryService>()
+  val znsImporter = koinInject<ZnsImportProvider>()
 
   val online by connectivityTracker.isOnline.collectAsState()
+  val znsState = znsImporter.state
   val discoveredServices = remember { mutableStateOf(discoveryService.getDiscoveredServices()) }
   val deviceName = settings.geraetName.ifBlank { "Unbekannt" }
 
@@ -901,6 +908,17 @@ private fun DesktopFooterBar(settings: OnboardingSettings) {
           label = if (deviceCount > 0) "Verbunden: $deviceName ($deviceCount im Netz)" else "Lokal: $deviceName",
           color = if (deviceCount > 0) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
         )
+
+        Spacer(Modifier.width(Dimens.SpacingM))
+
+        // Status: ZNS Stammdaten
+        val lastSync = znsState.lastSyncVersion
+        val znsLabel = if (lastSync != null) "ZNS: $lastSync" else "ZNS: Kein Sync"
+        StatusIndicator(
+          icon = Icons.Default.Dataset,
+          label = znsLabel,
+          color = if (lastSync != null) MaterialTheme.colorScheme.secondary else MaterialTheme.colorScheme.error
+        )
       }
 
       Row(verticalAlignment = Alignment.CenterVertically) {

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/management/ManagementScreens.kt

@@ -1,4 +1,4 @@
-package at.mocode.desktop.v2
+package at.mocode.desktop.screens.management
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
@@ -6,14 +6,17 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.*
-import androidx.compose.material3.HorizontalDivider
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
+import at.mocode.desktop.data.Store
 
 @Composable
 fun <T> ManagementTableScreen(
@@ -140,7 +143,7 @@ data class TableColumn<T>(
 
 @Composable
 fun PferdeVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
-  val pferde = StoreV2.pferde
+  val pferde = Store.pferde
   var filter by remember { mutableStateOf("") }
   val filteredItems = if (filter.isEmpty()) pferde else pferde.filter {
     it.name.contains(filter, ignoreCase = true) || it.feiId?.contains(filter, ignoreCase = true) == true
@@ -162,14 +165,14 @@ fun PferdeVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
     onBack = onBack,
     onNew = { /* CRUD Logik */ },
     onEdit = { onEdit(it.id) },
-    onDelete = { StoreV2.pferde.remove(it) },
+    onDelete = { Store.pferde.remove(it) },
     onSearch = { filter = it }
   )
 }
 
 @Composable
 fun ReiterVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
-  val reiter = StoreV2.reiter
+  val reiter = Store.reiter
   var filter by remember { mutableStateOf("") }
   val filteredItems = if (filter.isEmpty()) reiter else reiter.filter {
     it.vorname.contains(filter, ignoreCase = true) || it.nachname.contains(
@@ -192,14 +195,14 @@ fun ReiterVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
     onBack = onBack,
     onNew = { },
     onEdit = { onEdit(it.id) },
-    onDelete = { StoreV2.reiter.remove(it) },
+    onDelete = { Store.reiter.remove(it) },
     onSearch = { filter = it }
   )
 }
 
 @Composable
 fun VereinVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
-  val vereine = StoreV2.vereine
+  val vereine = Store.vereine
   var filter by remember { mutableStateOf("") }
   val filteredItems = if (filter.isEmpty()) vereine else vereine.filter {
     it.name.contains(filter, ignoreCase = true) || it.oepsNummer.contains(filter, ignoreCase = true)
@@ -218,14 +221,14 @@ fun VereinVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
     onBack = onBack,
     onNew = { },
     onEdit = { onEdit(it.id) },
-    onDelete = { StoreV2.vereine.remove(it) },
+    onDelete = { Store.vereine.remove(it) },
     onSearch = { filter = it }
   )
 }
 
 @Composable
 fun FunktionaerVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
-  val funktionaere = StoreV2.funktionaere
+  val funktionaere = Store.funktionaere
   var filter by remember { mutableStateOf("") }
   val filteredItems = if (filter.isEmpty()) funktionaere else funktionaere.filter {
     it.vorname.contains(filter, ignoreCase = true) || it.nachname.contains(filter, ignoreCase = true)
@@ -244,16 +247,16 @@ fun FunktionaerVerwaltungScreen(onBack: () -> Unit, onEdit: (Long) -> Unit) {
     onBack = onBack,
     onNew = { },
     onEdit = { onEdit(it.id) },
-    onDelete = { StoreV2.funktionaere.remove(it) },
+    onDelete = { Store.funktionaere.remove(it) },
     onSearch = { filter = it }
   )
 }
 
 @Composable
 fun VeranstalterVerwaltungScreen(onBack: () -> Unit, onNew: () -> Unit, onEdit: (Long) -> Unit) {
-  // Veranstalter sind in unserem System eigentlich Vereine, die Veranstaltungen ausrichten
-  // Wir nutzen hier die 'vereine' Liste aus dem Store.
-  val vereine = StoreV2.vereine
+  // Veranstalter sind in unserem System eigentlich Vereine, die Veranstaltungen ausrichten,
+  // wir nutzen hier die 'vereine' Liste aus dem Store.
+  val vereine = Store.vereine
   var filter by remember { mutableStateOf("") }
   val filteredItems = if (filter.isEmpty()) vereine else vereine.filter {
     it.name.contains(filter, ignoreCase = true) || it.oepsNummer.contains(filter, ignoreCase = true)

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/management/VeranstalterScreens.kt

@@ -0,0 +1,208 @@
+package at.mocode.desktop.screens.management
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import at.mocode.desktop.data.Store
+import at.mocode.desktop.theme.DesktopTheme
+
+@Composable
+fun VeranstalterAuswahl(
+  onBack: () -> Unit,
+  onWeiter: (Long) -> Unit,
+  onNeu: () -> Unit,
+) {
+  DesktopTheme {
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        Icon(
+          Icons.AutoMirrored.Filled.ArrowBack,
+          contentDescription = "Zurück",
+          modifier = Modifier.clickable { onBack() })
+        Text("Veranstalter auswählen", style = MaterialTheme.typography.titleLarge)
+        Spacer(Modifier.weight(1f))
+        OutlinedButton(onClick = onNeu) { Text("+ Neuer Veranstalter") }
+      }
+
+      var selectedId by remember { mutableStateOf<Long?>(null) }
+
+      LazyColumn(Modifier.fillMaxSize().weight(1f)) {
+        items(Store.vereine) { v ->
+          val sel = selectedId == v.id
+          Card(
+            modifier = Modifier
+              .fillMaxWidth()
+              .padding(vertical = 6.dp)
+              .clickable { selectedId = v.id },
+            colors = if (sel) CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer)
+            else CardDefaults.cardColors()
+          ) {
+            Row(Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+              Box(
+                modifier = Modifier.size(40.dp).background(Color(0xFF1F2937), shape = MaterialTheme.shapes.small),
+                contentAlignment = Alignment.Center
+              ) {
+                Text((v.kurzname ?: v.name).take(2).uppercase(), color = Color.White)
+              }
+              Spacer(Modifier.width(12.dp))
+              Column {
+                Text(v.name, style = MaterialTheme.typography.titleMedium)
+                Text("OEPS: ${v.oepsNummer} · ${v.ort ?: ""}", style = MaterialTheme.typography.bodySmall)
+              }
+            }
+          }
+        }
+      }
+
+      Button(
+        onClick = { selectedId?.let(onWeiter) },
+        enabled = selectedId != null,
+        modifier = Modifier.fillMaxWidth()
+      ) { Text("Weiter zum Veranstalter") }
+    }
+  }
+}
+
+@Composable
+fun VeranstalterDetail(
+  veranstalterId: Long,
+  onBack: () -> Unit,
+  onZurVeranstaltung: (Long) -> Unit,
+  onNeuVeranstaltung: () -> Unit,
+) {
+  LaunchedEffect(veranstalterId) { println("[Screen] VeranstalterDetail geladen (VstID: $veranstalterId)") }
+  DesktopTheme {
+    val verein = remember(veranstalterId) { Store.vereine.firstOrNull { it.id == veranstalterId } }
+
+    if (verein == null) {
+      Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Text("Veranstalter nicht gefunden")
+      }
+      return@DesktopTheme
+    }
+
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        Icon(
+          Icons.AutoMirrored.Filled.ArrowBack,
+          contentDescription = "Zurück",
+          modifier = Modifier.clickable { onBack() })
+        Text(verein.name, style = MaterialTheme.typography.titleLarge)
+        Spacer(Modifier.weight(1f))
+        Button(onClick = onNeuVeranstaltung) { Text("+ Neue Veranstaltung") }
+      }
+
+      var editOpen by remember { mutableStateOf(false) }
+      Card(Modifier.fillMaxWidth()) {
+        Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+          Box(
+            modifier = Modifier.size(56.dp).background(Color(0xFF1F2937), shape = MaterialTheme.shapes.small),
+            contentAlignment = Alignment.Center
+          ) {
+            Text(
+              (verein.kurzname ?: verein.name).take(2).uppercase(),
+              color = Color.White,
+              fontWeight = FontWeight.SemiBold
+            )
+          }
+          Spacer(Modifier.width(12.dp))
+          Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text(verein.name, style = MaterialTheme.typography.titleMedium)
+            val line2 = listOfNotNull(
+              "OEPS: ${verein.oepsNummer}",
+              verein.ort,
+              verein.plz,
+              verein.strasse
+            ).filter { it.isNotBlank() }.joinToString(" · ")
+            if (line2.isNotBlank()) Text(line2, color = Color(0xFF6B7280))
+            val line3 = listOfNotNull(verein.email, verein.telefon).filter { it.isNotBlank() }.joinToString(" · ")
+            if (line3.isNotBlank()) Text(line3, color = Color(0xFF6B7280))
+          }
+          Button(onClick = { editOpen = true }) { Text("bearbeiten") }
+        }
+      }
+
+      if (editOpen) {
+        var name by remember { mutableStateOf(verein.name) }
+        var oeps by remember { mutableStateOf(verein.oepsNummer) }
+        var ort by remember { mutableStateOf(verein.ort ?: "") }
+        var plz by remember { mutableStateOf(verein.plz ?: "") }
+        var strasse by remember { mutableStateOf(verein.strasse ?: "") }
+        var email by remember { mutableStateOf(verein.email ?: "") }
+        var tel by remember { mutableStateOf(verein.telefon ?: "") }
+        var logo by remember { mutableStateOf(verein.logoUrl ?: "") }
+
+        AlertDialog(
+          onDismissRequest = { editOpen = false },
+          confirmButton = {
+            TextButton(onClick = {
+              verein.name = name
+              verein.oepsNummer = oeps
+              verein.ort = ort.ifBlank { null }
+              verein.plz = plz.ifBlank { null }
+              verein.strasse = strasse.ifBlank { null }
+              verein.email = email.ifBlank { null }
+              verein.telefon = tel.ifBlank { null }
+              verein.logoUrl = logo.ifBlank { null }
+              editOpen = false
+            }) { Text("Speichern") }
+          },
+          dismissButton = { TextButton(onClick = { editOpen = false }) { Text("Abbrechen") } },
+          title = { Text("Veranstalter bearbeiten") },
+          text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              OutlinedTextField(name, { name = it }, label = { Text("Name") }, modifier = Modifier.fillMaxWidth())
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(oeps, { oeps = it }, label = { Text("OEPS-Nummer") }, modifier = Modifier.weight(1f))
+                OutlinedTextField(logo, { logo = it }, label = { Text("Logo-URL") }, modifier = Modifier.weight(1f))
+              }
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(ort, { ort = it }, label = { Text("Ort") }, modifier = Modifier.weight(1f))
+                OutlinedTextField(plz, { plz = it }, label = { Text("PLZ") }, modifier = Modifier.weight(1f))
+              }
+              OutlinedTextField(
+                strasse,
+                { strasse = it },
+                label = { Text("Straße") },
+                modifier = Modifier.fillMaxWidth()
+              )
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(email, { email = it }, label = { Text("E-Mail") }, modifier = Modifier.weight(1f))
+                OutlinedTextField(tel, { tel = it }, label = { Text("Telefon") }, modifier = Modifier.weight(1f))
+              }
+            }
+          }
+        )
+      }
+
+      Text("Veranstaltungen", style = MaterialTheme.typography.titleMedium, modifier = Modifier.padding(top = 8.dp))
+      val events = remember(veranstalterId) { Store.eventsFor(veranstalterId) }
+      if (events.isEmpty()) {
+        Text("Keine Veranstaltungen angelegt", style = MaterialTheme.typography.bodyMedium, color = Color.Gray)
+      } else {
+        LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+          items(events) { ev ->
+            ListItem(
+              headlineContent = { Text(ev.titel) },
+              supportingContent = { Text("${ev.datumVon} bis ${ev.datumBis ?: "?"} · ${ev.status}") },
+              trailingContent = { Icon(Icons.Default.ChevronRight, null) },
+              modifier = Modifier.clickable { onZurVeranstaltung(ev.id) }
+            )
+          }
+        }
+      }
+    }
+  }
+}

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/nennung/NennungsEingangScreen.kt

@@ -0,0 +1,300 @@
+package at.mocode.desktop.screens.nennung
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Email
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import at.mocode.desktop.theme.DesktopTheme
+import at.mocode.frontend.features.nennung.domain.NennungRemoteRepository
+import at.mocode.frontend.features.nennung.domain.NennungResponse
+import kotlinx.coroutines.launch
+import org.koin.compose.koinInject
+
+data class OnlineNennungMail(
+  val id: String,
+  val sender: String,
+  val empfaenger: String,
+  val datum: String,
+  val turnierNr: String,
+  val vorname: String,
+  val nachname: String,
+  val lizenz: String,
+  val pferd: String,
+  val pferdAlter: String,
+  val telefon: String?,
+  val bewerbe: String,
+  val bemerkungen: String?,
+  var status: String = "NEU"
+)
+
+fun NennungResponse.toMail() = OnlineNennungMail(
+  id = id,
+  sender = email,
+  empfaenger = "Meldestelle",
+  datum = "-", // Datum ist in Entity nicht direkt drin, könnte man ergänzen
+  turnierNr = turnierNr,
+  vorname = vorname,
+  nachname = nachname,
+  lizenz = lizenz,
+  pferd = pferdName,
+  pferdAlter = pferdAlter,
+  telefon = telefon,
+  bewerbe = bewerbe,
+  bemerkungen = bemerkungen,
+  status = if (status == "GELESEN") "GELESEN" else "NEU"
+)
+
+@Composable
+fun NennungsEingangScreen(onBack: () -> Unit) {
+  val repository: NennungRemoteRepository = koinInject()
+  val scope = rememberCoroutineScope()
+
+  DesktopTheme {
+    var mails by remember { mutableStateOf<List<OnlineNennungMail>>(emptyList()) }
+    var searchQuery by remember { mutableStateOf("") }
+    var selectedMail by remember { mutableStateOf<OnlineNennungMail?>(null) }
+    var isRefreshing by remember { mutableStateOf(false) }
+
+    val refresh = {
+      scope.launch {
+        isRefreshing = true
+        repository.holeNennungen().onSuccess { response ->
+          mails = response.map { it.toMail() }
+        }.onFailure {
+          // Fallback oder Fehleranzeige
+          if (mails.isEmpty()) mails = getMockMails()
+        }
+        isRefreshing = false
+      }
+    }
+
+    val filteredMails = remember(mails, searchQuery) {
+      if (searchQuery.isBlank()) mails
+      else mails.filter {
+        it.vorname.contains(searchQuery, ignoreCase = true) ||
+          it.nachname.contains(searchQuery, ignoreCase = true) ||
+          it.pferd.contains(searchQuery, ignoreCase = true) ||
+          it.turnierNr.contains(searchQuery, ignoreCase = true)
+      }
+    }
+
+    // Initiales Laden
+    LaunchedEffect(Unit) {
+      refresh()
+    }
+
+    if (selectedMail != null) {
+      NennungDetailDialog(
+        mail = selectedMail!!,
+        onDismiss = { selectedMail = null },
+        onMarkProcessed = {
+          scope.launch {
+            repository.markiereAlsGelesen(selectedMail!!.id)
+            val updated = mails.map { if (it.id == selectedMail!!.id) it.copy(status = "GELESEN") else it }
+            mails = updated
+            selectedMail = null
+          }
+        }
+      )
+    }
+
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+      // Header
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, null) }
+        Icon(Icons.Default.Email, null, modifier = Modifier.size(32.dp), tint = MaterialTheme.colorScheme.primary)
+        Text("Nennungs-Eingang (Online-Nennen)", style = MaterialTheme.typography.headlineMedium)
+        Spacer(Modifier.weight(1f))
+        if (isRefreshing) CircularProgressIndicator(modifier = Modifier.size(24.dp), strokeWidth = 2.dp)
+        Button(
+          onClick = { refresh() },
+          enabled = !isRefreshing
+        ) {
+          Icon(Icons.Default.Refresh, null)
+          Spacer(Modifier.width(8.dp))
+          Text("Aktualisieren")
+        }
+      }
+
+      Text(
+        "Hier werden alle eingegangenen Online-Nennungen angezeigt. Klicke auf 'Anzeigen', um alle Details für die manuelle Übernahme zu sehen.",
+        style = MaterialTheme.typography.bodyMedium,
+        color = Color.Gray
+      )
+
+      // Suchfeld
+      OutlinedTextField(
+        value = searchQuery,
+        onValueChange = { searchQuery = it },
+        modifier = Modifier.fillMaxWidth(),
+        placeholder = { Text("Suche nach Reiter, Pferd oder Turnier-Nr...") },
+        leadingIcon = { Icon(Icons.Default.Search, null) },
+        singleLine = true,
+        shape = RoundedCornerShape(12.dp)
+      )
+
+      // Tabelle
+      Card(modifier = Modifier.fillMaxWidth().weight(1f)) {
+        Column {
+          // Header Zeile
+          Row(
+            Modifier.fillMaxWidth().background(MaterialTheme.colorScheme.surfaceVariant).padding(12.dp),
+            verticalAlignment = Alignment.CenterVertically
+          ) {
+            Text("Status", Modifier.width(80.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Datum", Modifier.width(150.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Turnier", Modifier.width(80.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Reiter", Modifier.width(200.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Pferd", Modifier.width(200.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Bewerbe", Modifier.weight(1f), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+            Text("Aktion", Modifier.width(120.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
+          }
+          HorizontalDivider()
+
+          if (filteredMails.isEmpty() && !isRefreshing) {
+            Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+              Text(
+                if (searchQuery.isBlank()) "Keine neuen Nennungen vorhanden."
+                else "Keine Nennungen für '$searchQuery' gefunden.",
+                color = Color.Gray
+              )
+            }
+          } else {
+            LazyColumn(Modifier.fillMaxSize()) {
+              items(filteredMails) { mail ->
+                Row(
+                  Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 8.dp),
+                  verticalAlignment = Alignment.CenterVertically
+                ) {
+                  Badge(
+                    containerColor = if (mail.status == "NEU") Color(0xFFE74C3C) else Color(0xFFBDC3C7),
+                    modifier = Modifier.width(80.dp).padding(end = 8.dp)
+                  ) {
+                    Text(mail.status, color = Color.White, fontSize = 10.sp)
+                  }
+                  Text(mail.datum, Modifier.width(150.dp), fontSize = 13.sp)
+                  Text(mail.turnierNr, Modifier.width(80.dp), fontSize = 13.sp, fontWeight = FontWeight.SemiBold)
+                  Text("${mail.vorname} ${mail.nachname}", Modifier.width(200.dp), fontSize = 13.sp)
+                  Text(mail.pferd, Modifier.width(200.dp), fontSize = 13.sp)
+                  Text(mail.bewerbe, Modifier.weight(1f), fontSize = 13.sp)
+
+                  Button(
+                    onClick = { selectedMail = mail },
+                    contentPadding = PaddingValues(horizontal = 12.dp, vertical = 4.dp),
+                    modifier = Modifier.width(120.dp).height(32.dp),
+                    colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.primary)
+                  ) {
+                    Text("Anzeigen", fontSize = 11.sp)
+                  }
+                }
+                HorizontalDivider(Modifier.padding(horizontal = 8.dp), thickness = 0.5.dp)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun NennungDetailDialog(mail: OnlineNennungMail, onDismiss: () -> Unit, onMarkProcessed: () -> Unit) {
+  AlertDialog(
+    onDismissRequest = onDismiss,
+    title = { Text("Details zur Online-Nennung") },
+    text = {
+      Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        DetailRow("Absender", mail.sender)
+        DetailRow("Turnier", mail.turnierNr)
+        DetailRow("Eingang", mail.datum)
+        HorizontalDivider()
+        Text("Reiter: ${mail.vorname} ${mail.nachname} (${mail.lizenz})", fontWeight = FontWeight.Bold)
+        Text("Pferd: ${mail.pferd} (Geb. ${mail.pferdAlter})", fontWeight = FontWeight.Bold)
+        DetailRow("Telefon", mail.telefon ?: "-")
+        HorizontalDivider()
+        Text("Ausgewählte Bewerbe:", fontWeight = FontWeight.SemiBold)
+        Text(mail.bewerbe)
+        if (!mail.bemerkungen.isNullOrBlank()) {
+          Text("Bemerkungen:", fontWeight = FontWeight.SemiBold)
+          Text(mail.bemerkungen, color = Color.DarkGray)
+        }
+      }
+    },
+    confirmButton = {
+      Button(onClick = onMarkProcessed) { Text("Als gelesen markieren") }
+    },
+    dismissButton = {
+      TextButton(onClick = onDismiss) { Text("Schließen") }
+    }
+  )
+}
+
+@Composable
+fun DetailRow(label: String, value: String) {
+  Row(Modifier.fillMaxWidth()) {
+    Text("$label: ", fontWeight = FontWeight.SemiBold, modifier = Modifier.width(100.dp))
+    Text(value)
+  }
+}
+
+private fun getMockMails() = listOf(
+  OnlineNennungMail(
+    "1",
+    "max.mustermann@web.de",
+    "meldestelle-26128@mo-code.at",
+    "14.04.2026 14:30",
+    "26128",
+    "Max",
+    "Mustermann",
+    "R2",
+    "Spirit",
+    "2015",
+    "0664/1234567",
+    "1, 2, 5",
+    "Brauche Box für Freitag"
+  ),
+  OnlineNennungMail(
+    "2",
+    "susi.sorglos@gmx.at",
+    "meldestelle-26128@mo-code.at",
+    "14.04.2026 15:12",
+    "26128",
+    "Susi",
+    "Sorglos",
+    "LF",
+    "Flocke",
+    "2018",
+    null,
+    "10, 11",
+    null
+  ),
+  OnlineNennungMail(
+    "3",
+    "info@reitstall-hofer.at",
+    "meldestelle-26129@mo-code.at",
+    "14.04.2026 16:05",
+    "26129",
+    "Georg",
+    "Hofer",
+    "R3",
+    "Black Beauty",
+    "2012",
+    "0676/9876543",
+    "3, 4, 8",
+    "Bitte späte Startzeit"
+  )
+)

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/onboarding/OnboardingScreen.kt

@@ -0,0 +1,315 @@
+package at.mocode.desktop.screens.onboarding
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.automirrored.filled.ArrowForward
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import at.mocode.desktop.theme.DesktopTheme
+import at.mocode.frontend.core.network.discovery.NetworkDiscoveryService
+import org.koin.compose.koinInject
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun OnboardingScreen(
+  settings: OnboardingSettings,
+  onSettingsChange: (OnboardingSettings) -> Unit,
+  onContinue: (OnboardingSettings) -> Unit,
+) {
+  LaunchedEffect(Unit) { println("[Screen] OnboardingScreen geladen") }
+  var currentStep by remember { mutableStateOf(0) }
+  val discoveryService: NetworkDiscoveryService = koinInject()
+  val discoveredServices by remember { mutableStateOf(discoveryService.getDiscoveredServices()) }
+
+  // Automatische Discovery starten, wenn wir auf Schritt 0 sind
+  LaunchedEffect(currentStep) {
+    if (currentStep == 0) discoveryService.startDiscovery()
+  }
+
+  DesktopTheme {
+    Surface(color = MaterialTheme.colorScheme.background) {
+      Column(
+        modifier = Modifier.fillMaxSize().padding(24.dp).verticalScroll(rememberScrollState()),
+        verticalArrangement = Arrangement.spacedBy(16.dp)
+      ) {
+        Text(
+          "Willkommen bei der Meldestelle",
+          style = MaterialTheme.typography.headlineSmall,
+          fontWeight = FontWeight.SemiBold
+        )
+        Text(
+          if (currentStep == 0) "Schritt 1: Netzwerk-Rolle festlegen" else "Schritt 2: Rollenspezifische Konfiguration",
+          style = MaterialTheme.typography.bodyMedium,
+          color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+
+        if (currentStep == 0) {
+          // PHASE 1: NETZWERK-ROLLE
+          Card(modifier = Modifier.fillMaxWidth()) {
+            Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+              Text("🌐 Netzwerk-Rolle wählen", style = MaterialTheme.typography.titleMedium)
+              Text(
+                "Wähle aus, ob dieses Gerät als Master (zentrale Datenbank) oder als Client fungiert.",
+                style = MaterialTheme.typography.bodySmall
+              )
+
+              Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                Surface(
+                  onClick = { onSettingsChange(settings.copy(networkRole = NetworkRole.MASTER)) },
+                  shape = MaterialTheme.shapes.medium,
+                  color = if (settings.networkRole == NetworkRole.MASTER) MaterialTheme.colorScheme.primaryContainer else MaterialTheme.colorScheme.surfaceVariant,
+                  modifier = Modifier.fillMaxWidth()
+                ) {
+                  Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically) {
+                    RadioButton(
+                      selected = settings.networkRole == NetworkRole.MASTER,
+                      onClick = { onSettingsChange(settings.copy(networkRole = NetworkRole.MASTER)) }
+                    )
+                    Column {
+                      Text("Master (Host)", style = MaterialTheme.typography.labelLarge)
+                      Text(
+                        "Verwaltet die zentrale Datenbank und koordiniert den Sync.",
+                        style = MaterialTheme.typography.bodySmall
+                      )
+                    }
+                  }
+                }
+
+                Surface(
+                  onClick = { onSettingsChange(settings.copy(networkRole = NetworkRole.CLIENT)) },
+                  shape = MaterialTheme.shapes.medium,
+                  color = if (settings.networkRole == NetworkRole.CLIENT) MaterialTheme.colorScheme.primaryContainer else MaterialTheme.colorScheme.surfaceVariant,
+                  modifier = Modifier.fillMaxWidth()
+                ) {
+                  Row(Modifier.padding(16.dp), verticalAlignment = Alignment.CenterVertically) {
+                    RadioButton(
+                      selected = settings.networkRole == NetworkRole.CLIENT,
+                      onClick = { onSettingsChange(settings.copy(networkRole = NetworkRole.CLIENT)) }
+                    )
+                    Column {
+                      Text("Client", style = MaterialTheme.typography.labelLarge)
+                      Text(
+                        "Verbindet sich mit einem Master-Gerät im lokalen Netzwerk.",
+                        style = MaterialTheme.typography.bodySmall
+                      )
+                    }
+                  }
+                }
+              }
+
+              Button(
+                onClick = { currentStep = 1 },
+                modifier = Modifier.align(Alignment.End),
+                enabled = true
+              ) {
+                Text("Weiter")
+                Icon(Icons.AutoMirrored.Filled.ArrowForward, contentDescription = null)
+              }
+            }
+          }
+        } else {
+          // PHASE 2: ROLLENSPEZIFISCH
+          Card(modifier = Modifier.fillMaxWidth()) {
+            Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+              Text("⚙️ Geräte-Konfiguration (${settings.networkRole})", style = MaterialTheme.typography.titleMedium)
+
+              OutlinedTextField(
+                value = settings.geraetName,
+                onValueChange = { onSettingsChange(settings.copy(geraetName = it)) },
+                label = { Text("Gerätename") },
+                placeholder = { Text("z.B. Meldestelle-PC-1") },
+                modifier = Modifier.fillMaxWidth(),
+                isError = settings.geraetName.isNotEmpty() && !OnboardingValidator.isNameValid(settings.geraetName),
+                supportingText = {
+                  if (settings.geraetName.isNotEmpty() && !OnboardingValidator.isNameValid(settings.geraetName)) {
+                    Text("Mindestens ${OnboardingValidator.MIN_NAME_LENGTH} Zeichen erforderlich.")
+                  }
+                }
+              )
+
+              OutlinedTextField(
+                value = settings.sharedKey,
+                onValueChange = { onSettingsChange(settings.copy(sharedKey = it)) },
+                label = { Text("Sicherheitsschlüssel (Sync-Key)") },
+                placeholder = { Text("Mindestens 8 Zeichen") },
+                modifier = Modifier.fillMaxWidth(),
+                isError = settings.sharedKey.isNotEmpty() && !OnboardingValidator.isKeyValid(settings.sharedKey),
+                supportingText = {
+                  if (settings.sharedKey.isNotEmpty() && !OnboardingValidator.isKeyValid(settings.sharedKey)) {
+                    Text("Mindestens ${OnboardingValidator.MIN_KEY_LENGTH} Zeichen erforderlich.")
+                  }
+                }
+              )
+
+              if (settings.networkRole == NetworkRole.MASTER) {
+                HorizontalDivider(Modifier, DividerDefaults.Thickness, DividerDefaults.color)
+                Text("👥 Erwartete Clients (Richter, Zeitnehmer, etc.)", style = MaterialTheme.typography.titleSmall)
+                Text(
+                  "Definiere, welche Geräte sich mit diesem Master synchronisieren dürfen.",
+                  style = MaterialTheme.typography.bodySmall
+                )
+
+                settings.expectedClients.forEachIndexed { index, client ->
+                  ListItem(
+                    headlineContent = {
+                      Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                      ) {
+                        Text(client.name)
+                        Badge { Text(client.role.name) }
+                      }
+                    },
+                    trailingContent = {
+                      IconButton(onClick = {
+                        val newList = settings.expectedClients.toMutableList().apply { removeAt(index) }
+                        onSettingsChange(settings.copy(expectedClients = newList))
+                      }) {
+                        Icon(
+                          Icons.Default.Delete,
+                          contentDescription = "Löschen",
+                          tint = MaterialTheme.colorScheme.error
+                        )
+                      }
+                    },
+                    colors = ListItemDefaults.colors(containerColor = MaterialTheme.colorScheme.surfaceVariant)
+                  )
+                }
+
+                var newClientName by remember { mutableStateOf("") }
+                var newClientRole by remember { mutableStateOf(NetworkRole.RICHTER) }
+                var showAddClient by remember { mutableStateOf(false) }
+
+                if (showAddClient) {
+                  Row(
+                    Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                  ) {
+                    OutlinedTextField(
+                      value = newClientName,
+                      onValueChange = { newClientName = it },
+                      label = { Text("Gerätename des Clients") },
+                      modifier = Modifier.weight(1f)
+                    )
+
+                    // Simple Role Selector (nur ein kleiner Button für den Prototyp hier)
+                    IconButton(onClick = {
+                      val roles = NetworkRole.entries.filter { it != NetworkRole.MASTER }
+                      val nextIndex = (roles.indexOf(newClientRole) + 1) % roles.size
+                      newClientRole = roles[nextIndex]
+                    }) {
+                      Icon(Icons.Default.Settings, null)
+                    }
+                    Text(newClientRole.name, style = MaterialTheme.typography.labelSmall)
+
+                    Button(
+                      onClick = {
+                        if (newClientName.isNotBlank()) {
+                          val newList = settings.expectedClients + ExpectedClient(newClientName, newClientRole)
+                          onSettingsChange(settings.copy(expectedClients = newList))
+                          newClientName = ""
+                          showAddClient = false
+                        }
+                      },
+                      enabled = newClientName.isNotBlank()
+                    ) {
+                      Icon(Icons.Default.Add, null)
+                    }
+                  }
+                } else {
+                  TextButton(onClick = { showAddClient = true }) {
+                    Icon(Icons.Default.Add, null)
+                    Spacer(Modifier.width(8.dp))
+                    Text("Client hinzufügen")
+                  }
+                }
+
+                HorizontalDivider(Modifier, DividerDefaults.Thickness, DividerDefaults.color)
+                OutlinedTextField(
+                  value = settings.backupPath,
+                  onValueChange = { onSettingsChange(settings.copy(backupPath = it)) },
+                  label = { Text("Backup-Verzeichnis (Pfad)") },
+                  placeholder = { Text("/pfad/zu/den/backups") },
+                  modifier = Modifier.fillMaxWidth(),
+                  isError = settings.backupPath.isNotEmpty() && !OnboardingValidator.isBackupPathValid(settings.backupPath)
+                )
+
+                Text("Sync-Intervall: ${settings.syncInterval} Min.", style = MaterialTheme.typography.labelMedium)
+                Slider(
+                  value = settings.syncInterval.toFloat(),
+                  onValueChange = { onSettingsChange(settings.copy(syncInterval = it.toInt())) },
+                  valueRange = 1f..60f,
+                  steps = 59
+                )
+              } else {
+                HorizontalDivider(Modifier, DividerDefaults.Thickness, DividerDefaults.color)
+                Text("🔍 Verfügbare Master im Netzwerk", style = MaterialTheme.typography.titleSmall)
+
+                if (discoveredServices.isEmpty()) {
+                  Box(Modifier.fillMaxWidth().padding(16.dp), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator(modifier = Modifier.size(24.dp))
+                    Text("Suche nach Master...", modifier = Modifier.padding(start = 40.dp))
+                  }
+                }
+
+                discoveredServices.forEach { service ->
+                  ListItem(
+                    headlineContent = { Text(service.name) },
+                    supportingContent = { Text("${service.host}:${service.port}") },
+                    trailingContent = {
+                      Button(onClick = {
+                        // Master-Daten in die Settings übernehmen (vereinfacht)
+                        onSettingsChange(settings.copy(sharedKey = service.metadata["key"] ?: settings.sharedKey))
+                      }) {
+                        Text("Verbinden")
+                      }
+                    },
+                    colors = ListItemDefaults.colors(containerColor = MaterialTheme.colorScheme.primaryContainer)
+                  )
+                }
+
+                Text(
+                  "Hinweis: Als Client wird dieses Gerät automatisch versuchen, den Master im Netzwerk zu finden.",
+                  style = MaterialTheme.typography.bodySmall,
+                  color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+              }
+            }
+          }
+
+          Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+          ) {
+            TextButton(onClick = { currentStep = 0 }) {
+              Icon(Icons.AutoMirrored.Filled.ArrowBack, null)
+              Spacer(Modifier.width(8.dp))
+              Text("Zurück zur Rollenauswahl")
+            }
+
+            Button(
+              onClick = { onContinue(settings) },
+              enabled = OnboardingValidator.canContinue(settings)
+            ) {
+              Text("Konfiguration abschließen")
+              Icon(Icons.Default.Check, null, Modifier.padding(start = 8.dp))
+            }
+          }
+        }
+      }
+    }
+  }
+}

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/screens/profile/ProfileScreens.kt

@@ -0,0 +1,326 @@
+package at.mocode.desktop.screens.profile
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import at.mocode.desktop.data.Store
+import at.mocode.desktop.theme.DesktopTheme
+import at.mocode.frontend.core.designsystem.components.MsTextField
+
+@Composable
+fun PferdProfil(id: Long, onBack: () -> Unit) {
+  DesktopTheme {
+    val pferd = remember(id) { Store.pferde.firstOrNull { it.id == id } }
+    if (pferd == null) {
+      Text("Pferd nicht gefunden"); return@DesktopTheme
+    }
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Zurück") }
+        Text("Pferde-Profil", style = MaterialTheme.typography.titleLarge)
+      }
+
+      var editOpen by remember { mutableStateOf(false) }
+      Card(Modifier.fillMaxWidth()) {
+        Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+          Box(
+            modifier = Modifier.size(56.dp).background(Color(0xFF374151), shape = MaterialTheme.shapes.small),
+            contentAlignment = Alignment.Center
+          ) {
+            Text(pferd.name.take(2).uppercase(), color = Color.White, fontWeight = FontWeight.SemiBold)
+          }
+          Spacer(Modifier.width(12.dp))
+          Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text(pferd.name, style = MaterialTheme.typography.titleMedium)
+            val l2 =
+              listOfNotNull(pferd.oepsNummer?.let { "OEPS: $it" }, pferd.feiId?.let { "FEI: $it" }).joinToString(" · ")
+            if (l2.isNotBlank()) Text(l2, color = Color(0xFF6B7280))
+            val l3 = listOfNotNull(pferd.geburtsdatum?.let { "geb. $it" }, pferd.farbe).joinToString(" · ")
+            if (l3.isNotBlank()) Text(l3, color = Color(0xFF6B7280))
+          }
+          Button(onClick = { editOpen = true }) { Text("bearbeiten") }
+        }
+      }
+
+      if (editOpen) {
+        var name by remember { mutableStateOf(pferd.name) }
+        var oeps by remember { mutableStateOf(pferd.oepsNummer ?: "") }
+        var fei by remember { mutableStateOf(pferd.feiId ?: "") }
+        var geb by remember { mutableStateOf(pferd.geburtsdatum ?: "") }
+        var farbe by remember { mutableStateOf(pferd.farbe ?: "") }
+
+        AlertDialog(
+          onDismissRequest = { editOpen = false },
+          confirmButton = {
+            TextButton(onClick = {
+              pferd.name = name
+              pferd.oepsNummer = oeps.ifBlank { null }
+              pferd.feiId = fei.ifBlank { null }
+              pferd.geburtsdatum = geb.ifBlank { null }
+              pferd.farbe = farbe.ifBlank { null }
+              editOpen = false
+            }) { Text("Speichern") }
+          },
+          dismissButton = { TextButton(onClick = { editOpen = false }) { Text("Abbrechen") } },
+          title = { Text("Pferd bearbeiten") },
+          text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              MsTextField(name, { name = it }, label = "Name", modifier = Modifier.fillMaxWidth())
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(oeps, { oeps = it }, label = "ÖPS-Nr.", modifier = Modifier.weight(1f))
+                MsTextField(fei, { fei = it }, label = "FEI-ID", modifier = Modifier.weight(1f))
+              }
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(geb, { geb = it }, label = "Geburtsdatum", modifier = Modifier.weight(1f))
+                MsTextField(farbe, { farbe = it }, label = "Farbe", modifier = Modifier.weight(1f))
+              }
+            }
+          }
+        )
+      }
+    }
+  }
+}
+
+@Composable
+fun ReiterProfil(id: Long, onBack: () -> Unit) {
+  DesktopTheme {
+    val r = remember(id) { Store.reiter.firstOrNull { it.id == id } }
+    if (r == null) {
+      Text("Reiter nicht gefunden"); return@DesktopTheme
+    }
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Zurück") }
+        Text("Reiter-Profil", style = MaterialTheme.typography.titleLarge)
+      }
+
+      var editOpen by remember { mutableStateOf(false) }
+      Card(Modifier.fillMaxWidth()) {
+        Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+          Box(
+            modifier = Modifier.size(56.dp).background(Color(0xFF1E3A8A), shape = MaterialTheme.shapes.small),
+            contentAlignment = Alignment.Center
+          ) {
+            Text(
+              (r.vorname.take(1) + r.nachname.take(1)).uppercase(),
+              color = Color.White,
+              fontWeight = FontWeight.SemiBold
+            )
+          }
+          Spacer(Modifier.width(12.dp))
+          Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text("${r.vorname} ${r.nachname}", style = MaterialTheme.typography.titleMedium)
+            val l2 = listOfNotNull(r.oepsNummer?.let { "OEPS: $it" }, r.nation).joinToString(" · ")
+            if (l2.isNotBlank()) Text(l2, color = Color(0xFF6B7280))
+            val l3 = listOfNotNull("Lizenz: ${r.lizenzKlasse}", r.verein).joinToString(" · ")
+            if (l3.isNotBlank()) Text(l3, color = Color(0xFF6B7280))
+          }
+          Button(onClick = { editOpen = true }) { Text("bearbeiten") }
+        }
+      }
+
+      if (editOpen) {
+        var vor by remember { mutableStateOf(r.vorname) }
+        var nach by remember { mutableStateOf(r.nachname) }
+        var oeps by remember { mutableStateOf(r.oepsNummer ?: "") }
+        var liz by remember { mutableStateOf(r.lizenzKlasse) }
+        var verein by remember { mutableStateOf(r.verein ?: "") }
+
+        AlertDialog(
+          onDismissRequest = { editOpen = false },
+          confirmButton = {
+            TextButton(onClick = {
+              r.vorname = vor
+              r.nachname = nach
+              r.oepsNummer = oeps.ifBlank { null }
+              r.lizenzKlasse = liz
+              r.verein = verein.ifBlank { null }
+              editOpen = false
+            }) { Text("Speichern") }
+          },
+          dismissButton = { TextButton(onClick = { editOpen = false }) { Text("Abbrechen") } },
+          title = { Text("Reiter bearbeiten") },
+          text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(vor, { vor = it }, label = "Vorname", modifier = Modifier.weight(1f))
+                MsTextField(nach, { nach = it }, label = "Nachname", modifier = Modifier.weight(1f))
+              }
+              MsTextField(oeps, { oeps = it }, label = "OEPS-Nr.", modifier = Modifier.fillMaxWidth())
+              MsTextField(liz, { liz = it }, label = "Lizenzklasse", modifier = Modifier.fillMaxWidth())
+              MsTextField(verein, { verein = it }, label = "Verein", modifier = Modifier.fillMaxWidth())
+            }
+          }
+        )
+      }
+    }
+  }
+}
+
+@Composable
+fun VereinProfil(id: Long, onBack: () -> Unit) {
+  DesktopTheme {
+    val v = remember(id) { Store.vereine.firstOrNull { it.id == id } }
+    if (v == null) {
+      Text("Verein nicht gefunden"); return@DesktopTheme
+    }
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Zurück") }
+        Text("Vereins-Profil", style = MaterialTheme.typography.titleLarge)
+      }
+
+      var editOpen by remember { mutableStateOf(false) }
+      Card(Modifier.fillMaxWidth()) {
+        Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+          Box(
+            modifier = Modifier.size(56.dp).background(Color(0xFF1F2937), shape = MaterialTheme.shapes.small),
+            contentAlignment = Alignment.Center
+          ) {
+            Text((v.kurzname ?: v.name).take(2).uppercase(), color = Color.White, fontWeight = FontWeight.SemiBold)
+          }
+          Spacer(Modifier.width(12.dp))
+          Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text(v.name, style = MaterialTheme.typography.titleMedium)
+            val l2 = listOfNotNull("OEPS: ${v.oepsNummer}", v.ort, v.plz, v.strasse).filter { it.isNotBlank() }
+              .joinToString(" · ")
+            if (l2.isNotBlank()) Text(l2, color = Color(0xFF6B7280))
+            val l3 = listOfNotNull(v.email, v.telefon).filter { it.isNotBlank() }.joinToString(" · ")
+            if (l3.isNotBlank()) Text(l3, color = Color(0xFF6B7280))
+          }
+          Button(onClick = { editOpen = true }) { Text("bearbeiten") }
+        }
+      }
+
+      if (editOpen) {
+        var name by remember { mutableStateOf(v.name) }
+        var oeps by remember { mutableStateOf(v.oepsNummer) }
+        var ort by remember { mutableStateOf(v.ort ?: "") }
+        var plz by remember { mutableStateOf(v.plz ?: "") }
+        var strasse by remember { mutableStateOf(v.strasse ?: "") }
+        var email by remember { mutableStateOf(v.email ?: "") }
+        var tel by remember { mutableStateOf(v.telefon ?: "") }
+
+        AlertDialog(
+          onDismissRequest = { editOpen = false },
+          confirmButton = {
+            TextButton(onClick = {
+              v.name = name
+              v.oepsNummer = oeps
+              v.ort = ort.ifBlank { null }
+              v.plz = plz.ifBlank { null }
+              v.strasse = strasse.ifBlank { null }
+              v.email = email.ifBlank { null }
+              v.telefon = tel.ifBlank { null }
+              editOpen = false
+            }) { Text("Speichern") }
+          },
+          dismissButton = { TextButton(onClick = { editOpen = false }) { Text("Abbrechen") } },
+          title = { Text("Verein bearbeiten") },
+          text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              MsTextField(name, { name = it }, label = "Name", modifier = Modifier.fillMaxWidth())
+              MsTextField(oeps, { oeps = it }, label = "OEPS-Nr.", modifier = Modifier.fillMaxWidth())
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(ort, { ort = it }, label = "Ort", modifier = Modifier.weight(1f))
+                MsTextField(plz, { plz = it }, label = "PLZ", modifier = Modifier.weight(1f))
+              }
+              MsTextField(strasse, { strasse = it }, label = "Straße", modifier = Modifier.fillMaxWidth())
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(email, { email = it }, label = "E-Mail", modifier = Modifier.weight(1f))
+                MsTextField(tel, { tel = it }, label = "Telefon", modifier = Modifier.weight(1f))
+              }
+            }
+          }
+        )
+      }
+    }
+  }
+}
+
+@Composable
+fun FunktionaerProfil(id: Long, onBack: () -> Unit) {
+  DesktopTheme {
+    val f = remember(id) { Store.funktionaere.firstOrNull { it.id == id } }
+    if (f == null) {
+      Text("Funktionär nicht gefunden"); return@DesktopTheme
+    }
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+      Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+        IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Zurück") }
+        Text("Funktionärs-Profil", style = MaterialTheme.typography.titleLarge)
+      }
+
+      var editOpen by remember { mutableStateOf(false) }
+      Card(Modifier.fillMaxWidth()) {
+        Row(Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
+          Box(
+            modifier = Modifier.size(56.dp).background(Color(0xFF111827), shape = MaterialTheme.shapes.small),
+            contentAlignment = Alignment.Center
+          ) {
+            val initials =
+              (f.vorname + " " + f.nachname).trim().split(" ").mapNotNull { it.firstOrNull()?.toString() }.take(2)
+                .joinToString("")
+            Text(initials.uppercase(), color = Color.White, fontWeight = FontWeight.SemiBold)
+          }
+          Spacer(Modifier.width(12.dp))
+          Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+            Text("${f.vorname} ${f.nachname}", style = MaterialTheme.typography.titleMedium)
+            val l2 = listOfNotNull(
+              f.richterNummer?.let { "Nr. $it" },
+              f.richterQualifikation?.let { "Qual.: $it" }).joinToString(" · ")
+            if (l2.isNotBlank()) Text(l2, color = Color(0xFF6B7280))
+            f.email?.let { Text(it, color = Color(0xFF6B7280)) }
+          }
+          Button(onClick = { editOpen = true }) { Text("bearbeiten") }
+        }
+      }
+
+      if (editOpen) {
+        var vor by remember { mutableStateOf(f.vorname) }
+        var nach by remember { mutableStateOf(f.nachname) }
+        var num by remember { mutableStateOf(f.richterNummer ?: "") }
+        var qual by remember { mutableStateOf(f.richterQualifikation ?: "") }
+        var email by remember { mutableStateOf(f.email ?: "") }
+
+        AlertDialog(
+          onDismissRequest = { editOpen = false },
+          confirmButton = {
+            TextButton(onClick = {
+              f.vorname = vor
+              f.nachname = nach
+              f.richterNummer = num.ifBlank { null }
+              f.richterQualifikation = qual.ifBlank { null }
+              f.email = email.ifBlank { null }
+              editOpen = false
+            }) { Text("Speichern") }
+          },
+          dismissButton = { TextButton(onClick = { editOpen = false }) { Text("Abbrechen") } },
+          title = { Text("Funktionär bearbeiten") },
+          text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(vor, { vor = it }, label = "Vorname", modifier = Modifier.weight(1f))
+                MsTextField(nach, { nach = it }, label = "Nachname", modifier = Modifier.weight(1f))
+              }
+              Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                MsTextField(num, { num = it }, label = "Nummer", modifier = Modifier.weight(1f))
+                MsTextField(qual, { qual = it }, label = "Qualifikation", modifier = Modifier.weight(1f))
+              }
+              MsTextField(email, { email = it }, label = "E-Mail", modifier = Modifier.fillMaxWidth())
+            }
+          }
+        )
+      }
+    }
+  }
+}

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/theme/Theme.kt

@@ -1,9 +1,8 @@
-package at.mocode.desktop.v2
+package at.mocode.desktop.theme
 
 import androidx.compose.material3.ColorScheme
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Typography
-import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
@@ -26,7 +25,7 @@ private val LightColors: ColorScheme = lightColorScheme(
 )
 
 @Composable
-fun DesktopThemeV2(content: @Composable () -> Unit) {
+fun DesktopTheme(content: @Composable () -> Unit) {
   MaterialTheme(
     colorScheme = LightColors,
     typography = Typography(),

frontend/shells/meldestelle-desktop/src/jvmMain/kotlin/at/mocode/desktop/v2/NennungsEingangScreen.kt

@@ -1,257 +0,0 @@
-package at.mocode.desktop.v2
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material.icons.filled.Email
-import androidx.compose.material.icons.filled.Refresh
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import at.mocode.frontend.features.nennung.domain.NennungRemoteRepository
-import at.mocode.frontend.features.nennung.domain.NennungResponse
-import kotlinx.coroutines.launch
-import org.koin.compose.koinInject
-
-data class OnlineNennungMail(
-    val id: String,
-    val sender: String,
-    val empfaenger: String,
-    val datum: String,
-    val turnierNr: String,
-    val vorname: String,
-    val nachname: String,
-    val lizenz: String,
-    val pferd: String,
-    val pferdAlter: String,
-    val telefon: String?,
-    val bewerbe: String,
-    val bemerkungen: String?,
-    var status: String = "NEU"
-)
-
-fun NennungResponse.toMail() = OnlineNennungMail(
-  id = id,
-  sender = email,
-  empfaenger = "Meldestelle",
-  datum = "-", // Datum ist in Entity nicht direkt drin, könnte man ergänzen
-  turnierNr = turnierNr,
-  vorname = vorname,
-  nachname = nachname,
-  lizenz = lizenz,
-  pferd = pferdName,
-  pferdAlter = pferdAlter,
-  telefon = telefon,
-  bewerbe = bewerbe,
-  bemerkungen = bemerkungen,
-  status = if (status == "GELESEN") "GELESEN" else "NEU"
-)
-
-@Composable
-fun NennungsEingangScreen(onBack: () -> Unit) {
-  val repository: NennungRemoteRepository = koinInject()
-  val scope = rememberCoroutineScope()
-
-    DesktopThemeV2 {
-        var mails by remember { mutableStateOf<List<OnlineNennungMail>>(emptyList()) }
-        var searchQuery by remember { mutableStateOf("") }
-        var selectedMail by remember { mutableStateOf<OnlineNennungMail?>(null) }
-        var isRefreshing by remember { mutableStateOf(false) }
-
-      val refresh = {
-        scope.launch {
-          isRefreshing = true
-          repository.holeNennungen().onSuccess { response ->
-            mails = response.map { it.toMail() }
-          }.onFailure {
-            // Fallback oder Fehleranzeige
-            if (mails.isEmpty()) mails = getMockMails()
-          }
-          isRefreshing = false
-        }
-      }
-
-        val filteredMails = remember(mails, searchQuery) {
-            if (searchQuery.isBlank()) mails
-            else mails.filter {
-                it.vorname.contains(searchQuery, ignoreCase = true) ||
-                it.nachname.contains(searchQuery, ignoreCase = true) ||
-                it.pferd.contains(searchQuery, ignoreCase = true) ||
-                it.turnierNr.contains(searchQuery, ignoreCase = true)
-            }
-        }
-
-        // Initiales Laden
-        LaunchedEffect(Unit) {
-          refresh()
-        }
-
-        if (selectedMail != null) {
-            NennungDetailDialog(
-                mail = selectedMail!!,
-                onDismiss = { selectedMail = null },
-                onMarkProcessed = {
-                  scope.launch {
-                    repository.markiereAlsGelesen(selectedMail!!.id)
-                    val updated = mails.map { if (it.id == selectedMail!!.id) it.copy(status = "GELESEN") else it }
-                    mails = updated
-                    selectedMail = null
-                  }
-                }
-            )
-        }
-
-        Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
-            // Header
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-                IconButton(onClick = onBack) { Icon(Icons.AutoMirrored.Filled.ArrowBack, null) }
-                Icon(Icons.Default.Email, null, modifier = Modifier.size(32.dp), tint = MaterialTheme.colorScheme.primary)
-                Text("Nennungs-Eingang (Online-Nennen)", style = MaterialTheme.typography.headlineMedium)
-                Spacer(Modifier.weight(1f))
-                if (isRefreshing) CircularProgressIndicator(modifier = Modifier.size(24.dp), strokeWidth = 2.dp)
-                Button(
-                  onClick = { refresh() },
-                    enabled = !isRefreshing
-                ) {
-                    Icon(Icons.Default.Refresh, null)
-                    Spacer(Modifier.width(8.dp))
-                    Text("Aktualisieren")
-                }
-            }
-
-            Text(
-                "Hier werden alle eingegangenen Online-Nennungen angezeigt. Klicke auf 'Anzeigen', um alle Details für die manuelle Übernahme zu sehen.",
-                style = MaterialTheme.typography.bodyMedium,
-                color = Color.Gray
-            )
-
-            // Suchfeld
-            OutlinedTextField(
-                value = searchQuery,
-                onValueChange = { searchQuery = it },
-                modifier = Modifier.fillMaxWidth(),
-                placeholder = { Text("Suche nach Reiter, Pferd oder Turnier-Nr...") },
-                leadingIcon = { Icon(Icons.Default.Search, null) },
-                singleLine = true,
-                shape = RoundedCornerShape(12.dp)
-            )
-
-            // Tabelle
-            Card(modifier = Modifier.fillMaxWidth().weight(1f)) {
-                Column {
-                    // Header Zeile
-                    Row(
-                        Modifier.fillMaxWidth().background(MaterialTheme.colorScheme.surfaceVariant).padding(12.dp),
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text("Status", Modifier.width(80.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Datum", Modifier.width(150.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Turnier", Modifier.width(80.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Reiter", Modifier.width(200.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Pferd", Modifier.width(200.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Bewerbe", Modifier.weight(1f), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                        Text("Aktion", Modifier.width(120.dp), fontWeight = FontWeight.Bold, fontSize = 13.sp)
-                    }
-                    HorizontalDivider()
-
-                    if (filteredMails.isEmpty() && !isRefreshing) {
-                        Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                            Text(
-                                if (searchQuery.isBlank()) "Keine neuen Nennungen vorhanden."
-                                else "Keine Nennungen für '$searchQuery' gefunden.",
-                                color = Color.Gray
-                            )
-                        }
-                    } else {
-                        LazyColumn(Modifier.fillMaxSize()) {
-                            items(filteredMails) { mail ->
-                                Row(
-                                    Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 8.dp),
-                                    verticalAlignment = Alignment.CenterVertically
-                                ) {
-                                    Badge(
-                                        containerColor = if (mail.status == "NEU") Color(0xFFE74C3C) else Color(0xFFBDC3C7),
-                                        modifier = Modifier.width(80.dp).padding(end = 8.dp)
-                                    ) {
-                                        Text(mail.status, color = Color.White, fontSize = 10.sp)
-                                    }
-                                    Text(mail.datum, Modifier.width(150.dp), fontSize = 13.sp)
-                                    Text(mail.turnierNr, Modifier.width(80.dp), fontSize = 13.sp, fontWeight = FontWeight.SemiBold)
-                                    Text("${mail.vorname} ${mail.nachname}", Modifier.width(200.dp), fontSize = 13.sp)
-                                    Text(mail.pferd, Modifier.width(200.dp), fontSize = 13.sp)
-                                    Text(mail.bewerbe, Modifier.weight(1f), fontSize = 13.sp)
-
-                                    Button(
-                                        onClick = { selectedMail = mail },
-                                        contentPadding = PaddingValues(horizontal = 12.dp, vertical = 4.dp),
-                                        modifier = Modifier.width(120.dp).height(32.dp),
-                                        colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.primary)
-                                    ) {
-                                        Text("Anzeigen", fontSize = 11.sp)
-                                    }
-                                }
-                                HorizontalDivider(Modifier.padding(horizontal = 8.dp), thickness = 0.5.dp)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-fun NennungDetailDialog(mail: OnlineNennungMail, onDismiss: () -> Unit, onMarkProcessed: () -> Unit) {
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text("Details zur Online-Nennung") },
-        text = {
-            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
-                DetailRow("Absender", mail.sender)
-                DetailRow("Turnier", mail.turnierNr)
-                DetailRow("Eingang", mail.datum)
-                HorizontalDivider()
-                Text("Reiter: ${mail.vorname} ${mail.nachname} (${mail.lizenz})", fontWeight = FontWeight.Bold)
-                Text("Pferd: ${mail.pferd} (Geb. ${mail.pferdAlter})", fontWeight = FontWeight.Bold)
-                DetailRow("Telefon", mail.telefon ?: "-")
-                HorizontalDivider()
-                Text("Ausgewählte Bewerbe:", fontWeight = FontWeight.SemiBold)
-                Text(mail.bewerbe)
-                if (!mail.bemerkungen.isNullOrBlank()) {
-                    Text("Bemerkungen:", fontWeight = FontWeight.SemiBold)
-                    Text(mail.bemerkungen, color = Color.DarkGray)
-                }
-            }
-        },
-        confirmButton = {
-            Button(onClick = onMarkProcessed) { Text("Als gelesen markieren") }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) { Text("Schließen") }
-        }
-    )
-}
-
-@Composable
-fun DetailRow(label: String, value: String) {
-    Row(Modifier.fillMaxWidth()) {
-        Text("$label: ", fontWeight = FontWeight.SemiBold, modifier = Modifier.width(100.dp))
-        Text(value)
-    }
-}
-
-private fun getMockMails() = listOf(
-    OnlineNennungMail("1", "max.mustermann@web.de", "meldestelle-26128@mo-code.at", "14.04.2026 14:30", "26128", "Max", "Mustermann", "R2", "Spirit", "2015", "0664/1234567", "1, 2, 5", "Brauche Box für Freitag"),
-    OnlineNennungMail("2", "susi.sorglos@gmx.at", "meldestelle-26128@mo-code.at", "14.04.2026 15:12", "26128", "Susi", "Sorglos", "LF", "Flocke", "2018", null, "10, 11", null),
-    OnlineNennungMail("3", "info@reitstall-hofer.at", "meldestelle-26129@mo-code.at", "14.04.2026 16:05", "26129", "Georg", "Hofer", "R3", "Black Beauty", "2012", "0676/9876543", "3, 4, 8", "Bitte späte Startzeit")
-)