docs: Geplante Erweiterungen (IDs, Abhängigkeiten, XOR, Falten, Beschreibungen)

Die fünf geplanten Notations-Erweiterungen für vollständiges Lean-Pathfinding
sind in die Doku eingearbeitet — Schreibweisen samt offener Punkte in SPEC §11,
Begründung und Folgen in D34, Aufgaben in Phase 4, und als Knoten im
mitgelieferten Werkbaum-Plan.

Drei Kollisionen mit Bestehendem sind dabei benannt statt stillschweigend
mitentschieden: `#` trägt jetzt drei Bedeutungen (Ticket, Schlagwort, Knoten-ID),
`x` für XOR liest sich neben `[x]` schlecht, und kurze Knotenbeschreibungen
können keine eingerückte Folgezeile sein, weil Einrückung Hierarchie bedeutet.

Die weitestreichende Folge betrifft D18: Mit Dependency Closure — gemeinsame
Abhängigkeiten nur einmal gezählt — ist die günstigste Alternative nicht mehr
lokal entscheidbar; die gierige Wahl je Gruppe ist nicht länger optimal.

LEAN-PATHFINDING.md schlug für Abhängigkeiten noch `→ Feature` vor (Verweis auf
den Titel, rote Linien); das ist mit `:#id` überholt und korrigiert.

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

docs/DECISIONS.md

@@ -1471,3 +1471,77 @@ will. Der Streifen ist so schmal wie die Ziffern es verlangen
 `scroll` erst im nächsten Bild aus — in einem nicht gezeichneten Tab womöglich
 gar nicht. `scrollEditorToOffset()` zieht die Zahlen deshalb selbst gleich mit,
 statt sich auf das Ereignis zu verlassen.
+
+## D34 — Abhängigkeiten, IDs, XOR, Falten, Beschreibungen: erst reserviert, dann gebaut
+Fünf Erweiterungen auf einmal — Knoten-**IDs** (`#auth`), **Abhängigkeiten**
+(`:#auth,#api`) samt effektivem Status, **XOR** (`x`), ein- und ausklappbare
+**Teilbäume** (`>` / `<`) und **Knotenbeschreibungen**. Das ist der größte
+Zuwachs an Notation, seit die Sprache steht, und er kommt aus dem Ziel, Lean
+Pathfinding vollständig zu unterstützen (docs/LEAN-PATHFINDING.md).
+
+**Entscheidung: alles zuerst nach SPEC §11, nichts vorab gebaut.** Das ist die
+Hausregel (CLAUDE.md: „Syntaxänderungen: SPEC zuerst, dann Code"), hat hier aber
+einen eigenen Grund: Vier der fünf Erweiterungen belegen Zeichen, und **drei
+davon kollidieren mit etwas, das es schon gibt**. Wer eine davon baut, ohne die
+Kollision vorher aufzulösen, entscheidet sie stillschweigend mit.
+
+**Was entschieden ist:**
+
+- **Abhängigkeiten sagen etwas über den Status, nicht über die Reihenfolge.**
+  Sie legen nicht fest, wann jemand anfangen darf — das trennt Werkbaum von
+  einem Netzplan und hält den Baum als Zerlegung lesbar.
+- **Der effektive Status wird gerechnet, nie geschrieben.** Im Text steht der
+  intrinsische; alles andere gäbe zwei Quellen der Wahrheit für dieselbe
+  Aussage (D14: der Text ist das führende Format).
+- **Zyklen sind zulässig**, keine Warnung: Sie bedeuten „wird gemeinsam fertig"
+  und sind bei sich gegenseitig bedingenden Teilen die ehrliche Aussage. Ein
+  Werkzeug, das sie verbietet, zwingt zum Lügen.
+- **Faltmarken im Text sind der erste Darstellungs-Hinweis in der Notation.**
+  Ansichtszustand (Modus, Zoom, Aufteilung) liegt bisher bewusst **außerhalb**
+  des Textes, im localStorage und global über alle Dokumente (D22). `>` bricht
+  damit — vertretbar, weil es etwas anderes sagt: nicht „so sehe *ich* das
+  gerade", sondern „so wird dieses Dokument **eröffnet**". Das ist eine Aussage
+  des Autors über das Dokument, gehört also hinein. Der Betrachter bleibt frei:
+  im Diagramm wird danach unabhängig gefaltet.
+
+**Was ausdrücklich offen bleibt** (jeweils in SPEC §11 notiert, damit es
+niemand beim Bauen überliest):
+
+- **`#` trägt drei Bedeutungen** — Ticket (`#123`), Schlagwort (`#tag`),
+  Knoten-ID (`#auth`). Das Ticket ist numerisch und bleibt unterscheidbar; ID
+  und Schlagwort sind formgleich. Solange die Trennregel fehlt, ist auch `#tag`
+  blockiert — die ältere Reservierung ist die, die weichen oder sich fügen muss.
+- **`x` für XOR** kollidiert nicht beim Parsen (das Zerlegungszeichen steht vor
+  der Statusbox), aber `x [x] …` liest sich schlecht.
+- **Kurze Beschreibungen können keine eingerückte Folgezeile sein.** Einrückung
+  ist in dieser Notation Hierarchie (SPEC §2) — eine eingerückte Zeile *ist* ein
+  Kindknoten. Hier liegt die eigentliche Arbeit dieser Erweiterung, nicht im
+  Anzeigen eines Tooltips.
+
+**Die Folge, die am weitesten reicht: D18 wird schwerer.** Der günstigste Pfad
+rechnet heute rekursiv über den Baum — bei `any of` gewinnt die Alternative mit
+den kleinsten Eigenkosten, Gleichstand entscheidet die erste. Mit
+Abhängigkeiten zählt nicht mehr der Teilbaum, sondern die **Dependency
+Closure**, und gemeinsam benötigte Abhängigkeiten zählen **nur einmal**. Damit
+ist die Wahl nicht mehr lokal:
+
+> Eine Gruppe hat die Alternativen `A (S) :#db` und `B (M)`. Für sich genommen
+> gewinnt `B`, sobald `#db` mehr als `S` kostet. Wird `#db` aber ohnehin von
+> einem erforderlichen Knoten anderswo im Baum gebraucht, ist es bezahlt — die
+> **zusätzlichen** Kosten von `A` sind dann nur `S`, und `A` gewinnt.
+
+Was billig ist, hängt also davon ab, was der Rest des Plans schon einkauft; bei
+mehreren Alternativgruppen mit geteilten Abhängigkeiten hängen die Wahlen
+zusätzlich voneinander ab. Das ist die Bauform eines Überdeckungsproblems und
+im Allgemeinen nicht mehr gierig optimal zu lösen. Für die Baumgrößen, um die
+es hier geht (ein Plan hat Dutzende, nicht Millionen Knoten), ist eine exakte
+Suche machbar; wird sie zu langsam, bleibt die gierige Rechnung — dann aber
+**benannt**, nicht stillschweigend. Genau darum steht es hier und nicht erst im
+Code.
+
+**Nebenbefund:** `docs/LEAN-PATHFINDING.md` hatte für Abhängigkeiten `→ Feature`
+vorgeschlagen (Verweis auf den **Titel**, mit rot gestrichelten Linien). Das ist
+mit `:#id` überholt — ein Verweis auf den Titel bricht beim Umbenennen, und Rot
+ist in dieser Palette nicht vergeben (SPEC §4 nutzt Pastelltöne für Status,
+`--warn` für Hinweise). Die Datei ist entsprechend korrigiert; die dortigen
+Phasen bleiben, was sie sind: eine Wunschliste, kein Beschluss.

docs/LEAN-PATHFINDING.md

@@ -11,7 +11,7 @@
 ## Phase 1: Foundation – Quick Wins
 *Basis-Features für echte Pfad-Optimierung. Priorität: Höchst.*
 
-- [ ] **Abhängigkeits-Marker** — Features können explizit auf andere Features verweisen (`→ andere Feature`). Gestrichelte rote Linien im Diagramm zeigen Blockierungen; Warnungen wenn Abhängigkeiten zirkulär oder nicht erfüllbar sind.
+- [ ] **Abhängigkeits-Marker** — Features können explizit auf andere Features verweisen. Schreibweise ist inzwischen festgelegt: Knoten-ID `#auth`, Abhängigkeit `:#auth,#api` (SPEC §11, D34) — **nicht** der hier ursprünglich vorgeschlagene Verweis auf den Titel (`→ andere Feature`), der beim Umbenennen bricht. Querverbindungen werden optisch **sekundär** gezeichnet (dünn/gestrichelt), nicht rot: Rot ist in dieser Palette nicht vergeben. Zirkuläre Abhängigkeiten sind **zulässig** (sie bedeuten „wird gemeinsam fertig"), nicht erfüllbare — eine ID ohne Knoten — ergeben eine Warnung.
 
 - [ ] **Team-Velocity-basiertes Kostenmodell** — T-Shirt-Größen werden in Story-Points übersetzt (konfigurierbar pro Team). Automatische Timeline-Berechnung: T-Shirt + Team-Velocity → Wochen, mit eingebautem Overhead-Faktor (Meetings 1.2×) und Risk Buffer (1.15×). Warnung: "Feature > 2 Sprints, sollte zerlegt werden".
 
@@ -63,8 +63,11 @@
 ### MVP (Phase 1 + Teile von Phase 2)
 **Ziel:** Abhängigkeits-Tracking + Velocity-basierte Kostenschätzung als Basis.
 
-1. Data Model: Abhängigkeits-Notation in SPEC erweitern (z.B. `→ Feature-Id`)
+1. Data Model: Knoten-IDs und Abhängigkeiten in SPEC ausformulieren — reserviert
-2. Parser: `→`-Syntax extrahieren, Dependency Graph validieren
+   ist `#auth` bzw. `:#auth,#api` (SPEC §11); vorher die dort benannten offenen
+   Punkte entscheiden, allen voran die Doppelrolle von `#`
+2. Parser: IDs und `:#…`-Listen extrahieren, Dependency Graph aufbauen
+   (Zyklen sind erlaubt, unbekannte IDs sind Warnungen)
 3. UI: Dependency-Linien im Diagramm zeichnen; kritische Pfade hervorheben
 4. Timeline-Rechner: T-Shirt + Velocity + Team-Config → Wochen
 5. Tests: Zirkuläre Abhängigkeiten, Kostenberechnung, kritische Pfade

docs/ROADMAP.md

@@ -105,28 +105,60 @@ Tastendruck ein Commit); und wer bei einem Backend eigentlich was darf
   Status-/Zeitachse.
 - Attribut-Syntax für Termine/Meilensteine.
 
-## Features für vollständiges Lean-Pathfinding
+## Vollständiges Lean-Pathfinding
 
-- **Ein-/Ausklappbare Teilbäume**  
+Werkbaum hat die Grundlagen — Und/Oder-Zerlegung, Größen, günstigster Pfad —,
-  Teilbäume können im Text mit einer kompakten Zeichensyntax als initial eingeklappt markiert werden. `>` steht dabei für „ab hier einklappen“, `<` kann innerhalb eines eingeklappten Bereichs gezielt wieder sichtbare Teilbäume hervorholen. Im Diagramm kann anschließend unabhängig vom Text interaktiv ein- und ausgeklappt werden.
+aber der Pfad rechnet bisher nur innerhalb des gewählten Teilbaums. Was fehlt,
+ist die Möglichkeit, Bezüge **quer** durch den Baum auszudrücken. Diese Stufe
+holt das nach. Schreibweisen und offene Punkte stehen in **SPEC §11**,
+Begründung und Folgen in **D34**; hier steht, was es dem Werkzeug bringt.
 
-- **Knoten-IDs**  
+**Fünf Erweiterungen der Notation.** Sie hängen zusammen: ohne IDs keine
-  Knoten können über eine kompakte ID wie `#auth` eindeutig adressiert werden. IDs bestehen aus einem whitespace-freien Bezeichner und dienen insbesondere als Ziel für Querverweise und Abhängigkeiten.
+Abhängigkeiten, ohne Abhängigkeiten kein effektiver Status, ohne den kein
+Pfad, der die Wahrheit sagt.
 
-- **Abhängigkeiten zwischen Knoten**  
+- **Knoten-IDs** (`#auth`) — ein whitespace-freier Bezeichner macht einen Knoten
-  Mit einer Syntax wie `:#auth,#api` kann ein Knoten von anderen Knoten außerhalb seines eigenen Teilbaums abhängig gemacht werden. Dependencies beeinflussen nicht, wann Arbeiten beginnen dürfen, sondern den **effektiven Status** eines Knotens.
+  im ganzen Dokument adressierbar. Für sich genommen nutzlos; er ist das Ziel
+  für alles Folgende.
+- **Abhängigkeiten** (`:#auth,#api`) — ein Knoten hängt von Knoten außerhalb
+  seines eigenen Teilbaums ab. Sie sagen nichts über Reihenfolge oder
+  Startzeitpunkt, sondern etwas über den Status; Zyklen sind zulässig und
+  bedeuten „wird gemeinsam fertig".
+- **Intrinsischer und effektiver Status** — was in der Statusbox steht, ist der
+  Bearbeitungsstand des Knotens selbst. Effektiv fertig ist er erst, wenn auch
+  seine Abhängigkeiten es sind. Der effektive Status wird gerechnet, nie
+  geschrieben.
+- **XOR** (`x`) — neben „mindestens eine" (`|`) eine Gruppe, in der **genau
+  eine** Alternative realisiert werden darf. Für die Pfadrechnung ändert das
+  nichts (die wählt bei `|` ohnehin eine); es kommt eine Regel hinzu, die
+  verletzt werden kann und dann gemeldet wird.
+- **Knotenbeschreibungen** — Erläuterungstext zum Knoten, im Diagramm als
+  Tooltip oder Pop-up: kurz direkt beim Knoten, lang als Block am Dokumentende
+  über die ID zugeordnet. Die Arbeit steckt nicht im Anzeigen, sondern in der
+  Schreibweise: Einrückung bedeutet hier bereits Hierarchie.
 
-- **Intrinsischer und effektiver Status**  
+**Was daraus folgt.**
-  Der intrinsische Status beschreibt den tatsächlichen Bearbeitungsstand eines Knotens. Der effektive Status berücksichtigt zusätzlich seine Abhängigkeiten. Ein intrinsisch fertiger Knoten kann daher effektiv noch nicht vollständig fertig sein, solange Dependencies nicht erfüllt sind.
 
-- **Dependency-aware Lean Pathfinding**  
+- **Dependency-aware Pathfinding.** Gerechnet wird nicht mehr der Teilbaum,
-  Das Lean Pathfinding berücksichtigt künftig nicht nur den Restaufwand innerhalb des gewählten Teilbaums, sondern die gesamte notwendige **Dependency Closure**. Gemeinsam benötigte Dependencies werden dabei nur einmal berechnet. Zyklen sind zulässig und entsprechen gemeinsam fertigzustellenden Gruppen.
+  sondern die **Dependency Closure** — alles, was zusätzlich nötig ist, damit
+  der gewählte Knoten effektiv fertig werden kann. Gemeinsam benötigte
+  Abhängigkeiten zählen **nur einmal**. Damit ist die Wahl zwischen
+  Alternativen nicht mehr lokal entscheidbar: Was billig ist, hängt davon ab,
+  was der Rest des Plans ohnehin einkauft (Beispiel und Konsequenz in D34).
+  Das ist die eigentliche Erweiterung von D18, und die einzige Stelle, an der
+  hier echte Algorithmik steckt.
+- **Querverbindungen im Diagramm.** Abhängigkeiten als optisch sekundäre Linien
+  (dünn oder gestrichelt), bei ausgewähltem Knoten seine ein- und ausgehenden
+  hervorgehoben. Erste Linienart, die nicht der Zerlegung folgt — sie braucht
+  eine eigene Zeichenebene (SVG, wie der Pfad-Spline), nicht die Rahmenkanten.
+- **Ein- und ausklappbare Teilbäume** (`>` / `<`). Sobald Pläne quer verbunden
+  sind, wächst das Diagramm über den Bildschirm hinaus; ohne Falten ist ein
+  großer Plan nicht mehr zu lesen. Die Marken im Text bestimmen nur den
+  Anfangszustand — im Diagramm wird danach unabhängig gefaltet.
 
-- **Visualisierung von Dependencies**  
+Der gestaffelte „günstigste Pfad" aus *Kleinere Ideen* (Status-Bewusstsein,
-  Abhängigkeiten werden als optisch sekundäre Querverbindungen im Diagramm dargestellt, etwa dünn oder gestrichelt. Bei Auswahl eines Knotens können dessen ein- und ausgehende Dependencies hervorgehoben werden.
+Ausbaustufen) baut hierauf auf: Er braucht denselben Umbau der Kostenrechnung
+und ist danach im Wesentlichen eine Frage der Auswahl, nicht der Mechanik.
 
-- **XOR / exklusives Oder**  
+Breitere Feature-Wunschliste zum Thema: `docs/LEAN-PATHFINDING.md`
-  Zusätzlich zu `all-of`, `any-of` und optionalen Knoten soll eine echte XOR-Gruppe unterstützt werden: Genau eine Alternative darf realisiert werden. Als kompakte Syntax bietet sich beispielsweise `x` an.
+(Entwurf, kein Beschluss), Marktumfeld: `docs/MARKET-ANALYSIS.md`.
-
-- **Knotenbeschreibungen / Detailtexte**  
-  Knoten können zusätzliche Erläuterungstexte erhalten, die im Diagramm als Tooltip oder Pop-up angezeigt werden. Vorgesehen sind kurze, direkt beim Knoten eingerückte Texte sowie längere, über die Knoten-ID referenzierte Beschreibungsblöcke am Ende des Dokuments.

docs/SPEC.md

@@ -503,8 +503,111 @@ Druckdialog „an Seite anpassen“ bzw. Querformat wählen.
 
 ## 11. Reservierte Erweiterungen (noch nicht implementiert)
 
+Vergebene Zeichen und geplante Schreibweisen. **Reserviert heißt: nicht
+anderweitig verwenden** — nicht: schon entschieden. Die endgültige Schreibweise
+wird hier festgelegt, **bevor** sie gebaut wird; wo unten „offen“ steht, ist sie
+das auch. Begründung und Zusammenhang: D34.
+
+### Referenzen, Schlagworte und Knoten-IDs (`#`)
+
 - `#123` — Referenz auf externe Tickets (geplant für Taiga-Integration).
-- `#tag` — freie Schlagworte (deshalb `#` nicht anderweitig verwenden).
+- `#tag` — freie Schlagworte.
+- `#auth` — **Knoten-ID**: ein whitespace-freier Bezeichner, der einen Knoten im
+  ganzen Dokument eindeutig benennt. Ziel für Abhängigkeiten und
+  Beschreibungsblöcke (siehe unten). Zwei Knoten mit derselben ID sind ein
+  Fehler und bekommen eine Warnung mit Zeilennummer (§4).
+
+**Offen: `#` trägt damit drei Bedeutungen.** `#123` ist rein numerisch und
+bleibt unterscheidbar; **ID und Schlagwort sehen einander gleich**. Vor der
+Implementierung ist eine Trennregel zu entscheiden — etwa „das erste
+`#`-Token einer Zeile ist die ID, jedes weitere ein Schlagwort“ oder ein
+eigenes Zeichen für eine der beiden Rollen. Solange das offen ist, ist auch
+`#tag` nicht gebaut.
+
+### Abhängigkeiten zwischen Knoten (`:#auth,#api`)
+
+Ein Knoten kann von Knoten **außerhalb seines eigenen Teilbaums** abhängen;
+notiert als Doppelpunkt mit kommagetrennter ID-Liste.
+
+- Abhängigkeiten sagen **nichts über Reihenfolge oder Startzeitpunkt** — sie
+  sagen etwas über den **Status** (siehe unten). Das ist der Unterschied zu
+  einem Netzplan.
+- **Zyklen sind zulässig** und bedeuten: diese Knoten werden gemeinsam fertig.
+  Sie sind also kein Fehler und bekommen keine Warnung.
+- Eine ID ohne zugehörigen Knoten ist ein Fehler (Warnung mit Zeilennummer).
+- Kollisionsfrei zur bestehenden Zeilenextraktion (§1): Gelesen wird nur ein
+  Doppelpunkt mit **unmittelbar folgendem `#`** — ein Doppelpunkt im Label
+  bleibt damit Label. Die URL wird ohnehin schon in Schritt 3 herausgenommen,
+  vor Größe, Tags und Label.
+
+### Intrinsischer und effektiver Status
+
+- Der **intrinsische** Status ist der, der in der Statusbox steht (§4) — der
+  Bearbeitungsstand des Knotens selbst.
+- Der **effektive** Status berücksichtigt zusätzlich die Abhängigkeiten: Ein
+  intrinsisch fertiger Knoten ist effektiv **nicht** fertig, solange eine
+  Abhängigkeit es nicht ist.
+- Der effektive Status wird **gerechnet, nie geschrieben**. Im Notationstext
+  steht ausschließlich der intrinsische — sonst gäbe es zwei Quellen der
+  Wahrheit für dieselbe Aussage.
+- **Offen ist die Darstellung.** Die Knotenfarbe zeigt heute den intrinsischen
+  Status (§4); beide zugleich brauchen entweder einen zweiten visuellen Kanal
+  oder einen Umschalter.
+
+### Querverbindungen im Diagramm
+
+Abhängigkeiten werden als **optisch sekundäre** Querverbindungen gezeichnet
+(dünn oder gestrichelt) — sie dürfen den Baum nicht überlagern, der die
+Hauptaussage trägt. Bei ausgewähltem Knoten werden dessen ein- und ausgehende
+Abhängigkeiten hervorgehoben. Das ist die erste Linienart, die **nicht** der
+Zerlegung folgt; sie braucht deshalb eine eigene Zeichenebene (SVG, wie der
+Pfad-Spline in §9), nicht die Rahmenkanten der Knoten.
+
+### Günstigster Pfad mit Abhängigkeiten
+
+Die Kostenrechnung aus §9 zählt heute nur den gewählten Teilbaum. Mit
+Abhängigkeiten zählt die **Dependency Closure**: alles, was zusätzlich nötig
+ist, damit der gewählte Knoten effektiv fertig werden kann. Gemeinsam
+benötigte Abhängigkeiten werden dabei **nur einmal** gezählt. Genau das macht
+die Rechnung schwerer als heute — siehe D34.
+
+### Ein- und ausklappbare Teilbäume (`>` / `<`)
+
+- `>` an einem Knoten heißt: **ab hier eingeklappt** — sein Teilbaum ist beim
+  Öffnen des Dokuments zunächst verborgen.
+- `<` innerhalb eines eingeklappten Bereichs holt einen einzelnen Teilbaum
+  gezielt wieder hervor.
+- Im Diagramm wird danach **unabhängig vom Text** interaktiv auf- und
+  zugeklappt; die Marken im Text bestimmen nur den Anfangszustand.
+- **Offen:** die Stellung im Zeilenformat (§1) — vor oder hinter dem
+  Zerlegungszeichen — und ob eingeklappte Teilbäume in Grafikexport und Druck
+  eingeklappt bleiben.
+
+### XOR — genau eine Alternative (`x`)
+
+Neben `-` (all of), `+` (Zugabe) und `|` (any of, **mindestens** eine) soll es
+eine Gruppe geben, in der **genau eine** Alternative realisiert werden darf.
+Vorgeschlagenes Zeichen: `x`, an derselben Stelle wie die übrigen
+Zerlegungszeichen.
+
+- Für den günstigsten Pfad ändert das nichts: Der wählt bei `|` ohnehin genau
+  eine (§9). XOR fügt eine **Regel** hinzu, die verletzt werden kann — zwei
+  realisierte Alternativen ergeben eine Warnung.
+- **Offen** bleibt das Zeichen: `x` kollidiert nicht beim Parsen (das
+  Zerlegungszeichen steht vor der Statusbox), aber `x [x] …` liest sich
+  schlecht, weil `x` zugleich der Statuscode für *fertig* ist.
+
+### Knotenbeschreibungen
+
+Erläuternder Text zu einem Knoten, im Diagramm als Tooltip oder Pop-up.
+Vorgesehen sind zwei Formen: ein **kurzer Text unmittelbar beim Knoten** und
+ein **längerer Block am Ende des Dokuments**, über die Knoten-ID zugeordnet.
+
+**Offen — und hier liegt die eigentliche Arbeit:** Die kurze Form kann nicht
+einfach eine eingerückte Folgezeile sein. Einrückung bedeutet in dieser
+Notation Hierarchie (§2); eine eingerückte Zeile **ist** ein Kindknoten. Die
+kurze Form braucht deshalb ein eigenes einleitendes Zeichen, die lange Form
+eine Blockform, die sich nicht mit einem Wurzelknoten verwechseln lässt.
 
 ## 12. Dateiendung
 

docs/TASKS.md

@@ -60,3 +60,25 @@ Abhaken beim Erledigen; neue Aufgaben unten anfügen.
 - [ ] Mermaid-Plugin-Spike: Detektor + Registrierung, ein Minimalbaum.
 - [ ] Taiga-Spike: `#ref`-Syntax parsen, Status via REST-API auflösen
       (read-only), Mapping konfigurierbar.
+
+## Phase 4 — Vollständiges Lean-Pathfinding (siehe [ROADMAP](ROADMAP.md), D34)
+Reihenfolge ist nicht beliebig: ohne IDs keine Abhängigkeiten, ohne die keinen
+effektiven Status und keine Closure-Rechnung. Jeder Punkt beginnt in
+[SPEC §11](SPEC.md) — die dort benannten offenen Schreibweisen sind zu
+entscheiden, **bevor** Code entsteht.
+- [ ] `#`-Doppelrolle auflösen (Knoten-ID vs. Schlagwort) und in SPEC §11
+      festschreiben; `#tag` hängt an derselben Entscheidung.
+- [ ] Knoten-IDs parsen; doppelte ID → Warnung mit Zeilennummer.
+- [ ] Abhängigkeiten `:#a,#b` parsen; unbekannte ID → Warnung, Zyklen erlaubt.
+- [ ] Effektiven Status rechnen (intrinsisch + Abhängigkeiten); Darstellung
+      entscheiden — die Knotenfarbe zeigt heute den intrinsischen Status.
+- [ ] Günstigsten Pfad auf die Dependency Closure umstellen (gemeinsame
+      Abhängigkeiten nur einmal zählen). Erweitert D18; die gierige Wahl je
+      Alternativgruppe ist damit nicht mehr optimal — Verfahren wählen und
+      **benennen**.
+- [ ] Querverbindungen zeichnen (eigene SVG-Ebene, optisch sekundär);
+      bei ausgewähltem Knoten ein-/ausgehende hervorheben.
+- [ ] Faltmarken `>` / `<` parsen; interaktives Auf-/Zuklappen im Diagramm.
+- [ ] XOR-Gruppe (`x`): Zeichen endgültig wählen, parsen, Verletzung melden.
+- [ ] Knotenbeschreibungen: Schreibweise für kurze und lange Form festlegen
+      (Einrückung ist bereits Hierarchie), dann Tooltip/Pop-up.

docs/examples/werkbaum.werkbaum

@@ -9,6 +9,16 @@
       - [^] People tags, bare URLs, %% comments (XS)
     - [^] And/or decomposition (S)
     - [^] Optional nodes — neither required nor an alternative (S)
+    - [?] Node IDs, #auth (S)  %% but # already means tickets and tags, see SPEC §11
+    - [?] Dependencies across the tree, :#auth,#api (M)
+      - [?] They constrain the status, not when work may start (S)
+      - [?] Effective status: intrinsic, plus what it depends on (S)
+      - [?] Cycles are legal — they mean "finished together" (XS)
+      - [ ] An id with no node behind it is a warning (XS)
+    - [?] XOR — exactly one alternative, not at least one (S)
+    - [?] Node descriptions, shown as a tooltip or pop-up (M)
+      - [?] A short text right at the node (S)  %% indentation already means hierarchy
+      - [?] A long block at the end, addressed by its id (S)
     - [-] A separate storage format for the structure (L)  %% the text is the format
     - [ ] Ticket references #123 (S)
     - [?] Benefit per node, not only cost (M)
@@ -21,9 +31,19 @@
         - [^] Horizontal fan (S)
         - [^] Vertical, transposed (S)
         - [^] Compact (S)
+      - [?] Cross links for dependencies (M)
+        - [?] Visually secondary — the tree carries the message (S)
+        - [?] Highlight what a selected node needs and feeds (S)
     - [^] Cheapest path (M)
       - [^] Cost model, missing size counts as M (S)
       - [^] Metro-map line through the leaves (S)
+      - [?] Count the whole dependency closure (M)
+        - [?] Shared dependencies counted only once (S)
+        - [!] The cheapest alternative is no longer the local one (M)  %% see D34
+          | [?] Search exactly, the trees are small enough (M)
+            - [?] Enumerate the any-of choices (S)
+            - [?] Cost is the size of the union (S)
+          | [ ] Stay greedy, but say so (XS)
     - [^] Export (M)
       - [^] SVG and PNG download (S)
       - [^] PNG to the clipboard (S)
@@ -38,6 +58,9 @@
       - [^] Load a document from ?sourceUrl= (S)
     - [^] Jump between diagram and text (S)
     - [x] Line numbers in the text editor (XS)  %% the warnings name them
+    - [?] Collapsible subtrees (M)
+      - [?] Initial state from the text: > collapses, < re-opens (S)
+      - [?] Fold and unfold in the diagram, independently of the text (S)
     - [ ] Open and save .werkbaum files (S)
     + [^] Show what is new since your last visit (S)
     + [?] A pastel colour per person (S)