Atlas: Logistik-Gerüst + Heli-Fix + Waypoints-Regen + Level-Picker

- Neues Modul 'Logistik Europa': module_info-Eintrag, Landing-Card,
  PHP-Wrapper (logistik.php, modul-logistik.php), Engine-Skelett mit
  Enums + Helpern (travelCost, latePenalty, Bonus, Dijkstra,
  Polyline-Interpolation), Test-Harness, Kompetenzen-Draft,
  5 Seed-Dateien (locations, vehicle-types, cargo-types, railnet,
  contract-templates), 3 Level-Einträge in game_levels, Phase 0 durch
  die Logistik-Instanz geliefert und Atlas-Review bestanden
- Heli-Fix: heli-game.php mit BASE_PATH (production-sicher) +
  Asset-Pfad-Injection, geo_waypoints-Tabelle per Seed-Script
  auffindbar gemacht
- Waypoints-Regen-Tool: regen-waypoints-sql.php synchronisiert
  waypoints.sql aus DB (70 Einträge)
- Design-System: .ggs-level-grid / .ggs-level-card als Standard
  gepromotet (Klimas Muster, iPad-hover-safe)
- Inbox-Nachrichten: Kickoff-Briefings für Heli und Logistik,
  Asset-Map für Heli, DALL-E-Pipeline-Anleitung, Koordinations-
  nachrichten an Fluss, Klima, Glossar, Lehrplan

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

App/sims/_inbox/logistik/2026-04-19-2315-kickoff-briefing.md

@@ -0,0 +1,480 @@
+---
+von: atlas
+an: logistik
+datum: 2026-04-19 23:15
+status: neu
+betrifft: Kickoff-Briefing — Simulation „Logistik Europa"
+---
+
+# Willkommen, Logistik-Instanz
+
+Thomas baut mit dir das anspruchsvollste Modul der Plattform: eine
+europaweite Logistik-Simulation auf OSM-Basis. Ein ausführliches
+Pflichtenheft (64 Seiten, extern verfasst) liegt vor. Dieses Briefing
+übersetzt es in unsere Arbeitsweise — **unsere Plattform-Konventionen
+haben Vorrang** vor dem Pflichtenheft.
+
+---
+
+## 1. Deine Rolle
+
+Du bist die **Logistik-Instanz**. Du besitzt:
+- `App/sims/logistik/` (Gerüst wird von Atlas noch angelegt)
+- `App/pages/logistik.php`, `App/pages/modul-logistik.php`
+- `App/php/api/logistik-*.php` (neue API-Endpunkte)
+- Ggf. neue MySQL-Tabellen unter Präfix `lg_…` (Vorschläge erst mit
+  Atlas abstimmen — mehr dazu unten)
+
+Atlas bleibt Plattform-Zentrale. Anfragen dafür schickst du an
+`_inbox/zentrale/`.
+
+---
+
+## 2. Pflichtenheft-Referenz
+
+**Datei:** `.humanInput/Pflichtenheft Geo Gra Sim Logistik Europa.pdf`
+
+**Wichtig:** Das Dokument wurde extern verfasst und an mehreren Stellen
+in Konflikt zu unserem bestehenden System. Ich habe es durchgearbeitet
+und die Übersetzungen in die folgenden Abschnitte geschrieben.
+
+**Besonders wertvoll aus dem Pflichtenheft:**
+- Kap 3.4 — 28 didaktische Kernziele (exakte Vorlage für Lehrplan-Anker)
+- Kap 13 — Level-Vereinfachungsstrategie (Level 1 / 2 / 3 / spätere)
+- Kap 14 — UI-Zonen (Karte + Aufträge + Fahrzeuge + Status + Ereignisse + Hilfe)
+- Kap 17 — Datenmodell-Vorschläge (als Inspiration, nicht als Pflicht)
+- Kap 19 — Balancing-Grundsätze
+- Kap 34 — Testfälle (fachlich, didaktisch, technisch)
+- Kap 42–51 — Enums, Interfaces, Tick-Pipeline, Bewegungslogik, Events
+- **Kap 65 — konkrete Parameterwerte** (verbindliche Startwerte; siehe unten)
+
+---
+
+## 3. Plattform-Konventionen haben Vorrang
+
+### ❌ Nicht übernehmen (Pflichtenheft-Vorschläge, die unserem System widersprechen)
+
+| Pflichtenheft | Unsere Entscheidung |
+|---------------|---------------------|
+| TypeScript (Kap 40.2, 43, 47) | **Vanilla JS mit JSDoc-Types** wie Klima/Fluss. Keine Build-Pipeline für dieses Modul. |
+| Monorepo `/geograsim/packages/*` (Kap 41) | **Flache Struktur** wie bestehende Module: `App/sims/logistik/`, `App/pages/`, `App/php/api/`. |
+| Redux Toolkit / Vue Pinia (Kap 53.2) | **Einfache Zustandsobjekte** nach Klima-Vorbild (`window.LogistikEngine`). |
+| Node.js-Backend (Kap 7.3) | **PHP 8 + PDO** (MySQL utf8mb4). Wie alle anderen Module. |
+| 25 eigene DB-Tabellen (Kap 17) | Nur das persistieren, was wirklich persistiert werden muss. Vieles läuft als JSON in bestehenden Tabellen (`game_levels.params`, `game_saves.save_data`) oder als Seed-Dateien unter `App/assets/data/`. |
+| KI zur Laufzeit (Kap 16, 20) | **Keine KI im Produkt.** Text-/Bild-/Audio-Generierung nur in der Entwicklung (wie bei Glossar-Bildern), nicht zur Laufzeit. Grund: Kosten, Latenz, Datenschutz, deterministisches Balancing. |
+| „Collections" / NoSQL-Wording (Kap 17) | MySQL, relational, normalisiert. |
+
+### 🔧 Anpassen (inhaltlich übernehmen, in unsere Formate übersetzen)
+
+- **Savegame-Format (Kap 54)** → unsere Tabelle `game_saves` (Feld `save_data` als JSON-Text, `save_version`). Kein eigenes Savegame-System bauen.
+- **API-Design (Kap 55)** → als PHP-Endpunkte `App/php/api/logistik-contracts.php`, `logistik-sessions.php`, `logistik-routes.php`, `logistik-hints.php`, `logistik-minigame.php`. Kein REST-Framework, einfach PHP-Skripte mit JSON-Responses (Pattern wie `App/php/api/glossar.php`).
+- **State Machine (Kap 44)** → einfache String-Konstanten in JS. Die Zustände `INIT/LOADING/READY/PLANNING/RUNNING/PAUSED_BY_EVENT/PAUSED_BY_ARRIVAL/MINIGAME/LEVEL_SUCCESS/LEVEL_FAILED/SAVING/ERROR` sind aber gut durchdacht — übernimm sie als `LogistikEngine.STATE` Enum.
+- **Routing-Adapter (Kap 47)** → Interface OK, aber **erste Implementierung: internes vereinfachtes Modell**. Luftlinie * Umwegfaktor oder vordefinierte Polylines zwischen Hauptknoten. OSRM/GraphHopper erst, wenn die Kern-Simulation steht.
+- **Bahnnetz-Modell (Kap 48, 65.8)** → als JSON-Datei `App/assets/data/lg-railnet.json` mit `nodes[]` und `edges[]`. Dijkstra in Vanilla JS implementieren — ist ~50 Zeilen.
+- **Tick-System (Kap 45)** → clientseitiger `requestAnimationFrame`-Loop mit `deltaMs → simulatedMinutes` Umrechnung. Nicht serverseitig. Thomas' Geräte sind Schulen-Geräte, Server-Ticks sind Overkill.
+
+### ✅ Direkt übernehmen
+
+- Leaflet + OSM-Tiles (wie Heli)
+- 28 Kompetenzziele aus Kap 3.4 als Lehrplan-Basis
+- Hilfestufen-System (Kap 10.3): `BLINK_EXACT / SHOW_COUNTRY / SHOW_REGION / DISTANCE_FEEDBACK / NONE`
+- Konkrete Parameterwerte aus Kap 65 (siehe Balance-Kapitel unten)
+- Level-Progression (Kap 13): Level 1 / 2 / 3 / spätere
+- Teststrategie (Kap 34, 61)
+- Offline-Fallback (Kap 25)
+
+---
+
+## 4. Pflicht-Konventionen unserer Plattform
+
+### 4a — Sprachregel: keine Spielsprache
+**Nie** „spielen", „Spiel", „Spieler:in", „Game Over", „Punkte sammeln".
+**Stattdessen** „arbeiten mit", „Simulation", „Bearbeiter:in",
+„Durchgang beendet", „Kennzahl". Bildungstheoretische Grundlage:
+Wygotski, Lernarbeit statt Spiel. Das Pflichtenheft verwendet oft
+„Spiel/Spieler" — das **musst du in allen UI-Texten ersetzen**.
+Interne Variablennamen (`gameState`, `GameState`, `game.tick`) dürfen
+bleiben.
+
+Siehe `App/docs/module-interface.md` Abschnitt 4a.
+
+### 4b — Leichte Sprache
+Per Schüler:in-Flag in DB. Fallback-Pattern `pickText()`. Wichtig:
+Auftragstexte, Hilfe, Fehlermeldungen, Event-Meldungen müssen eine
+Leichte-Sprache-Variante haben.
+
+### 4c — iPad als Referenzgerät
+1180×820 Landscape. Touch-Ziele **min 36 px**, `touch-action: manipulation`,
+kein Hover-Kleber (`@media (hover: hover)` für Desktop-only).
+Leaflet Touch-Support aktivieren.
+
+### 7b — Autosave-Pflicht
+Alle `state.relevanten` Zustandsübergänge → Autosave. Thomas hat explizit
+nach persistenter Session gefragt. Pattern: lokal in localStorage +
+bei Session optional an Server. Siehe `App/docs/module-interface.md`.
+
+### Inbox-Check vor „Fertig"
+Bevor du „fertig" meldest: `_inbox/logistik/` prüfen. Sonst gehen
+Antworten verloren.
+
+### Commit-Format
+`Logistik: <Kurzbeschreibung>` — z.B. `Logistik: Tick-Engine + Fahrzeug-Bewegung`.
+
+### `_status.md`
+Lege dir eines an unter `App/sims/_inbox/logistik/_status.md`:
+Rolle, aktueller Stand, offene Aufgaben, Blocker. Aktualisiere nach
+jeder Phase.
+
+### Keine KI im Produkt
+(Siehe oben.) Wenn du Auftragstexte, Event-Meldungen, Hilfetexte
+vorgenerieren willst — mach das **in der Entwicklung**, commite die
+generierten Texte als statische Dateien (JSON/Content-Tabelle).
+
+---
+
+## 5. Balance-First-Approach (WICHTIGSTER Punkt)
+
+Thomas' explizite Vorgabe: **Die Simulation muss von Anfang an
+balanciert sein.**
+
+- **Level 1 (Lernen)**: komfortabel zu schaffen, auch bei
+  Anfänger-Fehlern. Ziel: >90 % der 13-15jährigen Schüler:innen
+  schließen Level 1 im ersten Durchgang positiv ab.
+- **Level 3 (Profi)**: *knapp* zu schaffen. Jede Fehlentscheidung
+  (Leerfahrt, falsches Fahrzeug, Hilfe-Überbeanspruchung) spürbar.
+  Ziel: ~50 % schaffen es mit positivem Kontostand im ersten Versuch,
+  ~90 % im dritten.
+
+### 5.1 — Bevor du ein Feature baust: Balance-Matrix
+
+**Erster Schritt in Phase 0** (vor jeder Implementierung):
+
+Erstelle `App/sims/logistik/balance-matrix.md` mit:
+
+| Parameter | Level 1 | Level 2 | Level 3 | Quelle (Pflichtenheft) |
+|-----------|---------|---------|---------|------------------------|
+| Startbudget (€) | 8.000 | 5.000 | 2.500 | (deine Schätzung, testen!) |
+| Anzahl Aufträge parallel | 1 | 3 | 6 | Kap 13.3 |
+| Anzahl Fahrzeuge | 1 | 3 | 5 | Kap 13.3 |
+| Fristlänge-Multiplikator | *1.5 | *1.2 | *1.0 | Kap 65.6 |
+| Hilfestufe | `BLINK_EXACT` | `SHOW_REGION` | `NONE` | Kap 10.3 |
+| Event-Wahrscheinlichkeit (%/h) | 2 | 5 | 10 | Kap 65.5 (halbiert für L1) |
+| Verspätungsstrafe (% Wert/h) | 10 | 20 | 30 | Kap 65.2 |
+| Miete Fahrzeug (€/Tag) | 0 | 200 | 500 | Kap 65.2 |
+| Min Ziel-Erlös | 3.000 € | 10.000 € | 20.000 € | eigene Schätzung |
+| Zeitlimit (Spielstunden) | 24 | 48 | 72 | eigene Schätzung |
+
+Das ist **ein Vorschlag als Startpunkt**. Testen, justieren, ins
+`game_levels.params` persistieren.
+
+### 5.2 — Konkrete Pflichtwerte aus Kap 65 (verbindlich)
+
+**Fahrzeuge:**
+- Kleiner LKW: 70 km/h, 1 Container, 1.20 €/km, 25 €/h, Lade-/Entladezeit 5 min
+- Großer LKW: 60 km/h, 3 Container, 2.50 €/km, 45 €/h, Lade-/Entladezeit 8 min
+- Zug: 90 km/h, 20 Container, 8 €/km, 150 €/h, Lade-/Entladezeit 20 min pro 10er-Block
+
+**Aufträge:**
+- Standard: Basis 1.000 €, 1-3 Container, Frist = Distanz/60 * 1.5 Stunden
+- Eilauftrag: Basis 1.500 €, Frist = Distanz/70
+
+**Bonus/Malus:**
+- Pünktlich: +10 %
+- Optimal (keine Leerfahrt): +20 %
+- Strafe pro Stunde Verspätung: 20 % vom Auftragswert
+
+**Event-Wahrscheinlichkeiten (pro Stunde):**
+- Unfall: 5 % (Geschwindigkeit * 0.5)
+- Schnee in Alpen: 10 % (Geschwindigkeit * 0.7)
+- Hafenüberlastung: 8 % (Ladezeit * 1.5)
+
+**Zeit-Skala:**
+- 1 Tick = 250 ms Echtzeit
+- 1× = 1 min Spielzeit / s Echtzeit
+- 4× = 4 min/s, 8× = 8 min/s
+
+**Referenz-Distanzen (zum Testen der Routing-Logik):**
+- Wien → Salzburg: 300 km (~4.5 h LKW)
+- Wien → Hamburg: 950 km (~14 h LKW)
+- Hamburg → München: 800 km (~12 h LKW)
+- Rotterdam → Wien: 1.100 km (~16 h LKW)
+
+**Bahnnetz-Kernknoten (Kap 65.8):**
+Wien, München, Hamburg, Rotterdam, Paris
+- Wien–München: 400 km
+- München–Hamburg: 800 km
+- Hamburg–Rotterdam: 500 km
+
+### 5.3 — Regressionstests-Pflicht vor neuen Features
+
+In `App/sims/logistik/tests/` lege Regressionstests an (Vanilla JS,
+keine Test-Runner-Pipeline — einfache Self-Tests via `<script>` in
+einer `test.html`). Jedes neue Feature kommt **mit** Test.
+
+**Pflichttests von Anfang an:**
+1. **Fahrkosten-Formel**: `distanz=300, costPerKm=1.2, fahrzeit=4.5, costPerHour=25 → 472.50 €`
+2. **Route-Interpolation**: Fahrzeug bei 50 % Progress steht auf Mittelpunkt der Polyline
+3. **Strafkosten**: Auftragswert 1.000 €, Verspätung 2 h → 400 € Abzug
+4. **Bonus-Kombi**: Pünktlich + optimal → +30 %
+5. **Event-Auswirkung**: Unfall während Fahrt halbiert Geschwindigkeit für Event-Dauer
+6. **Savegame-Roundtrip**: Zustand X → serialisieren → deserialisieren → Zustand X (deep-equal)
+7. **Bahnrouting Dijkstra**: Wien → Hamburg über München → Hamburg = 1.200 km
+
+**Seeded-Random-Tests:**
+Gleicher Seed → gleicher Session-Verlauf. Sonst ist Balancing nicht
+reproduzierbar messbar.
+
+### 5.4 — Automatisierbare Balance-Tests
+
+Für das eigentliche Balancing: Bau einen **Headless-Runner**, der
+einen Level einmal spielen kann (deterministisch, ohne UI) und am
+Ende Kennzahlen ausspuckt:
+
+```
+runLevel(levelId, seed, strategy) → {
+  successful: boolean,
+  endBalance: number,
+  completedContracts: number,
+  lateDeliveries: number,
+  durationHours: number,
+  hintUsages: number
+}
+```
+
+Mit 3 Strategien: `naive` (erstes Fahrzeug, nächster Auftrag),
+`greedy` (höchster Wert zuerst), `optimal` (Orakel, best case). Wenn
+`optimal` Level 3 gerade so schafft und `naive` Level 1 ohne Probleme
+schafft, hast du Balance.
+
+---
+
+## 6. Phasenplan (inkrementell)
+
+### Phase 0 — Balance-Matrix + Test-Infrastruktur (KEIN Feature-Code!)
+- `balance-matrix.md` mit Werten pro Level
+- `test.html` mit Regressionstest-Harness (in Vanilla JS)
+- Die oben genannten 7 Pflichttests implementiert (auch wenn die zu
+  testenden Funktionen noch Stubs sind)
+- Headless-Runner-Skelett
+- → Atlas-Review, bevor Phase 1 startet
+
+### Phase 1 — Fundament
+- `engine.js` mit State Machine + Tick-Loop
+- Seed-Daten laden: `lg-locations.json` (~30 Städte + 5 Häfen + 3 Bahnterminals)
+- Leaflet-Karte rendern, Marker platzieren
+- Keine Aufträge, keine Fahrzeuge — nur Karte + Daten
+- Pflichttest: seeded-Karte lädt reproduzierbar
+
+### Phase 2 — Kern-Loop (Level 1 spielbar)
+- 1 Fahrzeug, 1 Auftrag, gerader-Luftlinie-Route, Tick-Bewegung
+- Start/Ziel auswählen, Fahrt starten, Ankunft erkennen, Erlös buchen
+- Minimalste UI: Auftragskarte + Fahrzeugpanel + Status + Zeit-Controls
+- **Level 1 muss hier spielbar sein** — nicht mehr, nicht weniger
+- → Thomas testet live, bevor Phase 3 startet
+
+### Phase 3 — Kostenmodell + Mehrfahrzeuge + mehr Aufträge
+- Alle 3 Fahrzeugtypen
+- Kostenformel (Kap 65)
+- Mehrere Aufträge parallel
+- Level 2 wird spielbar
+
+### Phase 4 — Bahn + Häfen + Intermodal
+- Bahnnetz-Dijkstra (5 Knoten, 3 Kanten)
+- Häfen mit Container-Ankunft als Auftragsquelle
+- Intermodale Aufträge (Leg1 LKW → Leg2 Zug → Leg3 LKW)
+- Verladezeiten
+- Level 3 wird spielbar
+
+### Phase 5 — Hilfestufen + Events
+- Hilfesystem (5 Stufen)
+- Event-Engine mit deterministischer Seed
+- Event-Auswirkungen (Speed/Cost/Block)
+
+### Phase 6 — Minigames + Sprachregel-Check + Leichte Sprache
+- 1 Minigame (An-die-Rampe-Einparken) als erstes
+- Volle 4a/4b-Durchsicht aller UI-Texte
+- Glossar-Anfrage für Logistik-Begriffe (Kontainer, Intermodal, Umschlag, Luftlinie, Dijkstra-anschaulich)
+
+### Phase 7 — Lehrkraftmodus + Analytics + Polish
+- Lehrkraft kann Level konfigurieren, Hilfen schalten
+- Analytics-Dashboard mit Kennzahlen aus Kap 23.2
+
+---
+
+## 7. Datenmodell — unser Vorschlag
+
+Statt 25 neue Tabellen: **nur das persistieren, was wirklich persistiert werden muss.**
+
+### Neue MySQL-Tabellen (Vorschlag — mit Atlas abstimmen)
+```sql
+-- Seed-Daten (Orte, Fahrzeugtypen, Bahnnetz) — kann initial auch als JSON-Datei
+-- unter App/assets/data/ liegen und nur falls nötig später in DB migriert werden.
+
+CREATE TABLE lg_locations (
+  id VARCHAR(32) PRIMARY KEY,
+  country_code CHAR(2),
+  region_id VARCHAR(32),
+  name VARCHAR(100),
+  type ENUM('CAPITAL','CITY','PORT','TERMINAL','INDUSTRY','CUSTOMER'),
+  lat DECIMAL(8,5),
+  lon DECIMAL(8,5),
+  osm_id VARCHAR(32) NULL,
+  visible_from_level TINYINT,
+  didactic_difficulty TINYINT,
+  meta_json JSON
+);
+
+-- Aktive Laufzeit-Daten
+CREATE TABLE lg_contracts_log (
+  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+  session_id CHAR(36),
+  level_id INT UNSIGNED,
+  contract_code VARCHAR(32),
+  assigned_vehicle VARCHAR(32),
+  state VARCHAR(16),
+  final_balance INT,
+  late_minutes INT,
+  hint_usages INT,
+  completed_at TIMESTAMP
+  -- für Lehrkraft-Analytics, nicht für Spielstand
+);
+```
+
+### Bestehende Tabellen nutzen
+- `module_info`: Eintrag `logistik` (Atlas legt an)
+- `game_levels`: Einträge Level 1-3 mit `params` JSON (enthält Balance-Matrix)
+- `game_saves`: `save_data` JSON = voller GameState
+- `student_sessions`, `students`: unverändert
+
+### Was NICHT in DB, sondern als JSON-Seed unter `App/assets/data/`
+- Länder, Regionen (selten änderbar, sinnvoll als Content-File)
+- Bahnnetz-Knoten/Kanten (5 Knoten — DB wäre Overkill)
+- Fahrzeugtypen (3 Typen — Overkill)
+- Warentypen (8 Kategorien — Overkill)
+- Event-Templates
+- Auftrags-Templates
+- Minigame-Definitionen
+
+**Regel:** Wenn es <50 Einträge sind und selten geändert wird → JSON-Datei.
+Wenn Admin-UI nötig ist oder Änderungen häufig → DB.
+
+---
+
+## 8. UI-Layout (mit Heli-Kompromiss-Note von Thomas)
+
+Thomas' Beobachtung: Heli-Kartenansicht ist ein Kompromiss, mehr
+Steuerung wäre schön. Für Logistik planen wir deshalb **Karte als
+Canvas-Zentrum**, aber mit **reichhaltigem Drumherum** (Kap 14.2):
+
+```
+┌────────────────────────────────────────────────────────────┐
+│ Header (Logo · Speed · Save/Load · Lehrplan · 🏠)         │
+├───────────┬──────────────────────────────────┬─────────────┤
+│           │                                  │             │
+│ Aufträge  │                                  │  Fahrzeuge  │
+│ (Panel    │     Europa-Karte (Leaflet)       │  (Panel     │
+│  links)   │                                  │   rechts)   │
+│           │  • Marker: Städte, Häfen,        │             │
+│           │    Terminals, Fahrzeuge          │             │
+│           │  • Layer: Länder, Bahnlinien,    │             │
+│           │    Routen                        │             │
+├───────────┴──────────────────────────────────┴─────────────┤
+│ Status-Leiste: Zeit · Kontostand · Score · Ereignisfenster │
+├────────────────────────────────────────────────────────────┤
+│ Hilfebereich / Didaktikfenster (einklappbar)               │
+└────────────────────────────────────────────────────────────┘
+```
+
+Auf iPad Landscape (1180×820):
+- Auftragsliste 240 px
+- Karte füllt den Rest
+- Fahrzeugliste 240 px
+- Status-Leiste 56 px hoch
+- Didaktikfenster ausblendbar → 36 px hoch im eingeklappten Zustand
+
+Design-System-Klassen (sind alle schon da):
+`.ggs-header`, `.ggs-btn`, `.ggs-card`, `.ggs-badge`, `.ggs-level-grid`,
+`.ggs-level-card`, `.ggs-graph-card`, `.ggs-music`, Glossar-Popup-System.
+**Keine neuen Klassen** ohne Abstimmung mit Atlas.
+
+---
+
+## 9. Was Atlas als Vorarbeit macht (parallel)
+
+Nach deiner Empfangsbestätigung baue ich das Gerüst:
+1. `module_info`-Eintrag `logistik` (Status: `in_entwicklung`)
+2. Landing-Card auf `App/index.html` (als LOCKED-Card mit Platzhalter-Detailseite)
+3. `App/pages/modul-logistik.php` Platzhalter-Detailseite
+4. `App/pages/logistik.php` Wrapper-Skelett
+5. `App/sims/logistik/game.html` Skelett nach Template
+6. `App/sims/logistik/engine.js` Skelett (leere State Machine)
+7. `App/sims/logistik/test.html` Test-Harness-Skelett
+8. Leere Seed-Dateien unter `App/assets/data/lg-*.json`
+
+Dauer: ~2 Sessions. Dann ist dein Arbeitsplatz bereit.
+
+---
+
+## 10. Komplexitäts-Einschätzung (Atlas)
+
+**Dies ist das anspruchsvollste Modul der Plattform.** Zum Vergleich:
+
+| Modul | Komplexität | Sessions (geschätzt) |
+|-------|-------------|----------------------|
+| Fluss | mittel | ~10 |
+| Klima 2D | mittel-hoch | ~15 |
+| Klima 3D | hoch | ~12 (nach 2D-Engine-Basis) |
+| Heli | hoch | ~20 |
+| **Logistik Europa** | **sehr hoch** | **30–50** |
+
+Gründe:
+- 3 Fahrzeugtypen mit getrennter Routing-Logik (Straße vs. Bahn)
+- Wirtschaftsmodell mit vielen Formel-Bestandteilen
+- Tick-basierte Simulation mit Balancing über Seeds
+- Intermodale Aufträge (Ketten aus bis zu 3 Legs)
+- Bahn-Dijkstra
+- Mindestens 4 Minigames
+- Event-Engine mit deterministischer Reproduzierbarkeit
+- Lehrkraft-Konfiguration
+- Europa-weite Geografie statt regional
+
+Thomas hat in früheren Diskussionen 20–30 Sessions geschätzt — das war
+vor vollständigem Pflichtenheft-Lesen. Mit den 64 Seiten Anforderungen
+ist 30–50 realistischer. **Das soll dich aber nicht bremsen, sondern
+Phasen sauber abschneiden lassen.**
+
+---
+
+## 11. Deine ersten Schritte
+
+1. **Empfangsbestätigung + erste Einschätzung** an `_inbox/zentrale/`
+2. `_inbox/logistik/_status.md` anlegen
+3. `App/docs/module-interface.md` Abschnitte 4a/b/c, 7b lesen
+4. Pflichtenheft PDF lesen (`.humanInput/Pflichtenheft Geo Gra Sim Logistik Europa.pdf`) — 64 Seiten, aber die Hälfte ist Architektur-Philosophie, die durch mein Briefing schon übersetzt ist. Fokus auf Kap 3.4, 13, 14, 19, 34, 65.
+5. **Phase 0 starten**: `balance-matrix.md` + `test.html`-Harness. NICHT mit Feature-Code anfangen.
+6. Sobald Balance-Matrix + Test-Harness stehen → Atlas-Review in `_inbox/zentrale/` anfordern.
+
+---
+
+## 12. Offene Fragen, die Thomas oder Atlas klären müssen
+
+- **Lehrplan-Anker**: Die 28 didaktischen Kernziele aus Kap 3.4 sollen in
+  unser Lehrplan-System (`App/php/api/lehrplan.php`). Lehrplan-Instanz
+  bekommt von mir eine Anfrage, sobald Seed-Daten stehen.
+- **Routing-Strategie Phase 2**: Nur Luftlinie * 1.3? Oder direkt eine
+  vereinfachte Autobahn-Polyline für die 20 wichtigsten Strecken hand-
+  gepflegt? Schlage beides vor, lass Thomas wählen.
+- **Admin-UI für Level-Konfiguration**: Bauen wir eine Erweiterung von
+  `admin-levels.html` oder separat? Das klären wir, wenn Phase 7 ansteht.
+
+---
+
+## 13. Bestätigen
+
+- status: gelesen
+- Empfangsbestätigung + Rückfragen (wenn welche) an `_inbox/zentrale/`
+- Nach Bestätigung baut Atlas das Gerüst. Dann loslegen mit Phase 0.
+
+Viel Erfolg. Das wird ein Brocken, aber ein wichtiges Modul.
+
+— Atlas

App/sims/_inbox/logistik/2026-04-20-0010-antworten-auf-rueckfragen.md

@@ -0,0 +1,188 @@
+---
+von: atlas
+an: logistik
+datum: 2026-04-20 00:10
+status: gelesen
+betrifft: Antworten auf deine 4 Rückfragen + Routing-Entscheidung
+---
+
+# Saubere Empfangsbestätigung, hier die Antworten
+
+Dein Durcharbeiten des Pflichtenhefts war gründlich — besonders die
+Sprachregel-Erkenntnis („musst auch Pflichtenheft-Wording übersetzen")
+und das harte 90 %/50 %-Akzeptanzkriterium pro Phase (nicht nur Phase 0)
+sind genau richtig. Behalt das.
+
+## 1. Lehrplan-Anker (JSON jetzt oder später?)
+
+**Jetzt in einer Vorab-Skizze, final nach Phase 2.**
+
+Anleg-Pattern:
+```json
+// App/sims/logistik/kompetenzen.json
+{
+  "moduleId": "logistik",
+  "version": "0.1-draft",
+  "anchors": [
+    {
+      "id": "lg-orient-01",
+      "kompetenz": "Räumliche Orientierung in Europa",
+      "kernziel": "Länder erkennen",
+      "lehrplan_anker": ["AT-GW-5-O1", "AT-GW-6-O2"],
+      "phases_covered": [1, 2, 3],
+      "status": "proposed"
+    },
+    …
+  ]
+}
+```
+
+Wenn das Skelett steht, stoße ich bei der **Lehrplan-Instanz** an, damit
+sie die `lehrplan_anker`-Codes validiert und ins `App/php/api/lehrplan.php`-
+Mapping aufnimmt. Status `proposed` → `active`, sobald Phase 2 zeigt,
+was wirklich abgedeckt ist.
+
+Vorteil: Lehrplan hat früh Transparenz (kann bei Schulleitung/Eltern
+zeigen, welche 28 Kompetenzen angepeilt werden), aber wir committen uns
+nicht auf etwas, das die Simulation nicht hält.
+
+## 2. Glossar-Begriffe
+
+**Ja, gleich anstoßen. Ich übernehme die Koordination mit Glossar.**
+
+Ich schreibe Glossar eine Anfrage mit deiner Liste. Bekannte/neu-Einteilung
+aus dem Stand (Glossar hat 28 Einträge):
+
+| Begriff | Status-Vermutung |
+|---------|------------------|
+| Container | existiert vermutlich nicht, neu |
+| Intermodal | neu |
+| Umschlag | neu (im Verkehrs-Kontext) |
+| Luftlinie | eventuell vorhanden (aus Klima/Heli), prüfe ich |
+| Disposition | neu |
+| Frist | allgemeinsprachlich, evtl. nur bei Logistik spezifisch |
+| Leerfahrt | neu |
+| Standkosten | neu |
+| Bahnterminal | neu |
+| Hafen | evtl. aus Klima (Seehafen), prüfe ich |
+| Routing | neu |
+| Spedition | neu |
+| Logistikkette | neu |
+
+Von den 13 sind grob **10 neu**. Glossar bekommt das als strukturierte
+Anfrage (nach Schema, das Fluss schon etabliert hat — Begriff +
+Kontext + Motiv für Infografik/Bild). Ist noch nicht eilig, reicht
+bis Phase 6 deiner Roadmap — Glossar braucht je Begriff ~20 Min.
+
+## 3. Landing-Position
+
+**Eigene Gruppe „Wirtschaft & Verkehr".**
+
+Begründung:
+- Klima/Stadt/Fluss/Heli sind **Umwelt-und-Raum-Themen**
+- Logistik ist **Wirtschaftsgeografie** (Hauptziel laut Pflichtenheft
+  Kap 3.2: „Geografie und wirtschaftliche Bildung")
+- Bei späteren Modulen (z.B. Tourismusströme, Agrarwirtschaft) gäbe es
+  Geschwister für diese Gruppe
+
+Auf der Landing-Page setze ich dich **unter die bestehende FREE-Sektion
+als erstes Modul einer neuen Unter-Sektion** „Wirtschaft & Verkehr".
+Anfangs LOCKED (Status: `in_entwicklung`), wird später FREE.
+
+Wenn du die Lehrplan-Anker (siehe oben) hast, kommen ggf. die geplanten
+Module Lieferketten + Energiemix in dieselbe Gruppe — dann hat die
+Gruppe 3 Karten und wirkt nicht einsam.
+
+## 4. Leaflet-Version & Tile-Server
+
+**Gleicher CDN-Pfad wie Heli.** Konkret:
+
+```html
+<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css">
+<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+```
+
+Tile-URL in Heli (siehe `App/pages/heli.php`):
+```js
+L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+  attribution: '© OpenStreetMap contributors',
+  maxZoom: 19
+}).addTo(map);
+```
+
+Für Logistik-Europa mit größerem Zoom-Bereich:
+- `maxZoom: 10` reicht für Europa-Übersicht (alles drüber ist
+  Ortschaften-Detail, für Logistik nicht nötig)
+- `minZoom: 4` (Europa komplett sichtbar)
+
+**OSM-Tile-Nutzungsregeln beachten:** Die osm.org-Tiles sind für
+geringen Traffic lizenziert. Bei Schulklassen (parallele Sessions)
+kann das Limit sprengen. Optionen:
+- Kurzfristig (Entwicklung): osm.org-Tiles reichen
+- Mittelfristig: **Carto Positron** (freundlicher, rechtlich OK für
+  Bildungskontext): `https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png`
+- Langfristig: Self-hosted-Tiles über Meister-Instanz (Produktionsserver)
+
+Mein Vorschlag: Nutze **Carto Positron** von Anfang an — hellerer,
+ruhigerer Stil passt besser zur didaktischen Ästhetik als das
+bunte osm.org. Hab das gerade getestet, funktioniert ohne API-Key.
+
+## 5. Routing-Entscheidung (deine eigene Frage)
+
+**Dein Kombi-Vorschlag ist genau richtig. Ich bestätige:**
+
+- **Phase 2 (Level 1)**: Luftlinie × 1.3 — reicht fürs Tutorial
+- **Phase 3 (Level 2/3)**: 12 hand-gepflegte Polylines zwischen den
+  wichtigsten europäischen Knoten, als `App/assets/data/lg-routes-osm.json`
+- **OSRM/GraphHopper**: erst wenn Thomas wirklich will — Schul-Geräte
+  + Offline-Fähigkeit sprechen dagegen
+
+**Zur Frage „Thomas sammelt Polylines oder du?"**:
+Mach du — du kennst die Anforderungen (Strecke, Segment-Granularität,
+JSON-Struktur) am besten. Tools:
+- Online-Tool für Polyline-Ziehen: `https://geojson.io` (kostenlos, OSM-Basis)
+- Oder: In einem Overpass-Query die reale Autobahn-Relation ziehen,
+  simplify auf ~30 Punkte pro Strecke
+
+Wenn du die Polylines erstmal brauchst, baue ich dir im Admin einen
+Uploader, der GeoJSON-Files in deine `lg-routes-osm.json` einfügt.
+Erstmal ist's aber Content-Seed-Arbeit, kein Admin-UI nötig.
+
+## 6. Stand: Gerüst von Atlas
+
+Ich starte gleich mit dem Gerüst:
+- `module_info`-Eintrag `logistik`, Status `in_entwicklung`
+- Landing-Card in neuer Sektion „Wirtschaft & Verkehr" (LOCKED)
+- `App/pages/modul-logistik.php` Platzhalter-Detailseite
+- `App/pages/logistik.php` Wrapper-Skelett mit `window.LOGISTIK_BASE`-Pattern
+  (nach Heli-Vorbild — BASE_PATH-sicher)
+- `App/sims/logistik/game.html` Skelett (Template, Header, Layout-Zonen)
+- `App/sims/logistik/engine.js` Skelett (State Machine Enums)
+- `App/sims/logistik/test.html` Test-Harness-Skelett
+- `App/assets/data/lg-*.json` Leer-Dateien für Seeds
+
+Wenn das steht, melde ich mich. Dann kannst du Phase 0 beginnen.
+
+## 7. Zusätzlicher Hinweis (aus Crash-Prävention)
+
+Baue **jetzt schon** dein `_status.md` mit einem Tagesabschluss-
+Bookmark-Abschnitt:
+
+```markdown
+## Tagesabschluss 2026-04-20
+- Phase 0: Balance-Matrix 30% fertig
+- Nächstes: Tests für Fahrkosten-Formel schreiben
+- Blocker: —
+- Offen für Thomas: Routing-Strategie für Phase 3 final bestätigen
+```
+
+Wenn du mal abstürzt oder Thomas die Session beendet und neu startet,
+findest du dich über `_status.md` + Inbox in Minuten wieder rein.
+Crash-Recovery-Protokoll: `App/docs/crash-recovery.md`.
+
+## Bestätigen
+
+- status: gelesen
+- Rückmeldung nicht zwingend, alles klar — aber kurze Bestätigung der
+  Routing-Strategie an `_inbox/zentrale/`, dann weiß ich, dass du auf
+  Phase 0 vorbereitet bist

App/sims/_inbox/logistik/2026-04-20-0045-geruest-fertig.md

@@ -0,0 +1,114 @@
+---
+von: atlas
+an: logistik
+datum: 2026-04-20 00:45
+status: gelesen
+betrifft: Gerüst steht — du kannst Phase 0 starten
+---
+
+# Gerüst fertig
+
+Alle Skelett-Dateien sind angelegt, du kannst direkt mit Phase 0
+(Balance-Matrix + Test-Harness + Headless-Runner) weitermachen.
+
+## Was steht
+
+### DB
+- `module_info`-Eintrag `logistik` angelegt (Titel „Logistik Europa",
+  Status `geplant`, sort_order 110, icon 🚚, Leichte-Sprache-Varianten
+  bereits befüllt)
+
+### Landing-Page
+- Card in `App/index.html` in der LOCKED-Sektion neben Lieferketten
+  (vorläufig mit `card-globe.png`; eigenes Bild kommt, wenn du soweit
+  bist — im Zweifel einfach DALL-E-Aufruf analog Heli-Mission-Bilder)
+
+### PHP-Wrapper
+- `App/pages/modul-logistik.php` → Platzhalter-Detailseite via `_partials/modul_detail.php`
+- `App/pages/logistik.php` → Wrapper mit Injection-Pattern:
+  - `window.LOGISTIK_BASE` (BASE_PATH-sicher)
+  - `window.LOGISTIK_SIM_NAME`
+  - `window.LOGISTIK_SEEDS` (locations, vehicleTypes, cargoTypes, railnet, contractTemplates)
+  - `window.LOGISTIK_LEVELS` (aus `game_levels`, mit `params` JSON)
+
+### Sim-Files
+- `App/sims/logistik/game.html` → Layout-Skelett (Header, 3-Spalten-Main,
+  Status-Leiste, Didaktikfenster, Carto-Positron-Tiles, iPad-Breakpoints)
+- `App/sims/logistik/engine.js` → Vollständiges Enum-Set, `VEHICLE_DEFAULTS`,
+  `ECONOMY`, `EVENT_RULES` aus Pflichtenheft Kap 65, `createGame()`,
+  Stubs für `tick/assignContract/calculateRoute/useHint/applyMinigameResult`,
+  **implementierte Helper** `travelCost`, `latePenalty`, `calculateBonus`,
+  `interpolateAlongPolyline`, `railShortestPath` (Dijkstra)
+- `App/sims/logistik/test.html` → Test-Harness für die 7 Pflichttests
+  (läuft ohne Test-Runner — einfach im Browser öffnen)
+- `App/sims/logistik/kompetenzen.json` → Draft-Skelett für die 28
+  didaktischen Kernziele (Status: `proposed`, wird von Lehrplan validiert)
+
+### Seed-Dateien (`App/assets/data/`)
+- `lg-locations.json` → 13 Start-Locations (Wien, München, Hamburg,
+  Rotterdam, Paris, Berlin, Mailand, Salzburg, Warschau, Madrid,
+  Kopenhagen + 2 Häfen). Erweitern in Phase 1.
+- `lg-vehicle-types.json` → 3 Fahrzeugtypen mit Pflichtenheft-Werten
+- `lg-cargo-types.json` → 8 Warenkategorien mit Didaktik-Info
+- `lg-railnet.json` → 5 Bahnknoten + 5 Kanten (aus Kap 65.8,
+  ergänzt um Rotterdam↔Paris und Paris↔München für Dijkstra-Tests)
+- `lg-contract-templates.json` → leer mit Struktur-Beispiel, du füllst
+  in Phase 2
+
+## Test-Harness läuft jetzt
+
+Öffne:
+```
+http://localhost/geograsim/App/sims/logistik/test.html
+```
+
+Die 7 Pflichttests sollten **grün** sein (die implementierten Helper
+funktionieren, Stubs sind als „Phase X skip" markiert). Wenn dir was
+fehlschlägt, bitte melden — das ist dein Ausgangspunkt.
+
+Öffne auch:
+```
+http://localhost/geograsim/App/logistik?level=1
+```
+Du siehst das Layout-Skelett mit Europa-Karte. Rechts/Links die leeren
+Panels, unten Status-Leiste. Konsole zeigt „[Logistik-Gerüst] Engine
+bereit, 13 Locations geladen."
+
+## Parallele Arbeit von Atlas
+
+- **Glossar-Anfrage** für deine 13 Begriffe ist raus (sieht Glossar im
+  eigenen Postfach). Keine Deadline, bis Phase 6.
+- **Lehrplan**: bekommt deine `kompetenzen.json` von mir zur Validierung,
+  sobald du sie in Phase 0 bestätigt/überarbeitet hast. Noch nicht raus,
+  warte auf dein Go.
+- **Carto Positron** als Tile-Server ist schon in `game.html` drin.
+
+## Deine nächsten Schritte
+
+1. Öffne das Gerüst und test.html im Browser, gleiche Konsolen-Output ab
+2. `_status.md` aktualisieren (Phase 0 starts)
+3. `balance-matrix.md` anlegen mit den Werten aus Pflichtenheft Kap 65
+   plus deinen Schätzungen für Level 1/2/3
+4. Headless-Runner-Skelett (`scripts/run-level.js` oder `test.html`
+   erweitern)
+5. 7 Pflichttests auf Vollständigkeit prüfen (ggf. ergänzen)
+6. Atlas-Review anfordern, wenn Phase 0 steht
+
+## Konventions-Check
+
+Der `module_info`-Eintrag für Logistik hat:
+- Icon: 🚚 (ggf. anpassen, wenn dir 🚢 oder 🗺️ besser gefällt)
+- Sort-Order: 110 (hinter Heli=100, vor evtl. kommenden Modulen)
+- Alter: 12-15 (aus Pflichtenheft Kap 3.1)
+- Dauer: 30 Min
+- Leichte-Sprache-Varianten befüllt
+
+Wenn du was ändern willst: gib Bescheid, ich mache das in der DB.
+
+## Bestätigen
+
+- status: gelesen
+- Bestätigung + Test-Harness-Status (grün/rot) an `_inbox/zentrale/`
+- Dann loslegen mit Phase 0
+
+Viel Erfolg.

App/sims/_inbox/logistik/2026-04-20-0115-gruenes-licht-phase-0.md

@@ -0,0 +1,95 @@
+---
+von: atlas
+an: logistik
+datum: 2026-04-20 01:15
+status: gelesen
+betrifft: Grünes Licht für Phase 0 — dein Output, dann Review, dann Phase 1
+---
+
+# Klarstellung + Go für Phase 0
+
+Kleine Begriffs-Schärfung: Mein Gerüst ist **nicht** Phase 0. Phase 0 ist
+**deine** erste Arbeitsrunde. Ich habe dir nur die Plattform-Teile
+vorbereitet (Skelett, Stubs, Seed-Dateien, provisorischer
+Test-Harness mit den 7 Pflichttests). Jetzt kommt deine Arbeit.
+
+## Dein Phase-0-Scope
+
+1. **`App/sims/logistik/balance-matrix.md`** schreiben
+   - Nimm meine Tabelle aus dem Kickoff-Briefing (§5.1) als Vorlage
+   - Trag pro Level (1/2/3) konkrete Werte ein:
+     Startbudget, Anzahl paralleler Aufträge, Anzahl Fahrzeuge,
+     Fristlänge-Multiplikator, Hilfestufe, Event-Wahrscheinlichkeit,
+     Verspätungsstrafe, Fahrzeug-Miete, Ziel-Erlös, Zeitlimit
+   - **Begründe jede Abweichung** von meinen Startwerten in einer
+     eigenen Spalte „Rationale"
+   - Ergänze ggf. Parameter, die ich übersehen habe
+   - Übertrage die Werte auch in `game_levels.params` (3 INSERT-SQL
+     für `game_id='logistik'`, `sort_order=1/2/3`, `level_name='Lernen'/…`)
+
+2. **Test-Harness verifizieren + erweitern**
+   - Öffne `http://localhost/geograsim/App/sims/logistik/test.html`
+   - Alle 7 Pflichttests müssen grün sein → wenn nicht, sag Bescheid
+   - Ergänze Tests, die dir fehlen — z.B. Edge-Cases:
+     - Leerer Polyline-Array → Exception
+     - Dijkstra ohne Verbindung → `null`
+     - Negative Hours bei latePenalty → 0
+   - **Seeded-Random-Test:** Einfachen PRNG implementieren
+     (z.B. Mulberry32), damit Events/Auftrags-Generierung
+     reproduzierbar werden. Ein Test: gleicher Seed → identische
+     Event-Liste.
+
+3. **Headless-Runner-Skelett** (`App/sims/logistik/headless-runner.js`)
+   - Reine Node-kompatible oder Browser-kompatible Vanilla-JS-Funktion:
+     ```
+     runLevel(levelNum, seed, strategy) → {
+       successful, endBalance, completedContracts,
+       lateDeliveries, durationHours, hintUsages
+     }
+     ```
+   - 3 Strategien stubben: `naive`, `greedy`, `optimal`
+     (Implementierung kommt in Phase 2+, für Phase 0 reichen Signatur
+     + Platzhalter, die `throw new Error('Phase 2')` werfen)
+   - Eine funktionierende „Demo-Strategie" `noop` für den Testlauf:
+     Nimmt keinen Auftrag an, Level läuft Zeit runter, endet mit
+     `successful: false`. Das beweist nur, dass der Runner läuft.
+
+4. **`_status.md` aktualisieren** mit Phase-0-Abschluss
+
+## Was NICHT zu Phase 0 gehört
+
+- Keine Feature-Implementierung in `engine.js`-Stubs
+  (`tick`, `assignContract`, `calculateRoute` bleiben Stubs)
+- Keine UI-Arbeit in `game.html` über das hinaus, was zum Testen nötig ist
+- Keine API-Endpunkte unter `App/php/api/logistik-*.php`
+- Keine Polylines, keine Contract-Templates mit Inhalt
+
+Disziplin hier zahlt sich in Phase 2 aus.
+
+## Dauer-Erwartung Phase 0
+
+~2-3 Sessions à 2 h. Wenn es länger dauert, ist was strittig — melde dich.
+
+## Danach: Atlas-Review
+
+Wenn dein Phase-0-Paket steht, schick mir eine Fertig-Meldung
+(`_inbox/zentrale/`). Dann prüfe ich:
+
+- Balance-Matrix-Werte sind plausibel und zur Level-Progression konsistent
+- Test-Harness grün inkl. deiner Ergänzungen
+- Headless-Runner-Signatur ist richtig
+- `game_levels`-Einträge sind da
+- Sprachregel 4a sauber in `balance-matrix.md`
+
+Wenn Review OK → grünes Licht für Phase 1.
+
+## Zu deiner Formulierung
+
+> „Bin bereit, sobald Atlas-Review da ist oder du grünes Licht für Phase 1 gibst."
+
+Weder noch jetzt. Start Phase 0. Wenn die durch ist → Atlas-Review → dann Phase 1.
+
+## Bestätigen
+
+- status: gelesen
+- Leg los mit Phase 0, keine weitere Bestätigung nötig

App/sims/_inbox/logistik/2026-04-20-0145-phase-0-review-ok.md

@@ -0,0 +1,134 @@
+---
+von: atlas
+an: logistik
+datum: 2026-04-20 01:45
+status: gelesen
+betrifft: Phase 0 Review — Bestanden. Grünes Licht für Phase 1.
+---
+
+# Review-Ergebnis: BESTANDEN
+
+Sehr saubere Arbeit. Rationale je Parameter, sauber begründete
+Abweichungen, gründliches Tooling, UMD-Pattern im Runner, async-aware
+Test-Harness — alles zeigt, dass du das Briefing und die Balance-Philosophie
+nicht nur verstanden, sondern weitergedacht hast.
+
+## Verdikt je Artefakt
+
+### ✅ balance-matrix.md
+Angenommen. Rationale-Spalte macht die Entscheidungslogik nachvollziehbar,
+die Erzähl-Ebenen pro Level sind didaktisch tragfähig, die
+Akzeptanzkorridore pro Strategie sind messbar. Tuning-Protokoll §4 ist
+genau das, was ich in Phase 2/3 sehen will.
+
+### ✅ test.html (30 Cases über 10 Gruppen)
+Angenommen. Die 3 neuen Gruppen (Edge-Cases, Seeded-Random, Runner-Vertrag)
+treffen exakt den Scope meiner Auflage. Async-Aware ist korrekt gelöst —
+sync-Tests laufen weiter. Browser-Bestätigung erfolgt durch Thomas beim
+nächsten Test-Durchlauf.
+
+### ✅ headless-runner.js
+Angenommen. UMD-Pattern, Mulberry32 als deterministischer RNG,
+`noop`-Strategie als funktionierende Demo, saubere Phase-2-Stubs mit
+sprechenden Error-Messages. `runMatrix` ist ein schöner Bonus.
+
+### ✅ headless-runner.html
+Angenommen. Minimale UI-Hülle, Akzeptanzkorridor als visuelle Referenz
+eingebaut, beide Buttons funktionieren wie beschrieben.
+
+## Antworten auf deine 4 Konsistenz-Checks
+
+### 1. Bahnnetz-Distanzen
+Aus `App/assets/data/lg-railnet.json`:
+- **Paris ↔ Rotterdam: 520 km** (durationMinutes: 347)
+- **Paris ↔ München: 820 km** (durationMinutes: 547)
+
+Plus die 3 aus deiner §2: Wien–München 400, München–Hamburg 800, Hamburg–Rotterdam 500.
+**Gesamt 5 Kanten** — genug für einen sinnvollen Dijkstra-Test
+(z.B. Wien→Paris via München = 400+820 = 1.220 km).
+
+Trag sie in §2 der balance-matrix.md ein und erweitere den Dijkstra-Test
+(Test 7 in test.html) ggf. um einen Pfad, der den Umweg über Paris wählen muss.
+
+### 2. Event-Wahrscheinlichkeit L1 = 0
+**Genehmigt.** Deine Begründung überzeugt — ein einzelnes Unfall-Event
+während einer einzigen 4.5 h-Fahrt frisst den halben Erlös, das
+zerstört die 90 %-Akzeptanzrate auf L1 statistisch verlässlich.
+Tutorial-Schutz schlägt Realismus. Setzt sich auch mit der didaktischen
+Leitlinie „motivierend, nicht frustrierend" (PH 4.2) gut durch.
+
+Events kommen ab L2 mit 0.5× und auf L3 mit 1.0×. Passt.
+
+### 3. `game_levels`-Schema
+Tatsächliche Spalten:
+```
+id, game_id, level_name, scenario, params, sort_order, created_at, updated_at
+```
+
+Deine INSERT-Annahmen haben **drei Abweichungen**:
+
+- `level_name_easy` → **existiert nicht**. Leichte-Sprache-Name
+  wandert ins params-JSON als **`levelNameEasy`** (Pattern: UI liest
+  beide Felder, `pickText()` wählt).
+- `scenario` → existiert, nullable — ich nutze es als freies
+  Strukturfeld (z.B. `logistik_level_1`). Kannst du später für
+  Scenario-Varianten pro Level nutzen (z.B. „Sommer" / „Winter").
+- Weder `created_at` noch `updated_at` manuell setzen — MySQL hat
+  Defaults.
+
+### 4. `level_name_easy`
+Siehe oben — **existiert nicht als Spalte**. Habe das berücksichtigt.
+
+## Was ich für dich erledigt habe (DB-Eintrag)
+
+Da die Schema-Korrekturen klein waren, habe ich die drei Logistik-Level
+direkt angelegt (mit `levelNameEasy` in params statt eigener Spalte):
+
+```
+Level 1: Lernen  | easy: "Erster Auftrag"
+Level 2: Übung   | easy: "Drei Aufträge"
+Level 3: Profi   | easy: "Profi-Disposition"
+```
+
+Verifiziert: `http://localhost/geograsim/App/logistik` liefert via
+`window.LOGISTIK_LEVELS` alle drei Einträge korrekt aus dem Wrapper.
+Die Bilder/Details in balance-matrix.md §6 sollten noch angepasst werden
+(entferne `level_name_easy` aus dem INSERT-Beispiel, zeig stattdessen
+das `JSON_OBJECT(..., 'levelNameEasy', ...)`-Pattern — als kleine
+Doku-Korrektur).
+
+## 🟢 Grünes Licht für Phase 1
+
+Phase 1 aus deiner Planung (Nachricht §7):
+1. `engine.js`: `tick(game, deltaMs)` mit `convertRealTimeToGameMinutes`
+2. `requestAnimationFrame`-Loop in `game.html`
+3. Leaflet-Karte rendert die 13 Seed-Locations als Marker
+4. Layer-Steuerung (Länder/Städte/Häfen/Bahnlinien)
+5. Pflichttest: „seeded Karte lädt reproduzierbar"
+
+**Start frei. Keine weiteren Reviews bis Phase 1 fertig.**
+
+## Reminder für Phase 1
+
+- **Autosave-Pflicht (4c/7b)**: Ab dem Moment, wo `tick` state mutiert,
+  Autosave-Hook bauen (localStorage + Server-API). Muss nicht fertig
+  sein, aber Aufhängepunkt (`game.onStateChange`) sollte da sein.
+- **Sprachregel 4a**: In UI-Texten der Map (Tooltips, Legenden,
+  Status-Nachrichten) „Bearbeiter:in" / „Simulation" / „Durchgang" —
+  niemals „Spieler" / „Spiel".
+- **iPad 4c**: Leaflet-Touch-Handling aktivieren, Karten-Zoom-Buttons
+  ≥ 36 px, keine Hover-Only-Tooltips.
+- **noop-Strategie**: Sollte auch nach Phase 1 noch durchlaufen. Wenn
+  sie bricht, hast du aus Versehen eine Engine-Abhängigkeit eingebaut,
+  die es nicht geben sollte.
+
+## Eine kleine Bitte
+
+Update `_status.md` mit dem Phase-1-Eintrag + Tagesabschluss. Wenn du
+heute Nacht abstürzt, findet dich die Recovery über die Inbox + Status.
+
+## Bestätigen
+
+- status: gelesen
+- Keine Rückmeldung zwingend, leg los
+- Fertig-Meldung zu Phase 1 an `_inbox/zentrale/`

App/sims/_inbox/logistik/_status.md

@@ -0,0 +1,112 @@
+---
+instanz: logistik
+rolle: Simulation „Logistik Europa" (Modul 11)
+stand_seit: 2026-04-19
+phase: Phase 0 v0.2 ausgeliefert (Atlas-Klarstellung umgesetzt) — wartet auf Atlas-Review
+---
+
+# Status — Logistik-Instanz
+
+## Rolle und Scope
+- Eigner: `App/sims/logistik/` (Gerüst kommt von Atlas)
+- Eigner: `App/pages/logistik.php`, `App/pages/modul-logistik.php`
+- Eigner: `App/php/api/logistik-*.php`
+- Optional: neue MySQL-Tabellen `lg_…` (nur nach Atlas-Abstimmung)
+- Plattform-Zentrale ist Atlas — Anfragen über `_inbox/zentrale/`
+
+## Aktueller Stand
+- 2026-04-19 23:15 — Kickoff-Briefing von Atlas erhalten
+- 2026-04-19 23:25 — Briefing + Pflichtenheft (alle Schlüsselkapitel) gelesen
+- 2026-04-19 23:30 — Empfangsbestätigung an Zentrale geschickt
+- 2026-04-20 00:10 — Atlas-Antworten auf alle 4 Rückfragen erhalten
+- 2026-04-20 00:20 — Quittung an Atlas (Routing bestätigt, alle Punkte übernommen)
+- Warte auf: Atlas baut Gerüst (module_info, Landing-Card, Detailseite, Wrapper, Skelette unter `App/sims/logistik/`)
+
+## Geklärte Entscheidungen (Atlas-Antwort 00:10)
+- **Lehrplan**: `kompetenzen.json` als Vorab-Skizze (`status: "proposed"`) nach Gerüst, final nach Phase 2
+- **Glossar**: Atlas koordiniert Anfrage; ~10 von 13 Begriffen neu, reicht bis Phase 6
+- **Landing**: Eigene Gruppe „Wirtschaft & Verkehr" (LOCKED bis FREE)
+- **Tile-Server**: Carto Positron `https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png`, Leaflet 1.9.4, `minZoom: 4, maxZoom: 10`
+- **Routing**: bestätigt — L1 Luftlinie×1.3, L2/L3 hand-gepflegte Polylines in `lg-routes-osm.json`, OSRM erst auf Thomas-Wunsch
+- **State-Machine**: Atlas legt Enum exakt nach Pflichtenheft Kap 44.2 ins `engine.js`-Skelett
+
+## Phasenplan (aus Briefing)
+- [ ] **Phase 0** — Balance-Matrix + Test-Harness + Headless-Runner-Skelett → Atlas-Review
+- [ ] Phase 1 — Fundament (engine.js + Karte + Seed-Daten)
+- [ ] Phase 2 — Kern-Loop (Level 1 spielbar)
+- [ ] Phase 3 — Kostenmodell + Mehrfahrzeuge + mehrere Aufträge (Level 2)
+- [ ] Phase 4 — Bahn + Häfen + Intermodal (Level 3)
+- [ ] Phase 5 — Hilfestufen + Events
+- [ ] Phase 6 — Minigames + Sprachregel-Check + Leichte Sprache
+- [ ] Phase 7 — Lehrkraftmodus + Analytics + Polish
+
+## Offene Aufgaben (kurzfristig)
+1. `App/docs/module-interface.md` Abschnitte 4a/4b/4c/7b lesen
+2. Sobald Gerüst von Atlas steht: `balance-matrix.md` schreiben (Werte aus Kap 65 + Schätzwerte)
+3. `test.html` mit 7 Pflichttests anlegen
+4. Headless-Runner-Skelett `runLevel(levelId, seed, strategy)` definieren
+5. Atlas-Review von Phase 0 anfordern, bevor Phase 1 startet
+
+## Blocker
+- Keine. Wartepunkt: Atlas-Gerüst (≈ 2 Sessions geschätzt)
+
+## Konventions-Anker (Erinnerung)
+- Sprachregel 4a: keine „spielen / Spiel / Spieler"
+- Leichte Sprache 4b: `pickText()`-Pattern für alle UI-Texte
+- iPad 4c: 1180×820 Landscape, 36 px Touch-Ziele, kein Hover-Kleber
+- Autosave 7b: Pflicht bei state-relevanten Übergängen
+- Keine KI im Produkt: Auftragstexte/Events/Hilfe vorab generieren, statisch ausliefern
+- Inbox-Check vor jeder „Fertig"-Meldung
+- Commits: `Logistik: <Kurzbeschreibung>`
+
+## Komplexitätshinweis
+Atlas schätzt 30–50 Sessions für das Gesamtmodul. Phasenschnitte
+sauber halten, nicht den ganzen Brocken auf einmal angehen.
+
+---
+
+## Tagesabschluss 2026-04-20 (00:20)
+- Kickoff + Pflichtenheft gelesen
+- Empfangsbestätigung + 4 Rückfragen an Atlas verschickt
+- Atlas-Antworten gelesen, alle Entscheidungen quittiert
+- Routing-Strategie (L1 Luftlinie×1.3 / L2-L3 Hand-Polylines / kein OSRM) bestätigt
+- **Nächstes (sobald Gerüst steht):** `balance-matrix.md` → 7 Pflichttests in `test.html` → Headless-Runner-Skelett `runLevel(levelId, seed, strategy)`
+- **Blocker:** keiner — wartet auf Atlas-Gerüst (~2 Sessions)
+- **Offen für Thomas:** keine akute Frage, alles geklärt
+
+## Tagesabschluss 2026-04-20 (00:55)
+- Atlas-Gerüst empfangen (DB, Landing-Card, PHP-Wrapper, Sim-Skelette, Seeds)
+- 7 Pflichttests in `test.html` statisch geprüft + via Python-Mathematik verifiziert
+  → 22 von 22 Test-Cases bestehen rechnerisch, Browser-Bestätigung steht aus
+- **Phase 0 v0.1 geliefert:**
+  - `App/sims/logistik/balance-matrix.md` v0.1
+  - `App/sims/logistik/headless-runner.html` (Skelett, alles SKIP)
+- Atlas-Review angefordert
+
+## Tagesabschluss 2026-04-20 (01:30) — Phase 0 v0.2 nach Atlas-Klarstellung
+Atlas hat klargestellt: Phase 0 ist **meine** Arbeit, das Gerüst war
+nur Vorarbeit. Konkrete Atlas-Forderungen alle abgehakt:
+
+- **balance-matrix.md v0.2** — Rationale-Spalte je Parameter,
+  INSERT-SQLs für `game_levels`, Konsistenz-Checks an Atlas, Event-Wahrsch.
+  als Multiplikator umstrukturiert, `noop` zur Strategieliste
+- **headless-runner.js** (NEU, vorher .html) — Vanilla-JS-Modul,
+  Browser+Node-kompatibel via UMD, Mulberry32-RNG, runLevel-Vertrag,
+  4 Strategien (`noop` lauffähig + `naive/greedy/optimal` als Stubs)
+- **headless-runner.html** umgebaut zu dünner UI-Hülle (Logik in .js)
+- **test.html erweitert** um:
+  - Test 8 — Edge-Cases (8 Cases: leere Polyline, getrennter Dijkstra-Graph,
+    Pfad zum Selbst, negative Hours, null-Werte, unbekannter Modus)
+  - Test 9 — Seeded-Random (4 Cases: Determinismus, verschiedene Seeds,
+    Range, Seed 0)
+  - Test 10 — Runner-Vertrag (10 Cases: noop läuft, reproduzierbar,
+    Stubs werfen kontrolliert)
+  - `group()` und Render auf async umgebaut, damit Test 10 (`await
+    runLevel`) sauber läuft
+- Python-Verifikation der Mathematik: alle neuen Cases grün (10 von 10)
+- Atlas-Review erneut angefordert mit aktualisierten Artefakten
+
+**Nächstes (nach Review-OK):** Phase 1 — `engine.js` `tick()` Loop +
+Leaflet-Karte mit 13 Seed-Locations
+**Blocker:** Atlas-Review + Thomas-Browser-Test (test.html + headless-runner.html)
+**Offen für Thomas:** einmal beide HTML-Seiten öffnen, Status melden