@delorenj/pjangler 1.2.21 → 1.2.33

package/templates/commonproject/_bmad/bmb/workflows/agent/steps-c/step-05-commands-menu.md

@@ -1,178 +0,0 @@
----
-name: 'step-05-commands-menu'
-description: 'Build capabilities and command structure'
-
-# File References
-nextStepFile: './step-06-activation.md'
-agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
-agentMenuPatterns: ../data/agent-menu-patterns.md
-
-# Example Menus (for reference)
-simpleExample: ../data/reference/simple-examples/commit-poet.agent.yaml
-expertExample: ../data/reference/expert-examples/journal-keeper/journal-keeper.agent.yaml
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
----
-
-# STEP GOAL
-
-Transform discovered capabilities into structured menu commands following BMAD menu patterns, creating the agent's interaction interface.
-
-# MANDATORY EXECUTION RULES
-
-1. **MUST** load agent-menu-patterns.md before any conversation
-2. **MUST** use menu patterns as structural templates
-3. **MUST** keep final menu YAML under 100 lines
-4. **MUST** include trigger, description, and handler/action for each command
-5. **MUST NOT** add help or exit commands (auto-injected)
-6. **MUST** document menu YAML in agent-plan before completion
-7. **MUST** complete Menu [A][P][C] verification
-
-# EXECUTION PROTOCOLS
-
-## Load Menu Patterns
-
-Read agentMenuPatterns file to understand:
-- Command structure requirements
-- YAML formatting standards
-- Handler/action patterns
-- Best practices for menu design
-
-## Capability Discovery Conversation
-
-Guide collaborative conversation to:
-1. Review capabilities from previous step
-2. Identify which capabilities become commands
-3. Group related capabilities
-4. Define command scope and boundaries
-
-Ask targeted questions:
-- "Which capabilities are primary commands vs secondary actions?"
-- "Can related capabilities be grouped under single commands?"
-- "What should each command accomplish?"
-- "How should commands be triggered?"
-
-## Command Structure Development
-
-For each command, define:
-
-1. **Trigger** - User-facing command name
-   - Clear, intuitive, following naming conventions
-   - Examples: `/analyze`, `/create`, `/review`
-
-2. **Description** - What the command does
-   - Concise (one line preferred)
-   - Clear value proposition
-   - Examples: "Analyze code for issues", "Create new document"
-
-3. **Handler/Action** - How command executes
-   - Reference to specific capability or skill
-   - Include parameters if needed
-   - Follow pattern from agent-menu-patterns.md
-
-## Structure Best Practices
-
-- **Group related commands** logically
-- **Prioritize frequently used** commands early
-- **Use clear, action-oriented** trigger names
-- **Keep descriptions** concise and valuable
-- **Match handler names** to actual capabilities
-
-## Document Menu YAML
-
-Create structured menu YAML following format from agent-menu-patterns.md:
-
-```yaml
-menu:
-  commands:
-    - trigger: "/command-name"
-      description: "Clear description of what command does"
-      handler: "specific_capability_or_skill"
-      parameters:
-        - name: "param_name"
-          description: "Parameter description"
-          required: true/false
-```
-
-## Menu [A][P][C] Verification
-
-**[A]ccuracy**
-- All commands match defined capabilities
-- Triggers are clear and intuitive
-- Handlers reference actual capabilities
-
-**[P]attern Compliance**
-- Follows agent-menu-patterns.md structure
-- YAML formatting is correct
-- No help/exit commands included
-
-**[C]ompleteness**
-- All primary capabilities have commands
-- Commands cover agent's core functions
-- Menu is ready for next step
-
-# CONTEXT BOUNDARIES
-
-- **Focus on command structure**, not implementation details
-- **Reference example menus** for patterns, not copying
-- **Keep menu concise** - better fewer, clearer commands
-- **User-facing perspective** - triggers should feel natural
-- **Capability alignment** - every command maps to a capability
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-1. Load agent-menu-patterns.md to understand structure
-2. Review capabilities from agent-plan step 3
-3. Facilitate capability-to-command mapping conversation
-4. Develop command structure for each capability
-5. Define trigger, description, handler for each command
-6. Verify no help/exit commands (auto-injected)
-7. Document structured menu YAML to agent-plan
-8. Complete Menu [A][P][C] verification
-9. Confirm readiness for next step
-
-## 10. Present MENU OPTIONS
-
-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 {agentPlan}, update frontmatter, then only then load, read entire file, then execute {nextStepFile}
-- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#10-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
-- User can chat or ask questions - always respond and then end with display again of the menu options
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [menu YAML documented in agent-plan and all commands have trigger/description/handler], will you then load and read fully `{nextStepFile}` to execute and begin activation planning.
-
----
-
-# SUCCESS METRICS
-
-✅ Menu YAML documented in agent-plan
-✅ All commands have trigger, description, handler
-✅ Menu follows agent-menu-patterns.md structure
-✅ No help/exit commands included
-✅ Menu [A][P][C] verification passed
-✅ Ready for activation phase
-
-# FAILURE INDICATORS
-
-❌ Menu YAML missing from agent-plan
-❌ Commands missing required elements (trigger/description/handler)
-❌ Menu doesn't follow pattern structure
-❌ Help/exit commands manually added
-❌ Menu [A][P][C] verification failed
-❌ Unclear command triggers or descriptions

package/templates/commonproject/_bmad/bmb/workflows/agent/steps-c/step-06-activation.md

@@ -1,279 +0,0 @@
----
-name: 'step-06-activation'
-description: 'Plan activation behavior and route to build'
-
-# File References
-agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
-criticalActions: ../data/critical-actions.md
-
-# Build Step Routes (determined by agent type)
-simpleBuild: './step-07a-build-simple.md'
-expertBuild: './step-07b-build-expert.md'
-moduleBuild: './step-07c-build-module.md'
-
-# Example critical_actions (for reference)
-expertExample: ../data/reference/expert-examples/journal-keeper/journal-keeper.agent.yaml
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
----
-
-# STEP GOAL
-Define activation behavior through critical_actions and route to the appropriate build step based on agent complexity.
-
-# MANDATORY EXECUTION RULES
-
-1. **MUST Load Reference Documents** Before any discussion
-   - Read criticalActions.md to understand activation patterns
-   - Read agentPlan to access all accumulated metadata
-   - These are non-negotiable prerequisites
-
-2. **MUST Determine Route Before Activation Discussion**
-   - Check `module` and `hasSidecar` from plan metadata
-   - Determine destination build step FIRST
-   - Inform user of routing decision
-
-3. **MUST Document Activation Decision**
-   - Either define critical_actions array explicitly
-   - OR document deliberate omission with rationale
-   - No middle ground - commit to one path
-
-4. **MUST Follow Routing Logic Exactly**
-   ```yaml
-   # Route determination based on module and hasSidecar
-   # Module agents: any module value other than "stand-alone"
-   module ≠ "stand-alone" → step-07c-build-module.md
-   # Stand-alone agents: determined by hasSidecar
-   module = "stand-alone" + hasSidecar: true → step-07b-build-expert.md
-   module = "stand-alone" + hasSidecar: false → step-07a-build-simple.md
-   ```
-
-5. **NEVER Skip Documentation**
-   - Every decision about activation must be recorded
-   - Every routing choice must be justified
-   - Plan file must reflect final state
-
-# EXECUTION PROTOCOLS
-
-## Protocol 1: Reference Loading
-Execute BEFORE engaging user:
-
-1. Load criticalActions.md
-2. Load agentPlan-{agent_name}.md
-3. Extract routing metadata:
-   - hasSidecar (boolean)
-   - module (string)
-   - agentType (if defined)
-4. Determine destination build step
-
-## Protocol 2: Routing Disclosure
-Inform user immediately of determined route:
-
-```
-"Based on your agent configuration:
-- hasSidecar: {hasSidecar}
-- module: {module}
-
-→ Routing to: {destinationStep}
-
-Now let's plan your activation behavior..."
-```
-
-## Protocol 3: Activation Planning
-Guide user through decision:
-
-1. **Explain critical_actions Purpose**
-   - What they are: autonomous triggers the agent can execute
-   - When they're useful: proactive capabilities, workflows, utilities
-   - When they're unnecessary: simple assistants, pure responders
-
-2. **Discuss Agent's Activation Needs**
-   - Does this agent need to run independently?
-   - Should it initiate actions without prompts?
-   - What workflows or capabilities should it trigger?
-
-3. **Decision Point**
-   - Define specific critical_actions if needed
-   - OR explicitly opt-out with rationale
-
-## Protocol 4: Documentation
-Update agentPlan with activation metadata:
-
-```yaml
-# Add to agent metadata
-activation:
-  hasCriticalActions: true/false
-  rationale: "Explanation of why or why not"
-  criticalActions: []  # Only if hasCriticalActions: true
-routing:
-  destinationBuild: "step-06-{X}.md"
-  hasSidecar: {boolean}
-  module: "{module}"
-```
-
-# CONTEXT BOUNDARIES
-
-## In Scope
-- Planning activation behavior for the agent
-- Defining critical_actions array
-- Routing to appropriate build step
-- Documenting activation decisions
-
-## Out of Scope
-- Writing actual activation code (build step)
-- Designing sidecar workflows (build step)
-- Changing core agent metadata (locked after step 04)
-- Implementing commands (build step)
-
-## Routing Boundaries
-- Simple agents: No sidecar, straightforward activation
-- Expert agents: Sidecar + stand-alone module
-- Module agents: Sidecar + parent module integration
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-## 1. Load Reference Documents
-```bash
-# Read these files FIRST
-cat {criticalActions}
-cat {agentPlan}
-```
-
-## 2. Discuss Activation Needs
-Ask user:
-- "Should your agent be able to take autonomous actions?"
-- "Are there specific workflows it should trigger?"
-- "Should it run as a background process or scheduled task?"
-- "Or will it primarily respond to direct prompts?"
-
-## 3. Define critical_actions OR Explicitly Omit
-
-**If defining:**
-- Reference criticalActions.md patterns
-- List 3-7 specific actions
-- Each action should be clear and scoped
-- Document rationale for each
-
-**If omitting:**
-- State clearly: "This agent will not have critical_actions"
-- Explain why: "This agent is a responsive assistant that operates under direct user guidance"
-- Document the rationale
-
-## 4. Route to Build Step
-
-Determine destination:
-
-```yaml
-# Check plan metadata
-hasSidecar: {value from step 04}
-module: "{value from step 04}"
-
-# Route logic
-if hasSidecar == false:
-  destination = simpleBuild
-elif hasSidecar == true and module == "stand-alone":
-  destination = expertBuild
-else:  # hasSidecar == true and module != "stand-alone"
-  destination = moduleBuild
-```
-
-## 5. Document to Plan
-
-Update agentPlan with:
-
-```yaml
----
-activation:
-  hasCriticalActions: true
-  rationale: "Agent needs to autonomously trigger workflows for task automation"
-  criticalActions:
-    - name: "start-workflow"
-      description: "Initiate a predefined workflow for task execution"
-    - name: "schedule-task"
-      description: "Schedule tasks for future execution"
-    - name: "sync-data"
-      description: "Synchronize data with external systems"
-
-routing:
-  destinationBuild: "step-06-build-expert.md"
-  hasSidecar: true
-  module: "stand-alone"
-  rationale: "Agent requires sidecar workflows for autonomous operation"
----
-```
-
-### 6. Present MENU OPTIONS
-
-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 {agentPlan}, update frontmatter, determine appropriate build step based on hasSidecar and module values, then only then load, read entire file, then execute {simpleBuild} or {expertBuild} or {moduleBuild} as determined
-- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#6-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
-- User can chat or ask questions - always respond and then end with display again of the menu options
-
-## CRITICAL STEP COMPLETION NOTE
-
-This is the **ROUTING HUB** of agent creation. ONLY WHEN [C continue option] is selected and [routing decision determined with activation needs documented], will you then determine the appropriate build step based on hasSidecar/module values and load and read fully that build step file to execute.
-
-Routing logic:
-- hasSidecar: false → step-06-build-simple.md
-- hasSidecar: true + module: "stand-alone" → step-06-build-expert.md
-- hasSidecar: true + module: ≠ "stand-alone" → step-06-build-module.md
-
-You cannot proceed to build without completing routing.
-
----
-
-# SUCCESS METRICS
-
-✅ **COMPLETION CRITERIA:**
-- [ ] criticalActions.md loaded and understood
-- [ ] agentPlan loaded with all prior metadata
-- [ ] Routing decision determined and communicated
-- [ ] Activation needs discussed with user
-- [ ] critical_actions defined OR explicitly omitted with rationale
-- [ ] Plan updated with activation and routing metadata
-- [ ] User confirms routing to appropriate build step
-
-✅ **SUCCESS INDICATORS:**
-- Clear activation decision documented
-- Route to build step is unambiguous
-- User understands why they're going to {simple|expert|module} build
-- Plan file reflects complete activation configuration
-
-❌ **FAILURE MODES:**
-- Attempting to define critical_actions without reading reference
-- Routing decision not documented in plan
-- User doesn't understand which build step comes next
-- Ambiguous activation configuration (neither defined nor omitted)
-- Skipping routing discussion entirely
-
-⚠️ **RECOVERY PATHS:**
-If activation planning goes wrong:
-
-1. **Can't decide on activation?**
-   - Default: Omit critical_actions
-   - Route to simpleBuild
-   - Can add later via edit-agent workflow
-
-2. **Uncertain about routing?**
-   - Check hasSidecar value
-   - Check module value
-   - Apply routing logic strictly
-
-3. **User wants to change route?**
-   - Adjust hasSidecar or module values
-   - Re-run routing logic
-   - Update plan accordingly

package/templates/commonproject/_bmad/bmb/workflows/agent/steps-c/step-07a-build-simple.md

@@ -1,187 +0,0 @@
----
-name: 'step-07a-build-simple'
-description: 'Generate Simple agent YAML from plan'
-
-# File References
-nextStepFile: './step-08-celebrate.md'
-agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
-agentBuildOutput: '{bmb_creations_output_folder}/{agent-name}.agent.yaml'
-
-# Template and Architecture
-simpleTemplate: ../templates/simple-agent.template.md
-simpleArch: ../data/simple-agent-architecture.md
-agentCompilation: ../data/agent-compilation.md
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
----
-
-# STEP GOAL
-
-Assemble the agent plan content into a Simple agent YAML configuration using the template, producing a complete agent definition ready for validation.
-
-## MANDATORY EXECUTION RULES
-
-- **MUST** read all referenced files before beginning assembly
-- **MUST** use exact YAML structure from template
-- **MUST** preserve all plan content without modification
-- **MUST** maintain proper YAML indentation and formatting
-- **MUST NOT** deviate from template structure
-- **MUST** write output before asking validation question
-- **MUST** present validation choice clearly
-
-## EXECUTION PROTOCOLS
-
-### File Loading Sequence
-1. Read `simpleTemplate` - provides the YAML structure
-2. Read `simpleArch` - defines Simple agent architecture rules
-3. Read `agentCompilation` - provides assembly guidelines
-4. Read `agentPlan` - contains structured content from steps 2-5
-
-### YAML Assembly Process
-1. Parse template structure
-2. Extract content sections from agentPlan YAML
-3. Map plan content to template fields
-4. Validate YAML syntax before writing
-5. Write complete agent YAML to output path
-
-## CONTEXT BOUNDARIES
-
-**INCLUDE:**
-- Template structure exactly as provided
-- All agent metadata from agentPlan
-- Persona, commands, and rules from plan
-- Configuration options specified
-
-**EXCLUDE:**
-- Any content not in agentPlan
-- Sidecar file references (Simple agents don't use them)
-- Template placeholders (replace with actual content)
-- Comments or notes in final YAML
-
-## MANDATORY SEQUENCE
-
-**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
-
-### 1. Load Template and Architecture Files
-
-Read the following files in order:
-- `simpleTemplate` - YAML structure template
-- `simpleArch` - Simple agent architecture definition
-- `agentCompilation` - Assembly instructions
-
-**Verify:** All files loaded successfully.
-
-### 2. Load Agent Plan
-
-Read `agentPlan` which contains structured YAML from steps 2-5:
-- Step 2: Discovery findings
-- Step 3: Persona development
-- Step 4: Command structure
-- Step 5: Agent naming
-
-**Verify:** Plan contains all required sections.
-
-### 3. Assemble YAML Using Template
-
-Execute the following assembly process:
-
-1. **Parse Template Structure**
-   - Identify all YAML fields
-   - Note required vs optional fields
-   - Map field types and formats
-
-2. **Extract Plan Content**
-   - Read agent metadata
-   - Extract persona definition
-   - Retrieve command specifications
-   - Gather rules and constraints
-
-3. **Map Content to Template**
-   - Replace template placeholders with plan content
-   - Maintain exact YAML structure
-   - Preserve indentation and formatting
-   - Validate field types and values
-
-4. **Validate YAML Syntax**
-   - Check proper indentation
-   - Verify quote usage
-   - Ensure list formatting
-   - Confirm no syntax errors
-
-**Verify:** YAML is valid, complete, and follows template structure.
-
-### 4. Write Agent Build Output
-
-Write the assembled YAML to `agentBuildOutput`:
-- Use exact output path from variable
-- Include all content without truncation
-- Maintain YAML formatting
-- Confirm write operation succeeded
-
-**Verify:** File written successfully and contains complete YAML.
-
-### 5. Present MENU OPTIONS
-
-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: Write agent YAML to {agentBuildOutput}/{agent-name}.agent.yaml (or appropriate output path), update frontmatter, then only then load, read entire file, then execute {nextStepFile}
-- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#5-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
-- User can chat or ask questions - always respond and then end with display again of the menu options
-
-### 6. Route Based on User Choice
-
-**If user chooses "one-at-a-time":**
-- Proceed to `nextStepFile` (step-08-celebrate.md)
-- Continue through each validation step sequentially
-- Allow review between each validation
-
-**If user chooses "YOLO":**
-- Run all validation steps (7A through 7F) consecutively
-- Do not pause between validations
-- After all validations complete, proceed to Step 8
-- Present summary of all validation results
-
-## CRITICAL STEP COMPLETION NOTE
-
-ONLY WHEN [C continue option] is selected and [complete YAML generated and written to output], will you then load and read fully `{nextStepFile}` to execute and celebrate completion.
-
-## SUCCESS METRICS
-
-**SUCCESS looks like:**
-- Agent YAML file exists at specified output path
-- YAML is syntactically valid and well-formed
-- All template fields populated with plan content
-- Structure matches Simple agent architecture
-- User has selected validation approach
-- Clear next step identified
-
-**FAILURE looks like:**
-- Template or architecture files not found
-- Agent plan missing required sections
-- YAML syntax errors in output
-- Content not properly mapped to template
-- File write operation fails
-- User selection unclear
-
-## TRANSITION CRITERIA
-
-**Ready for Step 7A when:**
-- Simple agent YAML successfully created
-- User chooses "one-at-a-time" validation
-
-**Ready for Step 8 when:**
-- Simple agent YAML successfully created
-- User chooses "YOLO" validation
-- All validations (7A-7F) completed consecutively