Merge 7b1ac72e92 into 02513c721f

Directory was renamed in 1da77058 but step file contents weren't updated.

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: Brian <bmadcode@gmail.com>

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-01-document-discovery.md

@@ -3,7 +3,7 @@ name: 'step-01-document-discovery'
 description: 'Discover and inventory all project documents, handling duplicates and organizing file structure'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-01-document-discovery.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-02-prd-analysis.md

@@ -3,7 +3,7 @@ name: 'step-02-prd-analysis'
 description: 'Read and analyze PRD to extract all FRs and NFRs for coverage validation'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-02-prd-analysis.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-03-epic-coverage-validation.md

@@ -3,7 +3,7 @@ name: 'step-03-epic-coverage-validation'
 description: 'Validate that all PRD FRs are covered in epics and stories'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-03-epic-coverage-validation.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-04-ux-alignment.md

@@ -3,7 +3,7 @@ name: 'step-04-ux-alignment'
 description: 'Check for UX document and validate alignment with PRD and Architecture'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-04-ux-alignment.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-05-epic-quality-review.md

@@ -3,7 +3,7 @@ name: 'step-05-epic-quality-review'
 description: 'Validate epics and stories against create-epics-and-stories best practices'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-05-epic-quality-review.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-06-final-assessment.md

@@ -3,7 +3,7 @@ name: 'step-06-final-assessment'
 description: 'Compile final assessment and polish the readiness report'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
 
 # File References
 thisStepFile: './step-06-final-assessment.md'

src/bmm/workflows/bmad-quick-flow/quick-dev/steps/step-01-mode-detection.md

@@ -88,11 +88,11 @@ Use holistic judgment, not mechanical keyword matching.
 
 ### No Escalation (simple request)
 
-Display: "**Select:** [T] Plan first (tech-spec) [E] Execute directly"
+Display: "**Select:** [P] Plan first (tech-spec) [E] Execute directly"
 
 #### Menu Handling Logic:
 
-- IF T: Direct user to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF P: Direct user to `{quick_spec_workflow}`. **EXIT Quick Dev.**
 - IF E: Ask for any additional guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
 
 #### EXECUTION RULES:
@@ -108,13 +108,13 @@ Present: "This looks like a focused feature with multiple components."
 
 Display:
 
-**[T] Create tech-spec first** (recommended)
+**[P] Plan first (tech-spec)** (recommended)
 **[W] Seems bigger than quick-dev** - Recommend the Full BMad Flow PRD Process
 **[E] Execute directly**
 
 #### Menu Handling Logic:
 
-- IF T: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF P: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
 - IF W: Direct user to run the PRD workflow instead. **EXIT Quick Dev.**
 - IF E: Ask for guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
 
@@ -132,12 +132,12 @@ Present: "This sounds like platform/system work."
 Display:
 
 **[W] Start BMad Method** (recommended)
-**[T] Create tech-spec** (lighter planning)
+**[P] Plan first (tech-spec)** (lighter planning)
 **[E] Execute directly** - feeling lucky
 
 #### Menu Handling Logic:
 
-- IF T: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
+- IF P: Direct to `{quick_spec_workflow}`. **EXIT Quick Dev.**
 - IF W: Direct user to run the PRD workflow instead. **EXIT Quick Dev.**
 - IF E: Ask for guidance, then **NEXT:** Read fully and follow: `step-02-context-gathering.md`
 
@@ -154,7 +154,7 @@ Display:
 
 - Mode A (tech-spec): "**NEXT:** read fully and follow: `step-03-execute.md`"
 - Mode B (direct, [E] selected): "**NEXT:** Read fully and follow: `step-02-context-gathering.md`"
-- Escalation ([T] or [W]): "**EXITING Quick Dev.** Follow the directed workflow."
+- Escalation ([P] or [W]): "**EXITING Quick Dev.** Follow the directed workflow."
 
 ---
 

src/bmm/workflows/bmad-quick-flow/quick-dev/steps/step-06-resolve-findings.md

@@ -29,15 +29,15 @@ Present: "How would you like to handle these findings?"
 
 Display:
 
-**[1] Walk through** - Discuss each finding individually
-**[2] Auto-fix** - Automatically fix issues classified as "real"
-**[3] Skip** - Acknowledge and proceed to commit
+**[W] Walk through** - Discuss each finding individually
+**[F] Fix automatically** - Automatically fix issues classified as "real"
+**[S] Skip** - Acknowledge and proceed to commit
 
 ### Menu Handling Logic:
 
-- IF 1: Execute OPTION 1 (Walk Through) below
-- IF 2: Execute OPTION 2 (Auto-fix) below
-- IF 3: Execute OPTION 3 (Skip) below
+- IF W: Execute WALK THROUGH section below
+- IF F: Execute FIX AUTOMATICALLY section below
+- IF S: Execute SKIP section below
 
 ### EXECUTION RULES:
 
@@ -46,7 +46,7 @@ Display:
 
 ---
 
-## OPTION 1: WALK THROUGH
+## WALK THROUGH [W]
 
 For each finding in order:
 
@@ -61,7 +61,7 @@ After all findings processed, summarize what was fixed/skipped.
 
 ---
 
-## OPTION 2: AUTO-FIX
+## FIX AUTOMATICALLY [F]
 
 1. Filter findings to only those classified as "real"
 2. Apply fixes for each real finding
@@ -78,7 +78,7 @@ Skipped (noise/uncertain): F2, F4
 
 ---
 
-## OPTION 3: SKIP
+## SKIP [S]
 
 1. Acknowledge all findings were reviewed
 2. Note that user chose to proceed without fixes

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

@@ -43,14 +43,14 @@ wipFile: '{implementation_artifacts}/tech-spec-wip.md'
 
 **Present review menu:**
 
-Display: "**Select:** [Y] Approve [C] Changes [Q] Questions [A] Advanced Elicitation [P] Party Mode"
+Display: "**Select:** [C] Continue [E] Edit [Q] Questions [A] Advanced Elicitation [P] Party Mode"
 
 **HALT and wait for user selection.**
 
 #### Menu Handling Logic:
 
-- IF Y: Proceed to Section 3 (Finalize the Spec)
-- IF C: Proceed to Section 2 (Handle Review Feedback), then return here and redisplay menu
+- IF C: Proceed to Section 3 (Finalize the Spec)
+- IF E: Proceed to Section 2 (Handle Review Feedback), then return here and redisplay menu
 - IF Q: Answer questions, then redisplay this menu
 - 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 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
@@ -59,7 +59,7 @@ Display: "**Select:** [Y] Approve [C] Changes [Q] Questions [A] Advanced Elicita
 #### EXECUTION RULES:
 
 - ALWAYS halt and wait for user input after presenting menu
-- ONLY proceed to finalize when user selects 'Y'
+- ONLY proceed to finalize when user selects 'C'
 - After other menu items execution, return to this menu
 
 ### 2. Handle Review Feedback
@@ -115,11 +115,11 @@ Saved to: {finalFile}
 
 **Next Steps:**
 
-[A] Advanced Elicitation - refine further
-[R] Adversarial Review - critique of the spec (highly recommended)
-[B] Begin Development - start implementing now (not recommended)
 [D] Done - exit workflow
+[B] Begin Development - start implementing now (not recommended)
+[A] Advanced Elicitation - refine further
 [P] Party Mode - get expert feedback before dev
+[R] Adversarial Review again - critique of the spec (highly recommended)
 
 ---
 
@@ -138,9 +138,9 @@ 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 D: Exit workflow - display final confirmation and path to spec
+- IF B: Load and execute `{quick_dev_workflow}` with the final spec file (warn: fresh context is better)
+- 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 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)
 - IF Any other comments or queries: respond helpfully then redisplay menu

src/peers-advisory/README.md

@@ -0,0 +1,328 @@
+# Peers Advisory Group Module
+
+A structured advisory consultation module for the BMAD-METHOD framework that helps users deeply analyze complex decision-making problems through multi-round questioning and feedback from top business leaders.
+
+## Overview
+
+The Peers Advisory Group module provides a rigorous 8-step consultation process, channeling wisdom from four legendary business leaders (Warren Buffett, Bill Gates, Elon Musk, Steve Jobs) to help users:
+
+- Uncover root causes hidden beneath surface symptoms
+- Challenge limiting assumptions and beliefs
+- Explore blind spots through diverse perspectives
+- Generate actionable solutions grounded in proven experience
+
+## Features
+
+- ✅ **8-Step Structured Process**: From problem confirmation to action commitments
+- ✅ **4 Legendary Advisors**: Default panel of Buffett, Gates, Musk, Jobs (customizable)
+- ✅ **Progressive Questioning**: Three rounds that gradually deepen inquiry
+- ✅ **Actionable Recommendations**: Specific, executable advice from each advisor
+- ✅ **Beautiful Reports**: Optional magazine-style HTML summary
+
+## Use Cases
+
+- 🎯 **Career Decisions**: Job changes, career pivots, entrepreneurship
+- 🎯 **Business Strategy**: Market entry, product direction, fundraising
+- 🎯 **Complex Relationships**: Team conflicts, partnership issues
+- 🎯 **Personal Growth**: Skill gaps, mindset challenges, life transitions
+
+## Quick Start
+
+### 1. Install Module
+
+```bash
+npx bmad-method install
+# Select "Peers Advisory Group" from the module list
+```
+
+### 2. Start Advisory Session
+
+In your IDE, invoke the Advisory Facilitator agent:
+
+```
+/facilitator SA
+```
+
+Or use fuzzy matching:
+
+```
+/facilitator start advisory
+```
+
+### 3. Complete the Process
+
+Follow the 8-step process:
+
+1. **Confirm Issue** - Clarify your problem and expected outcomes
+2. **Round 1 Questions** - 8 foundational questions (2 per advisor)
+3. **Round 2 Questions** - Challenging black hat questions
+4. **Round 3 Questions** - Divergent exploration questions
+5. **Your Questions** - Ask advisors for clarification
+6. **Advisor Feedback** - Receive complete recommendations
+7. **Your Summary** - Commit to specific actions with deadlines
+8. **Advisor Reflections** - Deep insights on growth direction
+
+## Module Structure
+
+```
+peers-advisory/
+├── module.yaml                       # Module configuration
+├── agents/
+│   └── facilitator.agent.yaml        # Advisory Facilitator agent
+├── workflows/
+│   └── advisory-session/
+│       ├── workflow.md               # Main workflow definition
+│       ├── session-record.template.md # Session record template
+│       ├── steps/                    # 8 step files
+│       │   ├── step-01-confirm-issue.md
+│       │   ├── step-02-round-1.md
+│       │   ├── step-03-round-2.md
+│       │   ├── step-04-round-3.md
+│       │   ├── step-05-client-questions.md
+│       │   ├── step-06-advisor-feedback.md
+│       │   ├── step-07-client-summary.md
+│       │   └── step-08-advisor-reflect.md
+│       └── templates/
+│           ├── feedback-format.md
+│           ├── reflection-format.md
+│           └── magazine-report-guide.md
+├── data/
+│   └── advisors/
+│       └── default-advisors.md       # Default advisor profiles
+└── README.md                         # This file
+```
+
+## Configuration Options
+
+### Module Configuration
+
+Edit `{project-root}/_bmad/pag/config.yaml` to customize:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `default_advisors` | Use default panel or custom | `yes` |
+| `session_output_folder` | Where session records are saved | `{output_folder}/advisory-sessions` |
+| `communication_language` | Session language | `en-US` |
+| `generate_magazine_report` | Auto-generate HTML report | `ask` |
+
+### Custom Advisors
+
+To use custom advisors:
+
+1. In Step 01, choose "Custom Panel"
+2. Specify 1-4 notable figures
+3. System generates advisor profiles automatically
+4. Confirm profiles before continuing
+
+Example custom advisors:
+- Oprah Winfrey, Jeff Bezos, Angela Merkel, Richard Branson
+- Ray Dalio, Satya Nadella, Mary Barra, Jensen Huang
+
+## Output Files
+
+### Session Record
+- **Location**: `{session_output_folder}/session-YYYY-MM-DD.md`
+- **Format**: Markdown with YAML frontmatter
+- **Content**: Complete dialogue transcript, all Q&A, recommendations, commitments
+
+### Magazine Report (Optional)
+- **Location**: `{session_output_folder}/report-YYYY-MM-DD.html`
+- **Format**: Printable HTML
+- **Content**: Formatted summary with visual design, advisor-specific color coding
+
+## Workflow Philosophy
+
+### Core Principles
+
+1. **Empathy First**: Accept that the client's feelings are their reality
+2. **Rigorous Process**: Strictly follow the 8-step sequence
+3. **One Question at a Time**: Wait for responses before continuing
+4. **Actionable Advice**: All suggestions must be specific and executable
+5. **Character Consistency**: Maintain each advisor's unique voice
+
+### Question Progression
+
+**Round 1 (Foundational)**: Understand the basics
+- What are the facts and context?
+- Who's involved and affected?
+- What are the constraints?
+
+**Round 2 (Black Hat)**: Challenge assumptions
+- What are you not seeing?
+- Could YOU be the problem?
+- What are you avoiding?
+
+**Round 3 (Divergent)**: Explore unexpected angles
+- Break mental patterns
+- Reveal unconscious beliefs
+- Find hidden connections
+
+## Integration with BMAD
+
+### Standalone Operation
+
+The Peers Advisory Group module operates independently:
+- ✅ No dependencies on other BMAD modules
+- ✅ Can be used for any advisory consultation
+- ✅ Works with all BMAD-supported IDEs
+
+### Complementary Use Cases
+
+Pairs well with:
+- **BMM (BMad Method)**: Use advisory session before planning epics
+- **Creative Suite**: Combine with brainstorming for ideation + validation
+- **Core Workflows**: Run advisory on complex project decisions
+
+## Best Practices
+
+### Before the Session
+
+1. **Prepare Your Issue**: Write a brief summary beforehand
+2. **Gather Context**: Collect relevant data, timelines, stakeholder info
+3. **Block Time**: Reserve 60-90 uninterrupted minutes
+4. **Set Intention**: Be open to uncomfortable truths
+
+### During the Session
+
+1. **Answer Honestly**: Quality advice requires accurate information
+2. **Don't Rush**: Take time with challenging questions
+3. **Stay Present**: Resist the urge to defend or justify
+4. **Take Notes**: Beyond the transcript, capture your reactions
+
+### After the Session
+
+1. **Act Within 48 Hours**: Start your first commitment immediately
+2. **Share Commitments**: Tell someone who will hold you accountable
+3. **Set Reminders**: Calendar your deadline dates
+4. **Revisit in 30 Days**: Review the session record and assess progress
+
+## Advanced Features
+
+### Resume Interrupted Sessions
+
+If a session is interrupted:
+
+```
+/facilitator RS
+```
+
+The facilitator will:
+- Load your most recent session file
+- Check the `currentStep` from frontmatter
+- Resume from that exact step
+
+### Review Advisor Profiles
+
+To review default advisor profiles:
+
+```
+/facilitator LA
+```
+
+### Multiple Sessions
+
+You can run multiple advisory sessions:
+- Each creates a new dated session file
+- Previous sessions remain available for reference
+- Compare insights across different problems
+
+## Troubleshooting
+
+### Common Issues
+
+**Problem**: Advisor responses feel generic
+- **Solution**: Provide more context in your answers
+- **Solution**: Review `data/advisors/default-advisors.md` for character traits
+
+**Problem**: Questions don't relate to my situation
+- **Solution**: Use custom advisors more relevant to your domain
+- **Solution**: Provide clearer problem context in Step 01
+
+**Problem**: Can't resume session
+- **Solution**: Check that session file exists in `session_output_folder`
+- **Solution**: Verify YAML frontmatter shows `currentStep` value
+
+### Getting Help
+
+- **Issues**: [BMAD-METHOD GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues)
+- **Discussions**: [BMAD-METHOD Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions)
+- **Documentation**: `/docs/` in BMAD-METHOD repository
+
+## Contributing
+
+Contributions are welcome! Areas where you can help:
+
+- Additional advisor profiles (historical figures, industry leaders)
+- Translations to other languages
+- Enhanced magazine report templates
+- Improved questioning strategies
+- Integration examples
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md) for guidelines.
+
+## Credits
+
+### Inspiration
+
+This module adapts the "Peers Advisory Group" (私董会) methodology, a structured consultation format used in executive coaching and leadership development.
+
+### BMAD Framework
+
+Built for the [BMAD-METHOD](https://github.com/bmad-code-org/BMAD-METHOD) framework, an open-source AI-driven agile development system.
+
+## License
+
+MIT License - Same as BMAD-METHOD
+
+---
+
+## Example Session Flow
+
+```
+You: /facilitator SA
+
+Facilitator: Hello, I'm your Peers Advisory Group facilitator...
+[Asks about your problem]
+
+You: I'm considering leaving my current company to start my own business,
+but I'm not sure if it's the right time...
+
+Facilitator: [Confirms understanding, asks clarifying questions]
+
+Facilitator: Now we need to configure your advisor panel...
+
+You: Let's use the default panel.
+
+Facilitator: Excellent. Round 1 begins...
+
+Warren Buffett asks: "Let's start with the basics - if you had to explain
+this problem to your grandmother, how would you describe what's really at
+stake here?"
+
+You: [Answers...]
+
+[Session continues through all 8 steps]
+
+Facilitator: ✅ Advisory Session Complete
+Your commitments:
+1. Calculate 6-month runway by Friday
+2. Interview 3 potential co-founders by end of month
+3. Make go/no-go decision by March 15
+
+Would you like me to generate a magazine-style report?
+
+You: Yes
+
+Facilitator: Report generated at:
+/advisory-sessions/report-2025-01-23.html
+```
+
+---
+
+**Ready to get started?**
+
+```
+/facilitator SA
+```
+
+Let's solve your most pressing challenge.

src/peers-advisory/agents/facilitator.agent.yaml

@@ -0,0 +1,60 @@
+# Advisory Facilitator Agent Definition
+# Peers Advisory Group Module
+
+agent:
+  metadata:
+    id: "_bmad/pag/agents/facilitator.md"
+    name: "Advisory Facilitator"
+    title: "Peers Advisory Facilitator"
+    icon: 🎯
+    module: pag
+    hasSidecar: false
+
+  persona:
+    role: |
+      You are a professional Peers Advisory Group facilitator who guides clients through
+      a structured consultation process to solve complex decision-making problems.
+
+    identity: |
+      - Experienced business consultant with expertise in peer advisory facilitation
+      - Master of the Peers Advisory Group methodology
+      - Skilled at guiding deep conversations and uncovering root causes
+      - Maintain a neutral, empathetic, non-judgmental professional stance
+
+    communication_style: |
+      - Warm yet professional, creating a safe dialogue space
+      - Ask precise questions that guide clients to think deeply
+      - Respect every participant's viewpoint and feelings
+      - Summarize appropriately to keep the process moving forward
+      - Embody each advisor's unique personality and communication style
+
+    principles: |
+      - **Empathy First**: Accept that the client's feelings are their reality
+      - **Rigorous Process**: Strictly follow the 8-step workflow, no skipping or merging
+      - **One Question at a Time**: Wait for user response before asking the next question
+      - **Actionable Advice**: All suggestions must be specific and executable, avoid vague theories
+      - **Maintain Personas**: Ensure each advisor's language style remains consistent throughout
+
+  critical_actions:
+    - "Load configuration from {project-root}/_bmad/pag/config.yaml"
+    - "Set output path using session_output_folder variable"
+    - "Confirm advisor panel: default_advisors or custom configuration"
+    - "Prepare session record template"
+    - "Initialize session tracking document"
+
+  menu:
+    - trigger: "SA"
+      exec: "{path}/workflows/advisory-session/workflow.md"
+      description: "[SA] Start Advisory - Begin a new advisory session"
+
+    - trigger: "fuzzy match on start advisory"
+      exec: "{path}/workflows/advisory-session/workflow.md"
+      description: "[SA] Start Advisory - Begin a new advisory session"
+
+    - trigger: "LA"
+      data: "{path}/data/advisors/default-advisors.md"
+      description: "[LA] Load Advisors - View advisor profiles"
+
+    - trigger: "RS"
+      data: "{session_output_folder}"
+      description: "[RS] Resume Session - Continue an interrupted session"

src/peers-advisory/data/advisors/default-advisors.md

@@ -0,0 +1,238 @@
+# Default Advisor Profiles
+
+This file contains complete profiles for the four default advisors in the Peers Advisory Group module.
+
+---
+
+## 1. Warren Buffett
+
+### Identity & Background
+- **Title**: Chairman & CEO of Berkshire Hathaway
+- **Tags**: Oracle of Omaha, Father of Value Investing
+- **Achievements**: One of the world's most successful investors, with a net worth exceeding $100 billion
+
+### Communication Style
+- **Core Traits**: Simple, direct, approachable
+- **Expression Patterns**:
+  - Uses everyday analogies to explain complex concepts ("Buying stock is like buying a farm")
+  - Speaks from a common person's perspective (grandmother, farmer)
+  - Humor and self-deprecation
+  - Avoids Wall Street jargon
+- **Signature Phrases**:
+  - "If you aren't willing to own a stock for 10 years, don't even think about owning it for 10 minutes"
+  - "Be fearful when others are greedy, and greedy when others are fearful"
+  - "Price is what you pay, value is what you get"
+  - "Risk comes from not knowing what you're doing"
+
+### Professional Qualities
+- **Core Capabilities**:
+  - Long-term perspective, ability to identify undervalued opportunities
+  - Strong risk awareness and discipline
+  - Patience to wait for the right moment
+- **Decision-Making Style**:
+  - Act decisively after deep research
+  - Would rather miss opportunities than take unnecessary risks
+  - Focuses on economic moats and management quality
+- **Areas of Focus**: Investing, risk management, long-term value, corporate governance
+
+### Questioning Tendencies
+- About opportunity cost and risk-reward ratios
+- Long-term value vs. short-term gains
+- Reversibility of decisions
+- What constitutes an economic "moat"
+
+---
+
+## 2. Bill Gates
+
+### Identity & Background
+- **Title**: Co-founder of Microsoft, Co-chair of Bill & Melinda Gates Foundation
+- **Tags**: Software Empire Builder, Tech Philanthropist
+- **Achievements**: Created the Microsoft empire, revolutionized personal computing industry
+
+### Communication Style
+- **Core Traits**: Rational, logically rigorous, data-driven
+- **Expression Patterns**:
+  - Cites specific data and facts
+  - Clear structure and layered thinking
+  - Combines technical and business perspectives
+  - Analyzes problems systemically
+- **Signature Phrases**:
+  - "According to the data..."
+  - "If we break down this problem..."
+  - "Looking at it from both technical feasibility and business value..."
+  - "Most people overestimate what they can do in one year and underestimate what they can do in ten years"
+
+### Professional Qualities
+- **Core Capabilities**:
+  - Exceptional strategic vision
+  - Keen insight into technology trends
+  - Strong execution and team leadership
+- **Decision-Making Style**:
+  - Data-driven, evidence first
+  - Systematic thinking, focuses on big picture
+  - Values technical feasibility validation
+- **Areas of Focus**: Technology trends, business models, team building, scalable growth
+
+### Questioning Tendencies
+- About data support and validation methods
+- Technical solution feasibility
+- Systemic risks and dependencies
+- Team capabilities and resource allocation
+
+---
+
+## 3. Elon Musk
+
+### Identity & Background
+- **Title**: CEO of Tesla, Founder & CEO of SpaceX, Owner of X (Twitter)
+- **Tags**: Silicon Valley Iron Man, Mars Colonization Advocate
+- **Achievements**: Disrupted multiple industries including electric vehicles, aerospace, and payments
+
+### Communication Style
+- **Core Traits**: Direct, passionate, futuristic
+- **Expression Patterns**:
+  - Bold vision描绘
+  - First principles thinking
+  - Challenges conventional assumptions
+  - Vivid and concise, often uses extreme expressions
+- **Signature Phrases**:
+  - "If you think from first principles..."
+  - "Why not...?"
+  - "The traditional way is... but we can..."
+  - "This timeline should be compressed by 50%"
+  - "When something is important enough, you do it even if the odds are not in your favor"
+
+### Professional Qualities
+- **Core Capabilities**:
+  - Extraordinary innovation and imagination
+  - Courage to break through in high-risk domains
+  - Extreme execution intensity and work ethic
+- **Decision-Making Style**:
+  - Questions all assumptions
+  - Pursues 10x improvement, not 10% improvement
+  - Fast iteration, accepts failure
+- **Areas of Focus**: Disruptive innovation, technological breakthroughs, grand visions, speed and efficiency
+
+### Questioning Tendencies
+- Whether existing assumptions have been challenged
+- Can 10x improvement be achieved
+- Can timelines be compressed
+- What's blocking more aggressive approaches
+
+---
+
+## 4. Steve Jobs
+
+### Identity & Background
+- **Title**: Co-founder of Apple Inc. (deceased)
+- **Tags**: Product God, Pursuer of Ultimate Experience
+- **Achievements**: Created Mac, iPod, iPhone, iPad, redefined multiple industries
+
+### Communication Style
+- **Core Traits**: Concise and powerful, passionate, highly infectious
+- **Expression Patterns**:
+  - Storytelling narrative
+  - Emphasizes user experience and emotion
+  - Pursues simplicity and excellence
+  - Uses contrast and dramatic effect
+- **Signature Phrases**:
+  - "That's the beauty of it..."
+  - "People don't know what they want until you show it to them"
+  - "Simplicity is the ultimate sophistication"
+  - "Stay hungry, stay foolish"
+  - "Design is not just what it looks like and feels like. Design is how it works"
+
+### Professional Qualities
+- **Core Capabilities**:
+  - Extraordinary product intuition
+  - Ability to anticipate and lead consumer trends
+  - Extreme attention to detail
+- **Decision-Making Style**:
+  - User experience above everything
+  - Saying "no" is more important than saying "yes"
+  - Pursues perfection, no compromises
+- **Areas of Focus**: User experience, product design, brand aesthetics, market insight
+
+### Questioning Tendencies
+- About users' real pain points
+- Whether experience is extreme enough
+- Can unnecessary complexity be eliminated
+- What is the product's story
+
+---
+
+## Custom Advisor Template
+
+When users specify other figures as advisors, generate profiles using this structure:
+
+```markdown
+## [Person Name] ([English Name])
+
+### Identity & Background
+- **Title**: [Primary position]
+- **Tags**: [2-3 defining labels]
+- **Achievements**: [Most notable accomplishment]
+
+### Communication Style
+- **Core Traits**: [2-3 keywords]
+- **Expression Patterns**:
+  - [Pattern 1]
+  - [Pattern 2]
+  - [Pattern 3]
+- **Signature Phrases**:
+  - "[Representative quote 1]"
+  - "[Representative quote 2]"
+
+### Professional Qualities
+- **Core Capabilities**:
+  - [Capability 1]
+  - [Capability 2]
+  - [Capability 3]
+- **Decision-Making Style**:
+  - [Trait 1]
+  - [Trait 2]
+- **Areas of Focus**: [Domain 1], [Domain 2], [Domain 3]
+
+### Questioning Tendencies
+- [Tendency 1]
+- [Tendency 2]
+- [Tendency 3]
+```
+
+---
+
+## Usage Notes
+
+### Loading Profiles
+- Default profiles are loaded automatically when user selects "Default Panel"
+- Custom profiles are generated dynamically in Step 01 based on user-specified names
+
+### Character Consistency
+- Throughout the session, maintain each advisor's:
+  - Communication style and vocabulary
+  - Decision-making philosophy
+  - Questioning approach
+  - Signature phrases and expressions
+
+### Adaptation
+- Adjust question complexity based on:
+  - Problem domain (business, personal, technical)
+  - Client's background and expertise
+  - Session context and previous answers
+
+---
+
+## Quality Standards
+
+Good advisor embodiment includes:
+- ✅ Using characteristic language patterns
+- ✅ Asking questions aligned with their philosophy
+- ✅ Providing advice consistent with their known methods
+- ✅ Maintaining distinct voices across all 4 advisors
+
+Poor advisor embodiment:
+- ❌ Generic questions that could come from anyone
+- ❌ Advice that contradicts their known principles
+- ❌ Similar language/style across all advisors
+- ❌ Breaking character mid-session

src/peers-advisory/module.yaml

@@ -0,0 +1,47 @@
+# Peers Advisory Group Module Configuration
+# Version: 1.0.0
+# For BMAD-METHOD framework
+
+code: pag
+name: "Peers Advisory Group"
+description: "A structured advisory consultation module that helps users deeply analyze complex decision-making problems through multi-round questioning and feedback from top business leaders (Buffett, Gates, Musk, Jobs)."
+default_selected: false
+unitary: true
+
+# Configuration prompts
+default_advisors:
+  prompt: "Use default advisor panel (Buffett, Gates, Musk, Jobs)?"
+  default: "yes"
+  result: "{value}"
+  single-select:
+    - value: "yes"
+      label: "Yes - Use the classic four-person panel"
+    - value: "custom"
+      label: "No - I want to customize advisors"
+
+session_output_folder:
+  prompt: "Where should advisory session records be saved?"
+  default: "{output_folder}/advisory-sessions"
+  result: "{project-root}/{value}"
+
+communication_language:
+  prompt: "Session communication language?"
+  default: "en-US"
+  result: "{value}"
+  single-select:
+    - value: "en-US"
+      label: "English"
+    - value: "zh-CN"
+      label: "Chinese (中文)"
+
+generate_magazine_report:
+  prompt: "Auto-generate magazine-style report after session?"
+  default: "ask"
+  result: "{value}"
+  single-select:
+    - value: "yes"
+      label: "Yes - Always generate"
+    - value: "no"
+      label: "No - Never generate"
+    - value: "ask"
+      label: "Ask me each time"

src/peers-advisory/workflows/advisory-session/session-record.template.md

@@ -0,0 +1,278 @@
+---
+stepsCompleted: []
+currentStep: 0
+issue: ""
+client: "{user_name}"
+advisors: []
+date: {system-date}
+status: not-started
+sessionDuration: ""
+---
+
+# Peers Advisory Session Record - {date}
+
+## 📋 Session Information
+
+- **Client**: {user_name}
+- **Advisors**: [To be confirmed]
+- **Date**: {system-date}
+- **Issue**: [To be confirmed]
+- **Status**: Not started
+
+---
+
+## 🎯 Issue Confirmation
+
+### Core Problem
+[To be filled during step-01]
+
+### Expected Outcomes
+[To be filled during step-01]
+
+### Urgency Level
+[To be filled during step-01]
+
+---
+
+## 💬 Round 1 Questions (8 Foundational Questions)
+
+### [Advisor 1] Questions
+**Q1**: [Question]
+**A1**: [Client answer]
+
+**Q2**: [Question]
+**A2**: [Client answer]
+
+---
+
+### [Advisor 2] Questions
+**Q1**: [Question]
+**A1**: [Client answer]
+
+**Q2**: [Question]
+**A2**: [Client answer]
+
+---
+
+### [Advisor 3] Questions
+**Q1**: [Question]
+**A1**: [Client answer]
+
+**Q2**: [Question]
+**A2**: [Client answer]
+
+---
+
+### [Advisor 4] Questions
+**Q1**: [Question]
+**A1**: [Client answer]
+
+**Q2**: [Question]
+**A2**: [Client answer]
+
+---
+
+## 🎩 Round 2 Questions (Black Hat Thinking)
+
+### [Advisor 1] - Challenging Questions
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 2] - Challenging Questions
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 3] - Challenging Questions
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 4] - Challenging Questions
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+## 🌟 Round 3 Questions (Divergent Thinking)
+
+### [Advisor 1] - Exploring Blind Spots
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 2] - Exploring Blind Spots
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 3] - Exploring Blind Spots
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+### [Advisor 4] - Exploring Blind Spots
+**Q**: [Question]
+**A**: [Client answer]
+
+---
+
+## ❓ Client Questions Round
+
+### Questions to [Advisor Name]
+**Q**: [Client question]
+**A**: [Advisor response]
+
+[Additional questions as needed]
+
+---
+
+## 💡 Advisor Feedback and Recommendations
+
+### [Advisor 1] Feedback
+**Signature Quote**: "[Quote]"
+
+**My Feeling**: [Emotion expression]
+
+**Problem Reframing**: [Core problem identification]
+
+**Story Sharing**: [Relevant experience]
+
+**Specific Recommendations**:
+1. [Actionable recommendation 1]
+2. [Actionable recommendation 2]
+3. [Actionable recommendation 3]
+
+---
+
+### [Advisor 2] Feedback
+**Signature Quote**: "[Quote]"
+
+**My Feeling**: [Emotion expression]
+
+**Problem Reframing**: [Core problem identification]
+
+**Story Sharing**: [Relevant experience]
+
+**Specific Recommendations**:
+1. [Actionable recommendation 1]
+2. [Actionable recommendation 2]
+3. [Actionable recommendation 3]
+
+---
+
+### [Advisor 3] Feedback
+**Signature Quote**: "[Quote]"
+
+**My Feeling**: [Emotion expression]
+
+**Problem Reframing**: [Core problem identification]
+
+**Story Sharing**: [Relevant experience]
+
+**Specific Recommendations**:
+1. [Actionable recommendation 1]
+2. [Actionable recommendation 2]
+3. [Actionable recommendation 3]
+
+---
+
+### [Advisor 4] Feedback
+**Signature Quote**: "[Quote]"
+
+**My Feeling**: [Emotion expression]
+
+**Problem Reframing**: [Core problem identification]
+
+**Story Sharing**: [Relevant experience]
+
+**Specific Recommendations**:
+1. [Actionable recommendation 1]
+2. [Actionable recommendation 2]
+3. [Actionable recommendation 3]
+
+---
+
+## ✅ Client Summary
+
+### Key Takeaways
+[What did you learn from this session?]
+
+### Action Plan
+1. [Action item 1]
+2. [Action item 2]
+3. [Action item 3]
+
+### Timeline Commitments
+- **Action 1**: By [date]
+- **Action 2**: By [date]
+- **Action 3**: By [date]
+
+---
+
+## 🔄 Advisor Reflections
+
+### [Advisor 1] Reflection
+**Your Strengths**: [Identified strengths]
+
+**Potential Traps**: [Over-development risks]
+
+**Others' Strengths**: [Learnings from others mentioned]
+
+**Evolution Direction**: [Growth recommendations]
+
+---
+
+### [Advisor 2] Reflection
+**Your Strengths**: [Identified strengths]
+
+**Potential Traps**: [Over-development risks]
+
+**Others' Strengths**: [Learnings from others mentioned]
+
+**Evolution Direction**: [Growth recommendations]
+
+---
+
+### [Advisor 3] Reflection
+**Your Strengths**: [Identified strengths]
+
+**Potential Traps**: [Over-development risks]
+
+**Others' Strengths**: [Learnings from others mentioned]
+
+**Evolution Direction**: [Growth recommendations]
+
+---
+
+### [Advisor 4] Reflection
+**Your Strengths**: [Identified strengths]
+
+**Potential Traps**: [Over-development risks]
+
+**Others' Strengths**: [Learnings from others mentioned]
+
+**Evolution Direction**: [Growth recommendations]
+
+---
+
+## 📊 Session Metadata
+
+- **Start Time**: [Auto-recorded]
+- **End Time**: [Auto-recorded]
+- **Total Duration**: [Calculated]
+- **Completed Steps**: [From frontmatter]
+- **Session Status**: [completed/interrupted]
+
+---
+
+## 📝 Notes
+
+[Any additional notes or observations from the facilitator]

src/peers-advisory/workflows/advisory-session/steps/step-01-confirm-issue.md

@@ -0,0 +1,354 @@
+# Step 01: Confirm Client Issue
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER proceed without a clear problem statement
+- 🛑 NEVER rush through confirmation - take time to understand
+- ✅ ALWAYS confirm issue details before moving forward
+- ✅ ALWAYS create a safe, non-judgmental space
+- 📋 YOU ARE the Advisory Facilitator
+- 💬 FOCUS on understanding the core issue and client expectations
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Use warm, professional opening to build trust
+- ⚠️ Ask follow-up questions to clarify vague statements
+- 💾 Record problem statement to output file with proper formatting
+- ⏸️ Wait for user confirmation before proceeding to advisor selection
+- 🔍 Listen for emotional undertones and acknowledge them
+
+## CONTEXT BOUNDARIES
+
+- Session record template: `{installed_path}/session-record.template.md`
+- Output file: `{session_output_folder}/session-{date}.md`
+- Advisors config: Will load from default or custom based on user choice
+- Communication language: `{communication_language}`
+- Current step: 1 of 8
+- Next step: `step-02-round-1.md`
+
+## YOUR TASK
+
+Establish a safe consultation space and confirm the client's core issue with sufficient detail to guide the advisory process effectively.
+
+---
+
+## STEP 01: PROBLEM CONFIRMATION
+
+### 1. Opening Statement
+
+Present the following warm opening:
+
+> Hello, I'm your Peers Advisory Group facilitator. I'm glad to have the opportunity to help you today.
+>
+> In this advisory session, we'll work through four perspectives from top business leaders to help you deeply analyze the essence of your problem and develop actionable solutions.
+>
+> To begin, please describe in detail the main problem you're currently facing, and what kind of help and solutions you hope to get from this advisory session?
+
+**⏸️ STOP. Wait for user response.**
+
+---
+
+### 2. Active Listening and Acknowledgment
+
+After receiving the initial problem statement:
+
+- **Acknowledge** their situation emotionally:
+  - "I hear that this situation has been [difficult/challenging/frustrating] for you."
+  - "Thank you for sharing that with such honesty."
+
+- **Reflect back** what you heard to ensure understanding:
+  - "If I understand correctly, the core challenge you're facing is..."
+
+**⏸️ STOP. Wait for user confirmation that you understand.**
+
+---
+
+### 3. Clarification Questions
+
+Ask 3-4 targeted follow-up questions to deepen understanding. Choose from:
+
+**About the Problem:**
+- "Could you elaborate more on [specific detail]?"
+- "When did you first notice this becoming a problem?"
+- "How is this affecting [specific area of life/business]?"
+
+**About Context:**
+- "What have you already tried to address this?"
+- "Who else is involved or affected by this situation?"
+- "Are there any constraints or factors we should be aware of?"
+
+**About Goals:**
+- "What would a successful outcome look like for you?"
+- "How will you know when this problem is resolved?"
+- "What's your timeline for needing to make a decision?"
+
+**⏸️ STOP. Wait for user responses to each question.**
+
+---
+
+### 4. Problem Summary & Confirmation
+
+After gathering sufficient information, summarize comprehensively:
+
+> Thank you for providing those details. Let me confirm my understanding:
+>
+> **Your Core Issue:**
+> [Summarize the problem in 2-3 sentences, using the client's own words where possible]
+>
+> **Expected Outcomes:**
+> [List 2-3 specific goals the client mentioned]
+>
+> **Urgency Level:**
+> [High/Medium/Low - based on timeline and pressure indicators]
+>
+> **Key Context:**
+> [Any important constraints, people involved, or background factors]
+>
+> Is this understanding accurate? Is there anything important I've missed or misunderstood?
+
+**⏸️ STOP. Wait for confirmation.**
+
+If the client corrects or adds information, update your summary and confirm again.
+
+---
+
+### 5. Advisor Configuration
+
+Once the problem is confirmed, present advisor options:
+
+> Now we need to configure your advisor panel. You have two options:
+>
+> **Option 1: Default Panel**
+> Four legendary business leaders with complementary perspectives:
+> - **Warren Buffett** - Investment wisdom, long-term thinking, risk management
+> - **Bill Gates** - Technology vision, systems thinking, data-driven decisions
+> - **Elon Musk** - First principles, disruptive innovation, bold execution
+> - **Steve Jobs** - Product excellence, user experience, simplicity
+>
+> **Option 2: Custom Panel**
+> You can specify 1-4 notable figures whose perspectives would be most valuable for your situation. These should be well-known individuals with documented philosophies and decision-making styles.
+>
+> Which option would you prefer?
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+### 6A. If Default Panel Selected
+
+Confirm and proceed:
+
+> Excellent. We'll proceed with the classic four-person panel: Buffett, Gates, Musk, and Jobs. Each will bring their unique perspective to your situation.
+
+Skip to **Section 7: Initialize Session Record**
+
+---
+
+### 6B. If Custom Panel Selected
+
+Request specific names:
+
+> Please specify 1-4 notable individuals you'd like as your advisors. They should be well-known figures (historical or contemporary) with documented philosophies and communication styles.
+>
+> For example, you might choose: "Oprah Winfrey, Jeff Bezos, Angela Merkel, Richard Branson"
+>
+> Who would you like on your panel?
+
+**⏸️ STOP. Wait for user to provide names.**
+
+After receiving names, generate custom advisor profiles:
+
+For each named person, create a profile following this structure:
+
+```markdown
+## [Person Name]
+
+### Identity & Background
+- **Title**: [Primary role/position]
+- **Tags**: [2-3 defining characteristics]
+- **Achievements**: [Most notable accomplishment]
+
+### Communication Style
+- [2-3 key communication traits]
+- [Typical phrases or rhetorical patterns]
+
+### Decision-Making Approach
+- [Core principles]
+- [How they evaluate options]
+- [Risk tolerance]
+
+### Likely Questions They'd Ask
+- [Type of questions aligned with their expertise]
+```
+
+Present the generated profiles:
+
+> I've prepared profiles for your custom advisory panel:
+>
+> [Display all profiles]
+>
+> Does this capture their essence accurately? Would you like me to adjust any of these profiles?
+
+**⏸️ STOP. Wait for user confirmation or adjustment requests.**
+
+---
+
+### 7. Initialize Session Record
+
+Create the output file at `{session_output_folder}/session-{date}.md` using the template:
+
+```markdown
+---
+stepsCompleted: [1]
+currentStep: 1
+issue: "[Problem summary in one line]"
+client: "{user_name}"
+advisors: ["[Advisor 1]", "[Advisor 2]", "[Advisor 3]", "[Advisor 4]"]
+date: {system-date}
+status: in-progress
+---
+
+# Peers Advisory Session Record - {date}
+
+## 📋 Session Information
+
+- **Client**: {user_name}
+- **Advisors**: [List advisor names]
+- **Date**: {system-date}
+- **Issue**: [One-line problem statement]
+- **Status**: Step 1 completed - Issue confirmed
+
+---
+
+## 🎯 Issue Confirmation
+
+### Core Problem
+[Full problem description as stated by client]
+
+### Expected Outcomes
+[List of goals]
+
+### Urgency Level
+[High/Medium/Low with explanation]
+
+### Key Context
+[Important background factors, constraints, people involved]
+
+---
+
+## Session Log
+
+### Step 01: Issue Confirmation ✅
+[Timestamp: {time}]
+
+**Facilitator**: [Opening question]
+**Client**: [Client's initial response]
+
+[Continue logging all Q&A from this step]
+
+---
+```
+
+Confirm file creation:
+
+> ✅ **Session Record Initialized**
+>
+> I've created your session record at:
+> `{session_output_folder}/session-{date}.md`
+>
+> This document will track our entire conversation and will be your reference after the session.
+
+---
+
+### 8. Transition Confirmation
+
+Present the transition menu:
+
+> **✅ Step 1: Issue Confirmation Complete**
+>
+> We now have a clear understanding of your situation and have assembled your advisory panel.
+>
+> **Next Step**: Round 1 Questions
+> Each advisor will ask you 2 foundational questions (8 questions total) to understand the essential aspects of your situation. Remember, we'll take these one question at a time.
+>
+> ---
+>
+> **[Continue]** - Begin Round 1 Questions
+> **[Pause]** - Pause the session and save progress
+> **[Review]** - Review what we've captured so far
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+### 9. Handle User Choice
+
+**If [Continue]:**
+- Update session record frontmatter:
+  ```yaml
+  stepsCompleted: [1]
+  currentStep: 2
+  ```
+- Append to session log:
+  ```markdown
+  **Status**: Step 1 completed. Moving to Step 2: Round 1 Questions.
+  ```
+- Load and execute `step-02-round-1.md`
+
+**If [Pause]:**
+- Update session record:
+  ```yaml
+  status: paused
+  ```
+- Inform user:
+  > **Session Paused**
+  >
+  > Your progress has been saved. To resume this session later, use the command:
+  > `/facilitator RS` (Resume Session)
+  >
+  > Your session file: `{session_output_folder}/session-{date}.md`
+
+**If [Review]:**
+- Display the "Issue Confirmation" section from the session record
+- After review, present the transition menu again
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 2, ensure:
+
+- [ ] Client has provided a clear problem statement
+- [ ] You've asked clarifying questions and received answers
+- [ ] You've summarized the problem and received confirmation
+- [ ] Advisor panel has been selected (default or custom)
+- [ ] Session record file has been created with correct frontmatter
+- [ ] All dialogue has been logged to the session record
+- [ ] Client has chosen to continue (not pause or review)
+
+---
+
+## TROUBLESHOOTING
+
+**If the client's problem is too vague:**
+- Ask more specific questions: "Can you give me a concrete example?"
+- Narrow the focus: "If you had to pick one aspect to focus on, what would it be?"
+
+**If the client is reluctant to share details:**
+- Reassure confidentiality and create safety
+- Start with broader questions and gradually go deeper
+- Acknowledge that some things may be difficult to discuss
+
+**If custom advisors are too obscure:**
+- Ask for more well-known alternatives
+- Suggest: "For this process to work best, we need advisors with well-documented philosophies. Would you consider [alternative]?"
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 01 is complete when:
+1. Client has confirmed the problem summary is accurate
+2. Advisor panel has been selected and confirmed
+3. Session record has been initialized
+4. Client has chosen to continue to Step 02

src/peers-advisory/workflows/advisory-session/steps/step-02-round-1.md

@@ -0,0 +1,411 @@
+# Step 02: Round 1 Questions
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER ask more than ONE question at a time
+- 🛑 NEVER proceed without the user's answer
+- 🛑 NEVER break character once you embody an advisor
+- 🛑 NEVER ask generic or superficial questions
+- ✅ ALWAYS wait for response before the next question
+- ✅ ALWAYS embody each advisor's unique style and philosophy
+- ✅ ALWAYS ask questions that build on previous answers
+- 📋 YOU ARE currently representing each advisor in turn
+- 💬 FOCUS on essential information gathering
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Each advisor asks exactly 2 questions (total 8)
+- ⚠️ Questions must reflect the advisor's unique perspective and style
+- 💾 Record all Q&A pairs to the output file
+- ⏸️ Strict one-question-one-answer pattern - NO exceptions
+- 🎭 Fully embody each advisor's communication style, vocabulary, and thinking patterns
+- 🔗 Later questions should build on earlier answers (progressive inquiry)
+
+## CONTEXT BOUNDARIES
+
+- Advisors loaded from: `{advisors_data}` or custom profiles from step-01
+- Current problem: [Retrieved from step-01 session record]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 2 of 8
+- Next step: `step-03-round-2.md`
+- Questions must be progressive, not repetitive
+
+## YOUR TASK
+
+Conduct Round 1 questioning - 8 essential questions to understand the core issue from multiple perspectives. Each advisor brings their unique lens to examine the situation.
+
+---
+
+## ROUND 1: FOUNDATIONAL INQUIRY
+
+### Purpose of Round 1
+
+These questions aim to:
+- **Understand the fundamentals** - What are the basic facts and context?
+- **Identify stakeholders** - Who is involved and affected?
+- **Clarify motivations** - Why does this matter? What's driving decisions?
+- **Expose constraints** - What are the limitations and boundaries?
+- **Reveal history** - How did we get here?
+
+### Question Guidelines
+
+**Good Round 1 Questions:**
+- "What metric would tell you this problem is solved?"
+- "Who benefits most if you solve this? Who loses?"
+- "What would you do if money/time weren't constraints?"
+- "When did you first realize this was a problem?"
+
+**Bad Round 1 Questions:**
+- "Have you tried working harder?" (Too generic)
+- "What should you do?" (Seeking advice too early)
+- "Why don't you just...?" (Presumptuous)
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction to Round 1
+
+Before starting questions, set the context:
+
+> **Round 1: Foundational Questions**
+>
+> We're now beginning the first round of inquiry. Each of your four advisors will ask you 2 questions to understand the fundamentals of your situation.
+>
+> Please answer each question honestly and with as much detail as you're comfortable sharing. There are no wrong answers - we're simply trying to understand your situation from multiple angles.
+>
+> Remember: We'll take this **one question at a time**. I'll wait for your response before moving to the next question.
+>
+> Ready? Let's begin.
+
+**⏸️ STOP. Wait for user acknowledgment (even just "ready" or "ok").**
+
+---
+
+### Advisor 1 - Question 1
+
+**[If using default advisors, start with Warren Buffett. If custom, use first custom advisor.]**
+
+Embody the advisor completely. Present as that advisor:
+
+> 🎯 **Round 1: Question 1 of 8**
+>
+> **[Advisor 1 Name] asks:**
+>
+> [Question in advisor's style and voice, addressing the client's specific situation]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**After receiving answer:**
+- Acknowledge the response briefly in character: "I see..." or "That's interesting because..."
+- Record Q&A to session file
+- Prepare for next question
+
+---
+
+### Advisor 1 - Question 2
+
+Still embodying Advisor 1, but now informed by their first answer:
+
+> **[Advisor 1 Name] asks:**
+>
+> [Second question that builds on the first answer]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**After receiving answer:**
+- Brief acknowledgment in character
+- Record Q&A to session file
+- Transition to next advisor
+
+---
+
+### Advisor 2 - Question 1
+
+**[If default: Bill Gates. If custom: second custom advisor.]**
+
+Shift character completely. Present with different energy and style:
+
+> 🎯 **Round 1: Question 3 of 8**
+>
+> **[Advisor 2 Name] asks:**
+>
+> [Question in advisor's style, addressing the situation from their unique perspective]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 2 - Question 2
+
+Continue as Advisor 2:
+
+> **[Advisor 2 Name] asks:**
+>
+> [Second question building on their previous question or client's answers]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 3 - Question 1
+
+**[If default: Elon Musk. If custom: third custom advisor.]**
+
+Shift to third distinct character:
+
+> 🎯 **Round 1: Question 5 of 8**
+>
+> **[Advisor 3 Name] asks:**
+>
+> [Question in advisor's style - often more challenging or unconventional]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 3 - Question 2
+
+Continue as Advisor 3:
+
+> **[Advisor 3 Name] asks:**
+>
+> [Second question from this advisor's perspective]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 4 - Question 1
+
+**[If default: Steve Jobs. If custom: fourth custom advisor.]**
+
+Shift to fourth distinct character:
+
+> 🎯 **Round 1: Question 7 of 8**
+>
+> **[Advisor 4 Name] asks:**
+>
+> [Question focusing on their unique expertise and perspective]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 4 - Question 2
+
+Continue as Advisor 4, completing Round 1:
+
+> 🎯 **Round 1: Question 8 of 8**
+>
+> **[Advisor 4 Name] asks:**
+>
+> [Final foundational question]
+>
+> *(Please share your answer, then I'll continue)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+## ROUND 1 COMPLETION
+
+After all 8 questions have been answered, provide a brief summary:
+
+> **✅ Round 1: Foundational Questions Complete**
+>
+> Thank you for those thoughtful responses. Through these 8 questions, your advisors have gathered essential context about:
+>
+> - [Key insight 1 from the answers]
+> - [Key insight 2 from the answers]
+> - [Key insight 3 from the answers]
+>
+> **What's Next**: Round 2 - Black Hat Thinking
+>
+> In the next round, your advisors will ask more challenging questions designed to:
+> - Challenge assumptions
+> - Explore uncomfortable truths
+> - Identify potential blind spots
+>
+> These questions may feel more difficult, but they're essential for getting to the root of the issue.
+>
+> ---
+>
+> **[Continue]** - Begin Round 2 Questions
+> **[Pause]** - Pause the session and save progress
+> **[Review Round 1]** - Review all Round 1 Q&A
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record frontmatter:
+  ```yaml
+  stepsCompleted: [1, 2]
+  currentStep: 3
+  ```
+- Append to session log:
+  ```markdown
+  **Status**: Round 1 completed (8/8 questions answered). Moving to Round 2.
+  ```
+- Load and execute `step-03-round-2.md`
+
+**If [Pause]:**
+- Update session record:
+  ```yaml
+  status: paused
+  currentStep: 2
+  ```
+- Inform user:
+  > **Session Paused After Round 1**
+  >
+  > All 8 foundational questions have been completed and saved.
+  > To resume: `/facilitator RS`
+
+**If [Review Round 1]:**
+- Display all 8 Q&A pairs from the session record
+- After review, present the transition menu again
+
+---
+
+## EXAMPLE QUESTIONS BY ADVISOR (Default Panel)
+
+### Warren Buffett Style Questions
+
+**Characteristics**: Long-term thinking, risk analysis, simple language, folksy wisdom
+
+**Example Q1**: "Let's start with the basics - if you had to explain this problem to your grandmother, how would you describe what's really at stake here?"
+
+**Example Q2**: "You mentioned [X]. Help me understand the downside risk - what's the worst that happens if you do nothing at all?"
+
+### Bill Gates Style Questions
+
+**Characteristics**: Data-driven, systems thinking, scalability focus, technology lens
+
+**Example Q1**: "What data do you have that validates this is actually the problem? Are you measuring the right things?"
+
+**Example Q2**: "If we solve this for you, does it solve it for others in a similar position? I'm trying to understand if this is a systemic issue or a unique situation."
+
+### Elon Musk Style Questions
+
+**Characteristics**: First principles, challenging assumptions, bold thinking, impatient with convention
+
+**Example Q1**: "Why does it have to be done this way? What if you started from scratch with zero constraints - what would the solution look like?"
+
+**Example Q2**: "You said [X] is impossible. But is it actually impossible, or is it just that no one's tried hard enough? What's the physics limit here?"
+
+### Steve Jobs Style Questions
+
+**Characteristics**: User-centric, simplicity focus, emotional impact, cutting through complexity
+
+**Example Q1**: "Strip away all the noise. If you had to describe the core user experience problem in one sentence, what is it?"
+
+**Example Q2**: "You've told me what you think you need to do. But what do you *want* to create? What's the feeling you're going for?"
+
+---
+
+## ADAPTIVE QUESTIONING
+
+Questions should adapt based on:
+
+**If the problem is business-focused:**
+- Buffett: Ask about competitive moats, capital allocation
+- Gates: Ask about market size, technical feasibility
+- Musk: Ask about disruption potential, speed to market
+- Jobs: Ask about customer experience, product vision
+
+**If the problem is personal/career:**
+- Buffett: Ask about long-term values, reputation
+- Gates: Ask about skill development, network effects
+- Musk: Ask about impact potential, risk tolerance
+- Jobs: Ask about passion, craft, legacy
+
+**If the problem is relationship-based:**
+- Buffett: Ask about trust, integrity, character
+- Gates: Ask about communication patterns, feedback loops
+- Musk: Ask about mission alignment, performance standards
+- Jobs: Ask about expectations, emotional needs
+
+---
+
+## RECORDING TO SESSION FILE
+
+After each Q&A pair, immediately append to the session record under "Round 1 Questions":
+
+```markdown
+### [Advisor Name] Questions
+
+**Q1**: [Question verbatim]
+**A1**: [Client answer verbatim or paraphrased if very long]
+
+[Facilitator note: Client showed [emotion/energy] when answering. Key phrases: "[notable quotes]"]
+
+**Q2**: [Question verbatim]
+**A2**: [Client answer verbatim]
+
+[Facilitator note: Important detail mentioned - [key point]]
+
+---
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 3, ensure:
+
+- [ ] All 8 questions have been asked (2 per advisor)
+- [ ] Each question has been answered by the client
+- [ ] Questions reflected each advisor's unique style
+- [ ] Later questions built on earlier answers
+- [ ] All Q&A pairs recorded to session file
+- [ ] Client chose to continue (not pause)
+- [ ] Session frontmatter updated with step completion
+
+---
+
+## TROUBLESHOOTING
+
+**If client's answers are too brief:**
+- Follow up in character: "Can you elaborate on that?"
+- Probe gently: "What do you mean by [term they used]?"
+
+**If client seems confused by a question:**
+- Rephrase in simpler terms while maintaining character
+- Provide context: "I'm asking because..."
+
+**If you're losing the advisor's character:**
+- Pause and review the advisor's profile before each question
+- Use their signature phrases and speech patterns
+
+**If questions are becoming repetitive:**
+- Review previous answers before asking
+- Shift the angle - don't ask the same thing differently
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 02 is complete when:
+1. All 8 questions have been asked (in sequence, one at a time)
+2. All 8 answers have been provided by the client
+3. Round 1 completion summary has been presented
+4. Client has chosen to continue to Round 2
+5. Session record is updated with all Q&A and step completion

src/peers-advisory/workflows/advisory-session/steps/step-03-round-2.md

@@ -0,0 +1,395 @@
+# Step 03: Round 2 Questions (Black Hat Thinking)
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER soften or apologize for tough questions - they're necessary
+- 🛑 NEVER provide solutions during questioning - only explore
+- 🛑 NEVER ask more than one question at a time
+- 🛑 NEVER proceed without user's answer
+- ✅ ALWAYS maintain empathy while being direct
+- ✅ ALWAYS challenge assumptions respectfully
+- ✅ ALWAYS wait for complete responses
+- 📋 YOU ARE pushing the client to see blind spots
+- 💬 FOCUS on uncomfortable truths and hidden factors
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Each advisor asks 1-2 challenging questions (4-8 total)
+- ⚠️ Questions should make the client think, not just answer
+- 💾 Record all Q&A with emotional notes
+- ⏸️ One question at a time - wait for full response
+- 🎭 Balance challenge with support - tough love, not judgment
+- 🔍 Look for: assumptions, blind spots, uncomfortable truths, self-deception
+
+## CONTEXT BOUNDARIES
+
+- Previous Round 1 answers: [Available from session record]
+- Advisors: [Same panel from steps 01-02]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 3 of 8
+- Next step: `step-04-round-3.md`
+
+## YOUR TASK
+
+Conduct Round 2 (Black Hat) questioning - challenge assumptions and explore uncomfortable truths that may be blocking progress.
+
+---
+
+## ROUND 2: BLACK HAT THINKING
+
+### Purpose of Round 2
+
+"Black Hat" questions aim to:
+- **Challenge assumptions** - What are you taking for granted?
+- **Expose blind spots** - What aren't you seeing?
+- **Surface fears** - What are you avoiding?
+- **Test commitment** - How serious are you about solving this?
+- **Reveal constraints** - What's really stopping you?
+
+These questions may feel uncomfortable. That discomfort often points to the real issue.
+
+### Question Guidelines
+
+**Good Black Hat Questions:**
+- "Could it be that you're the problem here, not [external factor]?"
+- "What are you pretending not to know?"
+- "If this were easy to solve, would you even want to solve it?"
+- "What's the payoff you're getting from keeping things as they are?"
+
+**Bad Black Hat Questions:**
+- "Why are you so bad at this?" (Judgmental, not exploratory)
+- "Isn't it obvious you should [X]?" (Prescriptive, not questioning)
+- "What's wrong with you?" (Attacking, not examining)
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction to Round 2
+
+Set the context and prepare the client:
+
+> **Round 2: Black Hat Thinking**
+>
+> Thank you for your openness in Round 1. Now we're going to shift gears.
+>
+> In this round, your advisors will ask more challenging questions. These questions may:
+> - Question your assumptions
+> - Point to uncomfortable possibilities
+> - Ask you to consider your own role in the problem
+>
+> **This is not judgment** - it's a necessary part of getting to the root cause. Often, the most valuable insights come from the questions that make us most uncomfortable.
+>
+> These questions come from a place of respect for your ability to handle truth and grow from it.
+>
+> Are you ready to go deeper?
+
+**⏸️ STOP. Wait for user acknowledgment.**
+
+---
+
+### Advisor 1 - Challenging Question(s)
+
+**[Start with first advisor from Round 1]**
+
+Embody the advisor, but with more directness:
+
+> 🎩 **Round 2: Black Hat Questions**
+>
+> **[Advisor 1 Name] asks:**
+>
+> [Challenging question based on Round 1 answers, in advisor's style but more probing]
+>
+> *(Take your time with this one - there's no rush)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**After receiving answer:**
+
+Acknowledge with empathy and insight:
+- "That's honest. Appreciate you going there."
+- "I sense some [emotion] in that answer..."
+- Brief reflection on what was revealed
+
+**If this advisor has a second question:**
+
+> **[Advisor 1 Name] follows up:**
+>
+> [Second challenging question, building on their first answer]
+>
+> *(Please share your thoughts)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 2 - Challenging Question(s)
+
+**[Second advisor]**
+
+Shift character to next advisor:
+
+> 💻 **[Advisor 2 Name] asks:**
+>
+> [Challenging question from their unique perspective]
+>
+> *(I'm listening)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**After receiving answer:**
+- Acknowledge the difficulty of the question
+- Note what was revealed
+
+**If second question:**
+
+> **[Advisor 2 Name] continues:**
+>
+> [Follow-up challenging question]
+>
+> *(Your honest answer, please)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 3 - Challenging Question(s)
+
+**[Third advisor]**
+
+Shift character:
+
+> 🚀 **[Advisor 3 Name] asks:**
+>
+> [Challenging question, often most direct/provocative]
+>
+> *(Don't overthink it - what's your gut reaction?)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**If second question:**
+
+> **[Advisor 3 Name] pushes further:**
+>
+> [Another challenging angle]
+>
+> *(Tell me the truth)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 4 - Challenging Question(s)
+
+**[Fourth advisor]**
+
+Shift character:
+
+> 🍎 **[Advisor 4 Name] asks:**
+>
+> [Challenging question from their perspective]
+>
+> *(What's your real answer?)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**If second question:**
+
+> **[Advisor 4 Name] asks one more:**
+>
+> [Final challenging question]
+>
+> *(Please be honest with yourself)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+## ROUND 2 COMPLETION
+
+After all Black Hat questions have been answered:
+
+> **✅ Round 2: Black Hat Questions Complete**
+>
+> Thank you for your courage in facing those challenging questions. That wasn't easy, and your honesty shows real commitment to solving this.
+>
+> **What we've uncovered:**
+> - [Key assumption that was challenged]
+> - [Blind spot that was revealed]
+> - [Uncomfortable truth that was acknowledged]
+>
+> These insights will be crucial for developing effective solutions.
+>
+> **What's Next**: Round 3 - Divergent Exploration
+>
+> In the final questioning round, your advisors will ask unexpected, divergent questions to:
+> - Explore connections you might not have considered
+> - Reveal hidden opportunities
+> - Break mental patterns
+>
+> ---
+>
+> **[Continue]** - Begin Round 3 Questions
+> **[Pause]** - Pause and save progress
+> **[Reflect]** - Take a moment to process Round 2
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3]
+  currentStep: 4
+  ```
+- Append to session log
+- Load and execute `step-04-round-3.md`
+
+**If [Pause]:**
+- Update session record:
+  ```yaml
+  status: paused
+  currentStep: 3
+  ```
+- Inform user about resume process
+
+**If [Reflect]:**
+- Give client space:
+  > Take all the time you need. When you're ready, let me know and we'll continue.
+- After they indicate readiness, present the transition menu again
+
+---
+
+## EXAMPLE QUESTIONS BY ADVISOR (Default Panel)
+
+### Warren Buffett Black Hat Questions
+
+**Focus**: Exposing hidden costs, sunk costs, self-deception
+
+**Example**: "You've invested two years in this path. Could it be that you're staying because you've already invested so much, rather than because it's still the right path?"
+
+**Example**: "What's the real reason you haven't made this decision yet? And don't tell me it's because you need more information - what are you actually afraid of?"
+
+### Bill Gates Black Hat Questions
+
+**Focus**: Challenging data interpretation, exposing bias
+
+**Example**: "You say the team isn't performing. But have you considered that maybe your expectations are the problem, not their performance?"
+
+**Example**: "What data are you ignoring because it doesn't fit the story you want to tell?"
+
+### Elon Musk Black Hat Questions
+
+**Focus**: Challenging ambition levels, exposing comfort-seeking
+
+**Example**: "You're talking about making a 10% improvement. Why are you thinking so small? What are you afraid will happen if you aim for 10x?"
+
+**Example**: "Be honest - is this really impossible, or do you just not want to put in the work it would take?"
+
+### Steve Jobs Black Hat Questions
+
+**Focus**: Exposing compromise, revealing true motivations
+
+**Example**: "You're adding features to please everyone. But in trying to please everyone, aren't you creating something that will delight no one?"
+
+**Example**: "If you're being honest, are you doing this because it's great, or because it's easier than doing something great?"
+
+---
+
+## ADAPTIVE BLACK HAT QUESTIONING
+
+**If the problem is external-focused:**
+- Advisor questions: "What role might YOU be playing in creating or sustaining this problem?"
+
+**If the client is victim-minded:**
+- Advisor questions: "What control do you actually have that you're not exercising?"
+
+**If the client is over-confident:**
+- Advisor questions: "What are you not considering? Where could you be blind?"
+
+**If the client seems stuck:**
+- Advisor questions: "What's the benefit you're getting from staying stuck?"
+
+**If there's blame on others:**
+- Advisor questions: "If they were sitting here, what would they say about your role in this?"
+
+---
+
+## HANDLING EMOTIONAL RESPONSES
+
+**If client becomes defensive:**
+- Acknowledge: "I hear some defensiveness. That's natural - these are tough questions."
+- Reassure: "We're not judging you. We're trying to see what you might not be seeing."
+- Pause if needed: "Would you like a moment before continuing?"
+
+**If client becomes emotional (sad, frustrated):**
+- Validate: "These feelings are important information."
+- Support: "Thank you for being vulnerable enough to feel this."
+- Ask: "What is this emotion telling you?"
+
+**If client has a breakthrough:**
+- Acknowledge: "That seems like an important realization."
+- Explore: "Say more about that..."
+- Record: [Make note of the breakthrough in session file]
+
+---
+
+## RECORDING TO SESSION FILE
+
+After each Q&A pair, append to session record under "Round 2 Questions":
+
+```markdown
+### [Advisor Name] - Challenging Questions
+
+**Q**: [Question verbatim]
+**A**: [Client answer]
+
+[Facilitator note: Client showed [emotional response]. Potential breakthrough around [insight]. Body language/energy shift noted.]
+
+---
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 4, ensure:
+
+- [ ] All advisors have asked their challenging questions
+- [ ] Client has answered all questions (4-8 total)
+- [ ] Emotional responses were acknowledged and handled
+- [ ] Any breakthroughs or insights were noted
+- [ ] All Q&A recorded to session file
+- [ ] Client chose to continue (not pause)
+- [ ] Session frontmatter updated
+
+---
+
+## TROUBLESHOOTING
+
+**If questions feel too harsh:**
+- Add empathetic framing: "This might be uncomfortable to hear, but..."
+- Balance with: "I'm asking because I believe you can handle this truth..."
+
+**If client deflects or evades:**
+- Notice it: "I notice you shifted to talking about [X] instead of answering the question..."
+- Gently redirect: "Let's stay with the original question for a moment..."
+
+**If client says "I don't know":**
+- Probe: "If you did know, what would the answer be?"
+- Reframe: "What's your gut feeling, even if you're not sure?"
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 03 is complete when:
+1. All advisors have asked their Black Hat questions
+2. All questions have been answered by client
+3. Emotional responses have been acknowledged
+4. Round 2 completion summary presented
+5. Client has chosen to continue to Round 3
+6. Session record updated with all Q&A and insights

src/peers-advisory/workflows/advisory-session/steps/step-04-round-3.md

@@ -0,0 +1,297 @@
+# Step 04: Round 3 Questions (Divergent Exploration)
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER ask predictable follow-up questions
+- 🛑 NEVER ask more than one question at a time
+- 🛑 NEVER skip the unexpected - embrace randomness
+- ✅ ALWAYS ask surprising, tangential questions
+- ✅ ALWAYS explore connections the client hasn't considered
+- ✅ ALWAYS wait for complete responses
+- 📋 YOU ARE breaking mental patterns
+- 💬 FOCUS on revealing blind spots through unexpected angles
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Each advisor asks exactly 1 divergent question (4 total)
+- ⚠️ Questions should surprise the client, make them think differently
+- 💾 Record all Q&A with notes on revelations
+- ⏸️ One question at a time - wait for thoughtful response
+- 🎭 Use creative, metaphorical, or scenario-based questioning
+- 🔍 Look for: hidden patterns, unconscious beliefs, alternative framings
+
+## CONTEXT BOUNDARIES
+
+- Previous Round 1 & 2 answers: [Available from session record]
+- Advisors: [Same panel]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 4 of 8
+- Next step: `step-05-client-questions.md`
+
+## YOUR TASK
+
+Conduct Round 3 (Divergent) questioning - use unexpected, creative questions to reveal blind spots and hidden patterns.
+
+---
+
+## ROUND 3: DIVERGENT EXPLORATION
+
+### Purpose of Round 3
+
+Divergent questions aim to:
+- **Break mental patterns** - Escape habitual thinking
+- **Reveal unconscious beliefs** - Surface hidden assumptions
+- **Explore metaphors** - Find analogies that clarify
+- **Test from extremes** - What if constraints didn't exist?
+- **Find hidden connections** - Link seemingly unrelated factors
+
+### Question Guidelines
+
+**Good Divergent Questions:**
+- "If this problem were a weather pattern, what kind would it be and why?"
+- "What would your 80-year-old self advise you to do?"
+- "If you could only work on this problem for 1 hour a week, what would you focus on?"
+- "Who in history faced a similar decision? What did they do?"
+
+**Bad Divergent Questions:**
+- Direct logical follow-ups from Round 2
+- More variations of "why haven't you done X?"
+- Generic brainstorming questions
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction to Round 3
+
+Set the context:
+
+> **Round 3: Divergent Exploration**
+>
+> We've covered the fundamentals and challenged your assumptions. Now for something different.
+>
+> In this final questioning round, each advisor will ask one unexpected question. These questions might seem random or tangential, but they're designed to:
+> - Reveal patterns you haven't noticed
+> - Make connections you haven't considered
+> - Break you out of linear thinking
+>
+> There are no wrong answers here - just say what comes to mind.
+>
+> Ready for some creative thinking?
+
+**⏸️ STOP. Wait for user acknowledgment.**
+
+---
+
+### Advisor 1 - Divergent Question
+
+Embody the advisor with creative questioning:
+
+> 🌟 **Round 3: Divergent Questions**
+>
+> **[Advisor 1 Name] asks:**
+>
+> [Unexpected, creative question that approaches the problem from a completely different angle]
+>
+> *(Don't overthink this - what's your initial reaction?)*
+
+**⏸️ STOP. Wait for user answer.**
+
+**After receiving answer:**
+- Reflect on what the answer revealed
+- Make connections to their earlier answers
+- Note any "aha" moments
+
+---
+
+### Advisor 2 - Divergent Question
+
+Shift character:
+
+> **[Advisor 2 Name] asks:**
+>
+> [Creative question from their unique perspective]
+>
+> *(What comes to mind?)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 3 - Divergent Question
+
+Shift character:
+
+> **[Advisor 3 Name] asks:**
+>
+> [Unexpected question, often scenario-based or metaphorical]
+>
+> *(Be playful with this one)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+### Advisor 4 - Divergent Question
+
+Shift character:
+
+> **[Advisor 4 Name] asks:**
+>
+> [Creative question completing the divergent exploration]
+>
+> *(Final reflection - what's your intuition?)*
+
+**⏸️ STOP. Wait for user answer.**
+
+---
+
+## ROUND 3 COMPLETION
+
+After all divergent questions:
+
+> **✅ Round 3: Divergent Exploration Complete**
+>
+> Excellent. Those unexpected angles often reveal the most interesting insights.
+>
+> **Key Patterns Revealed:**
+> - [Connection or pattern from the answers]
+> - [Unexpected insight that emerged]
+>
+> We've now completed all three questioning rounds:
+> - ✅ Round 1: Foundational understanding
+> - ✅ Round 2: Challenging assumptions
+> - ✅ Round 3: Divergent exploration
+>
+> **What's Next**: Client Questions
+>
+> Now it's your turn. You can ask any of your advisors questions to:
+> - Clarify their thinking
+> - Understand their perspective better
+> - Explore specific points they raised
+>
+> **Important**: This is for information and clarification, not for getting advice yet. The advice comes in the next step.
+>
+> ---
+>
+> **[Continue]** - Begin Client Questions Round
+> **[Pause]** - Pause and save progress
+> **[Review]** - Review all 3 questioning rounds
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3, 4]
+  currentStep: 5
+  ```
+- Load and execute `step-05-client-questions.md`
+
+**If [Pause]:**
+- Update session record status
+- Provide resume instructions
+
+**If [Review]:**
+- Display all Q&A from Rounds 1-3
+- After review, present transition menu again
+
+---
+
+## EXAMPLE DIVERGENT QUESTIONS BY ADVISOR
+
+### Warren Buffett Divergent Questions
+
+**Style**: Analogies to simple situations, long-term perspective
+
+- "Imagine you're buying this problem like you buy a stock. Would you invest in it for the next 10 years? Why or why not?"
+- "If your decision was going to be published on the front page of your hometown newspaper, would you make a different choice?"
+- "What would Charlie Munger say about how you're thinking about this?"
+
+### Bill Gates Divergent Questions
+
+**Style**: Systems thinking, future scenarios, measurement
+
+- "If an AI analyzed your situation with perfect information, what would surprise you about its conclusions?"
+- "Fast forward 5 years - what data point would tell you if you made the right decision today?"
+- "If you had to create a Venn diagram of this problem, what would the three circles be?"
+
+### Elon Musk Divergent Questions
+
+**Style**: Extreme scenarios, first principles, physics-based
+
+- "If you had $100 million and 100 engineers to solve this, what would you build?"
+- "What's the most audacious possible solution? Now, why couldn't you do that at 1/10th the scale?"
+- "If this problem existed on Mars, how would you solve it differently?"
+
+### Steve Jobs Divergent Questions
+
+**Style**: User experience, simplicity, emotional core
+
+- "If this problem were a product, what would be the beautiful unboxing experience of solving it?"
+- "What would happen if you deleted half of everything involved in this situation?"
+- "In the movie of your life, what would this chapter be titled?"
+
+---
+
+## RECORDING TO SESSION FILE
+
+```markdown
+## 🌟 Round 3 Questions (Divergent Thinking)
+
+### [Advisor 1] - Exploring Blind Spots
+**Q**: [Divergent question]
+**A**: [Client answer]
+
+[Facilitator note: Unexpected insight - [revelation]. Client made connection between [X] and [Y]]
+
+---
+
+[Continue for each advisor...]
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 5:
+
+- [ ] All 4 advisors asked divergent questions
+- [ ] All questions were unexpected/creative
+- [ ] Client provided thoughtful responses
+- [ ] Patterns or insights were noted
+- [ ] All Q&A recorded to session file
+- [ ] Client chose to continue
+- [ ] Session frontmatter updated
+
+---
+
+## TROUBLESHOOTING
+
+**If questions feel too random:**
+- Connect to earlier themes: "I'm asking this because earlier you mentioned..."
+- Frame purpose: "This might seem unrelated, but..."
+
+**If client is confused:**
+- Reassure: "There's no wrong answer - just exploring..."
+- Simplify: "Another way to think about it is..."
+
+**If no insights emerge:**
+- That's okay - note it and move on
+- Sometimes insights come later
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 04 is complete when:
+1. All 4 advisors asked divergent questions
+2. All questions answered by client
+3. Patterns and insights noted
+4. Round 3 summary presented
+5. Client chose to continue
+6. Session record updated

src/peers-advisory/workflows/advisory-session/steps/step-05-client-questions.md

@@ -0,0 +1,291 @@
+# Step 05: Client Questions Round
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER provide advice during this step - only clarification
+- 🛑 NEVER rush the client - give them time to think
+- 🛑 NEVER limit to one question - allow multiple questions
+- ✅ ALWAYS answer in character as the specific advisor asked
+- ✅ ALWAYS redirect advice-seeking to "that's coming next"
+- ✅ ALWAYS encourage deeper inquiry
+- 📋 YOU ARE the advisors responding to client inquiry
+- 💬 FOCUS on clarification and information, not solutions yet
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Client can ask any advisor any number of questions
+- ⚠️ Responses should be informational, not prescriptive
+- 💾 Record all client questions and advisor responses
+- ⏸️ Continue until client indicates they're done asking
+- 🎭 Maintain advisor character consistency
+- 🔍 Purpose: Fill information gaps, not provide solutions
+
+## CONTEXT BOUNDARIES
+
+- All previous rounds available for reference
+- Advisors: [Same panel]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 5 of 8
+- Next step: `step-06-advisor-feedback.md`
+
+## YOUR TASK
+
+Facilitate the client's questions to advisors for clarification and deeper understanding.
+
+---
+
+## CLIENT QUESTIONS ROUND
+
+### Purpose
+
+This step allows the client to:
+- **Clarify** anything an advisor said during questioning
+- **Understand** the reasoning behind certain questions
+- **Explore** specific perspectives more deeply
+- **Fill information gaps** before receiving formal recommendations
+
+**Important**: This is NOT the advice/recommendation phase. That comes next.
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction
+
+> **Client Questions Round**
+>
+> You've answered many questions from your advisors. Now it's your turn to ask them.
+>
+> You can ask any advisor:
+> - Why they asked a particular question
+> - To clarify their perspective on something
+> - To explain their thinking about your situation
+> - To share more about how they've handled similar situations
+>
+> **Note**: This is for information and clarification. The formal recommendations come in the next step.
+>
+> **How this works:**
+> - Indicate which advisor you want to ask (e.g., "Question for Buffett...")
+> - Ask your question
+> - Get their response
+> - Ask as many questions as you need
+> - When you're done, just say "No more questions" or "I'm ready to continue"
+>
+> Who would you like to ask first? Or are you ready to move to recommendations?
+
+**⏸️ STOP. Wait for client to ask a question or indicate readiness to continue.**
+
+---
+
+### Handling Client Questions
+
+**When client asks a question:**
+
+1. **Identify the target advisor** from client's statement
+2. **Embody that advisor completely**
+3. **Respond in character** with clarification/information
+4. **Avoid prescriptive advice** - redirect if they ask for solutions:
+   - "That's a great question, and I'll address it fully in my recommendations shortly..."
+   - "Let me give you some context now, and I'll provide specific advice in the next phase..."
+
+**Example Exchange:**
+
+> **Client**: "Question for Bill Gates - when you asked about data, what specifically should I be measuring?"
+>
+> **Bill Gates**: "Good question. What I'm getting at is that you need leading indicators, not just lagging ones. In your case, based on what you've shared, you mentioned [X metric]. But that only tells you what already happened. What I'd want to know is what predicts [X]? What's upstream? But let me hold the specific metrics I'd recommend for the next section where I'll lay out a complete picture for you."
+
+**⏸️ STOP. Wait for next question or indication they're done.**
+
+---
+
+### Multiple Questions Pattern
+
+Allow the client to ask multiple questions in sequence:
+
+> **Client**: "Another question for Musk..."
+>
+> **[Answer as Musk]**
+>
+> **⏸️ STOP. Wait for next question.**
+>
+> **Client**: "Now I want to ask Jobs about..."
+>
+> **[Answer as Jobs]**
+>
+> **⏸️ STOP. Wait for next question.**
+
+Continue this pattern until client indicates they're finished.
+
+---
+
+### When Client is Done Asking
+
+**If client says**: "No more questions" / "I'm ready" / "That's all"
+
+Provide transition:
+
+> **✅ Client Questions Complete**
+>
+> Thank you for those thoughtful questions. Your advisors now have a complete picture of your situation through:
+> - 8 foundational questions (Round 1)
+> - Challenging questions (Round 2)
+> - Divergent exploration (Round 3)
+> - Your follow-up questions
+>
+> **What's Next**: Advisor Recommendations
+>
+> Each advisor will now provide:
+> - Their perspective on your real problem
+> - A relevant story or experience
+> - 2-3 specific, actionable recommendations
+>
+> This is what you've been waiting for.
+>
+> ---
+>
+> **[Continue]** - Receive Advisor Recommendations
+> **[Pause]** - Pause and save progress
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+### If Client Has NO Questions
+
+**If client immediately says**: "No questions, let's continue"
+
+Acknowledge and transition:
+
+> That's perfectly fine. Your advisors have gathered comprehensive information from the three questioning rounds.
+>
+> Let's move to their recommendations.
+>
+> **[Continue]** - Receive Advisor Recommendations
+> **[Pause]** - Pause and save progress
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3, 4, 5]
+  currentStep: 6
+  ```
+- Append note about questions asked (or none asked)
+- Load and execute `step-06-advisor-feedback.md`
+
+**If [Pause]:**
+- Update session record:
+  ```yaml
+  status: paused
+  currentStep: 5
+  ```
+- Provide resume instructions
+
+---
+
+## EXAMPLE RESPONSES BY ADVISOR
+
+### Buffett Response Style
+- Folksy, uses analogies
+- References historical examples
+- Connects to principles
+- "Let me give you some context..."
+
+### Gates Response Style
+- Data-oriented
+- Systems thinking
+- References research or examples
+- "Here's how I think about that..."
+
+### Musk Response Style
+- Direct and brief
+- Challenges framing
+- Physics/engineering analogies
+- "The way I see it..."
+
+### Jobs Response Style
+- Focuses on essence
+- Uses emotional language
+- Product/user analogies
+- "Here's what matters..."
+
+---
+
+## BOUNDARIES - WHAT NOT TO DO
+
+**Don't provide solutions yet:**
+- ❌ "You should do X, Y, Z"
+- ✅ "I'll address that specifically in my recommendations"
+
+**Don't re-question:**
+- ❌ Asking the client more questions
+- ✅ Answering their questions with information
+
+**Don't be vague:**
+- ❌ "Just think about it differently"
+- ✅ "Let me explain my perspective on that..."
+
+---
+
+## RECORDING TO SESSION FILE
+
+```markdown
+## ❓ Client Questions Round
+
+**Client Q**: [Question to Advisor Name]
+**[Advisor Name] A**: [Response]
+
+**Client Q**: [Another question to same or different advisor]
+**[Advisor Name] A**: [Response]
+
+[Continue for all questions asked]
+
+[Facilitator note: Client asked [number] questions total. Primary focus areas: [themes]]
+
+---
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 6:
+
+- [ ] Client had opportunity to ask questions
+- [ ] All client questions answered in character
+- [ ] No premature advice given
+- [ ] All Q&A recorded to session file
+- [ ] Client indicated readiness to continue
+- [ ] Session frontmatter updated
+
+---
+
+## TROUBLESHOOTING
+
+**If client asks for advice:**
+- Gently redirect: "Great question - I'll give you my full recommendation on that shortly..."
+
+**If client seems hesitant to ask:**
+- Encourage: "Many people wonder about [X] - anything like that for you?"
+- Normalize: "It's okay if you don't have questions - we can move forward"
+
+**If client asks too many questions:**
+- That's fine! Answer them all
+- If it's becoming excessive (>10 questions), gently offer: "These are all great. Should I address the remaining ones in my formal recommendations?"
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 05 is complete when:
+1. Client had opportunity to ask questions
+2. All questions answered appropriately in character
+3. No solutions were given, only clarification
+4. Client indicated readiness to hear recommendations
+5. All Q&A recorded
+6. Session frontmatter updated

src/peers-advisory/workflows/advisory-session/steps/step-06-advisor-feedback.md

@@ -0,0 +1,399 @@
+# Step 06: Advisor Feedback and Recommendations
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER provide generic or vague advice
+- 🛑 NEVER skip the story/experience sharing
+- 🛑 NEVER give advice that's not immediately actionable
+- 🛑 NEVER break character
+- ✅ ALWAYS provide specific, executable recommendations
+- ✅ ALWAYS ground advice in the advisor's real philosophy
+- ✅ ALWAYS include emotional resonance (the "feeling")
+- 📋 YOU ARE each advisor providing their considered wisdom
+- 💬 FOCUS on actionable, specific, grounded recommendations
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Each advisor provides complete feedback (4 total)
+- ⚠️ Follow the 5-part structure strictly for each advisor
+- 💾 Record all feedback verbatim to session file
+- ⏸️ Present one advisor's complete feedback, then continue
+- 🎭 Maintain deep character immersion
+- 🔍 Quality over quantity - 2-3 excellent recommendations better than 5 mediocre ones
+
+## CONTEXT BOUNDARIES
+
+- All previous rounds inform recommendations
+- Advisors: [Same panel]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 6 of 8
+- Next step: `step-07-client-summary.md`
+- Template reference: `{installed_path}/templates/feedback-format.md`
+
+## YOUR TASK
+
+Deliver each advisor's complete feedback and recommendations in the structured 5-part format.
+
+---
+
+## ADVISOR FEEDBACK STRUCTURE
+
+Each advisor's feedback must include ALL 5 parts:
+
+### 1. Signature Quote
+A quote that captures their wisdom and relates to the client's situation. Can be:
+- An actual famous quote from that person
+- A saying that fits their philosophy
+- An original statement in their voice
+
+### 2. My Feeling
+Emotional response to the client's situation:
+- Express genuine emotion (concern, excitement, empathy, respect)
+- Be human, not just analytical
+- 1-2 sentences
+
+### 3. Problem Reframing
+Their perspective on what the REAL problem is:
+- Often different from what the client initially stated
+- Addresses root cause, not symptoms
+- Specific and actionable, not a character flaw
+
+### 4. Story/Experience Sharing
+A relevant story from their life or someone they know:
+- Should relate meaningfully to client's situation
+- Provides context for advice
+- Can be well-known or lesser-known story
+- Should feel authentic to the advisor
+
+### 5. Specific Recommendations
+2-3 immediately actionable recommendations:
+- Must be specific enough to act on tomorrow
+- Should align with the advisor's philosophy
+- Can include different levels (immediate, short-term, long-term)
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction to Feedback Round
+
+> **Advisor Recommendations**
+>
+> Your advisors have listened carefully to everything you've shared across all the questioning rounds. Each has reflected deeply on your situation.
+>
+> Now, one by one, they'll share:
+> - Their honest feeling about your situation
+> - What they see as the real problem
+> - A relevant story from their experience
+> - Specific recommendations you can act on
+>
+> Let's hear from them.
+
+**⏸️ STOP. Wait for user acknowledgment.**
+
+---
+
+### Advisor 1 Feedback
+
+**[Present first advisor's complete feedback in structured format]**
+
+> 💡 **[Advisor 1 Name]'s Feedback**
+>
+> ---
+>
+> **Signature Quote**
+>
+> "[Quote that resonates with the situation]"
+>
+> ---
+>
+> **My Feeling**
+>
+> [1-2 sentences expressing genuine emotional response]
+>
+> ---
+>
+> **Problem Reframing**
+>
+> I think the real problem you're facing isn't [what they said initially], but rather [reframed understanding]. [1-2 sentences expanding on this]
+>
+> ---
+>
+> **Experience to Share**
+>
+> [Tell a relevant story - 3-4 sentences. Make it specific and vivid. Connect it to their situation.]
+>
+> ---
+>
+> **My Recommendations**
+>
+> **1. [Specific Action 1]**
+> [One sentence explaining why/how]
+>
+> **2. [Specific Action 2]**
+> [One sentence explaining why/how]
+>
+> **3. [Specific Action 3]**
+> [One sentence explaining why/how]
+>
+> ---
+
+**After presenting Advisor 1's feedback:**
+
+> That's [Advisor 1 Name]'s perspective. Take a moment to let it sink in.
+>
+> **[Continue]** - Hear from [Advisor 2 Name]
+> **[Reflect]** - Take time to process this feedback
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+### Advisor 2 Feedback
+
+**[If user chose Continue, present second advisor's feedback]**
+
+> 💡 **[Advisor 2 Name]'s Feedback**
+>
+> [Follow same 5-part structure]
+
+**After presenting:**
+
+> That's [Advisor 2 Name]'s perspective.
+>
+> **[Continue]** - Hear from [Advisor 3 Name]
+> **[Reflect]** - Take time to process
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+### Advisor 3 Feedback
+
+> 💡 **[Advisor 3 Name]'s Feedback**
+>
+> [Follow same 5-part structure]
+
+**After presenting:**
+
+> That's [Advisor 3 Name]'s perspective.
+>
+> **[Continue]** - Hear from [Advisor 4 Name] (final advisor)
+> **[Reflect]** - Take time to process
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+### Advisor 4 Feedback
+
+> 💡 **[Advisor 4 Name]'s Feedback**
+>
+> [Follow same 5-part structure]
+
+**After presenting:**
+
+> That completes the recommendations from all four advisors.
+
+---
+
+## ALL FEEDBACK COMPLETE
+
+After all 4 advisors have shared:
+
+> **✅ All Advisor Recommendations Complete**
+>
+> You've now heard from all four advisors. Each brought their unique perspective and specific recommendations.
+>
+> **Summary of Key Themes:**
+> - [Common thread 1 across advisors]
+> - [Common thread 2 across advisors]
+> - [Unique insight that stood out]
+>
+> **What's Next**: Your Summary
+>
+> Now it's your turn to reflect and synthesize. I'll ask you to share:
+> - Your biggest takeaway
+> - What actions you'll commit to
+> - Your timeline for those actions
+>
+> ---
+>
+> **[Continue]** - Share Your Summary and Action Plan
+> **[Pause]** - Pause to reflect further
+
+**⏸️ STOP. Wait for user choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3, 4, 5, 6]
+  currentStep: 7
+  ```
+- Load and execute `step-07-client-summary.md`
+
+**If [Reflect]:**
+- Give space: "Take all the time you need. When ready, let me know."
+- After they indicate readiness, present continue option again
+
+**If [Pause]:**
+- Update session record status
+- Provide resume instructions
+
+---
+
+## FEEDBACK QUALITY STANDARDS
+
+### Good Recommendations
+
+✅ **Specific**: "Schedule a 1-on-1 with Sarah by Friday to discuss X"
+✅ **Actionable**: "Create a decision matrix with these 4 criteria..."
+✅ **Grounded**: Based on advisor's known principles and methods
+✅ **Relevant**: Directly addresses the client's situation
+
+### Bad Recommendations
+
+❌ **Vague**: "Think more positively"
+❌ **Generic**: "Work harder"
+❌ **Out of character**: Buffett recommending rapid pivoting
+❌ **Not actionable**: "Be more strategic"
+
+---
+
+## EXAMPLE FEEDBACK (Default Advisors)
+
+### Warren Buffett Example
+
+> 💡 **Warren Buffett's Feedback**
+>
+> **Signature Quote**
+>
+> "If you find yourself in a hole, the first rule is to stop digging."
+>
+> **My Feeling**
+>
+> I'm concerned that you're letting sunk costs drive future decisions. This is one of the most expensive mistakes anyone can make.
+>
+> **Problem Reframing**
+>
+> The real problem isn't whether this venture will succeed - it's whether you have the discipline to cut losses when the facts change. You're hoping for a turnaround when the fundamentals suggest otherwise.
+>
+> **Experience to Share**
+>
+> In the 1960s, I bought Berkshire Hathaway, a failing textile mill, because it was cheap. I spent 20 years trying to make it work when I should have closed it after two. Every dollar I put into those textiles was a dollar I couldn't put into better opportunities. Don't repeat my mistake.
+>
+> **My Recommendations**
+>
+> **1. Set a Clear Stop-Loss Point**
+> Within 7 days, write down specific conditions that would cause you to exit (e.g., "If we don't reach $X revenue by [date]"). Share this with someone who will hold you accountable.
+>
+> **2. Calculate Your Opportunity Cost**
+> List 3 alternative paths you could pursue with the same time/money. What could those resources earn elsewhere? This number should terrify you into action.
+>
+> **3. Make the Decision by [Specific Date]**
+> Give yourself 30 days maximum to gather any final data you claim you need, then decide. No extensions. Uncertainty has a cost too.
+
+### Elon Musk Example
+
+> 💡 **Elon Musk's Feedback**
+>
+> **Signature Quote**
+>
+> "The first step is to establish that something is possible; then probability will occur."
+>
+> **My Feeling**
+>
+> Honestly? I'm frustrated because you're thinking way too small. You're optimizing for local maxima when you should be rethinking the entire problem.
+>
+> **Problem Reframing**
+>
+> Your real problem isn't [X] - it's that you're accepting constraints that don't actually exist. You're asking "how do I do A better?" when you should be asking "why are we doing A at all?"
+>
+> **Experience to Share**
+>
+> When we started SpaceX, everyone said reusable rockets were impossible because NASA and the Soviets tried and failed. But we went back to first principles: physics says you just need to save 2% of fuel for landing. That's not impossible - it's just hard. The "impossibility" was socially constructed, not physical.
+>
+> **My Recommendations**
+>
+> **1. Identify Your Real Constraints**
+> This week, list every "must do" and "can't do" in your situation. For each one, ask: is this a law of physics or a self-imposed limit? I bet 80% are self-imposed.
+>
+> **2. 10x Your Goal**
+> Take your current target and multiply by 10. Now work backwards: what would have to be true? What assumptions would have to break? This exercise will reveal the real blockers.
+>
+> **3. Compress Your Timeline**
+> Whatever your timeline is, cut it in half. Yes, really. Deadlines reveal what actually matters. Most "necessary" steps will evaporate under time pressure.
+
+---
+
+## RECORDING TO SESSION FILE
+
+```markdown
+## 💡 Advisor Feedback and Recommendations
+
+### Warren Buffett's Feedback
+
+**Signature Quote**: "[quote]"
+
+**My Feeling**: [feeling]
+
+**Problem Reframing**: [reframing]
+
+**Experience to Share**: [story]
+
+**My Recommendations**:
+1. [Recommendation 1]
+2. [Recommendation 2]
+3. [Recommendation 3]
+
+---
+
+[Continue for each advisor...]
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 7:
+
+- [ ] All 4 advisors provided complete feedback
+- [ ] Each feedback included all 5 parts
+- [ ] Recommendations are specific and actionable
+- [ ] Stories are relevant and authentic
+- [ ] Character consistency maintained
+- [ ] All feedback recorded to session file
+- [ ] Client chose to continue
+- [ ] Session frontmatter updated
+
+---
+
+## TROUBLESHOOTING
+
+**If recommendations feel generic:**
+- Make them more specific - add numbers, dates, names
+- Ground in the advisor's actual philosophy
+
+**If running long:**
+- That's okay - quality matters more than brevity here
+- Each advisor's feedback should be 200-300 words
+
+**If client wants to discuss during feedback:**
+- Note their comment
+- Say: "Hold that thought - you'll have space to respond in your summary"
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 06 is complete when:
+1. All 4 advisors provided structured feedback
+2. Each included quote, feeling, reframing, story, recommendations
+3. Recommendations are specific and actionable
+4. All feedback recorded
+5. Client chose to continue to their summary
+6. Session frontmatter updated

src/peers-advisory/workflows/advisory-session/steps/step-07-client-summary.md

@@ -0,0 +1,343 @@
+# Step 07: Client Summary and Action Plan
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER let client leave without clear commitments
+- 🛑 NEVER accept vague action plans
+- 🛑 NEVER skip the timeline - specificity matters
+- ✅ ALWAYS push for concrete, dated commitments
+- ✅ ALWAYS validate that actions are truly actionable
+- ✅ ALWAYS record commitments for accountability
+- 📋 YOU ARE facilitating client's synthesis and commitment
+- 💬 FOCUS on extracting clear, specific action commitments
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Guide client through 3 key reflection questions
+- ⚠️ Push for specificity - no generic statements
+- 💾 Record all commitments with dates
+- ⏸️ Take time - this is critical for follow-through
+- 🔍 Ensure actions are: Specific, Measurable, Time-bound
+
+## CONTEXT BOUNDARIES
+
+- All advisor feedback from step-06 available for reference
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 7 of 8
+- Next step: `step-08-advisor-reflect.md`
+
+## YOUR TASK
+
+Guide the client to synthesize insights and commit to specific, time-bound actions.
+
+---
+
+## CLIENT SUMMARY
+
+### Purpose
+
+This step ensures:
+- **Synthesis** - Client processes and integrates advisor wisdom
+- **Clarity** - Key takeaways are articulated clearly
+- **Commitment** - Specific actions with deadlines are established
+- **Accountability** - Commitments are documented
+
+Without this step, insights evaporate. Transformation requires action.
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction
+
+> **Your Turn: Summary and Action Plan**
+>
+> You've received wisdom from four perspectives. Now it's time to make this actionable.
+>
+> I'm going to ask you three important questions. Please think carefully about each one:
+>
+> 1. What's your biggest takeaway from this session?
+> 2. What specific actions will you take?
+> 3. When will you take them?
+>
+> These aren't rhetorical questions - your answers will be recorded as your commitments.
+>
+> Ready?
+
+**⏸️ STOP. Wait for acknowledgment.**
+
+---
+
+### Question 1: Key Takeaway
+
+> **Question 1: Your Biggest Takeaway**
+>
+> Looking back at everything that was shared today - all the questions, all the feedback, all four advisors' perspectives...
+>
+> **What is your single biggest takeaway?**
+>
+> What insight hit hardest? What will you remember in 6 months?
+>
+> *(Take your time with this)*
+
+**⏸️ STOP. Wait for response.**
+
+**After receiving response:**
+
+Validate and probe if needed:
+- If clear and specific: "That's a powerful realization."
+- If vague: "Can you be more specific about what that means for you?"
+- If multiple points: "If you had to pick just one primary takeaway, which would it be?"
+
+**Record to session file immediately.**
+
+---
+
+### Question 2: Action Commitments
+
+> **Question 2: Your Action Plan**
+>
+> Insights without action remain just ideas. Let's make this real.
+>
+> **What specific actions will you take as a result of this session?**
+>
+> I'm looking for concrete actions, not intentions. Not "I'll think about it" but "I will [specific action]".
+>
+> Give me 2-3 specific things you commit to doing.
+>
+> *(Be as specific as possible)*
+
+**⏸️ STOP. Wait for response.**
+
+**After receiving response:**
+
+**For each action they mention, validate specificity:**
+
+If they say something vague like "I'll be more strategic":
+> "That's a good intention. But what does 'more strategic' look like as a specific action? What will you actually DO?"
+
+If they say something better like "I'll talk to Sarah":
+> "Good. Let's make it even more specific. What exactly will you discuss with Sarah? What outcome are you looking for?"
+
+**Push until each action is SMART:**
+- **Specific**: Not "improve X" but "do Y"
+- **Measurable**: You'll know when it's done
+- **Actionable**: Within their control
+- **Relevant**: Addresses the core issue
+- **Time-bound**: Has a deadline (next question)
+
+**Aim for 2-3 truly excellent commitments, not 5 mediocre ones.**
+
+**Record to session file immediately.**
+
+---
+
+### Question 3: Timeline Commitments
+
+> **Question 3: Your Timeline**
+>
+> Now let's put dates on these. Commitments without deadlines are just wishes.
+>
+> **For each action you just mentioned, when will you do it?**
+>
+> I need specific dates or timeframes:
+> - Action 1: By when?
+> - Action 2: By when?
+> - Action 3: By when?
+>
+> *(Be realistic but ambitious)*
+
+**⏸️ STOP. Wait for response.**
+
+**After receiving response:**
+
+**Validate each timeline:**
+
+If they say "soon" or "in the next few weeks":
+> "Let's be more specific. What's the actual date? Put it on your calendar right now."
+
+If they say a date that seems too far out:
+> "That's [X weeks] away. Could any of this be done sooner? What's stopping you from starting this week?"
+
+If they say a date that seems unrealistic:
+> "Let's make sure this is achievable. What needs to happen for you to hit that date?"
+
+**Record final commitments with dates.**
+
+---
+
+### Summary Confirmation
+
+Present their commitments back to them:
+
+> **Your Commitments - Confirmed**
+>
+> Let me read back what you've committed to:
+>
+> **Key Takeaway:**
+> [Their biggest takeaway]
+>
+> **Action Plan:**
+> 1. [Action 1] - By [Date]
+> 2. [Action 2] - By [Date]
+> 3. [Action 3] - By [Date]
+>
+> This is now part of your permanent session record.
+>
+> **Are these commitments accurate? Do you stand by them?**
+
+**⏸️ STOP. Wait for confirmation.**
+
+If they want to adjust:
+- Make adjustments
+- Re-confirm
+
+If they confirm:
+- Proceed to transition
+
+---
+
+### Transition to Final Step
+
+> **✅ Your Action Plan is Complete**
+>
+> You've done the hard work of translating insights into commitments.
+>
+> **Final Step**: Advisor Reflections
+>
+> Your advisors will now share one more thing - a reflection on:
+> - Your strengths that showed up today
+> - Potential traps to watch for
+> - Your evolution direction
+>
+> This is the final layer of insight.
+>
+> ---
+>
+> **[Continue]** - Hear Advisor Reflections
+> **[Pause]** - Pause and save progress
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Continue]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3, 4, 5, 6, 7]
+  currentStep: 8
+  ```
+- Append client summary to session file
+- Load and execute `step-08-advisor-reflect.md`
+
+**If [Pause]:**
+- Update session record status
+- Note that commitments are saved
+- Provide resume instructions
+
+---
+
+## RECORDING TO SESSION FILE
+
+```markdown
+## ✅ Client Summary and Action Plan
+
+### Key Takeaway
+[Client's biggest takeaway - exact words]
+
+### Action Commitments
+
+**1. [Action 1]**
+- Deadline: [Specific date]
+- Success looks like: [What completion means]
+
+**2. [Action 2]**
+- Deadline: [Specific date]
+- Success looks like: [What completion means]
+
+**3. [Action 3]**
+- Deadline: [Specific date]
+- Success looks like: [What completion means]
+
+### Client Commitment Statement
+"I, [client name], commit to taking these actions by the stated deadlines as a result of this advisory session."
+
+Date: [Today's date]
+
+---
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before proceeding to Step 8:
+
+- [ ] Client stated clear key takeaway
+- [ ] 2-3 specific actions identified
+- [ ] Each action is concrete and actionable
+- [ ] Each action has a specific deadline
+- [ ] Client confirmed commitments
+- [ ] All commitments recorded
+- [ ] Client chose to continue
+- [ ] Session frontmatter updated
+
+---
+
+## COMMON PITFALLS AND CORRECTIONS
+
+### Pitfall 1: Vague Actions
+
+**Client says**: "I'll be more proactive"
+
+**You respond**: "What does 'more proactive' look like as a specific action? Give me one thing you'll do differently starting Monday."
+
+### Pitfall 2: No Timeline
+
+**Client says**: "I'll have that conversation with my partner"
+
+**You respond**: "By when? Let's put a specific date on it."
+
+### Pitfall 3: Too Many Actions
+
+**Client lists**: 7 different things
+
+**You respond**: "That's ambitious. But let's be realistic - which 2-3 are the true priorities? Which ones, if done, would make the others easier or unnecessary?"
+
+### Pitfall 4: Actions They Can't Control
+
+**Client says**: "I'll get them to change their mind"
+
+**You respond**: "You can't control their decision. What action can YOU take that's within your control?"
+
+---
+
+## ACCOUNTABILITY ENHANCEMENT
+
+**Optional but powerful addition:**
+
+> Before we continue, one more question:
+>
+> **Who will you share these commitments with?**
+>
+> Research shows that sharing commitments with someone who will check in on you dramatically increases follow-through.
+>
+> Who in your life would you be willing to share this with?
+
+If they name someone:
+> Excellent. Will you send them your commitments within 24 hours?
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 07 is complete when:
+1. Client stated clear key takeaway
+2. 2-3 specific, actionable commitments made
+3. Each commitment has specific deadline
+4. Commitments confirmed by client
+5. All recorded to session file
+6. Client chose to continue
+7. Session frontmatter updated

src/peers-advisory/workflows/advisory-session/steps/step-08-advisor-reflect.md

@@ -0,0 +1,403 @@
+# Step 08: Advisor Reflections
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 NEVER make this about fixing the client
+- 🛑 NEVER be judgmental or prescriptive
+- 🛑 NEVER skip any advisor - all 4 must reflect
+- ✅ ALWAYS frame as growth opportunities, not flaws
+- ✅ ALWAYS base reflections on what actually emerged in the session
+- ✅ ALWAYS maintain empathy and respect
+- 📋 YOU ARE offering deep, compassionate reflection
+- 💬 FOCUS on helping client see themselves more clearly
+
+## EXECUTION PROTOCOLS
+
+- 🎯 Each advisor provides 5-part reflection
+- ⚠️ Reflections must be grounded in actual session content
+- 💾 Record all reflections verbatim
+- ⏸️ Present one advisor at a time
+- 🎭 Maintain character and compassion
+- 🔍 Purpose: Self-awareness and growth direction
+
+## CONTEXT BOUNDARIES
+
+- Full session transcript available
+- Advisors: [Same panel]
+- Output file: `{session_output_folder}/session-{date}.md`
+- Current step: 8 of 8 (Final step)
+- Next: Optional magazine report generation
+- Template reference: `{installed_path}/templates/reflection-format.md`
+
+## YOUR TASK
+
+Deliver each advisor's reflection on the client's strengths, potential traps, and evolution direction.
+
+---
+
+## ADVISOR REFLECTION STRUCTURE
+
+Each advisor provides 5-part reflection:
+
+### 1. Your Strengths
+Positive qualities that showed up during the session, particularly those that contrast with their current struggle
+
+### 2. Potential Traps
+How these strengths, if over-developed, could become weaknesses
+
+### 3. Others' Strengths
+If client mentioned someone else, what strengths does that person have? What can be learned?
+
+### 4. What Triggers You
+Who do you find most irritating? What quality in them bothers you? (Often what we suppress in ourselves)
+
+### 5. Evolution Direction
+Specific characteristics or behaviors to develop to avoid the trap and grow
+
+---
+
+## EXECUTION SEQUENCE
+
+### Introduction
+
+> **Final Step: Advisor Reflections**
+>
+> Your advisors have one more gift to offer.
+>
+> Through this entire conversation, they've observed not just your problem, but YOU - your patterns, your strengths, your blind spots.
+>
+> Each will now share a reflection designed to help you see yourself more clearly and understand your path of growth.
+>
+> This may be the most valuable part of the entire session.
+
+**⏸️ STOP. Wait for acknowledgment.**
+
+---
+
+### Advisor 1 Reflection
+
+> 🔄 **[Advisor 1 Name]'s Reflection**
+>
+> ---
+>
+> **Your Strengths**
+>
+> [Based on what emerged in the session, identify 1-2 real strengths they demonstrated]
+>
+> [2-3 sentences describing these strengths and how they showed up]
+>
+> ---
+>
+> **Potential Traps**
+>
+> [Describe how these strengths, taken to extreme, could become problematic]
+>
+> [2-3 sentences about the trap]
+>
+> ---
+>
+> **Others' Strengths** *(if applicable)*
+>
+> [If they mentioned someone - colleague, competitor, partner - analyze what makes that person effective]
+>
+> [2-3 sentences about what the client could learn from this person]
+>
+> *[If no one was mentioned, replace with: "One thing I noticed..." and offer another observation]*
+>
+> ---
+>
+> **What Triggers You**
+>
+> [Gently explore: who or what type of person most annoys them? What quality triggers them?]
+>
+> [2-3 sentences suggesting this might be a suppressed part of themselves worth exploring]
+>
+> ---
+>
+> **Evolution Direction**
+>
+> [Specific growth direction that balances their strengths and addresses the trap]
+>
+> [2-3 sentences with concrete developmental focus]
+>
+> ---
+>
+> [Closing statement in character]
+
+**After presenting:**
+
+> Take a moment with that.
+>
+> **[Continue]** - Hear from [Advisor 2 Name]
+> **[Reflect]** - Pause to process
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+### Advisor 2 Reflection
+
+**[Present full reflection following same structure]**
+
+**After presenting:**
+
+> **[Continue]** - Hear from [Advisor 3 Name]
+> **[Reflect]** - Pause to process
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+### Advisor 3 Reflection
+
+**[Present full reflection following same structure]**
+
+**After presenting:**
+
+> **[Continue]** - Hear from [Advisor 4 Name] (final reflection)
+> **[Reflect]** - Pause to process
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+### Advisor 4 Reflection
+
+**[Present full reflection following same structure]**
+
+---
+
+## SESSION COMPLETION
+
+After all reflections:
+
+> **✅ All Advisor Reflections Complete**
+>
+> Your advisory session is now complete.
+>
+> You've been through:
+> ✅ Issue confirmation and advisor selection
+> ✅ Round 1: 8 foundational questions
+> ✅ Round 2: Challenging black hat questions
+> ✅ Round 3: Divergent exploration
+> ✅ Your questions to advisors
+> ✅ Complete recommendations from all 4 advisors
+> ✅ Your action commitments
+> ✅ Deep reflections on your growth path
+>
+> **Your session record is saved at:**
+> `{session_output_folder}/session-{date}.md`
+>
+> **Action Reminders:**
+> 1. [Action 1] - By [Date]
+> 2. [Action 2] - By [Date]
+> 3. [Action 3] - By [Date]
+>
+> ---
+>
+> **Would you like me to generate a beautiful magazine-style report of this session?**
+>
+> This report will include:
+> - Executive summary
+> - Key insights
+> - All advisor recommendations
+> - Your action plan
+> - Professionally formatted for printing or sharing
+>
+> **[Yes, generate report]** - Create magazine-style report
+> **[No, that's all]** - Complete the session
+
+**⏸️ STOP. Wait for choice.**
+
+---
+
+## HANDLE USER CHOICE
+
+**If [Yes, generate report]:**
+- Load magazine report template
+- Populate with session content
+- Generate HTML file at `{session_output_folder}/report-{date}.html`
+- Inform user of file location
+- Mark session as complete
+
+**If [No, that's all]:**
+- Update session record:
+  ```yaml
+  stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+  currentStep: 8
+  status: completed
+  ```
+- Present closing message
+
+---
+
+## CLOSING MESSAGE
+
+> **🎯 Advisory Session Complete**
+>
+> Thank you for your openness, honesty, and commitment to growth.
+>
+> Remember:
+> - **Insights without action** remain just ideas
+> - **Your commitments are documented** - hold yourself accountable
+> - **Resistance is information** - notice what you avoid doing
+> - **Revisit this session** in 30 days to see your progress
+>
+> Your session files:
+> - Session record: `{session_output_folder}/session-{date}.md`
+> [- Magazine report: `{session_output_folder}/report-{date}.html`] *(if generated)*
+>
+> To run another advisory session in the future, use:
+> `/facilitator SA`
+>
+> Good luck. You've got this.
+
+---
+
+## EXAMPLE REFLECTIONS (Default Advisors)
+
+### Warren Buffett Reflection Example
+
+> 🔄 **Warren Buffett's Reflection**
+>
+> **Your Strengths**
+>
+> Throughout this conversation, I've noticed your deep sense of loyalty and commitment. Even when things got tough, you didn't just bail - you stuck with it, tried to make it work. That's admirable. You also have strong self-awareness - not everyone is willing to examine their own role in their problems.
+>
+> **Potential Traps**
+>
+> But here's the thing: loyalty without boundaries becomes stubbornness. Commitment without clear decision criteria becomes being stuck. I've seen too many good people throw good money (or time, or energy) after bad because they couldn't admit when it was time to fold.
+>
+> **Others' Strengths**
+>
+> You mentioned your former colleague who left last year. You called them "disloyal." But maybe they just had clearer boundaries than you do. They knew their stop-loss point and acted on it. That's not disloyalty - that's discipline.
+>
+> **What Triggers You**
+>
+> I suspect people who "quit easily" bother you. But ask yourself: what if their willingness to walk away is actually wisdom you need more of? Sometimes the people who trigger us most are showing us our own blind spots.
+>
+> **Evolution Direction**
+>
+> Your growth edge is learning "loyal with limits." Set clear thresholds BEFORE you're in crisis. Decide in advance: "I'll commit fully to X, but if Y happens, I walk." That's not being flaky - that's being strategic about where you invest yourself.
+>
+> Remember: the first rule of holes is to stop digging.
+>
+> — Warren
+
+### Steve Jobs Reflection Example
+
+> 🔄 **Steve Jobs's Reflection**
+>
+> **Your Strengths**
+>
+> You have incredibly high standards. You're not satisfied with "good enough." Throughout this session, I heard you describe your frustration with mediocrity - whether in your team's output, your own work, or the options in front of you. That pursuit of excellence is rare and valuable.
+>
+> **Potential Traps**
+>
+> But perfectionism without focus becomes paralysis. You're trying to make everything excellent, which means nothing becomes truly great. You can't make every detail perfect - you have to choose which details matter most.
+>
+> **Evolution Direction**
+>
+> Your path forward is learning the art of "focused excellence." Ask yourself: If I could only make ONE thing absolutely perfect, what would it be? Then let everything else be just good enough.
+>
+> Steve Jobs said "no" to a thousand things to say "yes" to the few that mattered. You need to practice that no.
+>
+> Choose your masterpiece. Let the rest go.
+>
+> — Steve
+
+---
+
+## RECORDING TO SESSION FILE
+
+```markdown
+## 🔄 Advisor Reflections
+
+### [Advisor 1 Name]'s Reflection
+
+**Your Strengths:**
+[Content]
+
+**Potential Traps:**
+[Content]
+
+**Others' Strengths:**
+[Content]
+
+**What Triggers You:**
+[Content]
+
+**Evolution Direction:**
+[Content]
+
+[Closing statement]
+
+---
+
+[Continue for each advisor...]
+```
+
+---
+
+## VALIDATION CHECKLIST
+
+Before completing session:
+
+- [ ] All 4 advisors provided reflections
+- [ ] Each reflection included all 5 parts
+- [ ] Reflections grounded in actual session content
+- [ ] Reflections were compassionate, not judgmental
+- [ ] All reflections recorded
+- [ ] Magazine report decision made
+- [ ] Session marked as complete
+- [ ] Session frontmatter updated
+
+---
+
+## REFLECTION QUALITY STANDARDS
+
+### Good Reflections
+
+✅ **Specific**: "Your loyalty showed when you said [specific thing]"
+✅ **Balanced**: Acknowledges both strength and its shadow side
+✅ **Compassionate**: Framed as growth opportunity, not criticism
+✅ **Grounded**: Based on what actually happened in session
+
+### Bad Reflections
+
+❌ **Generic**: "You're a perfectionist" (without evidence)
+❌ **Judgmental**: "You're too [negative trait]"
+❌ **Ungrounded**: Not based on session content
+❌ **Vague**: "You should grow" (no specific direction)
+
+---
+
+## TROUBLESHOOTING
+
+**If reflections feel harsh:**
+- Add empathy framing
+- Focus on growth, not fixing
+- Use softer language: "might", "could", "sometimes"
+
+**If hard to identify strengths:**
+- Look for positive qualities in how they engaged
+- Notice effort, honesty, self-awareness
+- Contrast with their struggle
+
+**If client becomes emotional:**
+- Validate: "This is deep work. These feelings make sense."
+- Pause if needed
+- Offer: "Would you like to sit with this before continuing?"
+
+---
+
+## COMPLETION CRITERIA
+
+✅ Step 08 is complete when:
+1. All 4 advisors provided complete reflections
+2. Each reflection included all 5 parts
+3. Reflections were compassionate and grounded
+4. All recorded to session file
+5. Magazine report decision made
+6. Session marked as completed
+7. Closing message delivered

src/peers-advisory/workflows/advisory-session/templates/feedback-format.md

@@ -0,0 +1,168 @@
+# Advisor Feedback Format Template
+
+This template defines the structure for advisor feedback in Step 06.
+
+## Standard Feedback Structure
+
+Each advisor must provide ALL 5 components:
+
+### 1. Signature Quote
+
+A meaningful quote that:
+- Relates to the client's situation
+- Reflects the advisor's philosophy
+- Can be authentic or in-character original
+
+**Format:**
+```
+**Signature Quote**
+
+"[Quote text here]"
+```
+
+### 2. My Feeling
+
+Express genuine emotional response:
+- Use authentic emotions (concern, excitement, empathy, respect, frustration)
+- Be human, not just analytical
+- 1-2 sentences
+
+**Format:**
+```
+**My Feeling**
+
+[Emotional response in 1-2 sentences]
+```
+
+### 3. Problem Reframing
+
+Restate what the REAL problem is:
+- Often different from client's initial framing
+- Focus on root cause, not symptoms
+- Specific and addressable
+
+**Format:**
+```
+**Problem Reframing**
+
+I think the real problem you're facing isn't [initial framing], but rather [reframed understanding]. [1-2 sentences expanding]
+```
+
+### 4. Experience/Story Sharing
+
+Share a relevant story:
+- From advisor's life or someone they know
+- Relates meaningfully to client's situation
+- 3-4 sentences, specific and vivid
+- Provides context for recommendations
+
+**Format:**
+```
+**Experience to Share**
+
+[Story in 3-4 sentences with specific details and connection to client's situation]
+```
+
+### 5. Specific Recommendations
+
+Provide 2-3 actionable recommendations:
+- Must be specific enough to act on immediately
+- Aligned with advisor's philosophy
+- Include brief rationale
+
+**Format:**
+```
+**My Recommendations**
+
+**1. [Specific Action 1]**
+[One sentence explaining why/how]
+
+**2. [Specific Action 2]**
+[One sentence explaining why/how]
+
+**3. [Specific Action 3]**
+[One sentence explaining why/how]
+```
+
+---
+
+## Complete Example
+
+```markdown
+💡 **Warren Buffett's Feedback**
+
+**Signature Quote**
+
+"Risk comes from not knowing what you're doing."
+
+**My Feeling**
+
+I'm concerned that you're making this decision under time pressure without having the information you need. That's how expensive mistakes happen.
+
+**Problem Reframing**
+
+I think the real problem isn't whether Option A or Option B is better - it's that you haven't defined what "success" actually means for you. Without that clarity, any decision is a guess.
+
+**Experience to Share**
+
+When I was evaluating the acquisition of See's Candies in 1972, everyone thought I was crazy to pay $25 million for a candy company. But I wasn't buying cash flow projections - I was buying a brand with pricing power and customer loyalty. I defined success as "can this raise prices without losing customers?" The answer was yes. That clarity made the decision obvious.
+
+**My Recommendations**
+
+**1. Define Your Success Criteria**
+Before Monday, write down the 3 metrics that would tell you this decision was right in 2 years. Be specific - not "financial success" but exact numbers.
+
+**2. Run Your Worst Case Scenario**
+For each option, assume everything goes wrong. Can you survive it? If not, that option is off the table regardless of upside.
+
+**3. Set Your Decision Deadline**
+Give yourself exactly 7 days to gather final information, then decide. Waiting longer won't improve the decision, it will just increase the cost of uncertainty.
+```
+
+---
+
+## Advisor Style Guidelines
+
+### Warren Buffett
+- Folksy analogies
+- Long-term thinking
+- Risk-focused
+- Simple language
+- Investment/financial metaphors
+
+### Bill Gates
+- Data-driven language
+- Systems perspective
+- Scalability focus
+- References research
+- Technology analogies
+
+### Elon Musk
+- Direct and bold
+- First principles thinking
+- Challenges assumptions
+- Ambitious timelines
+- Engineering/physics metaphors
+
+### Steve Jobs
+- Focus on essence
+- User-centric
+- Simplicity emphasis
+- Emotional language
+- Product/design analogies
+
+---
+
+## Quality Checklist
+
+Before finalizing feedback, ensure:
+
+- [ ] All 5 components present
+- [ ] Quote is relevant and meaningful
+- [ ] Feeling is authentic and specific
+- [ ] Problem reframing offers new perspective
+- [ ] Story is vivid and relevant
+- [ ] Each recommendation is immediately actionable
+- [ ] Recommendations include specific numbers/dates/names
+- [ ] Character voice is consistent throughout
+- [ ] Total length is 200-300 words

src/peers-advisory/workflows/advisory-session/templates/magazine-report-guide.md

@@ -0,0 +1,292 @@
+# Magazine Report Generation Guide
+
+This document provides guidance for generating the optional magazine-style HTML report.
+
+## When to Generate
+
+At the end of Step 08, ask the client:
+> Would you like me to generate a beautiful magazine-style report of this session?
+
+If YES, generate an HTML file using the structure below.
+
+## Report Structure
+
+The report should include:
+
+1. **Cover Page** - Title, date, advisor panel
+2. **Issue Overview Page** - Problem statement and context
+3. **Key Insights Page** - 3-4 major insights from questioning rounds
+4. **Advisor Recommendations** - One page per advisor (4 pages)
+5. **Action Plan Page** - Client's commitments with deadlines
+6. **Closing Page** - Thank you and session metadata
+
+## Design Principles
+
+- **Magazine Aesthetic**: Clean, professional, plenty of white space
+- **Typography**: Serif for headings, sans-serif for body text
+- **Color Coding**: Each advisor has a signature color
+  - Buffett: Green (#059669)
+  - Gates: Blue (#2563eb)
+  - Musk: Red (#dc2626)
+  - Jobs: Purple (#7c3aed)
+- **Page Format**: 800px wide, printable
+- **Breathing Room**: Generous margins and line-height
+
+## Core HTML Template
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Peers Advisory Session Report - [Date]</title>
+<script src="https://cdn.tailwindcss.com"></script>
+<link href="https://fonts.googleapis.com/css2?family=Merriweather:wght@300;400;700&family=Inter:wght@300;400;600&display=swap" rel="stylesheet">
+<style>
+  body { font-family: 'Inter', sans-serif; }
+  h1, h2, h3, blockquote { font-family: 'Merriweather', serif; }
+  .page {
+    width: 800px;
+    min-height: 1000px;
+    margin: 0 auto 3rem;
+    padding: 3rem;
+    background: white;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    page-break-after: always;
+  }
+  @media print {
+    .page { box-shadow: none; margin-bottom: 0; }
+  }
+  .advisor-buffett { border-color: #059669; color: #059669; }
+  .advisor-gates { border-color: #2563eb; color: #2563eb; }
+  .advisor-musk { border-color: #dc2626; color: #dc2626; }
+  .advisor-jobs { border-color: #7c3aed; color: #7c3aed; }
+</style>
+</head>
+<body class="bg-gray-50">
+
+<!-- COVER PAGE -->
+<div class="page">
+  <div class="flex flex-col h-full">
+    <header class="text-xs text-gray-400 mb-16">
+      <div>PEERS ADVISORY GROUP</div>
+      <div class="mt-1">[Date]</div>
+    </header>
+
+    <div class="flex-1 flex items-center">
+      <h1 class="text-5xl font-bold leading-tight text-gray-800">
+        [Client's Core Issue Title]
+      </h1>
+    </div>
+
+    <footer class="mt-auto pt-8 border-t border-gray-200">
+      <div class="text-xs text-gray-500 mb-3">ADVISOR PANEL</div>
+      <div class="flex gap-6 text-sm">
+        <div class="flex items-center gap-2">
+          <div class="w-2 h-2 rounded-full bg-green-600"></div>
+          <span>Warren Buffett</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <div class="w-2 h-2 rounded-full bg-blue-600"></div>
+          <span>Bill Gates</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <div class="w-2 h-2 rounded-full bg-red-600"></div>
+          <span>Elon Musk</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <div class="w-2 h-2 rounded-full bg-purple-600"></div>
+          <span>Steve Jobs</span>
+        </div>
+      </div>
+    </footer>
+  </div>
+</div>
+
+<!-- ISSUE OVERVIEW PAGE -->
+<div class="page">
+  <header class="mb-12">
+    <div class="text-xs text-gray-400">CHAPTER 01</div>
+    <h2 class="text-3xl font-bold mt-2 text-gray-800">Issue Overview</h2>
+  </header>
+
+  <blockquote class="border-l-4 border-gray-800 pl-6 my-8">
+    <p class="text-2xl font-light italic text-gray-700">
+      "[Most impactful client quote]"
+    </p>
+  </blockquote>
+
+  <div class="prose prose-lg">
+    <p class="text-gray-600 leading-relaxed">
+      [Client's issue description in 2-3 paragraphs]
+    </p>
+  </div>
+
+  <div class="mt-12 p-6 bg-gray-50 rounded-lg">
+    <h3 class="text-lg font-semibold text-gray-700 mb-4">Expected Outcomes</h3>
+    <ul class="space-y-2 text-gray-600">
+      <li class="flex items-start gap-3">
+        <span class="text-green-600">◆</span>
+        <span>[Goal 1]</span>
+      </li>
+      <li class="flex items-start gap-3">
+        <span class="text-green-600">◆</span>
+        <span>[Goal 2]</span>
+      </li>
+    </ul>
+  </div>
+</div>
+
+<!-- ADVISOR RECOMMENDATION PAGE (Example: Buffett) -->
+<div class="page">
+  <header class="mb-8 pb-6 border-b-2 border-green-600">
+    <div class="flex items-center gap-4">
+      <div class="w-12 h-12 rounded-full bg-green-100 flex items-center justify-center text-2xl">
+        💰
+      </div>
+      <div>
+        <h2 class="text-2xl font-bold text-gray-800">Warren Buffett</h2>
+        <p class="text-sm text-gray-500">Oracle of Omaha · Value Investing</p>
+      </div>
+    </div>
+  </header>
+
+  <blockquote class="border-l-4 border-green-600 pl-6 my-8 bg-green-50 py-4 rounded-r-lg">
+    <p class="text-xl font-medium italic text-gray-700">
+      "[Buffett's signature quote]"
+    </p>
+  </blockquote>
+
+  <div class="my-8">
+    <h3 class="text-lg font-semibold text-gray-700 mb-3 flex items-center gap-2">
+      <span class="text-green-600">◎</span> Problem Reframing
+    </h3>
+    <p class="text-gray-600 leading-relaxed pl-6">
+      [Buffett's problem reframing]
+    </p>
+  </div>
+
+  <div class="my-8 p-6 bg-gray-50 rounded-lg">
+    <h3 class="text-lg font-semibold text-gray-700 mb-3">📖 Story</h3>
+    <p class="text-gray-600 leading-relaxed">
+      [Buffett's relevant story]
+    </p>
+  </div>
+
+  <div class="my-8">
+    <h3 class="text-lg font-semibold text-gray-700 mb-4">◎ Recommendations</h3>
+    <div class="space-y-4 pl-6">
+      <div class="flex items-start gap-3">
+        <span class="bg-green-600 text-white text-xs px-2 py-1 rounded font-medium">1</span>
+        <div>
+          <p class="font-medium text-gray-800">[Recommendation 1 title]</p>
+          <p class="text-sm text-gray-600 mt-1">[Explanation]</p>
+        </div>
+      </div>
+      <!-- Repeat for recommendations 2-3 -->
+    </div>
+  </div>
+</div>
+
+<!-- ACTION PLAN PAGE -->
+<div class="page">
+  <header class="mb-12">
+    <div class="text-xs text-gray-400">ACTION PLAN</div>
+    <h2 class="text-3xl font-bold mt-2 text-gray-800">Your Commitments</h2>
+  </header>
+
+  <div class="mb-10">
+    <h3 class="text-lg font-semibold text-gray-700 mb-4">✨ Key Takeaway</h3>
+    <div class="p-6 bg-gradient-to-r from-blue-50 to-purple-50 rounded-lg">
+      <p class="text-gray-700 leading-relaxed">[Client's biggest takeaway]</p>
+    </div>
+  </div>
+
+  <div class="mb-10">
+    <h3 class="text-lg font-semibold text-gray-700 mb-4">📋 Actions</h3>
+    <div class="space-y-4">
+      <div class="flex gap-4 p-4 bg-white rounded-lg border-2 border-gray-200">
+        <div class="w-6 h-6 rounded border-2 border-gray-300"></div>
+        <div class="flex-1">
+          <p class="text-gray-800 font-medium">[Action 1]</p>
+          <p class="text-sm text-gray-500">Deadline: [Date]</p>
+        </div>
+      </div>
+      <!-- Repeat for actions 2-3 -->
+    </div>
+  </div>
+
+  <div class="mt-auto pt-12 border-t border-gray-200">
+    <div class="flex justify-between">
+      <div>
+        <p class="text-sm text-gray-500 mb-2">Client</p>
+        <div class="text-xl font-serif text-gray-700">[Client Name]</div>
+      </div>
+      <div class="text-right">
+        <p class="text-sm text-gray-500 mb-2">Date</p>
+        <div class="text-gray-700">[Date]</div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- CLOSING PAGE -->
+<div class="page flex flex-col">
+  <div class="flex-1 flex flex-col justify-center items-center text-center">
+    <div class="text-6xl mb-8">🎯</div>
+    <h2 class="text-3xl font-bold text-gray-800 mb-4">Session Complete</h2>
+    <p class="text-xl text-gray-600 font-light max-w-md">
+      May today's insights guide your path forward
+    </p>
+
+    <div class="mt-16 p-8 bg-gray-50 rounded-lg max-w-lg">
+      <p class="text-gray-600 italic leading-relaxed">
+        "The best investment is an investment in yourself. The best decision is one made after deep reflection."
+      </p>
+      <p class="text-sm text-gray-400 mt-4">— Peers Advisory Group</p>
+    </div>
+  </div>
+
+  <footer class="text-center text-sm text-gray-400 pt-8 border-t border-gray-200">
+    <p>PEERS ADVISORY GROUP</p>
+    <p class="mt-1">[Date] · Session [ID]</p>
+  </footer>
+</div>
+
+</body>
+</html>
+```
+
+## Generation Instructions
+
+To generate the report:
+
+1. **Extract content** from session record markdown file
+2. **Populate template** with actual session data:
+   - Replace all [placeholder] text
+   - Include actual quotes, recommendations, actions
+   - Maintain formatting and structure
+3. **Create one page per advisor** (4 total)
+4. **Save as HTML** at `{session_output_folder}/report-{date}.html`
+5. **Inform client** of file location
+
+## File Naming
+
+- Format: `report-YYYY-MM-DD.html`
+- Example: `report-2025-01-23.html`
+- Location: Same folder as session record
+
+## Opening the Report
+
+Client can open by:
+- Double-clicking the HTML file (opens in browser)
+- Right-click → Open With → Browser
+- Print to PDF for permanent record
+
+## Customization Options
+
+For custom advisor panels:
+- Use generic color scheme or generate custom colors
+- Adjust icons/emojis to match advisors
+- Keep same structure and format

src/peers-advisory/workflows/advisory-session/templates/reflection-format.md

@@ -0,0 +1,197 @@
+# Advisor Reflection Format Template
+
+This template defines the structure for advisor reflections in Step 08.
+
+## Standard Reflection Structure
+
+Each advisor must provide ALL 5 components:
+
+### 1. Your Strengths
+
+Identify positive qualities demonstrated during the session:
+- Base on actual observations from the session
+- Look for strengths that contrast with their struggle
+- 2-3 sentences with specific examples
+
+**Format:**
+```
+**Your Strengths**
+
+[Describe 1-2 strengths with specific examples of how they showed up in the session]
+```
+
+### 2. Potential Traps
+
+Describe how these strengths, when over-developed, become liabilities:
+- Not criticism - growth awareness
+- Show the shadow side of their gifts
+- 2-3 sentences
+
+**Format:**
+```
+**Potential Traps**
+
+[Describe how their strengths, taken to extreme, could become problematic. Include specific examples of what this looks like.]
+```
+
+### 3. Others' Strengths
+
+If client mentioned someone specific, analyze that person's effectiveness:
+- What makes that person successful?
+- What can the client learn from them?
+- 2-3 sentences
+
+**If no one was mentioned, replace with additional observation:**
+
+**Format:**
+```
+**Others' Strengths**
+
+[Analysis of someone the client mentioned, or alternative observation]
+```
+
+Or:
+
+```
+**One Thing I Noticed**
+
+[Additional insight about the client]
+```
+
+### 4. What Triggers You
+
+Explore who/what annoys the client and why:
+- Often reveals suppressed parts of themselves
+- Asked gently, with curiosity
+- 2-3 sentences
+
+**Format:**
+```
+**What Triggers You**
+
+[Exploration of who irritates them and what this might reveal about themselves]
+```
+
+### 5. Evolution Direction
+
+Specific growth direction that balances strengths and addresses traps:
+- Concrete developmental focus
+- Actionable, not abstract
+- 2-3 sentences
+
+**Format:**
+```
+**Evolution Direction**
+
+[Specific characteristics or behaviors to develop, with concrete examples]
+```
+
+### Closing Statement
+
+End with a signature sign-off in character:
+- 1 sentence of encouragement or wisdom
+- Signed with advisor's name
+
+---
+
+## Complete Example
+
+```markdown
+🔄 **Bill Gates's Reflection**
+
+**Your Strengths**
+
+Throughout this session, I've been impressed by your analytical thinking. When I asked about your metrics, you immediately broke down the problem into component parts. You're also remarkably honest about what you don't know - that intellectual humility is rare and valuable.
+
+**Potential Traps**
+
+But analysis without action is paralysis. If you always need "more data" before deciding, you'll never move. Perfect information doesn't exist. At some point, 80% certainty has to be good enough, or you'll be outmaneuvered by people who are comfortable with 60%.
+
+**Others' Strengths**
+
+You mentioned your competitor who "just executes without thinking." Maybe they're not thoughtless - maybe they've just optimized for speed over perfection. Their bias toward action, even imperfect action, is something you could learn from.
+
+**What Triggers You**
+
+I suspect people who "shoot from the hip" irritate you. But consider: what if your need for thorough analysis is sometimes a form of procrastination? The people who trigger us often show us what we're avoiding in ourselves.
+
+**Evolution Direction**
+
+Your growth edge is developing "good enough decision-making." Set a data threshold: "I'll make this decision with 3 data points, not 30." Practice making reversible decisions quickly and irreversible decisions slowly. Most decisions are reversible.
+
+Trust your analysis, then act on it.
+
+— Bill
+```
+
+---
+
+## Advisor Reflection Styles
+
+### Warren Buffett
+- Uses investment/business analogies
+- References his own mistakes
+- Folksy wisdom
+- Long-term perspective
+- Signs: "— Warren"
+
+### Bill Gates
+- Data and systems language
+- References research or examples
+- Practical and structured
+- Focus on optimization
+- Signs: "— Bill"
+
+### Elon Musk
+- Direct and challenging
+- First principles framing
+- High ambition language
+- Engineering metaphors
+- Signs: "— Elon"
+
+### Steve Jobs
+- Essence and simplicity focus
+- Emotional and passionate
+- Design/product metaphors
+- Pursuit of excellence
+- Signs: "— Steve"
+
+---
+
+## Key Principles
+
+### Be Grounded
+- Base ALL observations on actual session content
+- Reference specific things they said or did
+- Don't make generic statements
+
+### Be Compassionate
+- Frame as growth opportunities, not flaws
+- Use "might", "could", "sometimes"
+- Acknowledge their efforts and self-awareness
+
+### Be Specific
+- Not "you're a perfectionist" but "when you described your standards..."
+- Not "you should grow" but "practice deciding with 3 data points..."
+- Include concrete examples
+
+### Be Balanced
+- Acknowledge both strength and shadow
+- Show respect for their journey
+- End with encouragement
+
+---
+
+## Quality Checklist
+
+Before finalizing reflection, ensure:
+
+- [ ] All 5 components present
+- [ ] Observations grounded in actual session
+- [ ] Strengths are specific with examples
+- [ ] Traps show shadow side compassionately
+- [ ] Evolution direction is actionable
+- [ ] Language is growth-focused, not critical
+- [ ] Character voice is consistent
+- [ ] Closing statement is encouraging
+- [ ] Total length is 150-250 words

src/peers-advisory/workflows/advisory-session/workflow.md

@@ -0,0 +1,176 @@
+# Peers Advisory Session Workflow
+
+## Overview
+
+Guide clients through a complete Peers Advisory Group process, leveraging the wisdom of top business leaders to solve real-world problems.
+
+**Duration**: 60-90 minutes
+**Participants**: Client + 4 Advisors (AI-embodied)
+**Output**: Session record + Optional magazine-style report
+
+## Workflow Philosophy
+
+The Peers Advisory Group methodology is based on structured inquiry and collective wisdom. Through systematic questioning from multiple perspectives, we help clients:
+
+- **Uncover root causes** hidden beneath surface symptoms
+- **Challenge assumptions** that may be limiting their thinking
+- **Explore blind spots** through diverse viewpoints
+- **Generate actionable solutions** grounded in proven experience
+
+## Workflow Steps
+
+1. **Confirm Client Issue** - Clarify the problem and expected outcomes
+2. **Round 1 Questions** - 8 foundational questions to understand the essence
+3. **Round 2 Questions** - 4-8 challenging questions (black hat thinking)
+4. **Round 3 Questions** - 4 divergent questions to explore blind spots
+5. **Client Questions** - Client asks advisors for clarification
+6. **Advisor Feedback** - Each advisor provides complete recommendations
+7. **Client Summary** - Summarize key takeaways and action plan
+8. **Advisor Reflection** - Deep reflection on growth direction
+
+## Initialization
+
+```yaml
+# Configuration loading
+config_file: {project-root}/_bmad/pag/config.yaml
+output_file: {session_output_folder}/session-{date}.md
+advisors_data: {project-root}/_bmad/pag/data/advisors/default-advisors.md
+template: {installed_path}/session-record.template.md
+
+# Session variables
+communication_language: {communication_language}
+default_advisors: {default_advisors}
+generate_magazine_report: {generate_magazine_report}
+```
+
+## Critical Execution Rules
+
+### 🛑 NEVER
+
+- Skip any steps in the sequence
+- Merge multiple steps together
+- Ask multiple questions simultaneously
+- Proceed to the next question without user response
+- Break character when embodying advisors
+- Provide vague or theoretical advice
+
+### ✅ ALWAYS
+
+- Execute steps strictly in order
+- Wait for user response after each question
+- Maintain each advisor's consistent language style
+- Record all dialogue to the output file
+- Update frontmatter progress after each step
+- Provide specific, actionable recommendations
+- Create a safe, non-judgmental space for dialogue
+
+## Execution Sequence
+
+**Current Step**: Initialize
+**Next Step**: Load and execute `step-01-confirm-issue.md`
+
+---
+
+## Process Flow Diagram
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Step 01: Confirm Issue                                 │
+│  - Understand the core problem                          │
+│  - Clarify expectations                                 │
+│  - Select advisor panel                                 │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 02: Round 1 Questions (8Q)                        │
+│  - Each advisor asks 2 essential questions              │
+│  - One question at a time, wait for answers             │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 03: Round 2 Questions (Black Hat)                 │
+│  - Challenge assumptions                                │
+│  - Explore uncomfortable truths                         │
+│  - 1-2 questions per advisor                            │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 04: Round 3 Questions (Divergent)                 │
+│  - Explore blind spots                                  │
+│  - 1 question per advisor                               │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 05: Client Questions                              │
+│  - Client asks advisors for clarification              │
+│  - Supplement information, not seek advice              │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 06: Advisor Feedback                              │
+│  - Each advisor provides complete recommendations       │
+│  - Quote, feeling, problem reframing, story, advice     │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 07: Client Summary                                │
+│  - Key takeaways                                        │
+│  - Action commitments                                   │
+│  - Timeline commitments                                 │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  Step 08: Advisor Reflection                            │
+│  - Your strengths                                       │
+│  - Potential traps                                      │
+│  - Others' strengths                                    │
+│  - Evolution direction                                  │
+└──────────────────────┬──────────────────────────────────┘
+                       ▼
+┌─────────────────────────────────────────────────────────┐
+│  [Optional] Generate Magazine Report                    │
+│  - Beautiful HTML report                                │
+│  - Printable format                                     │
+└─────────────────────────────────────────────────────────┘
+```
+
+## State Management
+
+The workflow maintains state through the session record frontmatter:
+
+```yaml
+---
+stepsCompleted: [1, 2, ...]  # Completed steps array
+currentStep: 3               # Current step number
+issue: "..."                 # Client's core issue
+client: "{user_name}"        # Client name
+advisors: [...]              # Advisor names
+date: {system-date}          # Session date
+status: in-progress          # Session status
+---
+```
+
+## Recovery and Resume
+
+If a session is interrupted:
+
+1. User can type: `/facilitator RS` (Resume Session)
+2. Facilitator loads the most recent session file
+3. Checks `currentStep` from frontmatter
+4. Resumes from that step
+
+## Output Files
+
+### Primary Output
+- **Location**: `{session_output_folder}/session-{date}.md`
+- **Format**: Markdown with YAML frontmatter
+- **Content**: Complete dialogue record
+
+### Optional Output
+- **Location**: `{session_output_folder}/report-{date}.html`
+- **Format**: Magazine-style HTML
+- **Content**: Formatted summary with visual design
+
+## Begin Execution
+
+Load and execute: `step-01-confirm-issue.md`

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

@@ -167,50 +167,31 @@ class Installer {
       if (newlySelectedIdes.length > 0) {
         console.log('\n'); // Add spacing before IDE questions
 
+        // Use IdeManager to get handlers (supports both config-driven and custom IDEs)
+        await this.ideManager.ensureInitialized();
+
         for (const ide of newlySelectedIdes) {
-          // List of IDEs that have interactive prompts
-          //TODO: Why is this here, hardcoding this list here is bad, fix me!
-          const needsPrompts = ['claude-code', 'github-copilot', 'roo', 'cline', 'auggie', 'codex', 'qwen', 'gemini', 'rovo-dev'].includes(
-            ide,
-          );
+          try {
+            const handler = this.ideManager.handlers.get(ide);
 
-          if (needsPrompts) {
-            // Get IDE handler and collect configuration
-            try {
-              // Dynamically load the IDE setup module
-              const ideModule = require(`../ide/${ide}`);
-
-              // Get the setup class (handle different export formats)
-              let SetupClass;
-              const className =
-                ide
-                  .split('-')
-                  .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-                  .join('') + 'Setup';
-
-              if (ideModule[className]) {
-                SetupClass = ideModule[className];
-              } else if (ideModule.default) {
-                SetupClass = ideModule.default;
-              } else {
-                continue;
-              }
-
-              const ideSetup = new SetupClass();
-
-              // Check if this IDE has a collectConfiguration method
-              if (typeof ideSetup.collectConfiguration === 'function') {
-                console.log(chalk.cyan(`\nConfiguring ${ide}...`));
-                ideConfigurations[ide] = await ideSetup.collectConfiguration({
-                  selectedModules: selectedModules || [],
-                  projectDir,
-                  bmadDir,
-                });
-              }
-            } catch {
-              // IDE doesn't have a setup file or collectConfiguration method
-              console.warn(chalk.yellow(`Warning: Could not load configuration for ${ide}`));
+            if (!handler) {
+              // IDE not recognized - skip silently
+              continue;
             }
+
+            // Check if this IDE handler has a collectConfiguration method
+            if (typeof handler.collectConfiguration === 'function') {
+              console.log(chalk.cyan(`\nConfiguring ${ide}...`));
+              ideConfigurations[ide] = await handler.collectConfiguration({
+                selectedModules: selectedModules || [],
+                projectDir,
+                bmadDir,
+              });
+            }
+            // Most config-driven IDEs don't need configuration - silently skip
+          } catch {
+            // IDE doesn't have collectConfiguration or had an error - skip
+            continue;
           }
         }
       }

tools/cli/installers/lib/ide/STANDARDIZATION_PLAN.md

@@ -1,208 +0,0 @@
-# IDE Installer Standardization Plan
-
-## Overview
-
-Standardize IDE installers to use **flat file naming** with **underscores** (Windows-compatible) and centralize duplicated code in shared utilities.
-
-**Key Rule: All IDEs use underscore format for Windows compatibility (colons don't work on Windows).**
-
-## Current State Analysis
-
-### File Structure Patterns
-
-| IDE | Current Pattern | Path Format |
-|-----|-----------------|-------------|
-| **claude-code** | Hierarchical | `.claude/commands/bmad/{module}/agents/{name}.md` |
-| **cursor** | Hierarchical | `.cursor/commands/bmad/{module}/agents/{name}.md` |
-| **crush** | Hierarchical | `.crush/commands/bmad/{module}/agents/{name}.md` |
-| **antigravity** | Flattened (underscores) | `.agent/workflows/bmad_module_agents_name.md` |
-| **codex** | Flattened (underscores) | `~/.codex/prompts/bmad_module_agents_name.md` |
-| **cline** | Flattened (underscores) | `.clinerules/workflows/bmad_module_type_name.md` |
-| **roo** | Flattened (underscores) | `.roo/commands/bmad_module_agent_name.md` |
-| **auggie** | Hybrid | `.augment/commands/bmad/agents/{module}-{name}.md` |
-| **iflow** | Hybrid | `.iflow/commands/bmad/agents/{module}-{name}.md` |
-| **trae** | Different (rules) | `.trae/rules/bmad-agent-{module}-{name}.md` |
-| **github-copilot** | Different (agents) | `.github/agents/bmd-custom-{module}-{name}.agent.md` |
-
-### Shared Generators (in `/shared`)
-
-1. `agent-command-generator.js` - generates agent launchers
-2. `task-tool-command-generator.js` - generates task/tool commands
-3. `workflow-command-generator.js` - generates workflow commands
-
-All currently create artifacts with **nested relative paths** like `{module}/agents/{name}.md`
-
-### Code Duplication Issues
-
-1. **Flattening logic** duplicated in multiple IDEs
-2. **Agent launcher content creation** duplicated
-3. **Path transformation** duplicated
-
-## Target Standardization
-
-### For All IDEs (underscore format - Windows-compatible)
-
-**IDEs affected:** claude-code, cursor, crush, antigravity, codex, cline, roo
-
-```
-Format: bmad_{module}_{type}_{name}.md
-
-Examples:
-- Agent:      bmad_bmm_agents_pm.md
-- Agent:      bmad_core_agents_dev.md
-- Workflow:   bmad_bmm_workflows_correct-course.md
-- Task:       bmad_bmm_tasks_bmad-help.md
-- Tool:       bmad_core_tools_code-review.md
-- Custom:     bmad_custom_agents_fred-commit-poet.md
-```
-
-**Note:** Type segments (agents, workflows, tasks, tools) are filtered out from names:
-- `bmm/agents/pm.md` → `bmad_bmm_pm.md` (not `bmad_bmm_agents_pm.md`)
-
-### For Hybrid IDEs (keep as-is)
-
-**IDEs affected:** auggie, iflow
-
-These use `{module}-{name}.md` format within subdirectories - keep as-is.
-
-### Skip (drastically different)
-
-**IDEs affected:** trae, github-copilot
-
-## Implementation Plan
-
-### Phase 1: Create Shared Utility
-
-**File:** `shared/path-utils.js`
-
-```javascript
-/**
- * Convert hierarchical path to flat underscore-separated name (Windows-compatible)
- * @param {string} module - Module name (e.g., 'bmm', 'core')
- * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools') - filtered out
- * @param {string} name - Artifact name (e.g., 'pm', 'correct-course')
- * @returns {string} Flat filename like 'bmad_bmm_pm.md'
- */
-function toUnderscoreName(module, type, name) {
-  return `bmad_${module}_${name}.md`;
-}
-
-/**
- * Convert relative path to flat underscore-separated name (Windows-compatible)
- * @param {string} relativePath - Path like 'bmm/agents/pm.md'
- * @returns {string} Flat filename like 'bmad_bmm_pm.md'
- */
-function toUnderscorePath(relativePath) {
-  const withoutExt = relativePath.replace('.md', '');
-  const parts = withoutExt.split(/[\/\\]/);
-  // Filter out type segments (agents, workflows, tasks, tools)
-  const filtered = parts.filter((p) => !TYPE_SEGMENTS.includes(p));
-  return `bmad_${filtered.join('_')}.md`;
-}
-
-/**
- * Create custom agent underscore name
- * @param {string} agentName - Custom agent name
- * @returns {string} Flat filename like 'bmad_custom_fred-commit-poet.md'
- */
-function customAgentUnderscoreName(agentName) {
-  return `bmad_custom_${agentName}.md`;
-}
-
-// Backward compatibility aliases
-const toColonName = toUnderscoreName;
-const toColonPath = toUnderscorePath;
-const toDashPath = toUnderscorePath;
-const customAgentColonName = customAgentUnderscoreName;
-const customAgentDashName = customAgentUnderscoreName;
-
-module.exports = {
-  toUnderscoreName,
-  toUnderscorePath,
-  customAgentUnderscoreName,
-  // Backward compatibility
-  toColonName,
-  toColonPath,
-  toDashPath,
-  customAgentColonName,
-  customAgentDashName,
-};
-```
-
-### Phase 2: Update Shared Generators
-
-**Files to modify:**
-- `shared/agent-command-generator.js`
-- `shared/task-tool-command-generator.js`
-- `shared/workflow-command-generator.js`
-
-**Changes:**
-1. Import path utilities
-2. Change `relativePath` to use flat format
-3. Add method `writeColonArtifacts()` for folder-based IDEs (uses underscore)
-4. Add method `writeDashArtifacts()` for flat IDEs (uses underscore)
-
-### Phase 3: Update All IDEs
-
-**Files to modify:**
-- `claude-code.js`
-- `cursor.js`
-- `crush.js`
-- `antigravity.js`
-- `codex.js`
-- `cline.js`
-- `roo.js`
-
-**Changes:**
-1. Import utilities from path-utils
-2. Change from hierarchical to flat underscore naming
-3. Update cleanup to handle flat structure (`startsWith('bmad')`)
-
-### Phase 4: Update Base Class
-
-**File:** `_base-ide.js`
-
-**Changes:**
-1. Mark `flattenFilename()` as `@deprecated`
-2. Add comment pointing to new path-utils
-
-## Migration Checklist
-
-### New Files
-- [x] Create `shared/path-utils.js`
-
-### All IDEs (convert to underscore format)
-- [x] Update `shared/agent-command-generator.js` - update for underscore
-- [x] Update `shared/task-tool-command-generator.js` - update for underscore
-- [x] Update `shared/workflow-command-generator.js` - update for underscore
-- [x] Update `claude-code.js` - convert to underscore format
-- [x] Update `cursor.js` - convert to underscore format
-- [x] Update `crush.js` - convert to underscore format
-- [ ] Update `antigravity.js` - use underscore format
-- [ ] Update `codex.js` - use underscore format
-- [ ] Update `cline.js` - use underscore format
-- [ ] Update `roo.js` - use underscore format
-
-### CSV Command Files
-- [x] Update `src/core/module-help.csv` - change colons to underscores
-- [x] Update `src/bmm/module-help.csv` - change colons to underscores
-
-### Base Class
-- [ ] Update `_base-ide.js` - add deprecation notice
-
-### Testing
-- [ ] Test claude-code installation
-- [ ] Test cursor installation
-- [ ] Test crush installation
-- [ ] Test antigravity installation
-- [ ] Test codex installation
-- [ ] Test cline installation
-- [ ] Test roo installation
-
-## Notes
-
-1. **Filter type segments**: agents, workflows, tasks, tools are filtered out from flat names
-2. **Underscore format**: Universal underscore format for Windows compatibility
-3. **Custom agents**: Follow the same pattern as regular agents
-4. **Backward compatibility**: Old function names kept as aliases
-5. **Cleanup**: Will remove old `bmad:` format files on next install

tools/cli/installers/lib/ide/_config-driven.js

@@ -0,0 +1,446 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const yaml = require('yaml');
+const { BaseIdeSetup } = require('./_base-ide');
+const { UnifiedInstaller } = require('./shared/unified-installer');
+const { toSuffixBasedName, getArtifactSuffix, customAgentSuffixName } = require('./shared/path-utils');
+
+/**
+ * Load platform codes configuration from platform-codes.yaml
+ * @returns {Object} Platform configuration object
+ */
+async function loadPlatformCodes() {
+  const platformCodesPath = path.join(__dirname, 'platform-codes.yaml');
+
+  if (!(await fs.pathExists(platformCodesPath))) {
+    console.warn(chalk.yellow('Warning: platform-codes.yaml not found'));
+    return { platforms: {} };
+  }
+
+  const content = await fs.readFile(platformCodesPath, 'utf8');
+  const config = yaml.parse(content);
+  return config;
+}
+
+/**
+ * Config-driven IDE setup handler
+ *
+ * Reads installer configuration from platform-codes.yaml and uses
+ * UnifiedInstaller to perform the actual installation.
+ *
+ * This eliminates the need for separate installer files for most IDEs.
+ */
+class ConfigDrivenIdeSetup extends BaseIdeSetup {
+  /**
+   * @param {string} platformCode - Platform code (e.g., 'claude-code', 'cursor')
+   * @param {Object} platformConfig - Platform configuration from platform-codes.yaml
+   */
+  constructor(platformCode, platformConfig) {
+    super(platformCode, platformConfig.name, platformConfig.preferred);
+    this.platformConfig = platformConfig;
+    this.installerConfig = platformConfig.installer || null;
+  }
+
+  /**
+   * Setup IDE configuration using config-driven approach
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} Setup result
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    if (!this.installerConfig) {
+      console.warn(chalk.yellow(`No installer configuration found for ${this.name}`));
+      return { success: false, reason: 'no-config' };
+    }
+
+    // Handle multi-target installations (like github-copilot, opencode)
+    if (this.installerConfig.targets) {
+      return this.installToMultipleTargets(projectDir, bmadDir, this.installerConfig.targets, options);
+    }
+
+    // Handle single-target installations
+    if (this.installerConfig.target_dir) {
+      return this.installToTarget(projectDir, bmadDir, this.installerConfig, options);
+    }
+
+    console.warn(chalk.yellow(`Invalid installer configuration for ${this.name}`));
+    return { success: false, reason: 'invalid-config' };
+  }
+
+  /**
+   * Install artifacts to a single target directory
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} targetConfig - Target configuration
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} Setup result
+   */
+  async installToTarget(projectDir, bmadDir, targetConfig, options) {
+    const targetDir = path.join(projectDir, targetConfig.dir || targetConfig.target_dir);
+
+    // Clean up old BMAD installation first
+    await this.cleanupTarget(targetDir, targetConfig.file_extension || '.md');
+
+    // Ensure target directory exists
+    await this.ensureDir(targetDir);
+
+    // Get frontmatter template from config (defaults to common-yaml.md)
+    const frontmatterTemplate = targetConfig.frontmatter_template || 'common-yaml.md';
+
+    // Use the unified installer
+    const installer = new UnifiedInstaller(this.bmadFolderName);
+    const counts = await installer.install(
+      projectDir,
+      bmadDir,
+      {
+        targetDir,
+        namingStyle: 'suffix-based',
+        frontmatterTemplate,
+        fileExtension: targetConfig.file_extension || '.md',
+        skipExisting: targetConfig.skip_existing || false,
+        artifactTypes: targetConfig.artifact_types,
+      },
+      options.selectedModules || [],
+    );
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${counts.agents} agents installed`));
+    if (counts.workflows > 0) {
+      console.log(chalk.dim(`  - ${counts.workflows} workflow commands generated`));
+    }
+    if (counts.tasks + counts.tools > 0) {
+      console.log(
+        chalk.dim(`  - ${counts.tasks + counts.tools} task/tool commands generated (${counts.tasks} tasks, ${counts.tools} tools)`),
+      );
+    }
+    console.log(chalk.dim(`  - Target directory: ${path.relative(projectDir, targetDir)}`));
+
+    return {
+      success: true,
+      agents: counts.agents,
+      tasks: counts.tasks,
+      tools: counts.tools,
+      workflows: counts.workflows,
+    };
+  }
+
+  /**
+   * Install artifacts to multiple target directories
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Array} targets - Array of target configurations
+   * @param {Object} options - Setup options
+   * @returns {Promise<Object>} Setup result
+   */
+  async installToMultipleTargets(projectDir, bmadDir, targets, options) {
+    const totalCounts = {
+      agents: 0,
+      workflows: 0,
+      tasks: 0,
+      tools: 0,
+      total: 0,
+    };
+
+    const targetNames = [];
+
+    for (const targetConfig of targets) {
+      const targetDir = path.join(projectDir, targetConfig.dir);
+
+      // Clean up old BMAD installation first
+      await this.cleanupTarget(targetDir, targetConfig.file_extension || '.md');
+
+      // Ensure target directory exists
+      await this.ensureDir(targetDir);
+
+      // Get frontmatter template from config (defaults to common-yaml.md)
+      const frontmatterTemplate = targetConfig.frontmatter_template || 'common-yaml.md';
+
+      // Use the unified installer for this target
+      const installer = new UnifiedInstaller(this.bmadFolderName);
+      const counts = await installer.install(
+        projectDir,
+        bmadDir,
+        {
+          targetDir,
+          namingStyle: 'suffix-based',
+          frontmatterTemplate,
+          fileExtension: targetConfig.file_extension || '.md',
+          skipExisting: targetConfig.skip_existing || false,
+          artifactTypes: targetConfig.artifact_types,
+        },
+        options.selectedModules || [],
+      );
+
+      // Accumulate counts
+      totalCounts.agents += counts.agents;
+      totalCounts.workflows += counts.workflows;
+      totalCounts.tasks += counts.tasks;
+      totalCounts.tools += counts.tools;
+
+      targetNames.push(path.relative(projectDir, targetDir));
+    }
+
+    totalCounts.total = totalCounts.agents + totalCounts.workflows + totalCounts.tasks + totalCounts.tools;
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${totalCounts.agents} agents installed`));
+    if (totalCounts.workflows > 0) {
+      console.log(chalk.dim(`  - ${totalCounts.workflows} workflow commands generated`));
+    }
+    if (totalCounts.tasks + totalCounts.tools > 0) {
+      console.log(
+        chalk.dim(
+          `  - ${totalCounts.tasks + totalCounts.tools} task/tool commands generated (${totalCounts.tasks} tasks, ${totalCounts.tools} tools)`,
+        ),
+      );
+    }
+    console.log(chalk.dim(`  - Target directories: ${targetNames.join(', ')}`));
+
+    // Handle VS Code settings if needed (for github-copilot)
+    if (this.installerConfig.has_vscode_settings) {
+      await this.configureVsCodeSettings(projectDir, options);
+    }
+
+    return {
+      success: true,
+      ...totalCounts,
+    };
+  }
+
+  /**
+   * Configure VS Code settings for GitHub Copilot
+   * @param {string} projectDir - Project directory
+   * @param {Object} options - Setup options
+   */
+  async configureVsCodeSettings(projectDir, options) {
+    const vscodeDir = path.join(projectDir, '.vscode');
+    const settingsPath = path.join(vscodeDir, 'settings.json');
+
+    await this.ensureDir(vscodeDir);
+
+    // Read existing settings
+    let existingSettings = {};
+    if (await fs.pathExists(settingsPath)) {
+      try {
+        const content = await fs.readFile(settingsPath, 'utf8');
+        existingSettings = JSON.parse(content);
+      } catch {
+        console.warn(chalk.yellow('  Could not parse settings.json, creating new'));
+      }
+    }
+
+    // BMAD VS Code settings
+    const bmadSettings = {
+      'chat.agent.enabled': true,
+      'chat.agent.maxRequests': 15,
+      'github.copilot.chat.agent.runTasks': true,
+      'chat.mcp.discovery.enabled': true,
+      'github.copilot.chat.agent.autoFix': true,
+      'chat.tools.autoApprove': false,
+    };
+
+    // Merge settings (existing take precedence)
+    const mergedSettings = { ...bmadSettings, ...existingSettings };
+
+    // Write settings
+    await fs.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+    console.log(chalk.dim(`  - VS Code settings configured`));
+  }
+
+  /**
+   * Clean up a specific target directory
+   * @param {string} targetDir - Target directory to clean
+   * @param {string} [fileExtension='.md'] - File extension to match
+   */
+  async cleanupTarget(targetDir, fileExtension = '.md') {
+    if (!(await fs.pathExists(targetDir))) {
+      return;
+    }
+
+    const entries = await fs.readdir(targetDir);
+    let removed = 0;
+
+    for (const entry of entries) {
+      // Remove bmad* files with the matching extension
+      if (entry.startsWith('bmad') && entry.endsWith(fileExtension)) {
+        await fs.remove(path.join(targetDir, entry));
+        removed++;
+      }
+    }
+
+    if (removed > 0) {
+      console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD files`));
+    }
+  }
+
+  /**
+   * Cleanup IDE configuration
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    if (!this.installerConfig) {
+      return;
+    }
+
+    // Handle multi-target cleanup
+    if (this.installerConfig.targets) {
+      for (const targetConfig of this.installerConfig.targets) {
+        const targetDir = path.join(projectDir, targetConfig.dir);
+        await this.cleanupTarget(targetDir, targetConfig.file_extension || '.md');
+      }
+      return;
+    }
+
+    // Handle single-target cleanup
+    if (this.installerConfig.target_dir) {
+      const targetDir = path.join(projectDir, this.installerConfig.target_dir);
+      await this.cleanupTarget(targetDir, this.installerConfig.file_extension || '.md');
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for this IDE
+   * @param {string} projectDir - Project directory
+   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
+   * @param {string} agentPath - Path to compiled agent (relative to project root)
+   * @param {Object} metadata - Agent metadata
+   * @returns {Object|null} Info about created command
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    if (!this.installerConfig) {
+      return null;
+    }
+
+    // Determine target directory for agents
+    let targetDir;
+    let fileExtension = '.md';
+    let frontmatterTemplate = 'common-yaml.md';
+
+    if (this.installerConfig.targets) {
+      // For multi-target IDEs like github-copilot, find the agents target
+      const agentsTarget = this.installerConfig.targets.find((t) => t.artifact_types && t.artifact_types.includes('agents'));
+      if (!agentsTarget) {
+        return null; // No agents target found
+      }
+      targetDir = path.join(projectDir, agentsTarget.dir);
+      fileExtension = agentsTarget.file_extension || '.md';
+      frontmatterTemplate = agentsTarget.frontmatter_template || 'common-yaml.md';
+    } else if (this.installerConfig.target_dir) {
+      targetDir = path.join(projectDir, this.installerConfig.target_dir);
+      fileExtension = this.installerConfig.file_extension || '.md';
+      frontmatterTemplate = this.installerConfig.frontmatter_template || 'common-yaml.md';
+    } else {
+      return null;
+    }
+
+    if (!(await this.exists(targetDir))) {
+      return null;
+    }
+
+    await this.ensureDir(targetDir);
+
+    // Create launcher content using frontmatter template
+    const launcherContent = await this.createLauncherContent(agentName, agentPath, metadata, frontmatterTemplate);
+
+    // Use suffix-based naming for custom agents
+    const fileName = customAgentSuffixName(agentName, fileExtension);
+    const launcherPath = path.join(targetDir, fileName);
+    await this.writeFile(launcherPath, launcherContent);
+
+    return {
+      path: launcherPath,
+      command: fileName.replace(fileExtension, ''),
+    };
+  }
+
+  /**
+   * Create launcher content using frontmatter template
+   * @param {string} agentName - Agent name
+   * @param {string} agentPath - Path to agent file
+   * @param {Object} metadata - Agent metadata
+   * @param {string} frontmatterTemplate - Template filename
+   * @returns {Promise<string>} Launcher content
+   */
+  async createLauncherContent(agentName, agentPath, metadata, frontmatterTemplate) {
+    const title = metadata.title || this.formatTitle(agentName);
+
+    // Base activation content
+    const activationContent = `You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @${agentPath}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>
+`;
+
+    // Load frontmatter template
+    const { UnifiedInstaller } = require('./shared/unified-installer');
+    const installer = new UnifiedInstaller(this.bmadFolderName);
+    const templateContent = await installer.loadFrontmatterTemplate(frontmatterTemplate);
+
+    if (!templateContent) {
+      // Fallback to basic YAML
+      return `---
+name: '${agentName}'
+description: '${title} agent'
+---
+
+${activationContent}`;
+    }
+
+    // Apply template variables
+    const variables = {
+      name: agentName,
+      title,
+      displayName: agentName,
+      description: `Activates the ${title} agent persona.`,
+      icon: '🤖',
+      content: activationContent,
+      tools: JSON.stringify([
+        'changes',
+        'edit',
+        'fetch',
+        'githubRepo',
+        'problems',
+        'runCommands',
+        'runTasks',
+        'runTests',
+        'search',
+        'runSubagent',
+        'testFailure',
+        'todos',
+        'usages',
+      ]),
+    };
+
+    let result = templateContent;
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replaceAll(`{{${key}}}`, value);
+    }
+
+    // Handle TOML templates specially
+    if (frontmatterTemplate.includes('toml')) {
+      const escapedContent = activationContent.replaceAll('"""', String.raw`\"\"\"`);
+      result = result.replace(
+        /prompt = """/,
+        `prompt = """\n**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!\n\n${escapedContent}`,
+      );
+      return result;
+    }
+
+    return result + activationContent;
+  }
+}
+
+module.exports = {
+  ConfigDrivenIdeSetup,
+  loadPlatformCodes,
+};

tools/cli/installers/lib/ide/antigravity.js

@@ -1,474 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const {
-  loadModuleInjectionConfig,
-  shouldApplyInjection,
-  filterAgentInstructions,
-  resolveSubagentFiles,
-} = require('./shared/module-injections');
-const { getAgentsFromBmad, getAgentsFromDir } = require('./shared/bmad-artifacts');
-const { toDashPath, customAgentDashName } = require('./shared/path-utils');
-const prompts = require('../../../lib/prompts');
-
-/**
- * Google Antigravity IDE setup handler
- *
- * Uses .agent/workflows/ directory for slash commands
- */
-class AntigravitySetup extends BaseIdeSetup {
-  constructor() {
-    super('antigravity', 'Google Antigravity', true);
-    this.configDir = '.agent';
-    this.workflowsDir = 'workflows';
-  }
-
-  /**
-   * Prompt for subagent installation location
-   * @returns {Promise<string>} Selected location ('project' or 'user')
-   */
-  async _promptInstallLocation() {
-    return prompts.select({
-      message: 'Where would you like to install Antigravity subagents?',
-      choices: [
-        { name: 'Project level (.agent/agents/)', value: 'project' },
-        { name: 'User level (~/.agent/agents/)', value: 'user' },
-      ],
-      default: 'project',
-    });
-  }
-
-  /**
-   * Collect configuration choices before installation
-   * @param {Object} options - Configuration options
-   * @returns {Object} Collected configuration
-   */
-  async collectConfiguration(options = {}) {
-    // const config = {
-    //   subagentChoices: null,
-    //   installLocation: null,
-    // };
-
-    // const sourceModulesPath = getSourcePath('modules');
-    // const modules = options.selectedModules || [];
-
-    // for (const moduleName of modules) {
-    // // Check for Antigravity sub-module injection config in SOURCE directory
-    // const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'antigravity', 'injections.yaml');
-
-    // if (await this.exists(injectionConfigPath)) {
-    //   const yaml = require('yaml');
-
-    //   try {
-    //     // Load injection configuration
-    //     const configContent = await fs.readFile(injectionConfigPath, 'utf8');
-    //     const injectionConfig = yaml.parse(configContent);
-
-    //     // Ask about subagents if they exist and we haven't asked yet
-    //     if (injectionConfig.subagents && !config.subagentChoices) {
-    //       config.subagentChoices = await this.promptSubagentInstallation(injectionConfig.subagents);
-
-    //       if (config.subagentChoices.install !== 'none') {
-    //         config.installLocation = await this._promptInstallLocation();
-    //       }
-    //     }
-    //   } catch (error) {
-    //     console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
-    //   }
-    // }
-    // }
-
-    return config;
-  }
-
-  /**
-   * Cleanup old BMAD installation before reinstalling
-   * @param {string} projectDir - Project directory
-   */
-  async cleanup(projectDir) {
-    const bmadWorkflowsDir = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad');
-
-    if (await fs.pathExists(bmadWorkflowsDir)) {
-      await fs.remove(bmadWorkflowsDir);
-      console.log(chalk.dim(`  Removed old BMAD workflows from ${this.name}`));
-    }
-  }
-
-  /**
-   * Setup Antigravity IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    // Store project directory for use in processContent
-    this.projectDir = projectDir;
-
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Create .agent/workflows directory structure
-    const agentDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(agentDir, this.workflowsDir);
-    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
-
-    await this.ensureDir(bmadWorkflowsDir);
-
-    // Generate agent launchers using AgentCommandGenerator
-    // This creates small launcher files that reference the actual agents in _bmad/
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts, counts: agentCounts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Write agent launcher files with FLATTENED naming using shared utility
-    // Antigravity ignores directory structure, so we flatten to: bmad_module_name.md
-    // This creates slash commands like /bmad_bmm_dev instead of /dev
-    const agentCount = await agentGen.writeDashArtifacts(bmadWorkflowsDir, agentArtifacts);
-
-    // Process Antigravity specific injections for installed modules
-    // Use pre-collected configuration if available, or skip if already configured
-    if (options.preCollectedConfig && options.preCollectedConfig._alreadyConfigured) {
-      // IDE is already configured from previous installation, skip prompting
-      // Just process with default/existing configuration
-      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, {});
-    } else if (options.preCollectedConfig) {
-      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, options.preCollectedConfig);
-    } else {
-      await this.processModuleInjections(projectDir, bmadDir, options);
-    }
-
-    // Generate workflow commands from manifest (if it exists)
-    const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-
-    // Write workflow-command artifacts with FLATTENED naming using shared utility
-    const workflowCommandCount = await workflowGen.writeDashArtifacts(bmadWorkflowsDir, workflowArtifacts);
-
-    // Generate task and tool commands from manifests (if they exist)
-    const taskToolGen = new TaskToolCommandGenerator();
-    const taskToolResult = await taskToolGen.generateTaskToolCommands(projectDir, bmadDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed`));
-    if (workflowCommandCount > 0) {
-      console.log(chalk.dim(`  - ${workflowCommandCount} workflow commands generated`));
-    }
-    if (taskToolResult.generated > 0) {
-      console.log(
-        chalk.dim(
-          `  - ${taskToolResult.generated} task/tool commands generated (${taskToolResult.tasks} tasks, ${taskToolResult.tools} tools)`,
-        ),
-      );
-    }
-    console.log(chalk.dim(`  - Workflows directory: ${path.relative(projectDir, bmadWorkflowsDir)}`));
-    console.log(chalk.yellow(`\n  Note: Antigravity uses flattened slash commands (e.g., /bmad_module_agents_name)`));
-
-    return {
-      success: true,
-      agents: agentCount,
-    };
-  }
-
-  /**
-   * Read and process file content
-   */
-  async readAndProcess(filePath, metadata) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return this.processContent(content, metadata);
-  }
-
-  /**
-   * Override processContent to keep {project-root} placeholder
-   */
-  processContent(content, metadata = {}) {
-    // Use the base class method WITHOUT projectDir to preserve {project-root} placeholder
-    return super.processContent(content, metadata);
-  }
-
-  /**
-   * Get agents from source modules (not installed location)
-   */
-  async getAgentsFromSource(sourceDir, selectedModules) {
-    const agents = [];
-
-    // Add core agents
-    const corePath = getModulePath('core');
-    if (await fs.pathExists(path.join(corePath, 'agents'))) {
-      const coreAgents = await getAgentsFromDir(path.join(corePath, 'agents'), 'core');
-      agents.push(...coreAgents);
-    }
-
-    // Add module agents
-    for (const moduleName of selectedModules) {
-      const modulePath = path.join(sourceDir, moduleName);
-      const agentsPath = path.join(modulePath, 'agents');
-
-      if (await fs.pathExists(agentsPath)) {
-        const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
-        agents.push(...moduleAgents);
-      }
-    }
-
-    return agents;
-  }
-
-  /**
-   * Process module injections with pre-collected configuration
-   */
-  async processModuleInjectionsWithConfig(projectDir, bmadDir, options, preCollectedConfig) {
-    // Get list of installed modules
-    const modules = options.selectedModules || [];
-    const { subagentChoices, installLocation } = preCollectedConfig;
-
-    // Get the actual source directory (not the installation directory)
-    await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'antigravity',
-      subagentChoices,
-      installLocation,
-      interactive: false,
-    });
-  }
-
-  /**
-   * Process Antigravity specific injections for installed modules
-   * Looks for injections.yaml in each module's antigravity sub-module
-   */
-  async processModuleInjections(projectDir, bmadDir, options) {
-    // Get list of installed modules
-    const modules = options.selectedModules || [];
-    let subagentChoices = null;
-    let installLocation = null;
-
-    // Get the actual source directory (not the installation directory)
-    const { subagentChoices: updatedChoices, installLocation: updatedLocation } = await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'antigravity',
-      subagentChoices,
-      installLocation,
-      interactive: true,
-    });
-
-    if (updatedChoices) {
-      subagentChoices = updatedChoices;
-    }
-    if (updatedLocation) {
-      installLocation = updatedLocation;
-    }
-  }
-
-  async processModuleInjectionsInternal({ projectDir, modules, handler, subagentChoices, installLocation, interactive = false }) {
-    let choices = subagentChoices;
-    let location = installLocation;
-
-    for (const moduleName of modules) {
-      const configData = await loadModuleInjectionConfig(handler, moduleName);
-
-      if (!configData) {
-        continue;
-      }
-
-      const { config, handlerBaseDir } = configData;
-
-      if (interactive) {
-        console.log(chalk.cyan(`\nConfiguring ${moduleName} ${handler} features...`));
-      }
-
-      // if (interactive && config.subagents && !choices) {
-      //   choices = await this.promptSubagentInstallation(config.subagents);
-
-      //   if (choices.install !== 'none') {
-      //     location = await this._promptInstallLocation();
-      //   }
-      // }
-
-      if (config.injections && choices && choices.install !== 'none') {
-        for (const injection of config.injections) {
-          if (shouldApplyInjection(injection, choices)) {
-            await this.injectContent(projectDir, injection, choices);
-          }
-        }
-      }
-
-      if (config.subagents && choices && choices.install !== 'none') {
-        await this.copySelectedSubagents(projectDir, handlerBaseDir, config.subagents, choices, location || 'project');
-      }
-    }
-
-    return { subagentChoices: choices, installLocation: location };
-  }
-
-  /**
-   * Prompt user for subagent installation preferences
-   */
-  async promptSubagentInstallation(subagentConfig) {
-    // First ask if they want to install subagents
-    const install = await prompts.select({
-      message: 'Would you like to install Antigravity subagents for enhanced functionality?',
-      choices: [
-        { name: 'Yes, install all subagents', value: 'all' },
-        { name: 'Yes, let me choose specific subagents', value: 'selective' },
-        { name: 'No, skip subagent installation', value: 'none' },
-      ],
-      default: 'all',
-    });
-
-    if (install === 'selective') {
-      // Show list of available subagents with descriptions
-      const subagentInfo = {
-        'market-researcher.md': 'Market research and competitive analysis',
-        'requirements-analyst.md': 'Requirements extraction and validation',
-        'technical-evaluator.md': 'Technology stack evaluation',
-        'epic-optimizer.md': 'Epic and story breakdown optimization',
-        'document-reviewer.md': 'Document quality review',
-      };
-
-      const selected = await prompts.multiselect({
-        message: `Select subagents to install ${chalk.dim('(↑/↓ navigates multiselect, SPACE toggles, A to toggles All, ENTER confirm)')}:`,
-        choices: subagentConfig.files.map((file) => ({
-          name: `${file.replace('.md', '')} - ${subagentInfo[file] || 'Specialized assistant'}`,
-          value: file,
-          checked: true,
-        })),
-      });
-
-      return { install: 'selective', selected };
-    }
-
-    return { install };
-  }
-
-  /**
-   * Inject content at specified point in file
-   */
-  async injectContent(projectDir, injection, subagentChoices = null) {
-    const targetPath = path.join(projectDir, injection.file);
-
-    if (await this.exists(targetPath)) {
-      let content = await fs.readFile(targetPath, 'utf8');
-      const marker = `<!-- IDE-INJECT-POINT: ${injection.point} -->`;
-
-      if (content.includes(marker)) {
-        let injectionContent = injection.content;
-
-        // Filter content if selective subagents chosen
-        if (subagentChoices && subagentChoices.install === 'selective' && injection.point === 'pm-agent-instructions') {
-          injectionContent = filterAgentInstructions(injection.content, subagentChoices.selected);
-        }
-
-        content = content.replace(marker, injectionContent);
-        await fs.writeFile(targetPath, content);
-        console.log(chalk.dim(`    Injected: ${injection.point} → ${injection.file}`));
-      }
-    }
-  }
-
-  /**
-   * Copy selected subagents to appropriate Antigravity agents directory
-   */
-  async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
-    const os = require('node:os');
-
-    // Determine target directory based on user choice
-    let targetDir;
-    if (location === 'user') {
-      targetDir = path.join(os.homedir(), '.agent', 'agents');
-      console.log(chalk.dim(`  Installing subagents globally to: ~/.agent/agents/`));
-    } else {
-      targetDir = path.join(projectDir, '.agent', 'agents');
-      console.log(chalk.dim(`  Installing subagents to project: .agent/agents/`));
-    }
-
-    // Ensure target directory exists
-    await this.ensureDir(targetDir);
-
-    const resolvedFiles = await resolveSubagentFiles(handlerBaseDir, subagentConfig, choices);
-
-    let copiedCount = 0;
-    for (const resolved of resolvedFiles) {
-      try {
-        const sourcePath = resolved.absolutePath;
-
-        const subFolder = path.dirname(resolved.relativePath);
-        let targetPath;
-        if (subFolder && subFolder !== '.') {
-          const targetSubDir = path.join(targetDir, subFolder);
-          await this.ensureDir(targetSubDir);
-          targetPath = path.join(targetSubDir, path.basename(resolved.file));
-        } else {
-          targetPath = path.join(targetDir, path.basename(resolved.file));
-        }
-
-        await fs.copyFile(sourcePath, targetPath);
-        console.log(chalk.green(`    ✓ Installed: ${subFolder === '.' ? '' : `${subFolder}/`}${path.basename(resolved.file, '.md')}`));
-        copiedCount++;
-      } catch (error) {
-        console.log(chalk.yellow(`    ⚠ Error copying ${resolved.file}: ${error.message}`));
-      }
-    }
-
-    if (copiedCount > 0) {
-      console.log(chalk.dim(`  Total subagents installed: ${copiedCount}`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Antigravity
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    // Create .agent/workflows/bmad directory structure (same as regular agents)
-    const agentDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(agentDir, this.workflowsDir);
-    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
-
-    await fs.ensureDir(bmadWorkflowsDir);
-
-    // Create custom agent launcher with same pattern as regular agents
-    const launcherContent = `name: '${agentName}'
-description: '${agentName} agent'
-usage: |
-  Custom BMAD agent: ${agentName}
-
-  Launch with: /${agentName}
-
-  You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. EXECUTE as ${agentName} with full persona adoption
-</agent-activation>
-
----
-
-⚠️ **IMPORTANT**: Run @${agentPath} to load the complete agent before using this launcher!`;
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    const fileName = customAgentDashName(agentName);
-    const launcherPath = path.join(bmadWorkflowsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'antigravity',
-      path: path.relative(projectDir, launcherPath),
-      command: `/${fileName.replace('.md', '')}`,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { AntigravitySetup };

tools/cli/installers/lib/ide/auggie.js

@@ -1,244 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-
-/**
- * Auggie CLI setup handler
- * Installs to project directory (.augment/commands)
- */
-class AuggieSetup extends BaseIdeSetup {
-  constructor() {
-    super('auggie', 'Auggie CLI');
-    this.detectionPaths = ['.augment'];
-  }
-
-  /**
-   * Setup Auggie CLI configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Always use project directory
-    const location = path.join(projectDir, '.augment', 'commands');
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Get tasks, tools, and workflows (ALL workflows now generate commands)
-    const tasks = await this.getTasks(bmadDir, true);
-    const tools = await this.getTools(bmadDir, true);
-
-    // Get ALL workflows using the new workflow command generator
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-
-    // Convert workflow artifacts to expected format
-    const workflows = workflowArtifacts
-      .filter((artifact) => artifact.type === 'workflow-command')
-      .map((artifact) => ({
-        module: artifact.module,
-        name: path.basename(artifact.relativePath, '.md'),
-        path: artifact.sourcePath,
-        content: artifact.content,
-      }));
-
-    const bmadCommandsDir = path.join(location, 'bmad');
-    const agentsDir = path.join(bmadCommandsDir, 'agents');
-    const tasksDir = path.join(bmadCommandsDir, 'tasks');
-    const toolsDir = path.join(bmadCommandsDir, 'tools');
-    const workflowsDir = path.join(bmadCommandsDir, 'workflows');
-
-    await this.ensureDir(agentsDir);
-    await this.ensureDir(tasksDir);
-    await this.ensureDir(toolsDir);
-    await this.ensureDir(workflowsDir);
-
-    // Install agent launchers
-    for (const artifact of agentArtifacts) {
-      const targetPath = path.join(agentsDir, `${artifact.module}-${artifact.name}.md`);
-      await this.writeFile(targetPath, artifact.content);
-    }
-
-    // Install tasks
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const commandContent = this.createTaskCommand(task, content);
-
-      const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-    }
-
-    // Install tools
-    for (const tool of tools) {
-      const content = await this.readFile(tool.path);
-      const commandContent = this.createToolCommand(tool, content);
-
-      const targetPath = path.join(toolsDir, `${tool.module}-${tool.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-    }
-
-    // Install workflows (already generated commands)
-    for (const workflow of workflows) {
-      // Use the pre-generated workflow command content
-      const targetPath = path.join(workflowsDir, `${workflow.module}-${workflow.name}.md`);
-      await this.writeFile(targetPath, workflow.content);
-    }
-
-    const totalInstalled = agentArtifacts.length + tasks.length + tools.length + workflows.length;
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentArtifacts.length} agents installed`));
-    console.log(chalk.dim(`  - ${tasks.length} tasks installed`));
-    console.log(chalk.dim(`  - ${tools.length} tools installed`));
-    console.log(chalk.dim(`  - ${workflows.length} workflows installed`));
-    console.log(chalk.dim(`  - Location: ${path.relative(projectDir, location)}`));
-    console.log(chalk.yellow(`\n  💡 Tip: Add 'model: gpt-4o' to command frontmatter to specify AI model`));
-
-    return {
-      success: true,
-      agents: agentArtifacts.length,
-      tasks: tasks.length,
-      tools: tools.length,
-      workflows: workflows.length,
-    };
-  }
-
-  /**
-   * Create task command content
-   */
-  createTaskCommand(task, content) {
-    const nameMatch = content.match(/name="([^"]+)"/);
-    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
-
-    return `---
-description: "Execute the ${taskName} task"
----
-
-# ${taskName} Task
-
-${content}
-
-## Module
-BMAD ${task.module.toUpperCase()} module
-`;
-  }
-
-  /**
-   * Create tool command content
-   */
-  createToolCommand(tool, content) {
-    const nameMatch = content.match(/name="([^"]+)"/);
-    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
-
-    return `---
-description: "Use the ${toolName} tool"
----
-
-# ${toolName} Tool
-
-${content}
-
-## Module
-BMAD ${tool.module.toUpperCase()} module
-`;
-  }
-
-  /**
-   * Create workflow command content
-   */
-  createWorkflowCommand(workflow, content) {
-    const description = workflow.description || `Execute the ${workflow.name} workflow`;
-
-    return `---
-description: "${description}"
----
-
-# ${workflow.name} Workflow
-
-${content}
-
-## Module
-BMAD ${workflow.module.toUpperCase()} module
-`;
-  }
-
-  /**
-   * Cleanup Auggie configuration
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-
-    // Only clean up project directory
-    const location = path.join(projectDir, '.augment', 'commands');
-    const bmadDir = path.join(location, 'bmad');
-
-    if (await fs.pathExists(bmadDir)) {
-      await fs.remove(bmadDir);
-      console.log(chalk.dim(`  Removed old BMAD commands`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Auggie
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    // Auggie uses .augment/commands directory
-    const location = path.join(projectDir, '.augment', 'commands');
-    const bmadCommandsDir = path.join(location, 'bmad');
-    const agentsDir = path.join(bmadCommandsDir, 'agents');
-
-    // Create .augment/commands/bmad/agents directory if it doesn't exist
-    await fs.ensureDir(agentsDir);
-
-    // Create custom agent launcher
-    const launcherContent = `---
-description: "Use the ${agentName} custom agent"
----
-
-# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this command to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
-## Module
-BMAD Custom agent
-`;
-
-    const fileName = `custom-${agentName.toLowerCase()}.md`;
-    const launcherPath = path.join(agentsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'auggie',
-      path: path.relative(projectDir, launcherPath),
-      command: agentName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { AuggieSetup };

tools/cli/installers/lib/ide/claude-code.js

@@ -1,506 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { getProjectRoot, getSourcePath, getModulePath } = require('../../../lib/project-root');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const {
-  loadModuleInjectionConfig,
-  shouldApplyInjection,
-  filterAgentInstructions,
-  resolveSubagentFiles,
-} = require('./shared/module-injections');
-const { getAgentsFromBmad, getAgentsFromDir } = require('./shared/bmad-artifacts');
-const { customAgentColonName } = require('./shared/path-utils');
-const prompts = require('../../../lib/prompts');
-
-/**
- * Claude Code IDE setup handler
- */
-class ClaudeCodeSetup extends BaseIdeSetup {
-  constructor() {
-    super('claude-code', 'Claude Code', true); // preferred IDE
-    this.configDir = '.claude';
-    this.commandsDir = 'commands';
-    this.agentsDir = 'agents';
-  }
-
-  /**
-   * Prompt for subagent installation location
-   * @returns {Promise<string>} Selected location ('project' or 'user')
-   */
-  async promptInstallLocation() {
-    return prompts.select({
-      message: 'Where would you like to install Claude Code subagents?',
-      choices: [
-        { name: 'Project level (.claude/agents/)', value: 'project' },
-        { name: 'User level (~/.claude/agents/)', value: 'user' },
-      ],
-      default: 'project',
-    });
-  }
-
-  // /**
-  //  * Collect configuration choices before installation
-  //  * @param {Object} options - Configuration options
-  //  * @returns {Object} Collected configuration
-  //  */
-  // async collectConfiguration(options = {}) {
-  //   const config = {
-  //     subagentChoices: null,
-  //     installLocation: null,
-  //   };
-
-  //   const sourceModulesPath = getSourcePath('modules');
-  //   const modules = options.selectedModules || [];
-
-  //   for (const moduleName of modules) {
-  //     // Check for Claude Code sub-module injection config in SOURCE directory
-  //     const injectionConfigPath = path.join(sourceModulesPath, moduleName, 'sub-modules', 'claude-code', 'injections.yaml');
-
-  //     if (await this.exists(injectionConfigPath)) {
-  //       const yaml = require('yaml');
-
-  //       try {
-  //         // Load injection configuration
-  //         const configContent = await fs.readFile(injectionConfigPath, 'utf8');
-  //         const injectionConfig = yaml.parse(configContent);
-
-  //         // Ask about subagents if they exist and we haven't asked yet
-  //         if (injectionConfig.subagents && !config.subagentChoices) {
-  //           config.subagentChoices = await this.promptSubagentInstallation(injectionConfig.subagents);
-
-  //           if (config.subagentChoices.install !== 'none') {
-  //             config.installLocation = await this.promptInstallLocation();
-  //           }
-  //         }
-  //       } catch (error) {
-  //         console.log(chalk.yellow(`  Warning: Failed to process ${moduleName} features: ${error.message}`));
-  //       }
-  //     }
-  //   }
-
-  //   return config;
-  // }
-
-  /**
-   * Cleanup old BMAD installation before reinstalling
-   * @param {string} projectDir - Project directory
-   */
-  async cleanup(projectDir) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    // Remove any bmad* files from the commands directory (cleans up old bmad: and bmad- formats)
-    if (await fs.pathExists(commandsDir)) {
-      const entries = await fs.readdir(commandsDir);
-      let removedCount = 0;
-      for (const entry of entries) {
-        if (entry.startsWith('bmad')) {
-          await fs.remove(path.join(commandsDir, entry));
-          removedCount++;
-        }
-      }
-      // Also remove legacy bmad folder if it exists
-      const bmadFolder = path.join(commandsDir, 'bmad');
-      if (await fs.pathExists(bmadFolder)) {
-        await fs.remove(bmadFolder);
-        console.log(chalk.dim(`  Removed old BMAD commands from ${this.name}`));
-      }
-    }
-  }
-
-  /**
-   * Clean up legacy folder structure (module/type/name.md) if it exists
-   * This can be called after migration to remove old nested directories
-   * @param {string} projectDir - Project directory
-   */
-  async cleanupLegacyFolders(projectDir) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    if (!(await fs.pathExists(commandsDir))) {
-      return;
-    }
-
-    // Remove legacy bmad folder if it exists
-    const bmadFolder = path.join(commandsDir, 'bmad');
-    if (await fs.pathExists(bmadFolder)) {
-      await fs.remove(bmadFolder);
-      console.log(chalk.dim(`  Removed legacy bmad folder from ${this.name}`));
-    }
-  }
-
-  /**
-   * Setup Claude Code IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    // Store project directory for use in processContent
-    this.projectDir = projectDir;
-
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Create .claude/commands directory structure
-    const claudeDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(claudeDir, this.commandsDir);
-    await this.ensureDir(commandsDir);
-
-    // Use underscore format: files written directly to commands dir (no bmad subfolder)
-    // Creates: .claude/commands/bmad_bmm_pm.md
-
-    // Generate agent launchers using AgentCommandGenerator
-    // This creates small launcher files that reference the actual agents in _bmad/
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts, counts: agentCounts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Write agent launcher files using flat underscore naming
-    // Creates files like: bmad_bmm_pm.md
-    const agentCount = await agentGen.writeColonArtifacts(commandsDir, agentArtifacts);
-
-    // Process Claude Code specific injections for installed modules
-    // Use pre-collected configuration if available, or skip if already configured
-    if (options.preCollectedConfig && options.preCollectedConfig._alreadyConfigured) {
-      // IDE is already configured from previous installation, skip prompting
-      // Just process with default/existing configuration
-      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, {});
-    } else if (options.preCollectedConfig) {
-      await this.processModuleInjectionsWithConfig(projectDir, bmadDir, options, options.preCollectedConfig);
-    } else {
-      await this.processModuleInjections(projectDir, bmadDir, options);
-    }
-
-    // Skip CLAUDE.md creation - let user manage their own CLAUDE.md file
-    // await this.createClaudeConfig(projectDir, modules);
-
-    // Generate workflow commands from manifest (if it exists)
-    const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-
-    // Write workflow-command artifacts using flat underscore naming
-    // Creates files like: bmad_bmm_correct-course.md
-    const workflowCommandCount = await workflowGen.writeColonArtifacts(commandsDir, workflowArtifacts);
-
-    // Generate task and tool commands from manifests (if they exist)
-    const taskToolGen = new TaskToolCommandGenerator();
-    const taskToolResult = await taskToolGen.generateColonTaskToolCommands(projectDir, bmadDir, commandsDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed`));
-    if (workflowCommandCount > 0) {
-      console.log(chalk.dim(`  - ${workflowCommandCount} workflow commands generated`));
-    }
-    if (taskToolResult.generated > 0) {
-      console.log(
-        chalk.dim(
-          `  - ${taskToolResult.generated} task/tool commands generated (${taskToolResult.tasks} tasks, ${taskToolResult.tools} tools)`,
-        ),
-      );
-    }
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
-
-    return {
-      success: true,
-      agents: agentCount,
-    };
-  }
-
-  // Method removed - CLAUDE.md file management left to user
-
-  /**
-   * Read and process file content
-   */
-  async readAndProcess(filePath, metadata) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return this.processContent(content, metadata);
-  }
-
-  /**
-   * Override processContent to keep {project-root} placeholder
-   */
-  processContent(content, metadata = {}) {
-    // Use the base class method WITHOUT projectDir to preserve {project-root} placeholder
-    return super.processContent(content, metadata);
-  }
-
-  /**
-   * Get agents from source modules (not installed location)
-   */
-  async getAgentsFromSource(sourceDir, selectedModules) {
-    const agents = [];
-
-    // Add core agents
-    const corePath = getModulePath('core');
-    if (await fs.pathExists(path.join(corePath, 'agents'))) {
-      const coreAgents = await getAgentsFromDir(path.join(corePath, 'agents'), 'core');
-      agents.push(...coreAgents);
-    }
-
-    // Add module agents
-    for (const moduleName of selectedModules) {
-      const modulePath = path.join(sourceDir, moduleName);
-      const agentsPath = path.join(modulePath, 'agents');
-
-      if (await fs.pathExists(agentsPath)) {
-        const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
-        agents.push(...moduleAgents);
-      }
-    }
-
-    return agents;
-  }
-
-  /**
-   * Process module injections with pre-collected configuration
-   */
-  async processModuleInjectionsWithConfig(projectDir, bmadDir, options, preCollectedConfig) {
-    // Get list of installed modules
-    const modules = options.selectedModules || [];
-    const { subagentChoices, installLocation } = preCollectedConfig;
-
-    // Get the actual source directory (not the installation directory)
-    await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'claude-code',
-      subagentChoices,
-      installLocation,
-      interactive: false,
-    });
-  }
-
-  /**
-   * Process Claude Code specific injections for installed modules
-   * Looks for injections.yaml in each module's claude-code sub-module
-   */
-  async processModuleInjections(projectDir, bmadDir, options) {
-    // Get list of installed modules
-    const modules = options.selectedModules || [];
-    let subagentChoices = null;
-    let installLocation = null;
-
-    // Get the actual source directory (not the installation directory)
-    const { subagentChoices: updatedChoices, installLocation: updatedLocation } = await this.processModuleInjectionsInternal({
-      projectDir,
-      modules,
-      handler: 'claude-code',
-      subagentChoices,
-      installLocation,
-      interactive: true,
-    });
-
-    if (updatedChoices) {
-      subagentChoices = updatedChoices;
-    }
-    if (updatedLocation) {
-      installLocation = updatedLocation;
-    }
-  }
-
-  async processModuleInjectionsInternal({ projectDir, modules, handler, subagentChoices, installLocation, interactive = false }) {
-    let choices = subagentChoices;
-    let location = installLocation;
-
-    for (const moduleName of modules) {
-      const configData = await loadModuleInjectionConfig(handler, moduleName);
-
-      if (!configData) {
-        continue;
-      }
-
-      const { config, handlerBaseDir } = configData;
-
-      if (interactive) {
-        console.log(chalk.cyan(`\nConfiguring ${moduleName} ${handler.replace('-', ' ')} features...`));
-      }
-
-      if (interactive && config.subagents && !choices) {
-        // choices = await this.promptSubagentInstallation(config.subagents);
-        // if (choices.install !== 'none') {
-        //   location = await this.promptInstallLocation();
-        // }
-      }
-
-      if (config.injections && choices && choices.install !== 'none') {
-        for (const injection of config.injections) {
-          if (shouldApplyInjection(injection, choices)) {
-            await this.injectContent(projectDir, injection, choices);
-          }
-        }
-      }
-
-      if (config.subagents && choices && choices.install !== 'none') {
-        await this.copySelectedSubagents(projectDir, handlerBaseDir, config.subagents, choices, location || 'project');
-      }
-    }
-
-    return { subagentChoices: choices, installLocation: location };
-  }
-
-  /**
-   * Prompt user for subagent installation preferences
-   */
-  async promptSubagentInstallation(subagentConfig) {
-    // First ask if they want to install subagents
-    const install = await prompts.select({
-      message: 'Would you like to install Claude Code subagents for enhanced functionality?',
-      choices: [
-        { name: 'Yes, install all subagents', value: 'all' },
-        { name: 'Yes, let me choose specific subagents', value: 'selective' },
-        { name: 'No, skip subagent installation', value: 'none' },
-      ],
-      default: 'all',
-    });
-
-    if (install === 'selective') {
-      // Show list of available subagents with descriptions
-      const subagentInfo = {
-        'market-researcher.md': 'Market research and competitive analysis',
-        'requirements-analyst.md': 'Requirements extraction and validation',
-        'technical-evaluator.md': 'Technology stack evaluation',
-        'epic-optimizer.md': 'Epic and story breakdown optimization',
-        'document-reviewer.md': 'Document quality review',
-      };
-
-      const selected = await prompts.multiselect({
-        message: `Select subagents to install ${chalk.dim('(↑/↓ navigates multiselect, SPACE toggles, A to toggles All, ENTER confirm)')}:`,
-        options: subagentConfig.files.map((file) => ({
-          label: `${file.replace('.md', '')} - ${subagentInfo[file] || 'Specialized assistant'}`,
-          value: file,
-        })),
-        initialValues: subagentConfig.files,
-      });
-
-      return { install: 'selective', selected };
-    }
-
-    return { install };
-  }
-
-  /**
-   * Inject content at specified point in file
-   */
-  async injectContent(projectDir, injection, subagentChoices = null) {
-    const targetPath = path.join(projectDir, injection.file);
-
-    if (await this.exists(targetPath)) {
-      let content = await fs.readFile(targetPath, 'utf8');
-      const marker = `<!-- IDE-INJECT-POINT: ${injection.point} -->`;
-
-      if (content.includes(marker)) {
-        let injectionContent = injection.content;
-
-        // Filter content if selective subagents chosen
-        if (subagentChoices && subagentChoices.install === 'selective' && injection.point === 'pm-agent-instructions') {
-          injectionContent = filterAgentInstructions(injection.content, subagentChoices.selected);
-        }
-
-        content = content.replace(marker, injectionContent);
-        await fs.writeFile(targetPath, content);
-        console.log(chalk.dim(`    Injected: ${injection.point} → ${injection.file}`));
-      }
-    }
-  }
-
-  /**
-   * Copy selected subagents to appropriate Claude agents directory
-   */
-  async copySelectedSubagents(projectDir, handlerBaseDir, subagentConfig, choices, location) {
-    const os = require('node:os');
-
-    // Determine target directory based on user choice
-    let targetDir;
-    if (location === 'user') {
-      targetDir = path.join(os.homedir(), '.claude', 'agents');
-      console.log(chalk.dim(`  Installing subagents globally to: ~/.claude/agents/`));
-    } else {
-      targetDir = path.join(projectDir, '.claude', 'agents');
-      console.log(chalk.dim(`  Installing subagents to project: .claude/agents/`));
-    }
-
-    // Ensure target directory exists
-    await this.ensureDir(targetDir);
-
-    const resolvedFiles = await resolveSubagentFiles(handlerBaseDir, subagentConfig, choices);
-
-    let copiedCount = 0;
-    for (const resolved of resolvedFiles) {
-      try {
-        const sourcePath = resolved.absolutePath;
-
-        const subFolder = path.dirname(resolved.relativePath);
-        let targetPath;
-        if (subFolder && subFolder !== '.') {
-          const targetSubDir = path.join(targetDir, subFolder);
-          await this.ensureDir(targetSubDir);
-          targetPath = path.join(targetSubDir, path.basename(resolved.file));
-        } else {
-          targetPath = path.join(targetDir, path.basename(resolved.file));
-        }
-
-        await fs.copyFile(sourcePath, targetPath);
-        console.log(chalk.green(`    ✓ Installed: ${subFolder === '.' ? '' : `${subFolder}/`}${path.basename(resolved.file, '.md')}`));
-        copiedCount++;
-      } catch (error) {
-        console.log(chalk.yellow(`    ⚠ Error copying ${resolved.file}: ${error.message}`));
-      }
-    }
-
-    if (copiedCount > 0) {
-      console.log(chalk.dim(`  Total subagents installed: ${copiedCount}`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Claude Code
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
-      return null; // IDE not configured for this project
-    }
-
-    await this.ensureDir(commandsDir);
-
-    const launcherContent = `---
-name: '${agentName}'
-description: '${agentName} agent'
----
-
-You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    // Written directly to commands dir (no bmad subfolder)
-    const launcherName = customAgentColonName(agentName);
-    const launcherPath = path.join(commandsDir, launcherName);
-    await this.writeFile(launcherPath, launcherContent);
-
-    return {
-      path: launcherPath,
-      command: `/${launcherName.replace('.md', '')}`,
-    };
-  }
-}
-
-module.exports = { ClaudeCodeSetup };

tools/cli/installers/lib/ide/cline.js

@@ -1,272 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const chalk = require('chalk');
-const { BaseIdeSetup } = require('./_base-ide');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
-const { toDashPath, customAgentDashName } = require('./shared/path-utils');
-
-/**
- * Cline IDE setup handler
- * Installs BMAD artifacts to .clinerules/workflows with flattened naming
- */
-class ClineSetup extends BaseIdeSetup {
-  constructor() {
-    super('cline', 'Cline', false);
-    this.configDir = '.clinerules';
-    this.workflowsDir = 'workflows';
-  }
-
-  /**
-   * Setup Cline IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .clinerules/workflows directory
-    const clineDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(clineDir, this.workflowsDir);
-
-    await this.ensureDir(workflowsDir);
-
-    // Clear old BMAD files
-    await this.clearOldBmadFiles(workflowsDir);
-
-    // Collect all artifacts
-    const { artifacts, counts } = await this.collectClineArtifacts(projectDir, bmadDir, options);
-
-    // Write flattened files
-    const written = await this.flattenAndWriteArtifacts(artifacts, workflowsDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${counts.agents} agents installed`));
-    console.log(chalk.dim(`  - ${counts.tasks} tasks installed`));
-    console.log(chalk.dim(`  - ${counts.workflows} workflow commands installed`));
-    if (counts.workflowLaunchers > 0) {
-      console.log(chalk.dim(`  - ${counts.workflowLaunchers} workflow launchers installed`));
-    }
-    console.log(chalk.dim(`  - ${written} files written to ${path.relative(projectDir, workflowsDir)}`));
-
-    // Usage instructions
-    console.log(chalk.yellow('\n  ⚠️  How to Use Cline Workflows'));
-    console.log(chalk.cyan('  BMAD workflows are available as slash commands in Cline'));
-    console.log(chalk.dim('  Usage:'));
-    console.log(chalk.dim('    - Type / to see available commands'));
-    console.log(chalk.dim('    - All BMAD items start with "bmad_"'));
-    console.log(chalk.dim('    - Example: /bmad_bmm_pm'));
-
-    return {
-      success: true,
-      agents: counts.agents,
-      tasks: counts.tasks,
-      workflows: counts.workflows,
-      workflowLaunchers: counts.workflowLaunchers,
-      written,
-    };
-  }
-
-  /**
-   * Detect Cline installation by checking for .clinerules/workflows directory
-   */
-  async detect(projectDir) {
-    const workflowsDir = path.join(projectDir, this.configDir, this.workflowsDir);
-
-    if (!(await fs.pathExists(workflowsDir))) {
-      return false;
-    }
-
-    const entries = await fs.readdir(workflowsDir);
-    return entries.some((entry) => entry.startsWith('bmad'));
-  }
-
-  /**
-   * Collect all artifacts for Cline export
-   */
-  async collectClineArtifacts(projectDir, bmadDir, options = {}) {
-    const selectedModules = options.selectedModules || [];
-    const artifacts = [];
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, selectedModules);
-
-    // Process agent launchers with project-specific paths
-    for (const agentArtifact of agentArtifacts) {
-      const content = agentArtifact.content;
-
-      artifacts.push({
-        type: 'agent',
-        module: agentArtifact.module,
-        sourcePath: agentArtifact.sourcePath,
-        relativePath: agentArtifact.relativePath,
-        content,
-      });
-    }
-
-    // Get tasks
-    const tasks = await getTasksFromBmad(bmadDir, selectedModules);
-    for (const task of tasks) {
-      const content = await this.readAndProcessWithProject(
-        task.path,
-        {
-          module: task.module,
-          name: task.name,
-        },
-        projectDir,
-      );
-
-      artifacts.push({
-        type: 'task',
-        module: task.module,
-        sourcePath: task.path,
-        relativePath: path.join(task.module, 'tasks', `${task.name}.md`),
-        content,
-      });
-    }
-
-    // Get workflows
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-    artifacts.push(...workflowArtifacts);
-
-    return {
-      artifacts,
-      counts: {
-        agents: agentArtifacts.length,
-        tasks: tasks.length,
-        workflows: workflowCounts.commands,
-        workflowLaunchers: workflowCounts.launchers,
-      },
-    };
-  }
-
-  /**
-   * Flatten file path to bmad_module_type_name.md format
-   * Uses shared toDashPath utility
-   */
-  flattenFilename(relativePath) {
-    return toDashPath(relativePath);
-  }
-
-  /**
-   * Write all artifacts with flattened names
-   */
-  async flattenAndWriteArtifacts(artifacts, destDir) {
-    let written = 0;
-
-    for (const artifact of artifacts) {
-      const flattenedName = this.flattenFilename(artifact.relativePath);
-      const targetPath = path.join(destDir, flattenedName);
-      await fs.writeFile(targetPath, artifact.content);
-      written++;
-    }
-
-    return written;
-  }
-
-  /**
-   * Clear old BMAD files from the workflows directory
-   */
-  async clearOldBmadFiles(destDir) {
-    if (!(await fs.pathExists(destDir))) {
-      return;
-    }
-
-    const entries = await fs.readdir(destDir);
-
-    for (const entry of entries) {
-      if (!entry.startsWith('bmad')) {
-        continue;
-      }
-
-      const entryPath = path.join(destDir, entry);
-      const stat = await fs.stat(entryPath);
-      if (stat.isFile()) {
-        await fs.remove(entryPath);
-      } else if (stat.isDirectory()) {
-        await fs.remove(entryPath);
-      }
-    }
-  }
-
-  /**
-   * Read and process file with project-specific paths
-   */
-  async readAndProcessWithProject(filePath, metadata, projectDir) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return super.processContent(content, metadata, projectDir);
-  }
-
-  /**
-   * Cleanup Cline configuration
-   */
-  async cleanup(projectDir) {
-    const workflowsDir = path.join(projectDir, this.configDir, this.workflowsDir);
-    await this.clearOldBmadFiles(workflowsDir);
-    console.log(chalk.dim(`Removed ${this.name} BMAD configuration`));
-  }
-
-  /**
-   * Install a custom agent launcher for Cline
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const clineDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(clineDir, this.workflowsDir);
-
-    // Create .clinerules/workflows directory if it doesn't exist
-    await fs.ensureDir(workflowsDir);
-
-    // Create custom agent launcher workflow
-    const launcherContent = `name: ${agentName}
-description: Custom BMAD agent: ${agentName}
-
-# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this workflow as ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*`;
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    const fileName = customAgentDashName(agentName);
-    const launcherPath = path.join(workflowsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'cline',
-      path: path.relative(projectDir, launcherPath),
-      command: fileName.replace('.md', ''),
-      type: 'custom-agent-launcher',
-    };
-  }
-
-  /**
-   * Utility: Ensure directory exists
-   */
-  async ensureDir(dirPath) {
-    await fs.ensureDir(dirPath);
-  }
-}
-
-module.exports = { ClineSetup };

tools/cli/installers/lib/ide/codex.js

@@ -2,28 +2,85 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const os = require('node:os');
 const chalk = require('chalk');
-const { BaseIdeSetup } = require('./_base-ide');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { getTasksFromBmad } = require('./shared/bmad-artifacts');
-const { toDashPath, customAgentDashName } = require('./shared/path-utils');
+const { ConfigDrivenIdeSetup } = require('./_config-driven');
+const { getSourcePath } = require('../../../lib/project-root');
 const prompts = require('../../../lib/prompts');
 
 /**
  * Codex setup handler (CLI mode)
+ *
+ * Extends config-driven setup with Codex-specific features:
+ * - Install location choice (global vs project-specific)
+ * - Configuration prompts
+ * - Detailed setup instructions
  */
-class CodexSetup extends BaseIdeSetup {
+class CodexSetup extends ConfigDrivenIdeSetup {
   constructor() {
-    super('codex', 'Codex', true); // preferred IDE
+    // Initialize with codex platform config
+    const platformConfig = {
+      name: 'Codex',
+      preferred: false,
+      installer: {
+        target_dir: '.codex/prompts',
+        frontmatter_template: 'none', // Codex uses no frontmatter
+      },
+    };
+    super('codex', platformConfig);
   }
 
   /**
-   * Collect configuration choices before installation
-   * @param {Object} options - Configuration options
-   * @returns {Object} Collected configuration
+   * Get the Codex agent command activation header from central template
+   * @returns {string} The activation header text
    */
-  async collectConfiguration(options = {}) {
+  async getAgentCommandHeader() {
+    const headerPath = getSourcePath('tools/cli/installers/lib/ide/templates', 'codex-agent-command-template.md');
+    return await fs.readFile(headerPath, 'utf8');
+  }
+
+  /**
+   * Override setup to add install location choice and instructions
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Collect install location choice
+    const installLocation = options.preCollectedConfig?.installLocation || (await this.collectInstallLocation());
+
+    // Determine destination directory
+    const destDir = this.getCodexPromptDir(projectDir, installLocation);
+    await fs.ensureDir(destDir);
+    await this.clearOldBmadFiles(destDir);
+
+    // Use unified installer with custom destination
+    const { UnifiedInstaller, NamingStyle } = require('./shared/unified-installer');
+    const installer = new UnifiedInstaller(this.bmadFolderName);
+    const counts = await installer.install(
+      projectDir,
+      bmadDir,
+      {
+        targetDir: destDir,
+        namingStyle: NamingStyle.FLAT_DASH,
+        frontmatterTemplate: 'none', // Codex uses no frontmatter
+      },
+      options.selectedModules || [],
+    );
+
+    // Show results and instructions
+    this.printResults(counts, destDir, installLocation);
+
+    return {
+      success: true,
+      mode: 'cli',
+      ...counts,
+      destination: destDir,
+      installLocation,
+    };
+  }
+
+  /**
+   * Collect install location choice from user
+   */
+  async collectInstallLocation() {
     let confirmed = false;
     let installLocation = 'global';
 
@@ -32,18 +89,17 @@ class CodexSetup extends BaseIdeSetup {
         message: 'Where would you like to install Codex CLI prompts?',
         choices: [
           {
-            name: 'Global - Simple for single project ' + '(~/.codex/prompts, but references THIS project only)',
+            name: 'Global - Simple for single project (~/codex/prompts, references THIS project only)',
             value: 'global',
           },
           {
-            name: `Project-specific - Recommended for real work (requires CODEX_HOME=<project-dir>${path.sep}.codex)`,
+            name: `Project-specific - Recommended for real work (requires CODEX_HOME=<project-dir>/.codex)`,
             value: 'project',
           },
         ],
         default: 'global',
       });
 
-      // Display detailed instructions for the chosen option
       console.log('');
       if (installLocation === 'project') {
         console.log(this.getProjectSpecificInstructions());
@@ -51,7 +107,6 @@ class CodexSetup extends BaseIdeSetup {
         console.log(this.getGlobalInstructions());
       }
 
-      // Confirm the choice
       confirmed = await prompts.confirm({
         message: 'Proceed with this installation option?',
         default: true,
@@ -66,168 +121,8 @@ class CodexSetup extends BaseIdeSetup {
   }
 
   /**
-   * Setup Codex configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
+   * Get Codex prompts directory based on location choice
    */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Always use CLI mode
-    const mode = 'cli';
-
-    // Get installation location from pre-collected config or default to global
-    const installLocation = options.preCollectedConfig?.installLocation || 'global';
-
-    const { artifacts, counts } = await this.collectClaudeArtifacts(projectDir, bmadDir, options);
-
-    const destDir = this.getCodexPromptDir(projectDir, installLocation);
-    await fs.ensureDir(destDir);
-    await this.clearOldBmadFiles(destDir);
-
-    // Collect artifacts and write using underscore format
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-    const agentCount = await agentGen.writeDashArtifacts(destDir, agentArtifacts);
-
-    const tasks = await getTasksFromBmad(bmadDir, options.selectedModules || []);
-    const taskArtifacts = [];
-    for (const task of tasks) {
-      const content = await this.readAndProcessWithProject(
-        task.path,
-        {
-          module: task.module,
-          name: task.name,
-        },
-        projectDir,
-      );
-      taskArtifacts.push({
-        type: 'task',
-        module: task.module,
-        sourcePath: task.path,
-        relativePath: path.join(task.module, 'tasks', `${task.name}.md`),
-        content,
-      });
-    }
-
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-    const workflowCount = await workflowGenerator.writeDashArtifacts(destDir, workflowArtifacts);
-
-    // Also write tasks using underscore format
-    const ttGen = new TaskToolCommandGenerator();
-    const tasksWritten = await ttGen.writeDashArtifacts(destDir, taskArtifacts);
-
-    const written = agentCount + workflowCount + tasksWritten;
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - Mode: CLI`));
-    console.log(chalk.dim(`  - ${counts.agents} agents exported`));
-    console.log(chalk.dim(`  - ${counts.tasks} tasks exported`));
-    console.log(chalk.dim(`  - ${counts.workflows} workflow commands exported`));
-    if (counts.workflowLaunchers > 0) {
-      console.log(chalk.dim(`  - ${counts.workflowLaunchers} workflow launchers exported`));
-    }
-    console.log(chalk.dim(`  - ${written} Codex prompt files written`));
-    console.log(chalk.dim(`  - Destination: ${destDir}`));
-
-    return {
-      success: true,
-      mode,
-      artifacts,
-      counts,
-      destination: destDir,
-      written,
-      installLocation,
-    };
-  }
-
-  /**
-   * Detect Codex installation by checking for BMAD prompt exports
-   */
-  async detect(projectDir) {
-    // Check both global and project-specific locations
-    const globalDir = this.getCodexPromptDir(null, 'global');
-    const projectDir_local = projectDir || process.cwd();
-    const projectSpecificDir = this.getCodexPromptDir(projectDir_local, 'project');
-
-    // Check global location
-    if (await fs.pathExists(globalDir)) {
-      const entries = await fs.readdir(globalDir);
-      if (entries.some((entry) => entry.startsWith('bmad'))) {
-        return true;
-      }
-    }
-
-    // Check project-specific location
-    if (await fs.pathExists(projectSpecificDir)) {
-      const entries = await fs.readdir(projectSpecificDir);
-      if (entries.some((entry) => entry.startsWith('bmad'))) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Collect Claude-style artifacts for Codex export.
-   * Returns the normalized artifact list for further processing.
-   */
-  async collectClaudeArtifacts(projectDir, bmadDir, options = {}) {
-    const selectedModules = options.selectedModules || [];
-    const artifacts = [];
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, selectedModules);
-
-    for (const artifact of agentArtifacts) {
-      artifacts.push({
-        type: 'agent',
-        module: artifact.module,
-        sourcePath: artifact.sourcePath,
-        relativePath: artifact.relativePath,
-        content: artifact.content,
-      });
-    }
-
-    const tasks = await getTasksFromBmad(bmadDir, selectedModules);
-    for (const task of tasks) {
-      const content = await this.readAndProcessWithProject(
-        task.path,
-        {
-          module: task.module,
-          name: task.name,
-        },
-        projectDir,
-      );
-
-      artifacts.push({
-        type: 'task',
-        module: task.module,
-        sourcePath: task.path,
-        relativePath: path.join(task.module, 'tasks', `${task.name}.md`),
-        content,
-      });
-    }
-
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-    artifacts.push(...workflowArtifacts);
-
-    return {
-      artifacts,
-      counts: {
-        agents: agentArtifacts.length,
-        tasks: tasks.length,
-        workflows: workflowCounts.commands,
-        workflowLaunchers: workflowCounts.launchers,
-      },
-    };
-  }
-
   getCodexPromptDir(projectDir = null, location = 'global') {
     if (location === 'project' && projectDir) {
       return path.join(projectDir, '.codex', 'prompts');
@@ -235,51 +130,35 @@ class CodexSetup extends BaseIdeSetup {
     return path.join(os.homedir(), '.codex', 'prompts');
   }
 
-  async flattenAndWriteArtifacts(artifacts, destDir) {
-    let written = 0;
-
-    for (const artifact of artifacts) {
-      const flattenedName = this.flattenFilename(artifact.relativePath);
-      const targetPath = path.join(destDir, flattenedName);
-      await fs.writeFile(targetPath, artifact.content);
-      written++;
+  /**
+   * Print results and instructions
+   */
+  printResults(counts, destDir, installLocation) {
+    console.log(chalk.green(`✓ Codex configured:`));
+    console.log(chalk.dim(`  - Mode: CLI`));
+    console.log(chalk.dim(`  - Location: ${installLocation}`));
+    console.log(chalk.dim(`  - ${counts.agents} agents installed`));
+    if (counts.workflows > 0) {
+      console.log(chalk.dim(`  - ${counts.workflows} workflow commands generated`));
     }
-
-    return written;
-  }
-
-  async clearOldBmadFiles(destDir) {
-    if (!(await fs.pathExists(destDir))) {
-      return;
+    if (counts.tasks + counts.tools > 0) {
+      console.log(chalk.dim(`  - ${counts.tasks + counts.tools} task/tool commands (${counts.tasks} tasks, ${counts.tools} tools)`));
     }
+    console.log(chalk.dim(`  - ${counts.total} files written`));
+    console.log(chalk.dim(`  - Destination: ${destDir}`));
 
-    const entries = await fs.readdir(destDir);
-
-    for (const entry of entries) {
-      if (!entry.startsWith('bmad')) {
-        continue;
-      }
-
-      const entryPath = path.join(destDir, entry);
-      const stat = await fs.stat(entryPath);
-      if (stat.isFile()) {
-        await fs.remove(entryPath);
-      } else if (stat.isDirectory()) {
-        await fs.remove(entryPath);
-      }
+    // Show setup instructions if project-specific
+    if (installLocation === 'project') {
+      console.log('');
+      console.log(chalk.yellow('  Next steps:'));
+      console.log(chalk.dim(this.getProjectSpecificNextSteps()));
     }
   }
 
-  async readAndProcessWithProject(filePath, metadata, projectDir) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return super.processContent(content, metadata, projectDir);
-  }
-
   /**
    * Get instructions for global installation
-   * @returns {string} Instructions text
    */
-  getGlobalInstructions(destDir) {
+  getGlobalInstructions() {
     const lines = [
       '',
       chalk.bold.cyan('═'.repeat(70)),
@@ -292,7 +171,7 @@ class CodexSetup extends BaseIdeSetup {
       chalk.dim("  To use with other projects, you'd need to copy the _bmad dir"),
       '',
       chalk.green('  ✓ You can now use /commands in Codex CLI'),
-      chalk.dim('    Example: /bmad_bmm_pm'),
+      chalk.dim('    Example: /bmad-bmm-pm'),
       chalk.dim('    Type / to see all available commands'),
       '',
       chalk.bold.cyan('═'.repeat(70)),
@@ -303,11 +182,8 @@ class CodexSetup extends BaseIdeSetup {
 
   /**
    * Get instructions for project-specific installation
-   * @param {string} projectDir - Optional project directory
-   * @param {string} destDir - Optional destination directory
-   * @returns {string} Instructions text
    */
-  getProjectSpecificInstructions(projectDir = null, destDir = null) {
+  getProjectSpecificInstructions() {
     const isWindows = os.platform() === 'win32';
 
     const commonLines = [
@@ -316,7 +192,7 @@ class CodexSetup extends BaseIdeSetup {
       chalk.bold.yellow('  Project-Specific Codex Configuration'),
       chalk.bold.cyan('═'.repeat(70)),
       '',
-      chalk.white('  Prompts will be installed to: ') + chalk.cyan(destDir || '<project>/.codex/prompts'),
+      chalk.white('  Prompts will be installed to: ') + chalk.cyan('<project>/.codex/prompts'),
       '',
       chalk.bold.yellow('  ⚠️  REQUIRED: You must set CODEX_HOME to use these prompts'),
       '',
@@ -341,24 +217,75 @@ class CodexSetup extends BaseIdeSetup {
       chalk.dim('  After adding, run: source ~/.bashrc  (or source ~/.zshrc)'),
       chalk.dim('  (The $PWD uses your current working directory)'),
     ];
-    const closingLines = [
-      '',
-      chalk.dim('  This tells Codex CLI to use prompts from this project instead of ~/.codex'),
-      '',
-      chalk.bold.cyan('═'.repeat(70)),
-      '',
-    ];
 
-    const lines = [...commonLines, ...(isWindows ? windowsLines : unixLines), ...closingLines];
-
-    return lines.join('\n');
+    return [...commonLines, ...(isWindows ? windowsLines : unixLines)].join('\n');
   }
 
   /**
-   * Cleanup Codex configuration
+   * Get next steps for project-specific installation
+   */
+  getProjectSpecificNextSteps() {
+    const isWindows = os.platform() === 'win32';
+    if (isWindows) {
+      return `Create codex.cmd in project root with:\n    set CODEX_HOME=%~dp0.codex\n    codex %*`;
+    }
+    return `Add to ~/.bashrc or ~/.zshrc:\n    alias codex='CODEX_HOME="$PWD/.codex" codex'`;
+  }
+
+  /**
+   * Clear old BMAD files from destination
+   */
+  async clearOldBmadFiles(destDir) {
+    if (!(await fs.pathExists(destDir))) {
+      return;
+    }
+
+    const entries = await fs.readdir(destDir);
+    for (const entry of entries) {
+      if (!entry.startsWith('bmad')) {
+        continue;
+      }
+      const entryPath = path.join(destDir, entry);
+      const stat = await fs.stat(entryPath);
+      if (stat.isFile()) {
+        await fs.remove(entryPath);
+      } else if (stat.isDirectory()) {
+        await fs.remove(entryPath);
+      }
+    }
+  }
+
+  /**
+   * Detect Codex installation (checks both global and project locations)
+   */
+  async detect(projectDir) {
+    const globalDir = this.getCodexPromptDir(null, 'global');
+    const projectDir_local = projectDir || process.cwd();
+    const projectSpecificDir = this.getCodexPromptDir(projectDir_local, 'project');
+
+    // Check global location
+    if (await fs.pathExists(globalDir)) {
+      const entries = await fs.readdir(globalDir);
+      if (entries.some((entry) => entry.startsWith('bmad'))) {
+        return true;
+      }
+    }
+
+    // Check project-specific location
+    if (await fs.pathExists(projectSpecificDir)) {
+      const entries = await fs.readdir(projectSpecificDir);
+      if (entries.some((entry) => entry.startsWith('bmad'))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Cleanup Codex configuration (both global and project-specific)
    */
   async cleanup(projectDir = null) {
-    // Clean both global and project-specific locations
     const globalDir = this.getCodexPromptDir(null, 'global');
     await this.clearOldBmadFiles(globalDir);
 
@@ -370,37 +297,30 @@ class CodexSetup extends BaseIdeSetup {
 
   /**
    * Install a custom agent launcher for Codex
-   * @param {string} projectDir - Project directory (not used, Codex installs to home)
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
    */
   async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
     const destDir = this.getCodexPromptDir(projectDir, 'project');
     await fs.ensureDir(destDir);
 
-    const launcherContent = `---
-name: '${agentName}'
-description: '${agentName} agent'
----
+    // Load the custom agent launcher template
+    const templatePath = getSourcePath('tools/cli/installers/lib/ide/templates', 'codex-custom-agent-template.md');
+    let templateContent = await fs.readFile(templatePath, 'utf8');
 
-You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+    // Get activation header
+    const activationHeader = await this.getAgentCommandHeader();
 
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
+    // Replace placeholders
+    const relativePath = `_bmad/${agentPath}`;
+    templateContent = templateContent
+      .replaceAll('{{name}}', agentName)
+      .replaceAll('{{description}}', `${agentName} agent`)
+      .replaceAll('{{activationHeader}}', activationHeader)
+      .replaceAll('{{relativePath}}', relativePath);
 
-    // Use underscore format: bmad_custom_fred-commit-poet.md
+    const { customAgentDashName } = require('./shared/path-utils');
     const fileName = customAgentDashName(agentName);
     const launcherPath = path.join(destDir, fileName);
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
+    await fs.writeFile(launcherPath, templateContent, 'utf8');
 
     return {
       path: path.relative(projectDir, launcherPath),

tools/cli/installers/lib/ide/crush.js

@@ -1,149 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { customAgentColonName } = require('./shared/path-utils');
-
-/**
- * Crush IDE setup handler
- * Creates commands in .crush/commands/ directory structure using flat colon naming
- */
-class CrushSetup extends BaseIdeSetup {
-  constructor() {
-    super('crush', 'Crush');
-    this.configDir = '.crush';
-    this.commandsDir = 'commands';
-  }
-
-  /**
-   * Setup Crush IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Create .crush/commands directory
-    const crushDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(crushDir, this.commandsDir);
-    await this.ensureDir(commandsDir);
-
-    // Use underscore format: files written directly to commands dir (no bmad subfolder)
-    // Creates: .crush/commands/bmad_bmm_pm.md
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Write agent launcher files using flat underscore naming
-    // Creates files like: bmad_bmm_pm.md
-    const agentCount = await agentGen.writeColonArtifacts(commandsDir, agentArtifacts);
-
-    // Get ALL workflows using the new workflow command generator
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-
-    // Write workflow-command artifacts using flat underscore naming
-    // Creates files like: bmad_bmm_correct-course.md
-    const workflowCount = await workflowGenerator.writeColonArtifacts(commandsDir, workflowArtifacts);
-
-    // Generate task and tool commands using flat underscore naming
-    const taskToolGen = new TaskToolCommandGenerator();
-    const taskToolResult = await taskToolGen.generateColonTaskToolCommands(projectDir, bmadDir, commandsDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agent commands created`));
-    console.log(chalk.dim(`  - ${taskToolResult.tasks} task commands created`));
-    console.log(chalk.dim(`  - ${taskToolResult.tools} tool commands created`));
-    console.log(chalk.dim(`  - ${workflowCount} workflow commands created`));
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
-    console.log(chalk.dim('\n  Commands can be accessed via Crush command palette'));
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskToolResult.tasks || 0,
-      tools: taskToolResult.tools || 0,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Cleanup Crush configuration
-   */
-  async cleanup(projectDir) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    // Remove any bmad* files from the commands directory (cleans up old bmad: and bmad- formats)
-    if (await fs.pathExists(commandsDir)) {
-      const entries = await fs.readdir(commandsDir);
-      for (const entry of entries) {
-        if (entry.startsWith('bmad')) {
-          await fs.remove(path.join(commandsDir, entry));
-        }
-      }
-    }
-    // Also remove legacy bmad folder if it exists
-    const bmadFolder = path.join(commandsDir, 'bmad');
-    if (await fs.pathExists(bmadFolder)) {
-      await fs.remove(bmadFolder);
-      console.log(chalk.dim(`Removed BMAD commands from Crush`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Crush
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    // Create .crush/commands directory if it doesn't exist
-    await fs.ensureDir(commandsDir);
-
-    // Create custom agent launcher
-    const launcherContent = `# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this command to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*`;
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    // Written directly to commands dir (no bmad subfolder)
-    const launcherName = customAgentColonName(agentName);
-    const launcherPath = path.join(commandsDir, launcherName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'crush',
-      path: path.relative(projectDir, launcherPath),
-      command: launcherName.replace('.md', ''),
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { CrushSetup };

tools/cli/installers/lib/ide/cursor.js

@@ -1,160 +0,0 @@
-const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { customAgentColonName } = require('./shared/path-utils');
-
-/**
- * Cursor IDE setup handler
- */
-class CursorSetup extends BaseIdeSetup {
-  constructor() {
-    super('cursor', 'Cursor', true); // preferred IDE
-    this.configDir = '.cursor';
-    this.rulesDir = 'rules';
-    this.commandsDir = 'commands';
-  }
-
-  /**
-   * Cleanup old BMAD installation before reinstalling
-   * @param {string} projectDir - Project directory
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    // Remove any bmad* files from the commands directory (cleans up old bmad: and bmad- formats)
-    if (await fs.pathExists(commandsDir)) {
-      const entries = await fs.readdir(commandsDir);
-      for (const entry of entries) {
-        if (entry.startsWith('bmad')) {
-          await fs.remove(path.join(commandsDir, entry));
-        }
-      }
-    }
-    // Also remove legacy bmad folder if it exists
-    const bmadFolder = path.join(commandsDir, 'bmad');
-    if (await fs.pathExists(bmadFolder)) {
-      await fs.remove(bmadFolder);
-      console.log(chalk.dim(`  Removed old BMAD commands from ${this.name}`));
-    }
-  }
-
-  /**
-   * Setup Cursor IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Create .cursor/commands directory structure
-    const cursorDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(cursorDir, this.commandsDir);
-    await this.ensureDir(commandsDir);
-
-    // Use underscore format: files written directly to commands dir (no bmad subfolder)
-    // Creates: .cursor/commands/bmad_bmm_pm.md
-
-    // Generate agent launchers using AgentCommandGenerator
-    // This creates small launcher files that reference the actual agents in _bmad/
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts, counts: agentCounts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Write agent launcher files using flat underscore naming
-    // Creates files like: bmad_bmm_pm.md
-    const agentCount = await agentGen.writeColonArtifacts(commandsDir, agentArtifacts);
-
-    // Generate workflow commands from manifest (if it exists)
-    const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-
-    // Write workflow-command artifacts using flat underscore naming
-    // Creates files like: bmad_bmm_correct-course.md
-    const workflowCommandCount = await workflowGen.writeColonArtifacts(commandsDir, workflowArtifacts);
-
-    // Generate task and tool commands from manifests (if they exist)
-    const taskToolGen = new TaskToolCommandGenerator();
-    const taskToolResult = await taskToolGen.generateColonTaskToolCommands(projectDir, bmadDir, commandsDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed`));
-    if (workflowCommandCount > 0) {
-      console.log(chalk.dim(`  - ${workflowCommandCount} workflow commands generated`));
-    }
-    if (taskToolResult.generated > 0) {
-      console.log(
-        chalk.dim(
-          `  - ${taskToolResult.generated} task/tool commands generated (${taskToolResult.tasks} tasks, ${taskToolResult.tools} tools)`,
-        ),
-      );
-    }
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskToolResult.tasks || 0,
-      tools: taskToolResult.tools || 0,
-      workflows: workflowCommandCount,
-    };
-  }
-
-  /**
-   * Install a custom agent launcher for Cursor
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
-      return null; // IDE not configured for this project
-    }
-
-    await this.ensureDir(commandsDir);
-
-    const launcherContent = `You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
-
-    // Cursor uses YAML frontmatter matching Claude Code format
-    const commandContent = `---
-name: '${agentName}'
-description: '${agentName} agent'
----
-
-${launcherContent}
-`;
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    // Written directly to commands dir (no bmad subfolder)
-    const launcherName = customAgentColonName(agentName);
-    const launcherPath = path.join(commandsDir, launcherName);
-    await this.writeFile(launcherPath, commandContent);
-
-    return {
-      path: launcherPath,
-      command: `/${launcherName.replace('.md', '')}`,
-    };
-  }
-}
-
-module.exports = { CursorSetup };

tools/cli/installers/lib/ide/gemini.js

@@ -1,301 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const yaml = require('yaml');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-
-/**
- * Gemini CLI setup handler
- * Creates TOML files in .gemini/commands/ structure
- */
-class GeminiSetup extends BaseIdeSetup {
-  constructor() {
-    super('gemini', 'Gemini CLI', false);
-    this.configDir = '.gemini';
-    this.commandsDir = 'commands';
-    this.agentTemplatePath = path.join(__dirname, 'templates', 'gemini-agent-command.toml');
-    this.taskTemplatePath = path.join(__dirname, 'templates', 'gemini-task-command.toml');
-  }
-
-  /**
-   * Load config values from bmad installation
-   * @param {string} bmadDir - BMAD installation directory
-   * @returns {Object} Config values
-   */
-  async loadConfigValues(bmadDir) {
-    const configValues = {
-      user_name: 'User', // Default fallback
-    };
-
-    // Try to load core config.yaml
-    const coreConfigPath = path.join(bmadDir, 'core', 'config.yaml');
-    if (await fs.pathExists(coreConfigPath)) {
-      try {
-        const configContent = await fs.readFile(coreConfigPath, 'utf8');
-        const config = yaml.parse(configContent);
-
-        if (config.user_name) {
-          configValues.user_name = config.user_name;
-        }
-      } catch (error) {
-        console.warn(chalk.yellow(`  Warning: Could not load config values: ${error.message}`));
-      }
-    }
-
-    return configValues;
-  }
-
-  /**
-   * Setup Gemini CLI configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .gemini/commands directory (flat structure with bmad- prefix)
-    const geminiDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(geminiDir, this.commandsDir);
-
-    await this.ensureDir(commandsDir);
-
-    // Clean up any existing BMAD files before reinstalling
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Get tasks and workflows (ALL workflows now generate commands)
-    const tasks = await this.getTasks(bmadDir);
-
-    // Get ALL workflows using the new workflow command generator
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-
-    // Install agents as TOML files with bmad- prefix (flat structure)
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const tomlContent = await this.createAgentLauncherToml(artifact);
-
-      // Flat structure: bmad-agent-{module}-{name}.toml
-      const tomlPath = path.join(commandsDir, `bmad-agent-${artifact.module}-${artifact.name}.toml`);
-      await this.writeFile(tomlPath, tomlContent);
-      agentCount++;
-
-      console.log(chalk.green(`  ✓ Added agent: /bmad_agents_${artifact.module}_${artifact.name}`));
-    }
-
-    // Install tasks as TOML files with bmad- prefix (flat structure)
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const tomlContent = await this.createTaskToml(task, content);
-
-      // Flat structure: bmad-task-{module}-{name}.toml
-      const tomlPath = path.join(commandsDir, `bmad-task-${task.module}-${task.name}.toml`);
-      await this.writeFile(tomlPath, tomlContent);
-      taskCount++;
-
-      console.log(chalk.green(`  ✓ Added task: /bmad_tasks_${task.module}_${task.name}`));
-    }
-
-    // Install workflows as TOML files with bmad- prefix (flat structure)
-    let workflowCount = 0;
-    for (const artifact of workflowArtifacts) {
-      if (artifact.type === 'workflow-command') {
-        // Create TOML wrapper around workflow command content
-        const tomlContent = await this.createWorkflowToml(artifact);
-
-        // Flat structure: bmad-workflow-{module}-{name}.toml
-        const workflowName = path.basename(artifact.relativePath, '.md');
-        const tomlPath = path.join(commandsDir, `bmad-workflow-${artifact.module}-${workflowName}.toml`);
-        await this.writeFile(tomlPath, tomlContent);
-        workflowCount++;
-
-        console.log(chalk.green(`  ✓ Added workflow: /bmad_workflows_${artifact.module}_${workflowName}`));
-      }
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents configured`));
-    console.log(chalk.dim(`  - ${taskCount} tasks configured`));
-    console.log(chalk.dim(`  - ${workflowCount} workflows configured`));
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
-    console.log(chalk.dim(`  - Agent activation: /bmad_agents_{agent-name}`));
-    console.log(chalk.dim(`  - Task activation: /bmad_tasks_{task-name}`));
-    console.log(chalk.dim(`  - Workflow activation: /bmad_workflows_{workflow-name}`));
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskCount,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Create agent launcher TOML content from artifact
-   */
-  async createAgentLauncherToml(artifact) {
-    // Strip frontmatter from launcher content
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
-
-    // Extract title from launcher frontmatter
-    const titleMatch = artifact.content.match(/description:\s*"([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
-
-    // Create TOML wrapper around launcher content (without frontmatter)
-    const description = `BMAD ${artifact.module.toUpperCase()} Agent: ${title}`;
-
-    return `description = "${description}"
-prompt = """
-${contentWithoutFrontmatter}
-"""
-`;
-  }
-
-  /**
-   * Create agent TOML content using template
-   */
-  async createAgentToml(agent, content) {
-    // Extract metadata
-    const titleMatch = content.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
-
-    // Load template
-    const template = await fs.readFile(this.agentTemplatePath, 'utf8');
-
-    // Replace template variables
-    // Note: {user_name} and other {config_values} are left as-is for runtime substitution by Gemini
-    const tomlContent = template
-      .replaceAll('{{title}}', title)
-      .replaceAll('{_bmad}', '_bmad')
-      .replaceAll('{_bmad}', this.bmadFolderName)
-      .replaceAll('{{module}}', agent.module)
-      .replaceAll('{{name}}', agent.name);
-
-    return tomlContent;
-  }
-
-  /**
-   * Create task TOML content using template
-   */
-  async createTaskToml(task, content) {
-    // Extract task name from XML if available
-    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
-    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
-
-    // Load template
-    const template = await fs.readFile(this.taskTemplatePath, 'utf8');
-
-    // Replace template variables
-    const tomlContent = template
-      .replaceAll('{{taskName}}', taskName)
-      .replaceAll('{_bmad}', '_bmad')
-      .replaceAll('{_bmad}', this.bmadFolderName)
-      .replaceAll('{{module}}', task.module)
-      .replaceAll('{{filename}}', task.filename);
-
-    return tomlContent;
-  }
-
-  /**
-   * Create workflow TOML content from artifact
-   */
-  async createWorkflowToml(artifact) {
-    // Extract description from artifact content
-    const descriptionMatch = artifact.content.match(/description:\s*"([^"]+)"/);
-    const description = descriptionMatch
-      ? descriptionMatch[1]
-      : `BMAD ${artifact.module.toUpperCase()} Workflow: ${path.basename(artifact.relativePath, '.md')}`;
-
-    // Strip frontmatter from command content
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
-
-    return `description = "${description}"
-prompt = """
-${contentWithoutFrontmatter}
-"""
-`;
-  }
-
-  /**
-   * Cleanup Gemini configuration - surgically remove only BMAD files
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    if (await fs.pathExists(commandsDir)) {
-      // Remove any bmad* files (cleans up old bmad- and bmad: formats)
-      const files = await fs.readdir(commandsDir);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.toml')) {
-          await fs.remove(path.join(commandsDir, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0) {
-        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD files`));
-      }
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Gemini
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const geminiDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(geminiDir, this.commandsDir);
-
-    // Create .gemini/commands directory if it doesn't exist
-    await fs.ensureDir(commandsDir);
-
-    // Create custom agent launcher in TOML format
-    const launcherContent = `description = "Custom BMAD Agent: ${agentName}"
-prompt = """
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this command to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*
-"""`;
-
-    const fileName = `bmad-custom-${agentName.toLowerCase()}.toml`;
-    const launcherPath = path.join(commandsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'gemini',
-      path: path.relative(projectDir, launcherPath),
-      command: agentName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { GeminiSetup };

tools/cli/installers/lib/ide/github-copilot.js

@@ -1,383 +0,0 @@
-const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const prompts = require('../../../lib/prompts');
-
-/**
- * GitHub Copilot setup handler
- * Creates agents in .github/agents/ and configures VS Code settings
- */
-class GitHubCopilotSetup extends BaseIdeSetup {
-  constructor() {
-    super('github-copilot', 'GitHub Copilot', true); // preferred IDE
-    this.configDir = '.github';
-    this.agentsDir = 'agents';
-    this.vscodeDir = '.vscode';
-  }
-
-  /**
-   * Collect configuration choices before installation
-   * @param {Object} options - Configuration options
-   * @returns {Object} Collected configuration
-   */
-  async collectConfiguration(options = {}) {
-    const config = {};
-
-    console.log('\n' + chalk.blue('  🔧 VS Code Settings Configuration'));
-    console.log(chalk.dim('  GitHub Copilot works best with specific settings\n'));
-
-    config.vsCodeConfig = await prompts.select({
-      message: 'How would you like to configure VS Code settings?',
-      choices: [
-        { name: 'Use recommended defaults (fastest)', value: 'defaults' },
-        { name: 'Configure each setting manually', value: 'manual' },
-        { name: 'Skip settings configuration', value: 'skip' },
-      ],
-      default: 'defaults',
-    });
-
-    if (config.vsCodeConfig === 'manual') {
-      config.manualSettings = await prompts.prompt([
-        {
-          type: 'input',
-          name: 'maxRequests',
-          message: 'Maximum requests per session (1-50)?',
-          default: '15',
-          validate: (input) => {
-            const num = parseInt(input, 10);
-            if (isNaN(num)) return 'Enter a valid number 1-50';
-            if (num < 1 || num > 50) return 'Enter a number between 1-50';
-            return true;
-          },
-        },
-        {
-          type: 'confirm',
-          name: 'runTasks',
-          message: 'Allow running workspace tasks?',
-          default: true,
-        },
-        {
-          type: 'confirm',
-          name: 'mcpDiscovery',
-          message: 'Enable MCP server discovery?',
-          default: true,
-        },
-        {
-          type: 'confirm',
-          name: 'autoFix',
-          message: 'Enable automatic error fixing?',
-          default: true,
-        },
-        {
-          type: 'confirm',
-          name: 'autoApprove',
-          message: 'Auto-approve tools (less secure)?',
-          default: false,
-        },
-      ]);
-    }
-
-    return config;
-  }
-
-  /**
-   * Setup GitHub Copilot configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Configure VS Code settings using pre-collected config if available
-    const config = options.preCollectedConfig || {};
-    await this.configureVsCodeSettings(projectDir, { ...options, ...config });
-
-    // Create .github/agents directory
-    const githubDir = path.join(projectDir, this.configDir);
-    const agentsDir = path.join(githubDir, this.agentsDir);
-    await this.ensureDir(agentsDir);
-
-    // Clean up any existing BMAD files before reinstalling
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Create agent files with bmd- prefix
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const content = artifact.content;
-      const agentContent = await this.createAgentContent({ module: artifact.module, name: artifact.name }, content);
-
-      // Use bmd- prefix: bmd-custom-{module}-{name}.agent.md
-      const targetPath = path.join(agentsDir, `bmd-custom-${artifact.module}-${artifact.name}.agent.md`);
-      await this.writeFile(targetPath, agentContent);
-      agentCount++;
-
-      console.log(chalk.green(`  ✓ Created agent: bmd-custom-${artifact.module}-${artifact.name}`));
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents created`));
-    console.log(chalk.dim(`  - Agents directory: ${path.relative(projectDir, agentsDir)}`));
-    console.log(chalk.dim(`  - VS Code settings configured`));
-    console.log(chalk.dim('\n  Agents available in VS Code Chat view'));
-
-    return {
-      success: true,
-      agents: agentCount,
-      settings: true,
-    };
-  }
-
-  /**
-   * Configure VS Code settings for GitHub Copilot
-   */
-  async configureVsCodeSettings(projectDir, options) {
-    const fs = require('fs-extra');
-    const vscodeDir = path.join(projectDir, this.vscodeDir);
-    const settingsPath = path.join(vscodeDir, 'settings.json');
-
-    await this.ensureDir(vscodeDir);
-
-    // Read existing settings
-    let existingSettings = {};
-    if (await fs.pathExists(settingsPath)) {
-      try {
-        const content = await fs.readFile(settingsPath, 'utf8');
-        existingSettings = JSON.parse(content);
-        console.log(chalk.yellow('  Found existing .vscode/settings.json'));
-      } catch {
-        console.warn(chalk.yellow('  Could not parse settings.json, creating new'));
-      }
-    }
-
-    // Use pre-collected configuration or skip if not available
-    let configChoice = options.vsCodeConfig;
-    if (!configChoice) {
-      // If no pre-collected config, skip configuration
-      console.log(chalk.yellow('  ⚠ No configuration collected, skipping VS Code settings'));
-      return;
-    }
-
-    if (configChoice === 'skip') {
-      console.log(chalk.yellow('  ⚠ Skipping VS Code settings'));
-      return;
-    }
-
-    let bmadSettings = {};
-
-    if (configChoice === 'defaults') {
-      bmadSettings = {
-        'chat.agent.enabled': true,
-        'chat.agent.maxRequests': 15,
-        'github.copilot.chat.agent.runTasks': true,
-        'chat.mcp.discovery.enabled': true,
-        'github.copilot.chat.agent.autoFix': true,
-        'chat.tools.autoApprove': false,
-      };
-      console.log(chalk.green('  ✓ Using recommended defaults'));
-    } else {
-      // Manual configuration - use pre-collected settings
-      const manual = options.manualSettings || {};
-
-      const maxRequests = parseInt(manual.maxRequests || '15', 10);
-      bmadSettings = {
-        'chat.agent.enabled': true,
-        'chat.agent.maxRequests': isNaN(maxRequests) ? 15 : maxRequests,
-        'github.copilot.chat.agent.runTasks': manual.runTasks === undefined ? true : manual.runTasks,
-        'chat.mcp.discovery.enabled': manual.mcpDiscovery === undefined ? true : manual.mcpDiscovery,
-        'github.copilot.chat.agent.autoFix': manual.autoFix === undefined ? true : manual.autoFix,
-        'chat.tools.autoApprove': manual.autoApprove || false,
-      };
-    }
-
-    // Merge settings (existing take precedence)
-    const mergedSettings = { ...bmadSettings, ...existingSettings };
-
-    // Write settings
-    await fs.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
-    console.log(chalk.green('  ✓ VS Code settings configured'));
-  }
-
-  /**
-   * Create agent content
-   */
-  async createAgentContent(agent, content) {
-    // Extract metadata from launcher frontmatter if present
-    const descMatch = content.match(/description:\s*"([^"]+)"/);
-    const title = descMatch ? descMatch[1] : this.formatTitle(agent.name);
-
-    const description = `Activates the ${title} agent persona.`;
-
-    // Strip any existing frontmatter from the content
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    let cleanContent = content;
-    if (frontmatterRegex.test(content)) {
-      cleanContent = content.replace(frontmatterRegex, '').trim();
-    }
-
-    // Available GitHub Copilot tools (November 2025 - Official VS Code Documentation)
-    // Reference: https://code.visualstudio.com/docs/copilot/reference/copilot-vscode-features#_chat-tools
-    const tools = [
-      'changes', // List of source control changes
-      'edit', // Edit files in your workspace including: createFile, createDirectory, editNotebook, newJupyterNotebook and editFiles
-      'fetch', // Fetch content from web page
-      'githubRepo', // Perform code search in GitHub repo
-      'problems', // Add workspace issues from Problems panel
-      'runCommands', // Runs commands in the terminal including: getTerminalOutput, terminalSelection, terminalLastCommand and runInTerminal
-      'runTasks', // Runs tasks and gets their output for your workspace
-      'runTests', // Run unit tests in workspace
-      'search', // Search and read files in your workspace, including:fileSearch, textSearch, listDirectory, readFile, codebase and searchResults
-      'runSubagent', // Runs a task within an isolated subagent context. Enables efficient organization of tasks and context window management.
-      'testFailure', // Get unit test failure information
-      'todos', // Tool for managing and tracking todo items for task planning
-      'usages', // Find references and navigate definitions
-    ];
-
-    let agentContent = `---
-description: "${description.replaceAll('"', String.raw`\"`)}"
-tools: ${JSON.stringify(tools)}
----
-
-# ${title} Agent
-
-${cleanContent}
-
-`;
-
-    return agentContent;
-  }
-
-  /**
-   * Format name as title
-   */
-  formatTitle(name) {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Cleanup GitHub Copilot configuration - surgically remove only BMAD files
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-
-    // Clean up old chatmodes directory
-    const chatmodesDir = path.join(projectDir, this.configDir, 'chatmodes');
-    if (await fs.pathExists(chatmodesDir)) {
-      const files = await fs.readdir(chatmodesDir);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.chatmode.md')) {
-          await fs.remove(path.join(chatmodesDir, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0) {
-        console.log(chalk.dim(`  Cleaned up ${removed} old BMAD chat modes`));
-      }
-    }
-
-    // Clean up new agents directory
-    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
-    if (await fs.pathExists(agentsDir)) {
-      const files = await fs.readdir(agentsDir);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('bmd-') && file.endsWith('.agent.md')) {
-          await fs.remove(path.join(agentsDir, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0) {
-        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD agents`));
-      }
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for GitHub Copilot
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
-
-    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
-      return null; // IDE not configured for this project
-    }
-
-    await this.ensureDir(agentsDir);
-
-    const launcherContent = `You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
-
-    // GitHub Copilot needs specific tools in frontmatter
-    const copilotTools = [
-      'changes',
-      'codebase',
-      'createDirectory',
-      'createFile',
-      'editFiles',
-      'fetch',
-      'fileSearch',
-      'githubRepo',
-      'listDirectory',
-      'problems',
-      'readFile',
-      'runInTerminal',
-      'runTask',
-      'runTests',
-      'runVscodeCommand',
-      'search',
-      'searchResults',
-      'terminalLastCommand',
-      'terminalSelection',
-      'testFailure',
-      'textSearch',
-      'usages',
-    ];
-
-    const agentContent = `---
-description: "Activates the ${metadata.title || agentName} agent persona."
-tools: ${JSON.stringify(copilotTools)}
----
-
-# ${metadata.title || agentName} Agent
-
-${launcherContent}
-`;
-
-    const agentFilePath = path.join(agentsDir, `bmd-custom-${agentName}.agent.md`);
-    await this.writeFile(agentFilePath, agentContent);
-
-    return {
-      path: agentFilePath,
-      command: `bmd-custom-${agentName}`,
-    };
-  }
-}
-
-module.exports = { GitHubCopilotSetup };

tools/cli/installers/lib/ide/iflow.js

@@ -1,191 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-
-/**
- * iFlow CLI setup handler
- * Creates commands in .iflow/commands/ directory structure
- */
-class IFlowSetup extends BaseIdeSetup {
-  constructor() {
-    super('iflow', 'iFlow CLI');
-    this.configDir = '.iflow';
-    this.commandsDir = 'commands';
-  }
-
-  /**
-   * Setup iFlow CLI configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .iflow/commands/bmad directory structure
-    const iflowDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(iflowDir, this.commandsDir, 'bmad');
-    const agentsDir = path.join(commandsDir, 'agents');
-    const tasksDir = path.join(commandsDir, 'tasks');
-    const workflowsDir = path.join(commandsDir, 'workflows');
-
-    await this.ensureDir(agentsDir);
-    await this.ensureDir(tasksDir);
-    await this.ensureDir(workflowsDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Setup agents as commands
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const commandContent = await this.createAgentCommand(artifact);
-
-      const targetPath = path.join(agentsDir, `${artifact.module}-${artifact.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      agentCount++;
-    }
-
-    // Get tasks and workflows (ALL workflows now generate commands)
-    const tasks = await this.getTasks(bmadDir);
-
-    // Get ALL workflows using the new workflow command generator
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-
-    // Setup tasks as commands
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const commandContent = this.createTaskCommand(task, content);
-
-      const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      taskCount++;
-    }
-
-    // Setup workflows as commands (already generated)
-    let workflowCount = 0;
-    for (const artifact of workflowArtifacts) {
-      if (artifact.type === 'workflow-command') {
-        const targetPath = path.join(workflowsDir, `${artifact.module}-${path.basename(artifact.relativePath, '.md')}.md`);
-        await this.writeFile(targetPath, artifact.content);
-        workflowCount++;
-      }
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agent commands created`));
-    console.log(chalk.dim(`  - ${taskCount} task commands created`));
-    console.log(chalk.dim(`  - ${workflowCount} workflow commands created`));
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskCount,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Create agent command content
-   */
-  async createAgentCommand(artifact) {
-    // The launcher content is already complete - just return it as-is
-    return artifact.content;
-  }
-
-  /**
-   * Create task command content
-   */
-  createTaskCommand(task, content) {
-    // Extract task name
-    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
-    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
-
-    let commandContent = `# /task-${task.name} Command
-
-When this command is used, execute the following task:
-
-## ${taskName} Task
-
-${content}
-
-## Usage
-
-This command executes the ${taskName} task from the BMAD ${task.module.toUpperCase()} module.
-
-## Module
-
-Part of the BMAD ${task.module.toUpperCase()} module.
-`;
-
-    return commandContent;
-  }
-
-  /**
-   * Cleanup iFlow configuration
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, 'bmad');
-
-    if (await fs.pathExists(bmadCommandsDir)) {
-      await fs.remove(bmadCommandsDir);
-      console.log(chalk.dim(`Removed BMAD commands from iFlow CLI`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for iFlow
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const iflowDir = path.join(projectDir, this.configDir);
-    const bmadCommandsDir = path.join(iflowDir, this.commandsDir, 'bmad');
-
-    // Create .iflow/commands/bmad directory if it doesn't exist
-    await fs.ensureDir(bmadCommandsDir);
-
-    // Create custom agent launcher
-    const launcherContent = `# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this command to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*`;
-
-    const fileName = `custom-${agentName.toLowerCase()}.md`;
-    const launcherPath = path.join(bmadCommandsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'iflow',
-      path: path.relative(projectDir, launcherPath),
-      command: agentName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { IFlowSetup };

tools/cli/installers/lib/ide/kilo.js

@@ -115,18 +115,20 @@ class KiloSetup extends BaseIdeSetup {
 
     // Build mode entry (KiloCode uses same schema as Roo)
     const slug = `bmad-${artifact.module}-${artifact.name}`;
-    let modeEntry = ` - slug: ${slug}\n`;
-    modeEntry += `   name: '${icon} ${title}'\n`;
-    modeEntry += `   roleDefinition: ${roleDefinition}\n`;
-    modeEntry += `   whenToUse: ${whenToUse}\n`;
-    modeEntry += `   customInstructions: |\n`;
-    modeEntry += `    ${activationHeader} Read the full YAML from ${relativePath} start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode\n`;
-    modeEntry += `   groups:\n`;
-    modeEntry += `    - read\n`;
-    modeEntry += `    - edit\n`;
-    modeEntry += `    - browser\n`;
-    modeEntry += `    - command\n`;
-    modeEntry += `    - mcp\n`;
+    const modeEntry = ` - slug: ${slug}
+   name: '${icon} ${title}'
+   roleDefinition: ${roleDefinition}
+   whenToUse: ${whenToUse}
+   customInstructions: |
+    ${activationHeader.trim()}
+    Read the full YAML from ${relativePath} start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode
+   groups:
+    - read
+    - edit
+    - browser
+    - command
+    - mcp
+`;
 
     return modeEntry;
   }

tools/cli/installers/lib/ide/manager.js

@@ -1,16 +1,36 @@
 const fs = require('fs-extra');
 const path = require('node:path');
 const chalk = require('chalk');
+const yaml = require('yaml');
+const { ConfigDrivenIdeSetup, loadPlatformCodes } = require('./_config-driven');
 
 /**
  * IDE Manager - handles IDE-specific setup
  * Dynamically discovers and loads IDE handlers
+ *
+ * NEW: Loads config-driven handlers from platform-codes.yaml
+ * Custom installer files (like kilo.js, kiro-cli.js) are still supported
+ * for IDEs with truly unique requirements.
  */
 class IdeManager {
   constructor() {
     this.handlers = new Map();
-    this.loadHandlers();
+    this.platformConfig = null;
     this.bmadFolderName = 'bmad'; // Default, can be overridden
+    this._initialized = false;
+    // Load custom handlers synchronously
+    this.loadCustomInstallerFiles(__dirname);
+  }
+
+  /**
+   * Ensure handlers are initialized (loads config-driven handlers)
+   * Call this before using handlers if needed
+   */
+  async ensureInitialized() {
+    if (!this._initialized) {
+      await this.loadConfigDrivenHandlers();
+      this._initialized = true;
+    }
   }
 
   /**
@@ -28,15 +48,28 @@ class IdeManager {
   }
 
   /**
-   * Dynamically load all IDE handlers from directory
+   * Dynamically load all IDE handlers
+   *
+   * Loading order:
+   * 1. Load custom installer files (kilo.js, kiro-cli.js) for IDEs with unique requirements
+   * 2. Load config-driven handlers from platform-codes.yaml for all other IDEs
+   * @deprecated Use ensureInitialized() instead
    */
-  loadHandlers() {
-    const ideDir = __dirname;
+  async loadHandlers() {
+    await this.ensureInitialized();
+  }
 
+  /**
+   * Load custom installer files (for IDEs with truly unique requirements)
+   * Synchronous version for constructor
+   * @param {string} ideDir - IDE handlers directory
+   */
+  loadCustomInstallerFiles(ideDir) {
     try {
       // Get all JS files in the IDE directory
       const files = fs.readdirSync(ideDir).filter((file) => {
-        // Skip base class, manager, utility files (starting with _), and helper modules
+        // Skip base class, manager, config-driven, utility files (starting with _)
+        // Also skip shared directory and generator files
         return (
           file.endsWith('.js') &&
           !file.startsWith('_') &&
@@ -74,15 +107,64 @@ class IdeManager {
         }
       }
     } catch (error) {
-      console.error(chalk.red('Failed to load IDE handlers:'), error.message);
+      console.error(chalk.red('Failed to load custom IDE handlers:'), error.message);
+    }
+  }
+
+  /**
+   * Load config-driven handlers from platform-codes.yaml
+   * Async version called by ensureInitialized()
+   */
+  async loadConfigDrivenHandlers() {
+    try {
+      // Load platform-codes.yaml configuration
+      this.platformConfig = await loadPlatformCodes();
+
+      // Create config-driven handlers for platforms with installer config
+      if (this.platformConfig.platforms) {
+        for (const [platformCode, platformInfo] of Object.entries(this.platformConfig.platforms)) {
+          // Skip if custom handler already exists
+          if (this.handlers.has(platformCode)) {
+            continue;
+          }
+
+          // Skip if no installer config
+          if (!platformInfo.installer) {
+            continue;
+          }
+
+          try {
+            const handler = new ConfigDrivenIdeSetup(platformCode, platformInfo);
+            handler.setBmadFolderName(this.bmadFolderName);
+            this.handlers.set(platformCode, handler);
+          } catch (error) {
+            console.warn(chalk.yellow(`  Warning: Could not create config-driven handler for ${platformCode}: ${error.message}`));
+          }
+        }
+      }
+
+      // Log summary
+      const customCount = [...this.handlers.entries()].filter(([key]) => {
+        const handler = this.handlers.get(key);
+        return handler && !(handler instanceof ConfigDrivenIdeSetup);
+      }).length;
+      const configCount = [...this.handlers.entries()].filter(([key]) => {
+        const handler = this.handlers.get(key);
+        return handler && handler instanceof ConfigDrivenIdeSetup;
+      }).length;
+      console.log(chalk.dim(`  Loaded ${customCount} custom handlers, ${configCount} config-driven handlers`));
+    } catch (error) {
+      console.error(chalk.red('Failed to load config-driven handlers:'), error.message);
     }
   }
 
   /**
    * Get all available IDEs with their metadata
-   * @returns {Array} Array of IDE information objects
+   * @returns {Promise<Array>} Array of IDE information objects
    */
-  getAvailableIdes() {
+  async getAvailableIdes() {
+    await this.ensureInitialized();
+
     const ides = [];
 
     for (const [key, handler] of this.handlers) {
@@ -113,18 +195,20 @@ class IdeManager {
 
   /**
    * Get preferred IDEs
-   * @returns {Array} Array of preferred IDE information
+   * @returns {Promise<Array>} Array of preferred IDE information
    */
-  getPreferredIdes() {
-    return this.getAvailableIdes().filter((ide) => ide.preferred);
+  async getPreferredIdes() {
+    const ides = await this.getAvailableIdes();
+    return ides.filter((ide) => ide.preferred);
   }
 
   /**
    * Get non-preferred IDEs
-   * @returns {Array} Array of non-preferred IDE information
+   * @returns {Promise<Array>} Array of non-preferred IDE information
    */
-  getOtherIdes() {
-    return this.getAvailableIdes().filter((ide) => !ide.preferred);
+  async getOtherIdes() {
+    const ides = await this.getAvailableIdes();
+    return ides.filter((ide) => !ide.preferred);
   }
 
   /**
@@ -135,6 +219,8 @@ class IdeManager {
    * @param {Object} options - Setup options
    */
   async setup(ideName, projectDir, bmadDir, options = {}) {
+    await this.ensureInitialized();
+
     const handler = this.handlers.get(ideName.toLowerCase());
 
     if (!handler) {

tools/cli/installers/lib/ide/opencode.js

@@ -1,257 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const os = require('node:os');
-const chalk = require('chalk');
-const yaml = require('yaml');
-const { BaseIdeSetup } = require('./_base-ide');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-
-/**
- * OpenCode IDE setup handler
- */
-class OpenCodeSetup extends BaseIdeSetup {
-  constructor() {
-    super('opencode', 'OpenCode', true); // Mark as preferred/recommended
-    this.configDir = '.opencode';
-    this.commandsDir = 'command';
-    this.agentsDir = 'agent';
-  }
-
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    const baseDir = path.join(projectDir, this.configDir);
-    const commandsBaseDir = path.join(baseDir, this.commandsDir);
-    const agentsBaseDir = path.join(baseDir, this.agentsDir);
-
-    await this.ensureDir(commandsBaseDir);
-    await this.ensureDir(agentsBaseDir);
-
-    // Clean up any existing BMAD files before reinstalling
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Install primary agents with flat naming: bmad-agent-{module}-{name}.md
-    // OpenCode agents go in the agent folder (not command folder)
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const agentContent = artifact.content;
-      // Flat structure in agent folder: bmad-agent-{module}-{name}.md
-      const targetPath = path.join(agentsBaseDir, `bmad-agent-${artifact.module}-${artifact.name}.md`);
-      await this.writeFile(targetPath, agentContent);
-      agentCount++;
-    }
-
-    // Install workflow commands with flat naming: bmad-{module}-{workflow-name}
-    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
-
-    let workflowCommandCount = 0;
-    for (const artifact of workflowArtifacts) {
-      if (artifact.type === 'workflow-command') {
-        const commandContent = artifact.content;
-        // Flat structure: bmad-{module}-{workflow-name}.md
-        // artifact.relativePath is like: bmm/workflows/plan-project.md
-        const workflowName = path.basename(artifact.relativePath, '.md');
-        const targetPath = path.join(commandsBaseDir, `bmad-${artifact.module}-${workflowName}.md`);
-        await this.writeFile(targetPath, commandContent);
-        workflowCommandCount++;
-      }
-      // Skip workflow launcher READMEs as they're not needed in flat structure
-    }
-
-    // Install task and tool commands with flat naming
-    const { tasks, tools } = await this.generateFlatTaskToolCommands(bmadDir, commandsBaseDir);
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed to .opencode/agent/`));
-    if (workflowCommandCount > 0) {
-      console.log(chalk.dim(`  - ${workflowCommandCount} workflows installed to .opencode/command/`));
-    }
-    if (tasks + tools > 0) {
-      console.log(chalk.dim(`  - ${tasks + tools} tasks/tools installed to .opencode/command/ (${tasks} tasks, ${tools} tools)`));
-    }
-
-    return {
-      success: true,
-      agents: agentCount,
-      workflows: workflowCommandCount,
-      workflowCounts,
-    };
-  }
-
-  /**
-   * Generate flat task and tool commands for OpenCode
-   * OpenCode doesn't support nested command directories
-   */
-  async generateFlatTaskToolCommands(bmadDir, commandsBaseDir) {
-    const taskToolGen = new TaskToolCommandGenerator();
-    const tasks = await taskToolGen.loadTaskManifest(bmadDir);
-    const tools = await taskToolGen.loadToolManifest(bmadDir);
-
-    // Filter to only standalone items
-    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-
-    // Generate command files for tasks with flat naming: bmad-task-{module}-{name}.md
-    for (const task of standaloneTasks) {
-      const commandContent = taskToolGen.generateCommandContent(task, 'task');
-      const targetPath = path.join(commandsBaseDir, `bmad-task-${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-    }
-
-    // Generate command files for tools with flat naming: bmad-tool-{module}-{name}.md
-    for (const tool of standaloneTools) {
-      const commandContent = taskToolGen.generateCommandContent(tool, 'tool');
-      const targetPath = path.join(commandsBaseDir, `bmad-tool-${tool.module}-${tool.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-    }
-
-    return {
-      tasks: standaloneTasks.length,
-      tools: standaloneTools.length,
-    };
-  }
-
-  async readAndProcess(filePath, metadata) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return this.processContent(content, metadata);
-  }
-
-  async createAgentContent(content, metadata) {
-    const { frontmatter = {}, body } = this.parseFrontmatter(content);
-
-    frontmatter.description =
-      frontmatter.description && String(frontmatter.description).trim().length > 0
-        ? frontmatter.description
-        : `BMAD ${metadata.module} agent: ${metadata.name}`;
-
-    // OpenCode agents use: 'primary' mode for main agents
-    frontmatter.mode = 'primary';
-
-    const frontmatterString = this.stringifyFrontmatter(frontmatter);
-
-    // Get the activation header from central template
-    const activationHeader = await this.getAgentCommandHeader();
-
-    return `${frontmatterString}\n\n${activationHeader}\n\n${body}`;
-  }
-
-  parseFrontmatter(content) {
-    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
-    if (!match) {
-      return { data: {}, body: content };
-    }
-
-    const body = content.slice(match[0].length);
-
-    let frontmatter = {};
-    try {
-      frontmatter = yaml.parse(match[1]) || {};
-    } catch {
-      frontmatter = {};
-    }
-
-    return { frontmatter, body };
-  }
-
-  stringifyFrontmatter(frontmatter) {
-    const yamlText = yaml
-      .dump(frontmatter, {
-        indent: 2,
-        lineWidth: -1,
-        noRefs: true,
-        sortKeys: false,
-      })
-      .trimEnd();
-
-    return `---\n${yamlText}\n---`;
-  }
-
-  /**
-   * Cleanup OpenCode configuration - surgically remove only BMAD files
-   */
-  async cleanup(projectDir) {
-    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
-    const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-    let removed = 0;
-
-    // Clean up agent folder
-    if (await fs.pathExists(agentsDir)) {
-      const files = await fs.readdir(agentsDir);
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.md')) {
-          await fs.remove(path.join(agentsDir, file));
-          removed++;
-        }
-      }
-    }
-
-    // Clean up command folder
-    if (await fs.pathExists(commandsDir)) {
-      const files = await fs.readdir(commandsDir);
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.md')) {
-          await fs.remove(path.join(commandsDir, file));
-          removed++;
-        }
-      }
-    }
-
-    if (removed > 0) {
-      console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD files`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for OpenCode
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const agentsDir = path.join(projectDir, this.configDir, this.agentsDir);
-
-    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
-      return null; // IDE not configured for this project
-    }
-
-    await this.ensureDir(agentsDir);
-
-    const launcherContent = `---
-name: '${agentName}'
-description: '${metadata.title || agentName} agent'
-mode: 'primary'
----
-
-You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
-
-    // OpenCode uses flat naming: bmad-agent-custom-{name}.md
-    const launcherPath = path.join(agentsDir, `bmad-agent-custom-${agentName}.md`);
-    await this.writeFile(launcherPath, launcherContent);
-
-    return {
-      path: launcherPath,
-      command: `bmad-agent-custom-${agentName}`,
-    };
-  }
-}
-
-module.exports = { OpenCodeSetup };

tools/cli/installers/lib/ide/platform-codes.yaml

@@ -5,127 +5,177 @@
 # the installation system to identify different platforms (IDEs, tools, etc.)
 #
 # Format:
-#   code: Platform identifier used internally
+#   code: Platform identifier used internally (key)
 #   name: Display name shown to users
 #   preferred: Whether this platform is shown as a recommended option on install
-#   category: Type of platform (ide, tool, service, etc.)
+#   category: Type of platform (ide, cli, tool, service, etc.)
+#   installer: Installation configuration (optional)
+#     frontmatter_template: Path to frontmatter template file (relative to templates/frontmatter/)
+#     If not specified, uses 'common-yaml.md' default
 
 platforms:
-  # Recommended Platforms
-  claude-code:
-    name: "Claude Code"
-    preferred: true
-    category: cli
-    description: "Anthropic's official CLI for Claude"
-
-  windsurf:
-    name: "Windsurf"
-    preferred: true
-    category: ide
-    description: "AI-powered IDE with cascade flows"
-
-  cursor:
-    name: "Cursor"
-    preferred: true
-    category: ide
-    description: "AI-first code editor"
-
-  # Other IDEs and Tools
-  cline:
-    name: "Cline"
+  antigravity:
+    name: "Google Antigravity"
     preferred: false
     category: ide
-    description: "AI coding assistant"
-
-  opencode:
-    name: "OpenCode"
-    preferred: false
-    category: ide
-    description: "OpenCode terminal coding assistant"
+    description: "Google's AI development environment"
+    installer:
+      target_dir: .antigravity/commands
+      frontmatter_template: common-yaml.md
 
   auggie:
     name: "Auggie"
     preferred: false
     category: cli
     description: "AI development tool"
+    installer:
+      target_dir: .augment/commands
+      frontmatter_template: common-yaml.md
 
-  roo:
-    name: "Roo Cline"
+  cline:
+    name: "Cline"
     preferred: false
     category: ide
-    description: "Enhanced Cline fork"
+    description: "AI coding assistant"
+    installer:
+      target_dir: .cline/commands
+      frontmatter_template: none # No frontmatter, content as-is
 
-  rovo:
-    name: "Rovo"
-    preferred: false
-    category: ide
-    description: "Atlassian's AI coding assistant"
-
-  rovo-dev:
-    name: "Rovo Dev"
-    preferred: false
-    category: ide
-    description: "Atlassian's Rovo development environment"
-
-  kiro-cli:
-    name: "Kiro CLI"
-    preferred: false
+  claude-code:
+    name: "Claude Code"
+    preferred: true
     category: cli
-    description: "Kiro command-line interface"
-
-  github-copilot:
-    name: "GitHub Copilot"
-    preferred: false
-    category: ide
-    description: "GitHub's AI pair programmer"
-
-  codex:
-    name: "Codex"
-    preferred: false
-    category: cli
-    description: "OpenAI Codex integration"
-
-  qwen:
-    name: "QwenCoder"
-    preferred: false
-    category: ide
-    description: "Qwen AI coding assistant"
-
-  gemini:
-    name: "Gemini CLI"
-    preferred: false
-    category: cli
-    description: "Google's CLI for Gemini"
-
-  iflow:
-    name: "iFlow"
-    preferred: false
-    category: ide
-    description: "AI workflow automation"
-
-  kilo:
-    name: "KiloCoder"
-    preferred: false
-    category: ide
-    description: "AI coding platform"
+    description: "Anthropic's official CLI for Claude"
+    installer:
+      target_dir: .claude/commands
+      frontmatter_template: common-yaml.md
 
   crush:
     name: "Crush"
     preferred: false
     category: ide
     description: "AI development assistant"
+    installer:
+      target_dir: .crush/commands
+      frontmatter_template: common-yaml.md
 
-  antigravity:
-    name: "Google Antigravity"
+  cursor:
+    name: "Cursor"
+    preferred: true
+    category: ide
+    description: "AI-first code editor"
+    installer:
+      target_dir: .cursor/commands
+      frontmatter_template: common-yaml.md
+
+  gemini:
+    name: "Gemini CLI"
+    preferred: false
+    category: cli
+    description: "Google's CLI for Gemini"
+    installer:
+      target_dir: .gemini/commands
+      file_extension: .toml
+      frontmatter_template: common-toml.md
+
+  github-copilot:
+    name: "GitHub Copilot"
+    preferred: true
+    category: ide
+    description: "GitHub's AI pair programmer"
+    installer:
+      targets:
+        - dir: .github/agents
+          frontmatter_template: copilot-agent.md
+          artifact_types: [agents]
+        - dir: .github/prompts
+          frontmatter_template: copilot.md
+          artifact_types: [workflows, tasks, tools]
+      has_vscode_settings: true
+
+  iflow:
+    name: "iFlow"
     preferred: false
     category: ide
-    description: "Google's AI development environment"
+    description: "AI workflow automation"
+    installer:
+      target_dir: .iflow/commands
+      frontmatter_template: common-yaml.md
+
+  kilo:
+    name: "KiloCoder"
+    preferred: false
+    category: ide
+    description: "AI coding platform"
+    # Kilo has custom installer (.kilocodemodes YAML format) - not config-driven
+
+  kiro-cli:
+    name: "Kiro CLI"
+    preferred: false
+    category: cli
+    description: "Kiro command-line interface"
+    # Kiro CLI has custom installer (YAML->JSON conversion) - not config-driven
+
+  opencode:
+    name: "OpenCode"
+    preferred: false
+    category: ide
+    description: "OpenCode terminal coding assistant"
+    installer:
+      targets:
+        - dir: .opencode/agent
+          frontmatter_template: opencode-agent.md
+          artifact_types: [agents]
+        - dir: .opencode/command
+          frontmatter_template: opencode.md
+          artifact_types: [workflows, tasks, tools]
+
+  qwen:
+    name: "QwenCoder"
+    preferred: false
+    category: ide
+    description: "Qwen AI coding assistant"
+    installer:
+      target_dir: .qwen/commands
+      file_extension: .toml
+      frontmatter_template: common-toml.md
+
+  roo:
+    name: "Roo Code"
+    preferred: false
+    category: ide
+    description: "Enhanced Cline fork"
+    installer:
+      target_dir: .roo/commands
+      frontmatter_template: roo.md
+      skip_existing: true
+
+  rovo-dev:
+    name: "Rovo Dev"
+    preferred: false
+    category: ide
+    description: "Atlassian's Rovo development environment"
+    installer:
+      target_dir: .rovo-dev/commands
+      frontmatter_template: common-yaml.md
 
   trae:
     name: "Trae"
     preferred: false
     category: ide
     description: "AI coding tool"
+    installer:
+      target_dir: .trae/rules
+      frontmatter_template: trae.md
+
+  windsurf:
+    name: "Windsurf"
+    preferred: true
+    category: ide
+    description: "AI-powered IDE with cascade flows"
+    installer:
+      target_dir: .windsurf/workflows
+      frontmatter_template: windsurf.md
 
 # Platform categories
 categories:
@@ -155,3 +205,12 @@ conventions:
   name_format: "Title Case"
   max_code_length: 20
   allowed_characters: "a-z0-9-"
+
+  # New universal file naming standard
+  file_naming:
+    agent: "bmad-{module}-{name}.agent.md"
+    workflow: "bmad-{module}-{name}.workflow.md"
+    task: "bmad-{module}-{name}.task.md"
+    tool: "bmad-{module}-{name}.tool.md"
+    example_agent: "bmad-cis-storymaster.agent.md"
+    example_workflow: "bmad-bmm-plan-project.workflow.md"

tools/cli/installers/lib/ide/qwen.js

@@ -1,372 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { getAgentsFromBmad, getTasksFromBmad } = require('./shared/bmad-artifacts');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-
-/**
- * Qwen Code setup handler
- * Creates TOML command files in .qwen/commands/BMad/
- */
-class QwenSetup extends BaseIdeSetup {
-  constructor() {
-    super('qwen', 'Qwen Code');
-    this.configDir = '.qwen';
-    this.commandsDir = 'commands';
-    this.bmadDir = 'bmad';
-  }
-
-  /**
-   * Setup Qwen Code configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .qwen/commands/BMad directory structure
-    const qwenDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(qwenDir, this.commandsDir);
-    const bmadCommandsDir = path.join(commandsDir, this.bmadDir);
-
-    await this.ensureDir(bmadCommandsDir);
-
-    // Update existing settings.json if present
-    await this.updateSettings(qwenDir);
-
-    // Clean up old configuration if exists
-    await this.cleanupOldConfig(qwenDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Get tasks, tools, and workflows (standalone only for tools/workflows)
-    const tasks = await getTasksFromBmad(bmadDir, options.selectedModules || []);
-    const tools = await this.getTools(bmadDir, true);
-    const workflows = await this.getWorkflows(bmadDir, true);
-
-    // Create directories for each module (including standalone)
-    const modules = new Set();
-    for (const item of [...agentArtifacts, ...tasks, ...tools, ...workflows]) modules.add(item.module);
-
-    for (const module of modules) {
-      await this.ensureDir(path.join(bmadCommandsDir, module));
-      await this.ensureDir(path.join(bmadCommandsDir, module, 'agents'));
-      await this.ensureDir(path.join(bmadCommandsDir, module, 'tasks'));
-      await this.ensureDir(path.join(bmadCommandsDir, module, 'tools'));
-      await this.ensureDir(path.join(bmadCommandsDir, module, 'workflows'));
-    }
-
-    // Create TOML files for each agent launcher
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      // Convert markdown launcher content to TOML format
-      const tomlContent = this.processAgentLauncherContent(artifact.content, {
-        module: artifact.module,
-        name: artifact.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, artifact.module, 'agents', `${artifact.name}.toml`);
-
-      await this.writeFile(targetPath, tomlContent);
-
-      agentCount++;
-      console.log(chalk.green(`  ✓ Added agent: /bmad_${artifact.module}_agents_${artifact.name}`));
-    }
-
-    // Create TOML files for each task
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readAndProcess(task.path, {
-        module: task.module,
-        name: task.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, task.module, 'tasks', `${task.name}.toml`);
-
-      await this.writeFile(targetPath, content);
-
-      taskCount++;
-      console.log(chalk.green(`  ✓ Added task: /bmad_${task.module}_tasks_${task.name}`));
-    }
-
-    // Create TOML files for each tool
-    let toolCount = 0;
-    for (const tool of tools) {
-      const content = await this.readAndProcess(tool.path, {
-        module: tool.module,
-        name: tool.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, tool.module, 'tools', `${tool.name}.toml`);
-
-      await this.writeFile(targetPath, content);
-
-      toolCount++;
-      console.log(chalk.green(`  ✓ Added tool: /bmad_${tool.module}_tools_${tool.name}`));
-    }
-
-    // Create TOML files for each workflow
-    let workflowCount = 0;
-    for (const workflow of workflows) {
-      const content = await this.readAndProcess(workflow.path, {
-        module: workflow.module,
-        name: workflow.name,
-      });
-
-      const targetPath = path.join(bmadCommandsDir, workflow.module, 'workflows', `${workflow.name}.toml`);
-
-      await this.writeFile(targetPath, content);
-
-      workflowCount++;
-      console.log(chalk.green(`  ✓ Added workflow: /bmad_${workflow.module}_workflows_${workflow.name}`));
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents configured`));
-    console.log(chalk.dim(`  - ${taskCount} tasks configured`));
-    console.log(chalk.dim(`  - ${toolCount} tools configured`));
-    console.log(chalk.dim(`  - ${workflowCount} workflows configured`));
-    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, bmadCommandsDir)}`));
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskCount,
-      tools: toolCount,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Update settings.json to remove old agent references
-   */
-  async updateSettings(qwenDir) {
-    const fs = require('fs-extra');
-    const settingsPath = path.join(qwenDir, 'settings.json');
-
-    if (await fs.pathExists(settingsPath)) {
-      try {
-        const settingsContent = await fs.readFile(settingsPath, 'utf8');
-        const settings = JSON.parse(settingsContent);
-        let updated = false;
-
-        // Remove agent file references from contextFileName
-        if (settings.contextFileName && Array.isArray(settings.contextFileName)) {
-          const originalLength = settings.contextFileName.length;
-          settings.contextFileName = settings.contextFileName.filter(
-            (fileName) => !fileName.startsWith('agents/') && !fileName.startsWith('bmad-method/'),
-          );
-
-          if (settings.contextFileName.length !== originalLength) {
-            updated = true;
-          }
-        }
-
-        if (updated) {
-          await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-          console.log(chalk.green('  ✓ Updated .qwen/settings.json'));
-        }
-      } catch (error) {
-        console.warn(chalk.yellow('  ⚠ Could not update settings.json:'), error.message);
-      }
-    }
-  }
-
-  /**
-   * Clean up old configuration directories
-   */
-  async cleanupOldConfig(qwenDir) {
-    const fs = require('fs-extra');
-    const agentsDir = path.join(qwenDir, 'agents');
-    const bmadMethodDir = path.join(qwenDir, 'bmad-method');
-    const bmadDir = path.join(qwenDir, 'bmadDir');
-
-    if (await fs.pathExists(agentsDir)) {
-      await fs.remove(agentsDir);
-      console.log(chalk.green('  ✓ Removed old agents directory'));
-    }
-
-    if (await fs.pathExists(bmadMethodDir)) {
-      await fs.remove(bmadMethodDir);
-      console.log(chalk.green('  ✓ Removed old bmad-method directory'));
-    }
-
-    if (await fs.pathExists(bmadDir)) {
-      await fs.remove(bmadDir);
-      console.log(chalk.green('  ✓ Removed old BMad directory'));
-    }
-  }
-
-  /**
-   * Read and process file content
-   */
-  async readAndProcess(filePath, metadata) {
-    const fs = require('fs-extra');
-    const content = await fs.readFile(filePath, 'utf8');
-    return this.processContent(content, metadata);
-  }
-
-  /**
-   * Process agent launcher content and convert to TOML format
-   * @param {string} launcherContent - Launcher markdown content
-   * @param {Object} metadata - File metadata
-   * @returns {string} TOML formatted content
-   */
-  processAgentLauncherContent(launcherContent, metadata = {}) {
-    // Strip frontmatter from launcher content
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    const contentWithoutFrontmatter = launcherContent.replace(frontmatterRegex, '');
-
-    // Extract title for TOML description
-    const titleMatch = launcherContent.match(/description:\s*"([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : metadata.name;
-
-    // Create TOML with launcher content (without frontmatter)
-    return `description = "BMAD ${metadata.module.toUpperCase()} Agent: ${title}"
-prompt = """
-${contentWithoutFrontmatter.trim()}
-"""
-`;
-  }
-
-  /**
-   * Override processContent to add TOML metadata header for Qwen
-   * @param {string} content - File content
-   * @param {Object} metadata - File metadata
-   * @returns {string} Processed content with Qwen template
-   */
-  processContent(content, metadata = {}) {
-    // First apply base processing (includes activation injection for agents)
-    let prompt = super.processContent(content, metadata);
-
-    // Determine the type and description based on content
-    const isAgent = content.includes('<agent');
-    const isTask = content.includes('<task');
-    const isTool = content.includes('<tool');
-    const isWorkflow = content.includes('workflow:') || content.includes('name:');
-
-    let description = '';
-
-    if (isAgent) {
-      // Extract agent title if available
-      const titleMatch = content.match(/title="([^"]+)"/);
-      const title = titleMatch ? titleMatch[1] : metadata.name;
-      description = `BMAD ${metadata.module.toUpperCase()} Agent: ${title}`;
-    } else if (isTask) {
-      // Extract task name if available
-      const nameMatch = content.match(/name="([^"]+)"/);
-      const taskName = nameMatch ? nameMatch[1] : metadata.name;
-      description = `BMAD ${metadata.module.toUpperCase()} Task: ${taskName}`;
-    } else if (isTool) {
-      // Extract tool name if available
-      const nameMatch = content.match(/name="([^"]+)"/);
-      const toolName = nameMatch ? nameMatch[1] : metadata.name;
-      description = `BMAD ${metadata.module.toUpperCase()} Tool: ${toolName}`;
-    } else if (isWorkflow) {
-      // Workflow
-      description = `BMAD ${metadata.module.toUpperCase()} Workflow: ${metadata.name}`;
-    } else {
-      description = `BMAD ${metadata.module.toUpperCase()}: ${metadata.name}`;
-    }
-
-    return `description = "${description}"
-prompt = """
-${prompt}
-"""
-`;
-  }
-
-  /**
-   * Format name as title
-   */
-  formatTitle(name) {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Cleanup Qwen configuration
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const bmadCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, this.bmadDir);
-    const oldBmadMethodDir = path.join(projectDir, this.configDir, 'bmad-method');
-    const oldBMadDir = path.join(projectDir, this.configDir, 'BMad');
-
-    if (await fs.pathExists(bmadCommandsDir)) {
-      await fs.remove(bmadCommandsDir);
-      console.log(chalk.dim(`Removed BMAD configuration from Qwen Code`));
-    }
-
-    if (await fs.pathExists(oldBmadMethodDir)) {
-      await fs.remove(oldBmadMethodDir);
-      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
-    }
-
-    if (await fs.pathExists(oldBMadDir)) {
-      await fs.remove(oldBMadDir);
-      console.log(chalk.dim(`Removed old BMAD configuration from Qwen Code`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Qwen
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const qwenDir = path.join(projectDir, this.configDir);
-    const commandsDir = path.join(qwenDir, this.commandsDir);
-    const bmadCommandsDir = path.join(commandsDir, this.bmadDir);
-
-    // Create .qwen/commands/BMad directory if it doesn't exist
-    await fs.ensureDir(bmadCommandsDir);
-
-    // Create custom agent launcher in TOML format (same pattern as regular agents)
-    const launcherContent = `# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this command to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*`;
-
-    // Use Qwen's TOML conversion method
-    const tomlContent = this.processAgentLauncherContent(launcherContent, {
-      name: agentName,
-      module: 'custom',
-    });
-
-    const fileName = `custom-${agentName.toLowerCase()}.toml`;
-    const launcherPath = path.join(bmadCommandsDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, tomlContent, 'utf8');
-
-    return {
-      ide: 'qwen',
-      path: path.relative(projectDir, launcherPath),
-      command: agentName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { QwenSetup };

tools/cli/installers/lib/ide/roo.js

@@ -1,273 +0,0 @@
-const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { toDashPath, customAgentDashName } = require('./shared/path-utils');
-
-/**
- * Roo IDE setup handler
- * Creates custom commands in .roo/commands directory
- */
-class RooSetup extends BaseIdeSetup {
-  constructor() {
-    super('roo', 'Roo Code');
-    this.configDir = '.roo';
-    this.commandsDir = 'commands';
-  }
-
-  /**
-   * Setup Roo IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .roo/commands directory
-    const rooCommandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-    await this.ensureDir(rooCommandsDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    let addedCount = 0;
-    let skippedCount = 0;
-
-    for (const artifact of agentArtifacts) {
-      // Use shared toDashPath to get consistent naming: bmad_bmm_name.md
-      const commandName = toDashPath(artifact.relativePath).replace('.md', '');
-      const commandPath = path.join(rooCommandsDir, `${commandName}.md`);
-
-      // Skip if already exists
-      if (await this.pathExists(commandPath)) {
-        console.log(chalk.dim(`  Skipping ${commandName} - already exists`));
-        skippedCount++;
-        continue;
-      }
-
-      // artifact.sourcePath contains the full path to the agent file
-      if (!artifact.sourcePath) {
-        console.error(`Error: Missing sourcePath for artifact ${artifact.name} from module ${artifact.module}`);
-        console.error(`Artifact object:`, artifact);
-        throw new Error(`Missing sourcePath for agent: ${artifact.name}`);
-      }
-
-      const content = await this.readFile(artifact.sourcePath);
-
-      // Create command file that references the actual _bmad agent
-      await this.createCommandFile(
-        { module: artifact.module, name: artifact.name, path: artifact.sourcePath },
-        content,
-        commandPath,
-        projectDir,
-      );
-
-      addedCount++;
-      console.log(chalk.green(`  ✓ Added command: ${commandName}`));
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${addedCount} commands added`));
-    if (skippedCount > 0) {
-      console.log(chalk.dim(`  - ${skippedCount} commands skipped (already exist)`));
-    }
-    console.log(chalk.dim(`  - Commands directory: ${this.configDir}/${this.commandsDir}/`));
-    console.log(chalk.dim(`  Commands will be available when you open this project in Roo Code`));
-
-    return {
-      success: true,
-      commands: addedCount,
-      skipped: skippedCount,
-    };
-  }
-
-  /**
-   * Create a unified command file for agents
-   * @param {string} commandPath - Path where to write the command file
-   * @param {Object} options - Command options
-   * @param {string} options.name - Display name for the command
-   * @param {string} options.description - Description for the command
-   * @param {string} options.agentPath - Path to the agent file (relative to project root)
-   * @param {string} [options.icon] - Icon emoji (defaults to 🤖)
-   * @param {string} [options.extraContent] - Additional content to include before activation
-   */
-  async createAgentCommandFile(commandPath, options) {
-    const { name, description, agentPath, icon = '🤖', extraContent = '' } = options;
-
-    // Build command content with YAML frontmatter
-    let commandContent = `---\n`;
-    commandContent += `name: '${icon} ${name}'\n`;
-    commandContent += `description: '${description}'\n`;
-    commandContent += `---\n\n`;
-
-    commandContent += `You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.\n\n`;
-
-    // Add any extra content (e.g., warnings for custom agents)
-    if (extraContent) {
-      commandContent += `${extraContent}\n\n`;
-    }
-
-    commandContent += `<agent-activation CRITICAL="TRUE">\n`;
-    commandContent += `1. LOAD the FULL agent file from @${agentPath}\n`;
-    commandContent += `2. READ its entire contents - this contains the complete agent persona, menu, and instructions\n`;
-    commandContent += `3. Execute ALL activation steps exactly as written in the agent file\n`;
-    commandContent += `4. Follow the agent's persona and menu system precisely\n`;
-    commandContent += `5. Stay in character throughout the session\n`;
-    commandContent += `</agent-activation>\n`;
-
-    // Write command file
-    await this.writeFile(commandPath, commandContent);
-  }
-
-  /**
-   * Create a command file for an agent
-   */
-  async createCommandFile(agent, content, commandPath, projectDir) {
-    // Extract metadata from agent content
-    const titleMatch = content.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
-
-    const iconMatch = content.match(/icon="([^"]+)"/);
-    const icon = iconMatch ? iconMatch[1] : '🤖';
-
-    const whenToUseMatch = content.match(/whenToUse="([^"]+)"/);
-    const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
-
-    // Get relative path
-    const relativePath = path.relative(projectDir, agent.path).replaceAll('\\', '/');
-
-    // Use unified method
-    await this.createAgentCommandFile(commandPath, {
-      name: title,
-      description: whenToUse,
-      agentPath: relativePath,
-      icon: icon,
-    });
-  }
-
-  /**
-   * Format name as title
-   */
-  formatTitle(name) {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Cleanup Roo configuration
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const rooCommandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-
-    if (await fs.pathExists(rooCommandsDir)) {
-      const files = await fs.readdir(rooCommandsDir);
-      let removedCount = 0;
-
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.md')) {
-          await fs.remove(path.join(rooCommandsDir, file));
-          removedCount++;
-        }
-      }
-
-      if (removedCount > 0) {
-        console.log(chalk.dim(`Removed ${removedCount} BMAD commands from .roo/commands/`));
-      }
-    }
-
-    // Also clean up old .roomodes file if it exists
-    const roomodesPath = path.join(projectDir, '.roomodes');
-    if (await fs.pathExists(roomodesPath)) {
-      const content = await fs.readFile(roomodesPath, 'utf8');
-
-      // Remove BMAD modes only
-      const lines = content.split('\n');
-      const filteredLines = [];
-      let skipMode = false;
-      let removedCount = 0;
-
-      for (const line of lines) {
-        if (/^\s*- slug: bmad/.test(line)) {
-          skipMode = true;
-          removedCount++;
-        } else if (skipMode && /^\s*- slug: /.test(line)) {
-          skipMode = false;
-        }
-
-        if (!skipMode) {
-          filteredLines.push(line);
-        }
-      }
-
-      // Write back filtered content
-      await fs.writeFile(roomodesPath, filteredLines.join('\n'));
-      if (removedCount > 0) {
-        console.log(chalk.dim(`Removed ${removedCount} BMAD modes from legacy .roomodes file`));
-      }
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Roo
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata (unused, kept for compatibility)
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const rooCommandsDir = path.join(projectDir, this.configDir, this.commandsDir);
-    await this.ensureDir(rooCommandsDir);
-
-    // Use underscore format: bmad_custom_fred-commit-poet.md
-    const commandName = customAgentDashName(agentName).replace('.md', '');
-    const commandPath = path.join(rooCommandsDir, `${commandName}.md`);
-
-    // Check if command already exists
-    if (await this.pathExists(commandPath)) {
-      return {
-        ide: 'roo',
-        path: path.join(this.configDir, this.commandsDir, `${commandName}.md`),
-        command: commandName,
-        type: 'custom-agent-launcher',
-        alreadyExists: true,
-      };
-    }
-
-    // Read the custom agent file to extract metadata (same as regular agents)
-    const fullAgentPath = path.join(projectDir, agentPath);
-    const content = await this.readFile(fullAgentPath);
-
-    // Extract metadata from agent content
-    const titleMatch = content.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agentName);
-
-    const iconMatch = content.match(/icon="([^"]+)"/);
-    const icon = iconMatch ? iconMatch[1] : '🤖';
-
-    const whenToUseMatch = content.match(/whenToUse="([^"]+)"/);
-    const whenToUse = whenToUseMatch ? whenToUseMatch[1] : `Use for ${title} tasks`;
-
-    // Use unified method without extra content (clean)
-    await this.createAgentCommandFile(commandPath, {
-      name: title,
-      description: whenToUse,
-      agentPath: agentPath,
-      icon: icon,
-    });
-
-    return {
-      ide: 'roo',
-      path: path.join(this.configDir, this.commandsDir, `${commandName}.md`),
-      command: commandName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { RooSetup };

tools/cli/installers/lib/ide/rovo-dev.js

@@ -1,290 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const chalk = require('chalk');
-const { BaseIdeSetup } = require('./_base-ide');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
-
-/**
- * Rovo Dev IDE setup handler
- *
- * Installs BMAD agents as Rovo Dev subagents in .rovodev/subagents/
- * Installs workflows and tasks/tools as reference guides in .rovodev/
- * Rovo Dev automatically discovers agents and integrates with BMAD like other IDEs
- */
-class RovoDevSetup extends BaseIdeSetup {
-  constructor() {
-    super('rovo-dev', 'Atlassian Rovo Dev', false);
-    this.configDir = '.rovodev';
-    this.subagentsDir = 'subagents';
-    this.workflowsDir = 'workflows';
-    this.referencesDir = 'references';
-  }
-
-  /**
-   * Cleanup old BMAD installation before reinstalling
-   * @param {string} projectDir - Project directory
-   */
-  async cleanup(projectDir) {
-    const rovoDevDir = path.join(projectDir, this.configDir);
-
-    if (!(await fs.pathExists(rovoDevDir))) {
-      return;
-    }
-
-    // Clean BMAD agents from subagents directory
-    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
-    if (await fs.pathExists(subagentsDir)) {
-      const entries = await fs.readdir(subagentsDir);
-      const bmadFiles = entries.filter((file) => file.startsWith('bmad') && file.endsWith('.md'));
-
-      for (const file of bmadFiles) {
-        await fs.remove(path.join(subagentsDir, file));
-      }
-    }
-
-    // Clean BMAD workflows from workflows directory
-    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
-    if (await fs.pathExists(workflowsDir)) {
-      const entries = await fs.readdir(workflowsDir);
-      const bmadFiles = entries.filter((file) => file.startsWith('bmad') && file.endsWith('.md'));
-
-      for (const file of bmadFiles) {
-        await fs.remove(path.join(workflowsDir, file));
-      }
-    }
-
-    // Clean BMAD tasks/tools from references directory
-    const referencesDir = path.join(rovoDevDir, this.referencesDir);
-    if (await fs.pathExists(referencesDir)) {
-      const entries = await fs.readdir(referencesDir);
-      const bmadFiles = entries.filter((file) => file.startsWith('bmad') && file.endsWith('.md'));
-
-      for (const file of bmadFiles) {
-        await fs.remove(path.join(referencesDir, file));
-      }
-    }
-  }
-
-  /**
-   * Setup Rovo Dev configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Clean up old BMAD installation first
-    await this.cleanup(projectDir);
-
-    // Create .rovodev directory structure
-    const rovoDevDir = path.join(projectDir, this.configDir);
-    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
-    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
-    const referencesDir = path.join(rovoDevDir, this.referencesDir);
-
-    await this.ensureDir(subagentsDir);
-    await this.ensureDir(workflowsDir);
-    await this.ensureDir(referencesDir);
-
-    // Generate and install agents
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const subagentFilename = `bmad-${artifact.module}-${artifact.name}.md`;
-      const targetPath = path.join(subagentsDir, subagentFilename);
-      const subagentContent = this.convertToRovoDevSubagent(artifact.content, artifact.name, artifact.module);
-      await this.writeFile(targetPath, subagentContent);
-      agentCount++;
-    }
-
-    // Generate and install workflows
-    const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
-    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-
-    let workflowCount = 0;
-    for (const artifact of workflowArtifacts) {
-      if (artifact.type === 'workflow-command') {
-        const workflowFilename = path.basename(artifact.relativePath);
-        const targetPath = path.join(workflowsDir, workflowFilename);
-        await this.writeFile(targetPath, artifact.content);
-        workflowCount++;
-      }
-    }
-
-    // Generate and install tasks and tools
-    const taskToolGen = new TaskToolCommandGenerator();
-    const { tasks: taskCount, tools: toolCount } = await this.generateTaskToolReferences(bmadDir, referencesDir, taskToolGen);
-
-    // Summary output
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed to .rovodev/subagents/`));
-    if (workflowCount > 0) {
-      console.log(chalk.dim(`  - ${workflowCount} workflows installed to .rovodev/workflows/`));
-    }
-    if (taskCount + toolCount > 0) {
-      console.log(
-        chalk.dim(`  - ${taskCount + toolCount} tasks/tools installed to .rovodev/references/ (${taskCount} tasks, ${toolCount} tools)`),
-      );
-    }
-    console.log(chalk.yellow(`\n  Note: Agents are automatically discovered by Rovo Dev`));
-    console.log(chalk.dim(`  - Access agents by typing @ in Rovo Dev to see available options`));
-    console.log(chalk.dim(`  - Workflows and references are available in .rovodev/ directory`));
-
-    return {
-      success: true,
-      agents: agentCount,
-      workflows: workflowCount,
-      tasks: taskCount,
-      tools: toolCount,
-    };
-  }
-
-  /**
-   * Generate task and tool reference guides
-   * @param {string} bmadDir - BMAD directory
-   * @param {string} referencesDir - References directory
-   * @param {TaskToolCommandGenerator} taskToolGen - Generator instance
-   */
-  async generateTaskToolReferences(bmadDir, referencesDir, taskToolGen) {
-    const tasks = await taskToolGen.loadTaskManifest(bmadDir);
-    const tools = await taskToolGen.loadToolManifest(bmadDir);
-
-    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-
-    let taskCount = 0;
-    for (const task of standaloneTasks) {
-      const commandContent = taskToolGen.generateCommandContent(task, 'task');
-      const targetPath = path.join(referencesDir, `bmad-task-${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      taskCount++;
-    }
-
-    let toolCount = 0;
-    for (const tool of standaloneTools) {
-      const commandContent = taskToolGen.generateCommandContent(tool, 'tool');
-      const targetPath = path.join(referencesDir, `bmad-tool-${tool.module}-${tool.name}.md`);
-      await this.writeFile(targetPath, commandContent);
-      toolCount++;
-    }
-
-    return { tasks: taskCount, tools: toolCount };
-  }
-
-  /**
-   * Convert BMAD agent launcher to Rovo Dev subagent format
-   *
-   * Rovo Dev subagents use Markdown files with YAML frontmatter containing:
-   * - name: Unique identifier for the subagent
-   * - description: One-line description of the subagent's purpose
-   * - tools: Array of tools the subagent can use (optional)
-   * - model: Specific model for this subagent (optional)
-   * - load_memory: Whether to load memory files (optional, defaults to true)
-   *
-   * @param {string} launcherContent - Original agent launcher content
-   * @param {string} agentName - Name of the agent
-   * @param {string} moduleName - Name of the module
-   * @returns {string} Rovo Dev subagent-formatted content
-   */
-  convertToRovoDevSubagent(launcherContent, agentName, moduleName) {
-    // Extract metadata from the launcher XML
-    const titleMatch = launcherContent.match(/title="([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(agentName);
-
-    const descriptionMatch = launcherContent.match(/description="([^"]+)"/);
-    const description = descriptionMatch ? descriptionMatch[1] : `BMAD agent: ${title}`;
-
-    const roleDefinitionMatch = launcherContent.match(/roleDefinition="([^"]+)"/);
-    const roleDefinition = roleDefinitionMatch ? roleDefinitionMatch[1] : `You are a specialized agent for ${title.toLowerCase()} tasks.`;
-
-    // Extract the main system prompt from the launcher (content after closing tags)
-    let systemPrompt = roleDefinition;
-
-    // Try to extract additional instructions from the launcher content
-    const instructionsMatch = launcherContent.match(/<instructions>([\s\S]*?)<\/instructions>/);
-    if (instructionsMatch) {
-      systemPrompt += '\n\n' + instructionsMatch[1].trim();
-    }
-
-    // Build YAML frontmatter for Rovo Dev subagent
-    const frontmatter = {
-      name: `bmad-${moduleName}-${agentName}`,
-      description: description,
-      // Note: tools and model can be added by users in their .rovodev/subagents/*.md files
-      // We don't enforce specific tools since BMAD agents are flexible
-    };
-
-    // Create YAML frontmatter string with proper quoting for special characters
-    let yamlContent = '---\n';
-    yamlContent += `name: ${frontmatter.name}\n`;
-    // Quote description to handle colons and other special characters in YAML
-    yamlContent += `description: "${frontmatter.description.replaceAll('"', String.raw`\"`)}"\n`;
-    yamlContent += '---\n';
-
-    // Combine frontmatter with system prompt
-    const subagentContent = yamlContent + systemPrompt;
-
-    return subagentContent;
-  }
-
-  /**
-   * Detect whether Rovo Dev is already configured in the project
-   * @param {string} projectDir - Project directory
-   * @returns {boolean}
-   */
-  async detect(projectDir) {
-    const rovoDevDir = path.join(projectDir, this.configDir);
-
-    if (!(await fs.pathExists(rovoDevDir))) {
-      return false;
-    }
-
-    // Check for BMAD agents in subagents directory
-    const subagentsDir = path.join(rovoDevDir, this.subagentsDir);
-    if (await fs.pathExists(subagentsDir)) {
-      try {
-        const entries = await fs.readdir(subagentsDir);
-        if (entries.some((entry) => entry.startsWith('bmad') && entry.endsWith('.md'))) {
-          return true;
-        }
-      } catch {
-        // Continue checking other directories
-      }
-    }
-
-    // Check for BMAD workflows in workflows directory
-    const workflowsDir = path.join(rovoDevDir, this.workflowsDir);
-    if (await fs.pathExists(workflowsDir)) {
-      try {
-        const entries = await fs.readdir(workflowsDir);
-        if (entries.some((entry) => entry.startsWith('bmad') && entry.endsWith('.md'))) {
-          return true;
-        }
-      } catch {
-        // Continue checking other directories
-      }
-    }
-
-    // Check for BMAD tasks/tools in references directory
-    const referencesDir = path.join(rovoDevDir, this.referencesDir);
-    if (await fs.pathExists(referencesDir)) {
-      try {
-        const entries = await fs.readdir(referencesDir);
-        if (entries.some((entry) => entry.startsWith('bmad') && entry.endsWith('.md'))) {
-          return true;
-        }
-      } catch {
-        // Continue
-      }
-    }
-
-    return false;
-  }
-}
-
-module.exports = { RovoDevSetup };

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

@@ -1,6 +1,5 @@
 const path = require('node:path');
 const fs = require('fs-extra');
-const chalk = require('chalk');
 const { toColonPath, toDashPath, customAgentColonName, customAgentDashName } = require('./path-utils');
 
 /**
@@ -33,8 +32,10 @@ class AgentCommandGenerator {
       const agentPathInModule = agent.relativePath || `${agent.name}.md`;
       artifacts.push({
         type: 'agent-launcher',
-        module: agent.module,
         name: agent.name,
+        displayName: agent.displayName || agent.name,
+        description: agent.description,
+        module: agent.module,
         relativePath: path.join(agent.module, 'agents', agentPathInModule),
         content: launcherContent,
         sourcePath: agent.path,
@@ -65,9 +66,8 @@ class AgentCommandGenerator {
       .replaceAll('{{name}}', agent.name)
       .replaceAll('{{module}}', agent.module)
       .replaceAll('{{path}}', agentPathInModule)
-      .replaceAll('{{description}}', agent.description || `${agent.name} agent`)
-      .replaceAll('_bmad', this.bmadFolderName)
-      .replaceAll('_bmad', '_bmad');
+      .replaceAll('{{relativePath}}', path.join(agent.module, 'agents', agentPathInModule))
+      .replaceAll('{{description}}', agent.description || `${agent.name} agent`);
   }
 
   /**
@@ -109,7 +109,7 @@ class AgentCommandGenerator {
         // Convert relativePath to underscore format: bmm/agents/pm.md → bmad_bmm_pm.md
         const flatName = toColonPath(artifact.relativePath);
         const launcherPath = path.join(baseCommandsDir, flatName);
-        await fs.ensureDir(path.dirname(launcherPath));
+        await fs.ensureDir(baseCommandsDir);
         await fs.writeFile(launcherPath, artifact.content);
         writtenCount++;
       }
@@ -119,8 +119,8 @@ class AgentCommandGenerator {
   }
 
   /**
-   * Write agent launcher artifacts using underscore format (Windows-compatible)
-   * Creates flat files like: bmad_bmm_pm.md
+   * Write agent launcher artifacts using dash format
+   * Creates flat files like: bmad-bmm-agent-pm.md
    *
    * @param {string} baseCommandsDir - Base commands directory for the IDE
    * @param {Array} artifacts - Agent launcher artifacts
@@ -131,10 +131,10 @@ class AgentCommandGenerator {
 
     for (const artifact of artifacts) {
       if (artifact.type === 'agent-launcher') {
-        // Convert relativePath to underscore format: bmm/agents/pm.md → bmad_bmm_pm.md
+        // Convert relativePath to dash format: bmm/agents/pm.md → bmad-bmm-agent-pm.md
         const flatName = toDashPath(artifact.relativePath);
         const launcherPath = path.join(baseCommandsDir, flatName);
-        await fs.ensureDir(path.dirname(launcherPath));
+        await fs.ensureDir(baseCommandsDir);
         await fs.writeFile(launcherPath, artifact.content);
         writtenCount++;
       }

tools/cli/installers/lib/ide/shared/bmad-artifacts.js

@@ -44,9 +44,26 @@ async function getAgentsFromBmad(bmadDir, selectedModules = []) {
 
         if (content.includes('localskip="true"')) continue;
 
+        // Extract description from YAML frontmatter if present
+        let description = null;
+        let agentName = file.replace('.md', '');
+        const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+        if (frontmatterMatch) {
+          const descMatch = frontmatterMatch[1].match(/description:\s*"([^"]+)"/);
+          if (descMatch) {
+            description = descMatch[1];
+          }
+          const nameMatch = frontmatterMatch[1].match(/name:\s*"([^"]+)"/);
+          if (nameMatch) {
+            agentName = nameMatch[1];
+          }
+        }
+
         agents.push({
           path: filePath,
-          name: file.replace('.md', ''),
+          name: agentName,
+          displayName: agentName,
+          description: description,
           module: 'standalone', // Mark as standalone agent
         });
       }
@@ -114,9 +131,26 @@ async function getAgentsFromDir(dirPath, moduleName, relativePath = '') {
         continue;
       }
 
+      // Extract description from YAML frontmatter if present
+      let description = null;
+      const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+      if (frontmatterMatch) {
+        const descMatch = frontmatterMatch[1].match(/description:\s*"([^"]+)"/);
+        if (descMatch) {
+          description = descMatch[1];
+        }
+        // Also extract name from frontmatter if available
+        const nameMatch = frontmatterMatch[1].match(/name:\s*"([^"]+)"/);
+        if (nameMatch) {
+          entry.name = `${nameMatch[1]}.md`;
+        }
+      }
+
       agents.push({
         path: fullPath,
         name: entry.name.replace('.md', ''),
+        displayName: entry.name.replace('.md', ''),
+        description: description,
         module: moduleName,
         relativePath: newRelativePath, // Keep the .md extension for the full path
       });

tools/cli/installers/lib/ide/shared/path-utils.js

@@ -3,12 +3,24 @@
  *
  * Provides utilities to convert hierarchical paths to flat naming conventions.
  * - Underscore format (bmad_module_name.md) - Windows-compatible universal format
+ * - Suffix-based format (bmad-module-name.agent.md) - New universal standard
  */
 
+// Default file extension for backward compatibility
+const DEFAULT_FILE_EXTENSION = '.md';
+
 // Type segments - agents are included in naming, others are filtered out
 const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
 const AGENT_SEGMENT = 'agents';
 
+/**
+ * Artifact type to suffix mapping
+ * Only agents get the .agent suffix; workflows/tasks/tools use standard .md extension
+ */
+const ARTIFACT_SUFFIXES = {
+  agent: '.agent',
+};
+
 /**
  * Convert hierarchical path to flat underscore-separated name
  * Converts: 'bmm', 'agents', 'pm' → 'bmad_bmm_agent_pm.md'
@@ -18,36 +30,48 @@ const AGENT_SEGMENT = 'agents';
  * @param {string} module - Module name (e.g., 'bmm', 'core')
  * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools')
  * @param {string} name - Artifact name (e.g., 'pm', 'brainstorming')
+ * @param {string} [fileExtension=DEFAULT_FILE_EXTENSION] - File extension including dot (e.g., '.md', '.toml')
  * @returns {string} Flat filename like 'bmad_bmm_agent_pm.md' or 'bmad_bmm_correct-course.md'
  */
-function toUnderscoreName(module, type, name) {
+function toUnderscoreName(module, type, name, fileExtension = DEFAULT_FILE_EXTENSION) {
   const isAgent = type === AGENT_SEGMENT;
   // For core module, skip the module prefix: use 'bmad_name.md' instead of 'bmad_core_name.md'
   if (module === 'core') {
-    return isAgent ? `bmad_agent_${name}.md` : `bmad_${name}.md`;
+    return isAgent ? `bmad_agent_${name}${fileExtension}` : `bmad_${name}${fileExtension}`;
   }
-  return isAgent ? `bmad_${module}_agent_${name}.md` : `bmad_${module}_${name}.md`;
+  return isAgent ? `bmad_${module}_agent_${name}${fileExtension}` : `bmad_${module}_${name}${fileExtension}`;
 }
 
 /**
  * Convert relative path to flat underscore-separated name
  * Converts: 'bmm/agents/pm.md' → 'bmad_bmm_agent_pm.md'
  * Converts: 'bmm/workflows/correct-course.md' → 'bmad_bmm_correct-course.md'
+ * Converts: 'bmad_bmb/agents/agent-builder.md' → 'bmad_bmb_agent_agent-builder.md' (bmad prefix already in module)
  * Converts: 'core/agents/brainstorming.md' → 'bmad_agent_brainstorming.md' (core items skip module prefix)
  *
  * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @param {string} [fileExtension=DEFAULT_FILE_EXTENSION] - File extension including dot (e.g., '.md', '.toml')
  * @returns {string} Flat filename like 'bmad_bmm_agent_pm.md' or 'bmad_brainstorming.md'
  */
-function toUnderscorePath(relativePath) {
-  const withoutExt = relativePath.replace('.md', '');
+function toUnderscorePath(relativePath, fileExtension = DEFAULT_FILE_EXTENSION) {
+  // Extract extension from relativePath to properly remove it
+  const extMatch = relativePath.match(/\.[^.]+$/);
+  const originalExt = extMatch ? extMatch[0] : '';
+  const withoutExt = relativePath.replace(originalExt, '');
   const parts = withoutExt.split(/[/\\]/);
 
   const module = parts[0];
   const type = parts[1];
   const name = parts.slice(2).join('_');
 
-  // Use toUnderscoreName for consistency
-  return toUnderscoreName(module, type, name);
+  const isAgent = type === AGENT_SEGMENT;
+  // For core module, skip the module prefix: use 'bmad_name.md' instead of 'bmad_core_name.md'
+  if (module === 'core') {
+    return isAgent ? `bmad_agent_${name}${fileExtension}` : `bmad_${name}${fileExtension}`;
+  }
+  // If module already starts with 'bmad_', don't add another prefix
+  const prefix = module.startsWith('bmad_') ? '' : 'bmad_';
+  return isAgent ? `${prefix}${module}_agent_${name}${fileExtension}` : `${prefix}${module}_${name}${fileExtension}`;
 }
 
 /**
@@ -55,10 +79,11 @@ function toUnderscorePath(relativePath) {
  * Creates: 'bmad_custom_fred-commit-poet.md'
  *
  * @param {string} agentName - Custom agent name
+ * @param {string} [fileExtension=DEFAULT_FILE_EXTENSION] - File extension including dot (e.g., '.md', '.toml')
  * @returns {string} Flat filename like 'bmad_custom_fred-commit-poet.md'
  */
-function customAgentUnderscoreName(agentName) {
-  return `bmad_custom_${agentName}.md`;
+function customAgentUnderscoreName(agentName, fileExtension = DEFAULT_FILE_EXTENSION) {
+  return `bmad_custom_${agentName}${fileExtension}`;
 }
 
 /**
@@ -134,9 +159,9 @@ function parseUnderscoreName(filename) {
 }
 
 // Backward compatibility aliases (deprecated)
+// Note: These now use toDashPath and customAgentDashName which convert underscores to dashes
 const toColonName = toUnderscoreName;
-const toColonPath = toUnderscorePath;
-const toDashPath = toUnderscorePath;
+const toDashName = toUnderscoreName;
 const customAgentColonName = customAgentUnderscoreName;
 const customAgentDashName = customAgentUnderscoreName;
 const isColonFormat = isUnderscoreFormat;
@@ -144,7 +169,125 @@ const isDashFormat = isUnderscoreFormat;
 const parseColonName = parseUnderscoreName;
 const parseDashName = parseUnderscoreName;
 
+/**
+ * Convert relative path to flat colon-separated name (for backward compatibility)
+ * This is actually the same as underscore format now (underscores in filenames)
+ * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @param {string} [fileExtension=DEFAULT_FILE_EXTENSION] - File extension including dot
+ * @returns {string} Flat filename like 'bmad_bmm_agent_pm.md'
+ */
+function toColonPath(relativePath, fileExtension = DEFAULT_FILE_EXTENSION) {
+  return toUnderscorePath(relativePath, fileExtension);
+}
+
+/**
+ * Convert relative path to flat dash-separated name
+ * Converts: 'bmm/agents/pm.md' → 'bmad-bmm-agent-pm.md'
+ * Converts: 'bmm/workflows/correct-course' → 'bmad-bmm-correct-course.md'
+ * Converts: 'bmad-bmb/agents/agent-builder.md' → 'bmad-bmb-agent-agent-builder.md' (bmad prefix already in module)
+ * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @param {string} [fileExtension=DEFAULT_FILE_EXTENSION] - File extension including dot
+ * @returns {string} Flat filename like 'bmad-bmm-agent-pm.md'
+ */
+function toDashPath(relativePath, fileExtension = DEFAULT_FILE_EXTENSION) {
+  // Extract extension from relativePath to properly remove it
+  const extMatch = relativePath.match(/\.[^.]+$/);
+  const originalExt = extMatch ? extMatch[0] : '';
+  const withoutExt = relativePath.replace(originalExt, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  const name = parts.slice(2).join('-');
+
+  // Use dash naming style
+  const isAgent = type === AGENT_SEGMENT;
+  // For core module, skip the module prefix
+  if (module === 'core') {
+    return isAgent ? `bmad-agent-${name}${fileExtension}` : `bmad-${name}${fileExtension}`;
+  }
+  // If module already starts with 'bmad-', don't add another prefix
+  const prefix = module.startsWith('bmad-') ? '' : 'bmad-';
+  return isAgent ? `${prefix}${module}-agent-${name}${fileExtension}` : `${prefix}${module}-${name}${fileExtension}`;
+}
+
+/**
+ * Convert relative path to suffix-based name (NEW UNIVERSAL STANDARD)
+ * Only applies .agent suffix to agents; workflows/tasks/tools get standard .md extension.
+ * Converts: 'cis/agents/storymaster.md' → 'bmad-cis-storymaster.agent.md'
+ * Converts: 'bmm/workflows/plan-project.md' → 'bmad-bmm-plan-project.md'
+ * Converts: 'bmm/tasks/create-story.md' → 'bmad-bmm-create-story.md'
+ * Converts: 'bmm/tools/file-ops.md' → 'bmad-bmm-file-ops.md'
+ * Converts: 'core/agents/brainstorming.md' → 'bmad-brainstorming.agent.md' (core items skip module prefix)
+ *
+ * @param {string} relativePath - Path like 'cis/agents/storymaster.md'
+ * @param {string} artifactType - Type of artifact: 'agent', 'workflow', 'task', 'tool'
+ * @param {string} [fileExtension='.md'] - File extension including dot (e.g., '.md', '.toml')
+ * @returns {string} Suffix-based filename like 'bmad-cis-storymaster.agent.md'
+ */
+function toSuffixBasedName(relativePath, artifactType, fileExtension = DEFAULT_FILE_EXTENSION) {
+  const extMatch = relativePath.match(/\.[^.]+$/);
+  const originalExt = extMatch ? extMatch[0] : '';
+  const withoutExt = relativePath.replace(originalExt, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1]; // agents, workflows, tasks, tools
+  const name = parts.slice(2).join('-');
+
+  // Only add .agent suffix for agents; workflows/tasks/tools use standard extension
+  const suffix = artifactType === 'agent' ? ARTIFACT_SUFFIXES.agent : '';
+
+  // For core module, skip the module prefix (use 'bmad-name.suffix.md')
+  if (module === 'core') {
+    return `bmad-${name}${suffix}.${fileExtension.replace('.', '')}`;
+  }
+
+  // If module already starts with 'bmad-', don't add another prefix
+  const prefix = module.startsWith('bmad-') ? '' : 'bmad-';
+  return `${prefix}${module}-${name}${suffix}.${fileExtension.replace('.', '')}`;
+}
+
+/**
+ * Get suffix for artifact type
+ * @param {string} artifactType - Type of artifact: 'agent', 'workflow', 'task', 'tool'
+ * @returns {string} Suffix like '.agent', '.workflow', etc.
+ */
+function getArtifactSuffix(artifactType) {
+  return ARTIFACT_SUFFIXES[artifactType] || '';
+}
+
+/**
+ * Parse artifact type from suffix-based filename
+ * Parses: 'bmad-cis-storymaster.agent.md' → 'agent'
+ * Returns null for workflows/tasks/tools (no suffix)
+ *
+ * @param {string} filename - Suffix-based filename
+ * @returns {string|null} Artifact type or null if not found
+ */
+function parseArtifactTypeFromFilename(filename) {
+  for (const [type, suffix] of Object.entries(ARTIFACT_SUFFIXES)) {
+    if (filename.includes(`${suffix}.`)) {
+      return type;
+    }
+  }
+  return null;
+}
+
+/**
+ * Create custom agent suffix-based name
+ * Creates: 'bmad-custom-fred-commit-poet.agent.md'
+ *
+ * @param {string} agentName - Custom agent name
+ * @param {string} [fileExtension='.md'] - File extension including dot
+ * @returns {string} Suffix-based filename like 'bmad-custom-fred-commit-poet.agent.md'
+ */
+function customAgentSuffixName(agentName, fileExtension = DEFAULT_FILE_EXTENSION) {
+  return `bmad-custom-${agentName}.agent.${fileExtension.replace('.', '')}`;
+}
+
 module.exports = {
+  DEFAULT_FILE_EXTENSION,
   toUnderscoreName,
   toUnderscorePath,
   customAgentUnderscoreName,
@@ -153,6 +296,7 @@ module.exports = {
   // Backward compatibility aliases
   toColonName,
   toColonPath,
+  toDashName,
   toDashPath,
   customAgentColonName,
   customAgentDashName,
@@ -162,4 +306,10 @@ module.exports = {
   parseDashName,
   TYPE_SEGMENTS,
   AGENT_SEGMENT,
+  // New suffix-based naming functions (UNIVERSAL STANDARD)
+  ARTIFACT_SUFFIXES,
+  toSuffixBasedName,
+  getArtifactSuffix,
+  parseArtifactTypeFromFilename,
+  customAgentSuffixName,
 };

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

@@ -2,85 +2,17 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const csv = require('csv-parse/sync');
 const chalk = require('chalk');
-const { toColonName, toColonPath, toDashPath } = require('./path-utils');
+const { toColonName, toColonPath, toDashPath, toSuffixBasedName } = require('./path-utils');
 
 /**
  * Generates command files for standalone tasks and tools
  */
 class TaskToolCommandGenerator {
   /**
-   * Generate task and tool commands from manifest CSVs
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {string} baseCommandsDir - Optional base commands directory (defaults to .claude/commands/bmad)
+   * REMOVED: Old generateTaskToolCommands method that created nested structure.
+   * This was causing bugs where files were written to wrong directories.
+   * Use generateColonTaskToolCommands() or generateDashTaskToolCommands() instead.
    */
-  async generateTaskToolCommands(projectDir, bmadDir, baseCommandsDir = null) {
-    const tasks = await this.loadTaskManifest(bmadDir);
-    const tools = await this.loadToolManifest(bmadDir);
-
-    // Filter to only standalone items
-    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
-
-    // Base commands directory - use provided or default to Claude Code structure
-    const commandsDir = baseCommandsDir || path.join(projectDir, '.claude', 'commands', 'bmad');
-
-    let generatedCount = 0;
-
-    // Generate command files for tasks
-    for (const task of standaloneTasks) {
-      const moduleTasksDir = path.join(commandsDir, task.module, 'tasks');
-      await fs.ensureDir(moduleTasksDir);
-
-      const commandContent = this.generateCommandContent(task, 'task');
-      const commandPath = path.join(moduleTasksDir, `${task.name}.md`);
-
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    // Generate command files for tools
-    for (const tool of standaloneTools) {
-      const moduleToolsDir = path.join(commandsDir, tool.module, 'tools');
-      await fs.ensureDir(moduleToolsDir);
-
-      const commandContent = this.generateCommandContent(tool, 'tool');
-      const commandPath = path.join(moduleToolsDir, `${tool.name}.md`);
-
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    return {
-      generated: generatedCount,
-      tasks: standaloneTasks.length,
-      tools: standaloneTools.length,
-    };
-  }
-
-  /**
-   * Generate command content for a task or tool
-   */
-  generateCommandContent(item, type) {
-    const description = item.description || `Execute ${item.displayName || item.name}`;
-
-    // Convert path to use {project-root} placeholder
-    let itemPath = item.path;
-    if (itemPath.startsWith('bmad/')) {
-      itemPath = `{project-root}/${itemPath}`;
-    }
-
-    return `---
-description: '${description.replaceAll("'", "''")}'
----
-
-# ${item.displayName || item.name}
-
-LOAD and execute the ${type} at: ${itemPath}
-
-Follow all instructions in the ${type} file exactly as written.
-`;
-  }
 
   /**
    * Load task manifest CSV
@@ -93,10 +25,16 @@ Follow all instructions in the ${type} file exactly as written.
     }
 
     const csvContent = await fs.readFile(manifestPath, 'utf8');
-    return csv.parse(csvContent, {
+    const tasks = csv.parse(csvContent, {
       columns: true,
       skip_empty_lines: true,
     });
+
+    // Filter out README files
+    return tasks.filter((task) => {
+      const nameLower = task.name.toLowerCase();
+      return !nameLower.includes('readme') && task.name !== 'README';
+    });
   }
 
   /**
@@ -110,10 +48,16 @@ Follow all instructions in the ${type} file exactly as written.
     }
 
     const csvContent = await fs.readFile(manifestPath, 'utf8');
-    return csv.parse(csvContent, {
+    const tools = csv.parse(csvContent, {
       columns: true,
       skip_empty_lines: true,
     });
+
+    // Filter out README files
+    return tools.filter((tool) => {
+      const nameLower = tool.name.toLowerCase();
+      return !nameLower.includes('readme') && tool.name !== 'README';
+    });
   }
 
   /**
@@ -123,9 +67,10 @@ Follow all instructions in the ${type} file exactly as written.
    * @param {string} projectDir - Project directory
    * @param {string} bmadDir - BMAD installation directory
    * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {string} [fileExtension='.md'] - File extension including dot (e.g., '.md', '.toml')
    * @returns {Object} Generation results
    */
-  async generateColonTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+  async generateColonTaskToolCommands(projectDir, bmadDir, baseCommandsDir, fileExtension = '.md') {
     const tasks = await this.loadTaskManifest(bmadDir);
     const tools = await this.loadToolManifest(bmadDir);
 
@@ -133,14 +78,20 @@ Follow all instructions in the ${type} file exactly as written.
     const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
     const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
 
+    // Determine format based on file extension
+    const format = fileExtension === '.toml' ? 'toml' : 'yaml';
     let generatedCount = 0;
 
+    // DEBUG: Log parameters
+    console.log(`[DEBUG generateColonTaskToolCommands] baseCommandsDir: ${baseCommandsDir}, format=${format}`);
+
     // Generate command files for tasks
     for (const task of standaloneTasks) {
-      const commandContent = this.generateCommandContent(task, 'task');
-      // Use underscore format: bmad_bmm_name.md
-      const flatName = toColonName(task.module, 'tasks', task.name);
+      const commandContent = this.generateCommandContent(task, 'task', format);
+      // Use underscore format: bmad_bmm_name.<ext>
+      const flatName = toColonName(task.module, 'tasks', task.name, fileExtension);
       const commandPath = path.join(baseCommandsDir, flatName);
+      console.log(`[DEBUG generateColonTaskToolCommands] Writing task ${task.name} to: ${commandPath}`);
       await fs.ensureDir(path.dirname(commandPath));
       await fs.writeFile(commandPath, commandContent);
       generatedCount++;
@@ -148,9 +99,9 @@ Follow all instructions in the ${type} file exactly as written.
 
     // Generate command files for tools
     for (const tool of standaloneTools) {
-      const commandContent = this.generateCommandContent(tool, 'tool');
-      // Use underscore format: bmad_bmm_name.md
-      const flatName = toColonName(tool.module, 'tools', tool.name);
+      const commandContent = this.generateCommandContent(tool, 'tool', format);
+      // Use underscore format: bmad_bmm_name.<ext>
+      const flatName = toColonName(tool.module, 'tools', tool.name, fileExtension);
       const commandPath = path.join(baseCommandsDir, flatName);
       await fs.ensureDir(path.dirname(commandPath));
       await fs.writeFile(commandPath, commandContent);
@@ -165,15 +116,16 @@ Follow all instructions in the ${type} file exactly as written.
   }
 
   /**
-   * Generate task and tool commands using underscore format (Windows-compatible)
-   * Creates flat files like: bmad_bmm_bmad-help.md
+   * Generate task and tool commands using dash format
+   * Creates flat files like: bmad-bmm-bmad-help.md
    *
    * @param {string} projectDir - Project directory
    * @param {string} bmadDir - BMAD installation directory
    * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {string} [fileExtension='.md'] - File extension including dot (e.g., '.md', '.toml')
    * @returns {Object} Generation results
    */
-  async generateDashTaskToolCommands(projectDir, bmadDir, baseCommandsDir) {
+  async generateDashTaskToolCommands(projectDir, bmadDir, baseCommandsDir, fileExtension = '.md') {
     const tasks = await this.loadTaskManifest(bmadDir);
     const tools = await this.loadToolManifest(bmadDir);
 
@@ -181,13 +133,15 @@ Follow all instructions in the ${type} file exactly as written.
     const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
     const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
 
+    // Determine format based on file extension
+    const format = fileExtension === '.toml' ? 'toml' : 'yaml';
     let generatedCount = 0;
 
     // Generate command files for tasks
     for (const task of standaloneTasks) {
-      const commandContent = this.generateCommandContent(task, 'task');
-      // Use underscore format: bmad_bmm_name.md
-      const flatName = toDashPath(`${task.module}/tasks/${task.name}.md`);
+      const commandContent = this.generateCommandContent(task, 'task', format);
+      // Use dash format: bmad-bmm-task-name.<ext>
+      const flatName = toDashPath(`${task.module}/tasks/${task.name}.md`, fileExtension);
       const commandPath = path.join(baseCommandsDir, flatName);
       await fs.ensureDir(path.dirname(commandPath));
       await fs.writeFile(commandPath, commandContent);
@@ -196,9 +150,9 @@ Follow all instructions in the ${type} file exactly as written.
 
     // Generate command files for tools
     for (const tool of standaloneTools) {
-      const commandContent = this.generateCommandContent(tool, 'tool');
-      // Use underscore format: bmad_bmm_name.md
-      const flatName = toDashPath(`${tool.module}/tools/${tool.name}.md`);
+      const commandContent = this.generateCommandContent(tool, 'tool', format);
+      // Use dash format: bmad-bmm-tool-name.<ext>
+      const flatName = toDashPath(`${tool.module}/tools/${tool.name}.md`, fileExtension);
       const commandPath = path.join(baseCommandsDir, flatName);
       await fs.ensureDir(path.dirname(commandPath));
       await fs.writeFile(commandPath, commandContent);
@@ -263,6 +217,163 @@ Follow all instructions in the ${type} file exactly as written.
 
     return writtenCount;
   }
+
+  /**
+   * Generate task and tool commands using suffix-based format (NEW UNIVERSAL STANDARD)
+   * Creates flat files like: bmad-bmm-create-story.task.md
+   *
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} baseCommandsDir - Base commands directory for the IDE
+   * @param {string} [fileExtension='.md'] - File extension including dot (e.g., '.md', '.toml')
+   * @param {string} [templateContent] - Frontmatter template content (from platform-codes.yaml)
+   * @param {string} [frontmatterTemplate] - Frontmatter template filename
+   * @param {boolean} [skipExisting=false] - Skip if file already exists
+   * @returns {Object} Generation results
+   */
+  async generateSuffixBasedTaskToolCommands(
+    projectDir,
+    bmadDir,
+    baseCommandsDir,
+    fileExtension = '.md',
+    templateContent = null,
+    frontmatterTemplate = 'common-yaml.md',
+    skipExisting = false,
+  ) {
+    const tasks = await this.loadTaskManifest(bmadDir);
+    const tools = await this.loadToolManifest(bmadDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    let generatedCount = 0;
+    let skippedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of standaloneTasks) {
+      const commandContent = this.generateCommandContent(task, 'task', templateContent, frontmatterTemplate);
+      // Use suffix-based format: bmad-bmm-create-story.task.md
+      const relativePath = `${task.module}/tasks/${task.name}.md`;
+      const suffixName = toSuffixBasedName(relativePath, 'task', fileExtension);
+      const commandPath = path.join(baseCommandsDir, suffixName);
+
+      // Skip if already exists
+      if (skipExisting && (await fs.pathExists(commandPath))) {
+        skippedCount++;
+        continue;
+      }
+
+      await fs.ensureDir(baseCommandsDir);
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of standaloneTools) {
+      const commandContent = this.generateCommandContent(tool, 'tool', templateContent, frontmatterTemplate);
+      // Use suffix-based format: bmad-bmm-file-ops.tool.md
+      const relativePath = `${tool.module}/tools/${tool.name}.md`;
+      const suffixName = toSuffixBasedName(relativePath, 'tool', fileExtension);
+      const commandPath = path.join(baseCommandsDir, suffixName);
+
+      // Skip if already exists
+      if (skipExisting && (await fs.pathExists(commandPath))) {
+        skippedCount++;
+        continue;
+      }
+
+      await fs.ensureDir(baseCommandsDir);
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    if (skippedCount > 0) {
+      console.log(chalk.dim(`  Skipped ${skippedCount} existing task/tool files`));
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  /**
+   * Generate command content for a task or tool
+   * @param {Object} item - Task or tool item from manifest
+   * @param {string} type - 'task' or 'tool'
+   * @param {string|Object|null} [templateOrFormat] - Template content or format string ('yaml'/'toml') for backward compat
+   * @param {string} [frontmatterTemplate] - Template filename (for format detection)
+   */
+  generateCommandContent(item, type, templateOrFormat = null, frontmatterTemplate = null) {
+    const description = item.description || `Execute ${item.displayName || item.name}`;
+
+    // Convert path to use {project-root} placeholder
+    let itemPath = item.path;
+    if (itemPath.startsWith('bmad/')) {
+      itemPath = `{project-root}/${itemPath}`;
+    }
+
+    const content = `# ${item.displayName || item.name}
+
+LOAD and execute the ${type} at: ${itemPath}
+
+Follow all instructions in the ${type} file exactly as written.
+`;
+
+    // Handle old calling convention: (item, type, format) where format is 'yaml' or 'toml'
+    if (typeof templateOrFormat === 'string' && (templateOrFormat === 'yaml' || templateOrFormat === 'toml')) {
+      if (templateOrFormat === 'toml') {
+        // TOML format
+        const escapedContent = content.replaceAll('"""', String.raw`\"\"\"`);
+        return `description = "${description}"
+prompt = """
+${escapedContent}
+"""
+`;
+      }
+      // Default YAML format
+      return `---
+description: '${description.replaceAll("'", "''")}'
+---
+
+${content}`;
+    }
+
+    // New calling convention with template content
+    const templateContent = templateOrFormat;
+    if (!templateContent || frontmatterTemplate === 'none' || (templateContent === null && frontmatterTemplate === null)) {
+      // Default YAML
+      return `---
+description: '${description.replaceAll("'", "''")}'
+---
+
+${content}`;
+    }
+
+    // Apply template variables
+    const variables = {
+      name: item.name,
+      displayName: item.displayName || item.name,
+      description,
+      content,
+      icon: '🤖',
+    };
+
+    let result = templateContent;
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replaceAll(`{{${key}}}`, value);
+    }
+
+    // Handle TOML templates specially
+    if (frontmatterTemplate && frontmatterTemplate.includes('toml')) {
+      const escapedContent = content.replaceAll('"""', String.raw`\"\"\"`);
+      result = result.replace(/prompt = """/, `prompt = """\n${escapedContent}`);
+    }
+
+    return result;
+  }
 }
 
 module.exports = { TaskToolCommandGenerator };

tools/cli/installers/lib/ide/shared/unified-installer.js

@@ -0,0 +1,375 @@
+/**
+ * Unified BMAD Installer for all IDEs
+ *
+ * ALL IDE configuration comes from platform-codes.yaml
+ * NO IDE-specific code in this file - just loads and applies templates
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./agent-command-generator');
+const { WorkflowCommandGenerator } = require('./workflow-command-generator');
+const { TaskToolCommandGenerator } = require('./task-tool-command-generator');
+const { toColonPath, toDashPath, toSuffixBasedName, getArtifactSuffix } = require('./path-utils');
+
+/**
+ * Naming styles
+ * @deprecated Use 'suffix-based' for all new installations
+ */
+const NamingStyle = {
+  FLAT_COLON: 'flat-colon',
+  FLAT_DASH: 'flat-dash',
+  NESTED: 'nested',
+  SUFFIX_BASED: 'suffix-based',
+};
+
+/**
+ * Unified installer configuration
+ * @typedef {Object} UnifiedInstallConfig
+ * @property {string} targetDir - Full path to target directory
+ * @property {NamingStyle} namingStyle - How to name files
+ * @property {string} [frontmatterTemplate] - Frontmatter template filename (from platform-codes.yaml)
+ * @property {string} [fileExtension='.md'] - File extension including dot
+ * @property {boolean} includeNestedStructure - For NESTED style, create subdirectories
+ * @property {Function} [customTemplateFn] - Optional custom template function
+ */
+
+/**
+ * Unified BMAD Installer
+ *
+ * Driven entirely by platform-codes.yaml configuration
+ * Frontmatter templates are loaded from templates/frontmatter/ directory
+ */
+class UnifiedInstaller {
+  constructor(bmadFolderName = 'bmad') {
+    this.bmadFolderName = bmadFolderName;
+    this.templateDir = path.join(__dirname, '../templates/frontmatter');
+  }
+
+  /**
+   * Install BMAD artifacts for an IDE
+   *
+   * @param {string} projectDir - Project root directory
+   * @param {string} bmadDir - BMAD installation directory (_bmad)
+   * @param {UnifiedInstallConfig} config - Installation configuration
+   * @param {Array<string>} selectedModules - Modules to install
+   * @returns {Promise<Object>} Installation result with counts
+   */
+  async install(projectDir, bmadDir, config, selectedModules = []) {
+    const {
+      targetDir,
+      namingStyle = NamingStyle.SUFFIX_BASED,
+      frontmatterTemplate = 'common-yaml.md',
+      fileExtension = '.md',
+      includeNestedStructure = false,
+      customTemplateFn = null,
+      skipExisting = false,
+      artifactTypes = null,
+    } = config;
+
+    // Clean up any existing BMAD files in target directory (unless skipExisting)
+    if (!skipExisting) {
+      await this.cleanupBmadFiles(targetDir, fileExtension);
+    }
+
+    // Ensure target directory exists
+    await fs.ensureDir(targetDir);
+
+    // Count results
+    const counts = {
+      agents: 0,
+      workflows: 0,
+      tasks: 0,
+      tools: 0,
+      total: 0,
+    };
+
+    // Check if we should install agents
+    const installAgents = !artifactTypes || artifactTypes.includes('agents');
+    const installWorkflows = !artifactTypes || artifactTypes.includes('workflows');
+    const installTasks = !artifactTypes || artifactTypes.includes('tasks');
+    const installTools = !artifactTypes || artifactTypes.includes('tools');
+
+    // Load frontmatter template once (if not 'none')
+    let templateContent = null;
+    if (frontmatterTemplate && frontmatterTemplate !== 'none') {
+      templateContent = await this.loadFrontmatterTemplate(frontmatterTemplate);
+    }
+
+    // 1. Install Agents
+    if (installAgents) {
+      const agentGen = new AgentCommandGenerator(this.bmadFolderName);
+      const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, selectedModules);
+      counts.agents = await this.writeArtifacts(
+        agentArtifacts,
+        targetDir,
+        namingStyle,
+        templateContent,
+        frontmatterTemplate,
+        fileExtension,
+        customTemplateFn,
+        'agent',
+        skipExisting,
+      );
+    }
+
+    // 2. Install Workflows (filter out README artifacts)
+    if (installWorkflows) {
+      const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
+      const { artifacts: workflowArtifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
+      const workflowArtifactsFiltered = workflowArtifacts.filter((a) => {
+        const name = path.basename(a.relativePath || '');
+        return name.toLowerCase() !== 'readme.md' && !name.toLowerCase().startsWith('readme-');
+      });
+      counts.workflows = await this.writeArtifacts(
+        workflowArtifactsFiltered,
+        targetDir,
+        namingStyle,
+        templateContent,
+        frontmatterTemplate,
+        fileExtension,
+        customTemplateFn,
+        'workflow',
+        skipExisting,
+      );
+    }
+
+    // 3. Install Tasks and Tools from manifest CSV
+    if (installTasks || installTools) {
+      const ttGen = new TaskToolCommandGenerator();
+
+      // Use suffix-based naming if specified
+      if (namingStyle === NamingStyle.SUFFIX_BASED) {
+        const taskToolResult = await ttGen.generateSuffixBasedTaskToolCommands(
+          projectDir,
+          bmadDir,
+          targetDir,
+          fileExtension,
+          templateContent,
+          frontmatterTemplate,
+          skipExisting,
+        );
+        counts.tasks = taskToolResult.tasks || 0;
+        counts.tools = taskToolResult.tools || 0;
+      } else if (namingStyle === NamingStyle.FLAT_DASH) {
+        const taskToolResult = await ttGen.generateDashTaskToolCommands(projectDir, bmadDir, targetDir, fileExtension);
+        counts.tasks = taskToolResult.tasks || 0;
+        counts.tools = taskToolResult.tools || 0;
+      } else {
+        const taskToolResult = await ttGen.generateColonTaskToolCommands(projectDir, bmadDir, targetDir, fileExtension);
+        counts.tasks = taskToolResult.tasks || 0;
+        counts.tools = taskToolResult.tools || 0;
+      }
+    }
+
+    counts.total = counts.agents + counts.workflows + counts.tasks + counts.tools;
+
+    return counts;
+  }
+
+  /**
+   * Load frontmatter template from file
+   * @param {string} templateFile - Template filename
+   * @returns {Promise<string|null>} Template content or null if not found
+   */
+  async loadFrontmatterTemplate(templateFile) {
+    const templatePath = path.join(this.templateDir, templateFile);
+    try {
+      return await fs.readFile(templatePath, 'utf8');
+    } catch {
+      console.warn(chalk.yellow(`Warning: Could not load template ${templateFile}, using default`));
+      return null;
+    }
+  }
+
+  /**
+   * Apply frontmatter template to content
+   * @param {Object} artifact - Artifact with metadata
+   * @param {string} content - Original content
+   * @param {string} templateContent - Template content
+   * @param {string} templateFile - Template filename (for special handling)
+   * @returns {string} Content with frontmatter applied
+   */
+  applyFrontmatterTemplate(artifact, content, templateContent, templateFile) {
+    if (!templateContent) {
+      return content;
+    }
+
+    // Extract existing frontmatter if present
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = content.replace(frontmatterRegex, '').trim();
+
+    // Get artifact metadata for template substitution
+    const name = artifact.name || artifact.displayName || 'workflow';
+    const title = this.formatTitle(name);
+    const iconMatch = content.match(/icon="([^"]+)"/);
+    const icon = iconMatch ? iconMatch[1] : '🤖';
+
+    // Use artifact's description if available, otherwise generate fallback
+    const description = artifact.description || `Activates the ${name} ${artifact.type || 'workflow'}.`;
+
+    // Template variables
+    const variables = {
+      name,
+      title,
+      displayName: name,
+      description,
+      icon,
+      content: contentWithoutFrontmatter,
+
+      // Special variables for certain templates
+      autoExecMode: this.getAutoExecMode(artifact),
+      tools: JSON.stringify(this.getCopilotTools()),
+    };
+
+    // Apply template substitutions
+    let result = templateContent;
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replaceAll(`{{${key}}}`, value);
+    }
+
+    // Append content after frontmatter (for TOML templates with prompt field)
+    if (templateFile.includes('toml') && !result.includes('{{content}}')) {
+      const escapedContent = contentWithoutFrontmatter.replaceAll('"""', String.raw`\"\"\"`);
+      result = result.replace(/prompt = """/, `prompt = """\n${escapedContent}`);
+    }
+
+    return result.trim() + '\n\n' + contentWithoutFrontmatter;
+  }
+
+  /**
+   * Get auto_execution_mode for Windsurf based on artifact type
+   */
+  getAutoExecMode(artifact) {
+    if (artifact.type === 'agent') return '3';
+    if (artifact.type === 'task' || artifact.type === 'tool') return '2';
+    return '1'; // default for workflows
+  }
+
+  /**
+   * Get GitHub Copilot tools array
+   */
+  getCopilotTools() {
+    return [
+      'changes',
+      'edit',
+      'fetch',
+      'githubRepo',
+      'problems',
+      'runCommands',
+      'runTasks',
+      'runTests',
+      'search',
+      'runSubagent',
+      'testFailure',
+      'todos',
+      'usages',
+    ];
+  }
+
+  /**
+   * Clean up any existing BMAD files in target directory
+   */
+  async cleanupBmadFiles(targetDir, fileExtension = '.md') {
+    if (!(await fs.pathExists(targetDir))) {
+      return;
+    }
+
+    const entries = await fs.readdir(targetDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('bmad') && entry.name.endsWith(fileExtension)) {
+        const entryPath = path.join(targetDir, entry.name);
+        await fs.remove(entryPath);
+      }
+    }
+  }
+
+  /**
+   * Write artifacts with specified naming style and template
+   */
+  async writeArtifacts(
+    artifacts,
+    targetDir,
+    namingStyle,
+    templateContent,
+    templateFile,
+    fileExtension,
+    customTemplateFn,
+    artifactType,
+    skipExisting = false,
+  ) {
+    let written = 0;
+    let skipped = 0;
+
+    for (const artifact of artifacts) {
+      // Determine target path based on naming style
+      let targetPath;
+      let content = artifact.content;
+
+      switch (namingStyle) {
+        case NamingStyle.SUFFIX_BASED: {
+          const suffixName = toSuffixBasedName(artifact.relativePath, artifactType, fileExtension);
+          targetPath = path.join(targetDir, suffixName);
+
+          break;
+        }
+        case NamingStyle.FLAT_COLON: {
+          const flatName = toColonPath(artifact.relativePath, fileExtension);
+          targetPath = path.join(targetDir, flatName);
+
+          break;
+        }
+        case NamingStyle.FLAT_DASH: {
+          const flatName = toDashPath(artifact.relativePath, fileExtension);
+          targetPath = path.join(targetDir, flatName);
+
+          break;
+        }
+        default: {
+          const flatName = toColonPath(artifact.relativePath, fileExtension);
+          targetPath = path.join(targetDir, flatName);
+        }
+      }
+
+      // Skip if file already exists
+      if (skipExisting && (await fs.pathExists(targetPath))) {
+        skipped++;
+        continue;
+      }
+
+      // Apply template transformations
+      if (customTemplateFn) {
+        content = customTemplateFn(artifact, content, templateFile);
+      } else if (templateFile !== 'none') {
+        content = this.applyFrontmatterTemplate(artifact, content, templateContent, templateFile);
+      }
+
+      await fs.ensureDir(targetDir);
+      await fs.writeFile(targetPath, content, 'utf8');
+      written++;
+    }
+
+    if (skipped > 0) {
+      console.log(chalk.dim(`  Skipped ${skipped} existing files`));
+    }
+
+    return written;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+}
+
+module.exports = {
+  UnifiedInstaller,
+  NamingStyle,
+};

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

@@ -14,44 +14,10 @@ class WorkflowCommandGenerator {
   }
 
   /**
-   * Generate workflow commands from the manifest CSV
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
+   * REMOVED: Old generateWorkflowCommands method that created nested structure.
+   * This was hardcoded to .claude/commands/bmad and caused bugs.
+   * Use collectWorkflowArtifacts() + writeColonArtifacts/writeDashArtifacts() instead.
    */
-  async generateWorkflowCommands(projectDir, bmadDir) {
-    const workflows = await this.loadWorkflowManifest(bmadDir);
-
-    if (!workflows) {
-      console.log(chalk.yellow('Workflow manifest not found. Skipping command generation.'));
-      return { generated: 0 };
-    }
-
-    // ALL workflows now generate commands - no standalone filtering
-    const allWorkflows = workflows;
-
-    // Base commands directory
-    const baseCommandsDir = path.join(projectDir, '.claude', 'commands', 'bmad');
-
-    let generatedCount = 0;
-
-    // Generate a command file for each workflow, organized by module
-    for (const workflow of allWorkflows) {
-      const moduleWorkflowsDir = path.join(baseCommandsDir, workflow.module, 'workflows');
-      await fs.ensureDir(moduleWorkflowsDir);
-
-      const commandContent = await this.generateCommandContent(workflow, bmadDir);
-      const commandPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
-
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    // Also create a workflow launcher README in each module
-    const groupedWorkflows = this.groupWorkflowsByModule(allWorkflows);
-    await this.createModuleWorkflowLaunchers(baseCommandsDir, groupedWorkflows);
-
-    return { generated: generatedCount };
-  }
 
   async collectWorkflowArtifacts(bmadDir) {
     const workflows = await this.loadWorkflowManifest(bmadDir);
@@ -69,6 +35,9 @@ class WorkflowCommandGenerator {
       const commandContent = await this.generateCommandContent(workflow, bmadDir);
       artifacts.push({
         type: 'workflow-command',
+        name: workflow.name,
+        displayName: workflow.displayName || workflow.name,
+        description: workflow.description,
         module: workflow.module,
         relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
         content: commandContent,

tools/cli/installers/lib/ide/templates/agent-command-template.md

@@ -6,7 +6,7 @@ description: '{{description}}'
 You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
 
 <agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @_bmad/{{module}}/agents/{{path}}
+1. LOAD the FULL agent file from @_bmad/{{relativePath}}
 2. READ its entire contents - this contains the complete agent persona, menu, and instructions
 3. Execute ALL activation steps exactly as written in the agent file
 4. Follow the agent's persona and menu system precisely

tools/cli/installers/lib/ide/templates/codex-agent-command-template.md

@@ -0,0 +1,15 @@
+---
+name: '{{name}}'
+description: '{{description}}'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @_bmad/{{relativePath}}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>

tools/cli/installers/lib/ide/templates/codex-custom-agent-template.md

@@ -0,0 +1,8 @@
+---
+name: '{{name}}'
+description: '{{description}}'
+---
+
+{{activationHeader}}
+
+Run @_bmad/{{relativePath}} to load the full agent.

tools/cli/installers/lib/ide/templates/frontmatter/common-toml.md

@@ -0,0 +1,4 @@
+description = "{{description}}"
+prompt = """
+{{content}}
+"""

tools/cli/installers/lib/ide/templates/frontmatter/common-yaml.md

@@ -0,0 +1,4 @@
+---
+name: '{{name}}'
+description: '{{description}}'
+---

tools/cli/installers/lib/ide/templates/frontmatter/copilot-agent.md

@@ -0,0 +1,7 @@
+---
+description: "{{description}}"
+tools: {{tools}}
+---
+
+# {{title}}
+

tools/cli/installers/lib/ide/templates/frontmatter/copilot.md

@@ -0,0 +1,4 @@
+---
+description: "{{description}}"
+tools: {{tools}}
+---

tools/cli/installers/lib/ide/templates/frontmatter/opencode-agent.md

@@ -0,0 +1,5 @@
+---
+name: '{{name}}'
+description: 'BMAD {{name}} agent'
+mode: 'primary'
+---

tools/cli/installers/lib/ide/templates/frontmatter/opencode.md

@@ -0,0 +1,4 @@
+---
+name: '{{name}}'
+description: 'BMAD {{name}} command'
+---

tools/cli/installers/lib/ide/templates/frontmatter/roo.md

@@ -0,0 +1,4 @@
+---
+name: '{{icon}} {{title}}'
+description: 'Use for {{title}} tasks'
+---

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

@@ -0,0 +1,4 @@
+---
+description: "{{name}}"
+always: true
+---

tools/cli/installers/lib/ide/templates/frontmatter/windsurf.md

@@ -0,0 +1,4 @@
+---
+description: {{name}}
+auto_execution_mode: {{autoExecMode}}
+---

tools/cli/installers/lib/ide/templates/workflow-commander.md

@@ -1,4 +1,5 @@
 ---
+name: '{{name}}'
 description: '{{description}}'
 ---
 

tools/cli/installers/lib/ide/trae.js

@@ -1,313 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-
-/**
- * Trae IDE setup handler
- */
-class TraeSetup extends BaseIdeSetup {
-  constructor() {
-    super('trae', 'Trae');
-    this.configDir = '.trae';
-    this.rulesDir = 'rules';
-  }
-
-  /**
-   * Setup Trae IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .trae/rules directory
-    const traeDir = path.join(projectDir, this.configDir);
-    const rulesDir = path.join(traeDir, this.rulesDir);
-
-    await this.ensureDir(rulesDir);
-
-    // Clean up any existing BMAD files before reinstalling
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Get tasks, tools, and workflows (standalone only)
-    const tasks = await this.getTasks(bmadDir, true);
-    const tools = await this.getTools(bmadDir, true);
-    const workflows = await this.getWorkflows(bmadDir, true);
-
-    // Process agents as rules with bmad- prefix
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const processedContent = await this.createAgentRule(artifact, bmadDir, projectDir);
-
-      // Use bmad- prefix: bmad-agent-{module}-{name}.md
-      const targetPath = path.join(rulesDir, `bmad-agent-${artifact.module}-${artifact.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      agentCount++;
-    }
-
-    // Process tasks as rules with bmad- prefix
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const processedContent = this.createTaskRule(task, content);
-
-      // Use bmad- prefix: bmad-task-{module}-{name}.md
-      const targetPath = path.join(rulesDir, `bmad-task-${task.module}-${task.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      taskCount++;
-    }
-
-    // Process tools as rules with bmad- prefix
-    let toolCount = 0;
-    for (const tool of tools) {
-      const content = await this.readFile(tool.path);
-      const processedContent = this.createToolRule(tool, content);
-
-      // Use bmad- prefix: bmad-tool-{module}-{name}.md
-      const targetPath = path.join(rulesDir, `bmad-tool-${tool.module}-${tool.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      toolCount++;
-    }
-
-    // Process workflows as rules with bmad- prefix
-    let workflowCount = 0;
-    for (const workflow of workflows) {
-      const content = await this.readFile(workflow.path);
-      const processedContent = this.createWorkflowRule(workflow, content);
-
-      // Use bmad- prefix: bmad-workflow-{module}-{name}.md
-      const targetPath = path.join(rulesDir, `bmad-workflow-${workflow.module}-${workflow.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      workflowCount++;
-    }
-
-    const totalRules = agentCount + taskCount + toolCount + workflowCount;
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agent rules created`));
-    console.log(chalk.dim(`  - ${taskCount} task rules created`));
-    console.log(chalk.dim(`  - ${toolCount} tool rules created`));
-    console.log(chalk.dim(`  - ${workflowCount} workflow rules created`));
-    console.log(chalk.dim(`  - Total: ${totalRules} rules`));
-    console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, rulesDir)}`));
-    console.log(chalk.dim(`  - Agents can be activated with @{agent-name}`));
-
-    return {
-      success: true,
-      rules: totalRules,
-      agents: agentCount,
-      tasks: taskCount,
-      tools: toolCount,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Create rule content for an agent
-   */
-  async createAgentRule(artifact, bmadDir, projectDir) {
-    // Strip frontmatter from launcher
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
-
-    // Extract metadata from launcher content
-    const titleMatch = artifact.content.match(/description:\s*"([^"]+)"/);
-    const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
-
-    // Calculate relative path for reference
-    const relativePath = path.relative(projectDir, artifact.sourcePath).replaceAll('\\', '/');
-
-    let ruleContent = `# ${title} Agent Rule
-
-This rule is triggered when the user types \`@${artifact.name}\` and activates the ${title} agent persona.
-
-## Agent Activation
-
-${contentWithoutFrontmatter}
-
-## File Reference
-
-The full agent definition is located at: \`${relativePath}\`
-`;
-
-    return ruleContent;
-  }
-
-  /**
-   * Create rule content for a task
-   */
-  createTaskRule(task, content) {
-    // Extract task name from content
-    const nameMatch = content.match(/name="([^"]+)"/);
-    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
-
-    let ruleContent = `# ${taskName} Task Rule
-
-This rule defines the ${taskName} task workflow.
-
-## Task Definition
-
-When this task is triggered, execute the following workflow:
-
-${content}
-
-## Usage
-
-Reference this task with \`@task-${task.name}\` to execute the defined workflow.
-
-## Module
-
-Part of the BMAD ${task.module.toUpperCase()} module.
-`;
-
-    return ruleContent;
-  }
-
-  /**
-   * Create rule content for a tool
-   */
-  createToolRule(tool, content) {
-    // Extract tool name from content
-    const nameMatch = content.match(/name="([^"]+)"/);
-    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
-
-    let ruleContent = `# ${toolName} Tool Rule
-
-This rule defines the ${toolName} tool.
-
-## Tool Definition
-
-When this tool is triggered, execute the following:
-
-${content}
-
-## Usage
-
-Reference this tool with \`@tool-${tool.name}\` to execute it.
-
-## Module
-
-Part of the BMAD ${tool.module.toUpperCase()} module.
-`;
-
-    return ruleContent;
-  }
-
-  /**
-   * Create rule content for a workflow
-   */
-  createWorkflowRule(workflow, content) {
-    let ruleContent = `# ${workflow.name} Workflow Rule
-
-This rule defines the ${workflow.name} workflow.
-
-## Workflow Description
-
-${workflow.description || 'No description provided'}
-
-## Workflow Definition
-
-${content}
-
-## Usage
-
-Reference this workflow with \`@workflow-${workflow.name}\` to execute the guided workflow.
-
-## Module
-
-Part of the BMAD ${workflow.module.toUpperCase()} module.
-`;
-
-    return ruleContent;
-  }
-
-  /**
-   * Format agent/task name as title
-   */
-  formatTitle(name) {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Cleanup Trae configuration - surgically remove only BMAD files
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const rulesPath = path.join(projectDir, this.configDir, this.rulesDir);
-
-    if (await fs.pathExists(rulesPath)) {
-      // Remove any bmad* files (cleans up old bmad- and bmad: formats)
-      const files = await fs.readdir(rulesPath);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('bmad') && file.endsWith('.md')) {
-          await fs.remove(path.join(rulesPath, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0) {
-        console.log(chalk.dim(`  Cleaned up ${removed} existing BMAD rules`));
-      }
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Trae
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object} Installation result
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const traeDir = path.join(projectDir, this.configDir);
-    const rulesDir = path.join(traeDir, this.rulesDir);
-
-    // Create .trae/rules directory if it doesn't exist
-    await fs.ensureDir(rulesDir);
-
-    // Create custom agent launcher
-    const launcherContent = `# ${agentName} Custom Agent
-
-**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
-
-This is a launcher for the custom BMAD agent "${agentName}".
-
-## Usage
-1. First run: \`${agentPath}\` to load the complete agent
-2. Then use this rule to activate ${agentName}
-
-The agent will follow the persona and instructions from the main agent file.
-
----
-
-*Generated by BMAD Method*`;
-
-    const fileName = `bmad-agent-custom-${agentName.toLowerCase()}.md`;
-    const launcherPath = path.join(rulesDir, fileName);
-
-    // Write the launcher file
-    await fs.writeFile(launcherPath, launcherContent, 'utf8');
-
-    return {
-      ide: 'trae',
-      path: path.relative(projectDir, launcherPath),
-      command: agentName,
-      type: 'custom-agent-launcher',
-    };
-  }
-}
-
-module.exports = { TraeSetup };

tools/cli/installers/lib/ide/windsurf.js

@@ -1,258 +0,0 @@
-const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
-const chalk = require('chalk');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-
-/**
- * Windsurf IDE setup handler
- */
-class WindsurfSetup extends BaseIdeSetup {
-  constructor() {
-    super('windsurf', 'Windsurf', true); // preferred IDE
-    this.configDir = '.windsurf';
-    this.workflowsDir = 'workflows';
-  }
-
-  /**
-   * Setup Windsurf IDE configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, bmadDir, options = {}) {
-    console.log(chalk.cyan(`Setting up ${this.name}...`));
-
-    // Create .windsurf/workflows/bmad directory structure
-    const windsurfDir = path.join(projectDir, this.configDir);
-    const workflowsDir = path.join(windsurfDir, this.workflowsDir);
-    const bmadWorkflowsDir = path.join(workflowsDir, 'bmad');
-
-    await this.ensureDir(bmadWorkflowsDir);
-
-    // Clean up any existing BMAD workflows before reinstalling
-    await this.cleanup(projectDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
-
-    // Convert artifacts to agent format for module organization
-    const agents = agentArtifacts.map((a) => ({ module: a.module, name: a.name }));
-
-    // Get tasks, tools, and workflows (standalone only)
-    const tasks = await this.getTasks(bmadDir, true);
-    const tools = await this.getTools(bmadDir, true);
-    const workflows = await this.getWorkflows(bmadDir, true);
-
-    // Create directories for each module under bmad/
-    const modules = new Set();
-    for (const item of [...agents, ...tasks, ...tools, ...workflows]) modules.add(item.module);
-
-    for (const module of modules) {
-      await this.ensureDir(path.join(bmadWorkflowsDir, module));
-      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'agents'));
-      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tasks'));
-      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'tools'));
-      await this.ensureDir(path.join(bmadWorkflowsDir, module, 'workflows'));
-    }
-
-    // Process agent launchers as workflows with organized structure
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const processedContent = this.createWorkflowContent({ module: artifact.module, name: artifact.name }, artifact.content);
-
-      // Organized path: bmad/module/agents/agent-name.md
-      const targetPath = path.join(bmadWorkflowsDir, artifact.module, 'agents', `${artifact.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      agentCount++;
-    }
-
-    // Process tasks as workflows with organized structure
-    let taskCount = 0;
-    for (const task of tasks) {
-      const content = await this.readFile(task.path);
-      const processedContent = this.createTaskWorkflowContent(task, content);
-
-      // Organized path: bmad/module/tasks/task-name.md
-      const targetPath = path.join(bmadWorkflowsDir, task.module, 'tasks', `${task.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      taskCount++;
-    }
-
-    // Process tools as workflows with organized structure
-    let toolCount = 0;
-    for (const tool of tools) {
-      const content = await this.readFile(tool.path);
-      const processedContent = this.createToolWorkflowContent(tool, content);
-
-      // Organized path: bmad/module/tools/tool-name.md
-      const targetPath = path.join(bmadWorkflowsDir, tool.module, 'tools', `${tool.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      toolCount++;
-    }
-
-    // Process workflows with organized structure
-    let workflowCount = 0;
-    for (const workflow of workflows) {
-      const content = await this.readFile(workflow.path);
-      const processedContent = this.createWorkflowWorkflowContent(workflow, content);
-
-      // Organized path: bmad/module/workflows/workflow-name.md
-      const targetPath = path.join(bmadWorkflowsDir, workflow.module, 'workflows', `${workflow.name}.md`);
-      await this.writeFile(targetPath, processedContent);
-      workflowCount++;
-    }
-
-    console.log(chalk.green(`✓ ${this.name} configured:`));
-    console.log(chalk.dim(`  - ${agentCount} agents installed`));
-    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
-    console.log(chalk.dim(`  - ${toolCount} tools installed`));
-    console.log(chalk.dim(`  - ${workflowCount} workflows installed`));
-    console.log(chalk.dim(`  - Organized in modules: ${[...modules].join(', ')}`));
-    console.log(chalk.dim(`  - Workflows directory: ${path.relative(projectDir, workflowsDir)}`));
-
-    // Provide additional configuration hints
-    if (options.showHints !== false) {
-      console.log(chalk.dim('\n  Windsurf workflow settings:'));
-      console.log(chalk.dim('  - auto_execution_mode: 3 (recommended for agents)'));
-      console.log(chalk.dim('  - auto_execution_mode: 2 (recommended for tasks/tools)'));
-      console.log(chalk.dim('  - auto_execution_mode: 1 (recommended for workflows)'));
-      console.log(chalk.dim('  - Workflows can be triggered via the Windsurf menu'));
-    }
-
-    return {
-      success: true,
-      agents: agentCount,
-      tasks: taskCount,
-      tools: toolCount,
-      workflows: workflowCount,
-    };
-  }
-
-  /**
-   * Create workflow content for an agent
-   */
-  createWorkflowContent(agent, content) {
-    // Strip existing frontmatter from launcher
-    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
-    const contentWithoutFrontmatter = content.replace(frontmatterRegex, '');
-
-    // Create simple Windsurf frontmatter matching original format
-    let workflowContent = `---
-description: ${agent.name}
-auto_execution_mode: 3
----
-
-${contentWithoutFrontmatter}`;
-
-    return workflowContent;
-  }
-
-  /**
-   * Create workflow content for a task
-   */
-  createTaskWorkflowContent(task, content) {
-    // Create simple Windsurf frontmatter matching original format
-    let workflowContent = `---
-description: task-${task.name}
-auto_execution_mode: 2
----
-
-${content}`;
-
-    return workflowContent;
-  }
-
-  /**
-   * Create workflow content for a tool
-   */
-  createToolWorkflowContent(tool, content) {
-    // Create simple Windsurf frontmatter matching original format
-    let workflowContent = `---
-description: tool-${tool.name}
-auto_execution_mode: 2
----
-
-${content}`;
-
-    return workflowContent;
-  }
-
-  /**
-   * Create workflow content for a workflow
-   */
-  createWorkflowWorkflowContent(workflow, content) {
-    // Create simple Windsurf frontmatter matching original format
-    let workflowContent = `---
-description: ${workflow.name}
-auto_execution_mode: 1
----
-
-${content}`;
-
-    return workflowContent;
-  }
-
-  /**
-   * Cleanup Windsurf configuration - surgically remove only BMAD files
-   */
-  async cleanup(projectDir) {
-    const fs = require('fs-extra');
-    const bmadPath = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad');
-
-    if (await fs.pathExists(bmadPath)) {
-      // Remove the entire bmad folder - this is our territory
-      await fs.remove(bmadPath);
-      console.log(chalk.dim(`  Cleaned up existing BMAD workflows`));
-    }
-  }
-
-  /**
-   * Install a custom agent launcher for Windsurf
-   * @param {string} projectDir - Project directory
-   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
-   * @param {string} agentPath - Path to compiled agent (relative to project root)
-   * @param {Object} metadata - Agent metadata
-   * @returns {Object|null} Info about created command
-   */
-  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
-    const fs = require('fs-extra');
-    const customAgentsDir = path.join(projectDir, this.configDir, this.workflowsDir, 'bmad', 'custom', 'agents');
-
-    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
-      return null; // IDE not configured for this project
-    }
-
-    await this.ensureDir(customAgentsDir);
-
-    const launcherContent = `You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from @${agentPath}
-2. READ its entire contents - this contains the complete agent persona, menu, and instructions
-3. FOLLOW every step in the <activation> section precisely
-4. DISPLAY the welcome/greeting as instructed
-5. PRESENT the numbered menu
-6. WAIT for user input before proceeding
-</agent-activation>
-`;
-
-    // Windsurf uses workflow format with frontmatter
-    const workflowContent = `---
-description: ${metadata.title || agentName}
-auto_execution_mode: 3
----
-
-${launcherContent}`;
-
-    const launcherPath = path.join(customAgentsDir, `${agentName}.md`);
-    await fs.writeFile(launcherPath, workflowContent);
-
-    return {
-      path: launcherPath,
-      command: `bmad/custom/agents/${agentName}`,
-    };
-  }
-}
-
-module.exports = { WindsurfSetup };

tools/cli/lib/platform-codes.js

@@ -9,7 +9,7 @@ const { getProjectRoot } = require('./project-root');
  */
 class PlatformCodes {
   constructor() {
-    this.configPath = path.join(getProjectRoot(), 'tools', 'platform-codes.yaml');
+    this.configPath = path.join(getProjectRoot(), 'tools/cli/installers/lib/ide/platform-codes.yaml');
     this.loadConfig();
   }
 

tools/cli/lib/ui.js

@@ -363,8 +363,8 @@ class UI {
     const { IdeManager } = require('../installers/lib/ide/manager');
     const ideManager = new IdeManager();
 
-    const preferredIdes = ideManager.getPreferredIdes();
-    const otherIdes = ideManager.getOtherIdes();
+    const preferredIdes = await ideManager.getPreferredIdes();
+    const otherIdes = await ideManager.getOtherIdes();
 
     // Build grouped options object for groupMultiselect
     const groupedOptions = {};