bmad-method 4.27.6 → 5.0.0

package/.bmad-core/tasks/core-dump.md

@@ -0,0 +1,74 @@
+# Core Dump Task
+
+## Purpose
+
+To create a concise memory recording file (`.ai/core-dump-n.md`) that captures the essential context of the current agent session, enabling seamless continuation of work in future agent sessions. This task ensures persistent context across agent conversations while maintaining minimal token usage for efficient context loading.
+
+## Inputs for this Task
+
+- Current session conversation history and accomplishments
+- Files created, modified, or deleted during the session
+- Key decisions made and procedures followed
+- Current project state and next logical steps
+- User requests and agent responses that shaped the session
+
+## Task Execution Instructions
+
+### 0. Check Existing Core Dump
+
+Before proceeding, check if `.ai/core-dump.md` already exists:
+
+- If file exists, ask user: "Core dump file exists. Should I: 1. Overwrite, 2. Update, 3. Append or 4. Create new?"
+- **Overwrite**: Replace entire file with new content
+- **Update**: Merge new session info with existing content, updating relevant sections
+- **Append**: Add new session as a separate entry while preserving existing content
+- **Create New**: Create a new file, appending the next possible -# to the file, such as core-dump-3.md if 1 and 2 already exist.
+- If file doesn't exist, proceed with creation of `core-dump-1.md`
+
+### 1. Analyze Session Context
+
+- Review the entire conversation to identify key accomplishments
+- Note any specific tasks, procedures, or workflows that were executed
+- Identify important decisions made or problems solved
+- Capture the user's working style and preferences observed during the session
+
+### 2. Document What Was Accomplished
+
+- **Primary Actions**: List the main tasks completed concisely
+- **Story Progress**: For story work, use format "Tasks Complete: 1-6, 8. Next Task Pending: 7, 9"
+- **Problem Solving**: Document any challenges encountered and how they were resolved
+- **User Communications**: Summarize key user requests, preferences, and discussion points
+
+### 3. Record File System Changes (Concise Format)
+
+- **Files Created**: `filename.ext` (brief purpose/size)
+- **Files Modified**: `filename.ext` (what changed)
+- **Files Deleted**: `filename.ext` (why removed)
+- Focus on essential details, avoid verbose descriptions
+
+### 4. Capture Current Project State
+
+- **Project Progress**: Where the project stands after this session
+- **Current Issues**: Any blockers or problems that need resolution
+- **Next Logical Steps**: What would be the natural next actions to take
+
+### 5. Create/Update Core Dump File
+
+Based on user's choice from step 0, handle the file accordingly:
+
+### 6. Optimize for Minimal Context
+
+- Keep descriptions concise but informative
+- Use abbreviated formats where possible (file sizes, task numbers)
+- Focus on actionable information rather than detailed explanations
+- Avoid redundant information that can be found in project documentation
+- Prioritize information that would be lost without this recording
+- Ensure the file can be quickly scanned and understood
+
+### 7. Validate Completeness
+
+- Verify all significant session activities are captured
+- Ensure a future agent could understand the current state
+- Check that file changes are accurately recorded
+- Confirm next steps are clear and actionable
+- Verify user communication style and preferences are noted

package/{expansion-packs/bmad-creator-tools → .bmad-core}/tasks/create-agent.md

@@ -1,10 +1,10 @@
 # Create Agent Task
 
-This task guides you through creating a new BMad agent following the standard template.
+This task guides you through creating a new BMAD agent following the standard template.
 
 ## Prerequisites
 
-- Agent template: `../templates/agent-tmpl.md`
+- Agent template: `.bmad-core/templates/agent-tmpl.md`
 - Target directory: `.bmad-core/agents/`
 
 ## Steps
@@ -55,7 +55,7 @@ Determine:
 
 **Track Created Items:**
 
-```text
+```
 Created during agent setup:
 - Tasks:
   - [ ] task-name-1.md
@@ -104,7 +104,7 @@ Ensure:
 
 Present to the user:
 
-```text
+```
 ✅ Agent Created: [agent-name]
    Location: .bmad-core/agents/[agent-id].md
 
@@ -141,11 +141,13 @@ 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
@@ -183,12 +185,12 @@ When a required task or template doesn't exist:
 ```yaml
 dependencies:
   tasks:
-    - create-doc
-    - analyze-requirements
-    - generate-report
+    - create-doc # Required if agent creates any documents
+    - analyze-requirements # Custom task for this agent
+    - generate-report # Another custom task
   templates:
-    - requirements-doc
-    - analysis-report
+    - requirements-doc # Template for requirements documents
+    - analysis-report # Template for analysis reports
 ```
 
 ## Notes

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

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

@@ -0,0 +1,425 @@
+# Create Expansion Pack Task
+
+This task helps you create a comprehensive BMAD expansion pack that can include new agents, tasks, templates, and checklists for a specific domain.
+
+## Understanding Expansion Packs
+
+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
+
+### Phase 1: Discovery and Planning
+
+#### 1.1 Define the Domain
+
+Ask the user:
+
+- **Pack Name**: Short identifier (e.g., `healthcare`, `fintech`, `gamedev`)
+- **Display Name**: Full name (e.g., "Healthcare Compliance Pack")
+- **Description**: What domain or industry does this serve?
+- **Key Problems**: What specific challenges will this pack solve?
+- **Target Users**: Who will benefit from this expansion?
+
+#### 1.2 Gather Examples
+
+Request from the user:
+
+- **Sample Documents**: Any existing documents in this domain
+- **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
+
+IMPORTANT: 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
+```
+
+Important: Wait for user approval before proceeding to Phase 2
+
+### Phase 2: Component Design
+
+#### 2.1 Create Orchestrator 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 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.3 Design Specialized Tasks
+
+For each task:
+
+- **Purpose**: What specific action does it enable?
+- **Inputs**: What information is needed?
+- **Process**: Step-by-step instructions
+- **Outputs**: What gets produced?
+- **Agent Usage**: Which agents will use this task?
+
+#### 2.4 Create Document Templates
+
+For each template:
+
+- **Document Type**: What kind of document?
+- **Structure**: Sections and organization
+- **Placeholders**: Variable content areas
+- **Instructions**: How to complete each section
+- **Standards**: Any format requirements
+
+#### 2.5 Define Checklists
+
+For each checklist:
+
+- **Purpose**: What quality aspect does it verify?
+- **Scope**: When should it be used?
+- **Items**: Specific things to check
+- **Criteria**: Pass/fail conditions
+
+### Phase 3: Implementation
+
+IMPORTANT: Only proceed after plan.md is approved
+
+#### 3.1 Create Directory Structure
+
+```text
+expansion-packs/
+└── {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
+    ├── templates/
+    │   └── {template-name}.md
+    ├── checklists/
+    │   └── {checklist-name}.md
+    └── ide-agents/
+        ├── {pack-name}-orchestrator.ide.md (REQUIRED)
+        └── {agent-id}.ide.md
+```
+
+#### 3.2 Create Manifest
+
+Create `manifest.yml`:
+
+```yaml
+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 create in the expansion pack
+files:
+  agents:
+    - {pack-name}-orchestrator.yml
+    - {agent-name}.yml
+
+  personas:
+    - {pack-name}-orchestrator.md
+    - {agent-name}.md
+
+  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: |
+  {Pack Name} expansion pack ready!
+
+  Required data files:
+  - {data-file}.{ext}: {description}
+
+  To use: npm run agent {pack-name}-orchestrator
+```
+
+### Phase 4: Content Creation
+
+IMPORTANT: Work through plan.md checklist systematically!
+
+#### 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
+4. **STOP** - Verify all referenced tasks/templates exist
+5. Create any missing tasks/templates immediately
+6. Mark agent as complete in plan.md
+
+#### 4.3 Task Creation Guidelines
+
+Each task should:
+
+1. Have a clear, single purpose
+2. Include step-by-step instructions
+3. Provide examples when helpful
+4. Reference domain standards
+5. Be reusable across agents
+
+#### 4.4 Template Best Practices
+
+Templates should:
+
+1. Include clear section headers
+2. Provide inline instructions
+3. Show example content
+4. Mark required vs optional sections
+5. Include domain-specific terminology
+
+### Phase 5: Verification and Documentation
+
+#### 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
+- Integration with BMAD workflow
+- Example scenarios
+
+#### 5.3 Data File Documentation
+
+For each required data file:
+
+```markdown
+## Required Data Files
+
+### {filename}.{ext}
+
+- **Purpose**: {why this file is needed}
+- **Format**: {file format and structure}
+- **Location**: Place in `bmad-core/data/`
+- **Example**:
+```
+
+## Example: Healthcare Expansion Pack
+
+```text
+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
+│   └── patient-data-analysis.md
+├── templates/
+│   ├── clinical-trial-protocol.md
+│   ├── hipaa-compliance-report.md
+│   └── patient-outcome-report.md
+└── 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
+
+### Initial Discovery
+
+1. "What domain or industry will this expansion pack serve?"
+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
+
+1. "Here's the proposed plan. Please review and approve before we continue."
+
+### Orchestrator Design
+
+1. "What key commands should the {pack-name} orchestrator support?"
+2. "What's the typical workflow from start to finish?"
+3. "How should it integrate with core BMAD agents?"
+
+### Agent Planning
+
+1. "For agent '{name}', what is their specific expertise?"
+2. "What tasks will this agent reference? (I'll create them)"
+3. "What templates will this agent use? (I'll create them)"
+4. "What data files will this agent need? (You'll provide these)"
+
+### Task Design
+
+1. "Describe the '{task}' process step-by-step"
+2. "What information is needed to complete this task?"
+3. "What should the output look like?"
+
+### Template Creation
+
+1. "What sections should the '{template}' document have?"
+2. "Are there any required formats or standards?"
+3. "Can you provide an example of a completed document?"
+
+### Data Requirements
+
+1. "For {data-file}, what information should it contain?"
+2. "What format should this data be in?"
+3. "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
+
+## Tips for Success
+
+1. **Plan Thoroughly**: The plan.md prevents missing components
+2. **Build Orchestrator First**: It defines the overall workflow
+3. **Verify As You Go**: Check off items in plan.md
+4. **Test References**: Ensure no broken dependencies
+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