bmad-method 6.0.0-alpha.22 → 6.0.0-alpha.23

package/src/modules/bmb/workflows/workflow/steps-c/step-09-build-next-step.md

@@ -0,0 +1,350 @@
+---
+name: 'step-09-build-next-step'
+description: 'Build the next step in the workflow sequence - repeatable until all steps are built'
+
+nextStepFile: './step-09-build-next-step.md'  # Self-referencing - repeats until complete
+targetWorkflowPath: '{bmb_creations_output_folder}/workflows/{new_workflow_name}'
+workflowPlanFile: '{targetWorkflowPath}/workflow-plan-{new_workflow_name}.md'
+stepTemplate: '../templates/step-template.md'
+stepTypePatterns: '../data/step-type-patterns.md'
+frontmatterStandards: '../data/frontmatter-standards.md'
+menuHandlingStandards: '../data/menu-handling-standards.md'
+outputFormatStandards: '../data/output-format-standards.md'
+csvDataFileStandards: '../data/csv-data-file-standards.md'
+subprocessPatterns: '../data/subprocess-optimization-patterns.md'
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 9: Build Next Step (Repeatable)
+
+## STEP GOAL:
+
+To build the next step file in the workflow sequence based on the approved design. This step is REPEATABLE - continue running it until all steps from the design have been built.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a workflow architect and systems designer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring implementation expertise and best practices
+- ✅ User brings their specific requirements and design approvals
+
+### Step-Specific Rules:
+
+- 🎯 Load the plan to determine WHICH step to build next
+- 🚫 FORBIDDEN to skip steps or build out of order
+- 💬 Each step is built collaboratively based on approved design
+- 🚪 This step REPEATS until all workflow steps are built
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Always check what's been built, then build the next one
+- 💾 Document each step in the plan as it's built
+- 📖 Update frontmatter stepsCompleted to add each step when completed
+- 🚫 Don't proceed to completion until ALL workflow steps are built
+
+## CONTEXT BOUNDARIES:
+
+- Approved design from step 6 specifies all steps
+- The plan tracks which steps have been built
+- Load step type patterns to understand each step's structure
+- This step continues until the design is fully implemented
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Check Build Status
+
+Load {workflowPlanFile} and check:
+
+**What steps have been built so far?**
+- Step 01: Always built in step-08
+- Subsequent steps: Track in plan
+
+**What is the NEXT step to build?**
+
+From the design in the plan, identify:
+- Step number and name
+- Step type (Middle/Standard, Middle/Simple, Branch, Validation, Final Polish, Final)
+- This step's goal and purpose
+
+Confirm: "The next step to build is **step-{N}-{name}** which is a [step type]. Its goal is: [goal from design]. Ready to proceed?"
+
+### 2. Load Standards for This Step Type
+
+**Load {stepTypePatterns}** and find the pattern for this step type:
+- Middle Step (Standard) - A/P/C menu, collaborative content
+- Middle Step (Simple) - C only menu, no A/P
+- Branch Step - Custom menu with routing logic
+- Validation Sequence - Auto-proceed through checks
+- Final Polish Step - Optimizes document built section-by-section
+- Final Step - Completion, no next step
+
+**Load {frontmatterStandards}** for variable rules.
+
+**Load {menuHandlingStandards}** for menu patterns.
+
+**Load {outputFormatStandards}** if this step outputs to document.
+
+### 2a. Apply Subprocess Optimization (If Designed for This Step)
+
+**Check the approved design from step 6:** Was subprocess optimization identified for this step?
+
+**If YES, apply the appropriate pattern(s):**
+
+Load {subprocessPatterns} and implement the subprocess optimization for this step:
+
+1. **Identify the pattern(s) from the design for this step:**
+   - Pattern 1: Single subprocess for grep/regex across many files
+   - Pattern 2: Per-file subprocess for deep analysis
+   - Pattern 3: Subprocess for data file operations
+   - Pattern 4: Parallel execution of independent operations
+
+2. **Add subprocess-specific Step-Specific Rules to this step:**
+   ```markdown
+   ### Step-Specific Rules:
+   - 🎯 [Brief description of which pattern applies]
+   - 💬 Subprocess must either update report OR return findings to parent
+   - 🚫 DO NOT BE LAZY - [specific guidance if Pattern 2]
+   - ⚙️ TOOL/SUBPROCESS FALLBACK: If subprocess unavailable, perform in main thread
+   ```
+
+3. **Implement subprocess directives in the MANDATORY SEQUENCE:**
+   - Use appropriate subprocess language:
+     - Pattern 1: "Launch a subprocess that runs [command] across all files, returns [results]"
+     - Pattern 2: "DO NOT BE LAZY - For EACH file, launch a subprocess that [analyzes], returns [findings]"
+     - Pattern 3: "Launch a subprocess that loads [data file], performs [operation], returns [results]"
+     - Pattern 4: "Launch subprocesses in parallel that [operations], aggregate results"
+
+4. **Ensure return patterns are specified:**
+   - Subprocess updates report directly OR
+   - Subprocess returns structured findings to parent for aggregation
+
+5. **Verify graceful fallback is documented:**
+   - Universal fallback rule in Universal Rules
+   - Step-specific fallback in Step-Specific Rules
+   - Clear instructions for LLMs without subprocess capability
+
+**If NO subprocess optimization was designed for this step:**
+
+Skip this section and proceed to build the step file.
+
+### 3. Build the Step File
+
+**Load {stepTemplate}** for base structure.
+
+Create `steps-c/step-{N}-{name}.md` with:
+
+**Frontmatter:**
+```yaml
+---
+name: 'step-{N}-{name}'
+description: '[what this step does]'
+
+# File references (ONLY variables used in this step)
+nextStepFile: './step-{N+1}-[next-name].md'  # Omit for final step
+outputFile: '{output_folder}/[output-name].md'
+templateFile: '../templates/[template-name].md'  # If applicable
+
+# Data files (if this step needs them)
+someData: '../data/[data-file].csv'  # If applicable
+
+# Tasks (if A/P menu used)
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+```
+
+**Content Structure:** (Same pattern as step-01, customized for this step)
+
+```markdown
+# Step {N}: [Step Name From Design]
+
+## STEP GOAL:
+[Single sentence goal from design]
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+### Universal Rules:
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+- ✅ You are [role from design]
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring [expertise for this step], user brings [theirs]
+
+### Step-Specific Rules:
+- 🎯 Focus only on [specific task for this step]
+- 🚫 FORBIDDEN to [prohibited action]
+- 💬 Approach: [how to engage for this step]
+
+## EXECUTION PROTOCOLS:
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 [Protocol - append to output if this step outputs]
+- 📖 [Protocol - tracking if applicable]
+
+## CONTEXT BOUNDARIES:
+- [What's available at this step]
+- Focus: [what to focus on]
+- Limits: [boundaries]
+- Dependencies: [what this step depends on from previous steps]
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. [First action - from design]
+[Intent-based instructions for this step]
+
+### 2. [Second action - from design]
+[Intent-based instructions]
+
+### ... [continue for all actions in this step]
+
+### N. Present MENU OPTIONS
+[Menu based on step type - Standard A/P/C, Simple C-only, Branching, Auto-proceed]
+
+#### EXECUTION RULES:
+[Based on menu type from {menuHandlingStandards}]
+
+#### Menu Handling Logic:
+[Handler for this step's menu]
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+### ✅ SUCCESS:
+[What success looks like for this step]
+
+### ❌ SYSTEM FAILURE:
+[What failure looks like]
+
+**Master Rule:** Skipping steps is FORBIDDEN.
+```
+
+**Customize based on:**
+- Step type pattern from {stepTypePatterns}
+- The step's specific goal and actions from design
+- What this step outputs (if document-producing workflow)
+- Menu pattern appropriate for step type
+
+### 4. Create Supporting Files (If Needed)
+
+**Does this step need any:**
+
+**Small templates?** - Inline in step content or create small template file
+
+**Data files?** - If step references CSV data, create in `data/` folder
+- Load {csvDataFileStandards} for CSV structure
+- Create CSV with proper headers and data
+
+**Validation checklists?** - If this step validates something, create checklist
+
+**Section templates?** - If step outputs to specific document section
+
+**If supporting files are created:**
+1. Create in appropriate folder (`data/` or `templates/`)
+2. Update step frontmatter to reference them
+3. Document in plan
+
+### 5. Document Build in Plan
+
+Append to {workflowPlanFile}:
+
+```markdown
+## Step {N} Build Complete
+
+**Created:**
+- steps-c/step-{N}-{name}.md
+- [any supporting files]
+
+**Step Configuration:**
+- Type: [step type]
+- Outputs to: [output section or file]
+- Next Step: [next step or "final step"]
+
+**Supporting Files:**
+- [list any data files, templates created for this step]
+```
+
+### 6. Check If More Steps Needed
+
+After documenting, check the design:
+
+**Are all steps from the design now built?**
+- **YES:** Proceed to completion menu (option 7 below)
+- **NO:** Present continuation menu (option 6 below)
+
+### 6a. Present MENU OPTIONS (More Steps Remaining)
+
+Display: **Step {N} Complete - Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Build Next Step
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY build next step when user selects 'C'
+- After other menu items execution, return to this menu
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF C: Save build summary to {workflowPlanFile}, update frontmatter stepsCompleted, then load, read entire file, then execute {nextStepFile} (which is THIS FILE - self-referencing for next iteration)
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#6a-present-menu-options-more-steps-remaining)
+
+### 6b. Present MENU OPTIONS (All Steps Complete)
+
+Display: **All Workflow Steps Built! Select an Option:** [R] Review Built Steps [V] Proceed to Validation [C] Complete Build
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- User selects final action
+
+#### Menu Handling Logic:
+
+- IF R: List all built steps with their paths, allow review, then redisplay menu
+- IF V: Save final build summary to {workflowPlanFile}, update frontmatter stepsCompleted to include ALL steps, then load `./step-10-confirmation.md`
+- IF C: Same as V (complete and proceed)
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#6b-present-menu-options-all-steps-complete)
+
+## CRITICAL STEP COMPLETION NOTE
+
+This step REPEATS until all workflow steps from the design are built. When complete, user selects V or C to proceed to completion.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Each step file created with proper structure for its type
+- Frontmatter follows {frontmatterStandards}
+- Menu handling follows {menuHandlingStandards}
+- Step type pattern followed correctly
+- Supporting files created as needed
+- Each build documented in plan
+- Process continues until ALL design steps are built
+
+### ❌ SYSTEM FAILURE:
+
+- Building steps out of order
+- Skipping steps from the design
+- Wrong menu pattern for step type
+- Not documenting each step in plan
+- Proceeding to completion before all steps built
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

package/src/modules/bmb/workflows/workflow/steps-c/step-10-confirmation.md

@@ -0,0 +1,320 @@
+---
+name: 'step-10-confirmation'
+description: 'Confirm workflow completion - validate plan completion or conversion coverage'
+
+targetWorkflowPath: '{bmb_creations_output_folder}/workflows/{new_workflow_name}'
+workflowPlanFile: '{targetWorkflowPath}/workflow-plan-{new_workflow_name}.md'
+nextStepFile: './step-11-completion.md'
+validationWorkflow: '{targetWorkflowPath}/steps-v/step-01-validate.md'
+---
+
+# Step 10: Confirmation
+
+## STEP GOAL:
+
+Confirm the workflow build is complete by checking plan metadata. If this is a conversion, verify all original workflow elements are covered. If new, validate all plan requirements were met.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER skip reading the plan file completely
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 📋 YOU ARE A FACILITATOR, not an autonomous converter
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a workflow quality assurance specialist
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring thorough review expertise
+- ✅ User confirms everything is complete
+
+### Step-Specific Rules:
+
+- 🎯 Focus on confirmation and verification
+- 🚫 FORBIDDEN to skip checking plan metadata
+- 💬 MUST read the entire plan to verify completion
+- 📋 Different paths for conversion vs new workflows
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load and read workflow plan completely
+- 💾 Check for conversionFrom metadata field
+- 📖 Route to appropriate confirmation path
+- 🚫 FORBIDDEN to proceed without verification
+
+## CONTEXT BOUNDARIES:
+
+- All build steps are complete
+- This is the final verification before completion
+- Conversion workflows get coverage check
+- New workflows get plan completion check
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Load Workflow Plan
+
+**Load the workflowPlanFile completely:**
+
+Read `{workflowPlanFile}` entirely to extract:
+- Frontmatter metadata (check for `conversionFrom`)
+- Discovery notes
+- All requirements from classification, design, tools sections
+- Original workflow analysis (if conversion)
+
+"**Loading workflow plan for confirmation...**"
+
+### 2. Check Conversion Metadata
+
+**Examine plan frontmatter for `conversionFrom` field:**
+
+```yaml
+conversionFrom: '{path to source workflow if this is a conversion}'
+```
+
+**IF conversionFrom EXISTS:**
+Route to [Conversion Confirmation](#3-conversion-confirmation-path)
+
+**ELSE (no conversionFrom):**
+Route to [New Workflow Confirmation](#4-new-workflow-confirmation-path)
+
+---
+
+### 3. Conversion Confirmation Path
+
+**DO NOT BE LAZY - Load and review the ORIGINAL workflow completely:**
+
+"**This is a workflow conversion. Verifying all original elements are covered...**"
+
+**Load the original workflow from conversionFrom path:**
+- Read EVERY file from the source workflow
+- Extract original goal, steps, instructions
+
+**For each element from the original, verify coverage:**
+
+#### A. Original Goal Coverage
+
+"**Original Goal:** {from source}
+
+**✅ Covered in new workflow:** {how it's covered}
+
+OR
+
+**⚠️ Partial coverage:** {what's covered} - {what might be missing}
+
+OR
+
+**❌ Not covered:** {explain gap}"
+
+#### B. Original Step Coverage
+
+**For EACH step from the original workflow:**
+
+| Original Step | Purpose | Covered In | Status |
+|---------------|---------|------------|--------|
+| {step name} | {purpose} | {new step location} | ✅ Full / ⚠️ Partial / ❌ Missing |
+
+"**Step-by-step coverage:** {count} of {total} steps fully covered"
+
+#### C. Original Instruction Patterns
+
+**Review how the original workflow instructed the LLM:**
+
+"**Original instruction style:** {describe}
+
+**New workflow instruction style:** {describe}
+
+**Collaborative patterns preserved:** {yes/no + details}
+
+**Key LLM instructions covered:**
+{List the key instruction patterns and how they're preserved}"
+
+#### D. Conversion Coverage Summary
+
+Present findings:
+
+"**━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━**
+
+**Conversion Coverage Report**
+
+**Source:** {conversionFrom}
+**Target:** {targetWorkflowPath}
+
+**Overall Coverage:** {percentage}%
+
+| Category | Total | Covered | Partial | Missing |
+|----------|-------|---------|---------|---------|
+| Goal | 1 | 1 | 0 | 0 |
+| Steps | {count} | {count} | {count} | {count} |
+| Instructions | {count} | {count} | {count} | {count} |
+| Output | 1 | 1 | 0 | 0 |
+
+---
+
+**Missing Elements:** {count}
+{List any gaps found}
+
+**Improvements Made:** {count}
+{List enhancements beyond original}
+
+**━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━**
+
+**Does this coverage look complete? Any gaps to address?**
+
+[C] Continue - Coverage is complete
+[F] Fix gaps - Address missing elements
+[R] Review details - See full comparison"
+
+**Menu Handling Logic:**
+
+- IF C: Proceed to [Completion Handoff](#5-completion-handoff)
+- IF F: Return to build steps to address gaps (route to step-09-build-next-step.md)
+- IF R: Present detailed step-by-step comparison, then redisplay menu
+- IF Any other: help user respond, then redisplay menu
+
+---
+
+### 4. New Workflow Confirmation Path
+
+**This is a new workflow (not a conversion). Validate all plan requirements were met.**
+
+"**Verifying all requirements from the plan were implemented...**"
+
+#### A. Load Plan Requirements
+
+**From workflowPlanFile, extract ALL requirements:**
+
+- Discovery: User's vision, who it's for, what it produces
+- Classification: Type, structure, mode decisions
+- Requirements: Specific features, inputs, outputs
+- Design: Step structure, flow, key decisions
+- Tools: Data files, templates, references
+
+#### B. Verify Each Requirement
+
+**For EACH requirement from the plan:**
+
+| Requirement Area | Specified | Implemented | Location | Status |
+|------------------|-----------|-------------|----------|--------|
+| {area} | {what was specified} | {what was built} | {file/step} | ✅/⚠️/❌ |
+
+#### C. Plan Completion Summary
+
+Present findings:
+
+"**━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━**
+
+**Plan Completion Report**
+
+**Workflow:** {new_workflow_name}
+**Location:** {targetWorkflowPath}
+
+**Overall Completion:** {percentage}%
+
+| Requirement Area | Specified | Implemented | Status |
+|------------------|-----------|-------------|--------|
+| Discovery Vision | {from plan} | {what was built} | ✅/⚠️ |
+| Workflow Type | {from plan} | {what was built} | ✅/⚠️ |
+| Structure | {from plan} | {what was built} | ✅/⚠️ |
+| Key Features | {from plan} | {what was built} | ✅/⚠️ |
+| Data/Tools | {from plan} | {what was built} | ✅/⚠️ |
+
+---
+
+**Missing Requirements:** {count}
+{List any unmet requirements}
+
+**Beyond Plan:** {count}
+{List any additional features added during build}
+
+**━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━**
+
+**Does this implementation match your vision?**
+
+[C] Continue - Implementation is complete
+[F] Fix gaps - Address missing requirements
+[R] Review details - See full comparison"
+
+**Menu Handling Logic:**
+
+- IF C: Proceed to [Completion Handoff](#5-completion-handoff)
+- IF F: Return to build steps to address gaps (route to step-09-build-next-step.md)
+- IF R: Present detailed requirement-by-requirement comparison, then redisplay menu
+- IF Any other: help user respond, then redisplay menu
+
+---
+
+### 5. Completion Handoff
+
+**After user confirms coverage/completion:**
+
+Update `{workflowPlanFile}` frontmatter:
+
+```yaml
+status: CONFIRMED
+confirmationDate: {current date}
+confirmationType: {conversion / new_workflow}
+coverageStatus: {complete / gaps_accepted}
+```
+
+Proceed to [Validation Offer](#6-validation-offer).
+
+---
+
+### 6. Validation Offer
+
+"**✅ Workflow build confirmed!**
+
+**Before using your workflow, I recommend running extensive validation.**
+
+The validation phase will systematically check:
+- File structure & size
+- Frontmatter compliance
+- Menu handling patterns
+- Step type patterns
+- Output format standards
+- Instruction style
+- Overall quality
+
+**Would you like to run validation?**"
+
+Display: **Build Confirmed! Select an Option:** [V] Start Validation [S] Skip - Complete Now
+
+#### Menu Handling Logic:
+
+- IF V: "Loading validation phase..." → Save confirmation status, update frontmatter, then load, read entire file, then execute {validationWorkflow}
+- IF S: "Skipping validation. Proceeding to completion..." → Load, read entire file, then execute {nextStepFile}
+- IF Any other: help user respond, then redisplay menu
+
+## CRITICAL STEP COMPLETION NOTE
+
+ALWAYS check plan metadata for conversionFrom field. Route to appropriate confirmation path. Only proceed after user confirms coverage/completion is satisfactory.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Plan file loaded completely
+- ConversionFrom metadata checked
+- Appropriate confirmation path executed
+- Original workflow reviewed (if conversion)
+- Plan requirements verified (if new)
+- Coverage/completion report presented clearly
+- User confirms and proceeds
+
+### ❌ SYSTEM FAILURE:
+
+- Not loading plan file completely
+- Not checking conversionFrom metadata
+- Skipping original workflow review (conversion)
+- Not verifying plan requirements (new)
+- Proceeding without user confirmation
+- Missing gaps in coverage
+
+**Master Rule:** Check conversionFrom metadata first. For conversions, REVIEW THE ORIGINAL COMPLETELY. For new workflows, VERIFY ALL PLAN REQUIREMENTS. Only proceed after user confirms.