lean-path: Angefangenes liegt auf dem Pfad (SPEC §9, D61)

Eine Zugabe (`+`) fällt aus dem günstigsten Pfad — außer sie ist
realisiert und noch nicht erledigt (`[~]`/`[/]`). Angefangene Arbeit ist
die offene Front, und seit D46 zeigt der Pfad genau die; bisher führte
der Von-Station-zu-Station-Knopf nie dorthin, wo gearbeitet wird.
Erledigte Zugaben bleiben draußen: dort ist nichts mehr zu tun, und was
darunter offen blieb, ist mit ihnen zusammen entbehrlich (§3).

Dabei die fehlende Hälfte von D46 gefunden: SPEC §9 sagt seit jeher
„eine bereits realisierte Alternative gewinnt", umgesetzt war das aber
nur über die Kosten — und die sind allein bei `[x]`/`[^]` null. Ein
`[~]`-Zweig verlor damit gegen eine unangetastete billigere, obwohl die
XOR-Regel gerade ihn als die realisierte Alternative ausweist.
`chosenPool()` schränkt die Wahlmenge auf die realisierten ein; unter
mehreren entscheiden wieder die Kosten. Nebengewinn: eine entschiedene
Gruppe ist keine freie Variable mehr und verkleinert die Suche (D42).

10 neue Tests; Gegenprobe geführt (jede Regel einzeln herausgenommen
lässt genau die nach ihr benannten Zusicherungen fallen). Der
mitgelieferte Plan ändert sich nicht — er hat keine angefangene Zugabe.

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

frontend/public/llms.md

@@ -63,7 +63,8 @@ One node per line. Everything except the label is optional.
   `[~]`, `[/]`, `[x]` or `[^]`); each additional realized one warns
   (`xorConflict`).
 - Optionality (`+`) is orthogonal to status: an optional node can be long
-  `[^]`. Optional nodes never count toward the cheapest path.
+  `[^]`. An optional node counts toward the cheapest path **only while it is
+  being worked on** — `[~]` or `[/]`; untouched and finished ones stay out.
 
 ### Fold mark (immediately before the label, i.e. after the status box)
 
@@ -96,10 +97,11 @@ One node per line. Everything except the label is optional.
 - **`[x]` and `[^]` cost nothing any more.** The cheapest path prices the
   work that is *left*, so a done node adds zero regardless of its size and
   carries no station on the path line; started work (`[~]`, `[/]`) still
-  counts in full. A realized alternative therefore wins its `|`/`=` group
-  even when a cheaper unstarted one sits next to it. The *intrinsic* status
-  decides — dependencies may hold a node back effectively, but the work on
-  it is paid for.
+  counts in full. **A realized alternative wins its `|`/`=` group** even when
+  a cheaper unstarted one sits next to it — the choice has been made; among
+  several realized ones cost decides again. The *intrinsic* status decides —
+  dependencies may hold a node back effectively, but the work on it is paid
+  for.
 
 ### Size (effort)
 

frontend/src/model.js

@@ -40,14 +40,18 @@ export function visibleChildren(n, showDiscarded){
    any-of und XOR ⇒ nur die günstigste Alternative. „Günstig" = kleinste rekursive
    Kosten (eigene Größe + Kinder; any-of das Minimum). Verworfene zählen nie
    mit (unabhängig vom Einblenden-Toggle). Gleichstand ⇒ erste. Fehlende
-   Größe = M.
+   Größe = M. Ist in einer disjunktiven Gruppe etwas realisiert, wird nur noch
+   unter den realisierten gewählt (`chosenPool`, D61).
    Optionale Kinder (`+`, SPEC §3/D29) fallen hier ebenfalls heraus — sie sind
-   per Definition entbehrlich, also weder Kostenanteil noch Pfadknoten. Da beide
-   Nutzer (`cheapestCost`, `markCheapest`) über diese Funktion gehen, gilt das
-   samt Teilbaum. */
+   per Definition entbehrlich, also weder Kostenanteil noch Pfadknoten. Da alle
+   Nutzer über diese Funktion gehen, gilt das samt Teilbaum.
+   AUSNAHME (D61): Wird an der Zugabe gerade gearbeitet (`isStarted`), liegt
+   sie auf dem Pfad — angefangene Arbeit IST die offene Front. Erledigte
+   Zugaben bleiben draußen: Dort ist nichts mehr zu tun, und was darunter
+   offen blieb, ist mit ihnen zusammen entbehrlich (§3). */
 export function pathChildren(n){
   return n.children.filter(k =>
-    !k.optional && (!k.status || k.status.key !== 'verworfen'));
+    (!k.optional || isStarted(k)) && (!k.status || k.status.key !== 'verworfen'));
 }
 /* ---------- Erledigt: was nichts mehr kostet (SPEC §9, D46) ----------
    `[x]` fertig und `[^]` in Produktion. Die Beförderung auf Prod ist keine
@@ -60,13 +64,29 @@ export function pathChildren(n){
 export function isDone(n){
   return !!n.status && (n.status.key === 'fertig' || n.status.key === 'prod');
 }
+/* „realisiert" (SPEC §3, D35): Kosten investiert oder mehr. Trägt die
+   XOR-Regel und — seit D61 — die Wahl in Alternativgruppen. */
+export function isRealized(n){
+  return !!n.status && ['arbeit', 'durchstich', 'fertig', 'prod'].includes(n.status.key);
+}
+/* Angefangen und noch offen: realisiert, aber nicht erledigt (D61). Aus zwei
+   vorhandenen Begriffen zusammengesetzt statt einer dritten Schwelle. */
+export function isStarted(n){ return isRealized(n) && !isDone(n); }
+/* Wahlmenge einer disjunktiven Gruppe (SPEC §9, D61): Ist etwas realisiert,
+   ist die Wahl getroffen — dann wird nur noch unter den realisierten gewählt.
+   Sonst stehen alle zur Wahl. Die Kostenregel (kleinste rekursive Kosten,
+   Gleichstand ⇒ erste) gilt innerhalb der Menge unverändert. */
+export function chosenPool(kids){
+  const real = kids.filter(isRealized);
+  return real.length ? real : kids;
+}
 /* fehlende Größe wird als M interpretiert; Erledigtes kostet nichts mehr */
 export function ownCost(n){ return isDone(n) ? 0 : SIZE_RANK[n.size || 'M'] + 1; }
 export function cheapestCost(n){
   const kids = pathChildren(n);
   let c = ownCost(n);
   if(kids.length){
-    if(gateOf(kids) !== 'and') c += Math.min(...kids.map(cheapestCost));
+    if(gateOf(kids) !== 'and') c += Math.min(...chosenPool(kids).map(cheapestCost));
     else c += kids.reduce((s, k) => s + cheapestCost(k), 0);
   }
   return c;
@@ -129,10 +149,14 @@ export function computeCheapPlan(roots){
     }
   })(roots);
   for(const kids of groups){
-    let best = kids[0], bc = cheapestCost(kids[0]);
-    for(const k of kids.slice(1)){ const c = cheapestCost(k); if(c < bc){ bc = c; best = k; } }
+    const pool = chosenPool(kids);
+    let best = pool[0], bc = cheapestCost(pool[0]);
+    for(const k of pool.slice(1)){ const c = cheapestCost(k); if(c < bc){ bc = c; best = k; } }
     localChoice.set(kids[0], best);   /* Schlüssel: erstes Kind der Gruppe */
-    if(anyDeps && kids.some(k => touches.get(k))) coupled.push(kids);
+    /* Eine entschiedene Gruppe (genau eine realisierte Alternative, D61) ist
+       keine freie Variable mehr — sie koppelt nicht und verkleinert die Suche. */
+    if(anyDeps && pool.length > 1 && pool.some(k => touches.get(k)))
+      coupled.push({key: kids[0], pool});
   }
 
   /* Nötige Menge für eine Belegung der gekoppelten Gruppen. */
@@ -159,7 +183,7 @@ export function computeCheapPlan(roots){
   const costOf = set => { let c = 0; set.forEach(n => c += ownCost(n)); return c; };
 
   let product = 1;
-  for(const kids of coupled){ product *= kids.length; if(product > EXACT_LIMIT) break; }
+  for(const grp of coupled){ product *= grp.pool.length; if(product > EXACT_LIMIT) break; }
   if(product > EXACT_LIMIT){
     /* Gierig, aber benannt (D42): lokale Wahl überall, Hülle trotzdem. */
     return {set: needed(new Map()), exact: false};
@@ -171,12 +195,12 @@ export function computeCheapPlan(roots){
   let best = null, bc = Infinity;
   for(;;){
     const choice = new Map();
-    coupled.forEach((kids, g) => choice.set(kids[0], kids[idx[g]]));
+    coupled.forEach((grp, i) => choice.set(grp.key, grp.pool[idx[i]]));
     const set = needed(choice);
     const c = costOf(set);
     if(c < bc){ bc = c; best = set; }
     let g = coupled.length - 1;
-    while(g >= 0 && ++idx[g] >= coupled[g].length){ idx[g] = 0; g--; }
+    while(g >= 0 && ++idx[g] >= coupled[g].pool.length){ idx[g] = 0; g--; }
     if(g < 0) break;
   }
   return {set: best, exact: true};

frontend/tests/frontier.test.js

@@ -80,10 +80,22 @@ describe('Auswahl — die getroffene Wahl gewinnt', () => {
   | [ ] Billig (XS)`)).toEqual(['Gemacht', 'Wahl']);
   });
 
-  it('eine erst angefangene Alternative gewinnt dadurch NICHT', () => {
+  /* Bis D61 gewann hier „Billig": Die Wahl lief allein über die Kosten, und
+     die sind nur bei `[x]`/`[^]` null. Angefangenes kostet voll und verlor
+     damit — obwohl SPEC §9 die Regel schon so formuliert hatte. */
+  it('gilt auch für eine erst angefangene Alternative', () => {
     expect(cheapLabels(`[ ] Wahl (XS)
   | [~] Angefangen (L)
-  | [ ] Billig (XS)`)).toEqual(['Billig', 'Wahl']);
+  | [ ] Billig (XS)`)).toEqual(['Angefangen', 'Wahl']);
+  });
+
+  /* Die unangetastete ist hier die billigste von allen — gewählt wird
+     trotzdem unter den realisierten, und dort entscheiden die Kosten. */
+  it('lässt unter mehreren realisierten wieder die Kosten entscheiden', () => {
+    expect(cheapLabels(`[ ] Wahl (XS)
+  | [~] Teuer (L)
+  | [/] Günstig (S)
+  | [ ] Unangetastet (XS)`)).toEqual(['Günstig', 'Wahl']);
   });
 
   it('gilt auch in einer XOR-Gruppe', () => {

frontend/tests/optional.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { parse } from '../src/parser.js';
-import { computeCheapSet, cheapestCost, visibleChildren } from '../src/model.js';
+import { computeCheapSet, cheapestCost, cheapCls, visibleChildren } from '../src/model.js';
 import { renderTreeHtml } from '../src/render.js';
 
 const t = key => key;
@@ -38,7 +38,7 @@ describe('Parser — `+` setzt optional, nicht das Gate', () => {
   });
 });
 
-describe('Günstigster Pfad — optionale Knoten sind nie nötig', () => {
+describe('Günstigster Pfad — unangetastete Zugaben sind nicht nötig', () => {
   const BAUM = `[ ] Wurzel (S)
   - [ ] Pflicht (S)
   + [ ] Zugabe (XXL)
@@ -69,6 +69,59 @@ describe('Günstigster Pfad — optionale Knoten sind nie nötig', () => {
   });
 });
 
+/* Die Ausnahme (D61): Wird an der Zugabe gearbeitet, ist sie offene Arbeit —
+   und der Pfad zeigt seit D46 die offene Front. Erledigte bleiben draußen. */
+describe('Günstigster Pfad — an einer angefangenen Zugabe wird gearbeitet', () => {
+  it('nimmt eine `[~]`-Zugabe auf den Pfad', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)\n  - [ ] Pflicht (S)\n  + [~] Zugabe (S)`))
+      .toEqual(['Pflicht', 'Wurzel', 'Zugabe']);
+  });
+
+  it('nimmt eine `[/]`-Zugabe ebenso', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)\n  + [/] Zugabe (S)`))
+      .toEqual(['Wurzel', 'Zugabe']);
+  });
+
+  it('lässt `[?]`, `[ ]`, `[!]` und ohne Status weiterhin draußen', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)
+  + [?] Idee (S)
+  + [ ] Geplant (S)
+  + [!] Riskant (S)
+  + Neutral (S)`)).toEqual(['Wurzel']);
+  });
+
+  /* Genau der Punkt, an dem die Empfehlung korrigiert wurde: Fertiges gehört
+     nicht auf die offene Front — und was darunter offen blieb, ist mit der
+     Zugabe zusammen entbehrlich (§3). */
+  it('lässt eine erledigte Zugabe samt offenem Rest draußen', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)
+  + [x] Fertige Zugabe (S)
+    - [ ] Rest (M)
+  + [^] Live (S)`)).toEqual(['Wurzel']);
+  });
+
+  it('nimmt den Teilbaum der angefangenen Zugabe mit', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)\n  + [~] Zugabe (S)\n    - [ ] Teil (S)`))
+      .toEqual(['Teil', 'Wurzel', 'Zugabe']);
+  });
+
+  it('rechnet sie damit auch in die Kosten des Elternknotens', () => {
+    /* Wurzel (S=2) + Zugabe (S=2) = 4; unangetastet wären es 2. */
+    expect(cheapestCost(roots(`[ ] Wurzel (S)\n  + [~] Zugabe (S)`)[0])).toBe(4);
+  });
+
+  it('macht sie zur Station statt des Elternknotens', () => {
+    const [wurzel] = roots(`[ ] Wurzel (S)\n  + [~] Zugabe (S)`);
+    const set = computeCheapSet([wurzel]);
+    expect(cheapCls(wurzel, set, false)).toBe('cheap');
+    expect(cheapCls(wurzel.children[0], set, false)).toBe('cheap cheap-leaf');
+  });
+
+  it('lässt eine verworfene Zugabe auch angefangen draußen', () => {
+    expect(cheapLabels(`[ ] Wurzel (S)\n  + [-] Abgebrochen (S)`)).toEqual(['Wurzel']);
+  });
+});
+
 describe('Renderer — Kennzeichnung und Gemischt-Warnung', () => {
   it('gibt dem optionalen Knoten die Klasse `opt`', () => {
     const {html} = render(`[ ] Wurzel\n  - [ ] Pflicht\n  + [ ] Zugabe`);