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

package/src/modules/bmb/workflows/workflow/steps-v/step-08-collaborative-experience-check.md

@@ -0,0 +1,199 @@
+---
+name: 'step-08-collaborative-experience-check'
+description: 'Check collaborative quality - does this workflow facilitate well or just interrogate?'
+
+nextStepFile: './step-08b-subprocess-optimization.md'
+targetWorkflowPath: '{workflow_folder_path}'
+validationReportFile: '{workflow_folder_path}/validation-report-{datetime}.md'
+workflowPlanFile: '{workflow_folder_path}/workflow-plan.md'
+---
+
+# Validation Step 8: Collaborative Experience Check
+
+## STEP GOAL:
+
+To validate that the workflow actually facilitates well - natural conversation, not interrogation. Questions asked progressively, not in laundry lists.
+
+## 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
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- ✅ Validation does NOT stop for user input - auto-proceed through all validation steps
+
+### Step-Specific Rules:
+
+- 🎯 Review EVERY step for collaborative quality
+- 🚫 DO NOT skip any files or experience checks
+- 💬 Append findings to report, then auto-load next step
+- 🚪 This is validation - systematic and thorough
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Walk through the workflow as a user would
+- 💾 Check conversation flow in each step
+- 📖 Validate facilitation quality
+- 🚫 DO NOT halt for user input - validation runs to completion
+
+## CONTEXT BOUNDARIES:
+
+- Good workflows facilitate, don't interrogate
+- Questions should be 1-2 at a time
+- Conversation should feel natural
+- Check EVERY step for collaborative patterns
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip or shortcut.
+
+### 1. Load the Workflow Design
+
+From {workflowPlanFile}, understand:
+- What is the workflow's goal?
+- Who is the user?
+- What interaction style was designed?
+
+### 2. Review EACH Step for Collaborative Quality
+
+**DO NOT BE LAZY - For EACH step file:**
+
+1. Load the step
+2. Read the MANDATORY SEQUENCE section
+3. Evaluate against collaborative quality criteria:
+
+**Good Facilitation Indicators:**
+- ✅ "Ask 1-2 questions at a time"
+- ✅ "Think about their response before continuing"
+- ✅ "Use conversation, not interrogation"
+- ✅ "Probe to understand deeper"
+- ✅ Natural language in instructions
+- ✅ Allows for back-and-forth
+
+**Bad Interrogation Indicators:**
+- ❌ Laundry lists of questions
+- ❌ "Ask the following: 1, 2, 3, 4, 5, 6..."
+- ❌ Form-filling approach
+- ❌ No space for conversation
+- ❌ Rigid sequences without flexibility
+
+**Role Reinforcement Check:**
+- ✅ "You are a [role], we engage in collaborative dialogue"
+- ✅ "Together we produce something better"
+- ❌ "You are a form filler" (obviously bad, but check for patterns)
+
+### 3. Check Progression and Arc
+
+**Does the workflow have:**
+- ✅ Clear progression from step to step?
+- ✅ Each step builds on previous work?
+- ✅ User knows where they are in the process?
+- ✅ Satisfying completion at the end?
+
+**Or does it:**
+- ❌ Feel disjointed?
+- ❌ Lack clear progression?
+- ❌ Leave user unsure of status?
+
+### 4. Check Error Handling
+
+**Do steps handle:**
+- ✅ Invalid input gracefully?
+- ✅ User uncertainty with guidance?
+- ✅ Off-track conversation with redirection?
+- ✅ Edge cases with helpful messages?
+
+### 5. Document Findings
+
+```markdown
+### Collaborative Experience Check Results
+
+**Overall Facilitation Quality:** [Excellent/Good/Fair/Poor]
+
+**Step-by-Step Analysis:**
+
+**step-01-init.md:**
+- Question style: [Progressive/Laundry list]
+- Conversation flow: [Natural/Rigid]
+- Role clarity: ✅/❌
+- Status: ✅ PASS / ❌ FAIL
+
+**step-02-*.md:**
+- Question style: [Progressive/laundry list - "Ask 1-2 at a time" / Lists 5+ questions]
+- Allows conversation: ✅/❌
+- Thinks before continuing: ✅/❌
+- Status: ✅ PASS / ❌ FAIL
+
+[Continue for ALL steps...]
+
+**Collaborative Strengths Found:**
+- [List examples of good facilitation]
+- [Highlight steps that excel at collaboration]
+
+**Collaborative Issues Found:**
+
+**Laundry List Questions:**
+- [List steps with question dumps]
+- Example: "step-03-*.md asks 7 questions at once"
+
+**Rigid Sequences:**
+- [List steps that don't allow conversation]
+- Example: "step-04-*.md has no space for back-and-forth"
+
+**Form-Filling Patterns:**
+- [List steps that feel like form filling]
+- Example: "step-05-*.md collects data without facilitation"
+
+**Progression Issues:**
+- [List problems with flow/arc]
+- Example: "step-06-*.md doesn't connect to previous step"
+
+**User Experience Assessment:**
+
+**Would this workflow feel like:**
+- [ ] A collaborative partner working WITH the user
+- [ ] A form collecting data FROM the user
+- [ ] An interrogation extracting information
+- [ ] A mix - depends on step
+
+**Overall Collaborative Rating:** ⭐⭐⭐⭐⭐ [1-5 stars]
+
+**Status:** ✅ EXCELLENT / ✅ GOOD / ⚠️ NEEDS IMPROVEMENT / ❌ POOR
+```
+
+### 6. Append to Report
+
+Update {validationReportFile} - replace "## Collaborative Experience Check *Pending...*" with actual findings.
+
+### 7. Save Report and Auto-Proceed
+
+**CRITICAL:** Save the validation report BEFORE loading next step.
+
+Then immediately load, read entire file, then execute {nextStepFile}.
+
+**Display:**
+"**Collaborative Experience check complete.** Proceeding to Cohesive Review..."
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- EVERY step reviewed for collaborative quality
+- Question patterns analyzed (progressive vs laundry list)
+- Conversation flow validated
+- Issues documented with specific examples
+- Findings appended to report
+- Report saved before proceeding
+- Next validation step loaded
+
+### ❌ SYSTEM FAILURE:
+
+- Not checking every step's collaborative quality
+- Missing question pattern analysis
+- Not documenting experience issues
+- Not saving report before proceeding
+
+**Master Rule:** Validation is systematic and thorough. DO NOT BE LAZY. Check EVERY step's collaborative quality. Auto-proceed through all validation steps.

package/src/modules/bmb/workflows/workflow/steps-v/step-08b-subprocess-optimization.md

@@ -0,0 +1,179 @@
+---
+name: 'step-08b-subprocess-optimization'
+description: 'Identify subprocess optimization opportunities - reduce context load, improve performance'
+
+nextStepFile: './step-09-cohesive-review.md'
+targetWorkflowPath: '{workflow_folder_path}'
+validationReportFile: '{workflow_folder_path}/validation-report-{datetime}.md'
+subprocessPatterns: '../data/subprocess-optimization-patterns.md'
+---
+
+# Validation Step 8b: Subprocess Optimization Analysis
+
+## STEP GOAL:
+
+To identify opportunities for subprocess optimization throughout the workflow - reducing context load, improving performance, and enabling massive operations that would otherwise exceed context limits.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 DO NOT BE LAZY - ANALYZE EVERY FILE IN ITS OWN SUBPROCESS
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- ✅ Validation does NOT stop for user input - auto-proceed through all validation steps
+- ⚙️ If any instruction references a subprocess/subagent/tool you do not have access to, you MUST still achieve the outcome in your main context
+
+### Step-Specific Rules:
+
+- 🎯 Analyze EVERY step file for subprocess optimization - each file in its own subprocess
+- 🚫 DO NOT skip any file - DO NOT BE LAZY
+- 💬 Load {subprocessPatterns} in subprocess performing some action required to understand patterns deeply with examples (if subprocess available), else load in main context
+- 🚪 This identifies context-saving and performance-optimizing opportunities
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Analyze each step file in its own subprocess - deep analysis of subprocess potential
+- 💾 Subprocesses must identify optimization patterns and return findings to parent for aggregation
+- 📖 Aggregate findings into validation report before loading next step
+
+## CONTEXT BOUNDARIES:
+
+- Three patterns: grep/regex across files, per-file deep analysis, data file operations, parallel execution
+- **Context-saving goal**: Return ONLY key findings to parent, not full file contents
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip or shortcut.
+
+### 1. Load Subprocess Pattern Reference (Context Optimization!)
+
+**First, understand the subprocess optimization patterns by loading {subprocessPatterns}:**
+
+**If subprocess capability available:**
+```markdown
+Launch a subprocess that:
+1. Loads {subprocessPatterns}
+2. Studies all patterns and examples deeply (Pattern 3: data operations!)
+3. Returns summary of key patterns to parent (not full file - saves context)
+```
+
+**If subprocess unavailable:**
+```markdown
+Load {subprocessPatterns} in main context
+# Larger context but still functional - demonstrates graceful fallback
+```
+
+**This step itself demonstrates Pattern 3 from the reference!**
+
+---
+
+### 2. Perform Subprocess Optimization Analysis
+
+**DO NOT BE LAZY - For EVERY step file, launch a subprocess that:**
+
+1. Loads that step file
+2. ALSO loads {subprocessPatterns} to understand all patterns deeply (subprocess needs full context!)
+3. Analyzes the step against each pattern looking for optimization opportunities
+4. Returns specific, actionable suggestions to parent
+
+**Subprocess gets full context:**
+- The step file being analyzed
+- The subprocess-optimization-patterns.md reference (all examples and patterns)
+- Returns only findings to parent (context savings!)
+
+**SUBPROCESS ANALYSIS PATTERN - Check each step file for:**
+
+**Pattern 1: Single subprocess for grep/regex** - Operations that check/search multiple files for patterns (frontmatter validation, menu checks, path searches). Suggest: "Use single grep subprocess, return only matches"
+
+**Pattern 2: Separate subprocess per file** - Operations requiring deep analysis of prose/logic/quality/style/flow per file (instruction review, collaborative quality assessment, step type compliance). Suggest: "Each file in own subprocess, return analysis findings"
+
+**Pattern 3: Subprocess for data operations** - Operations loading large data files to find matches, extract key details, or summarize findings. Suggest: "Subprocess loads data, returns ONLY relevant rows/findings"
+
+**Pattern 4: Parallel execution** - Independent operations that could run simultaneously. Suggest: "Run in parallel subprocesses to reduce execution time"
+
+**RETURN FORMAT (example structure, adapt as needed):**
+```json
+{
+  "step_file": "step-02-*.md",
+  "opportunities": [
+    {
+      "pattern": "grep/regex|per-file|data-ops|parallel",
+      "location": "Line XX: [quote relevant instruction]",
+      "issue": "Loads all files into parent context",
+      "suggestion": "Use single grep subprocess, return only failures",
+      "impact": "Saves ~N lines per file, faster execution",
+      "priority": "HIGH|MEDIUM|LOW"
+    }
+  ]
+}
+```
+
+### 2. Aggregate Findings and Create Report Section
+
+After ALL files analyzed, create/update section in {validationReportFile}:
+
+```markdown
+## Subprocess Optimization Opportunities
+
+**Total Opportunities:** {count} | **High Priority:** {count} | **Estimated Context Savings:** {description}
+
+### High-Priority Opportunities
+
+**{Step Name}** - {Pattern Type}
+- **Current:** {brief description of current approach}
+- **Suggested:** {specific optimization suggestion}
+- **Impact:** {context savings, performance gain}
+- **Example:** `{brief code/pseudocode}`
+
+[Repeat for each high-priority opportunity...]
+
+### Moderate/Low-Priority Opportunities
+
+{List with brief descriptions}
+
+### Summary by Pattern
+
+- **Pattern 1 (grep/regex):** {count} opportunities - {total savings}
+- **Pattern 2 (per-file):** {count} opportunities - {total savings}
+- **Pattern 3 (data ops):** {count} opportunities - {total savings}
+- **Pattern 4 (parallel):** {count} opportunities - {performance gain}
+
+### Implementation Recommendations
+
+**Quick Wins:** {easy implementations with big savings}
+**Strategic:** {higher effort but big payoff}
+**Future:** {moderate impact, consider later}
+
+**Status:** ✅ Complete / ⚠️ Review recommended
+```
+
+### 3. Save Report and Auto-Proceed
+
+**CRITICAL:** Save report BEFORE loading next step.
+
+Then load, read entire file, execute {nextStepFile}.
+
+**Display:** "**Subprocess optimization analysis complete.** Identified {count} opportunities with potential context savings. Proceeding to Cohesive Review..."
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- EVERY step file analyzed in its own subprocess
+- ALL optimization opportunities identified
+- Findings aggregated into report
+- Prioritized recommendations with context savings
+- Report saved, next step loaded
+
+### ❌ SYSTEM FAILURE:
+
+- Not analyzing every file
+- Skipping opportunity identification
+- Not providing specific suggestions
+- Not estimating savings
+- Not aggregating findings
+
+**Master Rule:** DO NOT BE LAZY. Analyze EVERY file in its own subprocess. Identify ALL optimization opportunities across 4 patterns. Provide specific, actionable recommendations with context savings. Return findings to parent. Auto-proceed.

package/src/modules/bmb/workflows/workflow/steps-v/step-09-cohesive-review.md

@@ -0,0 +1,186 @@
+---
+name: 'step-09-cohesive-review'
+description: 'Cohesive ultra-think review - overall quality, does this workflow actually facilitate well?'
+
+nextStepFile: './step-10-report-complete.md'
+targetWorkflowPath: '{workflow_folder_path}'
+validationReportFile: '{workflow_folder_path}/validation-report-{datetime}.md'
+workflowPlanFile: '{workflow_folder_path}/workflow-plan.md'
+---
+
+# Validation Step 9: Cohesive Review
+
+## STEP GOAL:
+
+To perform a cohesive "ultra-think" review of the entire workflow - walk through it as a whole, assess overall quality, does it actually facilitate well?
+
+## 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
+- 🔄 CRITICAL: When loading next step, ensure entire file is read
+- ✅ Validation does NOT stop for user input - auto-proceed through all validation steps
+- ⚙️ 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:
+
+- 🎯 Review the workflow as a cohesive whole - **NOTE: This step loads ENTIRE workflow for holistic review (different pattern from other validation steps)**
+- 🚫 DO NOT skip any aspect of the review - DO NOT BE LAZY
+- 💬 Subprocess optimization: When available, can use subprocesses to load individual step files and return structured summaries to parent for aggregation
+- 💬 However, since cohesive review requires understanding the COMPLETE workflow as one unit, parent may need full context for proper holistic assessment
+- 🚪 This is the meta-review - overall assessment
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Walk through the ENTIRE workflow end-to-end using subprocess optimization when available
+- 💬 When using subprocesses: Each subprocess loads one step file, performs deep analysis, returns structured findings to parent for aggregation
+- 💬 Subprocess must either update validation report directly OR return findings to parent for compilation
+- 💾 Assess overall quality, not just individual components
+- 📖 Think deeply: would this actually work well?
+- 🚫 DO NOT halt for user input - validation runs to completion
+
+## CONTEXT BOUNDARIES:
+
+- This is the cohesive review - look at the workflow as a whole
+- Consider user experience from start to finish
+- Assess whether the workflow achieves its goal
+- Be thorough and thoughtful
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip or shortcut.
+
+### 1. Load the Entire Workflow
+
+**DO NOT BE LAZY - Load EVERY step file using subprocess optimization when available:**
+
+**SUBPROCESS APPROACH (when available):**
+
+For EACH workflow file (workflow.md + all step files in order), launch a subprocess that:
+1. Loads that single file
+2. Performs deep analysis of content, flow, quality, and connection points
+3. Returns structured findings to parent for holistic aggregation
+
+**Subprocess should return:**
+- File name analyzed
+- Purpose and flow position within the workflow
+- How it connects to previous and next steps
+- Quality indicators and any issues found
+- Voice and tone consistency assessment
+
+**FALLBACK APPROACH (if subprocess unavailable):**
+
+Load workflow.md and EVERY step file in steps-c/ sequentially in main context:
+1. Load workflow.md
+2. Load EVERY step file in steps-c/ in order
+3. Read through each step
+4. Understand the complete flow
+
+**CRITICAL:** Whether using subprocess or main context, you must understand the COMPLETE workflow as one cohesive unit before proceeding to assessment.
+
+### 2. Walk Through the Workflow Mentally
+
+**Imagine you are a user running this workflow:**
+
+- Starting from workflow.md
+- Going through step-01
+- Progressing through each step
+- Experiencing the interactions
+- Reaching the end
+
+**Ask yourself:**
+- Does this make sense?
+- Is the flow logical?
+- Would I feel guided or confused?
+- Does it achieve its goal?
+
+### 3. Assess Cohesiveness
+
+**Check for:**
+
+**✅ Cohesive Indicators:**
+- Each step builds on previous work
+- Clear progression toward goal
+- Consistent voice and approach throughout
+- User always knows where they are
+- Satisfying completion
+
+**❌ Incohesive Indicators:**
+- Steps feel disconnected
+- Jumps in logic or flow
+- Inconsistent patterns
+- User might be confused
+- Abrupt or unclear ending
+
+### 4. Assess Overall Quality
+
+**Evaluate the workflow across key dimensions:**
+
+Consider goal clarity, logical flow, facilitation quality, user experience, and goal achievement. Provide an overall quality assessment based on these dimensions.
+
+### 5. Identify Strengths and Weaknesses
+
+**Strengths:**
+- What does this workflow do well?
+- What makes it excellent?
+- What should other workflows emulate?
+
+**Weaknesses:**
+- What could be improved?
+- What doesn't work well?
+- What would confuse users?
+
+**Critical Issues:**
+- Are there any show-stopper problems?
+- Would this workflow fail in practice?
+
+### 6. Provide Recommendation
+
+**Assess overall workflow readiness:**
+
+Determine if the workflow is excellent (ready to use, exemplifies best practices), good (solid with minor improvements possible), needs work (has issues to address), or problematic (major issues requiring significant revision). Provide a clear recommendation on readiness for use.
+
+### 7. Document Findings
+
+**Document your cohesive review findings in the validation report:**
+
+Include your overall assessment (excellent/good/needs work/problematic), quality evaluation across key dimensions, cohesiveness analysis (flow, progression, voice and tone), identified strengths and weaknesses, any critical issues, what makes the workflow work well, what could be improved, user experience forecast, and your recommendation on readiness for use.
+
+### 8. Append to Report
+
+Update {validationReportFile} - replace "## Cohesive Review *Pending...*" with actual findings.
+
+### 9. Save Report and Auto-Proceed
+
+**CRITICAL:** Save the validation report BEFORE loading next step.
+
+Then immediately load, read entire file, then execute {nextStepFile}.
+
+**Display:**
+"**Cohesive Review complete.** Proceeding to finalize validation report..."
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- ENTIRE workflow reviewed end-to-end
+- Quality assessed across multiple dimensions
+- Strengths and weaknesses documented
+- Thoughtful recommendation provided
+- Findings appended to report
+- Report saved before proceeding
+- Next validation step loaded
+
+### ❌ SYSTEM FAILURE:
+
+- Not reviewing the entire workflow
+- Superficial or lazy assessment
+- Not documenting strengths/weaknesses
+- Not providing clear recommendation
+- Not saving report before proceeding
+
+**Master Rule:** Validation is systematic and thorough. DO NOT BE LAZY. Review the ENTIRE workflow cohesively. Think deeply about quality. Auto-proceed through all validation steps.