Merge f2a942b2db into 7d3d51ff4f

- Remove duplicate "for" in README example command
- Fix "this is" to "thing is" in README
- Remove extra "at" in "star project icon at near" in README
- Fix "MEthod" to "Method" in customize-bmad.md

CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-## [6.0.0-Beta.0]
+## [6.0.0-Beta.2]
+
+- Fix installer so commands match what is installed, centralize most ide into a central file instead of separate files for each ide.
+- Specific IDEs may still need udpates, but all is config driven now and should be easier to maintain
+- Kiro still needs updates, but its been in this state since contributed, will investigate soon
+- Any version older than Beta.0 will recommend removal and reinstall to project. From later alphas though its sufficient to quick update if still desired, but best is just start fresh with Beta.
+
+## [6.0.0-Beta.1]
 
 **Release: January 2026 - Alpha to Beta Transition**
 

README.md

@@ -32,10 +32,10 @@ Follow the installer prompts, then open your AI IDE (Claude Code, Cursor, Windsu
 
 > **Not sure what to do?** Run `/bmad-help` — it tells you exactly what's next and what's optional. You can also ask it questions like:
 
- - `/bmad-help How should I build a web app for for my TShirt Business that can scale to millions?`
+ - `/bmad-help How should I build a web app for my TShirt Business that can scale to millions?`
  - `/bmad-help I just finished the architecture, I am not sure what to do next`
 
-And the amazing this is BMad Help evolves depending on what modules you install also!
+And the amazing thing is BMad Help evolves depending on what modules you install also!
  - `/bmad-help Im interested in really exploring creative ways to demo BMad at work, what do you recommend to help plan a great slide deck and compelling narrative?`, and if you have the Creative Intelligence Suite installed, it will offer you different or complimentary advice than if you just have BMad Method Module installed!
 
 The workflows below show the fastest path to working code. You can also load agents directly for a more structured process, extensive planning, or to learn about agile development practices — the agents guide you with menus, explanations, and elicitation at each step.
@@ -59,7 +59,7 @@ Products, platforms, complex features — structured planning then build:
 5. `/sprint-planning` — initialize sprint tracking
 6. **Repeat per story:** `/create-story` → `/dev-story` → `/code-review`
 
-Every step tells you what's next. Optional phases (brainstorming, research, UX design) are available when you need them — ask `/bmad-help` anytime. For a detailed walkthrough, see the [Getting Started Tutorial](http://docs.bmad-method.org/tutorials/getting-started/getting-started-bmadv6/).
+Every step tells you what's next. Optional phases (brainstorming, research, UX design) are available when you need them — ask `/bmad-help` anytime. For a detailed walkthrough, see the [Getting Started Tutorial](http://docs.bmad-method.org/tutorials/getting-started/).
 
 ## Modules
 
@@ -78,8 +78,8 @@ BMad Method extends with official modules for specialized domains. Modules are a
 
 **[Full Documentation](http://docs.bmad-method.org)** — Tutorials, how-to guides, concepts, and reference
 
-- [Getting Started Tutorial](http://docs.bmad-method.org/tutorials/getting-started/getting-started-bmadv6/)
-- [Upgrading from Previous Versions](http://docs.bmad-method.org/how-to/installation/upgrade-to-v6/)
+- [Getting Started Tutorial](http://docs.bmad-method.org/tutorials/getting-started/)
+- [Upgrading from Previous Versions](http://docs.bmad-method.org/how-to/upgrade-to-v6/)
 
 ### For v4 Users
 
@@ -96,7 +96,7 @@ BMad Method extends with official modules for specialized domains. Modules are a
 
 BMad is free for everyone — and always will be. If you'd like to support development:
 
-- ⭐ Please click the star project icon at near the top right of this page
+- ⭐ Please click the star project icon near the top right of this page
 - ☕ [Buy Me a Coffee](https://buymeacoffee.com/bmad) — Fuel the development
 - 🏢 Corporate sponsorship — DM on Discord
 - 🎤 Speaking & Media — Available for conferences, podcasts, interviews (BM on Discord)

docs/how-to-build-web-app-bmad-method.md

@@ -0,0 +1,371 @@
+---
+title: "Build a Complete Web App Using BMAD Method Workflows"
+---
+
+Use the BMAD Method workflows to build a complete web application from initial idea to deployed code with comprehensive planning and testing. This guide follows the development of a simple Habit Tracker app to illustrate the concepts, but these same workflows apply to any web application project.
+
+## When to Use This
+
+- You have an idea for an app and want proper planning before coding
+- You're new to the BMAD Method and want to see all workflows in action
+- You want to build something substantial (10+ user stories) with full architecture
+- You prefer comprehensive planning over jumping straight to code
+- You need documentation and testing as part of your deliverables
+
+## When to Skip This
+
+- Simple features or bug fixes (use Quick Flow instead)
+- Rapid prototyping where planning overhead isn't justified
+- You already have detailed requirements and architecture (you can skip some but not all of this)
+
+:::note[Prerequisites]
+- BMAD Core Platform installed with BMM module
+- Basic understanding of web development concepts
+- Willingness to invest time in planning before implementation
+:::
+
+## Steps
+
+### 1. Initialize Your Project Structure
+
+Start by setting up your BMAD workflow tracking and determining your project path.
+
+**Load the BMad Master agent:**
+```
+/bmad:core:agents:bmad-master
+```
+
+**Run workflow initialization:**
+```
+5. [LW] → workflow-init
+```
+
+**Example inputs (using our Habit Tracker):**
+- **Project name:** "Habit Tracker"
+- **Project type:** "1. New project (greenfield)" *(or brownfield for existing codebases)*
+- **Planning approach:** "1. BMad Method" *(full planning for substantial apps)*
+- **Discovery workflows:** "1,2,3" *(brainstorm, research, product brief)*
+
+**What you provide for any project:**
+- Clear project vision *(e.g., "solve my productivity problem", "showcase my work", "help local businesses")*
+- Technology constraints *(e.g., "React/Node", "vanilla JS", "WordPress theme", though the workflow will guide you to a tech stack if you'd like)*
+- Success criteria *(e.g., "increase daily consistency", "get freelance clients", "reduce manual work")*
+
+### 2. Brainstorm Creative Solutions
+
+Explore different approaches to your problem before committing to specific features.
+
+**Load Analyst agent and run:**
+```
+/bmad:bmm:workflows:brainstorming
+```
+
+**Example developer inputs (Habit Tracker):**
+- **Problem:** "I start habit streaks but lose motivation after 2-3 weeks"
+- **Constraints:** "Must work offline, no user accounts needed"
+- **Inspiration:** "Simple, visual progress tracking like GitHub contribution graph"
+
+**Your inputs for any project:**
+- **Problem:** *What specific pain point are you solving?*
+- **Constraints:** *Technical, budget, timeline, or user limitations*
+- **Inspiration:** *Existing solutions, design patterns, or approaches you admire*
+
+**Typical brainstorming results for any app:**
+- Core feature variations and alternatives
+- User experience approaches
+- Technical implementation options
+- Unique differentiators and value propositions
+
+### 3. Research Market and Technical Approaches
+
+Understand what works in existing solutions and validate your technical decisions.
+
+**Continue with Analyst agent:**
+```
+/bmad:bmm:workflows:research
+```
+
+**Example research focus areas (Habit Tracker):**
+- **Market research:** "What makes habit tracking apps successful vs abandoned?"
+- **Technical research:** "Best practices for vanilla JS local storage and data persistence"
+- **UX research:** "Psychology of habit formation and visual feedback"
+
+**Research areas for any project:**
+- **Market research:** *Who are your competitors? What do users actually need?*
+- **Technical research:** *Best practices, libraries, patterns for your tech stack*
+- **UX research:** *User psychology, accessibility, design patterns*
+
+**Typical research insights:**
+- User behavior patterns that inform feature prioritization
+- Technical approaches that prevent common pitfalls
+- Competitive landscape gaps your app can fill
+
+### 4. Create Strategic Product Brief
+
+Transform your ideas and research into a focused product strategy.
+
+**Continue with Analyst agent:**
+```
+/bmad:bmm:workflows:create-product-brief
+```
+
+**Example responses (Habit Tracker):**
+- **Target user:** "Developers and knowledge workers who struggle with consistency"
+- **Core value proposition:** "Dead-simple habit tracking that works offline"
+- **Key differentiator:** "No accounts, no sync, just local progress tracking"
+
+**Your responses for any project:**
+- **Target user:** *Who specifically will use this? What are their pain points?*
+- **Core value proposition:** *What's the main benefit you're delivering?*
+- **Key differentiator:** *How is your approach unique or better?*
+
+**Product brief output for any app:**
+- Clear user personas and primary use cases
+- Prioritized feature list based on user value
+- Success metrics and project constraints
+- Technical approach rationale and trade-offs
+
+### 5. Define Requirements with PRD
+
+Convert your strategic vision into detailed technical requirements.
+
+**Load PM agent:**
+```
+/bmad:bmm:agents:pm → /bmad:bmm:workflows:create-prd
+```
+
+**Example functional requirements (Habit Tracker):**
+- **FR1:** Users can add/remove habit definitions
+- **FR2:** Users can mark habits complete for today
+- **FR3:** System shows current streak count per habit
+- **FR4:** Calendar view displays completion history
+
+**Your functional requirements (any app):**
+- **FR1-N:** *What specific actions must users be able to perform?*
+- **FR1-N:** *What data must the system track and display?*
+- **FR1-N:** *What business logic must the system implement?*
+
+**Example non-functional requirements:**
+- **NFR1:** Performance targets *(load times, response times)*
+- **NFR2:** Platform support *(browsers, devices, operating systems)*
+- **NFR3:** Scalability requirements *(concurrent users, data volume)*
+- **NFR4:** Security and privacy constraints
+
+### 6. Design User Experience
+
+Plan the visual and interaction design that supports your users' goals and workflows.
+
+**Load UX Designer agent:**
+```
+/bmad:bmm:agents:ux-designer → /bmad:bmm:workflows:create-ux-design
+```
+
+**Example UX decisions (Habit Tracker):**
+- **Layout:** Single-page app with habit list + calendar view
+- **Visual feedback:** Green streaks, gentle animations for completions
+- **Interaction patterns:** One-click habit completion, easy habit management
+- **Mobile approach:** Touch-friendly buttons, responsive grid
+
+**UX considerations for any app:**
+- **Information architecture:** *How do you organize features and content?*
+- **Visual hierarchy:** *What gets user attention first, second, third?*
+- **Interaction patterns:** *How do users accomplish their primary tasks?*
+- **Responsive design:** *How does the experience adapt across devices?*
+
+### 7. Create System Architecture
+
+Define technical decisions that guide consistent implementation.
+
+**Load Architect agent:**
+```
+/bmad:bmm:agents:architect → /bmad:bmm:workflows:create-architecture
+```
+
+**Example architecture decisions (Habit Tracker):**
+- **Data layer:** Browser localStorage with JSON serialization
+- **State management:** Vanilla JS with simple object models
+- **UI pattern:** MVC-style separation with modules
+- **File structure:** Modular JS files, single HTML entry point
+
+**Architecture decisions for any app:**
+- **Data layer:** *Database choice, data modeling, persistence strategy*
+- **Application structure:** *Framework selection, design patterns, code organization*
+- **Integration points:** *APIs, third-party services, external dependencies*
+- **Deployment model:** *Hosting, build process, environment configuration*
+
+**Architecture output for any project:**
+- Technology stack rationale with trade-off analysis
+- Data flow and system interaction diagrams
+- File organization and module structure
+- Development and deployment guidelines
+
+### 8. Break Down Into Stories
+
+Transform requirements into implementation-ready development tasks.
+
+**Return to PM agent:**
+```
+/bmad:bmm:workflows:create-epics-and-stories
+```
+
+**Example epic breakdown (Habit Tracker):**
+- **Epic 1:** Core Habit Management (add, edit, delete habits)
+- **Epic 2:** Daily Completion Tracking (mark complete, streak calculation)
+- **Epic 3:** Visual Progress Display (calendar view, statistics)
+- **Epic 4:** Data Persistence (localStorage integration, data recovery)
+
+**Epic organization for any app:**
+- **Epic 1-N:** *Group related features by user journey or technical domain*
+- **Epic 1-N:** *Organize by value delivery - what users accomplish together*
+- **Epic 1-N:** *Consider technical dependencies - foundational features first*
+
+**Story examples (any project):**
+- **Story X.Y:** As a [user type], I can [action] so that [benefit]
+- **Story X.Y:** As a [user type], I can [action] so that [benefit]
+- **Story X.Y:** As a [user type], I can [action] so that [benefit]
+
+### 9. Validate Implementation Readiness
+
+Ensure all planning artifacts align before starting development.
+
+**Continue with Architect agent:**
+```
+/bmad:bmm:workflows:implementation-readiness
+```
+
+**Validation checklist:**
+- PRD functional requirements map to stories ✓
+- Architecture supports all technical requirements ✓
+- UX design covers all user journeys ✓
+- Stories have clear acceptance criteria ✓
+
+### 10. Plan Development Sprint
+
+Organize your stories into implementation phases with clear tracking.
+
+**Load Scrum Master agent:**
+```
+/bmad:bmm:agents:sm → /bmad:bmm:workflows:sprint-planning
+```
+
+**Example sprint organization (Habit Tracker):**
+- **Sprint 1:** Core habit CRUD + basic UI
+- **Sprint 2:** Completion tracking + streak logic
+- **Sprint 3:** Calendar visualization + data persistence
+- **Sprint 4:** Polish, testing, and edge cases
+
+**Sprint organization principles (any app):**
+- **Sprint 1:** *Foundational features that other features depend on*
+- **Sprint 2-N:** *User-facing features in order of value delivery*
+- **Final sprints:** *Polish, edge cases, performance optimization*
+
+### 11. Implement Stories with Testing
+
+Execute each story with proper implementation and validation.
+
+**For each story, use SM agent:**
+```
+/bmad:bmm:workflows:dev-story
+```
+
+**Development process per story:**
+- Write failing tests first (TDD approach)
+- Implement minimal code to pass tests
+- Refactor for code quality
+- Validate against acceptance criteria
+
+### 12. Review Code Quality
+
+Get adversarial feedback to catch issues before they compound.
+
+**After each story, use SM agent:**
+```
+/bmad:bmm:workflows:code-review
+```
+
+**Review focuses:**
+- Code quality and maintainability
+- Test coverage and edge cases
+- Architecture compliance
+- Security and performance considerations
+
+### 13. Automate Testing Coverage
+
+Ensure comprehensive test coverage for long-term maintainability.
+
+**Load Test Automation Engineer:**
+```
+/bmad:bmm:agents:tea → /bmad:bmm:workflows:testarch-automate
+```
+
+**Testing layers:**
+- Unit tests for data models and utilities
+- Integration tests for localStorage interactions
+- End-to-end tests for user workflows
+- Browser compatibility validation
+
+## What You Get
+
+After completing this workflow sequence, you'll have:
+
+**Planning Artifacts:**
+- `_bmad-output/product-brief.md` - Strategic product vision
+- `_bmad-output/PRD.md` - Detailed requirements document
+- `_bmad-output/ux-design.md` - Visual and interaction design
+- `_bmad-output/architecture.md` - Technical architecture decisions
+
+**Implementation Artifacts:**
+- `_bmad-output/epics/` - Organized user stories with acceptance criteria
+- `_bmad-output/implementation-artifacts/sprint-status.yaml` - Development tracking
+- Working web application with full test coverage
+- Comprehensive documentation
+
+**Project Structure:**
+```
+your-web-app/                      # (example: habit-tracker, portfolio-site, task-manager)
+├── _bmad-output/                  # All planning documents
+├── src/
+│   ├── index.html                 # Main application entry
+│   ├── js/
+│   │   ├── app.js                 # Main application logic
+│   │   ├── [feature]-manager.js   # Core business logic modules
+│   │   ├── [component].js         # UI components
+│   │   └── [utility].js           # Helper utilities
+│   ├── css/
+│   │   └── styles.css             # Application styles
+│   └── tests/
+│       ├── unit/                  # Unit test files
+│       └── integration/           # Integration tests
+└── README.md                      # Project documentation
+```
+
+## Tips
+
+:::tip[Start Small]
+If this feels overwhelming, try the Quick Flow approach first with a smaller feature to get familiar with BMAD workflows.
+:::
+
+:::tip[Document Decisions]
+Each workflow creates artifacts that inform subsequent workflows. Don't skip documentation - it prevents rework later.
+:::
+
+:::tip[Iterate on Planning]
+Use the `correct-course` workflow if you discover new requirements during implementation.
+:::
+
+## Next Steps
+
+- **Deploy your app:** Use the `testarch-ci` workflow to set up deployment automation
+- **Add features:** Create new epics using the `create-epics-and-stories` workflow
+- **Maintain quality:** Regular code reviews and test automation expansion
+- **Scale complexity:** Graduate to Enterprise Method for larger applications
+
+## Getting Help
+
+- **BMad Community:** [Discord community](https://discord.gg/bmad-method)
+- **Documentation:** [Complete workflow reference](https://docs.bmad-method.org/)
+- **Issues:** [GitHub repository](https://github.com/bmad-method/core)
+
+:::tip[Key Takeaways]
+The BMAD Method's strength is comprehensive planning that prevents common development pitfalls. Whether building a simple habit tracker or complex enterprise application, the same workflows scale to provide the right level of planning for your project. While it requires upfront investment, you'll avoid architecture refactoring, scope creep, and incomplete features that plague many projects. The workflow artifacts serve as living documentation that keeps your development focused and consistent.
+:::

docs/how-to-create-custom-agent-bmad-method.md

@@ -0,0 +1,532 @@
+---
+title: "Create a Custom Agent Using BMAD Method Workflows"
+---
+
+Use the BMAD Method workflows to design, build, and deploy a custom AI agent from initial concept to a delightful interactive persona that users love engaging with. This guide follows the development of a Teacher's Assistant agent to illustrate the concepts, but these same workflows apply to any custom agent project.
+
+## When to Use This
+
+- You want to create a specialized AI persona for specific domain expertise
+- You need an agent that guides users through multi-step processes in your field
+- You want to design custom interactive workflows beyond standard BMAD agents
+- You need an agent that embodies specific communication styles and knowledge areas
+- You're building agents for educational, professional, or specialized use cases
+
+## When to Skip This
+
+- Simple modifications to existing agents (use agent customization instead)
+- One-off custom prompts or simple AI interactions
+- Complex AI systems requiring custom training (this focuses on persona and workflow design)
+
+:::note[Prerequisites]
+- BMAD Core Platform installed with BMM module
+- Understanding of your target domain and user needs
+- Familiarity with BMAD agent interaction patterns
+- Access to Brainstorm Agent and Custom Agent Builder workflows
+:::
+
+:::tip[Quick Path]
+Initialize project → Brainstorm agent concepts → Define agent persona and capabilities → Build agent structure → Create workflows and menus → Test and refine → Deploy and document. The entire process typically takes 2-4 focused work sessions to go from idea to working custom agent.
+:::
+
+## Understanding Custom Agent Creation
+
+The BMAD Method approaches custom agent creation through systematic design and implementation workflows that ensure your agent delivers real value and delightful user experiences.
+
+| Phase | Name | What Happens |
+|-------|------|--------------|
+| 1 | Ideation | Brainstorm agent purpose, capabilities, personality *(collaborative)* |
+| 2 | Design | Define agent persona, communication style, knowledge domains *(structured)* |
+| 3 | Architecture | Plan agent workflows, menu systems, interaction patterns *(technical)* |
+| 4 | Implementation | Build agent files, configure activation sequences *(systematic)* |
+| 5 | Testing | Validate agent behavior, refine personality, test workflows *(iterative)* |
+| 6 | Deployment | Integrate agent into BMAD ecosystem, create documentation *(production)* |
+
+## Single Agent Method
+
+**All steps accomplished through one agent:**
+```
+/bmad:bmb:agents:agent-builder
+```
+
+The Agent Builder is a comprehensive Expert Agent that guides you through all phases of agent creation in a single workflow session. It handles brainstorming, discovery, type classification, persona development, menu structure, activation planning, and agent compilation without needing multiple specialized agents.
+
+## Steps
+
+### Step 1: Initialize Your Agent Creation Session
+
+**General Process:**
+Start the Agent Builder to begin comprehensive agent development using its step-file architecture.
+
+```
+/bmad:bmb:agents:agent-builder
+3. [CA] Create a new BMAD agent with best practices and compliance
+```
+
+**Teacher's Assistant Example:**
+When prompted for initial agent concept:
+- **Agent name:** "Teacher's Assistant"
+- **Primary domain:** "Education and learning facilitation"
+- **Target users:** "Students seeking homework help and concept understanding"
+- **Agent scope:** "Socratic questioning, scaffolding techniques, progress tracking"
+
+**Your Application:**
+Provide these key elements for any agent:
+- Clear agent purpose *(e.g., "help therapists with session planning", "guide developers through code reviews", "assist writers with story development")*
+- Target user definition *(e.g., "healthcare professionals", "marketing teams", "creative professionals")*
+- Domain expertise scope *(e.g., "financial planning", "project management", "technical documentation")*
+
+### Step 2: Brainstorm Agent Concepts and Capabilities
+
+**General Process:**
+The Agent Builder includes optional brainstorming in Step 1. When you choose to brainstorm, select from 4 specialized technique approaches:
+
+1. **User-Selected Techniques** - Browse the complete technique library
+2. **AI-Recommended Techniques** - Customized suggestions based on your goals *(includes web research)*
+3. **Random Technique Selection** - Discover unexpected creative methods
+4. **Progressive Technique Flow** - Start broad, then systematically narrow focus
+
+Each approach helps you discover your agent's essence - the living personality AND the utility it provides.
+
+**Teacher's Assistant Example:**
+Using AI-Recommended Techniques approach, we discovered:
+- **Core purpose:** "Guide students through understanding using educational best practices without providing direct answers"
+- **Key capabilities:** "Socratic questioning, scaffolding techniques, progress tracking, adaptive teaching methods"
+- **Personality traits:** "Patient mentor, educationally rigorous, never gives up on student learning"
+
+**Your Application:**
+Define these elements for any agent:
+- **Core purpose:** What main problem does your agent solve for users?
+- **Key capabilities:** What specific tasks should your agent excel at?
+- **Personality traits:** How should your agent communicate and behave?
+
+### Step 2a: Discovery Conversation Phase
+
+**General Process:**
+After brainstorming, the workflow includes a comprehensive discovery conversation that establishes your agent's scope, context, target users, and special features. This prevents re-asking questions in later development phases and generates a comprehensive agent plan document.
+
+**Teacher's Assistant Example:**
+Discovery conversation explored:
+- **Target Scope:** All educational interactions across grade levels and subjects
+- **Primary Context:** Home tutoring and independent study environments
+- **Communication Strategy:** Age-appropriate language complexity while maintaining concept integrity
+- **Persistence Philosophy:** "No giving up allowed" - always find alternative approaches
+- **Progress Tracking:** Subject-specific learning profiles with technique effectiveness monitoring
+- **Validation Approaches:** Student explanation + pop-quiz verification of understanding
+
+**Your Application:**
+The discovery phase will explore for any agent:
+- **Target Scope:** Who specifically will use your agent and in what contexts?
+- **Primary Context:** Where and how will your agent be used most frequently?
+- **Communication Strategy:** How should your agent adapt its communication style?
+- **Core Philosophy:** What principles guide your agent's decision-making?
+- **Special Features:** What unique capabilities set your agent apart?
+
+### Step 3: Determine Agent Type and Define Metadata
+
+**General Process:**
+The workflow systematically classifies your agent and defines all required metadata properties:
+- **Simple Agent:** Single-purpose, stateless, all-in-one file (~250 lines max)
+- **Expert Agent:** Persistent memory, sidecar folder, domain-specific expertise
+- **Module Agent:** Extends existing BMAD modules or requires multiple interconnected agents
+
+**Teacher's Assistant Example:**
+- **Classification:** Expert Agent (requires persistent memory for learning profiles)
+- **Rationale:** Student progress tracking, technique effectiveness monitoring, evolving teaching strategies
+- **Metadata Properties:**
+  - **ID:** `teachers-assistant`
+  - **Name:** `Sophia Chen`
+  - **Title:** `Educational Learning Facilitator`
+  - **Icon:** `🎓`
+  - **Module:** `stand-alone`
+  - **Has Sidecar:** `true`
+
+**Your Application:**
+For any agent, the system will determine:
+- **Agent Type:** Based on memory requirements and complexity needs
+- **Technical Properties:** ID (kebab-case), persona name, professional title
+- **Visual Identity:** Appropriate emoji icon for your domain
+- **Ecosystem Placement:** Stand-alone vs integration with existing modules
+
+### Step 4: Develop Four-Field Persona System
+
+**General Process:**
+The workflow uses a sophisticated four-field persona system that creates distinct, non-overlapping personality dimensions:
+- **Role:** WHAT they do (capabilities, expertise, knowledge areas)
+- **Identity:** WHO they are (background, experience, character)
+- **Communication Style:** HOW they speak (tone, patterns, voice)
+- **Principles:** WHY they act (decision framework, values, constraints)
+
+**Teacher's Assistant Example:**
+```yaml
+persona:
+  role: >
+    Educational learning facilitator specializing in Socratic questioning, scaffolding techniques,
+    and progress-based teaching that guides students to discover answers rather than providing direct instruction.
+
+  identity: >
+    Master educator with deep knowledge of educational psychology, constructivist learning theory,
+    and adaptive teaching methods. Passionate advocate for authentic learning through struggle and self-discovery.
+
+  communication_style: >
+    Speaks like a patient mentor using strategic questioning, encouraging language, and age-appropriate
+    complexity while maintaining conceptual integrity.
+
+  principles:
+    - Channel expert educational psychology wisdom: draw upon Zone of Proximal Development, scaffolding techniques, metacognitive strategies, and research-backed methods that facilitate genuine understanding
+    - Never provide direct answers - guide students to discover solutions through strategic questioning and multiple explanation pathways
+    - Authentic learning requires productive struggle - frustration signals growth, not failure
+    - Track what works for each student and adapt techniques accordingly - analogies for some, examples for others
+    - Academic boundaries are sacred - redirect non-educational conversations back to learning focus
+```
+
+**Your Application:**
+For any agent, you'll develop:
+- **Role:** Professional capabilities and expertise your agent provides
+- **Identity:** Background, experience, and character that makes them credible
+- **Communication Style:** How your agent speaks and interacts with users
+- **Principles:** Decision framework and values that guide behavior
+
+The first principle serves as an "expert activator" that tells the AI to access domain-specific knowledge and frameworks.
+
+### Step 5: Commands & Menu Structure Design
+
+**General Process:**
+Transform discovered capabilities into structured menu commands following BMAD patterns:
+- **Capability Review:** Analyze all capabilities from the discovery phase
+- **Command Grouping:** Organize related capabilities under logical command areas
+- **Menu Pattern Application:** Follow BMAD Expert Agent menu structure requirements
+- **Trigger Design:** Create intuitive 2-letter codes and fuzzy match patterns
+- **Handler Definition:** Map commands to specific prompts or actions
+
+**Teacher's Assistant Example:**
+Created 9 educational commands with Expert Agent architecture:
+
+```yaml
+critical_actions:
+  - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/learning-profiles.md'
+  - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/technique-tracking.md'
+  - 'ONLY read/write files in {project-root}/_bmad/_memory/teachers-assistant-sidecar/'
+
+prompts:
+  - id: socratic-guidance
+    content: |
+      <instructions>Guide student through learning using Socratic questioning without giving direct answers</instructions>
+      <process>1. Ask strategic questions 2. Use student interests for analogies 3. Encourage discovery 4. Validate understanding</process>
+
+menu:
+  - trigger: LG or fuzzy match on learn-guide
+    action: '#socratic-guidance'
+    description: '[LG] Learning guidance through Socratic questioning'
+
+  - trigger: QM or fuzzy match on quiz-me
+    action: 'Generate pop-quiz on recent or struggling concepts from learning profile'
+    description: '[QM] Quiz me on challenging concepts'
+
+  - trigger: SA or fuzzy match on study-aids
+    action: '#study-aids-generator'
+    description: '[SA] Generate study aids (flashcards, practice problems, guides)'
+```
+
+**Your Application:**
+For any agent, you'll create commands organized by:
+- **Primary Functions:** Core capabilities users access most frequently
+- **Utility Commands:** Support functions like help, settings, progress tracking
+- **Advanced Features:** Specialized tools for power users
+- **Memory Management:** For Expert agents with persistent data needs
+
+Design principles include 2-letter triggers, fuzzy matching, action handlers, and proper sidecar integration for Expert agents.
+
+### Step 6: Activation Planning
+
+**General Process:**
+Define how your agent behaves when it starts up through critical actions and startup sequences:
+- **Reference Loading:** Understanding critical action patterns
+- **Routing Decision:** Determining build path (Simple/Expert/Module) based on architecture
+- **Activation Needs Discussion:** Deciding autonomous vs responsive behavior patterns
+- **Critical Actions Definition:** Specifying startup commands for memory loading and boundaries
+
+**Teacher's Assistant Example:**
+```yaml
+activation:
+  hasCriticalActions: true
+  rationale: "Agent needs to auto-load student learning context to provide personalized educational guidance"
+  criticalActions:
+    - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/learning-profiles.md'
+    - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/technique-tracking.md'
+    - 'ONLY read/write files in {project-root}/_bmad/_memory/teachers-assistant-sidecar/'
+
+routing:
+  destinationBuild: "step-07b-build-expert.md"
+  rationale: "Expert agent requires sidecar memory for persistent learning profiles"
+```
+
+**Your Application:**
+For any agent, consider:
+- **Startup Needs:** What must your agent load or initialize when it starts?
+- **Memory Requirements:** Does your agent need persistent data between sessions?
+- **Security Boundaries:** What file access restrictions should be enforced?
+- **Operational Philosophy:** Responsive to prompts vs autonomous background tasks?
+
+Routing logic determines the build path based on your agent's architecture needs.
+
+### Step 7: Expert Agent Build and Compilation
+
+**General Process:**
+The Agent Builder automatically compiles all phases into the final .agent.yaml file:
+1. **Generates Agent YAML:** Combines persona, menu, activation, and metadata
+2. **Creates Sidecar Structure:** Sets up memory folders for Expert agents
+3. **Validates Configuration:** Ensures BMAD compliance and proper structure
+4. **Provides Installation:** Generates installation guidance
+
+**Teacher's Assistant Example:**
+Generated complete Expert agent with this structure:
+```
+agents/
+└── teachers-assistant/
+    ├── teachers-assistant.agent.yaml    # Complete agent definition
+    └── teachers-assistant-sidecar/      # Expert agent memory (build location)
+        ├── learning-profiles.md         # Student progress and preferences
+        ├── technique-tracking.md        # Teaching method effectiveness data
+        └── README.md                   # Sidecar documentation
+```
+
+Critical actions use proper path variables: `{project-root}/_bmad/_memory/{sidecar-folder}/` for runtime operation.
+
+**Your Application:**
+For any agent, this step produces:
+- **Agent YAML:** Complete agent definition with proper BMAD compliance
+- **Sidecar Structure:** Memory folders and files for Expert agents
+- **Path Configuration:** Proper variable usage for portability
+- **Documentation:** README files and installation guidance
+
+### Step 8: Celebration and Installation Guidance
+
+**General Process:**
+The Agent Builder provides comprehensive installation instructions and celebrates completion. To make any agent installable, create a standalone BMAD content module with:
+- Module directory with `module.yaml` containing `unitary: true`
+- Agent files in `agents/agent-name/` structure
+- Sidecar folder in `_memory/` for Expert agents
+
+**Teacher's Assistant Example:**
+Created this installable module structure:
+```
+my-educational-agents/
+├── module.yaml                              # Contains: unitary: true
+├── agents/
+│   └── teachers-assistant/
+│       ├── teachers-assistant.agent.yaml    # Main agent definition
+│       └── _memory/                         # Expert agent memory
+│           └── teachers-assistant-sidecar/
+│               ├── learning-profiles.md
+│               ├── technique-tracking.md
+│               └── README.md
+```
+
+Installation methods include new project setup or adding to existing BMAD installations.
+
+**Your Application:**
+For any agent, follow these installation principles:
+- **Module Structure:** Use `unitary: true` for standalone agent modules
+- **File Organization:** Place agent files in proper directory hierarchy
+- **Memory Management:** Include `_memory/` structure for Expert agents
+- **Distribution:** Package entire module directory for sharing
+
+## Installing and Using Your Custom Agent
+
+After completing agent creation, follow these steps to install and start using your new agent:
+
+### Step 1: Create Module Directory Structure
+
+**General Process:**
+Transform your agent output into a BMAD-installable module:
+
+```bash
+# Navigate to your project root
+cd /your/project/root
+
+# Create module directory
+mkdir -p my-custom-agents
+
+# Create module configuration
+echo "unitary: true" > my-custom-agents/module.yaml
+
+# Create agents directory structure
+mkdir -p my-custom-agents/agents
+```
+
+### Step 2: Organize Agent Files
+
+**General Process:**
+Move your completed agent files into the proper module structure:
+
+```bash
+# Copy agent directory from bmb-creations output
+cp -r /path/to/_bmad-output/bmb-creations/your-agent my-custom-agents/agents/
+
+# For Expert agents, organize sidecar structure
+mkdir -p my-custom-agents/agents/your-agent/_memory
+mv my-custom-agents/agents/your-agent/your-agent-sidecar my-custom-agents/agents/your-agent/_memory/
+```
+
+**Teacher's Assistant Example:**
+```
+my-educational-agents/
+├── module.yaml                              # Contains: unitary: true
+├── agents/
+│   └── teachers-assistant/
+│       ├── teachers-assistant.agent.yaml    # Main agent definition
+│       └── _memory/                         # Expert agent memory
+│           └── teachers-assistant-sidecar/
+│               ├── learning-profiles.md
+│               ├── technique-tracking.md
+│               └── README.md
+```
+
+### Step 3: Install Module in BMAD
+
+**General Process:**
+Add your custom module to an existing or new BMAD project:
+
+**For New Projects:**
+1. Run BMAD installer: `npx @bmad-method/cli init`
+2. When prompted for local modules, provide the path to your module
+3. Installer will automatically integrate your agent
+
+**For Existing Projects:**
+1. Run: `npx @bmad-method/cli modify`
+2. Select "Add local custom module"
+3. Provide path to your module directory
+4. Confirm installation
+
+### Step 4: Activate Your Agent
+
+**General Process:**
+Once installed, your agent becomes available through BMAD's command system:
+
+```bash
+# List available agents (verify your agent appears)
+/agents
+
+# Activate your agent using its module path
+/bmad:your-module:agents:your-agent
+```
+
+**Teacher's Assistant Example:**
+```bash
+/bmad:my-educational-agents:agents:teachers-assistant
+```
+
+### Step 5: Test Agent Functionality
+
+**General Process:**
+Start with basic interactions to verify your agent works correctly:
+
+**Initial Activation Test:**
+```
+/bmad:your-module:agents:your-agent
+```
+
+**Basic Conversation Examples:**
+- "Hi [Agent Name], what can you help me with?"
+- "Show me your available commands"
+- "Tell me about your capabilities"
+
+**Teacher's Assistant Example:**
+Specific conversation starters that test educational capabilities:
+- "Help me understand fractions without giving me the answer"
+- "LG" (Learning Guidance command)
+- "QM" (Quiz Me command)
+- "SA" (Study Aids command)
+
+### Step 6: Verify Expert Agent Memory (If Applicable)
+
+**General Process:**
+For Expert agents with sidecar folders, confirm memory persistence:
+
+1. **Start agent and interact with memory commands**
+2. **Update profiles or tracking data**
+3. **Restart agent and verify data persists**
+
+**Teacher's Assistant Example:**
+```
+UP (Update Profile command)
+LP (Learning Progress command)
+```
+
+### Troubleshooting Common Installation Issues
+
+**Agent Not Found:**
+- Verify `module.yaml` exists with `unitary: true`
+- Check agent file is in `agents/agent-name/agent-name.agent.yaml`
+- Confirm BMAD installation included your module
+
+**Sidecar Memory Issues (Expert Agents):**
+- Ensure `_memory/agent-sidecar/` structure exists
+- Verify critical_actions reference correct file paths
+- Check file permissions for read/write access
+
+**Command Not Working:**
+- Test basic interaction first before specialized commands
+- Verify agent activation completed successfully
+- Check for any startup errors in agent logs
+
+### Sharing Your Agent
+
+To share your agent with others:
+
+1. **Package entire module directory:** `my-custom-agents/`
+2. **Include installation instructions:** Reference this guide
+3. **Provide example interactions:** Show how to use key features
+4. **Document dependencies:** Any special requirements or modules
+
+**Distribution Options:**
+- **Git Repository:** Push module directory to version control
+- **Archive File:** Zip module directory for direct sharing
+- **BMAD Community:** Submit to community agent library (if available)
+
+Your custom agent is now ready for production use and can be shared across BMAD installations!
+
+## Summary
+
+The BMAD Agent Builder provides a comprehensive, single-agent solution for creating production-ready BMAD agents. Through its step-file architecture, it guides you through the complete end-to-end process:
+
+1. **Brainstorming** (optional) - Creative exploration using 4 specialized technique approaches
+2. **Discovery** - Comprehensive capability and context definition with agent-plan documentation
+3. **Type Classification** - Automatic Simple/Expert/Module architecture determination
+4. **Four-Field Persona** - Role, identity, communication style, and principles development
+5. **Commands & Menu** - Structured command interface with BMAD compliance
+6. **Activation Planning** - Critical actions definition and routing determination
+7. **Agent Build** - Complete YAML file generation with sidecar structure
+8. **Installation Guidance** - Module packaging instructions and testing recommendations
+
+**Complete Agent Creation in One Session:**
+```
+/bmad:bmb:agents:agent-builder → [CA] Create a new BMAD agent → Continue through all steps
+```
+
+**Process Results:**
+- **Production-Ready Files:** Complete `.agent.yaml` with proper BMAD compliance
+- **Expert Architecture:** Sidecar folder structure with memory files and security boundaries
+- **Installation Package:** Module structure with `module.yaml` for BMAD integration
+- **Testing Guidelines:** Conversation starters and command validation approaches
+- **Documentation:** Comprehensive agent plan and sidecar README for maintenance
+
+**Key Advantages:**
+- **Single Agent Workflow:** Complete process without switching between multiple agents
+- **BMAD Compliance:** Automatic adherence to all standards, patterns, and architectural requirements
+- **Expert Memory Management:** Proper sidecar setup with runtime path variables and file boundaries
+- **Specialized Domain Integration:** Research-backed methodology incorporation
+- **Production Installation:** Ready-to-install module structure with proper configuration
+
+**Teacher's Assistant Case Study Achievement:**
+- **Expert Agent:** 9 educational commands with persistent memory architecture
+- **Educational Psychology Integration:** Socratic method, scaffolding techniques, ZPD assessment
+- **Complete Workflow:** From concept to installable module in single session
+- **Memory Architecture:** Student learning profiles and technique effectiveness tracking
+- **BMAD Compliance:** Full validation and proper sidecar configuration
+
+**Time Investment:**
+Typically 2-4 focused work sessions to go from initial idea to production-ready, installable custom agent with comprehensive capabilities and professional-quality implementation.
+
+The BMAD Agent Creation Method transforms agent concepts into production-ready implementations efficiently and systematically, handling all technical complexity while maintaining focus on agent personality and user value delivery.

docs/how-to/customize-bmad.md

@@ -151,7 +151,7 @@ prompts:
 
 ## Workflow Customization
 
-Information about customizing existing BMad MEthod workflows and skills are coming soon.
+Information about customizing existing BMad Method workflows and skills are coming soon.
 
 ## Module Customization
 

my-educational-agents/agents/teachers-assistant/_memory/teachers-assistant-sidecar/README.md

@@ -0,0 +1,26 @@
+# Teachers-Assistant-Sidecar
+
+This folder stores persistent memory for the **Teachers Assistant** Expert agent.
+
+## Purpose
+Maintains individual student learning profiles and tracks teaching technique effectiveness to provide personalized educational guidance that adapts to each student's learning style and progress.
+
+## Files
+- **learning-profiles.md**: Student interests, grade level, subject progress tracking, and learning preferences
+- **technique-tracking.md**: Record of teaching methods and their effectiveness per student for continuous improvement
+
+## Runtime Access
+After BMAD installation, this folder will be accessible at:
+`{project-root}/_bmad/_memory/teachers-assistant-sidecar/`
+
+## Educational Philosophy
+This agent implements research-backed educational psychology principles:
+- **Zone of Proximal Development**: Scaffolding within student's learning capability
+- **Socratic Method**: Strategic questioning to guide discovery rather than provide answers
+- **Constructivist Learning**: Student-centered knowledge building through active engagement
+- **Metacognitive Strategies**: Building student awareness of their own learning processes
+
+## Security & Privacy
+- Agent file access is restricted to this sidecar folder only
+- Student learning data remains private and is not shared beyond educational interactions
+- Progress tracking serves to improve teaching effectiveness, not for external assessment

my-educational-agents/agents/teachers-assistant/_memory/teachers-assistant-sidecar/learning-profiles.md

@@ -0,0 +1,27 @@
+# Learning Profiles
+
+## Student Information
+- **Name**: [To be filled during first interaction]
+- **Grade Level**: [To be determined]
+- **Primary Subjects**: [To be identified]
+
+## Learning Preferences
+- **Communication Style**: [Age-appropriate complexity level]
+- **Preferred Analogies**: [Student interests for concept explanations]
+- **Learning Modalities**: [Visual, verbal, kinesthetic preferences]
+- **Study Aid Formats**: [Flashcards, concept maps, practice problems, guides]
+
+## Subject Progress Tracking
+
+### [Subject Name]
+- **Mastered Concepts**: [List concepts student has demonstrated understanding]
+- **Struggling Areas**: [Concepts requiring additional focus and practice]
+- **Effective Techniques**: [Methods that work well for this student in this subject]
+- **Recent Sessions**: [Brief notes on last few learning interactions]
+
+## Progress Notes
+- **Overall Learning Patterns**: [What consistently helps this student learn]
+- **Motivation Strategies**: [What keeps student engaged]
+- **Challenge Areas**: [Topics or approaches that consistently cause difficulty]
+
+*This file is updated automatically during learning sessions and can be manually edited through the [UP] command.*

my-educational-agents/agents/teachers-assistant/_memory/teachers-assistant-sidecar/technique-tracking.md

@@ -0,0 +1,43 @@
+# Technique Effectiveness Tracking
+
+## Teaching Method Analysis
+
+### Socratic Questioning
+- **Success Rate**: [Percentage of times this leads to understanding]
+- **Best Used For**: [Types of concepts where this works well]
+- **Student Response**: [How student typically responds to questioning approach]
+- **Notes**: [Specific questioning patterns that work for this student]
+
+### Analogies & Examples
+- **Preferred Analogy Types**: [Student interests that make good analogies]
+- **Successful Analogies**: [Record of analogies that clicked]
+- **Failed Analogies**: [Analogies that confused rather than clarified]
+- **Interest Areas**: [Student hobbies/interests available for analogies]
+
+### Study Aid Generation
+- **Most Effective Formats**: [Flashcards, concept maps, practice problems, guides]
+- **Usage Patterns**: [How student uses generated materials]
+- **Revision Frequency**: [How often student reviews generated aids]
+- **Success Metrics**: [Improvement after using specific aid types]
+
+### Alternative Explanation Methods
+- **Visual Methods**: [Diagrams, charts, illustrations effectiveness]
+- **Narrative Methods**: [Story-based learning success rate]
+- **Step-by-Step Guides**: [Procedural learning effectiveness]
+- **Peer Explanation**: [Student teaching back concepts success]
+
+## Session Effectiveness Tracking
+- **Date**: [Session date]
+- **Subject**: [Topic covered]
+- **Methods Used**: [Teaching techniques employed]
+- **Student Engagement**: [High/Medium/Low and why]
+- **Understanding Achieved**: [Yes/Partial/No and next steps]
+- **Follow-up Needed**: [Additional practice or review required]
+
+## Adaptation Insights
+- **Learning Style Preferences**: [What consistently works]
+- **Avoidance Patterns**: [Methods that consistently fail]
+- **Optimal Session Length**: [How long before fatigue sets in]
+- **Best Time Patterns**: [When student is most receptive to learning]
+
+*This file tracks which educational techniques work best for individual students and is updated after each learning session.*

my-educational-agents/agents/teachers-assistant/teachers-assistant.agent.yaml

@@ -0,0 +1,84 @@
+agent:
+  metadata:
+    id: teachers-assistant
+    name: Sophia Chen
+    title: Educational Learning Facilitator
+    icon: 🎓
+    module: stand-alone
+    hasSidecar: true
+
+  persona:
+    role: |
+      Educational learning facilitator specializing in Socratic questioning, scaffolding techniques, and progress-based teaching that guides students to discover answers rather than providing direct instruction.
+
+    identity: |
+      Master educator with deep knowledge of educational psychology, constructivist learning theory, and adaptive teaching methods. Passionate advocate for authentic learning through struggle and self-discovery.
+
+    communication_style: |
+      Speaks like a patient mentor using strategic questioning, encouraging language, and age-appropriate complexity while maintaining conceptual integrity.
+
+    principles:
+      - Channel expert educational psychology wisdom: draw upon Zone of Proximal Development, scaffolding techniques, metacognitive strategies, and research-backed methods that facilitate genuine understanding
+      - Never provide direct answers - guide students to discover solutions through strategic questioning and multiple explanation pathways
+      - Authentic learning requires productive struggle - frustration signals growth, not failure
+      - Track what works for each student and adapt techniques accordingly - analogies for some, examples for others
+      - Academic boundaries are sacred - redirect non-educational conversations back to learning focus
+
+  critical_actions:
+    - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/learning-profiles.md'
+    - 'Load COMPLETE file {project-root}/_bmad/_memory/teachers-assistant-sidecar/technique-tracking.md'
+    - 'ONLY read/write files in {project-root}/_bmad/_memory/teachers-assistant-sidecar/'
+
+  prompts:
+    - id: socratic-guidance
+      content: |
+        <instructions>Guide student through learning using Socratic questioning without giving direct answers</instructions>
+        <process>1. Ask strategic questions 2. Use student interests for analogies 3. Encourage discovery 4. Validate understanding</process>
+
+    - id: alternative-explanation
+      content: |
+        <instructions>Try different teaching approach when student struggles with current method</instructions>
+        <process>1. Assess why current approach failed 2. Select alternative method 3. Use different modality or analogy 4. Check for understanding</process>
+
+    - id: study-aids-generator
+      content: |
+        <instructions>Generate study materials based on student needs and preferences</instructions>
+        <options>Flashcards | Practice Problems | Concept Maps | Step-by-step Guides</options>
+        <process>1. Assess learning gaps 2. Choose appropriate format 3. Create targeted materials 4. Save to learning profile</process>
+
+  menu:
+    - trigger: LG or fuzzy match on learn-guide
+      action: '#socratic-guidance'
+      description: '[LG] Learning guidance through Socratic questioning'
+
+    - trigger: QM or fuzzy match on quiz-me
+      action: 'Generate pop-quiz on recent or struggling concepts from learning profile'
+      description: '[QM] Quiz me on challenging concepts'
+
+    - trigger: VC or fuzzy match on validate-concepts
+      action: 'Test retention of previously learned material to ensure long-term understanding'
+      description: '[VC] Validate concept retention'
+
+    - trigger: SA or fuzzy match on study-aids
+      action: '#study-aids-generator'
+      description: '[SA] Generate study aids (flashcards, practice problems, guides)'
+
+    - trigger: ED or fuzzy match on explain-differently
+      action: '#alternative-explanation'
+      description: '[ED] Try different explanation method'
+
+    - trigger: ST or fuzzy match on story-time
+      action: 'Tell engaging stories that exemplify concepts being learned'
+      description: '[ST] Story time - learn through narratives'
+
+    - trigger: UP or fuzzy match on update-profile
+      action: 'Update {project-root}/_bmad/_memory/teachers-assistant-sidecar/learning-profiles.md with interests and preferences'
+      description: '[UP] Update learning profile and interests'
+
+    - trigger: LP or fuzzy match on learning-progress
+      action: 'Review progress from {project-root}/_bmad/_memory/teachers-assistant-sidecar/technique-tracking.md and provide insights'
+      description: '[LP] View learning progress and technique effectiveness'
+
+    - trigger: HC or fuzzy match on help-commands
+      action: 'Display all available educational commands and their usage with examples'
+      description: '[HC] Help - show all available commands'

my-educational-agents/module.yaml

@@ -0,0 +1 @@
+unitary: true

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "bmad-method",
-  "version": "6.0.0-Beta.1",
+  "version": "6.0.0-Beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "bmad-method",
-      "version": "6.0.0-Beta.1",
+      "version": "6.0.0-Beta.2",
       "license": "MIT",
       "dependencies": {
         "@clack/prompts": "^0.11.0",

package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "6.0.0-Beta.1",
+  "version": "6.0.0-Beta.2",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",

src/bmm/module-help.csv

@@ -1,32 +1,32 @@
 module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs,
-bmm,anytime,Document Project,DP,10,_bmad/bmm/workflows/document-project/workflow.yaml,bmad_bmm_document-project,false,analyst,Create Mode,"Analyze an existing project to produce useful documentation",project-knowledge,*,
-bmm,anytime,Quick Spec,TS,20,_bmad/bmm/workflows/bmad-quick-flow/quick-spec/workflow.md,bmad_bmm_quick-spec,false,quick-flow-solo-dev,Create Mode,"Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the bmad method. Quick one-off tasks small changes simple apps utilities without extensive planning",planning_artifacts,"tech spec",
-bmm,anytime,Quick Dev,QD,30,_bmad/bmm/workflows/bmad-quick-flow/quick-dev/workflow.md,bmad_bmm_quick-dev,false,quick-flow-solo-dev,Create Mode,"Quick one-off tasks small changes simple apps utilities without extensive planning - Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the bmad method, unless the user is already working through the implementation phase and just requests a 1 off things not already in the plan",,,
-bmm,anytime,Correct Course,CC,40,_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml,bmad_bmm_correct-course,false,sm,Create Mode,"Anytime: Navigate significant changes. May recommend start over update PRD redo architecture sprint planning or correct epics and stories",planning_artifacts,"change proposal",
-bmm,1-analysis,Brainstorm Project,BP,10,_bmad/core/workflows/brainstorming/workflow.md,bmad_brainstorming,false,analyst,data=_bmad/bmm/data/project-context-template.md,"Expert Guided Facilitation through a single or multiple techniques",planning_artifacts,"brainstorming session",
-bmm,1-analysis,Market Research,MR,20,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad_bmm_research,false,analyst,Create Mode research_type=market,"Market analysis competitive landscape customer needs and trends","planning_artifacts|project-knowledge","research documents"
-bmm,1-analysis,Domain Research,DR,21,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad_bmm_research,false,analyst,Create Mode research_type=domain,"Industry domain deep dive subject matter expertise and terminology","planning_artifacts|project-knowledge","research documents"
-bmm,1-analysis,Technical Research,TR,22,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad_bmm_research,false,analyst,Create Mode research_type=technical,"Technical feasibility architecture options and implementation approaches","planning_artifacts|project-knowledge","research documents"
-bmm,1-analysis,Create Brief,CB,30,_bmad/bmm/workflows/1-analysis/create-product-brief/workflow.md,bmad_bmm_create-brief,false,analyst,Create Mode,"A guided experience to nail down your product idea",planning_artifacts,"product brief",
-bmm,1-analysis,Validate Brief,VB,40,_bmad/bmm/workflows/1-analysis/create-product-brief/workflow.md,bmad_bmm_validate-brief,false,analyst,Validate Mode,"Validates product brief completeness",planning_artifacts,"brief validation report",
-bmm,2-planning,Create PRD,CP,10,_bmad/bmm/workflows/2-plan-workflows/create-prd/workflow.md,bmad_bmm_prd,true,pm,Create Mode,"Expert led facilitation to produce your Product Requirements Document",planning_artifacts,prd,
-bmm,2-planning,Validate PRD,VP,20,_bmad/bmm/workflows/2-plan-workflows/create-prd/workflow.md,bmad_bmm_prd,false,pm,Validate Mode,"Validate PRD is comprehensive lean well organized and cohesive",planning_artifacts,"prd validation report",
-bmm,2-planning,Create UX,CU,30,_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.md,bmad_bmm_create-ux-design,false,ux-designer,Create Mode,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project",planning_artifacts,"ux design",
-bmm,2-planning,Validate UX,VU,40,_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.md,bmad_bmm_create-ux-design,false,ux-designer,Validate Mode,"Validates UX design deliverables",planning_artifacts,"ux validation report",
-,anytime,Create Dataflow,CDF,50,_bmad/bmm/workflows/excalidraw-diagrams/create-dataflow/workflow.yaml,bmad_bmm_create-excalidraw-dataflow,false,ux-designer,Create Mode,"Create data flow diagrams (DFD) in Excalidraw format - can be called standalone or during any workflow to add visual documentation",planning_artifacts,"dataflow diagram",
-,anytime,Create Diagram,CED,51,_bmad/bmm/workflows/excalidraw-diagrams/create-diagram/workflow.yaml,bmad_bmm_create-excalidraw-diagram,false,ux-designer,Create Mode,"Create system architecture diagrams ERDs UML diagrams or general technical diagrams in Excalidraw format - use anytime or call from architecture workflow to add visual documentation",planning_artifacts,"diagram",
-,anytime,Create Flowchart,CFC,52,_bmad/bmm/workflows/excalidraw-diagrams/create-flowchart/workflow.yaml,bmad_bmm_create-excalidraw-flowchart,false,ux-designer,Create Mode,"Create a flowchart visualization in Excalidraw format for processes pipelines or logic flows - use anytime or during architecture to add process documentation",planning_artifacts,"flowchart",
-,anytime,Create Wireframe,CEW,53,_bmad/bmm/workflows/excalidraw-diagrams/create-wireframe/workflow.yaml,bmad_bmm_create-excalidraw-wireframe,false,ux-designer,Create Mode,"Create website or app wireframes in Excalidraw format - use anytime standalone or call from UX workflow to add UI mockups",planning_artifacts,"wireframe",
-bmm,3-solutioning,Create Architecture,CA,10,_bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md,bmad_bmm_create-architecture,true,architect,Create Mode,"Guided Workflow to document technical decisions",planning_artifacts,architecture,
-bmm,3-solutioning,Validate Architecture,VA,20,_bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md,bmad_bmm_create-architecture,false,architect,Validate Mode,"Validates architecture completeness",planning_artifacts,"architecture validation report",
-bmm,3-solutioning,Create Epics and Stories,CE,30,_bmad/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.md,bmad_bmm_create-epics-and-stories,true,pm,Create Mode,"Create the Epics and Stories Listing",planning_artifacts,"epics and stories",
-bmm,3-solutioning,Validate Epics and Stories,VE,40,_bmad/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.md,bmad_bmm_create-epics-and-stories,false,pm,Validate Mode,"Validates epics and stories completeness",planning_artifacts,"epics validation report",
-bmm,3-solutioning,Test Design,TD,50,_bmad/bmm/workflows/testarch/test-design/workflow.yaml,bmad_bmm_testarch-test-design,false,tea,Create Mode,"Create comprehensive test scenarios ahead of development, recommended if string test compliance or assurance is needed. Very critical for distributed applications with separate front ends and backends outside of a monorepo.",planning_artifacts,"test design",
-bmm,3-solutioning,Check Implementation Readiness,IR,70,_bmad/bmm/workflows/3-solutioning/check-implementation-readiness/workflow.md,bmad_bmm_check-implementation-readiness,true,architect,Validate Mode,"Ensure PRD UX Architecture and Epics Stories are aligned",planning_artifacts,"readiness report",
-bmm,4-implementation,Sprint Planning,SP,10,_bmad/bmm/workflows/4-implementation/sprint-planning/workflow.yaml,bmad_bmm_sprint-planning,true,sm,Create Mode,"Generate sprint plan for development tasks - this kicks off the implementation phase by producing a plan the implementation agents will follow in sequence for every story in the plan.",implementation_artifacts,"sprint status",
-bmm,4-implementation,Sprint Status,SS,20,_bmad/bmm/workflows/4-implementation/sprint-status/workflow.yaml,bmad_bmm_sprint-status,false,sm,Create Mode,"Anytime: Summarize sprint status and route to next workflow",,,
-bmm,4-implementation,Create Story,CS,30,_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml,bmad_bmm_create-story,true,sm,Create Mode,"Story cycle start: Prepare first found story in the sprint plan that is next, or if the command is run with a specific epic and story designation with context. Once complete, then VS then DS then CR then back to DS if needed or next CS or ER",implementation_artifacts,story,
-bmm,4-implementation,Validate Story,VS,35,_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml,bmad_bmm_create-story,false,sm,Validate Mode,"Validates story readiness and completeness before development work begins",implementation_artifacts,"story validation report",
-bmm,4-implementation,Dev Story,DS,40,_bmad/bmm/workflows/4-implementation/dev-story/workflow.yaml,bmad_bmm_dev-story,true,dev,Create Mode,"Story cycle: Execute story implementation tasks and tests then CR then back to DS if fixes needed",,,
-bmm,4-implementation,Code Review,CR,50,_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml,bmad_bmm_code-review,false,dev,Create Mode,"Story cycle: If issues back to DS if approved then next CS or ER if epic complete",,,
-bmm,4-implementation,Retrospective,ER,60,_bmad/bmm/workflows/4-implementation/retrospective/workflow.yaml,bmad_bmm_retrospective,false,sm,Create Mode,"Optional at epic end: Review completed work lessons learned and next epic or if major issues consider CC",implementation_artifacts,retrospective,
+bmm,anytime,Document Project,DP,10,_bmad/bmm/workflows/document-project/workflow.yaml,bmad-bmm-document-project,false,analyst,Create Mode,"Analyze an existing project to produce useful documentation",project-knowledge,*,
+bmm,anytime,Quick Spec,TS,20,_bmad/bmm/workflows/bmad-quick-flow/quick-spec/workflow.md,bmad-bmm-quick-spec,false,quick-flow-solo-dev,Create Mode,"Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the bmad method. Quick one-off tasks small changes simple apps utilities without extensive planning",planning_artifacts,"tech spec",
+bmm,anytime,Quick Dev,QD,30,_bmad/bmm/workflows/bmad-quick-flow/quick-dev/workflow.md,bmad-bmm-quick-dev,false,quick-flow-solo-dev,Create Mode,"Quick one-off tasks small changes simple apps utilities without extensive planning - Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the bmad method, unless the user is already working through the implementation phase and just requests a 1 off things not already in the plan",,,
+bmm,anytime,Correct Course,CC,40,_bmad/bmm/workflows/4-implementation/correct-course/workflow.yaml,bmad-bmm-correct-course,false,sm,Create Mode,"Anytime: Navigate significant changes. May recommend start over update PRD redo architecture sprint planning or correct epics and stories",planning_artifacts,"change proposal",
+bmm,1-analysis,Brainstorm Project,BP,10,_bmad/core/workflows/brainstorming/workflow.md,bmad-brainstorming,false,analyst,data=_bmad/bmm/data/project-context-template.md,"Expert Guided Facilitation through a single or multiple techniques",planning_artifacts,"brainstorming session",
+bmm,1-analysis,Market Research,MR,20,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad-bmm-research,false,analyst,Create Mode research_type=market,"Market analysis competitive landscape customer needs and trends","planning_artifacts|project-knowledge","research documents"
+bmm,1-analysis,Domain Research,DR,21,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad-bmm-research,false,analyst,Create Mode research_type=domain,"Industry domain deep dive subject matter expertise and terminology","planning_artifacts|project-knowledge","research documents"
+bmm,1-analysis,Technical Research,TR,22,_bmad/bmm/workflows/1-analysis/research/workflow.md,bmad-bmm-research,false,analyst,Create Mode research_type=technical,"Technical feasibility architecture options and implementation approaches","planning_artifacts|project-knowledge","research documents"
+bmm,1-analysis,Create Brief,CB,30,_bmad/bmm/workflows/1-analysis/create-product-brief/workflow.md,bmad-bmm-create-brief,false,analyst,Create Mode,"A guided experience to nail down your product idea",planning_artifacts,"product brief",
+bmm,1-analysis,Validate Brief,VB,40,_bmad/bmm/workflows/1-analysis/create-product-brief/workflow.md,bmad-bmm-validate-brief,false,analyst,Validate Mode,"Validates product brief completeness",planning_artifacts,"brief validation report",
+bmm,2-planning,Create PRD,CP,10,_bmad/bmm/workflows/2-plan-workflows/create-prd/workflow.md,bmad-bmm-prd,true,pm,Create Mode,"Expert led facilitation to produce your Product Requirements Document",planning_artifacts,prd,
+bmm,2-planning,Validate PRD,VP,20,_bmad/bmm/workflows/2-plan-workflows/create-prd/workflow.md,bmad-bmm-prd,false,pm,Validate Mode,"Validate PRD is comprehensive lean well organized and cohesive",planning_artifacts,"prd validation report",
+bmm,2-planning,Create UX,CU,30,_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.md,bmad-bmm-create-ux-design,false,ux-designer,Create Mode,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project",planning_artifacts,"ux design",
+bmm,2-planning,Validate UX,VU,40,_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.md,bmad-bmm-create-ux-design,false,ux-designer,Validate Mode,"Validates UX design deliverables",planning_artifacts,"ux validation report",
+,anytime,Create Dataflow,CDF,50,_bmad/bmm/workflows/excalidraw-diagrams/create-dataflow/workflow.yaml,bmad-bmm-create-excalidraw-dataflow,false,ux-designer,Create Mode,"Create data flow diagrams (DFD) in Excalidraw format - can be called standalone or during any workflow to add visual documentation",planning_artifacts,"dataflow diagram",
+,anytime,Create Diagram,CED,51,_bmad/bmm/workflows/excalidraw-diagrams/create-diagram/workflow.yaml,bmad-bmm-create-excalidraw-diagram,false,ux-designer,Create Mode,"Create system architecture diagrams ERDs UML diagrams or general technical diagrams in Excalidraw format - use anytime or call from architecture workflow to add visual documentation",planning_artifacts,"diagram",
+,anytime,Create Flowchart,CFC,52,_bmad/bmm/workflows/excalidraw-diagrams/create-flowchart/workflow.yaml,bmad-bmm-create-excalidraw-flowchart,false,ux-designer,Create Mode,"Create a flowchart visualization in Excalidraw format for processes pipelines or logic flows - use anytime or during architecture to add process documentation",planning_artifacts,"flowchart",
+,anytime,Create Wireframe,CEW,53,_bmad/bmm/workflows/excalidraw-diagrams/create-wireframe/workflow.yaml,bmad-bmm-create-excalidraw-wireframe,false,ux-designer,Create Mode,"Create website or app wireframes in Excalidraw format - use anytime standalone or call from UX workflow to add UI mockups",planning_artifacts,"wireframe",
+bmm,3-solutioning,Create Architecture,CA,10,_bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md,bmad-bmm-create-architecture,true,architect,Create Mode,"Guided Workflow to document technical decisions",planning_artifacts,architecture,
+bmm,3-solutioning,Validate Architecture,VA,20,_bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md,bmad-bmm-create-architecture,false,architect,Validate Mode,"Validates architecture completeness",planning_artifacts,"architecture validation report",
+bmm,3-solutioning,Create Epics and Stories,CE,30,_bmad/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.md,bmad-bmm-create-epics-and-stories,true,pm,Create Mode,"Create the Epics and Stories Listing",planning_artifacts,"epics and stories",
+bmm,3-solutioning,Validate Epics and Stories,VE,40,_bmad/bmm/workflows/3-solutioning/create-epics-and-stories/workflow.md,bmad-bmm-create-epics-and-stories,false,pm,Validate Mode,"Validates epics and stories completeness",planning_artifacts,"epics validation report",
+bmm,3-solutioning,Test Design,TD,50,_bmad/bmm/workflows/testarch/test-design/workflow.yaml,bmad-bmm-testarch-test-design,false,tea,Create Mode,"Create comprehensive test scenarios ahead of development, recommended if string test compliance or assurance is needed. Very critical for distributed applications with separate front ends and backends outside of a monorepo.",planning_artifacts,"test design",
+bmm,3-solutioning,Check Implementation Readiness,IR,70,_bmad/bmm/workflows/3-solutioning/check-implementation-readiness/workflow.md,bmad-bmm-check-implementation-readiness,true,architect,Validate Mode,"Ensure PRD UX Architecture and Epics Stories are aligned",planning_artifacts,"readiness report",
+bmm,4-implementation,Sprint Planning,SP,10,_bmad/bmm/workflows/4-implementation/sprint-planning/workflow.yaml,bmad-bmm-sprint-planning,true,sm,Create Mode,"Generate sprint plan for development tasks - this kicks off the implementation phase by producing a plan the implementation agents will follow in sequence for every story in the plan.",implementation_artifacts,"sprint status",
+bmm,4-implementation,Sprint Status,SS,20,_bmad/bmm/workflows/4-implementation/sprint-status/workflow.yaml,bmad-bmm-sprint-status,false,sm,Create Mode,"Anytime: Summarize sprint status and route to next workflow",,,
+bmm,4-implementation,Create Story,CS,30,_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml,bmad-bmm-create-story,true,sm,Create Mode,"Story cycle start: Prepare first found story in the sprint plan that is next, or if the command is run with a specific epic and story designation with context. Once complete, then VS then DS then CR then back to DS if needed or next CS or ER",implementation_artifacts,story,
+bmm,4-implementation,Validate Story,VS,35,_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml,bmad-bmm-create-story,false,sm,Validate Mode,"Validates story readiness and completeness before development work begins",implementation_artifacts,"story validation report",
+bmm,4-implementation,Dev Story,DS,40,_bmad/bmm/workflows/4-implementation/dev-story/workflow.yaml,bmad-bmm-dev-story,true,dev,Create Mode,"Story cycle: Execute story implementation tasks and tests then CR then back to DS if fixes needed",,,
+bmm,4-implementation,Code Review,CR,50,_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml,bmad-bmm-code-review,false,dev,Create Mode,"Story cycle: If issues back to DS if approved then next CS or ER if epic complete",,,
+bmm,4-implementation,Retrospective,ER,60,_bmad/bmm/workflows/4-implementation/retrospective/workflow.yaml,bmad-bmm-retrospective,false,sm,Create Mode,"Optional at epic end: Review completed work lessons learned and next epic or if major issues consider CC",implementation_artifacts,retrospective,

src/bmm/workflows/bmad-quick-flow/quick-spec/steps/step-01-understand.md

@@ -2,7 +2,7 @@
 name: 'step-01-understand'
 description: 'Analyze the requirement delta between current state and what user wants to build'
 
-workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-spec'
 nextStepFile: './step-02-investigate.md'
 skipToStepFile: './step-03-generate.md'
 templateFile: '{workflow_path}/tech-spec-template.md'

src/bmm/workflows/bmad-quick-flow/quick-spec/steps/step-02-investigate.md

@@ -2,7 +2,7 @@
 name: 'step-02-investigate'
 description: 'Map technical constraints and anchor points within the codebase'
 
-workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-spec'
 nextStepFile: './step-03-generate.md'
 wipFile: '{implementation_artifacts}/tech-spec-wip.md'
 ---

src/bmm/workflows/bmad-quick-flow/quick-spec/steps/step-03-generate.md

@@ -2,7 +2,7 @@
 name: 'step-03-generate'
 description: 'Build the implementation plan based on the technical mapping of constraints'
 
-workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
+workflow_path: '{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-spec'
 nextStepFile: './step-04-review.md'
 wipFile: '{implementation_artifacts}/tech-spec-wip.md'
 ---

src/bmm/workflows/bmad-quick-flow/quick-spec/steps/step-04-review.md

@@ -139,7 +139,7 @@ b) **HALT and wait for user selection.**
 #### Menu Handling Logic:
 
 - IF A: Read fully and follow: `{advanced_elicitation}` with current spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
-- IF B: Load and execute `{quick_dev_workflow}` with the final spec file (warn: fresh context is better)
+- IF B: Read the entire workflow file at `{quick_dev_workflow}` and follow the instructions with the final spec file (warn: fresh context is better)
 - IF D: Exit workflow - display final confirmation and path to spec
 - IF P: Read fully and follow: `{party_mode_exec}` with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
 - IF R: Execute Adversarial Review (see below)

src/core/module-help.csv

@@ -1,9 +1,9 @@
 module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs
-core,,Brainstorming,BS,20,_bmad/core/workflows/brainstorming/workflow.md,bmad_brainstorming,false,analyst,,Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods,{output_folder}/brainstorming/brainstorming-session-{{date}}.md,,
-core,,Party Mode,PM,30,_bmad/core/workflows/party-mode/workflow.md,bmad_party-mode,false,party-mode facilitator,,Orchestrates group discussions between all installed BMAD agents enabling natural multi-agent conversations,,
-core,,bmad-help,BH,40,_bmad/core/tasks/help.md,bmad_help,false,system,,Get unstuck by showing what workflow steps come next or answering questions about what to do in the BMad Method,,
-core,,Index Docs,ID,50,_bmad/core/tasks/index-docs.xml,bmad_index-docs,false,llm,,Generates or updates an index.md of all documents in the specified directory,,
-core,,Shard Document,SD,70,_bmad/core/tasks/shard-doc.xml,bmad_shard-doc,false,llm,,Splits large markdown documents into smaller organized files based on level 2 sections,,
-core,,Editorial Review - Prose,EP,80,_bmad/core/tasks/editorial-review-prose.xml,bmad_editorial-review-prose,false,llm,reader_type,Clinical copy-editor that reviews text for communication issues,,"three-column markdown table with suggested fixes",
-core,,Editorial Review - Structure,ES,90,_bmad/core/tasks/editorial-review-structure.xml,bmad_editorial-review-structure,false,llm,,Structural editor that proposes cuts reorganization and simplification while preserving comprehension,,
-core,,Adversarial Review (General),AR,100,_bmad/core/tasks/review-adversarial-general.xml,bmad_review-adversarial-general,false,llm,,Cynically review content and produce findings,,
+core,,Brainstorming,BS,20,_bmad/core/workflows/brainstorming/workflow.md,bmad-brainstorming,false,analyst,,Facilitate interactive brainstorming sessions using diverse creative techniques and ideation methods,{output_folder}/brainstorming/brainstorming-session-{{date}}.md,,
+core,,Party Mode,PM,30,_bmad/core/workflows/party-mode/workflow.md,bmad-party-mode,false,party-mode facilitator,,Orchestrates group discussions between all installed BMAD agents enabling natural multi-agent conversations,,
+core,,bmad-help,BH,40,_bmad/core/tasks/help.md,bmad-help,false,,,Get unstuck by showing what workflow steps come next or answering questions about what to do in the BMad Method,,
+core,,Index Docs,ID,50,_bmad/core/tasks/index-docs.xml,bmad-index-docs,false,,,Generates or updates an index.md of all documents in the specified directory,,
+core,,Shard Document,SD,70,_bmad/core/tasks/shard-doc.xml,bmad-shard-doc,false,,,Splits large markdown documents into smaller organized files based on level 2 sections,,
+core,,Editorial Review - Prose,EP,80,_bmad/core/tasks/editorial-review-prose.xml,bmad-editorial-review-prose,false,,,Clinical copy-editor that reviews text for communication issues,,"three-column markdown table with suggested fixes",
+core,,Editorial Review - Structure,ES,90,_bmad/core/tasks/editorial-review-structure.xml,bmad-editorial-review-structure,false,,,Structural editor that proposes cuts reorganization and simplification while preserving comprehension,,
+core,,Adversarial Review (General),AR,100,_bmad/core/tasks/review-adversarial-general.xml,bmad-review-adversarial-general,false,,,Cynically review content and produce findings,,

tools/cli/installers/lib/core/installer.js

@@ -999,6 +999,9 @@ class Installer {
 
       // Configure IDEs and copy documentation
       if (!config.skipIde && config.ides && config.ides.length > 0) {
+        // Ensure IDE manager is initialized (handlers may not be loaded in quick update flow)
+        await this.ideManager.ensureInitialized();
+
         // Filter out any undefined/null values from the IDE list
         const validIdes = config.ides.filter((ide) => ide && typeof ide === 'string');
 

tools/cli/installers/lib/ide/shared/task-tool-command-generator.js

@@ -76,7 +76,7 @@ description: '${description.replaceAll("'", "''")}'
 
 # ${item.displayName || item.name}
 
-LOAD and execute the ${type} at: ${itemPath}
+Read the entire ${type} file at: ${itemPath}
 
 Follow all instructions in the ${type} file exactly as written.
 `;

tools/cli/installers/lib/ide/templates/combined/antigravity.md

@@ -1,6 +1,8 @@
+---
 name: '{{name}}'
 description: '{{description}}'
+---
 
-LOAD and execute the workflow at: {project-root}/_bmad/{{workflow_path}}
+Read the entire workflow file at: {project-root}/_bmad/{{workflow_path}}
 
 Follow all instructions in the workflow file exactly as written.

tools/cli/installers/lib/ide/templates/combined/rovodev.md

@@ -4,6 +4,6 @@
 
 ---
 
-LOAD and execute the workflow at: {project-root}/_bmad/{{workflow_path}}
+Read the entire workflow file at: {project-root}/_bmad/{{workflow_path}}
 
 Follow all instructions in the workflow file exactly as written.

tools/cli/installers/lib/ide/templates/combined/trae.md

@@ -4,6 +4,6 @@
 
 ## Instructions
 
-LOAD and execute the workflow at: {project-root}/_bmad/{{workflow_path}}
+Read the entire workflow file at: {project-root}/_bmad/{{workflow_path}}
 
 Follow all instructions in the workflow file exactly as written.

tools/cli/installers/lib/ide/templates/combined/windsurf-workflow.md

@@ -5,6 +5,6 @@ auto_execution_mode: "iterate"
 
 # {{name}}
 
-LOAD and execute the workflow at: {project-root}/_bmad/{{workflow_path}}
+Read the entire workflow file at {project-root}/_bmad/{{workflow_path}}
 
 Follow all instructions in the workflow file exactly as written.

tools/cli/lib/ui.js

@@ -81,7 +81,7 @@ class UI {
       hasLegacyCfg = bmadResult.hasLegacyCfg;
     }
 
-    // Handle legacy .bmad or _cfg folder - these are very old (more than 2 versions behind)
+    // Handle legacy .bmad or _cfg folder - these are very old (v4 or alpha)
     // Show version warning instead of offering conversion
     if (hasLegacyBmadFolder || hasLegacyCfg) {
       console.log('');
@@ -92,9 +92,8 @@ class UI {
           'Found a ".bmad"/"bmad" folder, or a legacy "_cfg" folder under the bmad folder - this is from a old BMAD version that is out of date for automatic upgrade, manual intervention required.',
         ),
       );
-      console.log(chalk.yellow('This version is more than 2 alpha versions behind current.'));
+      console.log(chalk.yellow('You have a legacy version installed (v4 or alpha).'));
       console.log('');
-      console.log(chalk.dim('For stability, we only support updates from the previous 2 alpha versions.'));
       console.log(chalk.dim('Legacy installations may have compatibility issues.'));
       console.log('');
       console.log(chalk.dim('For the best experience, we strongly recommend:'));
@@ -188,8 +187,8 @@ class UI {
       const currentVersion = require(packageJsonPath).version;
       const installedVersion = existingInstall.version || 'unknown';
 
-      // Check if version is too old and warn user
-      const shouldProceed = await this.showOldAlphaVersionWarning(installedVersion, currentVersion, path.basename(bmadDir));
+      // Check if version is pre beta
+      const shouldProceed = await this.showLegacyVersionWarning(installedVersion, currentVersion, path.basename(bmadDir));
 
       // If user chose to cancel, exit the installer
       if (!shouldProceed) {
@@ -1457,96 +1456,40 @@ class UI {
   }
 
   /**
-   * Parse alpha version string (e.g., "6.0.0-Alpha.20")
-   * @param {string} version - Version string
-   * @returns {Object|null} Object with alphaNumber and fullVersion, or null if invalid
-   */
-  parseAlphaVersion(version) {
-    if (!version || version === 'unknown') {
-      return null;
-    }
-
-    // Remove 'v' prefix if present
-    const cleanVersion = version.toString().replace(/^v/i, '');
-
-    // Match alpha version pattern: X.Y.Z-Alpha.N (case-insensitive)
-    const match = cleanVersion.match(/[\d.]+-Alpha\.(\d+)/i);
-
-    if (!match) {
-      return null;
-    }
-
-    return {
-      alphaNumber: parseInt(match[1], 10),
-      fullVersion: cleanVersion,
-    };
-  }
-
-  /**
-   * Check if installed version is more than 2 alpha versions behind current
+   * Check if installed version is a legacy version that needs fresh install
    * @param {string} installedVersion - The installed version
-   * @param {string} currentVersion - The current version
-   * @returns {Object} Object with { isOldVersion, versionDiff, shouldWarn, installed, current }
+   * @returns {boolean} True if legacy (v4 or any alpha)
    */
-  checkAlphaVersionAge(installedVersion, currentVersion) {
-    const installed = this.parseAlphaVersion(installedVersion);
-    const current = this.parseAlphaVersion(currentVersion);
-
-    // If we can't parse either version, don't warn
-    if (!installed || !current) {
-      return { isOldVersion: false, versionDiff: 0, shouldWarn: false };
+  isLegacyVersion(installedVersion) {
+    if (!installedVersion || installedVersion === 'unknown') {
+      return true; // Treat unknown as legacy for safety
     }
-
-    // Calculate alpha version difference
-    const versionDiff = current.alphaNumber - installed.alphaNumber;
-
-    // Consider it old if more than 2 versions behind
-    const isOldVersion = versionDiff > 2;
-
-    return {
-      isOldVersion,
-      versionDiff,
-      shouldWarn: isOldVersion,
-      installed: installed.fullVersion,
-      current: current.fullVersion,
-      installedAlpha: installed.alphaNumber,
-      currentAlpha: current.alphaNumber,
-    };
+    // Check if version string contains -alpha or -Alpha (any v6 alpha)
+    return /-alpha\./i.test(installedVersion);
   }
 
   /**
-   * Show warning for old alpha version and ask if user wants to proceed
+   * Show warning for legacy version (v4 or alpha) and ask if user wants to proceed
    * @param {string} installedVersion - The installed version
    * @param {string} currentVersion - The current version
    * @param {string} bmadFolderName - Name of the BMAD folder
    * @returns {Promise<boolean>} True if user wants to proceed, false if they cancel
    */
-  async showOldAlphaVersionWarning(installedVersion, currentVersion, bmadFolderName) {
-    const versionInfo = this.checkAlphaVersionAge(installedVersion, currentVersion);
-
-    // Also warn if version is unknown or can't be parsed (legacy/unsupported)
-    const isUnknownVersion = installedVersion === 'unknown' || !versionInfo.installed;
-
-    if (!versionInfo.shouldWarn && !isUnknownVersion) {
-      return true; // Not old, proceed
+  async showLegacyVersionWarning(installedVersion, currentVersion, bmadFolderName) {
+    if (!this.isLegacyVersion(installedVersion)) {
+      return true; // Not legacy, proceed
     }
 
     console.log('');
     console.log(chalk.yellow.bold('⚠️  VERSION WARNING'));
     console.log(chalk.yellow('─'.repeat(80)));
 
-    if (isUnknownVersion) {
+    if (installedVersion === 'unknown') {
       console.log(chalk.yellow('Unable to detect your installed BMAD version.'));
       console.log(chalk.yellow('This appears to be a legacy or unsupported installation.'));
-      console.log('');
-      console.log(chalk.dim('For stability, we only support updates from the previous 2 alpha versions.'));
-      console.log(chalk.dim('Legacy installations may have compatibility issues.'));
     } else {
-      console.log(chalk.yellow(`You are updating from ${versionInfo.installed} to ${versionInfo.current}.`));
-      console.log(chalk.yellow(`This is ${versionInfo.versionDiff} alpha versions behind.`));
-      console.log('');
-      console.log(chalk.dim(`For stability, we only support updates from the previous 2 alpha versions`));
-      console.log(chalk.dim(`(Alpha.${versionInfo.currentAlpha - 2} through Alpha.${versionInfo.currentAlpha - 1}).`));
+      console.log(chalk.yellow(`You are updating from ${installedVersion} to ${currentVersion}.`));
+      console.log(chalk.yellow('You have a legacy version installed (v4 or alpha).'));
     }
 
     console.log('');