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

package/src/modules/bmb/workflows/workflow/steps-v/step-10-report-complete.md

@@ -0,0 +1,154 @@
+---
+name: 'step-10-report-complete'
+description: 'Finalize validation report - check for plan file, summarize all findings, present to user'
+
+targetWorkflowPath: '{workflow_folder_path}'
+validationReportFile: '{workflow_folder_path}/validation-report-{datetime}.md'
+workflowPlanFile: '{workflow_folder_path}/workflow-plan.md'
+planValidationStep: './step-11-plan-validation.md'
+---
+
+# Validation Step 10: Report Complete
+
+## STEP GOAL:
+
+To check if a plan file exists (and run plan validation if it does), then summarize all validation findings and present to the user.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+- ⚙️ If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context
+
+### Step-Specific Rules:
+
+- 🎯 This is the final validation step - present findings
+- 🚫 DO NOT modify the workflow without user request
+- 💬 Present summary and ask what changes are needed
+- 🚪 This ends validation - user decides next steps
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load the complete validation report
+- 💾 Summarize ALL findings
+- 📖 Update report status to COMPLETE
+- 🚫 DO NOT proceed without user review
+
+## CONTEXT BOUNDARIES:
+
+- All 10 previous validation steps have completed
+- Report contains findings from all checks
+- User needs to see summary and decide on changes
+- This step DOES NOT auto-proceed
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip or shortcut.
+
+### 1. Check for Plan File
+
+Before finalizing the report, check if a plan file exists:
+
+**Check if {workflowPlanFile} exists:**
+- **IF YES:** Run plan validation first
+  - Load, read entire file, then execute {planValidationStep}
+  - The plan validation will append its findings to the report
+  - Then return to this step to finalize the report
+- **IF NO:** Proceed to finalize the report (no plan to validate)
+
+### 2. Load Complete Validation Report
+
+After plan validation (if applicable), load {validationReportFile} and read ALL findings from every validation step.
+
+### 3. Create Summary Section
+
+At the end of {validationReportFile}, replace "## Summary *Pending...*" with a comprehensive summary that includes:
+
+- Validation completion date
+- Overall status assessment (based on all validation steps)
+- List of all validation steps completed with their individual results
+- Summary of critical issues that must be fixed (or note if none found)
+- Summary of warnings that should be addressed (or note if none found)
+- Key strengths identified during validation
+- Overall assessment of workflow quality
+- Recommendation on readiness (ready to use / needs tweaks / needs revision / major rework needed)
+- Suggested next steps for the user
+
+Present this information in a clear, readable format - the exact structure is flexible as long as it covers all these points.
+
+### 4. Update Report Status
+
+Update the frontmatter of {validationReportFile} to set validationStatus to COMPLETE and add the completionDate. Keep existing fields like validationDate, workflowName, and workflowPath unchanged.
+
+### 5. Present Summary to User
+
+Present a clear summary to the user that includes:
+
+- Confirmation that validation is complete
+- Overall status of the workflow
+- Quick results overview showing each validation step and its result
+- Count of critical issues and warnings (or note if none found)
+- Recommendation on workflow readiness
+- Path to the full validation report
+- Options for next steps (review detailed findings, make changes, explain results, or other actions)
+
+Present this information in a natural, conversational way - the exact format doesn't matter as long as all this information is clearly communicated.
+
+### 6. Present MENU OPTIONS
+
+Display: **Validation Complete! Select an Option:** [R] Review Detailed Findings [F] Fix Issues [X] Exit Validation
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- User chooses their next action
+
+#### Menu Handling Logic:
+
+- IF R: Walk through the validation report section by section, explaining findings, then redisplay menu
+- IF F: "What issues would you like to fix?" → Discuss specific changes needed → User can make edits manually OR you can help edit files
+- IF X: "Validation complete. Your workflow is at: {targetWorkflowPath}. You can make changes and re-run validation anytime."
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#5-present-menu-options)
+
+### 7. If User Wants to Fix Issues
+
+Explain the available options for fixing issues:
+
+- Manual edits: User edits files directly, then re-runs validation
+- Guided edits: User specifies what to fix, help create specific edits for user approval
+- Edit workflow: If the workflow has steps-e/, use the edit workflow to make systematic changes
+
+The exact format doesn't matter - just ensure the user understands their options for addressing issues.
+
+### 8. Update Plan with Validation Status
+
+If a plan file exists at {workflowPlanFile}, update its frontmatter to include the validation status (COMPLETE), the current validation date, and a reference to the validation report file.
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the final validation step. User reviews findings and decides whether to make changes. Validation workflow ends here.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All validation findings summarized
+- Complete report presented to user
+- Summary section added to report
+- Report status updated to COMPLETE
+- User can review findings and decide on changes
+- Plan updated with validation status
+
+### ❌ SYSTEM FAILURE:
+
+- Not summarizing all findings
+- Not presenting complete report to user
+- Not updating report status
+- Not giving user clear options for next steps
+
+**Master Rule:** Validation is complete. User reviews findings and decides what changes to make. Provide clear summary and options.

package/src/modules/bmb/workflows/workflow/steps-v/step-11-plan-validation.md

@@ -0,0 +1,237 @@
+---
+name: 'step-11-plan-validation'
+description: 'Validate plan quality - ensure all user intent and requirements are implemented'
+
+targetWorkflowPath: '{workflow_folder_path}'
+validationReportFile: '{workflow_folder_path}/validation-report-{datetime}.md'
+workflowPlanFile: '{workflow_folder_path}/workflow-plan.md'
+---
+
+# Validation Step 11: Plan Quality Validation
+
+## STEP GOAL:
+
+To validate that a workflow plan (if it exists) has been fully implemented - all user intent captured, all requirements met with high quality.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 DO NOT BE LAZY - LOAD AND REVIEW EVERY FILE
+- 📖 CRITICAL: Read the complete step file before taking any action
+- ✅ This validation step only runs if a plan file exists
+- ⚙️ If any instruction references a subprocess, subagent, or tool you do not have access to, you MUST still achieve the outcome in your main context thread
+
+### Step-Specific Rules:
+
+- 🎯 Validate plan requirements using subprocess optimization - separate subprocess per requirement area for deep analysis
+- 🚫 DO NOT skip checking any requirement from the plan - DO NOT BE LAZY
+- 💬 Subprocess must either update validation report directly OR return structured findings to parent for aggregation
+- 🚪 This ensures the build actually delivered what was planned
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load plan and extract all requirements/intent using subprocess optimization when available - separate subprocess per requirement area for deep analysis
+- 💾 Subprocesses validate implementation against plan requirements and return findings for aggregation
+- 📖 Document gaps and quality issues
+- 🚫 Only run this step if workflowPlanFile exists
+
+## CONTEXT BOUNDARIES:
+
+- This step runs AFTER the workflow is built
+- Compares what was planned vs what was implemented
+- Checks for: missing features, quality gaps, unmet user intent
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Only run this step if {workflowPlanFile} exists. If it doesn't exist, skip to final summary.
+
+### 1. Check if Plan Exists
+
+First, check if {workflowPlanFile} exists:
+
+**IF plan file does NOT exist:**
+- Skip this validation step
+- Proceed to summary with note: "No plan file found - workflow may have been built without BMAD create-workflow process"
+
+**IF plan file exists:**
+- Load the complete plan file
+- Proceed with validation
+
+### 2. Extract Plan Requirements
+
+**DO NOT BE LAZY - Extract EVERY requirement from the plan:**
+
+**SUBPROCESS EXECUTION PATTERN:**
+
+Launch a subprocess that:
+1. Loads {workflowPlanFile}
+2. Extracts all requirements from each section (Discovery, Classification, Requirements, Design, Tools)
+3. Returns structured requirements list to parent
+
+**SUBPROCESS RETURNS:**
+Structured requirements list organized by section (discovery, classification, requirements, design, tools) with all extracted items and a count of total requirements.
+
+**If subprocess unavailable:** Load {workflowPlanFile} in main context and extract requirements (larger context but still functional - demonstrates graceful fallback).
+
+---
+
+### 3. Validate Each Requirement Against Built Workflow
+
+**DO NOT BE LAZY - For EACH requirement area, launch a subprocess that:**
+
+1. Loads relevant workflow files (workflow.md, step files, etc.)
+2. Validates that specific requirement area is implemented correctly
+3. Assesses quality of implementation
+4. **EITHER** updates validation report directly with findings
+5. **OR** returns structured validation results to parent for aggregation
+
+**PATTERN 2: Separate subprocess per requirement area for deep analysis**
+
+Each subprocess gets full context to deeply understand that requirement area and validate implementation quality:
+
+---
+
+**SUBPROCESS 1: Discovery Validation**
+
+**Subprocess analyzes:**
+- ✅ Built workflow addresses the original problem?
+- ✅ Vision from discovery is reflected in final workflow?
+
+**Subprocess returns:**
+Discovery validation results indicating whether the original problem and vision from the plan are addressed in the built workflow, with quality assessment, status (✅/❌), and any gaps identified.
+
+---
+
+**SUBPROCESS 2: Classification Validation**
+
+**Subprocess analyzes:**
+- ✅ Document output matches plan (yes/no)?
+- ✅ Module affiliation correct?
+- ✅ Continuable support as specified?
+- ✅ Tri-modal structure as specified?
+
+**Subprocess returns:**
+Classification validation results for each classification attribute (document output, module, continuable, tri-modal) comparing what was specified vs what was implemented, with overall quality assessment, status (✅/❌), and any gaps.
+
+---
+
+**SUBPROCESS 3: Requirements Validation**
+
+**Subprocess analyzes:**
+- ✅ Flow structure matches plan?
+- ✅ User interaction style as specified?
+- ✅ All required inputs configured?
+- ✅ Output format matches specification?
+- ✅ Success criteria achievable?
+
+**Subprocess returns:**
+Requirements validation results for flow structure, interaction style, inputs, outputs, and success criteria comparing what was specified vs what was implemented, with overall quality assessment, status (✅/❌), and any gaps.
+
+---
+
+**SUBPROCESS 4: Design Validation**
+
+**Subprocess analyzes:**
+- ✅ All steps from design present in workflow?
+- ✅ Step purposes match design?
+- ✅ Flow follows design diagram?
+- ✅ Interaction patterns as specified?
+
+**Subprocess returns:**
+Design validation results for each step from the plan checking if it exists in the workflow and if the purpose matches, along with whether the flow follows the design diagram and interaction patterns match, with overall quality assessment, status (✅/❌), and any gaps.
+
+---
+
+**SUBPROCESS 5: Tools Validation**
+
+**Subprocess analyzes:**
+- ✅ Specified tools configured in workflow?
+- ✅ Data files created as specified?
+
+**Subprocess returns:**
+Tools validation results checking which specified tools are configured and which data files were created, with overall quality assessment, status (✅/❌), and any gaps.
+
+---
+
+**If subprocess unavailable:** Validate each requirement area sequentially in main context (larger context but still functional - demonstrates graceful fallback).
+
+---
+
+### 4. Aggregate Findings and Update Report
+
+After ALL requirement area subprocesses complete, aggregate findings into validation report.
+
+Document the following information:
+
+**Plan Information:**
+- Plan file location
+- Whether a plan was found
+- Total number of requirements extracted from the plan
+
+**Implementation Coverage:**
+For each requirement area from the plan (Discovery/Vision, Classification attributes, Requirements specifications, Design elements, Tools):
+- What was specified in the plan
+- Whether it was implemented in the workflow
+- Quality assessment (High/Medium/Low)
+- Implementation status
+
+**Implementation Gaps:**
+List any requirements from the plan that are NOT present in the built workflow
+
+**Quality Issues:**
+List any requirements that are implemented but with quality concerns
+
+**Plan-Reality Alignment:**
+Describe where the built workflow doesn't match what was planned
+
+**Overall Assessment:**
+- Plan implementation score (percentage)
+- Overall status (Fully Implemented/Partially Implemented/Poorly Implemented/Missing Critical Items)
+
+**Quality Assessment Framework:**
+For each implemented requirement, assess quality:
+- **High Quality**: Implementation follows best practices, would facilitate effectively
+- **Medium Quality**: Functional but has issues or gaps
+- **Low Quality**: Minimal/barely working, would not facilitate well
+
+Examples:
+- Plan specifies "Highly collaborative, intent-based facilitation" and implementation has A/P menus with intent-based language = High Quality
+- Plan specifies "Continuable workflow with session resume" and implementation has step-01b-continue.md tracking stepsCompleted = High Quality
+
+### 5. Append to Report
+
+Append the aggregated findings to {validationReportFile} after the "## Cohesive Review" section.
+
+### 6. Save and Complete
+
+Save the validation report. This is the final validation step.
+
+**Display:**
+"**Plan Quality validation complete.** Validation report finalized."
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Plan file loaded completely (in subprocess or main context)
+- Every requirement extracted and validated using subprocess optimization when available
+- Each requirement area analyzed in separate subprocess (or main context with graceful fallback)
+- Implementation gaps documented with structured findings
+- Quality assessed for each requirement
+- Findings aggregated and appended to report
+- Context saved via subprocess pattern (return only findings, not full file contents)
+
+### ❌ SYSTEM FAILURE:
+
+- Not loading complete plan
+- Skipping requirement checks
+- Not validating each requirement area deeply
+- Not using subprocess optimization when available
+- Not documenting implementation gaps
+- Not assessing quality
+- Loading full file contents into parent instead of returning only findings
+
+**Master Rule:** Validation is systematic and thorough. DO NOT BE LAZY. Check EVERY requirement from the plan. Use subprocess optimization (Pattern 2: per-requirement deep analysis) when available. Document all gaps. Return only findings to parent, not full file contents.

package/src/modules/bmb/workflows/workflow/templates/minimal-output-template.md

@@ -0,0 +1,11 @@
+---
+stepsCompleted: []
+lastStep: ''
+date: ''
+user_name: ''
+project_name: ''
+---
+
+# {{document_title}}
+
+[Content will be progressively appended by workflow steps]

package/src/modules/bmb/{docs/workflows → workflows/workflow}/templates/step-01-init-continuable-template.md

@@ -17,11 +17,11 @@ workflow\*path: `{project-root}/_bmad/[module-path]/workflows/[workflow-name]`
 
 # File References (all use {variable} format in file)
 
-thisStepFile: `{workflow_path}/steps/step-01-init.md`
-nextStepFile: `{workflow_path}/steps/step-02-[step-name].md`
+thisStepFile: `./step-01-init.md`
+nextStepFile: `./step-02-[step-name].md`
 workflowFile: `{workflow_path}/workflow.md`
 outputFile: `{output_folder}/[output-file-name]-{project_name}.md`
-continueFile: `{workflow_path}/steps/step-01b-continue.md`
+continueFile: `./step-01b-continue.md`
 templateFile: `{workflow_path}/templates/[main-template].md`
 
 # Template References

package/src/modules/bmb/{docs/workflows → workflows/workflow}/templates/step-1b-template.md

@@ -17,7 +17,7 @@ workflow\*path: '{project-root}/_bmad/[module-path]/workflows/[workflow-name]'
 
 # File References (all use {variable} format in file)
 
-thisStepFile: '{workflow_path}/steps/step-01b-continue.md'
+thisStepFile: './step-01b-continue.md'
 outputFile: '{output_folder}/[output-file-name]-{project_name}.md'
 workflowFile: '{workflow_path}/workflow.md'
 

package/src/modules/bmb/{docs/workflows → workflows/workflow}/templates/step-template.md

@@ -15,9 +15,9 @@ workflow\*path: '{project-root}/_bmad/[module]/reference/workflows/[workflow-nam
 
 # File References (all use {variable} format in file)
 
-thisStepFile: '{workflow_path}/steps/step-[N]-[short-name].md'
-nextStep{N+1}: '{workflow_path}/steps/step-[N+1]-[next-short-name].md' # Remove for final step or no next step
-altStep{Y}: '{workflow_path}/steps/step-[Y]-[some-other-step].md' # if there is an alternate next story depending on logic
+thisStepFile: './step-[N]-[short-name].md'
+nextStep{N+1}: './step-[N+1]-[next-short-name].md' # Remove for final step or no next step
+altStep{Y}: './step-[Y]-[some-other-step].md' # if there is an alternate next story depending on logic
 workflowFile: '{workflow_path}/workflow.md'
 outputFile: '{output_folder}/[output-file-name]-{project_name}.md'
 
@@ -74,7 +74,7 @@ Example: "To analyze user requirements and document functional specifications th
 
 ## EXECUTION PROTOCOLS:
 
-- 🎯 [Step-specific protocol 1]
+- 🎯 Follow the MANDATORY SEQUENCE exactly
 - 💾 [Step-specific protocol 2 - e.g., document updates]
 - 📖 [Step-specific protocol 3 - e.g., tracking requirements]
 - 🚫 [Step-specific restriction]
@@ -86,9 +86,9 @@ Example: "To analyze user requirements and document functional specifications th
 - Limits: [what not to assume or do]
 - Dependencies: [what this step depends on]
 
-## Sequence of Instructions (Do not deviate, skip, or optimize)
+## MANDATORY SEQUENCE
 
-[Detailed instructions for the step's work]
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 
 ### 1. Title
 
@@ -243,7 +243,7 @@ Display: "**Select an Option:** [A] [Continue to Step Foo] [A] [Continue to Step
 
 ### Initialization Step Example
 
-See [step-01-init.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/workflows/meal-prep-nutrition/steps/step-01-init.md) for an example of:
+See [step-01-discovery.md](../steps-c/step-01-discovery.md) for an example of:
 
 - Detecting existing workflow state and short circuit to 1b
 - Creating output documents from templates
@@ -252,16 +252,16 @@ See [step-01-init.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src
 
 ### Continuation Step Example
 
-See [step-01b-continue.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/workflows/meal-prep-nutrition/steps/step-01b-continue.md) for an example of:
+See [step-01b-continue.md](../steps-c/step-01b-continuation.md) for an example of:
 
-- Handling already-in-progress workflows
-- Detecting completion status
+- Handling already-in-progress workflows that the user now wants to continue progress
+- Detecting completion status (which step was already completed last)
 - Presenting update vs new plan options
-- Seamless workflow resumption
+- Seamless workflow resumption by reviewing existing plan and output thus far that has been recorded and then jumping to the proper step
 
 ### Standard Step with Menu Example
 
-See [step-02-profile.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/workflows/meal-prep-nutrition/steps/step-02-profile.md) for an example of:
+See [step-02-classification.md](../steps-c/step-02-classification.md#8-present-menu-options) for an example of:
 
 - Presenting a menu with A/P/C options
 - Forcing halt until user selects 'C' (Continue)
@@ -271,12 +271,12 @@ See [step-02-profile.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/
 
 ### Final Step Example
 
-See [step-06-prep-schedule.md](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/src/modules/bmb/reference/workflows/meal-prep-nutrition/steps/step-06-prep-schedule.md) for an example of:
+See [step-11-completion.md](../steps-c/step-11-completion.md) for an example of:
 
 - Completing workflow deliverables
 - Marking workflow as complete in frontmatter
 - Providing final success messages
-- Ending the workflow session gracefully
+- Ending the workflow session gracefully or moving on to a validation workflow if applicable
 
 ## Best Practices
 

package/src/modules/bmb/{docs/workflows → workflows/workflow}/templates/workflow-template.md

@@ -97,8 +97,6 @@ Copy the template above and replace:
 
 Update the last line of the workflow.md being created to replace [FIRST STEP FILE PATH] with the path to the actual first step file.
 
-Example: Load, read the full file and then execute `{workflow_path}/steps/step-01-init.md` to begin the workflow.
+Example: Load, read the full file and then execute `./step-01-init.md` to begin the workflow.
 
-### NOTE: You can View a real example of a perfect workflow.md file that was created from this template
-
-`{project-root}/_bmad/bmb/reference/workflows/meal-prep-nutrition/workflow.md`
+### NOTE: You can View a real example of a perfect workflow.md file from the one you were executed from `../workflow.md`

package/src/modules/bmb/workflows/workflow/workflow.md

@@ -0,0 +1,109 @@
+---
+name: workflow
+description: "Create structured standalone workflows using markdown-based step architecture (tri-modal: create, validate, edit)"
+web_bundle: true
+---
+
+# Create Workflow
+
+**Goal:** Create structured, repeatable standalone workflows through collaborative conversation and step-by-step guidance.
+
+**Your Role:** In addition to your name, communication_style, and persona, you are also a workflow architect and systems designer collaborating with a workflow creator. This is a partnership, not a client-vendor relationship. You bring expertise in workflow design patterns, step architecture, and collaborative facilitation, while the user brings their domain knowledge and specific workflow requirements. Work together as equals.
+
+**Meta-Context:** The workflow architecture described below (step-file architecture, micro-file design, JIT loading, sequential enforcement, state tracking) is exactly what you'll be helping users create for their own workflows. You're demonstrating the pattern while building it with them.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+- **Tri-Modal Structure**: Separate step folders for Create (steps-c/), Validate (steps-v/), and Edit (steps-e/) modes
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps or optimize the sequence
+- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
+- 🎯 **ALWAYS** follow the exact instructions in the step file
+- ⏸️ **ALWAYS** halt at menus and wait for user input
+- 📋 **NEVER** create mental todo lists from future steps
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from {project-root}/_bmad/bmb/config.yaml and resolve:
+
+- `project_name`, `output_folder`, `user_name`, `communication_language`, `document_output_language`, `bmb_creations_output_folder`
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. Mode Determination
+
+**Check if mode was specified in the command invocation:**
+
+- If user invoked with "create workflow" or "new workflow" or "build workflow" → Set mode to **create**
+- If user invoked with "validate workflow" or "review workflow" or "-v" or "--validate" → Set mode to **validate**
+- If user invoked with "validate workflow MAX-PARALLEL" or "review workflow MAX-PARALLEL" or "-vmax" or "--validate-max" → Set mode to **validate-max-parallel**
+- If user invoked with "edit workflow" or "modify workflow" or "-e" or "--edit" → Set mode to **edit**
+
+**If mode is still unclear, ask user:**
+
+"Welcome to the BMAD Workflow Creator! What would you like to do?
+
+**[C]reate** - Build a new workflow from scratch
+**[V]alidate** - Review an existing workflow and generate validation report
+**[VMP] Validate Max Parallel** - Review an existing workflow and generate validation report running max steps as possible in parallel
+**[E]dit** - Modify an existing workflow
+
+Please select: [C]reate / [V]alidate / [E]dit"
+
+### 3. Route to First Step
+
+**IF mode == create:**
+
+"**Creating a new workflow. How would you like to start?**
+
+**[F]rom scratch** - Start with a blank slate - I'll help you discover your idea
+**[C]onvert existing** - Convert an existing workflow to BMAD compliant format
+
+Please select: [F]rom scratch / [C]onvert existing"
+
+#### Create Mode Routing:
+
+- **IF F:** Load, read completely, then execute `steps-c/step-01-discovery.md`
+- **IF C:** Ask for workflow path: "Please provide the path to the workflow you want to convert."
+  Then load, read completely, then execute `steps-c/step-00-conversion.md`
+- **IF Any other:** help user respond, then redisplay create mode menu
+
+**IF mode == validate:**
+Prompt for workflow path: "Which workflow would you like to validate? Please provide the path to the workflow.md file."
+Then load, read completely, and execute `steps-v/step-01-validate.md`
+
+**IF mode == validate-max-parallel:**
+Prompt for workflow path: "Which workflow would you like to validate? Please provide the path to the workflow.md file." validate a subprocess or task agent tool or similar is available
+Then load, read completely, and execute `steps-v/step-01-validate-max-mode.md`
+
+**IF mode == edit:**
+Prompt for workflow path: "Which workflow would you like to edit? Please provide the path to the workflow.md file."
+Then load, read completely, and execute `steps-e/step-e-01-assess-workflow.md`

package/src/modules/bmgd/agents/game-architect.agent.yaml

@@ -7,6 +7,7 @@ agent:
     title: Game Architect
     icon: 🏛️
     module: bmgd
+    hasSidecar: false
 
   persona:
     role: Principal Game Systems Architect + Technical Director

package/src/modules/bmgd/agents/game-designer.agent.yaml

@@ -7,6 +7,7 @@ agent:
     title: Game Designer
     icon: 🎲
     module: bmgd
+    hasSidecar: false
 
   persona:
     role: Lead Game Designer + Creative Vision Architect

package/src/modules/bmgd/agents/game-dev.agent.yaml

@@ -7,6 +7,7 @@ agent:
     title: Game Developer
     icon: 🕹️
     module: bmgd
+    hasSidecar: false
 
   persona:
     role: Senior Game Developer + Technical Implementation Specialist

package/src/modules/bmgd/agents/game-qa.agent.yaml

@@ -7,6 +7,7 @@ agent:
     title: Game QA Architect
     icon: 🧪
     module: bmgd
+    hasSidecar: false
 
   persona:
     role: Game QA Architect + Test Automation Specialist

package/src/modules/bmgd/agents/game-scrum-master.agent.yaml

@@ -7,6 +7,7 @@ agent:
     title: Game Dev Scrum Master
     icon: 🎯
     module: bmgd
+    hasSidecar: false
 
   persona:
     role: Game Development Scrum Master + Sprint Orchestrator