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

package/src/modules/bmb/workflows/workflow/steps-c/step-05-plan-review.md

@@ -0,0 +1,242 @@
+---
+name: 'step-05-plan-review'
+description: 'Review the complete workflow plan and approve before design'
+
+nextStepFile: './step-06-design.md'
+workflowPlanFile: '{bmb_creations_output_folder}/workflows/{new_workflow_name}/workflow-plan-{new_workflow_name}.md'
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Plan Review and Approval
+
+## STEP GOAL:
+
+To present the complete workflow plan (discovery, classification, requirements, tools) for review and approval before proceeding to the design phase.
+
+## 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 conducting a design review
+- ✅ Present the complete plan clearly
+- ✅ Solicit feedback and make refinements
+- ✅ Get explicit approval before proceeding to design
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on review and refinement
+- 🚫 FORBIDDEN to start designing workflow steps in this step
+- 💬 Present plan clearly, ask targeted questions
+- 🚫 DO NOT proceed to design without user approval
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Present complete plan from {workflowPlanFile}
+- 💾 Capture any modifications or refinements
+- 📖 Update frontmatter stepsCompleted when complete
+- 🚫 FORBIDDEN to load next step until user approves
+
+## CONTEXT BOUNDARIES:
+
+- Discovery (Step 1) → Classification (Step 2) → Requirements (Step 3) → Tools (Step 4)
+- ALL the information needed for design is now captured
+- This is the final checkpoint before designing the workflow structure
+- Once we proceed to Step 6, we'll be designing actual step files
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Initialize Review
+
+"**Let's review the complete plan before we start designing.**
+
+We've covered a lot of ground. Let me walk you through everything we've decided, and you can tell me what looks right and what needs adjustment."
+
+### 2. Present Complete Plan
+
+Load and present from `{workflowPlanFile}`:
+
+"**Complete Workflow Plan: {workflow-name}**
+
+---
+
+**1. DISCOVERY** (from Step 1)
+
+**Your Vision:**
+[Present user's vision]
+
+**Who It's For:**
+[Present users/audience]
+
+**Key Insights:**
+[Present important context]
+
+---
+
+**2. CLASSIFICATION** (from Step 2)
+
+**The 4 Key Decisions:**
+1. **Document Output:** {true/false} - [what it produces]
+2. **Module Affiliation:** {standalone/module} - {target path}
+3. **Session Type:** {single-session/continuable} - [implications]
+4. **Lifecycle Support:** {create-only/tri-modal} - [implications]
+
+**Workflow Name:** {name}
+**Target Location:** {path}
+
+---
+
+**3. REQUIREMENTS** (from Step 3)
+
+**Flow Structure:**
+- Pattern: {linear/looping/branching/repeating}
+- Phases: {list major phases}
+- Estimated steps: {count}
+
+**User Interaction:**
+- Style: {collaborative/autonomous/guided/mixed}
+- Decision points: {where user must choose}
+
+**Inputs:** {required and optional}
+**Output:** {type and format}
+**Success Criteria:** {what success looks like}
+**Instruction Style:** {intent/prescriptive/mixed}
+
+---
+
+**4. TOOLS CONFIGURATION** (from Step 4)
+
+**Core Tools:**
+- Party Mode: {included/excluded} - {integration point}
+- Advanced Elicitation: {included/excluded} - {integration point}
+- Brainstorming: {included/excluded} - {integration point}
+
+**LLM Features:**
+- Web-Browsing: {included/excluded}
+- File I/O: {included/excluded}
+- Sub-Agents: {included/excluded}
+- Sub-Processes: {included/excluded}
+
+**Memory:** {continuable/single-session}
+
+---
+
+### 3. Detailed Review by Section
+
+"**Let's go through this systematically. I want your feedback on each area:**"
+
+**A. Vision and Scope (Discovery)**
+- "Does the 'Your Vision' section capture what you're trying to build?"
+- "Anything we missed in the key insights?"
+
+**B. Structural Decisions (Classification)**
+- "Do the 4 key decisions still feel right?"
+- "Any second thoughts on continuable vs single-session?"
+- "Create-only or tri-modal - still the right call?"
+
+**C. Requirements (Details)**
+- "Does the flow structure match what you envisioned?"
+- "Are the interaction style and decision points accurate?"
+- "Input/output specifications complete?"
+- "Success criteria clear?"
+
+**D. Tools (Integrations)**
+- "Do the selected tools make sense?"
+- "Integration points feel right?"
+- "Any tools we should add or remove?"
+
+### 4. Collect Feedback
+
+"**Your feedback:**
+
+For each section above, tell me:
+1. What looks good and should stay as-is
+2. What needs modification or refinement
+3. What's missing that should be added
+4. Anything unclear or confusing
+
+**Take your time - this is our last chance to make changes before we start designing the actual workflow.**"
+
+### 5. Process Feedback and Refine
+
+For each feedback item:
+
+- Document the requested change
+- Discuss implications on workflow design
+- Make the refinement
+- Confirm with user
+
+Update `{workflowPlanFile}` with all approved changes.
+
+### 6. Final Confirmation
+
+"**One last check before we proceed to design:**
+
+Based on everything we've discussed:
+
+- [Re-state the workflow's purpose in one sentence]
+- [Re-state the key structural decision: continuable/tri-modal]
+- [Re-state the flow pattern]
+
+You're approving this plan to move into the actual workflow design phase.
+
+Ready to proceed?"
+
+### 7. Update Plan Status
+
+Update `{workflowPlanFile}` frontmatter:
+
+```yaml
+status: APPROVED_FOR_DESIGN
+approvedDate: [current date]
+```
+
+### 8. Present MENU OPTIONS
+
+Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Design
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'
+- User can chat or ask questions - always respond and redisplay menu
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}
+- IF P: Execute {partyModeWorkflow}
+- IF C: Update plan frontmatter with approval, then load `{nextStepFile}`
+- IF Any other: Help user, then redisplay menu
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Complete plan presented clearly from the plan document
+- All 4 sections reviewed systematically
+- User feedback collected and incorporated
+- User explicitly approves the plan
+- Plan status updated to APPROVED_FOR_DESIGN
+- Ready to proceed to design phase
+
+### ❌ SYSTEM FAILURE:
+
+- Not loading plan from {workflowPlanFile}
+- Skipping review sections
+- Not documenting refinements
+- Proceeding without explicit approval
+- Not updating plan status
+
+**Master Rule:** The plan must be complete and approved before design. This is the gatekeeper step.

package/src/modules/bmb/workflows/{create-workflow/steps → workflow/steps-c}/step-06-design.md

@@ -2,22 +2,20 @@
 name: 'step-06-design'
 description: 'Design the workflow structure and step sequence based on gathered requirements, tools configuration, and output format'
 
-# Path Definitions
-workflow_path: '{project-root}/_bmad/bmb/workflows/create-workflow'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-06-design.md'
-nextStepFile: '{workflow_path}/steps/step-07-build.md'
-workflowFile: '{workflow_path}/workflow.md'
-# Output files for workflow creation process
+nextStepFile: './step-07-foundation.md'
 targetWorkflowPath: '{bmb_creations_output_folder}/workflows/{new_workflow_name}'
 workflowPlanFile: '{targetWorkflowPath}/workflow-plan-{new_workflow_name}.md'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/tasks/advanced-elicitation.xml'
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
 partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
-# Template References
-# No template needed - will append design details directly to workflow plan
+stepTemplate: '../templates/step-template.md'
+stepTypePatterns: '../data/step-type-patterns.md'
+menuHandlingStandards: '../data/menu-handling-standards.md'
+frontmatterStandards: '../data/frontmatter-standards.md'
+outputFormatStandards: '../data/output-format-standards.md'
+inputDiscoveryStandards: '../data/input-discovery-standards.md'
+workflowChainingStandards: '../data/workflow-chaining-standards.md'
+trimodalWorkflowStructure: '../data/trimodal-workflow-structure.md'
+subprocessPatterns: '../data/subprocess-optimization-patterns.md'
 ---
 
 # Step 6: Workflow Structure Design
@@ -34,6 +32,7 @@ To collaboratively design the workflow structure, step sequence, and interaction
 - 📖 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:
 
@@ -54,7 +53,7 @@ To collaboratively design the workflow structure, step sequence, and interaction
 
 - 🎯 Guide collaborative design process
 - 💾 After completing design, append to {workflowPlanFile}
-- 📖 Update plan frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]` before loading next step
+- 📖 Update frontmatter stepsCompleted to add this step when completed.
 - 🚫 FORBIDDEN to load next step until user selects 'C' and design is saved
 
 ## CONTEXT BOUNDARIES:
@@ -68,37 +67,40 @@ To collaboratively design the workflow structure, step sequence, and interaction
 
 ## DESIGN REFERENCE MATERIALS:
 
-When designing, you may load these documents as needed:
-
-- `{project-root}/_bmad/bmb/docs/workflows/templates/step-template.md` - Step file structure
-- `{project-root}/_bmad/bmb/docs/workflows/templates/step-01-init-continuable-template.md` - Continuable init step template
-- `{project-root}/_bmad/bmb/docs/workflows/templates/step-1b-template.md` - Continuation step template
-- `{project-root}/_bmad/bmb/docs/workflows/templates/workflow-template.md` - Workflow configuration
-- `{project-root}/_bmad/bmb/reference/workflows/meal-prep-nutrition/workflow.md` - Complete example
+When designing, you will load these data standards as needed (ideally within subprocesses that can return the relevant insights during the design step):
 
-## WORKFLOW DESIGN PROCESS:
+- {stepTemplate} - Step file structure template
+- {stepTypePatterns} - Templates for different step types (init, middle, branch, validation, final)
+- {menuHandlingStandards} - Menu patterns and handler rules
+- {frontmatterStandards} - Variable definitions and path rules
+- {outputFormatStandards} - Output document patterns
+- {inputDiscoveryStandards} - How to discover documents from prior workflows
+- {workflowChainingStandards} - How workflows connect in sequences
+- {trimodalWorkflowStructure} - Tri-modal workflow patterns (if applicable)
 
-### 1. Step Structure Design
+Example [Workflow.md](../workflow.md) for reference of a perfect workflow.md with some complex options (not all workflows will offer multiple next step options like this one - most will just auto route right to a step 1 file)
 
-Let's reference our step creation documentation for best practices:
+## MANDATORY SEQUENCE
 
-Load and reference step-file architecture guide:
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 
-```
-Read: {project-root}/_bmad/bmb/docs/workflows/templates/step-template.md
-```
+### 1. Step Structure Design
 
-This shows the standard structure for step files. Also reference:
+Load {stepTypePatterns} for available step type templates:
 
-```
-Read: {project-root}/_bmad/bmb/docs/workflows/templates/step-1b-template.md
-```
+This shows the standard structure for all step types:
+- Init Step (Continuable)
+- Continuation Step (01b)
+- Middle Step (Standard/Simple)
+- Branch Step
+- Validation Sequence Step
+- Init Step (With Input Discovery)
+- Final Polish Step
+- Final Step
 
-This shows the continuation step pattern for workflows that might take multiple sessions.
+Based on the approved plan, collaboratively design the info to answer the following for the build plan:
 
-Based on the approved plan, collaboratively design:
-
-- How many major steps does this workflow need? (Recommend 3-7)
+- How many major steps does this workflow need?
 - What is the goal of each step?
 - Which steps are optional vs required?
 - Should any steps repeat or loop?
@@ -125,10 +127,11 @@ If **YES** to any of these, we should include continuation support using step-01
 
 ### 2. Interaction Pattern Design
 
-Design how users will interact with the workflow:
+Load {menuHandlingStandards} for menu pattern options:
 
+Design how users will interact with the workflow:
 - Where should users provide input vs where the AI works autonomously?
-- What type of menu options are needed at each step?
+- What menu pattern does each step need? (Standard A/P/C, Auto-proceed, Custom, Conditional)
 - Should there be Advanced Elicitation or Party Mode options?
 - How will users know their progress?
 - What confirmation points are needed?
@@ -172,6 +175,47 @@ Design quality assurance:
 - How can users recover from errors?
 - What constitutes successful completion?
 
+### 6a. Subprocess Optimization Design
+
+Load {subprocessPatterns} to understand subprocess optimization patterns that can save context and improve performance during workflow execution.
+
+Ask the user:
+
+"**Should we design this workflow to leverage subprocess optimization patterns?** Consider:
+
+- **Pattern 1 (Grep/Regex):** Will any step search across many files or documents for patterns?
+- **Pattern 2 (Deep Analysis):** Will any step analyze multiple files for prose, logic, quality, or flow?
+- **Pattern 3 (Data Operations):** Will any step load large reference data, knowledge bases, or datasets?
+- **Pattern 4 (Parallel Execution):** Can any validation or analysis checks run in parallel instead of sequentially?
+
+If **YES** to any of these, we should design those steps with subprocess optimization in mind."
+
+**If subprocess optimization is applicable:**
+
+For each step that could benefit from subprocesses:
+- Identify which pattern(s) apply (Pattern 1, 2, 3, or 4)
+- Design what the subprocess should return (findings only, not full content)
+- Plan graceful fallback for LLMs without subprocess capability
+- Document optimization strategy in the build plan
+
+**Example subprocess integration:**
+
+```markdown
+### Step-Specific Rules:
+- 🎯 Analyze X files for Y - use subprocess per file (Pattern 2)
+- 💬 Subprocess returns structured findings, not full content
+- ⚙️ If subprocess unavailable: Perform analysis in main thread
+```
+
+**Document in the plan:**
+
+For each step identified for subprocess optimization, record:
+- Step number and name
+- Pattern type(s) to apply
+- What the subprocess will analyze
+- Expected return structure
+- Fallback approach
+
 ### 7. Special Features Design
 
 Identify unique requirements:
@@ -181,6 +225,20 @@ Identify unique requirements:
 - Should it integrate with other workflows?
 - Does it need to handle multiple scenarios?
 
+**Input Discovery:**
+
+If this workflow depends on documents from prior workflows, load {inputDiscoveryStandards}:
+- What prior workflow outputs does this workflow need?
+- Are these required or optional inputs?
+- How will the workflow discover these documents?
+
+**Workflow Chaining:**
+
+If this workflow is part of a sequence, load {workflowChainingStandards}:
+- What workflow comes before this one?
+- What workflow comes after this one?
+- What outputs does this workflow produce for the next?
+
 ### 8. Design Review and Refinement
 
 Present the design for review:

package/src/modules/bmb/workflows/workflow/steps-c/step-07-foundation.md

@@ -0,0 +1,238 @@
+---
+name: 'step-07-foundation'
+description: 'Create workflow folder structure, workflow.md, and main output template(s)'
+
+nextStepFile: './step-08-build-step-01.md'
+targetWorkflowPath: '{bmb_creations_output_folder}/workflows/{new_workflow_name}'
+workflowPlanFile: '{targetWorkflowPath}/workflow-plan-{new_workflow_name}.md'
+workflowTemplate: '../templates/workflow-template.md'
+outputFormatStandards: '../data/output-format-standards.md'
+minimalOutputTemplate: '../templates/minimal-output-template.md'
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step 7: Foundation Build
+
+## STEP GOAL:
+
+To create the workflow folder structure, the main workflow.md file, and the primary output template(s) that step files will reference.
+
+## 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:
+
+- 🎯 Focus ONLY on creating foundation elements (folder, workflow.md, main template)
+- 🚫 FORBIDDEN to create step files yet - that comes next
+- 💬 Get confirmation before creating each foundation element
+- 🚪 CREATE files in the correct target location
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Create foundation systematically from approved design
+- 💾 Document what was created in the plan
+- 📖 Update frontmatter stepsCompleted to add this step when completed
+- 🚫 FORBIDDEN to load next step until user selects 'C'
+
+## CONTEXT BOUNDARIES:
+
+- Approved plan from step 6 guides implementation
+- Design specifies: workflow name, continuable or not, document output type, step count
+- Load templates and documentation as needed during build
+- Follow step-file architecture principles
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Confirm Foundation Readiness
+
+Based on the approved design from step 6, confirm:
+
+"**I have your approved design and I'm ready to create the workflow foundation.**
+
+From your design, I'll be creating:
+
+**Workflow:** {new_workflow_name}
+**Location:** {targetWorkflowPath}
+**Type:** [continuable/single-session]
+**Document Output:** [yes/no - template type if yes]
+**Estimated Steps:** [number from design]
+
+Ready to proceed with creating the folder structure?"
+
+### 2. Create Folder Structure
+
+Create the workflow folder structure:
+
+```
+{targetWorkflowPath}/
+├── workflow.md                    # To be created
+├── steps-c/                       # Create flow steps
+│   ├── step-01-init.md
+│   ├── step-01b-continue.md      # If continuable
+│   └── [remaining steps]
+├── steps-v/                       # Validate flow steps (to be created later)
+├── data/                          # Shared reference data
+└── templates/                     # Output templates
+```
+
+**For BMB module workflows:** The target will be `_bmad/custom/src/workflows/{workflow_name}/`
+**For other modules:** Check module's custom_workflow_location
+
+Create the folders and confirm structure.
+
+### 3. Generate workflow.md
+
+Load {workflowTemplate} and create workflow.md with:
+
+**Frontmatter:**
+```yaml
+---
+name: '{workflow-name-from-design}'
+description: '{description-from-design}'
+web_bundle: true
+---
+```
+
+**Content:**
+- Workflow name and description
+- Goal statement
+- Role definition
+- Meta-context (if applicable)
+- Initialization sequence pointing to steps-c/step-01-init.md
+- Configuration loading instructions
+
+**If tri-modal (Create + Edit + Validate):**
+Add mode routing logic to workflow.md:
+- IF invoked with -c: Load ./steps-c/step-01-init.md
+- IF invoked with -v: Load ./steps-v/step-01-validate.md
+- IF invoked with -e: Load ./steps-e/step-01-edit.md
+
+### 4. Create Main Output Template
+
+**Load {outputFormatStandards} to determine template type.**
+
+**From the design, determine:**
+- Free-form (recommended) - Minimal frontmatter + progressive append
+- Structured - Required sections with flexible content
+- Semi-structured - Core sections + optional additions
+- Strict - Exact format (rare, compliance/legal)
+
+**For Free-form (most common):**
+
+Create `templates/output-template.md`:
+```yaml
+---
+stepsCompleted: []
+lastStep: ''
+date: ''
+user_name: ''
+---
+```
+
+If the workflow produces a document with sections:
+```markdown
+# {{document_title}}
+
+[Content appended progressively by workflow steps]
+```
+
+**For Structured/Semi-structured:**
+
+Create template with section placeholders based on design:
+```markdown
+# {{title}}
+
+## {{section_1}}
+[Content to be filled]
+
+## {{section_2}}
+[Content to be filled]
+```
+
+**For Non-Document Workflows:**
+
+No output template needed. Document this in the plan.
+
+### 5. Document Foundation in Plan
+
+Append to {workflowPlanFile}:
+
+```markdown
+## Foundation Build Complete
+
+**Created:**
+- Folder structure at: {targetWorkflowPath}
+- workflow.md
+- Main template: [template-name]
+
+**Configuration:**
+- Workflow name: {name}
+- Continuable: [yes/no]
+- Document output: [yes/no - type]
+- Mode: [create-only or tri-modal]
+
+**Next Steps:**
+- Step 8: Build step-01 (and step-01b if continuable)
+- Step 9: Build remaining steps (repeatable)
+```
+
+### 6. Present MENU OPTIONS
+
+Display: **Foundation Complete - Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Step 01 Build
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond and then redisplay 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 foundation summary to {workflowPlanFile}, update frontmatter stepsCompleted, then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#6-present-menu-options)
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and foundation is saved to plan will you load {nextStepFile} to begin building step-01.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Folder structure created in correct location
+- workflow.md created with proper frontmatter and initialization
+- Main output template created (if document-producing workflow)
+- Foundation documented in {workflowPlanFile}
+- Frontmatter updated with stepsCompleted
+
+### ❌ SYSTEM FAILURE:
+
+- Creating folders without user confirmation
+- Missing mode routing for tri-modal workflows
+- Wrong template type for output format
+- Not documenting what was created
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.