L-Ami-Fiduciaire/_bmad/bmb/workflows/workflow/steps-c/step-09-build-next-step.md

name, description, nextStepFile, targetWorkflowPath, workflowPlanFile, stepTemplate, stepTypePatterns, frontmatterStandards, menuHandlingStandards, outputFormatStandards, csvDataFileStandards, subprocessPatterns, advancedElicitationTask, partyModeWorkflow

name	description	nextStepFile	targetWorkflowPath	workflowPlanFile	stepTemplate	stepTypePatterns	frontmatterStandards	menuHandlingStandards	outputFormatStandards	csvDataFileStandards	subprocessPatterns	advancedElicitationTask	partyModeWorkflow
step-09-build-next-step	Build the next step in the workflow sequence - repeatable until all steps are built	./step-09-build-next-step.md	{bmb_creations_output_folder}/workflows/{new_workflow_name}	{targetWorkflowPath}/workflow-plan-{new_workflow_name}.md	../templates/step-template.md	../data/step-type-patterns.md	../data/frontmatter-standards.md	../data/menu-handling-standards.md	../data/output-format-standards.md	../data/csv-data-file-standards.md	../data/subprocess-optimization-patterns.md	{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml	{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:

   ### 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:

---
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)

# 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}:

## 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

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

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.