feat: add run-batch orchestrator command

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

.claude/commands/run-batch.md

@@ -0,0 +1,155 @@
+Du bist der Batch-Orchestrator. Führe die folgenden Schritte der Reihe nach aus.
+
+Beachte dabei strikt die Regeln aus @rules/batch-orchestration.md
+
+## Schritt 1 — Phase und Tasks erkennen
+
+1. Lies CLAUDE.md und bestimme die aktive Phase und das Arbeitsverzeichnis
+2. Lies die task.md der aktiven Phase
+3. Finde den Arbeitsabschnitt: den ersten Abschnitt mit ### Unterüberschriften und - [ ] Checkboxen
+4. Ignoriere flache Checkbox-Listen ohne Unterüberschriften (das ist die Definition of Done)
+5. Erstelle eine nummerierte Liste aller offenen Tasks (- [ ]) mit:
+   - Nummer
+   - Task-Beschreibung
+   - Gruppenname (### Überschrift)
+   - Output-Pfad (falls im Text erkennbar)
+
+## Schritt 1.5 — Berechtigungen prüfen
+
+Prüfe ob die folgenden Tools ohne Nachfrage verfügbar sind: Read, Write, Edit, Glob, Grep, Agent.
+
+Falls Berechtigungen fehlen, zeige dem User:
+> Für den Batch-Modus werden folgende Berechtigungen benötigt: [Liste]
+> Bitte konfiguriere sie in `.claude/settings.json` oder `.claude/settings.local.json`:
+> ```json
+> { "permissions": { "allow": ["Read", "Write", "Edit", "Glob", "Grep", "Agent"] } }
+> ```
+
+Brich dann ab. Starte den Batch NICHT ohne bestätigte Berechtigungen.
+
+## Schritt 2 — Parameter abfragen
+
+Falls der User beim Aufruf keine Parameter angegeben hat, oder Parameter fehlen, frage interaktiv:
+
+Zeige die Task-Liste aus Schritt 1 und frage:
+
+> Ich sehe N offene Tasks in Phase X:
+> [nummerierte Liste mit Gruppenname]
+>
+> **Welche Tasks?** (alle / Nummern z.B. 1-3 / Gruppenname z.B. wave-3)
+> **Checkpoint-Modus?** (after-each / after-batch:N / at-end)
+
+Warte auf die Antworten des Users.
+
+Zeige dann eine Zusammenfassung des geplanten Batch-Laufs:
+> **Batch-Plan:**
+> - Tasks: [ausgewählte Tasks]
+> - Gruppen: [Gruppenreihenfolge, parallele Tasks markiert]
+> - Checkpoint: [gewählter Modus]
+> - Phase: [aktive Phase]
+>
+> Soll ich starten?
+
+Warte auf Bestätigung.
+
+## Schritt 3 — Gruppen abarbeiten
+
+Arbeite die Gruppen in der Reihenfolge ihrer ### Überschriften ab.
+
+### Für jede Gruppe:
+
+**Context bestimmen:**
+- Basis: rules der aktiven Phase + status.md
+- Phasen-spezifisch: falls Phase-Rules Context definieren (z.B. discovery-waves.md), folge diesen
+- Task-spezifisch: falls der Task (context: datei1, datei2) deklariert, lade diese
+- Fallback: alle existierenden Output-Dateien vorheriger Gruppen im aktuellen Batch
+
+**Tasks dispatchen:**
+- Falls die Gruppe nur einen Task hat: dispatche einen Subagent
+- Falls die Gruppe mehrere Tasks hat: dispatche alle als parallele Subagents
+
+Für jeden Subagent verwende das Agent-Tool mit folgendem Prompt-Muster:
+
+> Du bist ein Subagent im re:struct Framework.
+>
+> **Dein Auftrag:** [Task-Beschreibung aus task.md]
+> **Output-Datei:** [Pfad]
+> **Context-Dateien zum Lesen:** [Liste der Context-Dateien]
+> **Regeln:** Beachte @rules/framework-constraints.md und @rules/language-conventions.md
+>
+> Schreibe dein Ergebnis in die Output-Datei.
+> Gib am Ende eine Zusammenfassung in 2-3 Sätzen zurück (NUR die Zusammenfassung als Return-Value, nicht in die Datei).
+
+**Auf Abschluss warten:**
+- Warte bis alle Subagents der Gruppe fertig sind
+- Sammle die Summaries und eventuelle Fehler
+
+**Fehlerbehandlung:**
+- Falls ein Subagent fehlschlägt: notiere den Fehler, blockiere aber nicht andere parallele Tasks
+- Fehlgeschlagene Tasks werden beim Checkpoint gemeldet
+
+### Checkpoint-Logik
+
+Nach jeder abgeschlossenen Gruppe: prüfe ob ein Checkpoint fällig ist.
+
+**after-each:** Immer Checkpoint nach jeder Gruppe.
+**after-batch:N:** Checkpoint nach jeder N-ten Gruppe. Zähler beginnt bei 1.
+**at-end:** Kein Checkpoint bis alle Gruppen fertig sind.
+
+**Bei einem Checkpoint:**
+
+Zeige dem User:
+> **Checkpoint — Gruppe "[Gruppenname]" abgeschlossen**
+>
+> | Task | Output | Status | Summary |
+> |------|--------|--------|---------|
+> | [Name] | [Dateipfad] | ✅ / ❌ | [2-3 Sätze] |
+>
+> **Befehle:** `weiter` | `stopp` | `zeig mir [datei]`
+
+- Bei `weiter`: nächste Gruppe starten
+- Bei `stopp`: gehe zu Schritt 4 (Konsolidierung)
+- Bei `zeig mir [datei]`: Datei lesen und anzeigen, dann erneut fragen
+
+**Phasen-Checkpoint (immer aktiv):**
+Prüfe nach jeder Gruppe ob alle offenen Tasks der Phase erledigt sind (prüfe die DoD-Sektion).
+Falls ja: STOPP, unabhängig vom Checkpoint-Modus:
+> **Alle Tasks dieser Phase sind abgeschlossen.**
+> Ein Phasenwechsel ist möglich. Nutze `/project:phase-transition` wenn du bereit bist.
+
+Gehe dann zu Schritt 4.
+
+## Schritt 4 — Konsolidierung
+
+Führe die folgenden Updates durch (nur der Orchestrator, nie Subagents):
+
+1. **task.md aktualisieren:**
+   - Markiere erfolgreich abgeschlossene Tasks mit [x]
+   - Fehlgeschlagene Tasks bleiben [ ]
+
+2. **status.md aktualisieren:**
+   - Aktuellen Stand in 2-3 Sätzen
+   - Liste der abgeschlossenen Tasks
+   - Falls Fehler auftraten: dokumentiere sie
+   - Nächste Schritte (verbleibende offene Tasks)
+
+3. **decisions-log.md:**
+   - Falls während des Batch Entscheidungen relevant wurden: Einträge erstellen
+   - Format: siehe docs/templates/decisions-log-entry.md
+
+4. **Phasen-spezifische Shared Artifacts:**
+   - Falls die Phase geteilte Dokumente hat (z.B. capabilities-inventory.md in Discovery):
+     aktualisiere sie mit den konsolidierten Ergebnissen aus den Subagent-Summaries
+
+## Schritt 5 — Commit-Vorschlag
+
+Zeige dem User:
+> **Batch abgeschlossen.** Zusammenfassung:
+> - [N] Tasks erfolgreich, [M] fehlgeschlagen
+> - Aktualisiert: task.md, status.md [, decisions-log.md] [, weitere]
+> - Output-Dateien: [Liste der neuen Dateien]
+>
+> Soll ich einen Commit erstellen?
+
+Falls ja: erstelle einen Commit mit einer Nachricht die den Batch beschreibt,
+z.B. `feat: complete Wave 2 entry-points analysis`