ros/BMAD-METHOD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: update expansion versions

Browse Source
This commit is contained in:
Brian Madison
2025-06-30 00:14:04 -05:00
parent 95ab8bbd9c
commit 6905fe72f6
17 changed files with 602 additions and 641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
bmad-core/core-config.yml
View File

@@ -1,4 +1,4 @@
version: 4.20.1
version: 4.21.1
markdownExploder: true
prd:
prdFile: docs/prd.md

95
dist/agents/analyst.txt vendored
View File

@@ -652,76 +652,73 @@ Present these numbered options to the user:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#advanced-elicitation ====================

95
dist/agents/architect.txt vendored
View File

@@ -107,76 +107,73 @@ dependencies:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#create-deep-research-prompt ====================

95
dist/agents/bmad-master.txt vendored
View File

@@ -1173,76 +1173,73 @@ Present these numbered options to the user:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#document-project ====================

95
dist/agents/bmad-orchestrator.txt vendored
View File

@@ -263,76 +263,73 @@ Choose an action (0-9 - 9 to bypass - HELP for explanation of these options):
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#kb-mode-interaction ====================

95
dist/agents/pm.txt vendored
View File

@@ -104,76 +104,73 @@ dependencies:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#correct-course ====================

95
dist/agents/ux-expert.txt vendored
View File

@@ -464,76 +464,73 @@ Present these numbered options to the user:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#execute-checklist ====================

95
dist/expansion-packs/bmad-2d-phaser-game-dev/agents/game-designer.txt vendored
View File

@@ -104,76 +104,73 @@ dependencies:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#execute-checklist ====================

95
dist/expansion-packs/bmad-2d-phaser-game-dev/teams/phaser-2d-nodejs-game-team.txt vendored
View File

@@ -977,76 +977,73 @@ Present these numbered options to the user:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#advanced-elicitation ====================

95
dist/expansion-packs/bmad-infrastructure-devops/agents/infra-devops-platform.txt vendored
View File

@@ -105,76 +105,73 @@ dependencies:
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#review-infrastructure ====================

95
dist/teams/team-all.txt vendored
View File

@@ -755,76 +755,73 @@ Choose an action (0-9 - 9 to bypass - HELP for explanation of these options):
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#kb-mode-interaction ====================

95
dist/teams/team-fullstack.txt vendored
View File

@@ -599,76 +599,73 @@ Choose an action (0-9 - 9 to bypass - HELP for explanation of these options):
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#kb-mode-interaction ====================

95
dist/teams/team-ide-minimal.txt vendored
View File

@@ -499,76 +499,73 @@ Choose an action (0-9 - 9 to bypass - HELP for explanation of these options):
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#kb-mode-interaction ====================

95
dist/teams/team-no-ui.txt vendored
View File

@@ -531,76 +531,73 @@ Choose an action (0-9 - 9 to bypass - HELP for explanation of these options):
## Purpose
- Generate documents from any specified template following embedded instructions from the perspective of the selected agent persona
Generate documents from templates by EXECUTING (not just reading) embedded instructions from the perspective of the selected agent persona.
## Instructions
## CRITICAL RULES
### 1. Identify Template and Context
1. **Templates are PROGRAMS** - Execute every [[LLM:]] instruction exactly as written
2. **NEVER show markup** - Hide all [[LLM:]], {{placeholders}}, @{examples}, and template syntax
3. **STOP and EXECUTE** - When you see "apply tasks#" or "execute tasks#", STOP and run that task immediately
4. **WAIT for user input** - At review points and after elicitation tasks
- Determine which template to use (user-provided or list available for selection to user)
## Execution Flow
- 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:
### 1. Identify Template
@{example}
dependencies:
templates: - prd-tmpl - architecture-tmpl
@{/example}
- Load from `templates#*` or `{root}/templates directory`
- Agent-specific templates are listed in agent's dependencies
- If agent has `templates: [prd-tmpl, architecture-tmpl]`, offer to create "PRD" and "Architecture" documents
You would offer to create "PRD" and "Architecture" documents when the user asks what you can help with.
### 2. Ask Interaction Mode
- 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)
> 1. **Incremental** - Section by section with reviews
> 2. **YOLO Mode** - Complete draft then review (user can type `/yolo` anytime to switch)
### 3. Execute Template
- Load specified template from `templates#*` or the `{root}/templates directory`
- Follow ALL embedded LLM instructions within the template
- Process template markup according to `utils#template-format` or `{root}/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
- Replace {{placeholders}} with real content
- Execute [[LLM:]] instructions as you encounter them
- Process <<REPEAT>> loops and ^^CONDITIONS^^
- Use @{examples} for guidance but never output them
### 5. Content Generation
### 4. Key Execution Patterns
- **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
**When you see:** `[[LLM: Draft X and immediately execute tasks#advanced-elicitation]]`
### 6. Validation
- Draft the content
- Present it to user
- IMMEDIATELY execute the task
- Wait for completion before continuing
If template specifies a checklist:
**When you see:** `[[LLM: After section completion, apply tasks#Y]]`
- Run the appropriate checklist against completed document
- Document completion status for each item
- Address any deficiencies found
- Present validation summary to user
- Finish the section
- STOP and execute the task
- Wait for user input
### 7. Final Presentation
### 5. Validation & Final Presentation
- Run any specified checklists
- 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
- No truncation or summarization
- Begin directly with content (no preamble)
- Include any handoff prompts from template
## Important Notes
## Common Mistakes to Avoid
- Template markup is for AI processing only - never expose to users
❌ Skipping elicitation tasks
❌ Showing template markup to users
❌ Continuing past STOP signals
❌ Combining multiple review points
✅ Execute ALL instructions in sequence
✅ Present only clean, formatted content
✅ Stop at every elicitation point
✅ Wait for user confirmation when instructed
## Remember
Templates contain precise instructions for a reason. Follow them exactly to ensure document quality and completeness.
==================== END: tasks#create-doc ====================
==================== START: tasks#kb-mode-interaction ====================

2
expansion-packs/bmad-2d-phaser-game-dev/config.yml
View File

@@ -1,5 +1,5 @@
name: bmad-2d-phaser-game-dev
version: 1.1.2
version: 1.2.0
short-title: 2D game development with Phaser 3 & TypeScript
description: >-
2D Game Development expansion pack for BMAD Method - Phaser 3 & TypeScript

2
expansion-packs/bmad-creator-tools/config.yml
View File

@@ -1,5 +1,5 @@
name: bmad-creator-tools
version: 1.0.2
version: 1.1.0
short-title: Tools for creating BMAD framework components
description: Tools for creating and extending BMAD framework components.
author: Brian (BMad)

2
expansion-packs/bmad-infrastructure-devops/config.yml
View File

@@ -1,5 +1,5 @@
name: bmad-infrastructure-devops
version: 1.0.2
version: 1.1.0
short-title: Infrastructure and DevOps capabilities
description: >-
This expansion pack extends BMAD Method with comprehensive infrastructure and