create-byan-agent 2.18.0 → 2.19.0

package/install/templates/_byan/workflow/simple/agent/steps-c/step-03-type-metadata.md

@@ -0,0 +1,296 @@
+---
+name: 'step-03-type-metadata'
+description: 'Determine agent type and define metadata'
+
+# File References
+nextStepFile: './step-04-persona.md'
+agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
+agentTypesDoc: ../data/understanding-agent-types.md
+agentMetadata: ../data/agent-metadata.md
+
+# Example Agents (for reference)
+simpleExample: ../data/reference/simple-examples/commit-poet.agent.yaml
+expertExample: ../data/reference/expert-examples/journal-keeper/journal-keeper.agent.yaml
+moduleExample: ../data/reference/module-examples/security-engineer.agent.yaml
+
+# Task References
+advancedElicitationTask: '{project-root}/_byan/workflow/simple/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/workflow/simple/party-mode/workflow.md'
+---
+
+# STEP GOAL
+
+Determine the agent's classification (Simple/Expert/Module) and define all mandatory metadata properties required for agent configuration. Output structured YAML to the agent plan file for downstream consumption.
+
+---
+
+# MANDATORY EXECUTION RULES
+
+## Universal Rules
+- ALWAYS use `{communication_language}` for all conversational text
+- MAINTAIN step boundaries - complete THIS step only
+- DOCUMENT all decisions to agent plan file
+- HONOR user's creative control throughout
+
+## Role Reinforcement
+You ARE a master agent architect guiding collaborative agent creation. Balance:
+- Technical precision in metadata definition
+- Creative exploration of agent possibilities
+- Clear documentation for downstream steps
+
+## Step-Specific Rules
+- LOAD and reference agentTypesDoc and agentMetadata before conversations
+- NEVER skip metadata properties - all are mandatory
+- VALIDATE type selection against user's articulated needs
+- OUTPUT structured YAML format exactly as specified
+- SHOW examples when type classification is unclear
+
+---
+
+# EXECUTION PROTOCOLS
+
+## Protocol 1: Documentation Foundation
+Load reference materials first:
+1. Read agentTypesDoc for classification criteria
+2. Read agentMetadata for property definitions
+3. Keep examples ready for illustration
+
+## Protocol 2: Purpose Discovery
+Guide natural conversation to uncover:
+- Primary agent function/responsibility
+- Complexity level (single task vs multi-domain)
+- Scope boundaries (standalone vs manages workflows)
+- Integration needs (other agents/workflows)
+
+## Protocol 3: Type Determination
+Classify based on criteria:
+- **Simple**: Single focused purpose, minimal complexity (e.g., code reviewer, documentation generator)
+- **Expert**: Advanced domain expertise, multi-capability, manages complex tasks (e.g., game architect, system designer)
+- **Module**: Agent builder/manager, creates workflows, deploys other agents (e.g., agent-builder, workflow-builder)
+
+## Protocol 4: Metadata Definition
+Define each property systematically:
+- **id**: Technical identifier (lowercase, hyphens, no spaces)
+- **name**: Display name (conventional case, clear branding)
+- **title**: Concise function description (one line, action-oriented)
+- **icon**: Visual identifier (emoji or short symbol)
+- **module**: Module path (format: `{project}:{type}:{name}`)
+- **hasSidecar**: Boolean - manages external workflows? (default: false)
+
+## Protocol 5: Documentation Structure
+Output to agent plan file in exact YAML format:
+
+```yaml
+# Agent Type & Metadata
+agent_type: [Simple|Expert|Module]
+classification_rationale: |
+
+metadata:
+  id: [technical-identifier]
+  name: [Display Name]
+  title: [One-line action description]
+  icon: [emoji-or-symbol]
+  module: [project:type:name]
+  hasSidecar: [true|false]
+```
+
+## Protocol 6: Confirmation Menu
+Present structured options:
+- **[A] Accept** - Confirm and advance to next step
+- **[P] Pivot** - Modify type/metadata choices
+- **[C] Clarify** - Ask questions about classification
+
+---
+
+# CONTEXT BOUNDARIES
+
+## In Scope
+- Agent type classification
+- All 6 metadata properties
+- Documentation to plan file
+- Type selection guidance with examples
+
+## Out of Scope (Future Steps)
+- Persona/character development (Step 3)
+- Command structure design (Step 4)
+- Agent naming/branding refinement (Step 5)
+- Implementation/build (Step 6)
+- Validation/testing (Step 7)
+
+## Red Flags to Address
+- User wants complex agent but selects "Simple" type
+- Module classification without workflow management needs
+- Missing or unclear metadata properties
+- Module path format confusion
+
+---
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+## 1. Load Documentation
+Read and internalize:
+- `{agentTypesDoc}` - Classification framework
+- `{agentMetadata}` - Property definitions
+- Keep examples accessible for reference
+
+## 2. Purpose Discovery Conversation
+Engage user with questions in `{communication_language}`:
+- "What is the primary function this agent will perform?"
+- "How complex are the tasks this agent will handle?"
+- "Will this agent need to manage workflows or other agents?"
+- "What specific domains or expertise areas are involved?"
+
+Listen for natural language cues about scope and complexity.
+
+## 3. Agent Type Determination
+Based on discovery, propose classification:
+- Present recommended type with reasoning
+- Show relevant example if helpful
+- Confirm classification matches user intent
+- Allow pivoting if user vision evolves
+
+**Conversation Template:**
+```
+Based on our discussion, I recommend classifying this as a [TYPE] agent because:
+[reasoning from discovery]
+
+[If helpful: "For reference, here's a similar [TYPE] agent:"]
+[Show relevant example path: simpleExample/expertExample/moduleExample]
+
+Does this classification feel right to you?
+```
+
+## 4. Define All Metadata Properties
+Work through each property systematically:
+
+**4a. Agent ID**
+- Technical identifier for file naming
+- Format: lowercase, hyphens, no spaces
+- Example: `code-reviewer`, `journal-keeper`, `security-engineer`
+- User confirms or modifies
+
+**4b. Agent Name**
+- Display name for branding/UX
+- Conventional case, memorable
+- Example: `Code Reviewer`, `Journal Keeper`, `Security Engineer`
+- May differ from id (kebab-case vs conventional case)
+
+**4c. Agent Title**
+- Concise action description
+- One line, captures primary function
+- Example: `Reviews code quality and test coverage`, `Manages daily journal entries`
+- Clear and descriptive
+
+**4d. Icon Selection**
+- Visual identifier for UI/branding
+- Emoji or short symbol
+- Example: `🔍`, `📓`, `🛡️`
+- Should reflect agent function
+
+**4e. Module Path**
+- Complete module identifier
+- Format: `{project}:{type}:{name}`
+- Example: `bmb:agents:code-reviewer`
+- Guide user through structure if unfamiliar
+
+**4f. Sidecar Configuration**
+- Boolean: manages external workflows?
+- Typically false for Simple/Expert agents
+- True for Module agents that deploy workflows
+- Confirm based on user's integration needs
+
+**Conversation Template:**
+```
+Now let's define each metadata property:
+
+**ID (technical identifier):** [proposed-id]
+**Name (display name):** [Proposed Name]
+**Title (function description):** [Action description for function]
+**Icon:** [emoji/symbol]
+**Module path:** [project:type:name]
+**Has Sidecar:** [true/false with brief explanation]
+
+[Show structured preview]
+
+Ready to confirm, or should we adjust any properties?
+```
+
+## 5. Document to Plan File
+Write to `{agentPlan}`:
+
+```yaml
+# Agent Type & Metadata
+agent_type: [Simple|Expert|Module]
+classification_rationale: |
+  [Clear explanation of why this type matches user's articulated needs]
+
+metadata:
+  id: [technical-identifier]
+  name: [Display Name]
+  title: [One-line action description]
+  icon: [emoji-or-symbol]
+  module: [project:type:name]
+  hasSidecar: [true|false]
+
+# Type Classification Notes
+type_decision_date: [YYYY-MM-DD]
+type_confidence: [High/Medium/Low]
+considered_alternatives: |
+  - [Alternative type]: [reason not chosen]
+  - [Alternative type]: [reason not chosen]
+```
+
+### 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, then only then load, read entire file, then execute {nextStepFile}
+- 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
+
+ONLY WHEN [C continue option] is selected and [agent type classified and all 6 metadata properties defined and documented], will you then load and read fully `{nextStepFile}` to execute and begin persona development.
+
+---
+
+# SYSTEM SUCCESS/FAILURE METRICS
+
+## Success Indicators
+- Type classification clearly justified
+- All metadata properties populated correctly
+- YAML structure matches specification exactly
+- User confirms understanding and acceptance
+- Agent plan file updated successfully
+
+## Failure Indicators
+- Missing or undefined metadata properties
+- YAML structure malformed
+- User confusion about type classification
+- Inadequate documentation to plan file
+- Proceeding without user confirmation
+
+## Recovery Mode
+If user struggles with classification:
+- Show concrete examples from each type
+- Compare/contrast types with their use case
+- Ask targeted questions about complexity/scope
+- Offer type recommendation with clear reasoning
+
+Recover metadata definition issues by:
+- Showing property format examples
+- Explaining technical vs display naming
+- Clarifying module path structure
+- Defining sidecar use cases

package/install/templates/_byan/workflow/simple/agent/steps-c/step-04-persona.md

@@ -0,0 +1,212 @@
+---
+name: 'step-04-persona'
+description: 'Shape the agent personality through four-field persona system'
+
+# File References
+nextStepFile: './step-05-commands-menu.md'
+agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+communicationPresets: ../data/communication-presets.csv
+
+# Example Personas (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/workflow/simple/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/workflow/simple/party-mode/workflow.md'
+---
+
+# STEP GOAL
+
+Develop a complete four-field persona that defines the agent's personality, expertise, communication approach, and guiding principles. This persona becomes the foundation for how the agent thinks, speaks, and makes decisions.
+
+# MANDATORY EXECUTION RULES
+
+**CRITICAL: Field Purity Enforcement**
+- Each persona field has ONE specific purpose
+- NO mixing concepts between fields
+- NO overlapping responsibilities
+- Every field must be distinct and non-redundant
+
+**Output Requirements:**
+- Produce structured YAML block ready for agent.yaml
+- Follow principles-crafting guidance exactly
+- First principle MUST be the "expert activator"
+- All fields must be populated before proceeding
+
+# EXECUTION PROTOCOLS
+
+## Protocol 1: Load Reference Materials
+
+Read and integrate:
+- `personaProperties.md` - Field definitions and boundaries
+- `principlesCrafting.md` - Principles composition guidance
+- `communicationPresets.csv` - Style options and templates
+- Reference examples for pattern recognition
+
+## Protocol 2: Four-Field System Education
+
+Explain each field clearly:
+
+**1. Role (WHAT they do)**
+- Professional identity and expertise domain
+- Capabilities and knowledge areas
+- NOT personality or communication style
+- Pure functional definition
+
+**2. Identity (WHO they are)**
+- Character, personality, attitude
+- Emotional intelligence and worldview
+- NOT job description or communication format
+- Pure personality definition
+
+**3. Communication Style (HOW they speak)**
+- Language patterns, tone, voice
+- Formality, verbosity, linguistic preferences
+- NOT expertise or personality traits
+- Pure expression definition
+
+**4. Principles (WHY they act)**
+- Decision-making framework and values
+- Behavioral constraints and priorities
+- First principle = expert activator (core mission)
+- Pure ethical/operational definition
+
+## Protocol 3: Progressive Field Development
+
+### 3.1 Role Development
+- Define primary expertise domain
+- Specify capabilities and knowledge areas
+- Identify what makes them an "expert"
+- Keep it functional, not personal
+
+**Role Quality Checks:**
+- Can I describe their job without personality?
+- Would this fit in a job description?
+- Is it purely about WHAT they do?
+
+### 3.2 Identity Development
+- Define personality type and character
+- Establish emotional approach
+- Set worldview and attitude
+- Keep it personal, not functional
+
+**Identity Quality Checks:**
+- Can I describe their character without job title?
+- Would this fit in a character profile?
+- Is it purely about WHO they are?
+
+### 3.3 Communication Style Development
+- Review preset options from CSV
+- Select or customize style pattern
+- Define tone, formality, voice
+- Set linguistic preferences
+
+**Communication Quality Checks:**
+- Can I describe their speech patterns without expertise?
+- Is it purely about HOW they express themselves?
+- Would this fit in a voice acting script?
+
+### 3.4 Principles Development
+Follow `principlesCrafting.md` guidance:
+1. **Principle 1: Expert Activator** - Core mission and primary directive
+2. **Principle 2-5: Decision Framework** - Values that guide choices
+3. **Principle 6+: Behavioral Constraints** - Operational boundaries
+
+**Principles Quality Checks:**
+- Does first principle activate expertise immediately?
+- Do principles create decision-making clarity?
+- Would following these produce the desired behavior?
+
+## Protocol 4: Structured YAML Generation
+
+Output the four-field persona in this exact format:
+
+```yaml
+role: >
+  [Single sentence defining expertise and capabilities]
+
+identity: >
+  [2-3 sentences describing personality and character]
+
+communication_style: >
+  [Specific patterns for tone, formality, and voice]
+
+principles:
+  - [Expert activator - core mission]
+  - [Decision framework value 1]
+  - [Decision framework value 2]
+  - [Behavioral constraint 1]
+  - [Behavioral constraint 2]
+```
+
+# CONTEXT BOUNDARIES
+
+**Include in Persona:**
+- Professional expertise and capabilities (role)
+- Personality traits and character (identity)
+- Language patterns and tone (communication)
+- Decision-making values (principles)
+
+**Exclude from Persona:**
+- Technical skills (belongs in knowledge)
+- Tool usage (belongs in commands)
+- Workflow steps (belongs in orchestration)
+- Data structures (belongs in implementation)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
+
+1. **LOAD** personaProperties.md and principlesCrafting.md
+2. **EXPLAIN** four-field system with clear examples
+3. **DEVELOP** Role - define expertise domain and capabilities
+4. **DEVELOP** Identity - establish personality and character
+5. **DEVELOP** Communication Style - select/customize style preset
+6. **DEVELOP** Principles - craft 5-7 principles following guidance
+7. **OUTPUT** structured YAML block for agent.yaml
+8. **DOCUMENT** to agent-plan.md
+9. **PRESENT** completion menu
+
+## 9. 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](#9-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 [all four persona fields populated with DISTINCT content and field purity verified], will you then load and read fully `{nextStepFile}` to execute and begin command structure design.
+
+---
+
+# SUCCESS METRICS
+
+**Completion Indicators:**
+- Four distinct, non-overlapping persona fields
+- First principle activates expert capabilities
+- Communication style is specific and actionable
+- YAML structure is valid and ready for agent.yaml
+- User confirms persona accurately reflects vision
+
+**Failure Indicators:**
+- Role includes personality traits
+- Identity includes job descriptions
+- Communication includes expertise details
+- Principles lack expert activator
+- Fields overlap or repeat concepts
+- User expresses confusion or disagreement

package/install/templates/_byan/workflow/simple/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/workflow/simple/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/workflow/simple/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