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

package/src/modules/bmb/workflows/workflow/steps-c/step-08-build-step-01.md

@@ -0,0 +1,377 @@
+---
+name: 'step-08-build-step-01'
+description: 'Build step-01-init.md and step-01b-continue.md (if continuable) with any supporting files'
+
+nextStepFile: './step-09-build-next-step.md'
+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'
+inputDiscoveryStandards: '../data/input-discovery-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 8: Build Step 01 (and 01b if Continuable)
+
+## STEP GOAL:
+
+To build the first step file(s) for the new workflow - step-01-init.md and step-01b-continue.md if the workflow is continuable - including any supporting files these steps need.
+
+## 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 building step-01 (and 01b if continuable)
+- 🚫 FORBIDDEN to build other steps yet - use step-09 for those
+- 💬 Generate step content collaboratively based on approved design
+- 🚪 CREATE files in the correct target location
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load standards to understand step type patterns
+- 💾 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 design from step 6 specifies step-01's purpose and type
+- Load step type patterns to understand init step structure
+- Frontmatter and menu standards ensure compliance
+- This is the FIRST step - sets up everything that follows
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. Load Standards for Init Steps
+
+**Load {stepTypePatterns}** to understand the init step patterns:
+- Init Step (Non-Continuable) - For single-session workflows
+- Init Step (Continuable) - For multi-session workflows
+- Init Step (With Input Discovery) - If workflow needs prior documents
+
+**Load {frontmatterStandards}** for variable and path rules.
+
+**Load {menuHandlingStandards}** for menu patterns (init steps typically use auto-proceed or C-only).
+
+### 2. Determine Step 01 Type
+
+From the approved design, determine:
+
+**Is the workflow continuable?**
+- **YES:** Use Init Step (Continuable) pattern
+- **NO:** Use Init Step (Non-Continuable) pattern
+
+**Does the workflow need input discovery?**
+- **YES:** Use Init Step (With Input Discovery) pattern
+- **NO:** Standard init pattern
+
+Confirm with user: "Based on your design, step-01 will be [continuable/non-continuable] with [input discovery/standard init]. Is this correct?"
+
+### 3. Build step-01-init.md
+
+**Load {stepTemplate}** for base structure.
+
+Create `steps-c/step-01-init.md` with:
+
+**Frontmatter:**
+```yaml
+---
+name: 'step-01-init'
+description: '[from design]'
+
+# File references (ONLY variables used in this step)
+nextStepFile: './step-02-[next-step-name].md'
+outputFile: '{output_folder}/[output-name].md'
+templateFile: '../templates/output-template.md'  # If applicable
+
+# Continuation support (if continuable)
+continueFile: './step-01b-continue.md'  # If continuable
+
+# Input discovery (if needed)
+inputDocuments: []
+requiredInputCount: [number]
+moduleInputFolder: '{module_output_folder}'
+inputFilePatterns: ['*-prd.md', '*-ux.md']  # From design
+
+# 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:**
+```markdown
+# Step 1: [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], user brings [theirs]
+- ✅ Together we produce something better
+
+### Step-Specific Rules:
+- 🎯 Focus only on [specific task for step-01]
+- 🚫 FORBIDDEN to [prohibited action]
+- 💬 Approach: [how to engage]
+
+## EXECUTION PROTOCOLS:
+- 🎯 [Protocol 1]
+- 💾 [Protocol 2 - create/append to output]
+- 📖 [Protocol 3 - tracking]
+- 🚫 This is the init step - sets up everything
+
+## CONTEXT BOUNDARIES:
+- [What's available at step 01]
+- Focus: [what to focus on]
+- Limits: [boundaries]
+- Dependencies: [none - this is first step]
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+### 1. [First action - from design]
+[Instructions for step-01 - intent-based, not prescriptive]
+
+### 2. [Second action - from design]
+[Instructions]
+
+### ... [continue for all actions in step-01]
+
+### N. Present MENU OPTIONS
+[Menu from design - typically C-only for init, or A/P/C if appropriate]
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+
+#### Menu Handling Logic:
+- IF C: Create/append to {outputFile} with content, update frontmatter stepsCompleted, then load, read entire file, then execute {nextStepFile}
+- IF Any other: help user, then redisplay menu
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+### ✅ SUCCESS:
+[What success looks like for step-01]
+
+### ❌ SYSTEM FAILURE:
+[What failure looks like]
+
+**Master Rule:** Skipping steps is FORBIDDEN.
+```
+
+**Customize content based on:**
+- The step's goal from the design
+- The workflow's role and persona
+- Whether it's continuable
+- Whether it needs input discovery
+- The template type (if document-producing)
+
+### 4. Build step-01b-continue.md (If Continuable)
+
+**If workflow is continuable**, create `steps-c/step-01b-continue.md`:
+
+**Frontmatter:**
+```yaml
+---
+name: 'step-01b-continue'
+description: 'Handle workflow continuation from previous session'
+
+outputFile: '{output_folder}/[output-name].md'
+workflowFile: '../workflow.md'
+nextStepOptions:
+  step-02: './step-02-[name].md'
+  step-03: './step-03-[name].md'
+  # ... add all subsequent steps
+---
+```
+
+**Content:**
+```markdown
+# Step 1b: Continue Workflow
+
+## STEP GOAL:
+To resume the workflow from where it was left off in a previous session.
+
+## MANDATORY EXECUTION RULES:
+[Standard universal rules]
+
+## CONTEXT BOUNDARIES:
+- User has run this workflow before
+- Output file exists with stepsCompleted array
+- Need to route to the correct next step
+
+## MANDATORY SEQUENCE
+
+### 1. Welcome Back
+"**Welcome back!** Let me check where we left off..."
+
+### 2. Read stepsCompleted from Output
+Load {outputFile} and read frontmatter `stepsCompleted` array.
+
+### 3. Determine Next Step
+Find the last completed step and identify the next step to load.
+
+### 4. Route to Correct Step
+Load the appropriate next step file based on stepsCompleted.
+
+## MENU OPTIONS
+Display continuation status and offer to proceed.
+
+## SUCCESS/FAILURE METRICS
+[Standard metrics]
+```
+
+### 5. Create Supporting Files (If Needed)
+
+**Does step-01 need any:**
+
+**Small templates?** (inline in step, no separate file needed)
+
+**Data files?** (create if step references CSV data)
+
+**Validation checklists?** (create if step validates something)
+
+**If supporting files are needed, create them in `data/` folder and update step-01 frontmatter to reference them.**
+
+### 5a. Apply Subprocess Optimization (If Designed)
+
+**Check the approved design from step 6:** Was subprocess optimization identified for step-01?
+
+**If YES, apply the appropriate pattern(s):**
+
+Load {subprocessPatterns} and implement the subprocess optimization:
+
+1. **Identify the pattern(s) from the design:**
+   - 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:**
+   ```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 step-01:**
+
+Skip this section and proceed to document build in plan.
+
+### 6. Document Build in Plan
+
+Append to {workflowPlanFile}:
+
+```markdown
+## Step 01 Build Complete
+
+**Created:**
+- steps-c/step-01-init.md
+- steps-c/step-01b-continue.md [if continuable]
+- [any supporting files]
+
+**Step Configuration:**
+- Type: [continuable/non-continuable]
+- Input Discovery: [yes/no]
+- Next Step: step-02-[name]
+
+**Supporting Files:**
+- [list any data files, templates created]
+```
+
+### 7. Present MENU OPTIONS
+
+Display: **Step 01 Complete - Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Next Step 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
+
+#### 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}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#7-present-menu-options)
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and build is saved to plan will you load {nextStepFile} to begin building the next step.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- step-01-init.md created with proper structure
+- step-01b-continue.md created (if continuable)
+- Frontmatter follows {frontmatterStandards}
+- Menu handling follows {menuHandlingStandards}
+- Step type pattern followed correctly
+- Supporting files created (if needed)
+- Build documented in plan
+
+### ❌ SYSTEM FAILURE:
+
+- Creating step without following template
+- Missing continuation support for continuable workflow
+- Wrong menu pattern for step type
+- Frontmatter variables not used in step body
+- Hardcoded paths instead of variables
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.