@devo-bmad-custom/agent-orchestration 1.0.2 → 1.0.4

package/src/bmb/workflows/workflow/data/menu-handling-standards.md

@@ -1,133 +1,133 @@
-# Menu Handling Standards
-
-**CRITICAL:** Every menu MUST have a handler section. No exceptions.
-
-## Reserved Letters
-
-| Letter | Purpose              | After Execution                |
-| ------ | -------------------- | ------------------------------ |
-| **A**  | Advanced Elicitation | Redisplay menu                |
-| **P**  | Party Mode           | Redisplay menu                |
-| **C**  | Continue/Accept      | Save → update → load next step |
-| **X**  | Exit/Cancel          | End workflow                  |
-
-**Custom letters** allowed (L/R/F/etc.) but don't conflict with reserved.
-
-## Required Structure
-
-### Section 1: Display
-```markdown
-### N. Present MENU OPTIONS
-Display: "**Select:** [A] [action] [P] [action] [C] Continue"
-```
-
-### Section 2: Handler (MANDATORY)
-```markdown
-#### 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 content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
-- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
-```
-
-### Section 3: Execution Rules
-```markdown
-#### 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
-```
-
-## When To Include A/P
-
-**DON'T Include A/P:** Step 1 (init), Step 2 if only loading documents, validation sequences, simple data gathering
-
-**DO Include A/P:** Collaborative content creation, user might want alternatives, quality gate before proceeding, creative exploration valuable
-
-## Menu Patterns
-
-### Pattern 1: Standard A/P/C
-```markdown
-Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
-
-#### 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 content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
-- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
-
-#### 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
-```
-
-### Pattern 2: C Only (No A/P)
-```markdown
-Display: "**Select:** [C] Continue"
-
-#### Menu Handling Logic:
-- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
-- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to next step when user selects 'C'
-```
-
-**Use for:** Step 1, document discovery, simple progression
-
-### Pattern 3: Auto-Proceed (No Menu)
-```markdown
-Display: "**Proceeding to [next step]...**"
-
-#### Menu Handling Logic:
-- After [completion condition], immediately load, read entire file, then execute {nextStepFile}
-
-#### EXECUTION RULES:
-- This is an [auto-proceed reason] step with no user choices
-- Proceed directly to next step after setup
-```
-
-**Use for:** Init steps, validation sequences
-
-### Pattern 4: Branching
-```markdown
-Display: "**Select:** [L] Load Existing [N] Create New [C] Continue"
-
-#### Menu Handling Logic:
-- IF L: Load existing document, then load, read entire file, then execute {stepForExisting}
-- IF N: Create new document, then load, read entire file, then execute {stepForNew}
-- IF C: Save content to {outputFile}, update frontmatter, check {condition}, then load appropriate step
-- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
-
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting menu
-- Branching options load different steps based on user choice
-```
-
-## Critical Rules
-
-### ❌ DON'T:
-- Omit handler section after Display
-- Include A/P in Step 1 (no content to refine)
-- Forget "redisplay menu" for non-C options
-- Miss "halt and wait" in EXECUTION RULES
-
-### ✅ DO:
-- Handler section immediately follows Display
-- "Halt and wait" in EXECUTION RULES
-- Non-C options specify "redisplay menu"
-- A/P only when appropriate for step type
-
-## Validation Checklist
-
-For every menu:
-- [ ] Display section present
-- [ ] Handler section immediately follows
-- [ ] EXECUTION RULES section present
-- [ ] "Halt and wait" instruction included
-- [ ] A/P options appropriate for step type
-- [ ] Non-C options redisplay menu
-- [ ] C option: save → update → load next
-- [ ] All file references use variables
+# Menu Handling Standards
+
+**CRITICAL:** Every menu MUST have a handler section. No exceptions.
+
+## Reserved Letters
+
+| Letter | Purpose              | After Execution                |
+| ------ | -------------------- | ------------------------------ |
+| **A**  | Advanced Elicitation | Redisplay menu                |
+| **P**  | Party Mode           | Redisplay menu                |
+| **C**  | Continue/Accept      | Save → update → load next step |
+| **X**  | Exit/Cancel          | End workflow                  |
+
+**Custom letters** allowed (L/R/F/etc.) but don't conflict with reserved.
+
+## Required Structure
+
+### Section 1: Display
+```markdown
+### N. Present MENU OPTIONS
+Display: "**Select:** [A] [action] [P] [action] [C] Continue"
+```
+
+### Section 2: Handler (MANDATORY)
+```markdown
+#### 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 content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
+```
+
+### Section 3: Execution Rules
+```markdown
+#### 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
+```
+
+## When To Include A/P
+
+**DON'T Include A/P:** Step 1 (init), Step 2 if only loading documents, validation sequences, simple data gathering
+
+**DO Include A/P:** Collaborative content creation, user might want alternatives, quality gate before proceeding, creative exploration valuable
+
+## Menu Patterns
+
+### Pattern 1: Standard A/P/C
+```markdown
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### 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 content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
+
+#### 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
+```
+
+### Pattern 2: C Only (No A/P)
+```markdown
+Display: "**Select:** [C] Continue"
+
+#### Menu Handling Logic:
+- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+```
+
+**Use for:** Step 1, document discovery, simple progression
+
+### Pattern 3: Auto-Proceed (No Menu)
+```markdown
+Display: "**Proceeding to [next step]...**"
+
+#### Menu Handling Logic:
+- After [completion condition], immediately load, read entire file, then execute {nextStepFile}
+
+#### EXECUTION RULES:
+- This is an [auto-proceed reason] step with no user choices
+- Proceed directly to next step after setup
+```
+
+**Use for:** Init steps, validation sequences
+
+### Pattern 4: Branching
+```markdown
+Display: "**Select:** [L] Load Existing [N] Create New [C] Continue"
+
+#### Menu Handling Logic:
+- IF L: Load existing document, then load, read entire file, then execute {stepForExisting}
+- IF N: Create new document, then load, read entire file, then execute {stepForNew}
+- IF C: Save content to {outputFile}, update frontmatter, check {condition}, then load appropriate step
+- IF Any other: help user, then [Redisplay Menu Options](#n-present-menu-options)
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input after presenting menu
+- Branching options load different steps based on user choice
+```
+
+## Critical Rules
+
+### ❌ DON'T:
+- Omit handler section after Display
+- Include A/P in Step 1 (no content to refine)
+- Forget "redisplay menu" for non-C options
+- Miss "halt and wait" in EXECUTION RULES
+
+### ✅ DO:
+- Handler section immediately follows Display
+- "Halt and wait" in EXECUTION RULES
+- Non-C options specify "redisplay menu"
+- A/P only when appropriate for step type
+
+## Validation Checklist
+
+For every menu:
+- [ ] Display section present
+- [ ] Handler section immediately follows
+- [ ] EXECUTION RULES section present
+- [ ] "Halt and wait" instruction included
+- [ ] A/P options appropriate for step type
+- [ ] Non-C options redisplay menu
+- [ ] C option: save → update → load next
+- [ ] All file references use variables

package/src/bmb/workflows/workflow/data/output-format-standards.md

@@ -1,135 +1,135 @@
-# Output Format Standards
-
-## Golden Rule
-
-**Every step MUST output to a document BEFORE loading the next step.**
-
-Two patterns:
-1. **Direct-to-Final:** Steps append to final document
-2. **Plan-then-Build:** Steps append to plan → build step consumes plan
-
-## Menu C Option Sequence
-
-When user selects **C (Continue)**:
-1. **Append/Write** to document (plan or final)
-2. **Update frontmatter** (append this step to `stepsCompleted`)
-3. **THEN** load next step
-
-```markdown
-- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
-```
-
-## Output Patterns
-
-### Pattern 1: Plan-then-Build
-
-```
-Step 1 (init)     → Creates plan.md from template
-Step 2 (gather)   → Appends requirements to plan.md
-Step 3 (design)   → Appends design decisions to plan.md
-Step 4 (review)   → Appends review/approval to plan.md
-Step 5 (build)    → READS plan.md, CREATES final artifacts
-```
-
-**Plan frontmatter:**
-```yaml
-workflowName: [name]
-creationDate: [date]
-stepsCompleted: ['step-01-init', 'step-02-gather']
-status: PLANNING_COMPLETE
-```
-
-### Pattern 2: Direct-to-Final
-
-```
-Step 1 (init)     → Creates final-doc.md from minimal template
-Step 2 (section)  → Appends Section 1
-Step 3 (section)  → Appends Section 2
-Step 4 (section)  → Appends Section 3
-Step 5 (polish)   → Optimizes entire document
-```
-
-## Four Template Types
-
-### 1. Free-Form (RECOMMENDED)
-- Minimal template, progressive append, final polish
-
-```yaml
----
-stepsCompleted: []
-lastStep: ''
-date: ''
-user_name: ''
----
-
-# {{document_title}}
-
-[Content appended progressively by workflow steps]
-```
-
-### 2. Structured
-- Single template with placeholders, clear sections
-
-```markdown
-# {{title}}
-
-## {{section_1}}
-[Content to be filled]
-
-## {{section_2}}
-[Content to be filled]
-```
-
-### 3. Semi-Structured
-- Core required sections + optional additions
-
-### 4. Strict
-- Multiple templates, exact field definitions
-- Use for: compliance, legal, regulated
-
-## Template Syntax
-
-```markdown
-{{variable}}    # Handlebars style (preferred)
-[variable]      # Bracket style (also supported)
-```
-
-Keep templates lean - structure only, not content.
-
-## Step-to-Output Mapping
-
-Steps should be in ORDER of document appearance:
-
-```
-Step 1: Init (creates doc)
-Step 2: → ## Section 1
-Step 3: → ## Section 2
-Step 4: → ## Section 3
-Step 5: → ## Section 4
-Step 6: Polish (optimizes entire doc)
-```
-
-**Critical:** Use ## Level 2 headers for main sections - allows document splitting if needed.
-
-## Final Polish Step
-
-For free-form workflows, include a polish step that:
-1. Loads entire document
-2. Reviews for flow and coherence
-3. Reduces duplication
-4. Ensures proper ## Level 2 headers
-5. Improves transitions
-6. Keeps general order but optimizes readability
-
-## Output File Patterns
-
-```yaml
-# Single output
-outputFile: '{output_folder}/document-{project_name}.md'
-
-# Time-stamped
-outputFile: '{output_folder}/document-{project_name}-{timestamp}.md'
-
-# User-specific
-outputFile: '{output_folder}/document-{user_name}-{project_name}.md'
-```
+# Output Format Standards
+
+## Golden Rule
+
+**Every step MUST output to a document BEFORE loading the next step.**
+
+Two patterns:
+1. **Direct-to-Final:** Steps append to final document
+2. **Plan-then-Build:** Steps append to plan → build step consumes plan
+
+## Menu C Option Sequence
+
+When user selects **C (Continue)**:
+1. **Append/Write** to document (plan or final)
+2. **Update frontmatter** (append this step to `stepsCompleted`)
+3. **THEN** load next step
+
+```markdown
+- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+```
+
+## Output Patterns
+
+### Pattern 1: Plan-then-Build
+
+```
+Step 1 (init)     → Creates plan.md from template
+Step 2 (gather)   → Appends requirements to plan.md
+Step 3 (design)   → Appends design decisions to plan.md
+Step 4 (review)   → Appends review/approval to plan.md
+Step 5 (build)    → READS plan.md, CREATES final artifacts
+```
+
+**Plan frontmatter:**
+```yaml
+workflowName: [name]
+creationDate: [date]
+stepsCompleted: ['step-01-init', 'step-02-gather']
+status: PLANNING_COMPLETE
+```
+
+### Pattern 2: Direct-to-Final
+
+```
+Step 1 (init)     → Creates final-doc.md from minimal template
+Step 2 (section)  → Appends Section 1
+Step 3 (section)  → Appends Section 2
+Step 4 (section)  → Appends Section 3
+Step 5 (polish)   → Optimizes entire document
+```
+
+## Four Template Types
+
+### 1. Free-Form (RECOMMENDED)
+- Minimal template, progressive append, final polish
+
+```yaml
+---
+stepsCompleted: []
+lastStep: ''
+date: ''
+user_name: ''
+---
+
+# {{document_title}}
+
+[Content appended progressively by workflow steps]
+```
+
+### 2. Structured
+- Single template with placeholders, clear sections
+
+```markdown
+# {{title}}
+
+## {{section_1}}
+[Content to be filled]
+
+## {{section_2}}
+[Content to be filled]
+```
+
+### 3. Semi-Structured
+- Core required sections + optional additions
+
+### 4. Strict
+- Multiple templates, exact field definitions
+- Use for: compliance, legal, regulated
+
+## Template Syntax
+
+```markdown
+{{variable}}    # Handlebars style (preferred)
+[variable]      # Bracket style (also supported)
+```
+
+Keep templates lean - structure only, not content.
+
+## Step-to-Output Mapping
+
+Steps should be in ORDER of document appearance:
+
+```
+Step 1: Init (creates doc)
+Step 2: → ## Section 1
+Step 3: → ## Section 2
+Step 4: → ## Section 3
+Step 5: → ## Section 4
+Step 6: Polish (optimizes entire doc)
+```
+
+**Critical:** Use ## Level 2 headers for main sections - allows document splitting if needed.
+
+## Final Polish Step
+
+For free-form workflows, include a polish step that:
+1. Loads entire document
+2. Reviews for flow and coherence
+3. Reduces duplication
+4. Ensures proper ## Level 2 headers
+5. Improves transitions
+6. Keeps general order but optimizes readability
+
+## Output File Patterns
+
+```yaml
+# Single output
+outputFile: '{output_folder}/document-{project_name}.md'
+
+# Time-stamped
+outputFile: '{output_folder}/document-{project_name}-{timestamp}.md'
+
+# User-specific
+outputFile: '{output_folder}/document-{user_name}-{project_name}.md'
+```