siesa-agents 2.1.39 → 2.1.41

package/bmad/bmb/workflows/agent/steps-c/step-02-discovery.md

@@ -0,0 +1,168 @@
+---
+name: 'step-02-discovery'
+description: 'Discover what user wants holistically'
+
+# File References
+nextStepFile: './step-03-type-metadata.md'
+agentPlan: '{bmb_creations_output_folder}/agent-plan-{agent_name}.md'
+brainstormContext: ../data/brainstorm-context.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
+
+Conduct holistic discovery of what the user wants to create, documenting a comprehensive agent plan that serves as the single source of truth for all subsequent workflow steps. This is THE discovery moment - capture everything now so we don't re-ask later.
+
+# MANDATORY EXECUTION RULES
+
+1. **ONE-TIME DISCOVERY:** This is the only discovery step. Capture everything now.
+2. **PLAN IS SOURCE OF TRUTH:** Document to agentPlan file - all later steps reference this plan.
+3. **NO RE-ASKING:** Later steps MUST read from plan, not re-ask questions.
+4. **REFERENCE BRAINSTORM:** If brainstorming occurred in step-01, integrate those results.
+5. **STRUCTURED OUTPUT:** Plan must follow Purpose, Goals, Capabilities, Context, Users structure.
+6. **LANGUAGE ALIGNMENT:** Continue using {language} if configured in step-01.
+
+# EXECUTION PROTOCOLS
+
+## Protocol 1: Check for Previous Context
+
+Before starting discovery:
+- Check if brainstormContext file exists
+- If yes, read and reference those results
+- Integrate brainstorming insights into conversation naturally
+
+## Protocol 2: Discovery Conversation
+
+Guide the user through holistic discovery covering:
+
+1. **Purpose:** What problem does this agent solve? Why does it need to exist?
+2. **Goals:** What should this agent accomplish? What defines success?
+3. **Capabilities:** What specific abilities should it have? What tools/skills?
+4. **Context:** Where will it be used? What's the environment/setting?
+5. **Users:** Who will use this agent? What's their skill level?
+
+Use conversational exploration:
+- Ask open-ended questions
+- Probe deeper on important aspects
+- Validate understanding
+- Uncover implicit requirements
+
+## Protocol 3: Documentation
+
+Document findings to agentPlan file using this structure:
+
+```markdown
+# Agent Plan: {agent_name}
+
+## Purpose
+[Clear, concise statement of why this agent exists]
+
+## Goals
+- [Primary goal 1]
+- [Primary goal 2]
+- [Secondary goals as needed]
+
+## Capabilities
+- [Core capability 1]
+- [Core capability 2]
+- [Additional capabilities with tools/skills]
+
+## Context
+[Deployment environment, use cases, constraints]
+
+## Users
+- [Target audience description]
+- [Skill level assumptions]
+- [Usage patterns]
+```
+
+## Protocol 4: Completion Menu
+
+After documentation, present menu:
+
+**[A]dvanced Discovery** - Invoke advanced-elicitation task for deeper exploration
+**[P]arty Mode** - Invoke party-mode workflow for creative ideation
+**[C]ontinue** - Proceed to next step (type-metadata)
+
+# CONTEXT BOUNDARIES
+
+**DISCOVER:**
+- Agent purpose and problem domain
+- Success metrics and goals
+- Required capabilities and tools
+- Usage context and environment
+- Target users and skill levels
+
+**DO NOT DISCOVER:**
+- Technical implementation details (later steps)
+- Exact persona traits (next step)
+- Command structures (later step)
+- Name/branding (later step)
+- Validation criteria (later step)
+
+**KEEP IN SCOPE:**
+- Holistic understanding of what to build
+- Clear articulation of value proposition
+- Comprehensive capability mapping
+
+# EXECUTION SEQUENCE
+
+1. **Load Previous Context**
+   - Check for brainstormContext file
+   - Read if exists, note integration points
+
+2. **Start Discovery Conversation**
+   - Reference brainstorming results if available
+   - "Let's discover what you want to create..."
+   - Explore purpose, goals, capabilities, context, users
+
+3. **Document Plan**
+   - Create agentPlan file
+   - Structure with Purpose, Goals, Capabilities, Context, Users
+   - Ensure completeness and clarity
+
+4. **Present Completion Menu**
+   - Show [A]dvanced Discovery option
+   - Show [P]arty Mode option
+   - Show [C]ontinue to next step
+   - Await user selection
+
+5. **Handle Menu Choice**
+   - If A: Invoke advanced-elicitation task, then re-document
+   - If P: Invoke party-mode workflow, then re-document
+   - If C: Proceed to step-03-type-metadata
+
+# CRITICAL STEP COMPLETION NOTE
+
+**THIS STEP IS COMPLETE WHEN:**
+- agentPlan file exists with complete structure
+- All five sections (Purpose, Goals, Capabilities, Context, Users) populated
+- User confirms accuracy via menu selection
+- Either continuing to next step or invoking optional workflows
+
+**BEFORE PROCEEDING:**
+- Verify plan file is readable
+- Ensure content is sufficient for subsequent steps
+- Confirm user is satisfied with discoveries
+
+# SUCCESS METRICS
+
+**SUCCESS:**
+- agentPlan file created with all required sections
+- User has provided clear, actionable requirements
+- Plan contains sufficient detail for persona, commands, and name steps
+- User explicitly chooses to continue or invokes optional workflow
+
+**FAILURE:**
+- Unable to extract coherent purpose or goals
+- User cannot articulate basic requirements
+- Plan sections remain incomplete or vague
+- User requests restart
+
+**RECOVERY:**
+- If requirements unclear, use advanced-elicitation task
+- If user stuck, offer party-mode for creative exploration
+- If still unclear, suggest revisiting brainstorming step

package/bmad/bmb/workflows/agent/steps-c/step-03-type-metadata.md

@@ -0,0 +1,294 @@
+---
+name: 'step-02-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}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/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 `{agent-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
+
+---
+
+# INSTRUCTION SEQUENCE
+
+## 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 `{agent-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/bmad/bmb/workflows/agent/steps-c/step-04-persona.md

@@ -0,0 +1,210 @@
+---
+name: 'step-03-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}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/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)
+
+# EXECUTION SEQUENCE
+
+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