@the-bearded-bear/claude-craft 8.23.3 → 8.26.0-next.2a54921

package/Dev/i18n/de/Workflow/commands/init.md

@@ -120,7 +120,7 @@ Basierend auf dem Track den Workflow anzeigen:
 ║                                                           ║
 ║ Befehle:                                                  ║
 ║ • /qa:tdd    - Fix mit TDD                    ║
-║ • /project:add-task      - Arbeit verfolgen               ║
+║ • /project:backlog add task      - Arbeit verfolgen               ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -138,14 +138,16 @@ Basierend auf dem Track den Workflow anzeigen:
 ║   Hier starten                                            ║
 ║                                                           ║
 ║ Phase 1 - Planung:                                        ║
-║ • /project:generate-prd    - PRD erstellen/aktualisieren  ║
-║ • /project:generate-backlog - User Stories erstellen      ║
+║ • /workflow:plan --only=prd    - PRD erstellen/aktualisieren  ║
+║ • /workflow:plan --only=backlog - User Stories erstellen      ║
 ║                                                           ║
 ║ Phase 2 - Design:                                         ║
-║ • /project:generate-tech-spec - Technisches Design        ║
+║ • /workflow:design - Technisches Design        ║
 ║                                                           ║
 ║ Phase 3 - Implementierung:                                ║
-║ • /sprint:dev      - TDD/BDD-Entwicklung          ║
+║ • /workflow:start N      - Sprint-Setup           ║
+║ • /workflow:implement    - TDD/BDD-Entwicklung    ║
+║ • /workflow:auto-sprint N - Sprint Ende-zu-Ende   ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -163,18 +165,20 @@ Basierend auf dem Track den Workflow anzeigen:
 ║   Hier starten                                            ║
 ║                                                           ║
 ║ Phase 1 - Analyse:                                        ║
-║ • /workflow:analyze        - Recherche & Exploration      ║
+║ • /workflow:plan --research        - Recherche & Exploration      ║
 ║                                                           ║
 ║ Phase 2 - Planung:                                        ║
-║ • /project:generate-prd    - Vollständiges PRD            ║
-║ • /project:generate-backlog - Vollständiges Backlog       ║
+║ • /workflow:plan --only=prd    - Vollständiges PRD            ║
+║ • /workflow:plan --only=backlog - Vollständiges Backlog       ║
 ║                                                           ║
 ║ Phase 3 - Design:                                         ║
-║ • /project:generate-tech-spec - Vollständiges Tech Spec   ║
+║ • /workflow:design - Vollständiges Tech Spec   ║
 ║ • /common:architecture-decision - ADRs                    ║
 ║                                                           ║
 ║ Phase 4 - Implementierung:                                ║
-║ • /sprint:dev      - Sprint-weise Entwicklung     ║
+║ • /workflow:start N      - Sprint-Setup           ║
+║ • /workflow:implement    - TDD/BDD-Entwicklung    ║
+║ • /workflow:auto-sprint N - Sprint Ende-zu-Ende   ║
 ║                                                           ║
 ╚══════════════════════════════════════════════════════════╝
 ```
@@ -209,7 +213,27 @@ phases:
     status: pending
 
 next_action: "Generate or update PRD"
-next_command: "/project:generate-prd"
+next_command: "/workflow:plan --only=prd"
+```
+
+BMAD-Status-Skeleton erstellen (Single Source of Truth für den Story-Status, gelesen von `/gate:*`, `/sprint:*`, `/workflow:auto-sprint` und dem Kanban). Überspringen, falls `.bmad/sprint-status.yaml` bereits existiert; `/workflow:start` füllt `metadata` und `stories` später:
+
+```yaml
+# .bmad/sprint-status.yaml
+version: "1.0"
+metadata:
+  sprint_id: "sprint-0"
+  name: "Nicht gestartet"
+  start_date: ""
+  end_date: ""
+  goal: ""
+stories: {}
+routing:
+  auto_transitions:
+    enabled: true
+    run_on_session_start: false
+    run_on_task_complete: true
+    rules: []
 ```
 
 ### Schritt 6: Nächste Aktion anzeigen
@@ -220,6 +244,7 @@ next_command: "/project:generate-prd"
 ╠══════════════════════════════════════════════════════════╣
 ║ Workflow initialisiert: STANDARD Track                    ║
 ║ Statusdatei: project-management/workflow-status.yaml      ║
+║ Sprint-Status: .bmad/sprint-status.yaml                   ║
 ║                                                           ║
 ║ ─────────────────────────────────────────────────────────║
 ║ NÄCHSTER SCHRITT: Planungsphase                           ║
@@ -228,8 +253,8 @@ next_command: "/project:generate-prd"
 ║ Starten mit: /workflow:plan                               ║
 ║                                                           ║
 ║ Oder direkt zu bestimmten Aufgaben:                       ║
-║ • /project:generate-prd     - Anforderungsdokument erst.  ║
-║ • /project:generate-backlog - User Stories erstellen      ║
+║ • /workflow:plan --only=prd     - Anforderungsdokument erst.  ║
+║ • /workflow:plan --only=backlog - User Stories erstellen      ║
 ║                                                           ║
 ║ Fortschritt jederzeit prüfen: /workflow:status            ║
 ╚══════════════════════════════════════════════════════════╝
@@ -255,4 +280,7 @@ next_command: "/project:generate-prd"
 - `/workflow:plan` - Planungsphase starten
 - `/workflow:design` - Designphase starten
 - `/workflow:implement` - Implementierungsphase starten
-- `/workflow:analyze` - Analysephase starten (nur Enterprise)
+- `/workflow:auto-sprint` - Einen ganzen Sprint Ende-zu-Ende ausführen (Start → Merge)
+- `/workflow:plan --research` - Analysephase starten (nur Enterprise)
+
+> Unsicher, welchen Weg Sie wählen sollen? Siehe die Entscheidungsseite: https://github.com/TheBeardedBearSAS/claude-craft/blob/main/docs/guides/de/11-which-path.md

package/Dev/i18n/de/Workflow/commands/plan.md

@@ -1,7 +1,14 @@
 ---
 name: workflow-plan
-description: Die Planungsphase durchführen - PRD-Erstellung, Personas und Backlog-Generierung
+description: "Planungsphase ausführen - Recherche (--research), PRD (--only=prd) und SCRUM-Backlog (--only=backlog)"
+argument-hint: "[--research] [--only=prd|backlog] [--continue]"
 arguments:
+  - name: research
+    description: "Zuerst den Recherche-Schritt ausführen (früheres /workflow:plan --research): Domäne, Markt, technische Recherche, Constraints, Risiken"
+    required: false
+  - name: only
+    description: "Nur einen Schritt ausführen: prd (PRD + Personas) oder backlog (Personas, DoD, Epics, User Stories, Sprints)"
+    required: false
   - name: continue
     description: Dort fortfahren, wo aufgehört wurde
     required: false
@@ -9,221 +16,201 @@ arguments:
 
 # /workflow:plan
 
-## Mission
+## Auftrag
+
+Die Planungsphase des Entwicklungs-Workflows ausführen: optionale Recherche, Product Requirements Document (PRD), Personas und SCRUM-Backlog (Epics, User Stories, Sprint-Ordner). Dieser Befehl enthält die gesamte Generierungslogik; es gibt keinen separaten PRD- oder Backlog-Generator mehr, der aufgerufen werden müsste.
+
+## Usage
+
+| Aufruf | Was er tut | Ersetzt |
+|--------|------------|---------|
+| `/workflow:plan` | Vollständige Phase: PRD, dann Backlog (mit `--research` beginnt sie mit der Recherche) | - |
+| `/workflow:plan --research` | Recherche, Exploration, Constraints und Risiken vor dem PRD. Schreibt `project-management/analysis/` | `/workflow:plan --research` |
+| `/workflow:plan --only=prd` | Nur PRD + Personas. Schreibt `project-management/prd.md` | `/workflow:plan --only=prd` |
+| `/workflow:plan --only=backlog` | Nur Backlog: liest `project-management/prd.md` (+ `project-management/tech-spec.md`, falls vorhanden), schreibt Personas, DoD, Epics, User Stories mit `**Implements**`, Sprint-Ordner `sprint-{N}-{slug}` und registriert die Stories in `.bmad/sprint-status.yaml` mit dem Status `backlog` | `/workflow:plan --only=backlog` |
+| `/workflow:plan --continue` | Einen unterbrochenen Lauf fortsetzen | - |
 
-Die Planungsphase des Entwicklungs-Workflows durchführen. Diese Phase konzentriert sich auf die Erstellung des Product Requirements Document, die Definition von Personas und die Generierung des initialen Product Backlogs.
+`--research` lässt sich mit `--only=prd` kombinieren (Recherche, dann PRD).
+
+## Kanonische Reihenfolge
+
+Die Dokumente entstehen in dieser Reihenfolge: **PRD, dann Tech Spec, dann Backlog, dann Sprint**.
+
+- **Quick-Track**: `/workflow:plan` (ohne Option) erzeugt PRD + Backlog in einem Durchgang.
+- **Standard / Enterprise (empfohlen)**: `/workflow:plan --only=prd`, dann `/workflow:design`, dann `/workflow:plan --only=backlog`. Das Backlog liest dann `project-management/prd.md` und `project-management/tech-spec.md`: Die Stories tragen die reale Architektur, und `**Implements**` verweist auf die `FR-xxx` des PRD.
+- **Enterprise**: mit `/workflow:plan --research --only=prd` beginnen.
+
+Ohne PRD greift `--only=backlog` auf die Spezifikationen in `./docs/` zurück (ARCHITECTURE_TECHNIQUE*.md, CAHIER_DES_CHARGES*.md oder jede andere Spezifikationsdatei) und warnt, dass die Rückverfolgbarkeit eingeschränkt ist.
 
 ## Wann verwenden
 
-- **Standard**- und **Enterprise**-Tracks
-- Nach `/workflow:init` (oder `/workflow:analyze` für Enterprise)
-- Beim Start der Feature-Planung
+- Tracks **Standard** und **Enterprise**, nach `/workflow:init`
+- Zu Beginn der Feature-Planung oder wenn PRD oder Backlog neu generiert werden müssen
 
-## Plan-Modus
+## Plan Mode
 
-> **Der Plan-Modus wird empfohlen.** Claude aktiviert den Plan-Modus, um den Ansatz zu strukturieren, Abhängigkeiten zu identifizieren und eine Generierungsstrategie vorzustellen, bevor Artefakte erstellt werden.
+> **Der Plan Mode ist verpflichtend.** Claude aktiviert den Plan Mode, um den Ansatz zu strukturieren, Abhängigkeiten zu erkennen und eine Generierungsstrategie vorzustellen, bevor Artefakte erstellt werden.
 
 ## Workflow
 
-### Schritt 1: Planungs-Setup
+### Schritt 1: Vorbereitung und vorhandene Artefakte
 
-```
-╔══════════════════════════════════════════════════════════╗
-║             PLANUNGSPHASE - START                         ║
-╠══════════════════════════════════════════════════════════╣
-║ Track: Standard                                           ║
-║ Phase: 2 von 4 - Planung                                  ║
-║                                                           ║
-║ Ziele:                                                    ║
-║ • Product Requirements Document erstellen/aktualisieren   ║
-║ • Benutzer-Personas definieren                            ║
-║ • Product Backlog mit priorisierten User Stories erstellen ║
-║ • Erfolgsmetriken und KPIs festlegen                      ║
-╚══════════════════════════════════════════════════════════╝
-```
+Track und Phase anzeigen (Planung = Phase 2 von 4), dann `project-management/` prüfen: `prd.md`, `personas.md`, `backlog/`, `analysis/` (constraints.md, research-summary.md). Vorhandene Dateien werden nie stillschweigend überschrieben: nachfragen, ob aktualisiert, zusammengeführt oder übersprungen werden soll.
 
-### Schritt 2: Vorhandene Artefakte prüfen
+### Schritt 2 (`--research`): Recherchephase
 
-```
-╔══════════════════════════════════════════════════════════╗
-║              PRÜFUNG VORHANDENER ARTEFAKTE               ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ Prüfe project-management/ ...                             ║
-║                                                           ║
-║ PRD:                                                      ║
-║ ├── ❌ prd.md                    Nicht gefunden           ║
-║                                                           ║
-║ Personas:                                                 ║
-║ ├── ❌ personas.md               Nicht gefunden           ║
-║                                                           ║
-║ Backlog:                                                  ║
-║ ├── ❌ backlog/                  Nicht gefunden           ║
-║                                                           ║
-║ Analyse (Enterprise):                                     ║
-║ ├── ✅ analysis/constraints.md   Verfügbar                ║
-║ └── ✅ analysis/research.md      Verfügbar                ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
-```
+Früheres `/workflow:plan --research`. Recherche, Exploration und Constraints vor dem PRD.
+
+**Geführte Fragen**
+
+| Bereich | Fragen |
+|---------|--------|
+| Domäne | Welches Problem? Welche Stakeholder? Business-Treiber? Wie sieht Erfolg aus? |
+| Markt | Bestehende Lösungen? Wettbewerber? Best Practices der Branche? Neue Trends? |
+| Technik | Mögliche Technologien? Integrationen? Skalierbarkeit? Sicherheit / Compliance? |
 
-### Schritt 3: Planungsaufgaben
+Ist der MCP Context7 konfiguriert, ihn für aktuelle technische Dokumentation nutzen (`/common:research-context7` für tiefgehende Recherche).
 
-Planungsaufgaben in Reihenfolge ausführen:
+**Constraints**: technische (bestehendes Backend, Datenbank), geschäftliche (Budget, Zeitplan, Abwärtskompatibilität), regulatorische (DSGVO, PCI DSS) und Ressourcen-Constraints (Teamgröße, kein DevOps) dokumentieren.
+
+**Risiken und Chancen**: Risikotabelle (Risiko, Auswirkung, Wahrscheinlichkeit, Gegenmaßnahme) und Chancen.
+
+**Artefakte**
 
 ```
-╔══════════════════════════════════════════════════════════╗
-║               PLANUNGSAUFGABEN                            ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ □ Aufgabe 1: PRD erstellen                                ║
-║   Befehl: /project:generate-prd                           ║
-║   Ausgabe: project-management/prd.md                      ║
-║                                                           ║
-║ □ Aufgabe 2: Personas definieren                          ║
-║   (In PRD-Generierung enthalten)                          ║
-║   Ausgabe: project-management/personas.md                 ║
-║                                                           ║
-║ □ Aufgabe 3: Backlog erstellen                            ║
-║   Befehl: /project:generate-backlog                       ║
-║   Ausgabe: project-management/backlog/                    ║
-║                                                           ║
-║ □ Aufgabe 4: Backlog validieren                           ║
-║   Befehl: /gate:validate-backlog                       ║
-║   Stellt SCRUM-Konformität sicher                         ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
+project-management/analysis/
+├── research-summary.md      # Wichtigste Erkenntnisse
+├── constraints.md           # Alle identifizierten Constraints
+├── risks-opportunities.md   # Risikoregister & Chancen
+└── technical-options.md     # Technologiebewertung
 ```
 
-### Schritt 4: PRD-Generierung ausführen
+Agenten: **research-assistant** (technische Recherche), **product-owner** (Business-Kontext). Danach: PRD (die Analyse fließt ein).
 
-Den PRD-Generierungsbefehl aufrufen:
+### Schritt 3 (`--only=prd` oder vollständiger Lauf): PRD-Generierung
 
-```
-Starte /project:generate-prd...
+Schreibt `project-management/prd.md` und `project-management/personas.md`.
 
-[PRD-Generierungsworkflow läuft]
+**Phase 1 - Kontext-Erkundung**: `README.md` lesen, `./docs/` nach Spezifikationen durchsuchen, `project-management/personas.md` und `project-management/analysis/` lesen, falls vorhanden, den Code auf den Tech-Stack analysieren, die Konversation durchsehen. Gefundene Quellen auflisten.
 
-✅ PRD erstellt: project-management/prd.md
-✅ Personas extrahiert: project-management/personas.md
-```
+**Phase 2 - Interaktive Klärung** (nur fragen, was fehlt):
+
+| Thema | Fragen |
+|-------|--------|
+| Problem und Chance | Welches Problem? Wer leidet am meisten? Kosten des Nichtstuns? Geschäftschance? |
+| Zielnutzer | Hauptnutzer (Rolle, Profil)? Ziele? Frustrationen mit aktuellen Lösungen? Sekundäre Nutzer? |
+| Ziele und Metriken | Geschäftsziele? KPIs mit Zielwerten und Zeitrahmen? Wie sieht MVP-Erfolg aus? |
+| Umfang und Constraints | Muss-Features (P0)? Ausdrücklich außerhalb des Umfangs? Technische, Budget-, Zeit-, Compliance-Constraints? |
 
-### Schritt 5: Backlog-Generierung ausführen
+**Phase 3 - Generierung**: das PRD-Template laden (`.claude/templates/project/prd.md`, falls vorhanden), jeden Abschnitt füllen, detaillierte Personas erstellen, Anforderungen als P0/P1/P2 mit stabilen IDs `FR-001`, `FR-002`... (funktional) und `NFR-001`... (nicht funktional) organisieren, damit Stories darauf zurückverweisen können, Risiken aus Constraints und Abhängigkeiten ableiten.
 
-Nach Abschluss des PRD:
+**Phase 4 - Review und Iteration**: eine Abschnitts-Checkliste anzeigen (Executive Summary, Problem Statement, Goals & Metrics, Target Users, Functional Requirements, Non-Functional Requirements, Scope & Constraints, Timeline, Risks & Mitigations), unvollständige Abschnitte markieren, dann anbieten, einen Abschnitt auszubauen, Personas zu detaillieren oder die Priorisierung anzupassen.
 
 ```
-Starte /project:generate-backlog...
+project-management/
+├── prd.md                    # Generiertes PRD (FR-xxx / NFR-xxx)
+├── personas.md               # Extrahierte/erstellte Personas
+└── analysis/discovery-notes.md
+```
 
-Verwende PRD als Eingabe:
-• 3 Personas identifiziert
-• 12 funktionale Anforderungen extrahiert
-• 8 nicht-funktionale Anforderungen notiert
+### Schritt 4 (`--only=backlog` oder vollständiger Lauf): Backlog-Generierung
 
-Generiere Backlog-Struktur...
+Sie agieren als erfahrener Product Owner und Scrum Master. Das Backlog muss die 3 Scrum-Säulen (Transparenz, Inspektion, Anpassung) und die agilen Werte respektieren.
 
-[Backlog-Generierungsworkflow läuft]
+**Eingaben, nach Priorität**
 
-✅ Backlog erstellt mit:
-   • 4 EPICs
-   • 18 User Stories
-   • Sprint 1 geplant (Walking Skeleton)
-```
+1. `project-management/prd.md`: Hauptquelle. Seine `FR-xxx`-IDs speisen das Feld `**Implements**` jeder User Story.
+2. `project-management/tech-spec.md`, falls vorhanden (siehe `/workflow:design`): Architektur, Entitäten, Endpunkte für die technischen Notizen.
+3. Fallback ohne PRD: Spezifikationen in `./docs/`.
 
-### Schritt 6: Validierung
+**Vertical Slicing (verpflichtend)**: Jede User Story durchläuft alle Schichten des Projekt-Stacks (UI, API, Persistenz). Keine Story nur für das Backend oder nur für das Frontend. Den Stack aus der Tech Spec oder dem Code erkennen und DoD sowie technische Kriterien entsprechend anpassen.
 
-Backlog-Validierung ausführen:
+**Erzeugte Struktur**
 
 ```
-╔══════════════════════════════════════════════════════════╗
-║              BACKLOG-VALIDIERUNG                          ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ INVEST-Kriterien-Prüfung:                                 ║
-║ ├── Independent:    18/18 ✅                              ║
-║ ├── Negotiable:     18/18 ✅                              ║
-║ ├── Valuable:       18/18 ✅                              ║
-║ ├── Estimable:      18/18 ✅                              ║
-║ ├── Sized (≤8Pkt.): 16/18 ⚠️  (2 Stories müssen geteilt w.)║
-║ └── Testable:       18/18 ✅                              ║
-║                                                           ║
-║ 3C-Kriterien-Prüfung:                                     ║
-║ ├── Card:           18/18 ✅                              ║
-║ ├── Conversation:   18/18 ✅                              ║
-║ └── Confirmation:   18/18 ✅                              ║
-║                                                           ║
-║ Abnahmekriterien (Gherkin):                               ║
-║ └── Gültiges Format: 18/18 ✅                             ║
-║                                                           ║
-║ WARNUNGEN:                                                ║
-║ • US-007: 13 Punkte - Aufteilung erwägen                  ║
-║ • US-012: 21 Punkte - muss aufgeteilt werden              ║
-║                                                           ║
-╚══════════════════════════════════════════════════════════╝
+project-management/
+├── README.md                 # Überblick, Personas, Epics, Metriken, Roadmap
+├── personas.md
+├── definition-of-done.md
+├── dependencies-matrix.md
+├── backlog/
+│   ├── epics/EPIC-XXX-name.md
+│   └── user-stories/US-XXX-name.md
+└── sprints/sprint-{N}-{slug}/   # z. B. sprint-1-walking_skeleton
+    ├── sprint-goal.md
+    └── sprint-dependencies.md
 ```
 
-### Schritt 7: Phasenabschluss
+**personas.md**: mindestens 3 Personas (IDs P-001, P-002...; 1 primäre, 2+ sekundäre). Jede mit: Identität, repräsentatives Zitat, Kontext, 3 Ziele, mindestens 3 Frustrationen, Motivationen, Verhalten, Nutzungsszenarien (Kontext, Bedarf, Aktion, Ergebnis), Entscheidungskriterien. Eine Personas/Features-Matrix (3 Sterne kritisch, 2 wichtig, 1 nützlich) und Anti-Personas ergänzen.
 
-```
-╔══════════════════════════════════════════════════════════╗
-║             PLANUNGSPHASE ABGESCHLOSSEN                   ║
-╠══════════════════════════════════════════════════════════╣
-║                                                           ║
-║ Erstellte Artefakte:                                      ║
-║ ✅ prd.md              Product Requirements Document      ║
-║ ✅ personas.md         3 Benutzer-Personas                ║
-║ ✅ backlog/            Vollständiges SCRUM-Backlog        ║
-║    ├── epics/          4 EPICs                            ║
-║    └── user-stories/   18 User Stories                    ║
-║                                                           ║
-║ Zusammenfassung:                                          ║
-║ • Gesamte Story Points: 89                                ║
-║ • Sprint 1 Umfang: 21 Punkte (Walking Skeleton)          ║
-║ • Geschätzte Sprints: 4-5                                 ║
-║                                                           ║
-║ ─────────────────────────────────────────────────────────║
-║ NÄCHSTE PHASE: Design (Lösungsfindung)                    ║
-║ Befehl: /workflow:design                                  ║
-║ ─────────────────────────────────────────────────────────║
-║                                                           ║
-║ Die technische Spezifikation basiert auf den              ║
-║ PRD-Anforderungen.                                        ║
-╚══════════════════════════════════════════════════════════╝
-```
+**definition-of-done.md**: Code (genehmigtes Review, Konventionen, SOLID), Tests (80 % Unit, Integration, E2E, grüne CI), Kriterien je Schicht (UI, API, Parität zwischen Clients), Dokumentation, Qualität (statische Analyse auf höchster Stufe, API unter 200 ms), Deployment (Migrationen, Staging, PO-Abnahme).
 
-## Beteiligte Agenten
+**Epics** (`EPIC-XXX-name.md`): Beschreibung (Geschäftswert), Tabelle der zugehörigen Stories (ID, Titel, Punkte, Priorität, hängt ab von), Abhängigkeiten (Voraussetzungen und Abhängige), Minimum Marketable Feature (MMF) mit enthaltenen Stories, Schätzung (Größe S/M/L/XL, geschätzte Sprints).
 
-- **product-owner**: PRD-Erstellung, Persona-Definition, Priorisierung
-- **tech-lead**: Technische Machbarkeitsprüfung, Schätzungsberatung
+**User Stories** (`US-XXX-name.md`), ausgehend von `.claude/templates/project/user-story.md`:
 
-## Ausgabedateien
+- **INVEST** (verpflichtend): Independent, Negotiable, Valuable, Estimable, Sized (max. 8 Punkte), Testable.
+- **3 Cs** (verpflichtend): Card („Als [P-XXX]... möchte ich... damit..."), Conversation (offene Fragen), Confirmation (Akzeptanzkriterien).
+- **Akzeptanzkriterien** in SMART-Gherkin: 1 Nominalszenario, mindestens 2 alternative, mindestens 2 Fehlerszenarien.
+- Eltern-Epic, zugehörige Persona, Kriterien je Schicht, technische Notizen, Schätzung (Fibonacci-Punkte, MoSCoW), Abhängigkeiten (blockierend und blockiert), zugewiesener Sprint.
+- **Rückverfolgbarkeit**: den Abschnitt `## Traceability` mit `**Implements**: {FR-001, FR-003}` füllen (IDs der PRD-Anforderungen, die die Story liefert). Eine Story ohne `FR-xxx` wird markiert.
 
-| Datei | Zweck |
-|-------|-------|
-| `prd.md` | Product Requirements Document |
-| `personas.md` | Benutzer-Persona-Definitionen |
-| `backlog/epics/` | EPIC-Definitionen |
-| `backlog/user-stories/` | User-Story-Dateien |
-| `sprints/sprint-001/` | Erste Sprint-Struktur |
+**dependencies-matrix.md**: Mermaid-Graph zwischen Epics, Abhängigkeitstabelle, kritischer Pfad, Abhängigkeiten zwischen Stories.
 
-## Fortsetzen-Option
+**Sprints** (`sprint-{N}-{slug}/`): `sprint-goal.md` (Ziel in einem Satz, Zeremonien, ausgewählte Stories und Gesamtpunkte, Ausführungsreihenfolge, Mermaid-Abhängigkeitsgraph, auslieferbares Inkrement, Retrospektiven-Leitsatz und Starfish-Format) und `sprint-dependencies.md`.
 
-Bei Unterbrechung `--continue` verwenden, um fortzufahren:
+**Registrierung in `.bmad/sprint-status.yaml`**: für jede Story einen Eintrag mit `status: backlog` hinzufügen (Schema: `Project/templates/sprint-status.yaml.template`): `title`, `story_points`, `epic_id`, `tasks` (total 0), `acceptance_criteria.total` und einen `history`-Eintrag „Story created". `.bmad/sprint-status.yaml` ist die einzige Wahrheitsquelle für den Status; Markdown-Dateien enthalten nur Inhalt, nie einen Status. Die Datei aus dem Template erstellen, falls sie fehlt, vorhandene Einträge nie überschreiben.
 
-```bash
-/workflow:plan --continue
+**Scrum-Regeln**: 2-Wochen-Sprints, Velocity 20-40 Punkte, max. 8 Punkte pro Story (sonst teilen), Fibonacci-Skala (1, 2, 3, 5, 8, 13, 21), Sprint 1 = Walking Skeleton (Infrastruktur + ein vollständiger Ablauf).
 
-# Erkennt:
-# ✅ PRD abgeschlossen
-# ⏳ Backlog in Bearbeitung (12/18 Stories)
-# → Fährt ab Story 13 fort
-```
+### Schritt 5: Validierung
+
+`/gate:check backlog` ausführen (oder inline prüfen):
+
+| Prüfung | Kriterien |
+|---------|-----------|
+| INVEST | Alle 6 Kriterien je Story; max. 8 Punkte (13+ muss geteilt werden) |
+| 3 Cs | Card, Conversation, Confirmation vorhanden |
+| Gherkin | Gültiges Format; 1 nominal + 2 alternativ + 2 Fehler |
+| Personas | Mindestens 3, Matrix vorhanden |
+| Epics | MMF identifiziert, Mermaid-Abhängigkeiten |
+| Sprints | Sprint 1 = Walking Skeleton, Ziel in einem Satz, Abhängigkeitsgraph |
+| Rückverfolgbarkeit | Jede Story hat `**Implements**`; jedes P0-`FR-xxx` ist von mindestens einer Story abgedeckt |
+| Status | Jede Story ist in `.bmad/sprint-status.yaml` als `backlog` registriert |
+
+Warnungen melden (zum Beispiel „US-012: 21 Punkte - muss geteilt werden") und vor Abschluss beheben.
+
+### Schritt 6: Phasenabschluss
+
+Die Artefakte zusammenfassen (PRD, Personas, Epics, Anzahl Stories, Gesamtpunkte, Umfang von Sprint 1, geschätzte Sprints) und den nächsten Schritt empfehlen: nach `--only=prd` `/workflow:design`, dann `/workflow:plan --only=backlog`; nach dem Backlog `/workflow:design` (falls noch keine Tech Spec existiert) oder `/workflow:start 1`.
+
+## Beteiligte Agenten
+
+- **product-owner**: PRD-Erstellung, Personas, Priorisierung, Backlog
+- **tech-lead**: Prüfung der technischen Machbarkeit, Schätzungshilfe
+- **research-assistant**: Recherche (`--research`)
+
+## Ausgabedateien
+
+| Datei | Zweck | Modus |
+|-------|-------|-------|
+| `analysis/*.md` | Recherche, Constraints, Risiken | `--research` |
+| `prd.md`, `personas.md` | PRD mit `FR-xxx` / `NFR-xxx`, Personas | `--only=prd` |
+| `definition-of-done.md`, `dependencies-matrix.md`, `README.md` | Rahmen des Backlogs | `--only=backlog` |
+| `backlog/epics/`, `backlog/user-stories/` | Epics und Stories (`**Implements**`) | `--only=backlog` |
+| `sprints/sprint-{N}-{slug}/` | Sprint-Ordner | `--only=backlog` |
+| `.bmad/sprint-status.yaml` | Als `backlog` registrierte Stories | `--only=backlog` |
+
+## Fortsetzungsoption
+
+Bei Unterbrechung erkennt `/workflow:plan --continue`, was vorhanden ist (PRD fertig, Backlog bei 12/18 Stories), und macht beim nächsten fehlenden Element weiter.
 
 ## Verwandte Befehle
 
 - `/workflow:init` - Workflow initialisieren
-- `/workflow:analyze` - Vorherige Phase (Enterprise)
-- `/workflow:design` - Nächste Phase
+- `/workflow:design` - Tech Spec (zwischen PRD und Backlog)
+- `/workflow:start` - Einen Sprint aus dem Backlog starten
 - `/workflow:status` - Fortschritt prüfen
-- `/project:generate-prd` - Direkte PRD-Generierung
-- `/project:generate-backlog` - Direkte Backlog-Generierung
+- `/project:backlog` - Stories danach hinzufügen, auflisten, bearbeiten und verschieben
+- `/gate:check` - Das Backlog validieren
+- `/common:research-context7` - Tiefgehende Recherche mit Context7 MCP

package/Dev/i18n/de/Workflow/commands/retro.md

@@ -299,7 +299,7 @@ Zitate:
 ║    Nächsten Sprint starten                               ║
 ║                                                          ║
 ║  Wenn das Projekt abgeschlossen ist:                     ║
-║  → /common:release-checklist                             ║
+║  → /gate:check release                             ║
 ║    Release vorbereiten                                   ║
 ║  → /common:generate-changelog                            ║
 ║    Changelog generieren                                  ║

package/Dev/i18n/de/Workflow/commands/review.md

@@ -310,7 +310,7 @@ Gesamtdauer: 2h
 ║                                                          ║
 ║  Siehe auch:                                             ║
 ║  • /workflow:status  — Gesamtfortschritt prüfen          ║
-║  • /sprint:status    — Sprint-Metriken anzeigen          ║
+║  • /workflow:status    — Sprint-Metriken anzeigen          ║
 ║                                                          ║
 ╚══════════════════════════════════════════════════════════╝
 ```