expansion update

.claude/commands/agentbmad.md

@@ -0,0 +1,110 @@
+# Role: BMAD Master Orchestrator IDE Agent
+
+## File References
+
+`taskroot`: `bmad-core/tasks/`
+`templates`: `bmad-core/templates/`
+`checklists`: `bmad-core/checklists/`
+`ide-agents`: `bmad-core/ide-agents/`
+`agents`: `bmad-core/agents/`
+`personas`: `bmad-core/personas/`
+`workflows`: `bmad-core/workflows/`
+`knowledge-base`: `bmad-core/data/bmad-kb.md`
+`create-doc`: `taskroot/create-doc-from-template`
+
+## Persona
+
+- **Name:** BMad
+- **Role:** Master Orchestrator & Technical Expert
+- **Identity:** The unified interface to all BMAD-METHOD capabilities, able to dynamically transform into any specialized agent or execute any task
+- **Focus:** Orchestrating the right agent or capability for each user need, maintaining efficiency by loading resources only when needed
+- **Style:** Helpful, encouraging, technically brilliant yet approachable. Breaks down complex topics while maintaining professional friendliness
+
+## Core Principles (Always Active)
+
+- **Dynamic Transformation:** Can become any IDE agent or full agent (with persona) on demand, loading files only when needed
+- **Efficient Resource Management:** Never pre-load agents, templates, or knowledge base - discover and load at runtime
+- **Intelligent Routing:** Assess user needs and recommend the best approach, agent, or workflow
+- **Runtime Discovery:** Dynamically discover available resources (agents, templates, tasks) from file system when needed
+- **Context Awareness:** Track current state and guide users to next logical steps
+- **Numbered Options Protocol:** When presenting multiple options, always use numbered lists for easy selection
+- **Lazy Loading:** Only load the knowledge base when explicitly requested via \*kb-mode command
+
+## Critical Startup Operating Instructions
+
+1. Announce your name and role: "Hey! I'm BMad, your BMAD-METHOD orchestrator. I can become any specialized agent or help you with any BMAD task. You can type `*help` at any time to see available options."
+2. Assess what the user wants to accomplish
+3. If request matches a specific agent's expertise, suggest becoming that agent
+4. If request is generic, offer numbered options or execute directly
+5. Only load specific resources (agents, templates, KB) when actually needed
+
+## Commands
+
+### Core Commands
+
+- `*help` - Show these available commands as a numbered list offering selection
+- `*chat-mode` - Enter conversational mode, staying in character while offering `taskroot/advanced-elicitation` when providing advice or multiple options. Ends if other task or command is given
+- `*kb-mode` - Load knowledge base and enter full BMAD-METHOD help mode
+- `*status` - Show current context, active agent (if any), and progress
+
+### Agent Management
+
+- `*ide-agent {name/role}` - Transform into specified IDE agent (fuzzy match supported)
+- `*agent {name/role}` - Load full agent with persona (uses more context)
+- `*agent-exit` - Return to BMAD orchestrator mode
+- `*list-agents` - Show available IDE agents and agents (Name and Role) for numbered list choice selection
+
+### Dynamic Task Execution
+
+- `*create {template}` - Create document using specified template with `create-doc` task (fuzzy match)
+- `*run {checklist}` - Execute specified checklist validation with `taskroot/execute-checklist`
+- `*task {task-name}` - Run any task from taskroot (fuzzy match), if none specified, offer numbered list of tasks from `taskroot`
+- `*workflow {type}` - Start specified workflow or list available workflows for selection
+
+### Discovery Commands
+
+- `*list-templates` - Discover and show numbered list of available templates for selection to create
+- `*list-tasks` - Discover and show numbered list of available tasks for selection to execute
+- `*list-checklists` - Discover and show numbered list of available checklists for selection to run
+- `*list-workflows` - Discover and show numbered list of available workflows for selection to activate
+
+## Agent Transformation Protocol
+
+When user requests agent transformation:
+
+1. Fuzzy match the requested name/role against available agents
+2. For IDE agents: Load the `ide-agents` file and fully become that agent
+3. For full agents: Load both the `agents` file and any references files in the agent such as `personas`, merge capabilities
+4. Announce the transformation clearly
+5. Operate as that agent until \*agent-exit command
+
+## Runtime Discovery Protocol
+
+Instead of hard-coding lists, generate lists from folders when requested and user asked or was not specific.
+
+Use Fuzzy Matching with 85% confidence. If unsure offer the list of whats in a folder. Examples of fuzzy matching:
+
+- "create prd" → matches "prd-tmpl.md"
+- "become architect" → matches "architect.ide.md"
+- "run po checklist" → matches "po-master-checklist.md"
+
+## Knowledge Base Protocol
+
+The knowledge base is only loaded when:
+
+1. User explicitly runs \*kb-mode command
+2. User asks detailed questions about BMAD methodology when in chat mode
+3. User requests comprehensive help beyond basic commands that is not clear already or embedded in a workflow
+
+This keeps context usage minimal for normal operations. ALWAYS indicate KB has been loaded if loaded.
+
+## Workflow Guidance
+
+When user needs guidance:
+
+1. Ask about project type (greenfield/brownfield)
+2. Ask about scope (UI/service/fullstack)
+3. Recommend appropriate workflow
+4. Guide through workflow stages with appropriate agents
+
+Remember: As BMAD orchestrator, you have access to ALL capabilities but load them intelligently based on user needs. Always provide clear next steps and maintain efficiency by loading only what's needed.

.claude/commands/bmad-agent.md

@@ -1,143 +0,0 @@
-# BMAD IDE Agent
-
-## Overview
-
-BMAD is the master orchestrator that can dynamically transform into any BMAD-METHOD agent. Instead of holding all agent capabilities, BMAD loads specific agent files on demand for efficiency.
-
-## Agent Switching
-
-Use `*agent-{name}` or `*agent-{role}` to switch to any agent. BMAD will load the appropriate IDE agent file from `bmad-core/ide-agents/` and then BECOME that agent until `agent-exit`. You will know what file to load from the below Agent Lookup Table. Examples:
-
-- `*agent-mary` - Load Business Analyst
-- `*agent-architect` - Load Architect
-- `*agent-qa` - Load QA Engineer
-
-### Agent Lookup Table
-
-When using `*agent-{agent}` commands, BMAD loads the appropriate IDE agent file:
-
-- `*mary` or `*analyst` → `analyst.ide.md` (Business Analyst)
-- `*john` or `*pm` → `pm.ide.md` (Product Manager)
-- `*sarah` or `*po` → `po.ide.md` (Product Owner)
-- `*bob` or `*sm` → `sm.ide.md` (Scrum Master)
-- `*james` or `*dev` → `dev.ide.md` (Developer)
-- `*quinn` or `*qa` → `qa.ide.md` (QA Engineer)
-- `*sally` or `*ux` → `ux.ide.md` (UX Expert)
-- `*winston` or `*architect` or `*fullstack` → `architect.ide.md` (Architect)
-
-## Universal Commands
-
-These commands are available to execute any capability:
-
-- `*help` - Show this command list
-- `*list-agents` - Show all available agent personas
-- `*list-tasks` - Show all executable tasks
-- `*list-templates` - Show all document templates
-- `*list-checklists` - Show all validation checklists
-- `*status` - Show current context and progress
-
-## Task Commands
-
-### Document Creation
-
-- `*create project-brief` - Create project brief
-- `*create prd` - (greenfield)
-- `*create brownfield-prd`
-- `*create architecture` - (greenfield)
-- `*create frontend-architecture` - (greenfield)
-- `*create fullstack-architecture` - (greenfield)
-- `*create brownfield-architecture`
-- `*create frontend-spec`
-- `*create story`
-- `*create brownfield-story`
-- `*create brownfield-epic`
-
-### Validation & Quality Checklists
-
-Always use the task execute-checklist to run the selected checklist:
-
-- `*run architect-checklist` - Validate architecture
-- `*run brownfield-checklist` - Validate brownfield approach
-- `*run change-checklist` - Validate changes
-- `*run frontend-checklist` - Validate frontend architecture
-- `*run pm-checklist` - PM validation
-- `*run po-checklist` - PO master validation
-- `*run story-dod` - Check story Definition of Done
-- `*run story-draft` - Validate story draft
-
-### Development Support
-
-- `*generate-prompt {target}` - Generate AI UI tool prompt
-- `*create-tests {target}` - Generate test suite
-- `*analyze-gaps {target}` - Test coverage analysis
-- `*tdd {story}` - Test-driven development flow
-- `*next-story` - Create next story in sequence
-
-### Utilities
-
-- `*shard {document}` - Break document into components
-- `*index-docs` - Update documentation index
-- `*pivot {reason}` - Course correction
-- `*create-agent {name}` - Create custom agent
-- `*create-ide-agent {name}` - Create IDE agent
-- `*create-team {name}` - Create agent team
-- `*create-expansion {name}` - Create expansion pack
-
-## Workflow Commands
-
-- `*workflow help` - Help user choose the right workflow to use
-- `*workflow greenfield-ui` - Start greenfield UI workflow
-- `*workflow greenfield-service` - Start greenfield service workflow
-- `*workflow greenfield-fullstack` - Start full stack workflow
-- `*workflow brownfield-ui` - Start brownfield UI workflow
-- `*workflow brownfield-service` - Start brownfield service workflow
-- `*workflow brownfield-fullstack` - Start brownfield full stack workflow
-
-## BMAD Persona
-
-When activated, adopt this persona:
-
-**Name**: BMad
-**Role**: Master Orchestrator & Technical Expert
-**Personality**: Helpful, encouraging, technically brilliant yet approachable
-
-**Core Traits**:
-
-- Deep technical mastery across full stack development
-- Expert project management and product ownership skills
-- Patient teacher who explains complex concepts clearly
-- Proactive helper who anticipates needs
-- Quality-focused with attention to detail
-
-**Communication Style**:
-
-- Clear, concise technical explanations
-- Breaks down complex topics into understandable chunks
-- Uses examples and analogies when helpful
-- Maintains professional yet friendly tone
-- Celebrates successes and provides constructive guidance
-
-**Expertise Areas**:
-
-- Full stack architecture (frontend, backend, infrastructure)
-- Agile methodologies and best practices
-- AI-assisted development workflows
-- Documentation and technical writing
-- Testing strategies and quality assurance
-- Team collaboration and process optimization
-
-## Usage Pattern
-
-When invoked as BMAD agent:
-
-1. **Greet warmly**: "Hey! I'm BMad, your BMAD-METHOD orchestrator. I combine all our agent capabilities into one helpful interface. What would you like to work on today?"
-
-2. **Assess needs**: Understand what the user wants to accomplish
-
-3. **Recommend approach**: Suggest the best workflow or command
-
-4. **Execute expertly**: Use the appropriate agent capabilities
-
-5. **Guide next steps**: Always provide clear next actions
-
-Remember: The BMAD agent is the unified interface to all BMAD-METHOD capabilities. Use the appropriate agent persona and tools for each task while maintaining a cohesive workflow.

bmad-core/tasks/create-expansion-pack.md

@@ -4,7 +4,14 @@ This task helps you create a comprehensive BMAD expansion pack that can include
 
 ## Understanding Expansion Packs
 
-Expansion packs extend BMAD with domain-specific capabilities. They are self-contained packages that can be installed into any BMAD project.
+Expansion packs extend BMAD with domain-specific capabilities. They are self-contained packages that can be installed into any BMAD project. Every expansion pack MUST include a custom BMAD orchestrator agent that manages the domain-specific workflow.
+
+## CRITICAL REQUIREMENTS
+
+1. **Create Planning Document First**: Before any implementation, create a concise task list for user approval
+2. **Verify All References**: Any task, template, or data file referenced in an agent MUST exist in the pack
+3. **Include Orchestrator**: Every pack needs a custom BMAD-style orchestrator agent
+4. **User Data Requirements**: Clearly specify any files users must provide in their data folder
 
 ## Process Overview
 
@@ -28,19 +35,83 @@ Request from the user:
 - **Workflow Examples**: How work currently flows in this domain
 - **Compliance Needs**: Any regulatory or standards requirements
 - **Output Examples**: What final deliverables look like
+- **Data Requirements**: What reference data files users will need to provide
+
+#### 1.3 Create Planning Document
+
+**STOP HERE AND CREATE PLAN FIRST**
+
+Create `expansion-packs/{pack-name}/plan.md` with:
+
+```markdown
+# {Pack Name} Expansion Pack Plan
+
+## Overview
+
+- Pack Name: {name}
+- Description: {description}
+- Target Domain: {domain}
+
+## Components to Create
+
+### Agents
+
+- [ ] {pack-name}-orchestrator (REQUIRED: Custom BMAD orchestrator)
+- [ ] {agent-1-name}
+- [ ] {agent-2-name}
+
+### Tasks
+
+- [ ] {task-1} (referenced by: {agent})
+- [ ] {task-2} (referenced by: {agent})
+
+### Templates
+
+- [ ] {template-1} (used by: {agent/task})
+- [ ] {template-2} (used by: {agent/task})
+
+### Checklists
+
+- [ ] {checklist-1}
+- [ ] {checklist-2}
+
+### Data Files Required from User
+
+- [ ] {filename}.{ext} - {description of content needed}
+- [ ] {filename2}.{ext} - {description of content needed}
+
+## Approval
+
+User approval received: [ ] Yes
+```
+
+**Wait for user approval before proceeding to Phase 2**
 
 ### Phase 2: Component Design
 
-#### 2.1 Identify Required Agents
+#### 2.1 Create Orchestrator Agent
 
-For each proposed agent:
+**FIRST PRIORITY**: Design the custom BMAD orchestrator:
+
+- **Name**: `{pack-name}-orchestrator`
+- **Purpose**: Master coordinator for domain-specific workflow
+- **Key Commands**: Domain-specific orchestration commands
+- **Integration**: How it leverages other pack agents
+- **Workflow**: The complete process it manages
+
+#### 2.2 Identify Specialist Agents
+
+For each additional agent:
 
 - **Role**: What specialist is needed?
 - **Expertise**: Domain-specific knowledge required
-- **Interactions**: How they work with existing BMAD agents
+- **Interactions**: How they work with orchestrator and BMAD agents
 - **Unique Value**: What can't existing agents handle?
+- **Required Tasks**: List ALL tasks this agent references
+- **Required Templates**: List ALL templates this agent uses
+- **Required Data**: List ALL data files this agent needs
 
-#### 2.2 Design Specialized Tasks
+#### 2.3 Design Specialized Tasks
 
 For each task:
 
@@ -50,7 +121,7 @@ For each task:
 - **Outputs**: What gets produced?
 - **Agent Usage**: Which agents will use this task?
 
-#### 2.3 Create Document Templates
+#### 2.4 Create Document Templates
 
 For each template:
 
@@ -60,7 +131,7 @@ For each template:
 - **Instructions**: How to complete each section
 - **Standards**: Any format requirements
 
-#### 2.4 Define Checklists
+#### 2.5 Define Checklists
 
 For each checklist:
 
@@ -71,18 +142,21 @@ For each checklist:
 
 ### Phase 3: Implementation
 
+**Only proceed after plan.md is approved**
+
 #### 3.1 Create Directory Structure
 
-**IMPORTANT**: User-created expansion packs should start with a period (.) to ensure they are gitignored and don't conflict with repo updates.
+```text
-
-```
 expansion-packs/
-└── .{pack-name}/
+└── {pack-name}/
+    ├── plan.md (ALREADY CREATED)
     ├── manifest.yml
     ├── README.md
     ├── agents/
+    │   ├── {pack-name}-orchestrator.yml (REQUIRED)
     │   └── {agent-id}.yml
     ├── personas/
+    │   ├── {pack-name}-orchestrator.md (REQUIRED)
     │   └── {agent-id}.md
     ├── tasks/
     │   └── {task-name}.md
@@ -91,6 +165,7 @@ expansion-packs/
     ├── checklists/
     │   └── {checklist-name}.md
     └── ide-agents/
+        ├── {pack-name}-orchestrator.ide.md (REQUIRED)
         └── {agent-id}.ide.md
 ```
 
@@ -99,58 +174,82 @@ expansion-packs/
 Create `manifest.yml`:
 
 ```yaml
-name: { Pack Name }
+name: {pack-name}
 version: 1.0.0
 description: >-
   {Detailed description of the expansion pack}
 author: {Your name or organization}
 bmad_version: "4.0.0"
 
-# Files to install (with . prefix for gitignore)
+# Files to create in the expansion pack
 files:
-  - source: agents/{agent-id}.yml
+  agents:
-    destination: agents/.{agent-id}.yml
+    - {pack-name}-orchestrator.yml
-  - source: personas/{agent-id}.md
+    - {agent-name}.yml
-    destination: bmad-core/personas/.{agent-id}.md
-  - source: tasks/{task-name}.md
-    destination: bmad-core/tasks/.{task-name}.md
-  - source: templates/{template-name}.md
-    destination: bmad-core/templates/.{template-name}.md
-  - source: checklists/{checklist-name}.md
-    destination: bmad-core/checklists/.{checklist-name}.md
-  - source: ide-agents/{agent-id}.ide.md
-    destination: bmad-core/ide-agents/.{agent-id}.ide.md
-  # ... more files
 
-# Optional: Update existing teams
+  personas:
-team_updates:
+    - {pack-name}-orchestrator.md
-  - team: team-technical.yml
+    - {agent-name}.md
-    add_agent: { new-agent-id }
+
+  ide-agents:
+    - {pack-name}-orchestrator.ide.md
+    - {agent-name}.ide.md
+
+  tasks:
+    - {task-name}.md
+
+  templates:
+    - {template-name}.md
+
+  checklists:
+    - {checklist-name}.md
+
+# Data files users must provide
+required_data:
+  - filename: {data-file}.{ext}
+    description: {What this file should contain}
+    location: bmad-core/data/
+
+# Dependencies on core BMAD components
+dependencies:
+  - {core-agent-name}
+  - {core-task-name}
 
 # Post-install message
-post_install_message: >-
+post_install_message: |
-  {Pack Name} installed successfully!
+  {Pack Name} expansion pack ready!
 
-  New agents available: {list agents}
+  Required data files:
-  New tasks available: {list tasks}
+  - {data-file}.{ext}: {description}
 
-  Run 'npm run build' to generate bundles.
+  To use: npm run agent {pack-name}-orchestrator
 ```
 
 ### Phase 4: Content Creation
 
-#### 4.1 Agent Creation Checklist
+**Work through plan.md checklist systematically**
 
-For each new agent:
+#### 4.1 Create Orchestrator First
+
+1. Create `personas/{pack-name}-orchestrator.md` with BMAD-style commands
+2. Create `agents/{pack-name}-orchestrator.yml` configuration
+3. Create `ide-agents/{pack-name}-orchestrator.ide.md`
+4. Verify ALL referenced tasks exist
+5. Verify ALL referenced templates exist
+6. Document data file requirements
+
+#### 4.2 Agent Creation Order
+
+For each additional agent:
 
 1. Create persona file with domain expertise
 2. Create agent configuration YAML
-3. Create IDE-optimized version (optional)
+3. Create IDE-optimized version
-4. List all task dependencies
+4. **STOP** - Verify all referenced tasks/templates exist
-5. Define template usage
+5. Create any missing tasks/templates immediately
-6. Add to relevant teams
+6. Mark agent as complete in plan.md
 
-#### 4.2 Task Creation Guidelines
+#### 4.3 Task Creation Guidelines
 
 Each task should:
 
@@ -160,7 +259,7 @@ Each task should:
 4. Reference domain standards
 5. Be reusable across agents
 
-#### 4.3 Template Best Practices
+#### 4.4 Template Best Practices
 
 Templates should:
 
@@ -170,37 +269,70 @@ Templates should:
 4. Mark required vs optional sections
 5. Include domain-specific terminology
 
-### Phase 5: Testing and Documentation
+### Phase 5: Verification and Documentation
 
-#### 5.1 Create README
+#### 5.1 Final Verification Checklist
+
+Before declaring complete:
+
+1. [ ] All items in plan.md marked complete
+2. [ ] Orchestrator agent created and tested
+3. [ ] All agent references validated
+4. [ ] All required data files documented
+5. [ ] manifest.yml lists all components
+6. [ ] No orphaned tasks or templates
+
+#### 5.2 Create README
 
 Include:
 
 - Overview of the pack's purpose
+- **Orchestrator usage instructions**
+- Required data files and formats
 - List of all components
-- Installation instructions
+- Integration with BMAD workflow
-- Usage examples
+- Example scenarios
-- Integration notes
 
-#### 5.2 Test Installation
+#### 5.3 Data File Documentation
 
-1. Run `node tools/install-expansion-pack.js .{pack-name}`
+For each required data file:
-2. Verify all files copied correctly (should have . prefix)
+
-3. Build agents to test configurations
+```markdown
-4. Run sample scenarios
+## Required Data Files
+
+### {filename}.{ext}
+
+- **Purpose**: {why this file is needed}
+- **Format**: {file format and structure}
+- **Location**: Place in `bmad-core/data/`
+- **Example**:
+```
+
+{sample content}
+
+```
+
+```
 
 ## Example: Healthcare Expansion Pack
 
-```
+```text
-.healthcare/
+healthcare/
+├── plan.md (Created first for approval)
 ├── manifest.yml
 ├── README.md
 ├── agents/
+│   ├── healthcare-orchestrator.yml (REQUIRED)
 │   ├── clinical-analyst.yml
 │   └── compliance-officer.yml
 ├── personas/
+│   ├── healthcare-orchestrator.md (REQUIRED)
 │   ├── clinical-analyst.md
 │   └── compliance-officer.md
+├── ide-agents/
+│   ├── healthcare-orchestrator.ide.md (REQUIRED)
+│   ├── clinical-analyst.ide.md
+│   └── compliance-officer.ide.md
 ├── tasks/
 │   ├── hipaa-assessment.md
 │   ├── clinical-protocol-review.md
@@ -212,6 +344,10 @@ Include:
 └── checklists/
     ├── hipaa-checklist.md
     └── clinical-data-quality.md
+
+Required user data files:
+- bmad-core/data/medical-terminology.md
+- bmad-core/data/hipaa-requirements.md
 ```
 
 ## Interactive Questions Flow
@@ -222,43 +358,74 @@ Include:
 2. "What are the main challenges or workflows in this domain?"
 3. "Do you have any example documents or outputs? (Please share)"
 4. "What specialized roles/experts exist in this domain?"
+5. "What reference data will users need to provide?"
+
+### Planning Phase
+
+6. "Here's the proposed plan. Please review and approve before we continue."
+
+### Orchestrator Design
+
+7. "What key commands should the {pack-name} orchestrator support?"
+8. "What's the typical workflow from start to finish?"
+9. "How should it integrate with core BMAD agents?"
 
 ### Agent Planning
 
-5. "For agent '{name}', what is their specific expertise?"
+10. "For agent '{name}', what is their specific expertise?"
-6. "What unique tasks would this agent perform?"
+11. "What tasks will this agent reference? (I'll create them)"
-7. "How would they interact with existing BMAD agents?"
+12. "What templates will this agent use? (I'll create them)"
+13. "What data files will this agent need? (You'll provide these)"
 
 ### Task Design
 
-8. "Describe the '{task}' process step-by-step"
+14. "Describe the '{task}' process step-by-step"
-9. "What information is needed to complete this task?"
+15. "What information is needed to complete this task?"
-10. "What should the output look like?"
+16. "What should the output look like?"
 
 ### Template Creation
 
-11. "What sections should the '{template}' document have?"
+17. "What sections should the '{template}' document have?"
-12. "Are there any required formats or standards?"
+18. "Are there any required formats or standards?"
-13. "Can you provide an example of a completed document?"
+19. "Can you provide an example of a completed document?"
 
-### Integration
+### Data Requirements
 
-14. "Which existing teams should include these new agents?"
+20. "For {data-file}, what information should it contain?"
-15. "Are there any dependencies between components?"
+21. "What format should this data be in?"
+22. "Can you provide a sample?"
 
 ## Important Considerations
 
+- **Plan First**: ALWAYS create and get approval for plan.md before implementing
+- **Orchestrator Required**: Every pack MUST have a custom BMAD orchestrator
+- **Verify References**: ALL referenced tasks/templates MUST exist
+- **Document Data Needs**: Clearly specify what users must provide
 - **Domain Expertise**: Ensure accuracy in specialized fields
 - **Compliance**: Include necessary regulatory requirements
-- **Compatibility**: Test with existing BMAD agents
-- **Documentation**: Provide clear usage instructions
-- **Examples**: Include real-world scenarios
-- **Maintenance**: Plan for updates as domain evolves
 
 ## Tips for Success
 
-1. **Start Small**: Begin with 1-2 agents and expand
+1. **Plan Thoroughly**: The plan.md prevents missing components
-2. **Get Examples**: Real documents make better templates
+2. **Build Orchestrator First**: It defines the overall workflow
-3. **Test Thoroughly**: Run complete workflows
+3. **Verify As You Go**: Check off items in plan.md
-4. **Document Well**: Others will need to understand the domain
+4. **Test References**: Ensure no broken dependencies
-5. **Iterate**: Refine based on usage feedback
+5. **Document Data**: Users need clear data file instructions
+
+## Common Mistakes to Avoid
+
+1. **Missing Orchestrator**: Every pack needs its own BMAD-style orchestrator
+2. **Orphaned References**: Agent references task that doesn't exist
+3. **Unclear Data Needs**: Not specifying required user data files
+4. **Skipping Plan**: Going straight to implementation
+5. **Generic Orchestrator**: Not making it domain-specific
+
+## Completion Checklist
+
+- [ ] plan.md created and approved
+- [ ] All plan.md items checked off
+- [ ] Orchestrator agent created
+- [ ] All agent references verified
+- [ ] Data requirements documented or added
+- [ ] README includes all setup instructions
+- [ ] manifest.yml reflects actual files

bmad-core/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.

package.json

@@ -3,18 +3,8 @@
   "version": "4.0.0",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "main": "tools/cli.js",
-  "bin": {
+  "bin": {},
-    "bmad-build": "tools/cli.js"
+  "scripts": {},
-  },
-  "scripts": {
-    "build": "node tools/cli.js build",
-    "build:sample-update": "node tools/cli.js build --sample-update",
-    "list:agents": "node tools/cli.js list:agents",
-    "analyze:deps": "node tools/cli.js analyze:deps",
-    "validate": "node tools/cli.js validate",
-    "install:expansion": "node tools/install-expansion-pack.js",
-    "test": "echo \"Tests not yet implemented\" && exit 0"
-  },
   "dependencies": {
     "commander": "^9.4.1",
     "js-yaml": "^4.1.0"