fix: berechne-alle-winkel Signatur-Nachzug (schon-flach) + HundM05-Menu-Fix nachgezogen

Lisp/vf_standard.lsp: berechne-alle-winkel um Parameter schon-flach
erweitert (Fussabdruck-Korrektur, wenn ein Frame flach statt bei 3 Grad
ankommt) - vf_linienzug.lsp rief die Funktion bereits mit diesem 5.
Argument auf, dieser Commit fehlte im letzten Commit und liess den
Zwischenstand mit Argumentzahl-Mismatch zurueck. tests/test_foerderer.lsp
und tests/test_mubea.lsp ziehen dieselbe Signatur nach (inkl.
berechne-horizontale-mitte, das schon-flach bereits erwartete).
tests/testdata/linienzug_tests*.json aktualisiert passend zum echten
Bau-Ablauf. menu/SSG_LIB.mnu/.cui: TEST_LINIENZUG_STUFE2 im Testmenue
ergaenzt.

Lisp/vf_spec.lsp + lib/vf_spec_export.py: *vsp-menu-start* auf die aktuelle
6-Optionen-Kettenanfang-Zuordnung umgestellt (vorher noch 4 Optionen) -
vsp-journal replayt gegen den LEBENDEN vf-linienzug-modus. Python-Tabelle
bewusst NICHT umgestellt (dekodiert eine eingefrorene Alt-Aufzeichnung).
TEST_HUNDM05 schlaegt trotzdem weiterhin fehl (separates, ungeloestes
Problem - siehe naechster Absatz).

Bekannter offener Fehler: TEST_HUNDM05 baut nach wie vor nicht korrekt -
der Menu-Code-Fix allein reicht nicht. Root Cause nicht abschliessend
geklaert, Uebergabe an Kollegen fuer Logik-Review vorgesehen.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Lisp/vf_spec.lsp

@@ -65,10 +65,21 @@
 (setq *vsp-tab-ende2*      '(("ja-mit-es" . "1") ("nein" . "2")))
 
 ;; Glied -> Menue-Code. Der Code haengt am Frame: 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.
-(setq *vsp-menu-start*  '(("Linie-GF" . "1") ("Linie-VF" . "2")
-                          ("Horizontal-VF" . "3") ("Linie" . "4")))
+;; ohne Frame (Kettenanfang) und bekommt 6 Optionen - GF-Bogen UND Vario-Kurve
+;; sind seit der "Fortsetzung einer bestehenden Teilkette"-Erweiterung
+;; (vf_linienzug.lsp, vfl-naechstes-element-header-Zweig ohne frame) AUCH am
+;; Kettenanfang waehlbar (Referenzrichtung kommt dann aus einem KS_AUS am
+;; Startpunkt statt aus einem Frame) - NICHT mehr nur 4 Optionen wie fruecher.
+;; Jede spaetere Sektion (Frame existiert bereits) hat weiterhin 5 Optionen
+;; (GF-Bogen ist dort IMMER Option 1, kein Vario-Kurve-Sonderfall noetig - eine
+;; Vario-Kurve wird dort ueber die VF-Einheit selbst erreicht). Beide Tabellen
+;; MUESSEN exakt zur Options-Reihenfolge in vf-linienzug-modus passen (siehe
+;; dortiger Kommentar "Kettenanfang: 6 Optionen statt 4") - ein Regressions-Fund
+;; 2026-09-12 (TEST_HUNDM05 baute "GF-Bogen" statt "Linie-GF" als erstes Glied,
+;; weil diese Tabelle noch die alte 4-Optionen-Zuordnung hatte).
+(setq *vsp-menu-start*  '(("GF-Bogen" . "1") ("Vario-Kurve" . "2")
+                          ("Linie-GF" . "3") ("Linie-VF" . "4")
+                          ("Horizontal-VF" . "5") ("Linie" . "6")))
 (setq *vsp-menu-weiter* '(("GF-Bogen" . "1") ("Linie-GF" . "2")
                           ("Linie-VF" . "3") ("Horizontal-VF" . "4")
                           ("Linie" . "5")))
@@ -88,6 +99,10 @@
 ;; darum in vsp-bau-aus-spec und nicht einmal aussen: der Abbruch-Handler in
 ;; vf-linienzug-modus setzt *ssg-ils-dim* zurueck.
 (if (not (boundp '*vsp-dim-override*)) (setq *vsp-dim-override* nil))
+;; Ausgabe-Flag von vsp-sektion (siehe dort): T, wenn eine "Linie-GF"-Sektion
+;; mit ende="ja-mit-es" die NAECHSTE Sektion (das ES-Glied) bereits inline
+;; mitverarbeitet hat - vsp-journal ueberspringt sie dann beim Weiterzaehlen.
+(if (not (boundp '*vsp-es-verbraucht*)) (setq *vsp-es-verbraucht* nil))
 
 ;; Fehler sammeln (aeltester zuerst) statt beim ersten abzubrechen: eine
 ;; handgeschriebene Spec hat selten genau einen Tippfehler.
@@ -234,7 +249,13 @@
       (vsp-wert-str (ssg-val kopf "as_winkel") "as_winkel")
       (vsp-code-raus *vsp-tab-seite* (ssg-val kopf "as_seite") "as_seite"))))
 
-(defun vsp-sektion (sek subs erster / label tab code art modus smodus)
+;; naechste: Felder der NAECHSTEN Top-Level-Sektion (oder nil) - wird nur fuer
+;; "Linie-GF" gebraucht (siehe dort). *vsp-es-verbraucht* (Ausgabe-Flag, vom
+;; Aufrufer vsp-journal gelesen): T, wenn diese Sektion die naechste (das
+;; ES-Glied) bereits mitverarbeitet hat - der Aufrufer muss sie dann beim
+;; Weiterzaehlen ueberspringen.
+(defun vsp-sektion (sek subs erster naechste / label tab code art modus smodus ende-wert)
+  (setq *vsp-es-verbraucht* nil)
   (setq label (ssg-val sek "glied"))
   (setq *vsp-wo* (strcat "Sektion " (if label label "(ohne glied)")))
   (cond
@@ -277,6 +298,31 @@
           (setq modus (ssg-val sek "laenge_modus"))
           (if (null modus) (setq modus "endpunkt"))
           (vsp-code-raus *vsp-tab-gf-laenge-modus* modus "laenge_modus")
+          ;; NEU (2026-09-12): "Ist das Kettenende?" wird im Bau-Ablauf jetzt
+          ;; SOFORT nach der Laenge-Modus-Wahl gefragt (vor Separator/
+          ;; Gefaelle) - vorher lief die Frage erst nach dem Bau. Bei
+          ;; "ja-mit-es" fragt vf-linienzug-modus DIREKT im Anschluss auch
+          ;; ES-Winkel/-Seite (damit deren Fussabdruck schon in die
+          ;; Laengenberechnung eingeht) - die Spec beschreibt das ES-Element
+          ;; aber weiterhin als EIGENE, nachfolgende Sektion (glied="ES",
+          ;; siehe dort) fuer bessere Lesbarkeit. vsp-journal muss die beiden
+          ;; Tokengruppen daher HIER zusammenziehen: "ende" + (bei ja-mit-es)
+          ;; die Winkel/Seite-Tokens der naechsten Sektion, vorgezogen. Die
+          ;; eigentliche ES-Sektion wird dadurch bereits vollstaendig
+          ;; verbraucht - vsp-journal ueberspringt sie danach (siehe
+          ;; *vsp-es-verbraucht*), sonst kaemen ihre Tokens ein zweites Mal.
+          (setq ende-wert (ssg-val sek "ende"))
+          (vsp-code-raus *vsp-tab-ende3* ende-wert "ende")
+          (if (= ende-wert "ja-mit-es")
+            (cond
+              ((null naechste)
+                (vsp-fehler "ende=\"ja-mit-es\", aber keine folgende ES-Sektion vorhanden"))
+              ((/= (ssg-val naechste "glied") "ES")
+                (vsp-fehler "ende=\"ja-mit-es\" erwartet eine direkt folgende Sektion mit glied=\"ES\""))
+              (T
+                (vsp-wert-str (ssg-val naechste "winkel") "winkel (ES, vorgezogen)")
+                (vsp-code-raus *vsp-tab-seite* (ssg-val naechste "seite") "seite (ES, vorgezogen)")
+                (setq *vsp-es-verbraucht* T))))
           (cond
             ((= modus "steigend")
               (setq smodus (ssg-val sek "steigend_modus"))
@@ -304,7 +350,7 @@
                 (vsp-zahl "REAL" (ssg-val sek "hoehe") "hoehe")
                 (vsp-zahl "REAL" (ssg-val sek "winkel") "winkel")))
           )
-          (vsp-code-raus *vsp-tab-ende3* (ssg-val sek "ende") "ende"))
+        )
 
         ((= label "Linie-VF")
           (vsp-linie sek)
@@ -424,17 +470,24 @@
 
 ;; Spec -> Vorwaerts-Journal. Rueckgabe: Journal, oder nil wenn die Spec
 ;; Fehler hat (dann stehen sie in *vsp-fehler*).
-(defun vsp-journal (spec / sektionen i)
+;; Index-basierte Schleife (statt foreach) - noetig, damit "Linie-GF" bei
+;; ende="ja-mit-es" die naechste Sektion (das ES-Glied) vorziehen UND danach
+;; ueberspringen kann (siehe vsp-sektion/*vsp-es-verbraucht*).
+(defun vsp-journal (spec / sektionen n i s naechste)
   (setq *vsp-fehler* nil  *vsp-tok* nil  *vsp-erster-dl* T  *vsp-wo* "Spec")
   (cond
     ((null (vsp-kopf spec)) (vsp-fehler "Kopf-Objekt fehlt") nil)
     (T
       (vsp-praeambel (vsp-kopf spec))
-      (setq sektionen (vsp-sektionen spec)  i 0)
+      (setq sektionen (vsp-sektionen spec))
+      (setq n (length sektionen))
       (if (null sektionen) (vsp-fehler "Spec hat keine Sektionen"))
-      (foreach s sektionen
-        (setq i (1+ i))
-        (vsp-sektion (vsp-sek-felder s) (vsp-sek-subs s) (= i 1)))
+      (setq i 0)
+      (while (< i n)
+        (setq s (nth i sektionen))
+        (setq naechste (if (< (1+ i) n) (vsp-sek-felder (nth (1+ i) sektionen)) nil))
+        (vsp-sektion (vsp-sek-felder s) (vsp-sek-subs s) (= i 0) naechste)
+        (setq i (+ i (if *vsp-es-verbraucht* 2 1))))
       (if *vsp-fehler* nil (reverse *vsp-tok*)))))
 
 ;; Nur pruefen, nichts bauen: liefert die Fehlerliste (nil = Spec in

Lisp/vf_standard.lsp

@@ -217,12 +217,22 @@
 ;; feste-hz: horizontales Budget der festen Elemente (Umlenk+Motor+Separatoren).
 ;; nil => Standardwert FESTE_HORIZONTAL (1600, Standard-VF mit 2 Separatoren).
 ;; Der Linienzug uebergibt 1300 (nur 1 Separator am Einlauf, siehe vf_linienzug).
-(defun berechne-alle-winkel (deltaL deltaH richtung feste-hz /
+;; schon-flach: T => der Frame kommt FLACH (0 Grad) an, statt schon auf der
+;; 3-Grad-Basis zu stehen - der Aufrufer wird VOR dem eigentlichen VF-Koerper
+;; noch einen Uebergangsbogen (flach->3 Grad, IMMER "ab", siehe vfl-nach-
+;; 3grad) einfuegen, dessen Fussabdruck (entry-dx/entry-dz) hier - genau wie
+;; aus-dx/aus-dz beim AS-Element - VORAB vom verfuegbaren Budget abgezogen
+;; werden muss. Ohne das wurde diese Strecke stillschweigend verbraucht und
+;; die Kette verfehlte den Zielpunkt (real beobachtet: schon-flach-Faelle im
+;; Linienzug-Kettenende, bis dahin nur bei Stufe 2/berechne-horizontale-mitte
+;; beruecksichtigt). Default nil (unveraendertes Verhalten fuer alle
+;; Aufrufer, die immer von der 3-Grad-Basis starten).
+(defun berechne-alle-winkel (deltaL deltaH richtung feste-hz schon-flach /
                              winkel-list ergebnis-liste A B cos3 sin3
                              bogen-x1 bogen-z1 bogen-x2 bogen-z2
                              abs-dz-AUS abs-dz-EIN L_GF L_VF cosα sinα
                              winkel-eff cosEff sinEff rad5 rad7
-                             winkel mass1 mass2 gueltig
+                             winkel mass1 mass2 gueltig entry-mass entry-dx entry-dz
                              best-winkel best-L_GF best-L_VF)
 
   (if (or (not *lib-initialized*) (null aus-dz) (null ein-dz))
@@ -233,6 +243,11 @@
   )
   (if (null feste-hz) (setq feste-hz FESTE_HORIZONTAL))
 
+  (setq entry-dx 0.0  entry-dz 0.0)
+  (if schon-flach
+    (progn
+      (setq entry-mass (get-bogen-mass bogen-ab (fix *vfk-gefaelle-winkel*)))
+      (setq entry-dx (car entry-mass)  entry-dz (caddr entry-mass))))
   (setq abs-dz-AUS (abs aus-dz) abs-dz-EIN (abs ein-dz))
   (setq winkel-list (ssg-cfg-or "vario" "bogen_winkel"
                      '(3 6 9 12 15 18 21 27 33 39 45 51)))
@@ -270,15 +285,15 @@
         (setq cosα (cos (* winkel (/ pi 180.0)))
               sinα (sin (* winkel (/ pi 180.0))))
         (setq A (- deltaL aus-dx ein-dx bogen-x1 bogen-x2
-                   (* feste-hz cos3)))
+                   (* feste-hz cos3) entry-dx))
         (setq winkel-eff (if (= richtung "Auf") (- winkel *vfk-gefaelle-winkel*) (+ winkel *vfk-gefaelle-winkel*)))
         (setq cosEff (cos (* winkel-eff (/ pi 180.0)))
               sinEff (sin (* winkel-eff (/ pi 180.0))))
         (if (= richtung "Auf")
-          (setq B (+ deltaH abs-dz-AUS abs-dz-EIN
+          (setq B (+ deltaH abs-dz-AUS abs-dz-EIN (abs entry-dz)
                      (- bogen-z1) (- bogen-z2)
                      (* feste-hz sin3)))
-          (setq B (+ (- deltaH abs-dz-AUS abs-dz-EIN
+          (setq B (+ (- deltaH abs-dz-AUS abs-dz-EIN (abs entry-dz)
                          (* feste-hz sin3))
                      bogen-z1 bogen-z2))
         )
@@ -395,7 +410,7 @@
   (setq FESTE_HORIZONTAL  (ssg-cfg-or "vario" "feste_horizontal"  1600))
   (setq staustrecke-basis (ssg-cfg-or "vario" "staustrecke_basis" 1000))
   (init-bibliothek)
-  (berechne-alle-winkel deltaL deltaH richtung nil)
+  (berechne-alle-winkel deltaL deltaH richtung nil nil)
 )
 
 ;; ============================================================