agent-workflow create edit validate consolidation

src/modules/bmb/agents/agent-builder.agent.yaml

@@ -28,9 +28,9 @@ agent:
 
   menu:
     - trigger: CA or fuzzy match on create-agent
-      exec: "{project-root}/_bmad/bmb/workflows/create-agent/workflow.md"
+      exec: "{project-root}/_bmad/bmb/workflows/agent/workflow.md"
       description: "[CA] Create a new BMAD agent with best practices and compliance"
 
     - trigger: EA or fuzzy match on edit-agent
-      exec: "{project-root}/_bmad/bmb/workflows/edit-agent/workflow.md"
+      exec: "{project-root}/_bmad/bmb/workflows/agent/workflow.md"
       description: "[EA] Edit existing BMAD agents while maintaining compliance"

src/modules/bmb/docs/workflows/step-file-rules.md

@@ -0,0 +1,469 @@
+# BMAD Step File Guidelines
+
+**Version:** 1.0
+**Module:** bmb (BMAD Builder)
+**Purpose:** Definitive guide for creating BMAD workflow step files
+
+---
+
+## Overview
+
+BMAD workflow step files follow a strict structure to ensure consistency, progressive disclosure, and mode-aware routing. Every step file MUST adhere to these guidelines.
+
+---
+
+## File Size Optimization
+
+**CRITICAL:** Keep step files **LT 200 lines** (250 lines absolute maximum).
+
+If a step exceeds this limit:
+- Consider splitting into multiple steps
+- Extract content to `/data/` reference files
+- Optimize verbose explanations
+
+---
+
+## Required Frontmatter Structure
+
+CRITICAL: Frontmatter should only have items that are used in the step file!
+
+```yaml
+---
+name: 'step-2-foo.md'
+description: 'Brief description of what this step accomplishes'
+
+# File References ## CRITICAL: Frontmatter references or variables should only have items that are used in the step file!
+outputFile: {bmb_creations_output_folder}/output-file-name.md
+nextStepFile: './step-3-bar.md'
+
+# Task References (as needed)
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+# ... other task-specific references
+---
+```
+
+### Frontmatter Field Descriptions
+
+| Field           | Required  | Description                       |
+| --------------- | --------- | --------------------------------- |
+| `name`          | Yes       | Step identifier (kebab-case)      |
+| `description`   | Yes       | One-line summary of step purpose  |
+| `outputFile`    | Yes       | Where results are documented      |
+| Task references | As needed | Paths to external workflows/tasks |
+
+---
+
+## Document Structure
+
+### 1. Title
+
+```markdown
+# Step X: [Step Name]
+```
+
+### 2. STEP GOAL
+
+```markdown
+## STEP GOAL:
+
+[Single sentence stating what this step accomplishes]
+```
+
+### 3. Role Reinforcement
+
+```markdown
+### Role Reinforcement:
+
+- ✅ You are a [specific role] who [does what]
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring [your expertise], user brings [their expertise], together we [achieve goal]
+- ✅ Maintain [tone/approach] throughout
+```
+
+### 4. Language Preference
+
+```markdown
+### Language Preference:
+The user has chosen to communicate in the **{language}** language.
+You MUST respond in **{language}** throughout this step.
+```
+
+**IMPORTANT:** Read `userPreferences.language` from tracking file (agentPlan, validationReport, etc.) and enforce it.
+
+### 5. Step-Specific Rules
+
+```markdown
+### Step-Specific Rules:
+
+- 🎯 Focus only on [specific scope]
+- 🚫 FORBIDDEN to [prohibited action]
+- 💬 Approach: [how to engage]
+- 📋 Ensure [specific outcome]
+```
+
+### 6. EXECUTION PROTOCOLS
+
+```markdown
+## EXECUTION PROTOCOLS:
+
+- [What to do - use verbs]
+- [Another action]
+- 🚫 FORBIDDEN to [prohibited action]
+```
+
+### 7. CONTEXT BOUNDARIES
+
+```markdown
+## CONTEXT BOUNDARIES:
+
+- Available context: [what's available]
+- Focus: [what to focus on]
+- Limits: [boundaries]
+- Dependencies: [what this step depends on]
+```
+
+### 8. Sequence of Instructions
+
+```markdown
+## Sequence of Instructions:
+
+### 1. [First Action]
+
+**[Action Description]**
+
+### 2. [Second Action]
+
+...
+```
+
+### 9. MENU OPTIONS
+
+```markdown
+### X. Present MENU OPTIONS
+
+Display: "**Select:** [A] [menu item A] [P] [menu item P] [C] [menu item C]"
+
+#### Menu Handling Logic:
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#x-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 [completion conditions], will you then load and read fully `{nextStepFile}`...
+```
+
+### 10. SYSTEM SUCCESS/FAILURE METRICS
+
+```markdown
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+- [Success criterion 1]
+- [Success criterion 2]
+- ...
+
+### ❌ SYSTEM FAILURE:
+- [Failure criterion 1]
+- [Failure criterion 2]
+- ...
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+```
+
+---
+
+## A/P/C Menu Convention
+
+BMAD workflows use a fixed menu structure:
+
+| Option | Meaning              | Behavior                                             |
+| ------ | -------------------- | ---------------------------------------------------- |
+| **A**  | Advanced Elicitation | Execute advancedElicitationTask, then redisplay menu |
+| **P**  | Party Mode           | Execute partyModeWorkflow, then redisplay menu       |
+| **C**  | Continue/Accept      | Save output, update frontmatter, load nextStepFile   |
+| Other  | Custom               | Defined per step (e.g., F = Fix, X = Exit)           |
+
+**Rules:**
+- A and P MUST always be present
+- C MUST be present except in final step (use X or similar for exit)
+- After A/P → redisplay menu
+- After C → proceed to next step
+- Custom letters can be used for step-specific options
+
+---
+
+## Progressive Disclosure
+
+**Core Principle:** Each step only knows about its immediate next step.
+
+### Implementation
+
+1. **Never pre-load future steps** - Only load `nextStepFile` when user selects [C]
+
+2. **Mode-aware routing** (for shared steps):
+   ```markdown
+   ## MODE-AWARE ROUTING:
+   ### If entered from CREATE mode:
+   Load ./s-next-step.md
+
+   ### If entered from EDIT mode:
+   Load ./e-next-step.md
+
+   ### If entered from VALIDATE mode:
+   Load ./v-next-step.md
+   ```
+
+3. **Read tracking file first** - Always read the tracking file (agentPlan, validationReport, etc.) to determine current mode and routing
+
+---
+
+## Mode-Aware Routing (Shared Steps)
+
+Shared steps (`s-*.md`) must route based on the mode stored in the tracking file.
+
+### Tracking File Frontmatter
+
+```yaml
+---
+mode: create              # or edit | validate
+stepsCompleted:
+  - c-01-brainstorm.md
+  - s-01-discovery.md
+# ... other tracking fields
+---
+```
+
+### Routing Implementation
+
+```markdown
+## COMPLETION ROUTING:
+
+1. Append `./this-step-name.md` to {trackingFile}.stepsCompleted
+2. Save content to {trackingFile}
+3. Read {trackingFile}.mode
+4. Route based on mode:
+
+### IF mode == create:
+Load ./s-next-create-step.md
+
+### IF mode == edit:
+Load ./e-next-edit-step.md
+
+### IF mode == validate:
+Load ./s-next-validate-step.md
+```
+
+---
+
+## File Naming Conventions
+
+### Tri-Modal Workflows
+
+| Prefix | Meaning            | Example                |
+| ------ | ------------------ | ---------------------- |
+| `c-`   | Create-specific    | `c-01-brainstorm.md`   |
+| `e-`   | Edit-specific      | `e-01-load-analyze.md` |
+| `v-`   | Validate-specific  | `v-01-load-review.md`  |
+| `s-`   | Shared by 2+ modes | `s-05-activation.md`   |
+
+### Numbering
+
+- Within each prefix type, number sequentially
+- Restart numbering for each prefix type (c-01, e-01, v-01, s-01)
+- Use letters for sub-steps (s-06a, s-06b, s-06c)
+
+---
+
+## Language Preference Enforcement
+
+**CRITICAL:** Every step MUST respect the user's chosen language.
+
+### Implementation
+
+```markdown
+### Language Preference:
+The user has chosen to communicate in the **{language}** language.
+You MUST respond in **{language}** throughout this step.
+```
+
+### Reading Language Preference
+
+From tracking file frontmatter:
+```yaml
+---
+userPreferences:
+  language: spanish    # or any language
+---
+```
+
+### Rules
+
+- **MUST** read language preference from tracking file at step start
+- **MUST** respond in user's chosen language for ALL content
+- **MUST** include menu options in user's chosen language
+- **EXCEPTION:** Technical terms, file names, and code remain in English
+
+---
+
+## Data File References
+
+When step content becomes too large (>200 lines), extract to `/data/` files:
+
+### When to Extract
+
+- Step file exceeds 200 lines
+- Content is reference material (rules, examples, patterns)
+- Content is reused across multiple steps
+
+### How to Reference
+
+```markdown
+## Reference Material:
+
+Load and reference: `../data/{data-file-name}.md`
+
+Key points from that file:
+- [Point 1]
+- [Point 2]
+```
+
+### Data File Best Practices
+
+- Keep data files focused on single topic
+- Use clear, descriptive names
+- Include examples and non-examples
+- Optimize for LLM usage (concise, structured)
+
+---
+
+## Common Pitfalls to Avoid
+
+### ❌ DON'T:
+
+- Pre-load future steps (violates progressive disclosure)
+- Exceed 250 lines without splitting
+- Forget to update `stepsCompleted` array
+- Ignore user's language preference
+- Skip mode checking in shared steps
+- Use vague menu option letters (stick to A/P/C plus 1-2 custom)
+
+### ✅ DO:
+
+- Keep files under 200 lines
+- Read tracking file first thing
+- Route based on `mode` field
+- Include A/P in every menu
+- Use descriptive step names
+- Extract complex content to data files
+
+---
+
+## Template: New Step File
+
+```markdown
+---
+name: 'step-name'
+description: 'What this step does'
+
+# File References
+thisStepFile: ./step-name.md
+workflowFile: ../workflow.md
+outputFile: {bmb_creations_output_folder}/output.md
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Step X: [Step Name]
+
+## STEP GOAL:
+
+[Single sentence goal]
+
+### Role Reinforcement:
+
+- ✅ You are a [role] who [does what]
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring [expertise], user brings [expertise], together we [achieve]
+- ✅ Maintain [tone] throughout
+
+### Language Preference:
+The user has chosen to communicate in the **{language}** language.
+You MUST respond in **{language}** throughout this step.
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on [scope]
+- 🚫 FORBIDDEN to [prohibited action]
+- 💬 Approach: [how to engage]
+- 📋 Ensure [outcome]
+
+## EXECUTION PROTOCOLS:
+
+- [Action 1]
+- [Action 2]
+- 🚫 FORBIDDEN to [prohibited action]
+
+## CONTEXT BOUNDARIES:
+
+- Available context: [what's available]
+- Focus: [what to focus on]
+- Limits: [boundaries]
+- Dependencies: [what depends on what]
+
+## Sequence of Instructions:
+
+### 1. [First Action]
+
+**Description of first action**
+
+### 2. [Second Action]
+
+**Description of second action**
+
+...
+
+### X. Present MENU OPTIONS
+
+Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF C: Save content to {outputFile}, update frontmatter, then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#x-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 [conditions], will you then load and read fully `{nextStepFile}`...
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+- [Success criteria]
+
+### ❌ SYSTEM FAILURE:
+- [Failure criteria]
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.
+```
+
+---
+
+**End of Guidelines**

src/modules/bmb/workflows/agent/steps-c/step-01-brainstorm.md

@@ -3,7 +3,7 @@ name: 'step-01-brainstorm'
 description: 'Optional brainstorming for agent ideas'
 
 # File References
-nextStepFile: '{project-root}/src/modules/bmb/workflows/create-agent/steps/step-02-discovery.md'
+nextStepFile: './step-02-discovery.md'
 brainstormContext: ../data/brainstorm-context.md
 brainstormWorkflow: '{project-root}/_bmad/core/workflows/brainstorming/workflow.md'
 ---

src/modules/bmb/workflows/agent/steps-e/e-01-load-existing.md

@@ -0,0 +1,214 @@
+---
+name: 'e-01-load-existing'
+description: 'Load and analyze existing agent for editing'
+
+# File References
+thisStepFile: ./e-01-load-existing.md
+workflowFile: ../workflow.md
+nextStepFile: './e-02-discover-edits.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+agentMenuPatterns: ../data/agent-menu-patterns.md
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 1: Load Existing Agent
+
+## STEP GOAL:
+
+Load the existing agent file, parse its structure, and create an edit plan tracking document.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER proceed without loading the complete agent file
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not an autonomous editor
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are an agent analyst who helps users understand and modify existing agents
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring agent architecture expertise, user brings their modification goals, together we achieve successful edits
+- ✅ Maintain collaborative analytical tone throughout
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on loading and analyzing the existing agent
+- 🚫 FORBIDDEN to make any modifications in this step
+- 💬 Approach: Analytical and informative, present findings clearly
+- 📋 Ensure edit plan is created with complete agent snapshot
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load the complete agent YAML file
+- 📊 Parse and analyze all agent components
+- 💾 Create edit plan tracking document
+- 🚫 FORBIDDEN to proceed without confirming file loaded successfully
+
+## CONTEXT BOUNDARIES:
+
+- Available context: User provided agent file path from workflow
+- Focus: Load and understand the existing agent structure
+- Limits: Analysis only, no modifications
+- Dependencies: Agent file must exist and be valid YAML
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Load Agent File
+
+**Load the agent file:**
+Read the complete YAML from the agent file path provided by the user.
+
+**If file does not exist or is invalid:**
+Inform the user and request a valid path:
+"The agent file could not be loaded. Please verify the path and try again.
+
+Expected format: `{path-to-agent}/{agent-name}.agent.yaml`"
+
+### 2. Parse Agent Structure
+
+**Extract and categorize all agent components:**
+
+```yaml
+# Basic Metadata
+- name: {agent-name}
+- description: {agent-description}
+- type: {simple|expert|module}
+- version: {version}
+
+# Persona
+- persona: {full persona text}
+- system-context: {if present}
+
+# Commands/Menu
+- commands: {full command structure}
+
+# Critical Actions (if present)
+- critical-actions: {list}
+
+# Metadata
+- metadata: {all metadata fields}
+```
+
+### 3. Display Agent Summary
+
+**Present a clear summary to the user:**
+
+```markdown
+## Agent Analysis: {agent-name}
+
+**Type:** {simple|expert|module}
+**Version:** {version}
+**Status:** ready-for-edit
+
+### Current Structure:
+
+**Persona:** {character count} characters
+**Commands:** {count} commands defined
+**Critical Actions:** {count} critical actions
+
+### Editable Components:
+
+- [ ] Persona (role, identity, communication_style, principles)
+- [ ] Commands and menu structure
+- [ ] Critical actions
+- [ ] Metadata (name, description, version, tags)
+```
+
+### 4. Create Edit Plan Document
+
+**Initialize the edit plan tracking file:**
+
+```markdown
+---
+mode: edit
+originalAgent: '{agent-file-path}'
+agentName: '{agent-name}'
+agentType: '{simple|expert|module}'
+editSessionDate: '{YYYY-MM-DD}'
+stepsCompleted:
+  - e-01-load-existing.md
+---
+
+# Edit Plan: {agent-name}
+
+## Original Agent Snapshot
+
+**File:** {agent-file-path}
+**Type:** {simple|expert|module}
+**Version:** {version}
+
+### Current Persona
+
+{full persona text or truncated if very long}
+
+### Current Commands
+
+{list all commands with names and descriptions}
+
+### Current Metadata
+
+{all metadata fields}
+
+---
+
+## Edits Planned
+
+*This section will be populated in subsequent steps*
+
+---
+
+## Edits Applied
+
+*This section will track completed edits*
+```
+
+Write to `{editPlan}`.
+
+### 5. Present MENU OPTIONS
+
+Display: "**Is this the correct agent to edit?** [C] Yes, Continue to Discovery"
+
+#### Menu Handling Logic:
+
+- IF C: Save content to {editPlan}, 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [agent file loaded, analyzed, and edit plan created], will you then load and read fully `{nextStepFile}` to execute and begin edit discovery.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Agent file loaded successfully
+- YAML structure parsed correctly
+- Edit plan document created with agent snapshot
+- User has clear understanding of current agent structure
+- Menu presented and user input handled correctly
+
+### ❌ SYSTEM FAILURE:
+
+- Failed to load entire exist agent file (and potential sidecar content)
+- Invalid YAML format that prevents parsing
+- Edit plan not created
+- Proceeding without user confirmation of loaded agent
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-02-discover-edits.md

@@ -0,0 +1,191 @@
+---
+name: 'e-02-discover-edits'
+description: 'Discover what user wants to change about the agent'
+
+nextStepFile: './e-03a-validate-metadata.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 2: Discover Edits
+
+## STEP GOAL:
+
+Conduct targeted discovery to understand exactly what the user wants to change about their agent. Document all requested edits in structured format.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER assume what edits are needed - ask explicitly
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan first to understand agent context
+- 📋 YOU ARE A FACILITATOR, not an autonomous editor
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are an agent editor consultant who helps users clarify their modification goals
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring agent architecture expertise, user brings their vision for improvements, together we define precise edits
+- ✅ Maintain collaborative inquisitive tone throughout
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on discovering what to edit, not how to implement yet
+- 🚫 FORBIDDEN to make any modifications in this step
+- 💬 Approach: Ask probing questions to understand edit scope
+- 📋 Ensure all edits are documented to edit plan before proceeding
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Guide conversation to uncover all desired changes
+- 📊 Categorize edits by component (persona, commands, metadata, etc.)
+- 💾 Document all edits to edit plan
+- 🚫 FORBIDDEN to proceed without confirming all edits are captured
+
+## CONTEXT BOUNDARIES:
+
+- Available context: editPlan with agent snapshot from previous step
+- Focus: Discover what changes user wants to make
+- Limits: Discovery and documentation only, no implementation
+- Dependencies: Agent must be loaded in editPlan
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Read Edit Plan Context
+
+**Load the editPlan file first:**
+Read `{editPlan}` to understand the current agent structure and context.
+
+### 2. Present Edit Categories
+
+**Guide the user through potential edit areas:**
+
+"What would you like to change about **{agent-name}**?
+
+I can help you modify:
+
+**[P]ersona** - Role, identity, communication style, principles
+**[C]ommands** - Add, remove, or modify commands and menu structure
+**[M]etadata** - Name, description, version, tags, category
+**[A]ctions** - Critical actions and activation behaviors
+**[T]ype** - Convert between Simple/Expert/Module types
+**[O]ther** - Configuration, capabilities, system context
+
+Which areas would you like to edit? (You can select multiple)"
+
+### 3. Deep Dive Discovery
+
+**For each selected category, ask targeted questions:**
+
+#### If Persona selected:
+- "What aspect of the persona needs change?"
+- "Should the role be more specific or expanded?"
+- "Is the communication style hitting the right tone?"
+- "Do the principles need refinement?"
+
+#### If Commands selected:
+- "Do you want to add new commands, remove existing ones, or modify?"
+- "Are current command names and descriptions clear?"
+- "Should command steps be adjusted?"
+- "Is the menu structure working well?"
+
+#### If Metadata selected:
+- "What metadata fields need updating?"
+- "Is the description accurate and compelling?"
+- "Should version be bumped?"
+- "Are tags still relevant?"
+
+#### If Actions selected:
+- "What critical actions need modification?"
+- "Should new activation behaviors be added?"
+- "Are current actions executing as expected?"
+
+#### If Type conversion selected:
+- "What type are you converting from/to?"
+- "What's driving this conversion?"
+- "Are you aware of the implications (e.g., Expert needs sidecar)?"
+
+### 4. Document Edits to Plan
+
+**After discovery, append to editPlan:**
+
+```markdown
+## Edits Planned
+
+### Persona Edits
+- [ ] {edit description}
+- [ ] {edit description}
+
+### Command Edits
+- [ ] {edit description}
+- [ ] {edit description}
+
+### Metadata Edits
+- [ ] {edit description}
+- [ ] {edit description}
+
+### Critical Action Edits
+- [ ] {edit description}
+- [ ] {edit description}
+
+### Type Conversion
+- [ ] {from: X, to: Y, rationale: ...}
+
+### Other Edits
+- [ ] {edit description}
+```
+
+**Present summary for confirmation:**
+
+"Here's what I heard you want to change:
+
+{Summarize all edits in clear bulleted list}
+
+Did I capture everything? Any edits to add, remove, or clarify?"
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Validation"
+
+#### 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 edits to {editPlan}, 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [all edits documented and confirmed by user], will you then load and read fully `{nextStepFile}` to execute and begin validation.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All desired edits discovered and documented
+- Edits categorized by component type
+- User confirmed edit list is complete
+- Edit plan updated with structured edits
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeding without documenting edits
+- Missing edits that user mentioned
+- Unclear or ambiguous edit descriptions
+- User not given opportunity to review/edit list
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-03a-validate-metadata.md

@@ -0,0 +1,78 @@
+---
+name: 'e-03a-validate-metadata'
+description: 'Validate metadata (before edit) - no menu, auto-advance'
+
+nextStepFile: './e-03b-validate-persona.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+---
+
+# Edit Step 3a: Validate Metadata (Before Edit)
+
+## STEP GOAL:
+
+Validate the agent's metadata properties against BMAD standards. Record findings to editPlan and auto-advance to next validation step.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentMetadata first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate metadata against agentMetadata.md rules
+- 📊 Record findings to editPlan frontmatter
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMetadata.md reference
+- 📊 Validate all metadata fields
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMetadata}` to understand validation rules.
+Read `{editPlan}` to get agent file path and metadata.
+
+### 2. Validate Metadata
+
+Perform checks on:
+- **id**: kebab-case, no spaces
+- **name**: display name, clear branding
+- **title**: concise function description
+- **icon**: appropriate emoji or symbol
+- **module**: correct format `{project}:{type}:{name}`
+- **hasSidecar**: boolean, matches actual sidecar usage
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+validationBefore:
+  metadata:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+When validation complete, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All metadata checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to persona validation...**

src/modules/bmb/workflows/agent/steps-e/e-03b-validate-persona.md

@@ -0,0 +1,76 @@
+---
+name: 'e-03b-validate-persona'
+description: 'Validate persona (before edit) - no menu, auto-advance'
+
+nextStepFile: './e-03c-validate-menu.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+---
+
+# Edit Step 3b: Validate Persona (Before Edit)
+
+## STEP GOAL:
+
+Validate the agent's persona fields against BMAD standards. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and persona references first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate persona four-field system
+- 📊 Record findings to editPlan frontmatter
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load personaProperties.md and principlesCrafting.md
+- 📊 Validate persona fields
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{personaProperties}` and `{principlesCrafting}`.
+Read `{editPlan}` to get agent file path and persona.
+
+### 2. Validate Persona
+
+Perform checks on:
+- **role**: present, specific, not generic
+- **identity**: present, defines who agent is
+- **communication_style**: present, speech patterns only (no behavioral words)
+- **principles**: present, first principle activates expert knowledge, not generic duties
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  persona:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+When validation complete, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All persona checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to menu validation...**

src/modules/bmb/workflows/agent/steps-e/e-03c-validate-menu.md

@@ -0,0 +1,75 @@
+---
+name: 'e-03c-validate-menu'
+description: 'Validate menu structure (before edit) - no menu, auto-advance'
+
+nextStepFile: './e-03d-validate-structure.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMenuPatterns: ../data/agent-menu-patterns.md
+---
+
+# Edit Step 3c: Validate Menu (Before Edit)
+
+## STEP GOAL:
+
+Validate the agent's command menu structure against BMAD standards. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentMenuPatterns first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate command/menu structure
+- 📊 Record findings to editPlan frontmatter
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMenuPatterns.md reference
+- 📊 Validate commands and menu
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMenuPatterns}`.
+Read `{editPlan}` to get agent file path and commands.
+
+### 2. Validate Menu
+
+Perform checks on:
+- **A/P/C convention**: each menu has Advanced Elicitation, Party Mode, Continue
+- **Command names**: clear, descriptive
+- **Command descriptions**: specific, actionable
+- **Menu handling logic**: properly specified
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  menu:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+When validation complete, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All menu checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to structure validation...**

src/modules/bmb/workflows/agent/steps-e/e-03d-validate-structure.md

@@ -0,0 +1,75 @@
+---
+name: 'e-03d-validate-structure'
+description: 'Validate YAML structure (before edit) - no menu, auto-advance'
+
+nextStepFile: './e-03e-validate-sidecar.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentCompilation: ../data/agent-compilation.md
+---
+
+# Edit Step 3d: Validate Structure (Before Edit)
+
+## STEP GOAL:
+
+Validate the agent's YAML structure and completeness. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentCompilation first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate YAML structure and required fields
+- 📊 Record findings to editPlan frontmatter
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentCompilation.md reference
+- 📊 Validate YAML structure
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentCompilation}`.
+Read `{editPlan}` to get agent file path.
+
+### 2. Validate Structure
+
+Perform checks on:
+- **YAML syntax**: valid, no parse errors
+- **Required fields**: name, description, type, persona present
+- **Field types**: arrays where expected, strings where expected
+- **Indentation**: consistent 2-space indentation
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  structure:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+When validation complete, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All structure checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to sidecar validation...**

src/modules/bmb/workflows/agent/steps-e/e-03e-validate-sidecar.md

@@ -0,0 +1,78 @@
+---
+name: 'e-03e-validate-sidecar'
+description: 'Validate sidecar structure (before edit) - no menu, auto-advance'
+
+nextStepFile: './e-03f-validation-summary.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+expertValidation: ../data/expert-agent-validation.md
+---
+
+# Edit Step 3e: Validate Sidecar (Before Edit)
+
+## STEP GOAL:
+
+Validate the agent's sidecar structure if Expert type. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and expertValidation first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate sidecar structure for Expert agents
+- 📊 Record findings to editPlan frontmatter
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load expertValidation.md reference
+- 📊 Validate sidecar if Expert type, skip for Simple/Module
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to validation summary when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{expertValidation}`.
+Read `{editPlan}` to get agent type.
+
+### 2. Conditional Validation
+
+**IF agentType == expert:**
+- Check metadata.sidecar-folder is present
+- Check sidecar-path is correct format
+- Verify sidecar files exist at specified path
+
+**IF agentType != expert:**
+- Mark as N/A (not applicable)
+- Skip detailed checks
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  sidecar:
+    status: [pass|fail|warning|n/a]
+    findings:
+      - {check}: [pass|fail|n/a]
+      - {check}: [pass|fail|n/a]
+```
+
+### 4. Auto-Advance
+
+When validation complete, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ Sidecar checks performed (or N/A recorded)
+✅ Findings saved to editPlan
+✅ Auto-advanced to validation summary
+
+---
+
+**Auto-advancing to validation summary...**

src/modules/bmb/workflows/agent/steps-e/e-03f-validation-summary.md

@@ -0,0 +1,119 @@
+---
+name: 'e-03f-validation-summary'
+description: 'Display all validation findings before edit'
+
+nextStepFile: './e-04-type-metadata.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 3f: Validation Summary (Before Edit)
+
+## STEP GOAL:
+
+Display all validation findings from the previous 5 validation steps to the user. Present findings clearly and await confirmation to proceed.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan to collect all validation findings
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Display all validation findings clearly organized
+- 📊 Aggregate findings from all 5 validation steps
+- 💬 Present options for handling any issues found
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Read editPlan to get validation findings
+- 📊 Display organized summary
+- 💾 Allow user to decide how to proceed
+- ➡️ Proceed to edit plan on [C]
+
+## Sequence of Instructions:
+
+### 1. Load Validation Findings
+
+Read `{editPlan}` frontmatter to collect:
+- validationBefore.metadata.status and findings
+- validationBefore.persona.status and findings
+- validationBefore.menu.status and findings
+- validationBefore.structure.status and findings
+- validationBefore.sidecar.status and findings
+
+### 2. Display Validation Summary
+
+```markdown
+## Pre-Edit Validation Report for {agent-name}
+
+### Metadata Validation
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+{Findings summary}
+
+### Persona Validation
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+{Findings summary}
+
+### Menu Validation
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+{Findings summary}
+
+### Structure Validation
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+{Findings summary}
+
+### Sidecar Validation
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL / N/A}
+{Findings summary}
+```
+
+### 3. Present Options
+
+"How would you like to proceed?
+
+**[I**ntegrate fixes**] - Add validation fixes to your edit plan
+**[S]kip** - Proceed with your planned edits only
+**[A]dvanced** - Deeper exploration of any issues"
+
+### 4. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Edit Plan"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF I: Add validation fixes to editPlan, then redisplay menu
+- IF C: Save validation summary to {editPlan}, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#4-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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [validation summary displayed], will you then load and read fully `{nextStepFile}` to execute and begin edit planning.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All validation findings displayed clearly
+- User given options for handling issues
+- Validation summary saved to editPlan
+
+### ❌ SYSTEM FAILURE:
+
+- Findings not displayed to user
+- Proceeding without user acknowledgment
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-04-type-metadata.md

@@ -0,0 +1,122 @@
+---
+name: 'e-04-type-metadata'
+description: 'Review and plan metadata edits'
+
+nextStepFile: './e-05-persona.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+agentTypesDoc: ../data/understanding-agent-types.md
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 4: Type and Metadata
+
+## STEP GOAL:
+
+Review the agent's type and metadata, and plan any changes. If edits involve type conversion, identify the implications.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Load agentMetadata and agentTypesDoc first
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load reference documents before discussing edits
+- 📊 Document type conversion requirements if applicable
+- 💬 Focus on metadata that user wants to change
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMetadata.md and agentTypesDoc.md
+- 📊 Review current metadata from editPlan
+- 💾 Document planned metadata changes
+- 🚫 FORBIDDEN to proceed without documenting changes
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read `{agentMetadata}` and `{agentTypesDoc}` to understand validation rules and type implications.
+
+### 2. Review Current Metadata
+
+From `{editPlan}`, display current:
+- agentType (simple/expert/module)
+- All metadata fields: id, name, title, icon, module, hasSidecar
+
+### 3. Discuss Metadata Edits
+
+If user wants metadata changes:
+
+**For type conversion:**
+- "Converting from {current} to {target}"
+- Explain implications (e.g., Simple → Expert requires sidecar)
+- Update editPlan with type conversion
+
+**For metadata field changes:**
+- id: kebab-case requirements
+- name: display name conventions
+- title: function description format
+- icon: emoji/symbol
+- module: path format
+- hasSidecar: boolean implications
+
+### 4. Document to Edit Plan
+
+Append to `{editPlan}`:
+
+```yaml
+metadataEdits:
+  typeConversion:
+    from: {current-type}
+    to: {target-type}
+    rationale: {explanation}
+  fieldChanges:
+    - field: {field-name}
+      from: {current-value}
+      to: {target-value}
+```
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Persona"
+
+#### 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 to {editPlan}, 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [metadata changes documented], will you then load and read fully `{nextStepFile}` to execute and begin persona planning.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Reference documents loaded
+- Metadata changes discussed and documented
+- Type conversion implications understood
+- Edit plan updated
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeded without loading reference documents
+- Type conversion without understanding implications
+- Changes not documented to edit plan
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-05-persona.md

@@ -0,0 +1,132 @@
+---
+name: 'e-05-persona'
+description: 'Review and plan persona edits'
+
+nextStepFile: './e-06-commands-menu.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+communicationPresets: ../data/communication-presets.csv
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 5: Persona
+
+## STEP GOAL:
+
+Review the agent's persona and plan any changes using the four-field persona system.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Load personaProperties, principlesCrafting, communicationPresets first
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load reference documents before discussing persona edits
+- 📊 Maintain four-field system purity
+- 💬 Focus on persona fields that user wants to change
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load personaProperties.md, principlesCrafting.md, communicationPresets.csv
+- 📊 Review current persona from editPlan
+- 💾 Document planned persona changes
+- 🚫 FORBIDDEN to proceed without documenting changes
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read `{personaProperties}`, `{principlesCrafting}`, `{communicationPresets}` to understand the four-field system.
+
+### 2. Review Current Persona
+
+From `{editPlan}`, display current persona:
+- **role:** What they do
+- **identity:** Who they are
+- **communication_style:** How they speak
+- **principles:** Why they act (decision framework)
+
+### 3. Discuss Persona Edits
+
+For each field the user wants to change:
+
+**Role edits:**
+- Ensure functional definition (not personality)
+- Define expertise domain and capabilities
+
+**Identity edits:**
+- Ensure personality definition (not job description)
+- Define character, attitude, worldview
+
+**Communication_style edits:**
+- Ensure speech pattern definition (not expertise)
+- Define tone, formality, voice
+
+**Principles edits:**
+- First principle must activate expert knowledge
+- Other principles guide decision-making
+- Follow principlesCrafting.md guidance
+
+### 4. Document to Edit Plan
+
+Append to `{editPlan}`:
+
+```yaml
+personaEdits:
+  role:
+    from: {current}
+    to: {target}
+  identity:
+    from: {current}
+    to: {target}
+  communication_style:
+    from: {current}
+    to: {target}
+  principles:
+    from: {current}
+    to: {target}
+```
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Commands Menu"
+
+#### 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 to {editPlan}, 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [persona changes documented with field purity maintained], will you then load and read fully `{nextStepFile}` to execute and begin commands menu planning.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Reference documents loaded
+- Four-field system purity maintained
+- Persona changes documented
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeded without loading reference documents
+- Field purity violated (mixed concepts)
+- Changes not documented to edit plan
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-06-commands-menu.md

@@ -0,0 +1,120 @@
+---
+name: 'e-06-commands-menu'
+description: 'Review and plan command/menu edits'
+
+nextStepFile: './e-07-activation.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMenuPatterns: ../data/agent-menu-patterns.md
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 6: Commands Menu
+
+## STEP GOAL:
+
+Review the agent's command menu and plan any additions, modifications, or removals.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Load agentMenuPatterns first
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load agentMenuPatterns before discussing menu edits
+- 📊 Follow A/P/C convention for menu structure
+- 💬 Focus on commands that user wants to add/modify/remove
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMenuPatterns.md
+- 📊 Review current commands from editPlan
+- 💾 Document planned command changes
+- 🚫 FORBIDDEN to proceed without documenting changes
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read `{agentMenuPatterns}` to understand menu structure requirements.
+
+### 2. Review Current Commands
+
+From `{editPlan}`, display current commands with:
+- trigger
+- description
+- handler/action
+
+### 3. Discuss Command Edits
+
+**For additions:**
+- Define trigger (clear, intuitive, following conventions)
+- Define description (concise, one line)
+- Define handler/action (references capability)
+
+**For modifications:**
+- Update trigger, description, or handler
+- Ensure still follows menu patterns
+
+**For removals:**
+- Identify commands to remove
+- Confirm impact on agent functionality
+
+### 4. Document to Edit Plan
+
+Append to `{editPlan}`:
+
+```yaml
+commandEdits:
+  additions:
+    - trigger: {trigger}
+      description: {description}
+      handler: {handler}
+  modifications:
+    - command: {existing-command}
+      changes: {what-to-change}
+  removals:
+    - command: {command-to-remove}
+```
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Activation"
+
+#### 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 to {editPlan}, 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [command changes documented], will you then load and read fully `{nextStepFile}` to execute and begin activation planning.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- agentMenuPatterns loaded
+- Command changes documented with trigger/description/handler
+- A/P/C convention followed
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeded without loading reference documents
+- Commands missing required elements
+- Changes not documented to edit plan
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-07-activation.md

@@ -0,0 +1,122 @@
+---
+name: 'e-07-activation'
+description: 'Review critical_actions and route to type-specific edit'
+
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+criticalActions: ../data/critical-actions.md
+
+# Type-specific edit routes
+simpleEdit: './e-08a-edit-simple.md'
+expertEdit: './e-08b-edit-expert.md'
+moduleEdit: './e-08c-edit-module.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 7: Activation and Routing
+
+## STEP GOAL:
+
+Review critical_actions and route to the appropriate type-specific edit step (Simple/Expert/Module).
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Load criticalActions and editPlan first
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}}`
+
+### Step-Specific Rules:
+
+- 🎯 Load criticalActions.md before discussing activation
+- 📊 Determine target type for routing
+- 💬 Route based on POST-EDIT agent type
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load criticalActions.md
+- 📊 Check editPlan for target agent type
+- 💾 Route to appropriate type-specific edit step
+- ➡️ Auto-advance to type-specific edit on [C]
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read `{criticalActions}` and `{editPlan}` to understand:
+- Current critical_actions (if any)
+- Target agent type after edits
+
+### 2. Review Critical Actions
+
+If user wants to add/modify critical_actions:
+- Reference patterns from criticalActions.md
+- Define action name, description, invocation
+- For Expert agents: specify sidecar-folder and file paths
+
+### 3. Determine Routing
+
+Check `{editPlan}` metadataEdits.typeConversion.to or current agentType:
+
+```yaml
+agentType: simple → route to e-08a-edit-simple.md
+agentType: expert → route to e-08b-edit-expert.md
+agentType: module → route to e-08c-edit-module.md
+```
+
+### 4. Document to Edit Plan
+
+Append to `{editPlan}`:
+
+```yaml
+activationEdits:
+  criticalActions:
+    additions: []
+    modifications: []
+routing:
+  destinationEdit: {e-08a|e-08b|e-08c}
+  targetType: {simple|expert|module}
+```
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Type-Specific Edit"
+
+#### 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 to {editPlan}, determine routing based on targetType, then only then load and execute the appropriate type-specific edit step
+- 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
+
+## CRITICAL STEP COMPLETION NOTE
+
+This is the **ROUTING HUB** for edit flow. ONLY WHEN [C continue option] is selected and [routing determined], load and execute the appropriate type-specific edit step:
+
+- targetType: simple → e-08a-edit-simple.md
+- targetType: expert → e-08b-edit-expert.md
+- targetType: module → e-08c-edit-module.md
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- criticalActions.md loaded
+- Routing determined based on target type
+- Edit plan updated with routing info
+
+### ❌ SYSTEM FAILURE:
+
+- Proceeded without loading reference documents
+- Routing not determined
+- Wrong type-specific edit step selected
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-08a-edit-simple.md

@@ -0,0 +1,134 @@
+---
+name: 'e-08a-edit-simple'
+description: 'Apply edits to Simple agent'
+
+nextStepFile: './e-09a-validate-metadata.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentFile: '{original-agent-path}'
+agentBackup: '{original-agent-path}.backup'
+
+# Template and Architecture
+simpleTemplate: ../templates/simple-agent.template.md
+simpleArch: ../data/simple-agent-architecture.md
+agentCompilation: ../data/agent-compilation.md
+agentMetadata: ../data/agent-metadata.md
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+agentMenuPatterns: ../data/agent-menu-patterns.md
+criticalActions: ../data/critical-actions.md
+---
+
+# Edit Step 8a: Edit Simple Agent
+
+## STEP GOAL:
+
+Apply all planned edits to the Simple agent YAML file using templates and architecture references for validation.
+
+## MANDATORY EXECUTION RULES:
+
+- 🛑 ALWAYS create backup before modifying agent file
+- 📖 CRITICAL: Read template and architecture files first
+- 🔄 CRITICAL: Load editPlan and agentFile
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load all reference files before applying edits
+- 📊 Apply edits exactly as specified in editPlan
+- 💾 Validate YAML after each edit
+- ➡️ Auto-advance to post-edit validation when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load template, architecture, and data files
+- 📊 Read editPlan to get all planned changes
+- 💾 Create backup
+- 📝 Apply edits: type conversion, metadata, persona, commands, critical_actions
+- ✅ Validate YAML syntax
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read all files before editing:
+- `{simpleTemplate}` - YAML structure reference
+- `{simpleArch}` - Simple agent architecture
+- `{agentCompilation}` - Assembly guidelines
+- `{agentMetadata}`, `{personaProperties}`, `{principlesCrafting}`
+- `{agentMenuPatterns}`, `{criticalActions}`
+
+### 2. Load Edit Plan and Agent
+
+Read `{editPlan}` to get all planned edits.
+Read `{agentFile}` to get current agent YAML.
+
+### 3. Create Backup
+
+ALWAYS backup before editing:
+`cp {agentFile} {agentBackup}`
+
+Confirm: "Backup created at: `{agentBackup}`"
+
+### 4. Apply Edits in Sequence
+
+For each planned edit:
+
+**Type Conversion:**
+- Update `type:` field if converting
+- Add/remove type-specific fields
+
+**Metadata Edits:**
+- Apply each field change from metadataEdits
+
+**Persona Edits:**
+- Replace persona section with new four-field persona
+- Validate field purity (role ≠ identity ≠ communication_style)
+
+**Command Edits:**
+- Additions: append to commands array
+- Modifications: update specific commands
+- Removals: remove from commands array
+
+**Critical Actions Edits:**
+- Additions: append to critical_actions array
+- Modifications: update specific actions
+- Removals: remove from array
+
+### 5. Validate YAML After Each Edit
+
+Confirm YAML syntax is valid after each modification.
+
+### 6. Document Applied Edits
+
+Append to `{editPlan}`:
+
+```yaml
+editsApplied:
+  - {edit-description}
+  - {edit-description}
+backup: {agentBackup}
+timestamp: {YYYY-MM-DD HH:MM}
+```
+
+### 7. Auto-Advance
+
+When all edits applied successfully, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ Backup created
+✅ All reference files loaded
+✅ All edits applied correctly
+✅ YAML remains valid
+✅ Edit plan tracking updated
+
+## FAILURE MODES
+
+❌ Backup failed
+❌ YAML became invalid
+❌ Edits not applied as specified
+
+---
+
+**Auto-advancing to post-edit validation...

src/modules/bmb/workflows/agent/steps-e/e-08b-edit-expert.md

@@ -0,0 +1,117 @@
+---
+name: 'e-08b-edit-expert'
+description: 'Apply edits to Expert agent'
+
+nextStepFile: './e-09a-validate-metadata.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentFile: '{original-agent-path}'
+agentBackup: '{original-agent-path}.backup'
+
+# Template and Architecture
+expertTemplate: ../templates/expert-agent-template/expert-agent.template.md
+expertArch: ../data/expert-agent-architecture.md
+agentCompilation: ../data/agent-compilation.md
+agentMetadata: ../data/agent-metadata.md
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+agentMenuPatterns: ../data/agent-menu-patterns.md
+criticalActions: ../data/critical-actions.md
+expertValidation: ../data/expert-agent-validation.md
+---
+
+# Edit Step 8b: Edit Expert Agent
+
+## STEP GOAL:
+
+Apply all planned edits to the Expert agent YAML file and manage sidecar structure changes.
+
+## MANDATORY EXECUTION RULES:
+
+- 🛑 ALWAYS create backup before modifying agent file
+- 📖 CRITICAL: Read template and architecture files first
+- 🔄 CRITICAL: Load editPlan and agentFile
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load all reference files before applying edits
+- 📊 Manage sidecar structure for Expert agents
+- 💾 Validate YAML and sidecar paths after edits
+- ➡️ Auto-advance to post-edit validation when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load template, architecture, and data files
+- 📊 Read editPlan to get all planned changes
+- 💾 Create backup
+- 📝 Apply edits including sidecar management
+- ✅ Validate YAML and sidecar paths
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read all files before editing:
+- `{expertTemplate}` - Expert YAML structure
+- `{expertArch}` - Expert agent architecture
+- `{agentCompilation}`, `{agentMetadata}`, `{personaProperties}`, `{principlesCrafting}`
+- `{agentMenuPatterns}`, `{criticalActions}`, `{expertValidation}`
+
+### 2. Load Edit Plan and Agent
+
+Read `{editPlan}` to get all planned edits.
+Read `{agentFile}` to get current agent YAML.
+
+### 3. Create Backup
+
+ALWAYS backup before editing:
+`cp {agentFile} {agentBackup}`
+
+### 4. Apply Edits in Sequence
+
+**Type Conversion to Expert:**
+- Update `type: expert`
+- Add `metadata.sidecar-folder` if not present
+- Create sidecar directory: `mkdir -p {project-root}/_bmad/_memory/{sidecar-folder}/`
+
+**Sidecar Management:**
+- If changing sidecar-folder: update all critical_actions references
+- If removing sidecar (Expert → Simple): remove sidecar fields and folder
+- Create/update sidecar files as needed
+
+**Metadata, Persona, Commands, Critical Actions:**
+- Same as Simple agent edit
+
+### 5. Validate Sidecar Paths
+
+After editing, confirm all critical_actions reference correct sidecar paths:
+`{project-root}/_bmad/_memory/{sidecar-folder}/{file}.md`
+
+### 6. Document Applied Edits
+
+Append to `{editPlan}` with sidecar changes noted.
+
+### 7. Auto-Advance
+
+When all edits applied successfully, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ Backup created
+✅ All reference files loaded
+✅ All edits applied correctly
+✅ YAML remains valid
+✅ Sidecar structure correct
+✅ Sidecar paths validated
+
+## FAILURE MODES
+
+❌ Backup failed
+❌ YAML became invalid
+❌ Sidecar paths broken
+❌ Edits not applied as specified
+
+---
+
+**Auto-advancing to post-edit validation...

src/modules/bmb/workflows/agent/steps-e/e-08c-edit-module.md

@@ -0,0 +1,120 @@
+---
+name: 'e-08c-edit-module'
+description: 'Apply edits to Module agent'
+
+nextStepFile: './e-09a-validate-metadata.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentFile: '{original-agent-path}'
+agentBackup: '{original-agent-path}.backup'
+
+# Template and Architecture (use expert as baseline for Module)
+expertTemplate: ../templates/expert-agent-template/expert-agent.template.md
+expertArch: ../data/expert-agent-architecture.md
+moduleArch: ../data/module-agent-validation.md
+agentCompilation: ../data/agent-compilation.md
+agentMetadata: ../data/agent-metadata.md
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+agentMenuPatterns: ../data/agent-menu-patterns.md
+criticalActions: ../data/critical-actions.md
+---
+
+# Edit Step 8c: Edit Module Agent
+
+## STEP GOAL:
+
+Apply all planned edits to the Module agent YAML file and manage workflow integration and sidecar structure.
+
+## MANDATORY EXECUTION RULES:
+
+- 🛑 ALWAYS create backup before modifying agent file
+- 📖 CRITICAL: Read template and architecture files first
+- 🔄 CRITICAL: Load editPlan and agentFile
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load all reference files before applying edits
+- 📊 Manage workflow integration paths for Module agents
+- 💾 Validate YAML and workflow paths after edits
+- ➡️ Auto-advance to post-edit validation when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load template, architecture, and data files
+- 📊 Read editPlan to get all planned changes
+- 💾 Create backup
+- 📝 Apply edits including workflow paths
+- ✅ Validate YAML and workflow paths
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load Reference Documents
+
+Read all files before editing:
+- `{expertTemplate}` - Module uses expert as baseline
+- `{expertArch}`, `{moduleArch}` - Architecture references
+- `{agentCompilation}`, `{agentMetadata}`, `{personaProperties}`, `{principlesCrafting}`
+- `{agentMenuPatterns}`, `{criticalActions}`
+
+### 2. Load Edit Plan and Agent
+
+Read `{editPlan}` to get all planned edits.
+Read `{agentFile}` to get current agent YAML.
+
+### 3. Create Backup
+
+ALWAYS backup before editing:
+`cp {agentFile} {agentBackup}`
+
+### 4. Apply Edits in Sequence
+
+**Type Conversion to Module:**
+- Update `type: module`
+- Add workflow integration paths
+
+**Workflow Path Management:**
+- Add: `skills: - workflow: {path}`
+- Remove: delete workflow entries
+- Modify: update workflow paths
+
+**Sidecar for Multi-Workflow Modules:**
+- If 3+ workflows: consider sidecar creation
+- Add sidecar configuration if needed
+
+**Metadata, Persona, Commands, Critical Actions:**
+- Same as Expert agent edit
+
+### 5. Validate Workflow Paths
+
+After editing, confirm all workflow paths are valid:
+`{project-root}/_bmad/{module-id}/workflows/{workflow-name}/workflow.md`
+
+### 6. Document Applied Edits
+
+Append to `{editPlan}` with workflow changes noted.
+
+### 7. Auto-Advance
+
+When all edits applied successfully, load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ Backup created
+✅ All reference files loaded
+✅ All edits applied correctly
+✅ YAML remains valid
+✅ Workflow paths validated
+✅ Sidecar structure correct (if applicable)
+
+## FAILURE MODES
+
+❌ Backup failed
+❌ YAML became invalid
+❌ Workflow paths broken
+❌ Edits not applied as specified
+
+---
+
+**Auto-advancing to post-edit validation...

src/modules/bmb/workflows/agent/steps-e/e-09a-validate-metadata.md

@@ -0,0 +1,70 @@
+---
+name: 'e-09a-validate-metadata'
+description: 'Validate metadata (after edit) - no menu, auto-advance'
+
+nextStepFile: './e-09b-validate-persona.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+---
+
+# Edit Step 9a: Validate Metadata (After Edit)
+
+## STEP GOAL:
+
+Validate the agent's metadata properties after edits. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentMetadata first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate metadata against agentMetadata.md rules
+- 📊 Record findings to editPlan frontmatter (validationAfter section)
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMetadata.md reference
+- 📊 Validate all metadata fields
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMetadata}` and `{editPlan}`.
+
+### 2. Validate Metadata
+
+Perform checks on id, name, title, icon, module, hasSidecar.
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+validationAfter:
+  metadata:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All metadata checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to persona validation...**

src/modules/bmb/workflows/agent/steps-e/e-09b-validate-persona.md

@@ -0,0 +1,70 @@
+---
+name: 'e-09b-validate-persona'
+description: 'Validate persona (after edit) - no menu, auto-advance'
+
+nextStepFile: './e-09c-validate-menu.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+---
+
+# Edit Step 9b: Validate Persona (After Edit)
+
+## STEP GOAL:
+
+Validate the agent's persona after edits. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and persona references first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate persona four-field system
+- 📊 Record findings to editPlan frontmatter (validationAfter section)
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load personaProperties.md and principlesCrafting.md
+- 📊 Validate persona fields
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{personaProperties}`, `{principlesCrafting}`, and `{editPlan}`.
+
+### 2. Validate Persona
+
+Perform checks on role, identity, communication_style, principles.
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  persona:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All persona checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to menu validation...**

src/modules/bmb/workflows/agent/steps-e/e-09c-validate-menu.md

@@ -0,0 +1,69 @@
+---
+name: 'e-09c-validate-menu'
+description: 'Validate menu structure (after edit) - no menu, auto-advance'
+
+nextStepFile: './e-09d-validate-structure.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentMenuPatterns: ../data/agent-menu-patterns.md
+---
+
+# Edit Step 9c: Validate Menu (After Edit)
+
+## STEP GOAL:
+
+Validate the agent's command menu structure after edits. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentMenuPatterns first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate command/menu structure
+- 📊 Record findings to editPlan frontmatter (validationAfter section)
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMenuPatterns.md reference
+- 📊 Validate commands and menu
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMenuPatterns}` and `{editPlan}`.
+
+### 2. Validate Menu
+
+Perform checks on A/P/C convention, command names, descriptions.
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  menu:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All menu checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to structure validation...**

src/modules/bmb/workflows/agent/steps-e/e-09d-validate-structure.md

@@ -0,0 +1,69 @@
+---
+name: 'e-09d-validate-structure'
+description: 'Validate YAML structure (after edit) - no menu, auto-advance'
+
+nextStepFile: './e-09e-validate-sidecar.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+agentCompilation: ../data/agent-compilation.md
+---
+
+# Edit Step 9d: Validate Structure (After Edit)
+
+## STEP GOAL:
+
+Validate the agent's YAML structure after edits. Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and agentCompilation first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate YAML structure and required fields
+- 📊 Record findings to editPlan frontmatter (validationAfter section)
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentCompilation.md reference
+- 📊 Validate YAML structure
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to next validation step when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentCompilation}` and `{editPlan}`.
+
+### 2. Validate Structure
+
+Perform checks on YAML syntax, required fields, field types, indentation.
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  structure:
+    status: [pass|fail|warning]
+    findings:
+      - {check}: [pass|fail]
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ All structure checks performed and recorded
+✅ Findings saved to editPlan
+✅ Auto-advanced to next step
+
+---
+
+**Auto-advancing to sidecar validation...**

src/modules/bmb/workflows/agent/steps-e/e-09e-validate-sidecar.md

@@ -0,0 +1,70 @@
+---
+name: 'e-09e-validate-sidecar'
+description: 'Validate sidecar structure (after edit) - no menu, auto-advance'
+
+nextStepFile: './e-09f-validation-summary.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+expertValidation: ../data/expert-agent-validation.md
+---
+
+# Edit Step 9e: Validate Sidecar (After Edit)
+
+## STEP GOAL:
+
+Validate the agent's sidecar structure after edits (if Expert type). Record findings to editPlan and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan and expertValidation first
+- 🚫 NO MENU in this step - record findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate sidecar structure for Expert agents
+- 📊 Record findings to editPlan frontmatter (validationAfter section)
+- 🚫 FORBIDDEN to present menu - auto-advance when complete
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load expertValidation.md reference
+- 📊 Validate sidecar if Expert type, skip for Simple/Module
+- 💾 Record findings to editPlan
+- ➡️ Auto-advance to validation summary when complete
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{expertValidation}` and `{editPlan}` to get agent type.
+
+### 2. Conditional Validation
+
+**IF agentType == expert:** Check sidecar-folder, sidecar-path, file existence
+**IF agentType != expert:** Mark as N/A
+
+### 3. Record Findings
+
+Append to editPlan frontmatter:
+
+```yaml
+  sidecar:
+    status: [pass|fail|warning|n/a]
+    findings:
+      - {check}: [pass|fail|n/a]
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+## SUCCESS METRICS
+
+✅ Sidecar checks performed (or N/A recorded)
+✅ Findings saved to editPlan
+✅ Auto-advanced to validation summary
+
+---
+
+**Auto-advancing to validation summary...**

src/modules/bmb/workflows/agent/steps-e/e-09f-validation-summary.md

@@ -0,0 +1,111 @@
+---
+name: 'e-09f-validation-summary'
+description: 'Display all validation findings after edit'
+
+nextStepFile: './e-10-celebrate.md'
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 9f: Validation Summary (After Edit)
+
+## STEP GOAL:
+
+Display all post-edit validation findings and compare with pre-edit state. Present findings and await confirmation to proceed to celebration.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan to collect all validation findings
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Display all validation findings clearly organized
+- 📊 Compare before/after states
+- 💬 Present options for handling any remaining issues
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Read editPlan to get validation findings
+- 📊 Display organized summary with before/after comparison
+- 💾 Allow user to decide how to proceed
+
+## Sequence of Instructions:
+
+### 1. Load Validation Findings
+
+Read `{editPlan}` frontmatter to collect validationBefore and validationAfter findings.
+
+### 2. Display Validation Summary
+
+```markdown
+## Post-Edit Validation Report for {agent-name}
+
+### Before vs After Comparison
+
+| Component | Before | After | Status |
+|-----------|--------|-------|--------|
+| Metadata | {status} | {status} | {Δ} |
+| Persona | {status} | {status} | {Δ} |
+| Menu | {status} | {status} | {Δ} |
+| Structure | {status} | {status} | {Δ} |
+| Sidecar | {status} | {status} | {Δ} |
+
+### Detailed Findings (After Edit)
+
+**Metadata:** {summary}
+**Persona:** {summary}
+**Menu:** {summary}
+**Structure:** {summary}
+**Sidecar:** {summary}
+```
+
+### 3. Present Options
+
+"How do the edits look?
+
+**[R]eview** - Show detailed before/after for any component
+**[F]ix** - Address any remaining issues
+**[A]ccept** - Proceed to celebration"
+
+### 4. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Celebration"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF R: Show detailed before/after comparison, then redisplay menu
+- IF C: Save validation summary to {editPlan}, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#4-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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [validation summary displayed], will you then load and read fully `{nextStepFile}` to execute and celebrate completion.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All validation findings displayed clearly
+- Before/after comparison shown
+- User given options for handling issues
+
+### ❌ SYSTEM FAILURE:
+
+- Findings not displayed to user
+- Proceeding without user acknowledgment
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-e/e-10-celebrate.md

@@ -0,0 +1,150 @@
+---
+name: 'e-10-celebrate'
+description: 'Celebrate successful agent edit completion'
+
+editPlan: '{bmb_creations_output_folder}/edit-plan-{agent-name}.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Edit Step 10: Celebration
+
+## STEP GOAL:
+
+Celebrate the successful agent edit, provide summary of changes, and mark edit workflow completion.
+
+## MANDATORY EXECUTION RULES:
+
+- 🎉 ALWAYS celebrate the achievement with enthusiasm
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read editPlan to summarize what was accomplished
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a celebration coordinator who acknowledges successful agent improvements
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring celebration energy, user brings their satisfaction, together we acknowledge successful collaboration
+
+### Step-Specific Rules:
+
+- 🎯 Focus on celebrating and summarizing what was accomplished
+- 🚫 FORBIDDEN to end without marking workflow completion
+- 💬 Approach: Enthusiastic while providing clear summary
+
+## EXECUTION PROTOCOLS:
+
+- 🎉 Celebrate the edit completion enthusiastically
+- 📊 Provide clear summary of all changes made
+- 💾 Mark workflow completion in edit plan
+- 🚫 FORBIDDEN to end without proper completion marking
+
+## CONTEXT BOUNDARIES:
+
+- Available context: editPlan with full edit history
+- Focus: Celebration and summary
+- Limits: No more edits, only acknowledgment
+- Dependencies: All edits successfully applied
+
+## Sequence of Instructions:
+
+### 1. Read Edit Plan
+
+Read `{editPlan}` to get:
+- Original agent state
+- All edits that were applied
+- Validation results (before and after)
+
+### 2. Grand Celebration
+
+"🎉 **Excellent work!** Your agent **{agent-name}** has been successfully updated!"
+
+### 3. Edit Summary
+
+```markdown
+## Edit Summary for {agent-name}
+
+**Completed:** {YYYY-MM-DD HH:MM}
+**Edits Applied:** {count}
+
+### What Changed
+
+**Persona Updates:** {list or "None"}
+**Command Updates:** {list or "None"}
+**Metadata Updates:** {list or "None"}
+**Type Conversion:** {details or "None"}
+
+### Validation Results
+
+**Before:** {summary of pre-edit validation}
+**After:** {summary of post-edit validation}
+```
+
+### 4. Verification Guidance
+
+"**Quick Test:**
+- Load the agent and check it initializes correctly
+- Run through a few commands to verify behavior
+
+**File Locations:**
+- **Agent File:** `{agentFile}`
+- **Backup:** `{agentFile}.backup`"
+
+### 5. Document Completion
+
+Append to editPlan:
+
+```markdown
+## Edit Session Complete ✅
+
+**Completed:** {YYYY-MM-DD HH:MM}
+**Status:** Success
+
+### Final State
+- Agent file updated successfully
+- All edits applied
+- Backup preserved
+```
+
+### 6. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [X] Exit Workflow"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF X: Save completion status to {editPlan} and end workflow gracefully
+- 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 complete workflow when user selects 'X'
+- After other menu items execution, return to this menu
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [X exit option] is selected and [completion documented], will the workflow end gracefully with agent edit complete.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Enthusiastic celebration of edit completion
+- Clear summary of all changes provided
+- Before/after validation comparison shown
+- Verification guidance provided
+- Workflow completion marked in edit plan
+
+### ❌ SYSTEM FAILURE:
+
+- Ending without marking workflow completion
+- Not providing clear summary of changes
+- Missing celebration of achievement
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-v/v-01-load-review.md

@@ -0,0 +1,128 @@
+---
+name: 'v-01-load-review'
+description: 'Load agent and initialize validation report'
+
+nextStepFile: './v-02a-validate-metadata.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Validate Step 1: Load Agent for Review
+
+## STEP GOAL:
+
+Load the existing agent file and initialize a validation report to track all findings.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Load the complete agent file
+- 📊 Create validation report tracking document
+- 🚫 FORBIDDEN to proceed without user confirming correct agent
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load the complete agent YAML file
+- 📊 Parse and display agent summary
+- 💾 Create validation report document
+- 🚫 FORBIDDEN to proceed without user confirmation
+
+## Sequence of Instructions:
+
+### 1. Load Agent File
+
+Read the complete YAML from the agent file path provided by the user.
+
+### 2. Display Agent Summary
+
+```markdown
+## Agent to Validate: {agent-name}
+
+**Type:** {simple|expert|module}
+**Version:** {version}
+**File:** {agent-file-path}
+
+### Current Structure:
+
+**Persona:** {character count} characters
+**Commands:** {count} commands
+**Critical Actions:** {count} actions
+```
+
+### 3. Create Validation Report
+
+Initialize the validation report:
+
+```markdown
+---
+agentName: '{agent-name}'
+agentType: '{simple|expert|module}'
+agentFile: '{agent-file-path}'
+validationDate: '{YYYY-MM-DD}'
+stepsCompleted:
+  - v-01-load-review.md
+---
+
+# Validation Report: {agent-name}
+
+## Agent Overview
+
+**Name:** {agent-name}
+**Type:** {simple|expert|module}
+**Version:** {version}
+**File:** {agent-file-path}
+
+---
+
+## Validation Findings
+
+*This section will be populated by validation steps*
+```
+
+Write to `{validationReport}`.
+
+### 4. Present MENU OPTIONS
+
+Display: "**Is this the correct agent to validate?** [A] Advanced Elicitation [P] Party Mode [C] Yes, Begin Validation"
+
+#### 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 to {validationReport}, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#4-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
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [agent loaded and report created], will you then load and read fully `{nextStepFile}` to execute and begin validation.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Agent file loaded successfully
+- Validation report created
+- User confirmed correct agent
+
+### ❌ SYSTEM FAILURE:
+
+- Failed to load agent file
+- Report not created
+- Proceeded without user confirmation
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/steps-v/v-02a-validate-metadata.md

@@ -0,0 +1,73 @@
+---
+name: 'v-02a-validate-metadata'
+description: 'Validate metadata and append to report'
+
+nextStepFile: './v-02b-validate-persona.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+agentMetadata: ../data/agent-metadata.md
+---
+
+# Validate Step 2a: Validate Metadata
+
+## STEP GOAL:
+
+Validate the agent's metadata properties against BMAD standards. Append findings to validation report and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport and agentMetadata first
+- 🚫 NO MENU - append findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate metadata against agentMetadata.md rules
+- 📊 Append findings to validation report
+- 🚫 FORBIDDEN to present menu
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMetadata.md reference
+- 📊 Validate all metadata fields
+- 💾 Append findings to validation report
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMetadata}` and `{validationReport}`.
+
+### 2. Validate Metadata
+
+Perform checks on: id, name, title, icon, module, hasSidecar.
+
+### 3. Append Findings to Report
+
+Append to `{validationReport}`:
+
+```markdown
+### Metadata Validation
+
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+
+**Checks:**
+- [ ] id: kebab-case, no spaces
+- [ ] name: clear display name
+- [ ] title: concise function description
+- [ ] icon: appropriate emoji/symbol
+- [ ] module: correct format `{project}:{type}:{name}`
+- [ ] hasSidecar: matches actual usage
+
+**Findings:**
+{Detailed findings}
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+---
+
+**Validating persona...**

src/modules/bmb/workflows/agent/steps-v/v-02b-validate-persona.md

@@ -0,0 +1,72 @@
+---
+name: 'v-02b-validate-persona'
+description: 'Validate persona and append to report'
+
+nextStepFile: './v-02c-validate-menu.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+personaProperties: ../data/persona-properties.md
+principlesCrafting: ../data/principles-crafting.md
+---
+
+# Validate Step 2b: Validate Persona
+
+## STEP GOAL:
+
+Validate the agent's persona against BMAD standards. Append findings to validation report and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport and persona references first
+- 🚫 NO MENU - append findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate persona four-field system
+- 📊 Append findings to validation report
+- 🚫 FORBIDDEN to present menu
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load personaProperties.md and principlesCrafting.md
+- 📊 Validate persona fields
+- 💾 Append findings to validation report
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{personaProperties}`, `{principlesCrafting}`, and `{validationReport}`.
+
+### 2. Validate Persona
+
+Perform checks on: role, identity, communication_style, principles.
+
+### 3. Append Findings to Report
+
+Append to `{validationReport}`:
+
+```markdown
+### Persona Validation
+
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+
+**Checks:**
+- [ ] role: specific, not generic
+- [ ] identity: defines who agent is
+- [ ] communication_style: speech patterns only
+- [ ] principles: first principle activates expert knowledge
+
+**Findings:**
+{Detailed findings}
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+---
+
+**Validating menu structure...**

src/modules/bmb/workflows/agent/steps-v/v-02c-validate-menu.md

@@ -0,0 +1,71 @@
+---
+name: 'v-02c-validate-menu'
+description: 'Validate menu structure and append to report'
+
+nextStepFile: './v-02d-validate-structure.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+agentMenuPatterns: ../data/agent-menu-patterns.md
+---
+
+# Validate Step 2c: Validate Menu
+
+## STEP GOAL:
+
+Validate the agent's command menu structure against BMAD standards. Append findings to validation report and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport and agentMenuPatterns first
+- 🚫 NO MENU - append findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate command/menu structure
+- 📊 Append findings to validation report
+- 🚫 FORBIDDEN to present menu
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentMenuPatterns.md reference
+- 📊 Validate commands and menu
+- 💾 Append findings to validation report
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentMenuPatterns}` and `{validationReport}`.
+
+### 2. Validate Menu
+
+Perform checks on: A/P/C convention, command names, descriptions.
+
+### 3. Append Findings to Report
+
+Append to `{validationReport}`:
+
+```markdown
+### Menu Validation
+
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+
+**Checks:**
+- [ ] A/P/C convention followed
+- [ ] Command names clear and descriptive
+- [ ] Command descriptions specific and actionable
+- [ ] Menu handling logic properly specified
+
+**Findings:**
+{Detailed findings}
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+---
+
+**Validating YAML structure...**

src/modules/bmb/workflows/agent/steps-v/v-02d-validate-structure.md

@@ -0,0 +1,71 @@
+---
+name: 'v-02d-validate-structure'
+description: 'Validate YAML structure and append to report'
+
+nextStepFile: './v-02e-validate-sidecar.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+agentCompilation: ../data/agent-compilation.md
+---
+
+# Validate Step 2d: Validate Structure
+
+## STEP GOAL:
+
+Validate the agent's YAML structure and completeness. Append findings to validation report and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport and agentCompilation first
+- 🚫 NO MENU - append findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate YAML structure and required fields
+- 📊 Append findings to validation report
+- 🚫 FORBIDDEN to present menu
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load agentCompilation.md reference
+- 📊 Validate YAML structure
+- 💾 Append findings to validation report
+- ➡️ Auto-advance to next validation step
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{agentCompilation}` and `{validationReport}`.
+
+### 2. Validate Structure
+
+Perform checks on: YAML syntax, required fields, field types, indentation.
+
+### 3. Append Findings to Report
+
+Append to `{validationReport}`:
+
+```markdown
+### Structure Validation
+
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL}
+
+**Checks:**
+- [ ] Valid YAML syntax
+- [ ] Required fields present (name, description, type, persona)
+- [ ] Field types correct (arrays, strings)
+- [ ] Consistent 2-space indentation
+
+**Findings:**
+{Detailed findings}
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+---
+
+**Validating sidecar structure...**

src/modules/bmb/workflows/agent/steps-v/v-02e-validate-sidecar.md

@@ -0,0 +1,76 @@
+---
+name: 'v-02e-validate-sidecar'
+description: 'Validate sidecar structure and append to report'
+
+nextStepFile: './v-03-summary.md'
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+expertValidation: ../data/expert-agent-validation.md
+---
+
+# Validate Step 2e: Validate Sidecar
+
+## STEP GOAL:
+
+Validate the agent's sidecar structure (if Expert type). Append findings to validation report and auto-advance.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport and expertValidation first
+- 🚫 NO MENU - append findings and auto-advance
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Validate sidecar structure for Expert agents
+- 📊 Append findings to validation report
+- 🚫 FORBIDDEN to present menu
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load expertValidation.md reference
+- 📊 Validate sidecar if Expert type, skip for Simple/Module
+- 💾 Append findings to validation report
+- ➡️ Auto-advance to summary step
+
+## Sequence of Instructions:
+
+### 1. Load References
+
+Read `{expertValidation}` and `{validationReport}` to get agent type.
+
+### 2. Conditional Validation
+
+**IF agentType == expert:**
+- Check metadata.sidecar-folder present
+- Check sidecar-path correct format
+- Verify sidecar files exist
+
+**IF agentType != expert:**
+- Mark as N/A
+
+### 3. Append Findings to Report
+
+Append to `{validationReport}`:
+
+```markdown
+### Sidecar Validation
+
+**Status:** {✅ PASS / ⚠️ WARNING / ❌ FAIL / N/A}
+
+**Checks:**
+- [ ] metadata.sidecar-folder present (Expert only)
+- [ ] sidecar-path format correct
+- [ ] Sidecar files exist at specified path
+
+**Findings:**
+{Detailed findings or "N/A - Not an Expert agent"}
+```
+
+### 4. Auto-Advance
+
+Load and execute `{nextStepFile}` immediately.
+
+---
+
+**Compiling validation summary...**

src/modules/bmb/workflows/agent/steps-v/v-03-summary.md

@@ -0,0 +1,100 @@
+---
+name: 'v-03-summary'
+description: 'Display complete validation report and offer next steps'
+
+validationReport: '{bmb_creations_output_folder}/validation-report-{agent-name}.md'
+
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+---
+
+# Validate Step 3: Validation Summary
+
+## STEP GOAL:
+
+Display the complete validation report to the user and offer options for fixing issues or improving the agent.
+
+## MANDATORY EXECUTION RULES:
+
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: Read validationReport to display findings
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Step-Specific Rules:
+
+- 🎯 Display complete validation report clearly
+- 📊 Offer options for fixing issues
+- 💬 Present next step choices
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Read validation report to collect all findings
+- 📊 Display organized summary
+- 💾 Allow user to decide next steps
+
+## Sequence of Instructions:
+
+### 1. Load Validation Report
+
+Read `{validationReport}` to collect all validation findings.
+
+### 2. Display Complete Report
+
+```markdown
+## Validation Complete: {agent-name}
+
+### Overall Status
+
+{Summary table: Metadata | Persona | Menu | Structure | Sidecar}
+
+### Detailed Findings
+
+{Display all sections from the validation report}
+```
+
+### 3. Present Next Steps
+
+"What would you like to do?
+
+**[E]dit Agent** - Launch edit workflow to fix issues or make improvements
+**[S]ave Report** - Save this validation report and exit
+**[R]etry** - Run validation again (if you've made external changes)"
+
+### 4. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [E] Edit Agent [S] Save & Exit [R] Retry Validation"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, and when finished redisplay the menu
+- IF P: Execute {partyModeWorkflow}, and when finished redisplay the menu
+- IF E: Inform user they can launch edit workflow with the same agent file, then redisplay menu
+- IF S: Save final report to {validationReport} and end workflow
+- IF R: Restart validation from step v-01
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#4-present-menu-options)
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- User can chat or ask questions - always respond and then end with display again of the menu options
+
+## CRITICAL STEP COMPLETION NOTE
+
+The validation workflow is complete when user selects [S] to save the report, or [E] to proceed to edit workflow.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Complete validation report displayed
+- All findings clearly organized
+- User offered clear next steps
+
+### ❌ SYSTEM FAILURE:
+
+- Findings not displayed to user
+- No clear next steps offered
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/agent/workflow.md

@@ -0,0 +1,123 @@
+---
+name: agent
+description: Tri-modal workflow for creating, editing, and validating BMAD Core compliant agents
+web_bundle: true
+---
+
+# Agent Workflow
+
+**Goal:** Collaboratively create, edit, or validate BMAD Core compliant agents through guided discovery and systematic execution.
+
+**Your Role:** In addition to your name, communication_style, and persona, you are also an expert agent architect specializing in BMAD Core agent lifecycle management. You guide users through creating new agents, editing existing ones, or validating agent configurations.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self-contained instruction file
+- **Just-In-Time Loading**: Only the current step file is in memory
+- **Sequential Enforcement**: Steps completed in order, conditional based on mode
+- **State Tracking**: Document progress in tracking files (agentPlan, editPlan, validationReport)
+- **Mode-Aware Routing**: Separate step flows for Create/Edit/Validate
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute numbered sections in order
+3. **WAIT FOR INPUT**: Halt at menus and wait for user selection
+4. **CHECK CONTINUATION**: Only proceed when user selects appropriate option
+5. **SAVE STATE**: Update progress before loading next step
+6. **LOAD NEXT**: When directed, load and execute the next step file
+
+### Critical Rules
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps unless explicitly optional
+- 💾 **ALWAYS** save progress and outputs
+- 🎯 **ALWAYS** follow exact instructions in step files
+- ⏸️ **ALWAYS** halt at menus and wait for input
+- 📋 **NEVER** pre-load future steps
+
+---
+
+## MODE OVERVIEW
+
+This workflow supports three modes:
+
+| Mode | Purpose | Entry Point | Output |
+|------|---------|-------------|--------|
+| **Create** | Build new agent from scratch | `steps-c/step-01-brainstorm.md` | New `.agent.yaml` file |
+| **Edit** | Modify existing agent | `steps-e/e-01-load-existing.md` | Updated `.agent.yaml` file |
+| **Validate** | Review existing agent | `steps-v/v-01-load-review.md` | Validation report |
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from `{project-root}/_bmad/bmb/config.yaml`:
+
+- `project_name`, `user_name`, `communication_language`, `document_output_language`, `bmb_creations_output_folder`
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. Mode Determination
+
+**Check if mode was specified in the command invocation:**
+
+- If user invoked with "create agent" or "new agent" → Set mode to **create**
+- If user invoked with "edit agent" or "modify agent" → Set mode to **edit**
+- If user invoked with "validate agent" or "review agent" → Set mode to **validate**
+
+**If mode is unclear from command, ask user:**
+
+"Welcome to the BMAD Agent Workflow! What would you like to do?
+
+**[C]reate** - Build a new agent from scratch
+**[E]dit** - Modify an existing agent
+**[V]alidate** - Review an existing agent and generate report
+
+Please select: [C]reate / [E]dit / [V]alidate"
+
+### 3. Route to First Step
+
+**IF mode == create:**
+Load, read completely, then execute `steps-c/step-01-brainstorm.md`
+
+**IF mode == edit:**
+Prompt for agent file path: "Which agent would you like to edit? Please provide the path to the `.agent.yaml` file."
+Then load, read completely, and execute `steps-e/e-01-load-existing.md`
+
+**IF mode == validate:**
+Prompt for agent file path: "Which agent would you like to validate? Please provide the path to the `.agent.yaml` file."
+Then load, read completely, and execute `steps-v/v-01-load-review.md`
+
+---
+
+## MODE-SPECIFIC NOTES
+
+### Create Mode
+- Starts with optional brainstorming
+- Progresses through discovery, metadata, persona, commands, activation
+- Builds agent based on type (Simple/Expert/Module)
+- Validates built agent
+- Celebrates completion with installation guidance
+
+### Edit Mode
+- Loads existing agent first
+- Discovers what user wants to change
+- Validates current agent before editing
+- Creates structured edit plan
+- Applies changes with validation
+- Celebrates successful edit
+
+### Validate Mode
+- Loads existing agent
+- Runs systematic validation (metadata, persona, menu, structure, sidecar)
+- Generates comprehensive validation report
+- Offers option to apply fixes if user desires

src/modules/bmb/workflows/create-agent/workflow.md

@@ -1,59 +0,0 @@
----
-name: create-agent
-description: Interactive workflow to build BMAD Core compliant agents with optional brainstorming, persona development, and command structure
-web_bundle: true
----
-
-# Create Agent Workflow
-
-**Goal:** Collaboratively build BMAD Core compliant agents through guided discovery, preserving all functionality from the legacy workflow while enabling step-specific loading.
-
-**Your Role:** In addition to your name, communication_style, and persona, you are also an expert agent architect and builder specializing in BMAD Core agent creation. You guide users through discovering their agent's purpose, shaping its personality, building its capabilities, and generating complete YAML configuration with all necessary supporting files.
-
----
-
-## WORKFLOW ARCHITECTURE
-
-This uses **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self contained instruction file
-- **Just-In-Time Loading**: Only the current step file is in memory
-- **Sequential Enforcement**: Steps completed in order, conditional based on agent type
-- **State Tracking**: Document progress in agent output files
-- **Agent-Type Optimization**: Load only relevant steps for Simple/Expert/Module agents
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute numbered sections in order
-3. **WAIT FOR INPUT**: Halt at menus and wait for user selection
-4. **CHECK CONTINUATION**: Only proceed when user selects 'C' (Continue)
-5. **SAVE STATE**: Update progress before loading next step
-6. **LOAD NEXT**: When directed, load and execute the next step file
-
-### Critical Rules
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps unless explicitly optional
-- 💾 **ALWAYS** save progress and outputs
-- 🎯 **ALWAYS** follow exact instructions in step files
-- ⏸️ **ALWAYS** halt at menus and wait for input
-- 📋 **NEVER** pre-load future steps
-
----
-
-## INITIALIZATION SEQUENCE
-
-### 1. Configuration Loading
-
-Load and read full config from `{project-root}/_bmad/bmb/config.yaml`:
-
-- `project_name`, `user_name`, `communication_language`, `document_output_language`, `bmb_creations_output_folder`
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### 2. First Step EXECUTION
-
-Load, read completely, then execute `steps/step-01-brainstorm.md` to begin the workflow.

src/modules/bmb/workflows/edit-agent/steps/step-01-discover-intent.md

@@ -1,135 +0,0 @@
----
-name: 'step-01-discover-intent'
-description: 'Get agent path and user editing goals'
-
-# Path Definitions
-workflow_path: '{project-root}/bmb/workflows/create-agent/edit-agent'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-01-discover-intent.md'
-nextStepFile: '{workflow_path}/steps/step-02-analyze-agent.md'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
----
-
-# Step 1: Discover Edit Intent
-
-## STEP GOAL:
-
-Get the agent path to edit and understand what the user wants to accomplish before proceeding to targeted analysis.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an agent editor who helps users improve their BMAD agents
-- ✅ If you already have a name, communication_style and identity, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring agent architecture expertise, user brings their agent and goals, together we improve the agent
-- ✅ Maintain collaborative guiding tone throughout
-
-### Step-Specific Rules:
-
-- 🎯 Focus only on getting agent path and understanding user goals
-- 🚫 FORBIDDEN to load any documentation or analyze the agent yet
-- 💬 Approach: Direct questions to understand what needs fixing
-- 🚫 FORBIDDEN to make suggestions or propose solutions
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Ask clear questions to get agent path and user goals
-- 💾 Store path and goals for next step
-- 📖 Do NOT load any references in this step
-- 🚫 FORBIDDEN to analyze agent content yet
-
-## CONTEXT BOUNDARIES:
-
-- Available context: User wants to edit an existing agent
-- Focus: Get path and understand goals ONLY
-- Limits: No analysis, no documentation loading, no suggestions
-- Dependencies: User must provide agent path
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Get Agent Path
-
-Ask the user:
-"What agent do you want to edit? Please provide the path to:
-
-- A .agent.yaml file (Simple agent)
-- A folder containing .agent.yaml (Expert agent with sidecar files)"
-
-Wait for user response with the path.
-
-### 2. Understand Editing Goals
-
-Ask clear questions to understand what they want to accomplish:
-"What do you want to change about this agent?"
-
-Listen for specific goals such as:
-
-- Fix broken functionality
-- Update personality/communication style
-- Add or remove commands
-- Fix references or paths
-- Reorganize sidecar files (Expert agents)
-- Update for new standards
-
-Continue asking clarifying questions until goals are clear.
-
-### 3. Confirm Understanding
-
-Summarize back to user:
-"So you want to edit the agent at {{agent_path}} to {{user_goals}}. Is that correct?"
-
-### 4. Present MENU OPTIONS
-
-Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
-
-#### Menu Handling Logic:
-
-- IF A: Execute {advancedElicitationTask}
-- IF P: Execute {partyModeWorkflow}
-- IF C: Load, read entire file, then execute {nextStepFile}
-- IF Any other comments or queries: help user respond then redisplay 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 path and goals obtained], will you then load and read fully `{nextStepFile}` to execute and begin agent analysis.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Agent path clearly obtained and validated
-- User editing goals understood completely
-- User confirms understanding is correct
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Proceeding without agent path
-- Making suggestions or analyzing agent
-- Loading documentation in this step
-- Not confirming user goals clearly
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/edit-agent/steps/step-02-analyze-agent.md

@@ -1,203 +0,0 @@
----
-name: 'step-02-analyze-agent'
-description: 'Load agent and relevant documentation for analysis'
-
-# Path Definitions
-workflow_path: '{project-root}/bmb/workflows/create-agent/edit-agent'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-02-analyze-agent.md'
-nextStepFile: '{workflow_path}/steps/step-03-propose-changes.md'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
-
-# Documentation References (load JIT based on user goals)
-understanding_agent_types: '{project-root}/_bmad/bmb/docs/agents/understanding-agent-types.md'
-agent_compilation: '{project-root}/_bmad/bmb/docs/agents/agent-compilation.md'
-simple_architecture: '{project-root}/_bmad/bmb/docs/agents/simple-agent-architecture.md'
-expert_architecture: '{project-root}/_bmad/bmb/docs/agents/expert-agent-architecture.md'
-module_architecture: '{project-root}/_bmad/bmb/docs/agents/module-agent-architecture.md'
-menu_patterns: '{project-root}/_bmad/bmb/docs/agents/agent-menu-patterns.md'
-communication_presets: '{project-root}/_bmad/bmb/workflows/create-agent/data/communication-presets.csv'
-reference_simple_agent: '{project-root}/_bmad/bmb/reference/agents/simple-examples/commit-poet.agent.yaml'
-reference_expert_agent: '{project-root}/_bmad/bmb/reference/agents/expert-examples/journal-keeper/journal-keeper.agent.yaml'
-validation: '{project-root}/_bmad/bmb/workflows/create-agent/data/agent-validation-checklist.md'
----
-
-# Step 2: Analyze Agent
-
-## STEP GOAL:
-
-Load the agent and relevant documentation, then analyze with focus on the user's stated goals to identify specific issues that need fixing.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an agent editor with deep knowledge of BMAD agent architecture
-- ✅ If you already have a name, communication_style and identity, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring agent architecture expertise, user brings their agent and goals, together we identify specific improvements
-- ✅ Maintain analytical yet supportive tone throughout
-
-### Step-Specific Rules:
-
-- 🎯 Focus analysis ONLY on user's stated goals from step 1
-- 🚫 FORBIDDEN to load documentation not relevant to user goals
-- 💬 Approach: Load documentation JIT when needed for specific analysis
-- 🚫 FORBIDDEN to propose solutions yet (analysis only)
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Load agent file from path provided in step 1
-- 💾 Load documentation JIT based on user goals
-- 📖 Always "Load and read fully" when accessing documentation
-- 🚫 FORBIDDEN to make changes in this step (analysis only)
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Agent path and user goals from step 1
-- Focus: Analyze agent in context of user goals
-- Limits: Only load documentation relevant to stated goals
-- Dependencies: Must have agent path and clear user goals
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Load Agent File
-
-Load the agent file from the path provided in step 1:
-
-**If path is to a .agent.yaml file (Simple Agent):**
-
-- Load and read the entire YAML file
-- Note: Simple agent, all content in one file
-
-**If path is to a folder (Expert Agent with sidecar files):**
-
-- Load and read the .agent.yaml file from inside the folder
-- Inventory all sidecar files in the folder:
-  - Templates (`_.md`, `_.txt`)
-  - Documentation files
-  - Knowledge base files (`_.csv`, `_.json`, `*.yaml`)
-  - Any other resources referenced by the agent
-- Note: Expert agent with sidecar structure
-
-Present what was loaded:
-
-- "Loaded [agent-name].agent.yaml"
-- If Expert: "Plus X sidecar files: [list them]"
-
-### 2. Load Relevant Documentation Based on User Goals
-
-**CRITICAL: Load documentation JIT based ONLY on user's stated goals:**
-
-**If user mentioned persona/communication issues:**
-
-- Load and read fully: `{agent_compilation}` - understand how LLM interprets persona fields
-- Load and read fully: `{communication_presets}` - reference for pure communication styles
-
-**If user mentioned functional/broken reference issues:**
-
-- Load and read fully: `{menu_patterns}` - proper menu structure
-- Load and read fully: `{agent_compilation}` - compilation requirements
-
-**If user mentioned sidecar/structure issues (Expert agents):**
-
-- Load and read fully: `{expert_architecture}` - sidecar best practices
-
-**If user mentioned agent type confusion:**
-
-- Load and read fully: `{understanding_agent_types}`
-- Load and read fully appropriate architecture guide based on agent type
-
-### 3. Focused Analysis Based on User Goals
-
-Analyze only what's relevant to user goals:
-
-**For persona/communication issues:**
-
-- Check communication_style field for mixed behaviors/identity/principles
-- Look for red flag words that indicate improper mixing:
-  - "ensures", "makes sure", "always", "never" → Behaviors (belongs in principles)
-  - "experienced", "expert who", "senior", "seasoned" → Identity descriptors (belongs in role/identity)
-  - "believes in", "focused on", "committed to" → Philosophy (belongs in principles)
-- Compare current communication_style against examples in `{communication_presets}`
-
-**For functional issues:**
-
-- Verify all workflow references exist and are valid
-- Check menu handler patterns against `{menu_patterns}`
-- Validate YAML syntax and structure
-
-**For sidecar issues:**
-
-- Map each menu item reference to actual sidecar files
-- Identify orphaned files (not referenced in YAML)
-- Check if all referenced files actually exist
-
-### 4. Report Findings
-
-Present focused analysis findings:
-"Based on your goal to {{user_goal}}, I found the following issues:"
-
-For each issue found:
-
-- Describe the specific problem
-- Show the relevant section of the agent
-- Reference the loaded documentation that explains the standard
-- Explain why this is an issue
-
-### 5. Present MENU OPTIONS
-
-Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
-
-#### Menu Handling Logic:
-
-- IF A: Execute {advancedElicitationTask}
-- IF P: Execute {partyModeWorkflow}
-- IF C: Load, read entire file, then execute {nextStepFile}
-- IF Any other comments or queries: help user respond then redisplay 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 [analysis complete with specific issues identified], will you then load and read fully `{nextStepFile}` to execute and begin proposing specific changes.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- Agent file loaded completely with proper type detection
-- Relevant documentation loaded JIT based on user goals
-- Analysis focused only on user's stated issues
-- Specific problems identified with documentation references
-- User understands what needs fixing and why
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Loading documentation not relevant to user goals
-- Proposing solutions instead of analyzing
-- Missing critical issues related to user goals
-- Not following "load and read fully" instruction
-- Making changes to agent files
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/edit-agent/steps/step-03-propose-changes.md

@@ -1,158 +0,0 @@
----
-name: 'step-03-propose-changes'
-description: 'Propose specific changes and get approval'
-
-# Path Definitions
-workflow_path: '{project-root}/bmb/workflows/create-agent/edit-agent'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-03-propose-changes.md'
-nextStepFile: '{workflow_path}/steps/step-04-apply-changes.md'
-agentFile: '{{agent_path}}'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
-
-# Documentation References (load JIT if needed)
-communication_presets: '{project-root}/_bmad/bmb/workflows/create-agent/data/communication-presets.csv'
-agent_compilation: '{project-root}/_bmad/bmb/docs/agents/agent-compilation.md'
----
-
-# Step 3: Propose Changes
-
-## STEP GOAL:
-
-Propose specific, targeted changes based on analysis and get user approval before applying them to the agent.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an agent editor who helps users improve their BMAD agents through targeted changes
-- ✅ If you already have a name, communication_style and identity, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring agent architecture expertise, user brings their agent and goals, together we improve the agent
-- ✅ Maintain collaborative guiding tone throughout
-
-### Step-Specific Rules:
-
-- 🎯 Focus only on proposing changes based on analysis from step 2
-- 🚫 FORBIDDEN to apply changes without explicit user approval
-- 💬 Approach: Present one change at a time with clear before/after comparison
-- 📋 Load references JIT when explaining rationale or providing examples
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Propose one change at a time with clear before/after comparison
-- 💾 Track approved changes for application in next step
-- 📖 Load references JIT if needed for examples or best practices
-- 🚫 FORBIDDEN to apply changes without explicit user approval
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Analysis results from step 2, agent path, and user goals from step 1
-- Focus: Propose specific changes based on analysis, not apply them
-- Limits: Only propose changes, do not modify any files yet
-- Dependencies: Must have completed step 2 analysis results
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Present First Change
-
-Based on analysis from step 2, propose the most important change first:
-
-"I recommend fixing {{issue}} because {{reason}}.
-
-**Current:**
-
-```yaml
-{ { current_code } }
-```
-
-**Proposed:**
-
-```yaml
-{ { proposed_code } }
-```
-
-This will help with {{benefit}}."
-
-### 2. Explain Rationale
-
-- Why this change matters for the agent's functionality
-- How it aligns with BMAD agent best practices
-- Reference loaded documentation if helpful for explaining
-
-### 3. Load References if Needed
-
-**Load references JIT when explaining:**
-
-- If proposing persona changes: Load and read `{communication_presets}` for examples
-- If proposing structural changes: Load and read `{agent_compilation}` for requirements
-
-### 4. Get User Approval
-
-"Does this change look good? Should I apply it?"
-Wait for explicit user approval before proceeding.
-
-### 5. Repeat for Each Issue
-
-Go through each identified issue from step 2 analysis one by one:
-
-- Present change with before/after
-- Explain rationale with loaded references if needed
-- Get explicit user approval for each change
-- Track which changes are approved vs rejected
-
-### 6. Present MENU OPTIONS
-
-Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
-
-#### Menu Handling Logic:
-
-- IF A: Execute {advancedElicitationTask}
-- IF P: Execute {partyModeWorkflow}
-- IF C: Save approved changes list to context, 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 [all proposed changes reviewed and user approvals obtained], will you then load and read fully `{nextStepFile}` to execute and begin applying approved changes.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All proposed changes clearly presented with before/after comparison
-- Rationale explained with references to best practices
-- User approval obtained for each proposed change
-- Approved changes tracked for application in next step
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Applying changes without explicit user approval
-- Not presenting clear before/after comparisons
-- Skipping explanation of rationale or references
-- Proceeding without tracking which changes were approved
-- Loading references when not needed for current proposal
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/edit-agent/steps/step-04-apply-changes.md

@@ -1,151 +0,0 @@
----
-name: 'step-04-apply-changes'
-description: 'Apply approved changes to the agent'
-
-# Path Definitions
-workflow_path: '{project-root}/bmb/workflows/create-agent/edit-agent'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-04-apply-changes.md'
-agentFile: '{{agent_path}}'
-nextStepFile: '{workflow_path}/steps/step-05-validate.md'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
----
-
-# Step 4: Apply Changes
-
-## STEP GOAL:
-
-Apply all user-approved changes to the agent files directly using the Edit tool.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an agent editor who helps users improve their BMAD agents through precise modifications
-- ✅ If you already have a name, communication_style and identity, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring agent architecture expertise, user brings their agent and goals, together we improve the agent
-- ✅ Maintain collaborative guiding tone throughout
-
-### Step-Specific Rules:
-
-- 🎯 Focus only on applying changes that were explicitly approved in step 3
-- 🚫 FORBIDDEN to make any changes that were not approved by the user
-- 💬 Approach: Apply changes one by one with confirmation after each
-- 📋 Use Edit tool to make precise modifications to agent files
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Apply only changes that were explicitly approved in step 3
-- 💾 Show confirmation after each change is applied
-- 📖 Edit files directly using Edit tool with precise modifications
-- 🚫 FORBIDDEN to make unapproved changes or extra modifications
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Approved changes list from step 3, agent path from step 1
-- Focus: Apply ONLY the approved changes, nothing more
-- Limits: Do not make any modifications beyond what was explicitly approved
-- Dependencies: Must have approved changes list from step 3
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Load Agent File
-
-Read the complete agent file to understand current state before making changes.
-
-### 2. Apply First Approved Change
-
-For each change approved in step 3, apply it systematically:
-
-**For YAML changes in main agent file:**
-
-- Use Edit tool to modify the agent YAML file at `{agentFile}`
-- Make the exact approved modification
-- Confirm the change was applied correctly
-
-**For sidecar file changes (Expert agents):**
-
-- Use Edit tool to modify the specific sidecar file
-- Make the exact approved modification
-- Confirm the change was applied correctly
-
-### 3. Confirm Each Change Applied
-
-After each change is applied:
-"Applied change: {{description}}
-
-- Updated section matches approved change ✓
-- File saved successfully ✓"
-
-### 4. Continue Until All Changes Applied
-
-Repeat step 2-3 for each approved change until complete:
-
-- Apply change using Edit tool
-- Confirm it matches what was approved
-- Move to next approved change
-
-### 5. Verify All Changes Complete
-
-"Summary of changes applied:
-
-- {{number}} changes applied successfully
-- All modifications match user approvals from step 3
-- Agent files updated and saved"
-
-### 6. Present MENU OPTIONS
-
-Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
-
-#### Menu Handling Logic:
-
-- IF A: Execute {advancedElicitationTask}
-- IF P: Execute {partyModeWorkflow}
-- IF C: Save completion status to context, 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 [all approved changes from step 3 have been applied to agent files], will you then load and read fully `{nextStepFile}` to execute and begin validation of applied changes.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All approved changes from step 3 applied using Edit tool
-- Each modification matches exactly what was approved by user
-- Agent files updated and saved correctly
-- Confirmation provided for each applied change
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Making changes that were not approved in step 3
-- Using tools other than Edit tool for file modifications
-- Not confirming each change was applied correctly
-- Making extra modifications beyond approved changes
-- Skipping confirmation steps or verification
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/edit-agent/steps/step-05-validate.md

@@ -1,151 +0,0 @@
----
-name: 'step-05-validate'
-description: 'Validate that changes work correctly'
-
-# Path Definitions
-workflow_path: '{project-root}/bmb/workflows/create-agent/edit-agent'
-
-# File References
-thisStepFile: '{workflow_path}/steps/step-05-validate.md'
-agentFile: '{{agent_path}}'
-
-# Task References
-advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
-partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
-
-# Documentation References (load JIT)
-validation: '{project-root}/_bmad/bmb/workflows/create-agent/data/agent-validation-checklist.md'
-agent_compilation: '{project-root}/_bmad/bmb/docs/agents/agent-compilation.md'
----
-
-# Step 5: Validate Changes
-
-## STEP GOAL:
-
-Validate that the applied changes work correctly and the edited agent follows BMAD best practices and standards.
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-### Universal Rules:
-
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: Read the complete step file before taking any action
-- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### Role Reinforcement:
-
-- ✅ You are an agent editor who helps users ensure their edited BMAD agents meet quality standards
-- ✅ If you already have a name, communication_style and identity, continue to use those while playing this new role
-- ✅ We engage in collaborative dialogue, not command-response
-- ✅ You bring agent architecture expertise, user brings their agent and goals, together we ensure quality
-- ✅ Maintain collaborative guiding tone throughout
-
-### Step-Specific Rules:
-
-- 🎯 Focus only on validating changes that were applied in step 4
-- 🚫 FORBIDDEN to make additional changes during validation
-- 💬 Approach: Systematic validation using standard checklist
-- 📋 Load validation references JIT when needed for specific checks
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 Validate only the changes that were applied in step 4
-- 💾 Report validation results clearly and systematically
-- 📖 Load validation checklist and standards JIT as needed
-- 🚫 FORBIDDEN to make additional modifications during validation
-
-## CONTEXT BOUNDARIES:
-
-- Available context: Applied changes from step 4, agent path from step 1, original goals from step 1
-- Focus: Validate that applied changes work and meet standards
-- Limits: Do not modify anything, only validate and report
-- Dependencies: Must have completed step 4 with applied changes
-
-## Sequence of Instructions (Do not deviate, skip, or optimize)
-
-### 1. Load and Read Validation Standards
-
-Load and read fully: `{validation}`
-
-### 2. Load Updated Agent File
-
-Read the updated agent file to see all applied changes in context.
-
-### 3. Check Each Applied Change
-
-Verify each change that was applied in step 4:
-
-- "Checking {{change}}... ✓ Works correctly"
-- "Validating {{modification}}... ✓ Follows best practices"
-
-### 4. Run Standard Validation Checklist
-
-Check key items from validation checklist:
-
-- YAML syntax is valid and properly formatted
-- Persona fields are properly separated (if persona was changed)
-- All references and paths resolve correctly (if references were fixed)
-- Menu structure follows BMAD patterns (if menu was modified)
-- Agent compilation requirements are met (if structure changed)
-
-### 5. Load Agent Compilation if Needed
-
-If persona or agent structure was changed:
-
-- Load and read fully: `{agent_compilation}`
-- Verify persona fields follow compilation requirements
-- Check that agent structure meets BMAD standards
-
-### 6. Report Validation Results
-
-"Validation results:
-✓ All {{number}} changes applied correctly
-✓ Agent meets BMAD standards and best practices
-✓ No issues found in modified sections
-✓ Ready for use"
-
-### 7. Present MENU OPTIONS
-
-Display: "**Select an Option:** [A] Edit Another Agent [P] Party Mode [C] Complete"
-
-#### Menu Handling Logic:
-
-- IF A: Start fresh workflow with new agent path
-- IF P: Execute {partyModeWorkflow} to celebrate successful agent editing
-- IF C: Complete workflow and provide final success message
-- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#7-present-menu-options)
-
-#### EXECUTION RULES:
-
-- ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed when user selects 'A', 'P', or 'C'
-- After party mode 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 complete option] is selected and [all changes from step 4 have been validated successfully], will you then provide a final workflow completion message. The agent editing workflow is complete.
-
----
-
-## 🚨 SYSTEM SUCCESS/FAILURE METRICS
-
-### ✅ SUCCESS:
-
-- All applied changes from step 4 validated successfully
-- Agent meets BMAD standards and best practices
-- Validation checklist completed with no critical issues
-- Clear validation report provided to user
-- Menu presented and user input handled correctly
-
-### ❌ SYSTEM FAILURE:
-
-- Not validating all applied changes from step 4
-- Making modifications during validation step
-- Skipping validation checklist or standards checks
-- Not reporting validation results clearly
-- Not loading references when needed for specific validation
-
-**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

src/modules/bmb/workflows/edit-agent/workflow.md

@@ -1,59 +0,0 @@
----
-name: edit-agent
-description: Edit existing BMAD agents while following all best practices and conventions
-web_bundle: false
----
-
-# Edit Agent Workflow
-
-**Goal:** Edit existing BMAD agents following best practices with targeted analysis and direct updates.
-
-**Your Role:** In addition to your name, communication_style, and persona, you are also an agent editor collaborating with a BMAD agent owner. This is a partnership, not a client-vendor relationship. You bring agent architecture expertise and editing skills, while the user brings their agent and specific improvement goals. Work together as equals.
-
----
-
-## WORKFLOW ARCHITECTURE
-
-This uses **step-file architecture** for disciplined execution:
-
-### Core Principles
-
-- **Micro-file Design**: Each step is a self contained instruction file that is a part of an overall workflow that must be followed exactly
-- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until told to do so
-- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
-- **State Tracking**: Document progress in context for editing workflows (no output file frontmatter needed)
-- **Append-Only Building**: Build documents by appending content as directed to the output file
-
-### Step Processing Rules
-
-1. **READ COMPLETELY**: Always read the entire step file before taking any action
-2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
-3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
-4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
-5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
-6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
-
-### Critical Rules (NO EXCEPTIONS)
-
-- 🛑 **NEVER** load multiple step files simultaneously
-- 📖 **ALWAYS** read entire step file before execution
-- 🚫 **NEVER** skip steps or optimize the sequence
-- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
-- 🎯 **ALWAYS** follow the exact instructions in the step file
-- ⏸️ **ALWAYS** halt at menus and wait for user input
-- 📋 **NEVER** create mental todo lists from future steps
-
----
-
-## INITIALIZATION SEQUENCE
-
-### 1. Configuration Loading
-
-Load and read full config from {project-root}/_bmad/bmb/config.yaml and resolve:
-
-- `project_name`, `output_folder`, `user_name`, `communication_language`, `document_output_language`
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-### 2. First Step EXECUTION
-
-Load, read the full file and then execute `{workflow_path}/steps/step-01-discover-intent.md` to begin the workflow.