create-byan-agent 2.1.0 → 2.2.1

package/install/templates/_byan/bmb/workflows/agent/steps-c/step-05-commands-menu.md

@@ -0,0 +1,178 @@
+---
+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}/_byan/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/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/install/templates/_byan/bmb/workflows/agent/steps-c/step-06-activation.md

@@ -0,0 +1,279 @@
+---
+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}/_byan/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/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/install/templates/_byan/bmb/workflows/agent/steps-c/step-07a-build-simple.md

@@ -0,0 +1,187 @@
+---
+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}/_byan/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/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