rinkplanner/docs/isu-rules-structure.md
torsten 31d4e70ba1 feat: Features pro Fuß und Variationen je Kategorie begrenzen
Schritt 7 der Mehrsaison-Reihe: Die Level-Features folgen jetzt den drei
Zählregeln aus ISU 2788.

- "In any spin with change of foot the maximum number of features attained
  on one foot is two (2)." Level-Berechnung deckelt pro Fuß; der Validator
  meldet zu viele Features auf einem Fuß und fehlende Fußangaben.
- "In any spin only two (2) difficult variations are counted." Die Gruppe
  difficult_variation hat einen Deckel in den Daten (types.spin.groups).
- "Any category of difficult spin variation in a basic position counts only
  once per program." Die Variation ist in fünf Kategorien aufgeteilt (Sitz,
  Camel, Layback, Upright, Sonstige); damit greift einmal-pro-Programm ohne
  Sonderlogik.

Daten: `per_foot` je Feature, `max_features_per_foot` je Elementtyp,
`change_of_foot` im Katalog (sechs Pirouetten mit Fußwechsel; CSp ist die
Camel-Pirouette, nicht Change foot). Schema 9 speichert den Fuß als
`element_feature_feet` (Code → L/R).

Oberfläche: Die Fußauswahl erscheint nur, wenn sie das Ergebnis ändern kann –
bei einer Fußwechsel-Pirouette mit mehr als zwei fußbezogenen Features.
Angaben zu Level und Ausführung bleiben Selbsteinschätzung; das entscheidet
weiterhin das technische Panel.
2026-11-13 11:53:42 +01:00

538 lines
24 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# ISU-Regelwerk – Struktur, Pflege und Saisonwechsel
Stand: 2026-11-13
Status: **umgesetzt.** Alle sieben Schritte der Umsetzungsreihenfolge stehen:
Saisonordner, Manifest, Policies, Invariantenkatalog A–F, Saison an der Kür,
Validator pro Regelpaket, Oberfläche, Export, Saison-Upgrade-Prüfung und die
Feature-Grenzen. Offen ist nur eine PDF-Ausgabe des Saisonvergleichs.
## Zweck
Zwei Anforderungen bestimmen alles Weitere:
1. **Pflege über Jahre:** Ein Saisonwechsel soll Datenarbeit sein, keine
Codearbeit. Wenn eine neue Saison GDScript berührt, ist die Struktur nicht
fertig.
2. **Alte Küren bleiben gültig:** Eine Kür wird **immer** gegen das Regelwerk
der Saison geprüft, in der sie gelaufen ist – nicht gegen das der App.
## Grundsätze
1. **Daten schlagen Code.** Alles, was sich jährlich ändert, ist JSON. Code
ändert sich nur bei einer strukturellen ISU-Reform, dann mit
`schema_version`.
2. **`kind` statt Dateiname.** Der Code fragt nach `sov`, `levels`, `adult`.
Dateinamen stehen ausschließlich im Manifest.
3. **Die Saison hängt an der Kür, nicht am Build.** Es gibt keine
„aktive Saison" als Konstante, sondern eine Auflösung pro Kür.
4. **Fehlt eine Policy, gilt sie nicht.** Saisonabhängige Prüfungen haben
keinen stillen Default im Code; sonst erben alte Saisons neue Regeln.
5. **Codes sind Verträge.** `element_code` und Feature-Codes werden in
Kürdateien gespeichert und nie umbenannt. Nur `name` und `description`
dürfen sich ändern.
6. **Kein Saisonordner wird gelöscht.** Ein Regelpaket kostet ~15 KB pro Jahr.
Git-Historie ersetzt keine ladbaren Daten.
7. **Prüfen ist nicht Umstellen.** Eine Kür wechselt die Saison nur auf
ausdrückliche Bestätigung; Prüfberichte ändern nie etwas.
8. **Keine Regel-Bearbeitung in der App.** Regeln liegen im Repo, versioniert
und im Diff reviewbar. Ein Editor wäre eine zweite Wahrheit.
## Verhältnis zu den anderen Dokumenten
| Dokument | Zielgruppe | Inhalt |
| :--- | :--- | :--- |
| `docs/isu-rules.md` | Anwender | Was in dieser Saison gilt (Katalog, Level, Adult) |
| `docs/isu-rules-structure.md` | Pflege | Wie die Daten aufgebaut sind und wie man sie fortschreibt |
| `docs/manual.md` | Anwender | Bedienung der App |
Die Anwender-Doku wird künftig aus den Daten erzeugt (Kategorie-Tabelle,
Elementzahlen), damit sie nicht driften kann. Bis dahin bleibt sie von Hand
gepflegt.
## Ordnerstruktur
```
rinkplanner/src/core/rules/
├── data/
│ ├── 2025-26/
│ │ ├── manifest.json
│ │ ├── sov.json
│ │ ├── levels.json
│ │ ├── adult.json
│ │ └── notes.md
│ └── 2026-27/
│ ├── manifest.json
│ ├── sov.json
│ ├── levels.json
│ ├── adult.json
│ └── notes.md
├── element_catalog.gd
├── element_level_rules.gd
└── adult_category_rules.gd
```
- Der Ordnername ist die Saison mit `-` statt `/`: `2026-27` ↔ `2026/27`.
Abweichung ist ein Fehler (A1).
- `notes.md` ist Pflicht und beschreibt, was sich gegenüber der Vorsaison
geändert hat (siehe E1–E3).
- Die bisherigen Dateien `isu_sov_2026_27.json` usw. entfallen nach der
Migration. Es gibt genau einen Satz Daten pro Saison; die Historie liegt in
Git.
## Manifest
Vollständige Saison:
```json
{
"schema_version": 1,
"season": "2026/27",
"label": "Saison 2026/27",
"valid_from": "2026-07-01",
"status": "complete",
"replaces": "2025/26",
"documents": {
"sov": {
"file": "sov.json",
"source": "ISU Communication No. 2786, Scale of Values …",
"valid_from": "2026-07-01"
},
"levels": {
"file": "levels.json",
"source": "ISU Communication No. 2788, Levels of Difficulty …",
"valid_from": "2026-06-01"
},
"adult": {
"file": "adult.json",
"source": "IAFSC Technical Announcement 2026/27",
"valid_from": "2026-07-01"
}
}
}
```
Unvollständige Saison (die Papiere kommen zeitversetzt):
```json
{
"schema_version": 1,
"season": "2027/28",
"valid_from": "2027-07-01",
"status": "partial",
"replaces": "2026/27",
"documents": {
"sov": { "file": "sov.json", "source": "ISU Communication No. 28xx …" },
"levels": { "inherit_from": "2026-27" },
"adult": { "inherit_from": "2026-27" }
}
}
```
Regeln:
- Ein Dokument-Eintrag hat **genau eines** von `file`, `inherit_from` oder
`status: missing` (A4).
- `status: complete` verbietet `inherit_from` (A6). Ein einzelnes fehlendes
Dokument macht die Saison **nicht** unvollständig: `complete` heißt, dass
Katalog und Level-Regeln als Datei vorliegen. Ein nicht erfasstes Dokument
steht auf `status: missing` und wird am Dokument gemeldet, nicht durch einen
halben Saisonstatus.
- `status: partial` heißt: Katalog oder Level-Regeln liegen nur geerbt vor.
Nur solche Saisons aktivieren sich nicht von selbst.
- Geerbte Dokumente bleiben im Bericht sichtbar: „Level-Regeln noch aus
2026/27 (Communication für 2027/28 fehlt)".
- `valid_from` der Teildateien darf sich unterscheiden – SoV und Levels werden
erfahrungsgemäß zu verschiedenen Terminen veröffentlicht. Sie müssen nur im
selben Saisonfenster liegen (A8).
### Korrekturen innerhalb einer Saison
Die ISU korrigiert gelegentlich mitten in der Saison. **Entschieden:** Die
Saison wird mutiert, es gibt keine Revisionen.
- Die betroffene Datei wird korrigiert, `valid_from` bleibt.
- `notes.md` bekommt eine Zeile: Datum, Communication, Änderung.
- Folge: Alle Küren dieser Saison werden ab sofort nach der korrigierten
Fassung geprüft, auch rückwirkend.
Das ist für ein Planungs- und Trainingswerkzeug richtig: Es gibt keine
amtliche Punktzahl, die rekonstruiert werden müsste. Zwei Revisionen in der
Oberfläche wären für einen Trainer nur verwirrend. Die Rückwirkung ist der
Preis und steht so in `notes.md`.
## Saisonauflösung
**Voreinstellung für neue Küren:** die Saison mit dem größten `valid_from`
≤ heute, die `status: complete` hat. Eine ausgelieferte Folgesaison schaltet
sich damit am 1. Juli von selbst scharf – ein Pflegeschritt weniger.
- Eine `partial`-Saison aktiviert sich **nie** von selbst.
- Ein Entwickler-Schalter muss eine Saison erzwingen können (Saisontest).
**Für eine bestehende Kür gilt immer die in der Datei gespeicherte Saison.**
Daraus folgen drei Zustände:
| Zustand | Beispiel | Verhalten |
| :--- | :--- | :--- |
| Saison mit Regeln | `2026/27` | vollständig prüfen; Inspector, Kategorie und Picker aus dieser Saison |
| Saison ohne Regeln | `2027/28` im Sommer geplant | zeichnen und speichern; Prüfung meldet „Regeln für 2027/28 liegen noch nicht vor" |
| Saison nicht festgelegt | Altdatei ohne Feld | Statusleiste zeigt „nicht festgelegt"; der Tooltip nennt die zum Dateidatum passende Saison. Geprüft wird erst nach der Auswahl |
Zwei Randfälle, die ausdrücklich so behandelt werden:
- **Kür neuer als die App:** Geometrie, Labels und Playback funktionieren;
Bearbeiten und Prüfen werden mit klarer Meldung verweigert. Nicht
„irgendwie gegen die neueste bekannte Saison prüfen" – das wäre eine stille
Falschaussage.
- **Kür ohne Saison wird nie stillschweigend zugeordnet.** Die Annahme der
aktuellen Saison würde eine Regelkonformität behaupten, die nicht geprüft
ist.
## Policies: deklarierte Prüfungen
Das ist der Kern der Mehrsaison-Fähigkeit. „Das damalige Regelwerk" steckt zu
etwa 95 % in den Daten und zu 5 % im Validator-Code. Daten lassen sich
einfrieren, Code nicht – er wird mit jeder App-Version besser. Deshalb müssen
saisonabhängige Prüfungen **von den Daten deklariert** werden.
```json
"policies": {
"axel_required_in_sequence": true
}
```
Die Policies stehen im **Manifest** der Saison, nicht in den Teildateien: Sie
betreffen die Programmprüfung als Ganzes, nicht ein einzelnes Dokument.
Regeln, die zu einem Elementtyp gehören (Schwellen, Gruppen, Fuß-Deckel),
stehen dagegen in `levels.json` – dort, wo auch die Features liegen.
Harte Semantik: **Fehlt ein Schlüssel, existiert die Regel in dieser Saison
nicht.** Kein Default, kein „im Zweifel an" (F1). Werte, die es nicht gibt,
werden daher weggelassen statt auf `null` gesetzt. Sonst erbt `2025/26`
automatisch jede Regel, die später erfunden wird, und die Mehrsaison-Fähigkeit
ist wertlos.
### Einordnung der heutigen Prüfungen
| Prüfung | Art | Ort |
| :--- | :--- | :--- |
| Kürzel im Katalog | strukturell, zeitlos | Code |
| Elementtyp passt | strukturell, zeitlos | Code |
| Level existiert / Sprung-Level 0 | strukturell | Code, Werte aus Daten |
| Level aus Features berechnen | Logik | Code |
| Feste Level (ChSq/ChSp) | Daten | `fixed_levels` |
| Pflichtfeatures | Daten | `required_features` |
| Max. Features pro Element | Daten | `max_per_element` |
| Einmal pro Programm | Daten | `once_per_program` |
| **Axel-Pflicht in Sprungfolge** | **Policy** | `policies.axel_required_in_sequence` |
| **Max. zwei Variationen pro Pirouette** | Daten (Gruppe) | `types.spin.groups` |
| **Max. zwei Features pro Fuß** | Daten (Typ) | `types.spin.max_features_per_foot` |
| **Feature-Positionsregeln** | Code + Daten | Variationen sind nach Grundposition getrennt |
| Adult-Grenzen | Daten | `adult.json` |
Die Axel-Pflicht steht heute im Code und gilt damit rückwirkend für jede
2025/26-Kür. Sie wandert bei der Migration in die Daten. Dasselbe gilt für
„max. zwei Features pro Fuß": Wenn sie als GDScript-Bedingung entsteht, ist
der nächste Saisonwechsel wieder Codearbeit.
**Strukturell zeitlos** bleibt alles, was für jede denkbare Saison gilt:
Kürzel muss existieren, Typ muss passen, Level muss im Datenbestand vorhanden
sein, das Level aus Features muss zum gespeicherten Level passen.
## Invarianten
Geprüft von `tools/check_rules.sh` (`RulesAudit`, eigenständig lauffähig, von
`./tools/test.sh` mit aufgerufen). **Fehler** blockiert, **Warnung** wird
gemeldet und ist durchlassbar.
Die Gruppen A–F sind implementiert; Ausnahmen sind bei der jeweiligen Zeile
vermerkt.
### A. Manifest und Ordner
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| A1 | Ordnername == `season` mit `-` statt `/` | Fehler |
| A2 | `schema_version` ist der App bekannt | Fehler |
| A3 | `sov`, `levels`, `adult` je genau einmal vorhanden | Fehler |
| A4 | Jeder Dokument-Eintrag hat genau eines von `file`, `inherit_from`, `status: missing` | Fehler |
| A5 | `file` existiert und ist gültiges JSON | Fehler |
| A6 | `status: complete` ⇒ kein `inherit_from`, und `sov`/`levels` liegen als Datei vor | Fehler |
| A7 | `season` im Manifest == `season` in jeder Teildatei | Fehler |
| A8 | `valid_from` ist ISO-Datum; alle Dokumente liegen im selben Saisonfenster (± 120 Tage) | Fehler |
| A9 | `inherit_from` existiert, ist älter und bildet keinen Zyklus | Fehler |
| A10 | `valid_from` größer als das der Vorsaison | Warnung |
| A11 | `replaces` verweist auf eine vorhandene Saison (oder `null` bei der ersten) | Fehler |
### B. Katalog (`sov`)
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| B1 | `code` eindeutig, nicht leer, ohne Leerzeichen | Fehler |
| B2 | `type` ∈ {`jump`, `spin`, `sequence`} | Fehler |
| B3 | `jump` ⇒ genau `base_value`; `spin`/`sequence` ⇒ genau `base_values` | Fehler |
| B4 | `base_values` enthält `"B"` und jedes Level aus `levels.levels` lückenlos | Fehler |
| B5 | Werte > 0, ≤ 2 Nachkommastellen, innerhalb 0,3 … 15,0 | Fehler |
| B6 | Sprungfamilien vollständig (1–4 × {T, S, Lo, F, Lz, A}); Lücken nur mit Begründung in `notes.md` | Warnung |
| B7 | Base Values nicht-fallend in der Reihenfolge T ≤ S ≤ Lo ≤ F ≤ Lz ≤ A | Fehler |
| B8 | Base Values streng steigend mit der Rotationszahl je Sprungart (`2Lz > 1Lz`) | Fehler |
| B9 | Pirouetten-/Sequenz-BV streng steigend über die Level (`B < 1 < 2 < 3 < 4`) | Fehler |
B7 und B8 sind die stärksten Prüfungen im Katalog: Sie fangen Zahlendreher
(`1,30` → `3,10`) ohne einen einzigen gepflegten Sollwert und gelten in jeder
Saison. B7 ist bewusst **nicht** streng, weil `1T` == `1S` und `1Lo` == `1F`
gilt.
B7 ist eine Annahme über die ISU, keine Tatsache. Bricht die ISU sie, braucht
die Prüfung eine begründete Ausnahmeliste – nicht das Abschalten der Prüfung.
### C. Level-Regeln (`levels`)
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| C1 | Jeder Code in `fixed_levels` existiert im Katalog | Fehler |
| C2 | Jeder Sprung hat **keinen** `types`-Eintrag; jeder Spin-/Sequenz-Code hat einen | Fehler |
| C3 | Feature-`code` je Typ eindeutig; `name` und `description` nicht leer | Fehler |
| C4 | `required_features` ⊆ Feature-Codes des Typs | Fehler |
| C5 | `level4_requires_any` ⊆ Feature-Codes des Typs | Fehler |
| C6 | `levels`: `min_features` streng steigend, beginnt bei 1, lückenlos | Fehler |
| C7 | Höchste `min_features` ≤ Anzahl Features des Typs (Level 4 erreichbar) | Fehler |
| C8 | Level in `levels` == Level in `base_values` aller levelbaren Elemente | Fehler |
| C9 | `max_per_element` ≥ 1; `once_per_program` ist Boolean | Fehler |
C2 ersetzt eine heute implizite Annahme: „Sprünge sind nicht levelbar". Bekäme
ein Sprung versehentlich einen `types`-Eintrag, rechnete die App plötzlich
Level für Sprünge. C7 fängt den typischen Fehler beim Features-Umbau: drei
Features definieren, aber Level 4 bei vier verlangen.
### D. Adult-Kategorien
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| D1 | `code` je Programmtyp eindeutig, `name` nicht leer, `duration_seconds` 60–300 | Fehler |
| D2 | `forbidden_jumps` ⊆ Katalog-Codes vom Typ `jump` | Fehler |
| D3 | `allowed_rotations` ⊆ {`single`, `double`, `triple`, `quad`} | Fehler |
| D4 | `required_axel` ⇒ `allow_axel` | Fehler |
| D5 | `forbidden_jumps` enthält keinen Axel, wenn `allow_axel: true` | Warnung |
| D6 | `max_spin_level` / `max_sequence_level` ≤ höchstes Level der Saison | Fehler |
| D7 | `required_*` ≤ `max_*` (Schrittsequenz, Choreo-Sequenz) | Fehler |
| D8 | `max_jumps_per_combination` ≥ 2, sobald `max_jump_combinations` > 0 | Fehler |
| D9 | `requires_choreographic_spin` ⇒ `ChSp` existiert im Katalog | Fehler |
| D10 | `pcs_factor` > 0 (außer `scored: false`), `fall_deduction` ≥ 0 | Fehler |
| D11 | `max_jumps_per_combination` ≤ `max_jump_elements` | Fehler |
D5 ist absichtlich nur eine Warnung: In Gold stehen `2F`, `2Lz` und `2A` in
`forbidden_jumps`, während `allow_axel: true` gilt. Das ist kein Widerspruch –
verboten ist der *gesprungene* 2A, nicht der Axel an sich. Die Semantik von
`forbidden_jumps` („Element-Code, nicht Rotation") gehört als Kommentar in die
Datei, damit sie beim nächsten Pflegenden nicht anders gelesen wird.
### E. Über Saisons hinweg
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| E1 | Jeder gegenüber der Vorsaison verschwundene Code ist in `notes.md` erwähnt | Warnung |
| E2 | Jeder neue Code ist in `notes.md` erwähnt | Warnung |
| E3 | Jeder geänderte Wert steht als „alt → neu" in `notes.md` | manuell |
| E4 | In Kürdateien gespeicherte Codes (`element_code`, Feature-Codes) sind unverändert – oder über eine Alias-Tabelle auflösbar | Fehler |
| E5 | Alias-Ziele existieren; der Altcode kommt in keiner Saison mehr als aktiver Code vor | Fehler |
| E6 | Für jedes Saisonpaar existiert ein Test, der eine Referenzkür gegen beide Saisons prüft und die dokumentierte Differenz festnagelt | Warnung |
E4 ist die stille Falle: Eine Kür speichert `element_code` und
`element_features` als Strings. Wird `windmills` zu `windmill`, öffnen alte
Küren mit „unbekanntes Feature" – ohne Fehlermeldung, ohne Migration. Weil
alte Küren jetzt dauerhaft gültig bleiben, ist „Codes einfrieren" keine
Empfehlung mehr, sondern Vertrag. Eine Alias-Tabelle gibt es noch nicht; E4/E5
gelten derzeit durch die Konvention, dass Codes nie umbenannt werden.
E6 ist der einzige Test, der verhindert, dass alte Regeln später versehentlich
„mitrepariert" werden: Die Kür besteht 2025/26 und scheitert 2026/27 an genau
den zwei erwarteten Befunden.
### F. Policies
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| F1 | Kein Policy-Wert hat einen stillen Default im Code; fehlt der Schlüssel, ist die Regel inaktiv | Fehler |
| F2 | Unbekannte Policy-Schlüssel in den Daten sind ein Fehler (Tippfehlerschutz) | Fehler |
| F3 | Policy-Werte haben den erwarteten Typ und Wertebereich | Fehler |
| F4 | Jede Saison deklariert dieselbe Policy-Menge – oder die Abweichung steht in `notes.md` | Warnung |
| F5 | Für jede Policy existiert ein Test, dass sie in einer Saison ohne den Schlüssel nicht wirkt | Warnung |
## Saison-Upgrade-Prüfung
**Motivation:** Ein Verein stellt im Sommer auf die neue Saison um und muss
wissen, was an bestehenden Küren bricht. Heute gibt es dafür keine Antwort
außer „Kür öffnen und hoffen".
**Nutzen:** Das ist der eigentliche Grund, warum sich die Mehrsaison-Struktur
für den Anwender auszahlt – nicht das Archiv, sondern der Vergleich.
**Stand:** umgesetzt (`SeasonUpgradeCheck`). Der Validator ist eine reine
Funktion über (Kür, Regelpaket); der Bericht ist die Differenz zweier Pakete
für diese eine Kür. Bis auf den PDF-Export (siehe offene Punkte) entspricht
die Umsetzung dieser Planung.
### Bedienung
- Auslöser im Prüfdialog und in der Statusleiste: **„Gegen Saison … prüfen"**
mit Auswahl der Ziel-Saison.
- Zwei getrennte Aktionen:
- **Nur prüfen** – schreibgeschützt, ändert nichts.
- **Auf Saison umstellen** – ausdrücklich bestätigt, ein Undo-Schritt,
ändert nur `season` an der Kür.
- Beim Umstellen werden **keine** Elementdaten stillschweigend angepasst. Ein
Kürzel, das es in der Ziel-Saison nicht mehr gibt, bleibt stehen und wird
als Befund gemeldet. Automatisches Löschen oder Umbenennen würde Arbeit
vernichten.
### Bericht
Vier Gruppen, jeder Befund mit Abschnitt und Segment verlinkt:
1. **Elemente:** nicht mehr im Katalog; Typ geändert; Level nicht mehr
verfügbar; Base Value geändert (alt → neu).
2. **Features:** in der Kür gesetzt, in der Ziel-Saison unbekannt; neues
Pflichtfeature; Level-Ergebnis ändert sich (L3 → L2).
3. **Kategorie:** Grenzen geändert (Dauer, Sprunganzahl, Level-Caps, erlaubte
Sprünge); Kategorie in der Ziel-Saison nicht vorhanden.
4. **Summe:** Punktschätzung alt vs. neu mit Differenz.
Zusätzlich nennt der Kopf beide Saisons und die Quelle, und er weist aus,
wenn sich das Prüfverhalten durch Policies ändert („Axel-Pflicht in
Sprungfolge: neu").
Beispielausgabe:
```
Kür „Kür 2026/27 Gold" — 2026/27 → 2027/28
Elemente
• 2 Elemente nicht mehr im Katalog: 2A (Abschnitt 2), CCoSp (Abschnitt 3)
• 3Lz Base Value 5,90 → 6,00
Features
• 1 Feature entfallen: windmills (nicht mehr in 2027/28)
• CCoSp: Level 3 → Level 2
Kategorie Gold
• Dauer 2:50 → 2:40 ±10 s — Kür jetzt 10 s zu lang
• Pflichtelement ChSp bleibt
Summe (Schätzung)
Basiswert 18,40 → 16,90 (−1,50)
```
### Randfälle
- **Ziel-Saison ohne Regeln** (`partial`, Zukunft): Aktion deaktiviert, Grund
genannt.
- **Kür ohne Saison:** derselbe Dialog dient als Erstzuordnung.
- **Ziel-Saison älter als die Kür:** erlaubt, mit Hinweis. Nützlich beim
Testen, harmlos im Ergebnis.
- **Ziel-Saison nicht installiert:** erst nach App-Update verfügbar; die
Auswahl zeigt nur vorhandene Saisons.
### Nebeneffekt
Der Katalog-Diff zweier Saisons ist genau die Änderungsliste, die `notes.md`
beschreibt. Dieselbe Mechanik kann später „Was ist neu in Saison X" erzeugen –
ohne zusätzliche Datenpflege.
## Pflegeablauf pro Saison
1. Ordner `2027-28/` anlegen, Manifest mit `status: partial` und
`inherit_from` für die noch fehlenden Papiere.
2. Neues SoV nicht abtippen: `tools/rules_diff.py 2026-27 2027-28` stellt die
Saisons gegenüber; getippt werden nur Änderungen. 43 Elemente × 5 Werte neu
zu erfassen ist eine Stunde Fehlerquelle, sechs geänderte Werte sind zehn
Minuten. Das Werkzeug ist noch nicht gebaut; bis dahin hilft
`git diff --no-index` über zwei Ordner.
3. `notes.md` mit den Änderungen füllen, die der Diff nicht erklärt.
4. `./tools/test.sh` – der Invariantenkatalog läuft mit.
5. Sobald die übrigen Papiere da sind: `file` statt `inherit_from`,
`status: complete`.
6. Ab dem `valid_from` schaltet sich die Saison von selbst scharf.
**Maßstab:** Wenn ein Saisonwechsel GDScript berührt, ist die Struktur nicht
fertig. Nachweis: `git diff --stat` zeigt nur `data/2027-28/**`.
## Migration der bestehenden Saisons
Ausgangslage: `isu_sov_2025_26.json`, `isu_levels_2025_26.json`,
`isu_sov_2026_27.json`, `isu_levels_2026_27.json`,
`isu_adult_2026_27.json`. Beide Saisons sind migriert; 2025/26 hat die
Adult-Regeln beim Nachtragen erhalten.
### 2025/26
1. Ordner `2025-26/` anlegen, die beiden Dateien als `sov.json` und
`levels.json` übernehmen (Inhalt unverändert).
2. `manifest.json` mit `status: complete`, `replaces: null`.
3. **Adult nachgetragen** aus dem IAFSC-Announcement 2025/26. Eine Lücke, die
man mit einer Datei schließen kann, wäre sonst zur Dauererklärung im
Prüfdialog geworden („nicht anwendbar, keine Adult-Regeln").
Gegenüber 2026/27 gibt es genau zwei fachliche Unterschiede, sie stehen in
`2025-26/notes.md`: kein `ChSp` (also `requires_choreographic_spin: false`)
und Gold kappt alle Features bei Level 3 (`max_sequence_level: 3`).
4. **Policies backfillen** mit dem Stand, der 2025/26 tatsächlich galt
(mindestens `axel_required_in_sequence`).
5. `notes.md`: Was gilt, was fehlt, welche Policies nachgetragen wurden und
warum.
### 2026/27
1. Ordner `2026-27/` anlegen, drei Dateien als `sov.json`, `levels.json`,
`adult.json` übernehmen.
2. `manifest.json` mit `status: complete`, `replaces: "2025/26"` und den drei
Quellenangaben (Communication 2786, 2788, IAFSC-Announcement).
3. Policies aus dem heutigen Code übernehmen – insbesondere die Axel-Pflicht,
damit sich das Prüfergebnis gegenüber heute nicht ändert.
4. `notes.md` mit dem Diff gegen 2025/26 füllen.
5. Die fünf alten `isu_*.json` im selben Commit entfernen.
### Tests
`run_rules_tests.gd`, `run_level_tests.gd` und `run_adult_tests.gd` prüfen
heute absolute Werte der aktiven Saison. Umbau:
- Absolute Werte reduzieren auf eine Handvoll bewusst handgeprüfter Anker je
Saison.
- Der Rest wird Beziehungsprüfung (B7–B9, C6–C7) – die überlebt jeden
Saisonwechsel.
- Neu: der Saison-Paar-Test (E6).
## Umsetzungsreihenfolge
| Schritt | Inhalt | Fertig, wenn |
| :-- | :--- | :--- |
| 1 ✅ | `kind`-Lookup, Manifest, beide Ordner migriert | App lädt beide Saisons; `check_rules.sh` prüft A–D, F |
| 2 ✅ | `season` an der Kür, drei Zustände, Migration alter Dateien | Altkür ohne Saison zeigt „nicht festgelegt" und wird erst nach Auswahl geprüft |
| 3 ✅ | Validator als Funktion über (Kür, Regelpaket) | Kein globaler Katalog mehr in den Prüfpfaden; Saison-Paar-Test grün |
| 4 ✅ | Inspector, Picker, Kategorie folgen dem Kontext | Eine 2025/26-Kür bietet nur 2025/26-Elemente an |
| 5 ✅ | Saison-Anzeige in Statusleiste, Prüfdialog und PDF | Auf dem PDF ist die Saison lesbar |
| 6 ✅ | Saison-Upgrade-Prüfung | Beispielausgabe oben ist reproduzierbar |
| 7 ✅ | „Max. zwei Features pro Fuß" und Variationen pro Kategorie | Neue Regel ohne GDScript-Änderung ergänzbar |
Schritte 1 und 3 sind der Hebel; alles andere baut darauf auf.
## Bewusst nicht
- **Regel-Editor in der App.** Zweite Wahrheit, unversionierter Zustand.
- **Revisionen innerhalb einer Saison.** Die Saison wird mutiert, `notes.md`
dokumentiert (siehe oben).
- **Saisonordner löschen oder archivieren.** Alte Küren bleiben prüfbar.
- **Automatische Umbenennung von Codes beim Saisonwechsel.** Befund statt
stiller Anpassung.
- **Stillschweigende Saisonzuordnung** bei Kürdateien ohne das Feld.
## Offene Punkte
- Ob die Anwender-Doku (`docs/isu-rules.md`) vollständig generiert wird oder
nur die Tabellen und Zahlen.
- Ob der Upgrade-Bericht als PDF ausgegeben wird (für die Weitergabe an
Trainer und Eltern) – naheliegend, aber eigenes Feature.
- Ob `2025/26` auch im Inspector vollständig bedienbar bleibt (Elemente
anlegen) oder nur lesend geprüft wird. Die Entscheidung „alte Küren bleiben
gültig" verlangt Prüfbarkeit, nicht zwingend Bearbeitbarkeit.