[FEAT] VF-Linienzug aus Eingabedaten bauen (Stufe 1: Spec -> Journal -> Replay)

Stufe 1 des Fahrplans in doc/TODO-plan-vf-interactive.md, fertig fuer
Modus 1. Eine SPEC beschreibt eine Kette in Domaenenwerten ("links",
"winkel", "aussen", ja/nein) statt in Menue-Codes; vsp-journal uebersetzt sie
in ein Eingabe-Journal, vsp-bau-aus-spec spielt es per
vfl-journal-replay-start durch den UNVERAENDERTEN vf-linienzug-modus. Der
fertige Block traegt damit dasselbe SSG_VF_EDIT-Journal wie eine handgebaute
Kette und bleibt per Doppelklick editier- und 2D/3D-konvertierbar - kein
Journal-Konsument muss etwas von Specs wissen.

CAD-Lauf VF_SPEC_BAU: 5 OK, 0 Fehler. Je Kette status "executed",
prompts 0 (keine Live-Eingabe erreicht), eingaben_offen 0, keine
Spec-Fehler, keine Bau-Meldungen, glieder_ist == glieder_soll,
Einfuegepunkt gleich dem Kettenstart der Spec.

Neu:
- Lisp/vf_spec.lsp: Code-Tabellen, Emitter vsp-journal, Validierung
  vsp-pruefen, flacher JSON-Loader, Headless-Rahmen vsp-headless-an/-aus,
  Ergebnis-Record, vsp-bau-aus-spec/-liste, c:VF_SPEC_BAU. Von vf_core.lsp
  NACH vf_linienzug.lsp geladen - damit sind beide Ladewege abgedeckt (Menue
  und der .scr-Loader), das MNL bleibt unveraendert.
- lib/vf_spec_export.py: derselbe Emitter in Python PLUS die Umkehrung
  (spec_aus_journal), erzeugt die Spec-Testdaten.
- tests/testdata/vf_spec_hundm05.json: die 5 echten Ketten als Spec,
  erzeugt statt handgeschrieben.
- tests/test_vf_spec.lsp (C:TEST_VF_SPEC, in alltests.json): 7 Faelle je
  Glied-Typ, 7 Validierungsfaelle, Gruppieren, und die 5 echten Ketten gegen
  ihr aufgezeichnetes Journal.
- tests/test_vf_spec.py: 36 Tests (Rundlauf, Spec-Daten, Validierung,
  Erwartungswert-Abgleich, Ergebnisse von VF_SPEC_BAU).

Drei Regeln, die der Uebersetzer besitzen muss - jede wuerde sonst die ganze
Replay-Queue verschieben:
- Der Menue-Code haengt am Frame: erste Sektion 4 Optionen (kein GF-Bogen,
  es gibt noch keine Richtung), jede spaetere 5.
- hz steht genau EINMAL im Journal, beim ersten Segment (vfl-in-abstand
  journalisiert die Richtung nur bei freier Richtungswahl).
- Nur ein HORIZONTALER Erstkoerper einer VF-Einheit stellt die Separator-/
  Endpunktfragen vorab (winkel1=0 laeuft durch vfl-baue-horizontal-koerper);
  ein gewinkelter wird ohne jede Frage gebaut.

Wie die Richtigkeit belegt ist - drei Implementierungen derselben Grammatik,
die einander pruefen:
- Rundlauf gegen echte Daten: journal_aus_spec(spec_aus_journal(tok)) == tok
  fuer alle 5 HundM-Ketten, tokenweise numerisch verglichen. Damit ist
  bewiesen, dass die Spec das Journal verlustfrei abbildet.
- Der Weg, den LISP nimmt (flaches JSON -> Spec -> Journal), ergibt separat
  geprueft dieselben Journale wie das aufgezeichnete Protokoll.
- Der unabhaengige Dekoder aus lib/vf_journal_export.py verdaut alle 7
  synthetischen Emitter-Ausgaben restlos, auch die zwei Zweige, die in den
  echten Daten fehlen (Linie-VF, gewinkelter Erstkoerper).
- Die Erwartungswerte im LISP-Test kommen aus dem geprueften Python-Emitter;
  TestLispErwartungen liest sie zurueck und vergleicht erneut. Ohne das
  koennte ein Uebertragungsfehler einen falschen Erwartungswert
  festschreiben und der CAD-Lauf waere gruen, obwohl der Emitter falsch
  liegt.

Abweichungen von der Planung (Begruendungen in doc/TODO-plan-vf-interactive.md
Abschnitt 4.6): vsp-pruefen ruft den Emitter statt eine zweite Regelmenge zu
pflegen; das vollstaendige Journal steht nicht im Record (statt dessen
glieder_soll/glieder_ist als Desync-Detektor); Zusatzfeld segment_typ am
Glied "Linie", weil dort vfl-segment-entscheidung selbst zwischen GF und VF
waehlt; vf_ende-Werte "automatisch"/"zielpunkt-ohne-es" fuer die Faelle ohne
Frage; Praefix vsp- statt vfs- (das gehoert vf_standard.lsp).

Zusaetzlich:
- tests/test_vf_headless_statisch.py prueft jetzt auch, dass
  Lisp/vf_spec.lsp UEBERHAUPT keine Eingabe-/Dialogfunktion aufruft - beim
  Daten-Pfad ist die Null die Vorgabe.
- tests/testdata/mubea.json: die drei einzeln eingefuegten S-LP-Separatoren
  entfernt (Fortsetzung von 699744e - die Separatoren stecken jetzt in den
  Staustreckenbloecken).

Noch offen: die Uebersetzer fuer Modus 2 und 3. Modus 2 braucht laut
Fahrplan erst 2-3 echte "linienzug2"-Journale als Referenz -
tests/testdata/hundm05.json enthaelt ausschliesslich Modus-1-Ketten.

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

doc/TODO-plan-vf-interactive.md

@@ -12,7 +12,7 @@
 | P1 | `vfl-meldung` statt `alert` in den Bau-Pfaden | **erledigt** |
 | P2 | `*vfl-headless*`: leere Replay-Queue wird zum Fehler | **erledigt** |
 | P3 | Kleinkram (`*vfl-meldungen*`-Reset, `vfl-view-refresh`) | **erledigt** |
-| S1 | Stufe 1: `Lisp/vf_spec.lsp` (Spec -> Journal -> Replay) | offen |
+| S1 | Stufe 1: `Lisp/vf_spec.lsp` (Spec -> Journal -> Replay) | **Modus 1 fertig**, im CAD ungetestet |
 | S2 | Stufe 2: echte Funktionstrennung (Schritte 0-11) | offen |
 | PY | `lib/vf_journal_export.py`: Grammatik vervollstaendigen | **erledigt** |
 
@@ -361,6 +361,89 @@ gruppiert wie `hundm05:gruppiere`. Wahrheitswerte als `1`/`0`
 (`ssg-cfg-parse-value` kennt kein `true`/`false`). Ein `nr`-Feld pro Sektion
 macht handgeschriebene Dateien selbstpruefend.
 
+### 4.6 Umsetzungsstand Stufe 1 (2026-09-03)
+
+**Fertig fuer Modus 1.** Was entstanden ist:
+
+| Datei | Inhalt |
+|---|---|
+| `Lisp/vf_spec.lsp` | Code-Tabellen, Emitter `vsp-journal`, Validierung `vsp-pruefen`, flacher JSON-Loader `vsp-json-laden`/`vsp-gruppieren`, Headless-Rahmen `vsp-headless-an`/`-aus`, Ergebnis-Record, `vsp-bau-aus-spec`/`-liste`, `c:VF_SPEC_BAU` |
+| `lib/vf_spec_export.py` | derselbe Emitter in Python PLUS die Umkehrung (`spec_aus_journal`), erzeugt die Spec-Testdaten |
+| `tests/testdata/vf_spec_hundm05.json` | die 5 echten Ketten als Spec (57 flache Objekte), **erzeugt** statt handgeschrieben |
+| `tests/test_vf_spec.lsp` | `C:TEST_VF_SPEC`: 7 handgebaute Faelle je Glied-Typ, 7 Validierungsfaelle, Gruppieren, und die 5 echten Ketten gegen ihr aufgezeichnetes Journal |
+| `tests/test_vf_spec.py` | 27 Tests ohne CAD + 10 fuer die `VF_SPEC_BAU`-Ergebnisse |
+
+Abweichungen von der Planung, jeweils mit Grund:
+
+1. **`vsp-pruefen` ruft den Emitter** statt eine zweite Regelmenge zu
+   pflegen. Zwei getrennte Regelwerke laufen auseinander; der Emitter
+   validiert ohnehin jedes Feld, das er anfasst.
+2. **Das vollstaendige Journal steht NICHT im Ergebnis-Record.** Es ist schon
+   in der Spec und in der XDATA des gebauten Blocks - eine dritte Kopie waere
+   nur Ballast. Statt dessen `glieder_soll` und `glieder_ist`: das ist der
+   Desync-Detektor, der auch dann greift, wenn die Queue zufaellig aufgeht.
+3. **Zusatzfeld `segment_typ`** am Glied `Linie`: dort waehlt
+   `vfl-segment-entscheidung` selbst zwischen reiner Gefaellestrecke und
+   VF-Einheit. Am Journal ist es erkennbar (VF-Einheit beginnt mit der
+   GF-Verteilungsfrage), aus der Spec allein nicht - und Geometrie zu raten
+   verstoesst gegen I3.
+4. **`vf_ende`-Werte `automatisch` und `zielpunkt-ohne-es`** neben
+   `ja-mit-es`/`nein`: in beiden Faellen stellt `vfl-vf-einheit-abschluss`
+   KEINE Frage (Glied `Linie` bzw. Kettenende am Zielpunkt ohne ES-Wunsch).
+   Ohne diese Werte waere die Tokenzahl nicht bestimmbar.
+5. **Praefix `vsp-`**, nicht `vfl-`: `vfs-` ist schon von `vf_standard.lsp`
+   belegt, und die Spec-Ebene ist bewusst von `vf_linienzug.lsp` getrennt
+   (einseitige Abhaengigkeit).
+
+**Wie die Richtigkeit belegt ist** - drei Implementierungen derselben
+Grammatik, die einander pruefen:
+
+- **Rundlauf gegen echte Daten**: fuer alle 5 HundM-Ketten gilt
+  `journal_aus_spec(spec_aus_journal(tok)) == tok`, tokenweise numerisch
+  verglichen. Damit ist bewiesen, dass die Spec das Journal verlustfrei
+  abbildet - sonst waere ein spec-gebauter Nachbau eine andere Kette.
+- **Der Weg, den LISP nimmt**, ist separat geprueft: flaches JSON -> Spec ->
+  Journal ergibt dieselben Journale wie das aufgezeichnete Protokoll.
+- **Der unabhaengige Dekoder** (`lib/vf_journal_export.py`, gegen die echten
+  Ketten verifiziert) verdaut alle 7 synthetischen Emitter-Ausgaben restlos -
+  auch die zwei Zweige, die in den echten Daten fehlen (`Linie-VF`,
+  gewinkelter Erstkoerper).
+- **Die Erwartungswerte im LISP-Test sind nicht von Hand abgeleitet**: sie
+  kommen aus dem geprueften Python-Emitter, und
+  `TestLispErwartungen` in `tests/test_vf_spec.py` liest sie aus
+  `tests/test_vf_spec.lsp` zurueck und vergleicht sie erneut. Sonst koennte
+  ein Uebertragungsfehler einen falschen Erwartungswert festschreiben und der
+  CAD-Lauf waere gruen, obwohl der Emitter falsch liegt. Gegengeprobt: eine
+  verfaelschte Zahl im LISP-Test wird erkannt.
+
+**CAD-Lauf `VF_SPEC_BAU` (2026-09-03): 5 OK, 0 Fehler.** Alle 5 Ketten aus
+der Spec gebaut, je Kette `status: executed`, `prompts: 0` (keine Live-Eingabe
+erreicht - der positive Beweis), `eingaben_offen: 0`, `spec_fehler: []`,
+`meldungen: []`, `glieder_ist == glieder_soll`, Einfuegepunkt gleich dem
+Kettenstart der Spec. Damit ist der Daten-Pfad in der Praxis belegt; die
+9 Ergebnis-Tests in `tests/test_vf_spec.py` laufen gruen gegen diesen Lauf.
+
+Zwei Nacharbeiten aus dem Lauf:
+- Die Ergebnisdatei landete in `results/`, weil `c:VF_SPEC_BAU` `DXFM_RESULTS`
+  bevorzugte. Das ist das Verzeichnis der Sivas-/CSV-Exporte; Testergebnisse
+  gehoeren nach `tests/output` (Konvention `test_run_all.lsp`, von den
+  pytest-Fixtures gelesen, per `.gitignore` ausgeschlossen). Default jetzt
+  `tests/output`, Override ueber `DXFM_VF_SPEC_OUT`. Die Fixture prueft beide
+  Orte, damit ein alter Lauf nicht stumm uebersprungen wird.
+- `TEST_VF_SPEC` ist ein Testbefehl und muss vorher geladen werden:
+  `(load (strcat (getenv "DXFMAKRO") "/tests/test_vf_spec.lsp"))` - oder
+  ueber `SSG_RUN_ALL_TESTS`, wo `vf_spec` inzwischen in `alltests.json` steht.
+
+**Noch offen in Stufe 1**: die Uebersetzer fuer Modus 2 (`pfad-handles` +
+Segmentliste, Abschnitt 4.4) und Modus 3 sind NICHT gebaut - Modus 2 braucht
+laut Reihenfolge (Punkt 11) erst 2-3 echte `"linienzug2"`-Journale als
+Referenz, und `tests/testdata/hundm05.json` enthaelt ausschliesslich
+Modus-1-Ketten. Ebenfalls offen: der CAD-Lauf `TEST_VF_SPEC` (Uebersetzer,
+ohne Zeichnung) und `VF_SPEC_BAU` (baut die 5 Ketten aus der Spec; danach
+prueft `tests/test_vf_spec.py` das Ergebnis gegen
+`tests/output/hundm05_results.json` - Attribut fuer Attribut, das ist der
+Beweis "Spec-Pfad == Journal-Pfad" auf Geometrie-Ebene).
+
 ---
 
 ## Teil 5 - Stufe 2: echte Funktionstrennung

doc/variofoerderer.md

@@ -487,6 +487,69 @@ Sektion warum nicht baubar war - bleibt erhalten. Die reinen Interaktiv-Alerts
 `alert` geblieben. `vfl-journal-reset` loescht `*vfl-meldungen*` und
 `*vfl-headless-fehler*` mit: beides gehoert zum einzelnen Lauf.
 
+### Spec-Pfad: Kette aus Eingabedaten (`VF_SPEC_BAU`)
+
+Auf dem Headless-Rahmen sitzt `Lisp/vf_spec.lsp`. Eine **Spec** beschreibt
+eine Kette in Domaenenwerten statt in Menue-Codes:
+
+```json
+{ "spec_id": "VF_spec_LZ_01", "modus": 1,
+  "start_punkt": [4912.2, 1230.9, 2154.0], "start_hoehe": 2154.0,
+  "as": 1, "as_winkel": "90", "as_seite": "links" }
+{ "glied": "Linie-GF", "nr": 1, "dl": 2249.3, "hz": 90.0,
+  "gefaelle": "winkel", "winkel": 3.0, "ende": "nein" }
+{ "glied": "Horizontal-VF", "nr": 2, "dl": 3256.9,
+  "gf_verteilung": "einlauf", "vf_sep_vor": 0, "vf_sep_nach": 0,
+  "vf_ende": "nein", "vf_separator": 0 }
+{ "sub": "vario-kurve", "winkel": 90, "seite": "rechts", "variante": "innen" }
+{ "sub": "motorstation" }
+{ "glied": "ES", "winkel": "90", "seite": "links" }
+```
+
+Flach, weil `ssg-load-json` zeilenweise liest; Wahrheitswerte als `1`/`0`.
+`vsp-journal` uebersetzt das in ein Eingabe-Journal, `vsp-bau-aus-spec`
+spielt es per `vfl-journal-replay-start` durch den **unveraenderten**
+`vf-linienzug-modus`. Der fertige Block traegt danach dasselbe
+`SSG_VF_EDIT`-Journal wie eine handgebaute Kette.
+
+Drei Regeln, die der Uebersetzer besitzen muss (sie sind der Grund, warum die
+Spec nicht einfach "die Antworten" ist):
+
+1. **Der Menue-Code haengt am Frame.** Nur die erste Sektion laeuft ohne
+   Frame und bekommt 4 Optionen (kein GF-Bogen - es gibt noch keine Richtung,
+   an die er anschliessen koennte), jede spaetere 5. `Linie-GF` ist also in
+   Sektion 1 der Code `"1"`, ab Sektion 2 der Code `"2"`.
+2. **`hz` steht genau einmal im Journal**, beim allerersten Segment
+   (`vfl-in-abstand` journalisiert die gesnappte Richtung nur bei freier
+   Richtungswahl). Ein `hz` an spaeterer Stelle verschiebt die ganze
+   Replay-Queue - darum ein harter Spec-Fehler.
+3. **Der erste Koerper einer VF-Einheit** stellt nur dann Separator- und
+   Endpunktfragen vorab, wenn er HORIZONTAL ist (`winkel1 = 0` in
+   `vfl-vf-einheit` laeuft durch `vfl-baue-horizontal-koerper`). Ein
+   gewinkelter Erstkoerper (`Linie-VF`, `Linie` -> VF) wird ohne jede Frage
+   gebaut.
+
+Nicht vorhersagbar bleibt die Winkelwahl: `vfl-waehle-winkel` fragt nur, wenn
+mehrere Kandidaten geometrisch gueltig sind, was von der real gemessenen
+Restlaenge abhaengt. Dafuer das optionale Feld `winkel_idx`; fehlt es und der
+Bau braucht die Antwort, greift der Headless-Riegel und nennt Glied und
+Eingabe-Nummer. Geraten wird nichts.
+
+Ergebnis je Kette als Record (`tests/output/vf_spec_results.json`): `status`
+(`executed`/`warnung`/`desync`/`abbruch`/`spec-fehler`), Block, Handle,
+Einfuegepunkt, Attribute, `eingaben_offen`, `prompts` (muss 0 sein),
+`glieder_soll` gegen `glieder_ist` und die gesammelten `meldungen`. Der
+Glied-Vergleich ist der Desync-Detektor, der auch dann greift, wenn die Queue
+aufgeht: eine geometrisch abgewiesene Sektion wirft keinen Fehler, sie
+verbraucht nur weniger Eintraege.
+
+Gegenstueck in Python: `lib/vf_spec_export.py` enthaelt denselben Emitter
+PLUS die Umkehrung und erzeugt daraus die Spec-Testdaten. Der Rundlauf
+`Journal -> Spec -> Journal` laeuft in `tests/test_vf_spec.py` gegen die 5
+echten HundM-Ketten - er beweist, dass die Spec das Journal verlustfrei
+abbildet. Modus 2 und 3 haben noch keinen Uebersetzer (Modus 2 braucht erst
+echte `"linienzug2"`-Journale als Referenz).
+
 Beispiel: `tests/test_hundm05.lsp` (5 echte Ketten aus `data/polylines.dxf`)
 setzt alle drei Schalter mit Save/Restore, ersetzt `getpoint`/`getstring`/
 `getint`/`getreal`/`alert` zusaetzlich durch **zaehlende** Stubs (Netz fuer