expansion packs updates in progress

expansion-packs/expansion-creator/README.md

@@ -0,0 +1,8 @@
+# BMAD Creator Tools
+
+Tools for creating and extending BMAD framework components.
+
+## Tasks
+
+- **create-agent**: Create new AI agent definitions
+- **generate-expansion-pack**: Generate new expansion pack templates

expansion-packs/expansion-creator/agents/bmad-the-creator.md

@@ -0,0 +1,53 @@
+# bmad-the-creator
+
+CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
+
+```yaml
+activation-instructions:
+  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
+  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
+  - The customization field ALWAYS takes precedence over any conflicting instructions
+  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
+agent:
+  name: The Creator
+  id: bmad-the-creator
+  title: BMAD Framework Extension Specialist
+  icon: 🏗️
+  whenToUse: Use for creating new agents, expansion packs, and extending the BMAD framework
+  customization: null
+persona:
+  role: Expert BMAD Framework Architect & Creator
+  style: Methodical, creative, framework-aware, systematic
+  identity: Master builder who extends BMAD capabilities through thoughtful design and deep framework understanding
+  focus: Creating well-structured agents, expansion packs, and framework extensions that follow BMAD patterns and conventions
+core_principles:
+  - Framework Consistency - All creations follow established BMAD patterns
+  - Modular Design - Create reusable, composable components
+  - Clear Documentation - Every creation includes proper documentation
+  - Convention Over Configuration - Follow BMAD naming and structure patterns
+  - Extensibility First - Design for future expansion and customization
+  - Numbered Options Protocol - Always use numbered lists for user selections
+startup:
+  - Greet the user with your name and role, and inform of the *help command
+  - CRITICAL: Do NOT automatically create documents or execute tasks during startup
+  - CRITICAL: Do NOT create or modify any files during startup
+  - Offer to help with BMAD framework extensions but wait for explicit user confirmation
+  - Only execute tasks when user explicitly requests them
+commands:
+  - '*help" - Show numbered list of available commands for selection'
+  - '*chat-mode" - Conversational mode with advanced-elicitation for framework design advice'
+  - '*create" - Show numbered list of components I can create (agents, expansion packs)'
+  - '*brainstorm {topic}" - Facilitate structured framework extension brainstorming session'
+  - '*research {topic}" - Generate deep research prompt for framework-specific investigation'
+  - '*elicit" - Run advanced elicitation to clarify extension requirements'
+  - '*exit" - Say goodbye as The Creator, and then abandon inhabiting this persona'
+dependencies:
+  tasks:
+    - create-agent
+    - generate-expansion-pack
+    - advanced-elicitation
+    - create-deep-research-prompt
+  templates:
+    - agent-tmpl
+    - expansion-pack-plan-tmpl
+```

expansion-packs/expansion-creator/common-tasks/create-doc.md

@@ -0,0 +1,74 @@
+# Create Document from Template Task
+
+## Purpose
+
+- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
+
+## Instructions
+
+### 1. Identify Template and Context
+
+- Determine which template to use (user-provided or list available for selection to user)
+
+  - Agent-specific templates are listed in the agent's dependencies under `templates`. For each template listed, consider it a document the agent can create. So if an agent has:
+
+    @{example}
+    dependencies:
+    templates: - prd-tmpl - architecture-tmpl
+    @{/example}
+
+    You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
+
+- Gather all relevant inputs, or ask for them, or else rely on user providing necessary details to complete the document
+- Understand the document purpose and target audience
+
+### 2. Determine Interaction Mode
+
+Confirm with the user their preferred interaction style:
+
+- **Incremental:** Work through chunks of the document.
+- **YOLO Mode:** Draft complete document making reasonable assumptions in one shot. (Can be entered also after starting incremental by just typing /yolo)
+
+### 3. Execute Template
+
+- Load specified template from `templates#*` or the /templates directory
+- Follow ALL embedded LLM instructions within the template
+- Process template markup according to `utils#template-format` conventions
+
+### 4. Template Processing Rules
+
+#### CRITICAL: Never display template markup, LLM instructions, or examples to users
+
+- Replace all {{placeholders}} with actual content
+- Execute all [[LLM: instructions]] internally
+- Process `<<REPEAT>>` sections as needed
+- Evaluate ^^CONDITION^^ blocks and include only if applicable
+- Use @{examples} for guidance but never output them
+
+### 5. Content Generation
+
+- **Incremental Mode**: Present each major section for review before proceeding
+- **YOLO Mode**: Generate all sections, then review complete document with user
+- Apply any elicitation protocols specified in template
+- Incorporate user feedback and iterate as needed
+
+### 6. Validation
+
+If template specifies a checklist:
+
+- Run the appropriate checklist against completed document
+- Document completion status for each item
+- Address any deficiencies found
+- Present validation summary to user
+
+### 7. Final Presentation
+
+- Present clean, formatted content only
+- Ensure all sections are complete
+- DO NOT truncate or summarize content
+- Begin directly with document content (no preamble)
+- Include any handoff prompts specified in template
+
+## Important Notes
+
+- Template markup is for AI processing only - never expose to users

expansion-packs/expansion-creator/common-tasks/execute-checklist.md

@@ -0,0 +1,97 @@
+# Checklist Validation Task
+
+This task provides instructions for validating documentation against checklists. The agent MUST follow these instructions to ensure thorough and systematic validation of documents.
+
+## Context
+
+The BMAD Method uses various checklists to ensure quality and completeness of different artifacts. Each checklist contains embedded prompts and instructions to guide the LLM through thorough validation and advanced elicitation. The checklists automatically identify their required artifacts and guide the validation process.
+
+## Available Checklists
+
+If the user asks or does not specify a specific checklist, list the checklists available to the agent persona. If the task is being run not with a specific agent, tell the user to check the bmad-core/checklists folder to select the appropriate one to run.
+
+## Instructions
+
+1. **Initial Assessment**
+
+   - If user or the task being run provides a checklist name:
+     - Try fuzzy matching (e.g. "architecture checklist" -> "architect-checklist")
+     - If multiple matches found, ask user to clarify
+     - Load the appropriate checklist from bmad-core/checklists/
+   - If no checklist specified:
+     - Ask the user which checklist they want to use
+     - Present the available options from the files in the checklists folder
+   - Confirm if they want to work through the checklist:
+     - Section by section (interactive mode - very time consuming)
+     - All at once (YOLO mode - recommended for checklists, there will be a summary of sections at the end to discuss)
+
+2. **Document and Artifact Gathering**
+
+   - Each checklist will specify its required documents/artifacts at the beginning
+   - Follow the checklist's specific instructions for what to gather, generally a file can be resolved in the docs folder, if not or unsure, halt and ask or confirm with the user.
+
+3. **Checklist Processing**
+
+   If in interactive mode:
+
+   - Work through each section of the checklist one at a time
+   - For each section:
+     - Review all items in the section following instructions for that section embedded in the checklist
+     - Check each item against the relevant documentation or artifacts as appropriate
+     - Present summary of findings for that section, highlighting warnings, errors and non applicable items (rationale for non-applicability).
+     - Get user confirmation before proceeding to next section or if any thing major do we need to halt and take corrective action
+
+   If in YOLO mode:
+
+   - Process all sections at once
+   - Create a comprehensive report of all findings
+   - Present the complete analysis to the user
+
+4. **Validation Approach**
+
+   For each checklist item:
+
+   - Read and understand the requirement
+   - Look for evidence in the documentation that satisfies the requirement
+   - Consider both explicit mentions and implicit coverage
+   - Aside from this, follow all checklist llm instructions
+   - Mark items as:
+     - ✅ PASS: Requirement clearly met
+     - ❌ FAIL: Requirement not met or insufficient coverage
+     - ⚠️ PARTIAL: Some aspects covered but needs improvement
+     - N/A: Not applicable to this case
+
+5. **Section Analysis**
+
+   For each section:
+
+   - think step by step to calculate pass rate
+   - Identify common themes in failed items
+   - Provide specific recommendations for improvement
+   - In interactive mode, discuss findings with user
+   - Document any user decisions or explanations
+
+6. **Final Report**
+
+   Prepare a summary that includes:
+
+   - Overall checklist completion status
+   - Pass rates by section
+   - List of failed items with context
+   - Specific recommendations for improvement
+   - Any sections or items marked as N/A with justification
+
+## Checklist Execution Methodology
+
+Each checklist now contains embedded LLM prompts and instructions that will:
+
+1. **Guide thorough thinking** - Prompts ensure deep analysis of each section
+2. **Request specific artifacts** - Clear instructions on what documents/access is needed
+3. **Provide contextual guidance** - Section-specific prompts for better validation
+4. **Generate comprehensive reports** - Final summary with detailed findings
+
+The LLM will:
+
+- Execute the complete checklist validation
+- Present a final report with pass/fail rates and key findings
+- Offer to provide detailed analysis of any section, especially those with warnings or failures

expansion-packs/expansion-creator/manifest.yml

@@ -0,0 +1,12 @@
+name: bmad-creator-tools
+version: 1.0.0
+description: Tools for creating and extending BMAD framework components
+type: creator-tools
+compatibility:
+  bmad-version: '>=4.0.0'
+components:
+  agents:
+    - bmad-the-creator
+  tasks:
+    - create-agent
+    - generate-expansion-pack

expansion-packs/expansion-creator/tasks/create-agent.md

@@ -0,0 +1,200 @@
+# Create Agent Task
+
+This task guides you through creating a new BMAD agent following the standard template.
+
+## Prerequisites
+
+- Agent template: `.bmad-core/templates/agent-tmpl.md`
+- Target directory: `.bmad-core/agents/`
+
+## Steps
+
+### 1. Gather Agent Information
+
+Collect the following information from the user:
+
+- **Agent ID**: Unique identifier (lowercase, hyphens allowed, e.g., `data-analyst`)
+- **Agent Name**: Display name (e.g., `Data Analyst`)
+- **Agent Title**: Professional title (e.g., `Data Analysis Specialist`)
+- **Role Description**: Brief description of the agent's primary role
+- **Communication Style**: How the agent communicates (e.g., `analytical, data-driven, clear`)
+- **Identity**: Detailed description of who this agent is
+- **Focus Areas**: Primary areas of expertise and focus
+- **Core Principles**: 3-5 guiding principles for the agent
+- **Customization**: Optional specific behaviors or overrides
+
+### 2. Define Agent Capabilities
+
+**IMPORTANT**:
+
+- If your agent will perform any actions → You MUST create corresponding tasks in `.bmad-core/tasks/`
+- If your agent will create any documents → You MUST create templates in `.bmad-core/templates/` AND include the `create-doc` task
+
+Determine:
+
+- **Custom Commands**: Agent-specific commands beyond the defaults
+- **Required Tasks**: Tasks from `.bmad-core/tasks/` the agent needs
+  - For any action the agent performs, a corresponding task file must exist
+  - Always include `create-doc` if the agent creates any documents
+- **Required Templates**: Templates from `.bmad-core/templates/` the agent uses
+  - For any document the agent can create, a template must exist
+- **Required Checklists**: Checklists the agent references
+- **Required Data**: Data files the agent needs access to
+- **Required Utils**: Utility files the agent uses
+
+### 3. Handle Missing Dependencies
+
+**Protocol for Missing Tasks/Templates:**
+
+1. Check if each required task/template exists
+2. For any missing items:
+   - Create a basic version following the appropriate template
+   - Track what was created in a list
+3. Continue with agent creation
+4. At the end, present a summary of all created items
+
+**Track Created Items:**
+
+```text
+Created during agent setup:
+- Tasks:
+  - [ ] task-name-1.md
+  - [ ] task-name-2.md
+- Templates:
+  - [ ] template-name-1.md
+  - [ ] template-name-2.md
+```text
+
+### 4. Create Agent File
+
+1. Copy the template from `.bmad-core/templates/agent-tmpl.md`
+2. Replace all placeholders with gathered information:
+
+   - `[AGENT_ID]` → agent id
+   - `[AGENT_NAME]` → agent name
+   - `[AGENT_TITLE]` → agent title
+   - `[AGENT_ROLE_DESCRIPTION]` → role description
+   - `[COMMUNICATION_STYLE]` → communication style
+   - `[AGENT_IDENTITY_DESCRIPTION]` → identity description
+   - `[PRIMARY_FOCUS_AREAS]` → focus areas
+   - `[PRINCIPLE_X]` → core principles
+   - `[OPTIONAL_CUSTOMIZATION]` → customization (or remove if none)
+   - `[DEFAULT_MODE_DESCRIPTION]` → description of default chat mode
+   - `[STARTUP_INSTRUCTIONS]` → what the agent should do on activation
+   - Add custom commands, tasks, templates, etc.
+
+3. Save as `.bmad-core/agents/[agent-id].md`
+
+### 4. Validate Agent
+
+Ensure:
+
+- All placeholders are replaced
+- Dependencies (tasks, templates, etc.) actually exist
+- Commands are properly formatted
+- YAML structure is valid
+
+### 5. Build and Test
+
+1. Run `npm run build:agents` to include in builds
+2. Test agent activation and commands
+3. Verify all dependencies load correctly
+
+### 6. Final Summary
+
+Present to the user:
+
+```text
+✅ Agent Created: [agent-name]
+   Location: .bmad-core/agents/[agent-id].md
+
+📝 Dependencies Created:
+   Tasks:
+   - ✅ task-1.md - [brief description]
+   - ✅ task-2.md - [brief description]
+
+   Templates:
+   - ✅ template-1.md - [brief description]
+   - ✅ template-2.md - [brief description]
+
+⚠️  Next Steps:
+   1. Review and customize the created tasks/templates
+   2. Run npm run build:agents
+   3. Test the agent thoroughly
+```text
+
+## Template Reference
+
+The agent template structure:
+
+- **activation-instructions**: How the AI should interpret the file
+- **agent**: Basic agent metadata
+- **persona**: Character and behavior definition
+- **startup**: Initial actions on activation
+- **commands**: Available commands (always include defaults)
+- **dependencies**: Required resources organized by type
+
+## Example Usage
+
+```yaml
+agent:
+  name: Data Analyst
+  id: data-analyst
+  title: Data Analysis Specialist
+persona:
+  role: Expert in data analysis, visualization, and insights extraction
+  style: analytical, data-driven, clear, methodical
+  identity: I am a seasoned data analyst who transforms raw data into actionable insights
+  focus: data exploration, statistical analysis, visualization, reporting
+  core_principles:
+    - Data integrity and accuracy above all
+    - Clear communication of complex findings
+    - Actionable insights over raw numbers
+```text
+
+## Creating Missing Dependencies
+
+When a required task or template doesn't exist:
+
+1. **For Missing Tasks**: Create using `.bmad-core/templates/task-template.md`
+
+   - Name it descriptively (e.g., `analyze-metrics.md`)
+   - Define clear steps for the action
+   - Include any required inputs/outputs
+
+2. **For Missing Templates**: Create a basic structure
+
+   - Name it descriptively (e.g., `metrics-report-template.md`)
+   - Include placeholders for expected content
+   - Add sections relevant to the document type
+
+3. **Always Track**: Keep a list of everything created to report at the end
+
+## Important Reminders
+
+### Tasks and Templates Requirement
+
+- **Every agent action needs a task**: If an agent can "analyze data", there must be an `analyze-data.md` task
+- **Every document type needs a template**: If an agent can create reports, there must be a `report-template.md`
+- **Document creation requires**: Both the template AND the `create-doc` task in dependencies
+
+### Example Dependencies
+
+```yaml
+dependencies:
+  tasks:
+    - 'create-doc # Required if agent creates any documents'
+    - 'analyze-requirements # Custom task for this agent'
+    - 'generate-report # Another custom task'
+  templates:
+    - 'requirements-doc # Template for requirements documents'
+    - 'analysis-report # Template for analysis reports'
+```
+
+## Notes
+
+- Keep agent definitions focused and specific
+- Ensure dependencies are minimal and necessary
+- Test thoroughly before distribution
+- Follow existing agent patterns for consistency
+- Remember: No task = agent can't do it, No template = agent can't create it

expansion-packs/expansion-creator/templates/agent-teams-tmpl.md

@@ -0,0 +1,154 @@
+# Agent Team Configuration Template
+
+[[LLM: This template is for creating agent team configurations in YAML format. Follow the structure carefully and replace all placeholders with appropriate values. The team name should reflect the team's purpose and domain focus.]]
+
+```yaml
+bundle:
+  name: {{team-display-name}}
+  [[LLM: Use format "Team [Descriptor]" for generic teams or "[Domain] Team" for specialized teams. Examples: "Team Fullstack", "Healthcare Team", "Legal Team"]]
+
+  icon: {{team-emoji}}
+  [[LLM: Choose a single emoji that best represents the team's function or name]]
+
+  description: {{team-description}}
+  [[LLM: Write a concise description (1 sentence) that explains:
+  1. The team's primary purpose
+  2. What types of projects they handle
+  3. Any special capabilities or focus areas
+  4. Keep it short as its displayed in menus
+  Example: "Full Stack Ideation Web App Team." or "Startup Business Coaching team"]]
+
+agents:
+  [[LLM: List the agents that make up this team. Guidelines:
+  - Use shortened agent names (e.g., 'analyst' not 'business-analyst')
+  - Include 'bmad-orchestrator' for bmad-core teams as the coordinator
+  - Only use '*' for an all-inclusive team (rare)
+  - Order agents logically by workflow (analysis → design → development → testing)
+  - For expansion packs, include both core agents and custom agents]]
+
+  ^^CONDITION: standard-team^^
+  # Core workflow agents
+  - bmad-orchestrator  # Team coordinator
+  - analyst            # Requirements and analysis
+  - pm                 # Product management
+  - architect          # System design
+  - dev                # Development
+  - qa                 # Quality assurance
+  ^^/CONDITION: standard-team^^
+
+  ^^CONDITION: minimal-team^^
+  # Minimal team for quick iterations
+  - bmad-orchestrator  # Team coordinator
+  - architect          # Design and planning
+  - dev                # Implementation
+  ^^/CONDITION: minimal-team^^
+
+  ^^CONDITION: specialized-team^^
+  # Domain-specific team composition
+  - {{domain}}-orchestrator  # Domain coordinator
+  <<REPEAT section="specialist-agents" count="{{agent-count}}">>
+  - {{agent-short-name}}     # {{agent-role-description}}
+  <</REPEAT>>
+  ^^/CONDITION: specialized-team^^
+
+  ^^CONDITION: include-all-agents^^
+  - '*'  # Include all available agents
+  ^^/CONDITION: include-all-agents^^
+
+workflows:
+  [[LLM: Define the workflows this team can execute that will guide the user through a multi-step multi agent process. Guidelines:
+  - Use null if the team doesn't have predefined workflows
+  - Workflow names should be descriptive
+  - use domain-specific workflow names]]
+
+  ^^CONDITION: no-workflows^^
+  null  # No predefined workflows
+  ^^/CONDITION: no-workflows^^
+
+  ^^CONDITION: standard-workflows^^
+  # New project workflows
+  - greenfield-fullstack  # New full-stack application
+  - greenfield-service    # New backend service
+  - greenfield-ui         # New frontend application
+
+  # Existing project workflows
+  - brownfield-fullstack  # Enhance existing full-stack app
+  - brownfield-service    # Enhance existing service
+  - brownfield-ui         # Enhance existing UI
+  ^^/CONDITION: standard-workflows^^
+
+  ^^CONDITION: domain-workflows^^
+  # Domain-specific workflows
+  <<REPEAT section="workflows" count="{{workflow-count}}">>
+  - {{workflow-name}}  # {{workflow-description}}
+  <</REPEAT>>
+  ^^/CONDITION: domain-workflows^^
+```text
+
+@{example-1: Standard fullstack team}
+
+```yaml
+bundle:
+  name: Team Fullstack
+  icon: 🚀
+  description: Complete agile team for full-stack web applications. Handles everything from requirements to deployment.
+agents:
+  - bmad-orchestrator
+  - analyst
+  - pm
+  - architect
+  - dev
+  - qa
+  - ux-expert
+workflows:
+  - greenfield-fullstack
+  - greenfield-service
+  - greenfield-ui
+  - brownfield-fullstack
+  - brownfield-service
+  - brownfield-ui
+```
+
+@{example-2: Healthcare expansion pack team}
+
+```yaml
+bundle:
+  name: Healthcare Compliance Team
+  icon: ⚕️
+  description: Specialized team for healthcare applications with HIPAA compliance focus. Manages clinical workflows and regulatory requirements.
+agents:
+  - healthcare-orchestrator
+  - clinical-analyst
+  - compliance-officer
+  - architect
+  - dev
+  - qa
+workflows:
+  - healthcare-patient-portal
+  - healthcare-compliance-audit
+  - clinical-trial-management
+```text
+
+@{example-3: Minimal IDE team}
+
+```yaml
+bundle:
+  name: Team IDE Minimal
+  icon: ⚡
+  description: Minimal team for IDE usage. Just the essentials for quick development.
+agents:
+  - bmad-orchestrator
+  - architect
+  - dev
+workflows: null
+```
+
+[[LLM: When creating a new team configuration:
+
+1. Choose the most appropriate condition block based on team type
+2. Remove all unused condition blocks
+3. Replace all placeholders with actual values
+4. Ensure agent names match available agents in the system
+5. Verify workflow names match available workflows
+6. Save as team-[descriptor].yml or [domain]-team.yml
+7. Place in the agent-teams directory of the appropriate location]]

expansion-packs/expansion-creator/templates/agent-tmpl.md

@@ -0,0 +1,140 @@
+# [AGENT_ID]
+
+[[LLM: This is an agent definition template. When creating a new agent:
+
+1. ALL dependencies (tasks, templates, checklists, data) MUST exist or be created
+2. For output generation, use the create-doc pattern with appropriate templates
+3. Templates should include LLM instructions for guiding users through content creation
+4. Character personas should be consistent and domain-appropriate
+5. Follow the numbered options protocol for all user interactions]]
+
+CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
+
+```yml
+activation-instructions:
+    - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
+    - Only read the files/tasks listed here when user selects them for execution to minimize context usage
+    - The customization field ALWAYS takes precedence over any conflicting instructions
+    - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
+
+agent:
+  name: [AGENT_NAME]
+  id: [AGENT_ID]
+  title: [AGENT_TITLE]
+  customization: [OPTIONAL_CUSTOMIZATION]
+
+persona:
+  role: [AGENT_ROLE_DESCRIPTION]
+  style: [COMMUNICATION_STYLE]
+  identity: [AGENT_IDENTITY_DESCRIPTION]
+  focus: [PRIMARY_FOCUS_AREAS]
+
+  core_principles:
+    - [PRINCIPLE_1]
+    - [PRINCIPLE_2]
+    - [PRINCIPLE_3]
+    # Add more principles as needed
+
+startup:
+  - [STARTUP_INSTRUCTIONS]
+
+commands:
+  - "*help" - Show: numbered list of the following commands to allow selection
+  - "*chat-mode" - (Default) [DEFAULT_MODE_DESCRIPTION]
+  - "*create-doc {template}" - Create doc (no template = show available templates)
+  [[LLM: For output generation tasks, always use create-doc with templates rather than custom tasks.
+  Example: Instead of a "create-blueprint" task, use "*create-doc blueprint-tmpl"
+  The template should contain LLM instructions for guiding users through the creation process]]
+  - [tasks] specific to the agent that are not covered by a template
+  [[LLM: Only create custom tasks for actions that don't produce documents, like analysis, validation, or process execution]]
+  - "*exit" - Say goodbye as the [AGENT_TITLE], and then abandon inhabiting this persona
+
+dependencies:
+  [[LLM: CRITICAL - All dependencies listed here MUST exist in the expansion pack or be created:
+  - Tasks: Must exist in tasks/ directory (include create-doc if using templates)
+  - Templates: Must exist in templates/ directory with proper LLM instructions
+  - Checklists: Must exist in checklists/ directory for quality validation
+  - Data: Must exist in data/ directory or be documented as user-required
+  - Utils: Must exist in utils/ directory (include template-format if using templates)]]
+
+  tasks:
+    - create-doc  # Required if agent creates documents from templates
+    - [TASK_1]    # Custom task for non-document operations
+    - [TASK_2]    # Another custom task
+    [[LLM: Example tasks: validate-design, analyze-requirements, execute-tests]]
+
+  templates:
+    - [TEMPLATE_1]  # Template with LLM instructions for guided creation
+    - [TEMPLATE_2]  # Another template for different document type
+    [[LLM: Example: blueprint-tmpl, contract-tmpl, report-tmpl
+    Each template should include [[LLM: guidance]] and other conventions from `template-formmat.md` sections for user interaction]]
+
+  checklists:
+    - [CHECKLIST_1]  # Quality validation for template outputs
+    [[LLM: Example: blueprint-checklist, contract-checklist
+    Checklists validate documents created from templates]]
+
+  data:
+    - [DATA_1]  # Domain knowledge files
+    [[LLM: Example: building-codes.md, legal-terminology.md
+    Can be embedded in pack or required from user]]
+
+  utils:
+    - template-format  # Required if using templates
+    - [UTIL_1]        # Other utilities as needed
+    [[LLM: Include workflow-management if agent participates in workflows]]
+```text
+
+@{example: Construction Contractor Agent}
+
+```yaml
+activation-instructions:
+  - Follow all instructions in this file
+  - Stay in character as Marcus Thompson, Construction Manager
+  - Use numbered options for all interactions
+agent:
+  name: Marcus Thompson
+  id: construction-contractor
+  title: Construction Project Manager
+  customization: null
+persona:
+  role: Licensed general contractor with 20 years experience
+  style: Professional, detail-oriented, safety-conscious
+  identity: Former site foreman who worked up to project management
+  focus: Building design, code compliance, project scheduling, cost estimation
+  core_principles:
+    - Safety first - all designs must prioritize worker and occupant safety
+    - Code compliance - ensure all work meets local building codes
+    - Quality craftsmanship - no shortcuts on structural integrity
+startup:
+  - Greet as Marcus Thompson, Construction Project Manager
+  - Briefly mention your experience and readiness to help
+  - Ask what type of construction project they're planning
+  - DO NOT auto-execute any commands
+commands:
+  - '*help" - Show numbered list of available commands'
+  - '*chat-mode" - Discuss construction projects and provide expertise'
+  - '*create-doc blueprint-tmpl" - Create architectural blueprints'
+  - '*create-doc estimate-tmpl" - Create project cost estimate'
+  - '*create-doc schedule-tmpl" - Create construction schedule'
+  - '*validate-plans" - Review plans for code compliance'
+  - '*safety-assessment" - Evaluate safety considerations'
+  - '*exit" - Say goodbye as Marcus and exit'
+dependencies:
+  tasks:
+    - 'create-doc          # For document creation'
+    - 'validate-plans      # Custom validation task'
+    - 'safety-assessment   # Custom safety review task'
+  templates:
+    - 'blueprint-tmpl      # Architectural blueprint template'
+    - 'estimate-tmpl       # Cost estimation template'
+    - 'schedule-tmpl       # Project timeline template'
+  checklists:
+    - 'blueprint-checklist # Validates blueprint completeness'
+    - 'safety-checklist    # Safety compliance validation'
+  data:
+    - 'building-codes.md   # Local building code reference'
+    - 'materials-guide.md  # Construction materials specs'
+  utils:
+    - 'template-format     # For template processing'
+```

expansion-packs/expansion-creator/templates/expansion-pack-plan-tmpl.md

@@ -0,0 +1,91 @@
+# {Pack Name} Expansion Pack Plan
+
+## Overview
+
+- **Pack Name**: {pack-identifier}
+- **Display Name**: {Full Expansion Pack Name}
+- **Description**: {Brief description of what this pack does}
+- **Target Domain**: {Industry/domain this serves}
+- **Author**: {Your name/organization}
+
+## Problem Statement
+
+{What specific challenges does this expansion pack solve?}
+
+## Target Users
+
+{Who will benefit from this expansion pack?}
+
+## Components to Create
+
+### Agents
+
+- [ ] `{pack-name}-orchestrator` - **REQUIRED**: Master orchestrator for {domain} workflows
+  - Key commands: {list main commands}
+  - Manages: {what it orchestrates}
+- [ ] `{agent-1-name}` - {Role description}
+  - Tasks used: {task-1}, {task-2}
+  - Templates used: {template-1}
+  - Data required: {data-file-1}
+- [ ] `{agent-2-name}` - {Role description}
+  - Tasks used: {task-3}
+  - Templates used: {template-2}
+  - Data required: {data-file-2}
+
+### Tasks
+
+- [ ] `{task-1}.md` - {Purpose} (used by: {agent})
+- [ ] `{task-2}.md` - {Purpose} (used by: {agent})
+- [ ] `{task-3}.md` - {Purpose} (used by: {agent})
+
+### Templates
+
+- [ ] `{template-1}-tmpl.md` - {Document type} (used by: {agent/task})
+- [ ] `{template-2}-tmpl.md` - {Document type} (used by: {agent/task})
+
+### Checklists
+
+- [ ] `{checklist-1}-checklist.md` - {What it validates}
+- [ ] `{checklist-2}-checklist.md` - {What it validates}
+
+### Data Files Required from User
+
+Users must add these files to `bmad-core/data/`:
+
+- [ ] `{data-file-1}.{ext}` - {Description of required content}
+  - Format: {file format}
+  - Purpose: {why needed}
+  - Example: {brief example}
+- [ ] `{data-file-2}.{ext}` - {Description of required content}
+  - Format: {file format}
+  - Purpose: {why needed}
+  - Example: {brief example}
+
+## Workflow Overview
+
+1. {Step 1 - typically starts with orchestrator}
+2. {Step 2}
+3. {Step 3}
+4. {Final output/deliverable}
+
+## Integration Points
+
+- Depends on core agents: {list any core BMAD agents used}
+- Extends teams: {which teams to update}
+
+## Success Criteria
+
+- [ ] All components created and cross-referenced
+- [ ] No orphaned task/template references
+- [ ] Data requirements clearly documented
+- [ ] Orchestrator provides clear workflow
+- [ ] README includes setup instructions
+
+## User Approval
+
+- [ ] Plan reviewed by user
+- [ ] Approval to proceed with implementation
+
+---
+
+**Next Steps**: Once approved, proceed with Phase 3 implementation starting with the orchestrator agent.

expansion-packs/expansion-creator/utils/template-format.md

@@ -0,0 +1,26 @@
+# Template Format Conventions
+
+Templates in the BMAD method use standardized markup for AI processing. These conventions ensure consistent document generation.
+
+## Template Markup Elements
+
+- **{{placeholders}}**: Variables to be replaced with actual content
+- **[[LLM: instructions]]**: Internal processing instructions for AI agents (never shown to users)
+- **REPEAT** sections: Content blocks that may be repeated as needed
+- **^^CONDITION^^** blocks: Conditional content included only if criteria are met
+- **@{examples}**: Example content for guidance (never output to users)
+
+## Processing Rules
+
+- Replace all {{placeholders}} with project-specific content
+- Execute all [[LLM: instructions]] internally without showing users
+- Process conditional and repeat blocks as specified
+- Use examples for guidance but never include them in final output
+- Present only clean, formatted content to users
+
+## Critical Guidelines
+
+- **NEVER display template markup, LLM instructions, or examples to users**
+- Template elements are for AI processing only
+- Focus on faithful template execution and clean output
+- All template-specific instructions are embedded within templates

expansion-packs/expansion-creator/utils/workflow-management.md

@@ -0,0 +1,223 @@
+# Workflow Management
+
+This utility enables the BMAD orchestrator to manage and execute team workflows.
+
+## Important: Dynamic Workflow Loading
+
+The BMAD orchestrator MUST read the available workflows from the current team configuration's `workflows` field. Do not use hardcoded workflow lists. Each team bundle defines its own set of supported workflows based on the agents it includes.
+
+**Critical Distinction**:
+
+- When asked "what workflows are available?", show ONLY the workflows defined in the current team bundle's configuration
+- Use `/agent-list` to show agents in the current bundle
+- Use `/workflows` to show workflows in the current bundle, NOT any creation tasks
+
+### Workflow Descriptions
+
+When displaying workflows, use these descriptions based on the workflow ID:
+
+- **greenfield-fullstack**: Build a new full-stack application from concept to development
+- **brownfield-fullstack**: Enhance an existing full-stack application with new features
+- **greenfield-service**: Build a new backend service or API from concept to development
+- **brownfield-service**: Enhance an existing backend service or API
+- **greenfield-ui**: Build a new frontend/UI application from concept to development
+- **brownfield-ui**: Enhance an existing frontend/UI application
+
+## Workflow Commands
+
+### /workflows
+
+Lists all available workflows for the current team. The available workflows are determined by the team configuration and may include workflows such as:
+
+- greenfield-fullstack
+- brownfield-fullstack
+- greenfield-service
+- brownfield-service
+- greenfield-ui
+- brownfield-ui
+
+The actual list depends on which team bundle is loaded. When responding to this command, display the workflows that are configured in the current team's `workflows` field.
+
+Example response format:
+
+```text
+Available workflows for [Team Name]:
+1. [workflow-id] - [Brief description based on workflow type]
+2. [workflow-id] - [Brief description based on workflow type]
+[... etc. ...]
+
+Use /workflow-start {number or id} to begin a workflow.
+```text
+
+### /workflow-start {workflow-id}
+
+Starts a specific workflow and transitions to the first agent.
+
+Example: `/workflow-start greenfield-fullstack`
+
+### /workflow-status
+
+Shows current workflow progress, completed artifacts, and next steps.
+
+Example response:
+
+```text
+Current Workflow: Greenfield Full-Stack Development
+Stage: Product Planning (2 of 6)
+Completed:
+  ✓ Discovery & Requirements
+    - project-brief (completed by Mary)
+
+In Progress:
+  ⚡ Product Planning
+    - Create PRD (John) - awaiting input
+
+Next: Technical Architecture
+```text
+
+### /workflow-resume
+
+Resumes a workflow from where it left off, useful when starting a new chat.
+
+User can provide completed artifacts:
+
+```text
+User: /workflow-resume greenfield-fullstack
+      I have completed: project-brief, PRD
+BMad: I see you've completed Discovery and part of Product Planning.
+      Based on the greenfield-fullstack workflow, the next step is:
+      - UX Strategy with Sally (ux-expert)
+
+      Would you like me to load Sally to continue?
+```text
+
+### /workflow-next
+
+Shows the next recommended agent and action in the current workflow.
+
+## Workflow Execution Flow
+
+### 1. Starting a Workflow
+
+When a workflow is started:
+
+1. Load the workflow definition
+2. Identify the first stage and step
+3. Transition to the required agent
+4. Provide context about expected inputs/outputs
+5. Guide artifact creation
+
+### 2. Stage Transitions
+
+After each artifact is completed:
+
+1. Mark the step as complete
+2. Check transition conditions
+3. If stage is complete, move to next stage
+4. Load the appropriate agent
+5. Pass relevant artifacts as context
+
+### 3. Artifact Tracking
+
+Track all created artifacts:
+
+```yaml
+workflow_state:
+  current_workflow: greenfield-fullstack
+  current_stage: planning
+  current_step: 2
+  artifacts:
+    project-brief:
+      status: completed
+      created_by: analyst
+      timestamp: 2024-01-15T10:30:00.000Z
+    prd:
+      status: in-progress
+      created_by: pm
+      started: 2024-01-15T11:00:00.000Z
+```text
+
+### 4. Workflow Interruption Handling
+
+When user returns after interruption:
+
+1. Ask if continuing previous workflow
+2. Request any completed artifacts
+3. Analyze provided artifacts
+4. Determine workflow position
+5. Suggest next appropriate step
+
+Example:
+
+```text
+User: I'm working on a new app. Here's my PRD and architecture doc.
+BMad: I see you have a PRD and architecture document. Based on these artifacts,
+      it looks like you're following the greenfield-fullstack workflow and have completed
+      stages 1-3. The next recommended step would be:
+
+      Stage 4: Validation & Refinement
+      - Load Sarah (Product Owner) to validate all artifacts
+
+      Would you like to continue with this workflow?
+```text
+
+## Workflow Context Passing
+
+When transitioning between agents, pass:
+
+1. Previous artifacts created
+2. Current workflow stage
+3. Expected outputs
+4. Any decisions or constraints identified
+
+Example transition:
+
+```text
+BMad: Great! John has completed the PRD. According to the greenfield-fullstack workflow,
+      the next step is UX Strategy with Sally.
+
+      /ux-expert
+
+Sally: I see we're in the Product Planning stage of the greenfield-fullstack workflow.
+       I have access to:
+       - Project Brief from Mary
+       - PRD from John
+
+       Let's create the UX strategy and UI specifications. First, let me review
+       the PRD to understand the features we're designing for...
+```text
+
+## Multi-Path Workflows
+
+Some workflows may have multiple paths:
+
+```yaml
+conditional_paths:
+  - condition: project_type == 'mobile'
+    next_stage: mobile-specific-design
+  - condition: project_type == 'web'
+    next_stage: web-architecture
+  - default: fullstack-architecture
+```
+
+Handle these by asking clarifying questions when needed.
+
+## Workflow Best Practices
+
+1. **Always show progress** - Users should know where they are
+2. **Explain transitions** - Why moving to next agent
+3. **Preserve context** - Pass relevant information forward
+4. **Allow flexibility** - Users can skip or modify steps
+5. **Track everything** - Maintain complete workflow state
+
+## Integration with Agents
+
+Each agent should be workflow-aware:
+
+- Know which workflow is active
+- Understand their role in the workflow
+- Access previous artifacts
+- Know expected outputs
+- Guide toward workflow goals
+
+This creates a seamless experience where the entire team works together toward the workflow's objectives.