bmad-method 6.0.0-alpha.12 → 6.0.0-alpha.14

package/src/core/workflows/party-mode/workflow.md

@@ -0,0 +1,206 @@
+---
+name: party-mode
+description: Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations
+---
+
+# Party Mode Workflow
+
+**Goal:** Orchestrates group discussions between all installed BMAD agents, enabling natural multi-agent conversations
+
+**Your Role:** You are a party mode facilitator and multi-agent conversation orchestrator. You bring together diverse BMAD agents for collaborative discussions, managing the flow of conversation while maintaining each agent's unique personality and expertise.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** with **sequential conversation orchestration**:
+
+- Step 01 loads agent manifest and initializes party mode
+- Step 02 orchestrates the ongoing multi-agent discussion
+- Step 03 handles graceful party mode exit
+- Conversation state tracked in frontmatter
+- Agent personalities maintained through merged manifest data
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/{bmad_folder}/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as a system-generated value
+- Agent manifest path: `{project-root}/{bmad_folder}/_cfg/agent-manifest.csv`
+
+### Paths
+
+- `installed_path` = `{project-root}/{bmad_folder}/core/workflows/party-mode`
+- `agent_manifest_path` = `{project-root}/{bmad_folder}/_cfg/agent-manifest.csv`
+- `standalone_mode` = `true` (party mode is an interactive workflow)
+
+---
+
+## AGENT MANIFEST PROCESSING
+
+### Agent Data Extraction
+
+Parse CSV manifest to extract agent entries with complete information:
+
+- **name** (agent identifier)
+- **displayName** (agent's persona name)
+- **title** (formal position)
+- **icon** (visual identifier emoji)
+- **role** (capabilities summary)
+- **identity** (background/expertise)
+- **communicationStyle** (how they communicate)
+- **principles** (decision-making philosophy)
+- **module** (source module)
+- **path** (file location)
+
+### Agent Roster Building
+
+Build complete agent roster with merged personalities for conversation orchestration.
+
+---
+
+## EXECUTION
+
+Execute party mode activation and conversation orchestration:
+
+### Party Mode Activation
+
+**Your Role:** You are a party mode facilitator creating an engaging multi-agent conversation environment.
+
+**Welcome Activation:**
+
+"🎉 PARTY MODE ACTIVATED! 🎉
+
+Welcome {{user_name}}! All BMAD agents are here and ready for a dynamic group discussion. I've brought together our complete team of experts, each bringing their unique perspectives and capabilities.
+
+**Let me introduce our collaborating agents:**
+
+[Load agent roster and display 2-3 most diverse agents as examples]
+
+**What would you like to discuss with the team today?**"
+
+### Agent Selection Intelligence
+
+For each user message or topic:
+
+**Relevance Analysis:**
+
+- Analyze the user's message/question for domain and expertise requirements
+- Identify which agents would naturally contribute based on their role, capabilities, and principles
+- Consider conversation context and previous agent contributions
+- Select 2-3 most relevant agents for balanced perspective
+
+**Priority Handling:**
+
+- If user addresses specific agent by name, prioritize that agent + 1-2 complementary agents
+- Rotate agent selection to ensure diverse participation over time
+- Enable natural cross-talk and agent-to-agent interactions
+
+### Conversation Orchestration
+
+Load step: `./steps/step-02-discussion-orchestration.md`
+
+---
+
+## WORKFLOW STATES
+
+### Frontmatter Tracking
+
+```yaml
+---
+stepsCompleted: [1]
+workflowType: 'party-mode'
+user_name: '{{user_name}}'
+date: '{{date}}'
+agents_loaded: true
+party_active: true
+exit_triggers: ['*exit', 'goodbye', 'end party', 'quit']
+---
+```
+
+---
+
+## ROLE-PLAYING GUIDELINES
+
+### Character Consistency
+
+- Maintain strict in-character responses based on merged personality data
+- Use each agent's documented communication style consistently
+- Reference agent memories and context when relevant
+- Allow natural disagreements and different perspectives
+- Include personality-driven quirks and occasional humor
+
+### Conversation Flow
+
+- Enable agents to reference each other naturally by name or role
+- Maintain professional discourse while being engaging
+- Respect each agent's expertise boundaries
+- Allow cross-talk and building on previous points
+
+---
+
+## QUESTION HANDLING PROTOCOL
+
+### Direct Questions to User
+
+When an agent asks the user a specific question:
+
+- End that response round immediately after the question
+- Clearly highlight the questioning agent and their question
+- Wait for user response before any agent continues
+
+### Inter-Agent Questions
+
+Agents can question each other and respond naturally within the same round for dynamic conversation.
+
+---
+
+## EXIT CONDITIONS
+
+### Automatic Triggers
+
+Exit party mode when user message contains any exit triggers:
+
+- `*exit`, `goodbye`, `end party`, `quit`
+
+### Graceful Conclusion
+
+If conversation naturally concludes:
+
+- Ask user if they'd like to continue or end party mode
+- Exit gracefully when user indicates completion
+
+---
+
+## TTS INTEGRATION
+
+Party mode includes Text-to-Speech for each agent response:
+
+**TTS Protocol:**
+
+- Trigger TTS immediately after each agent's text response
+- Use agent's merged voice configuration from manifest
+- Format: `Bash: .claude/hooks/bmad-speak.sh "[Agent Name]" "[Their response]"`
+
+---
+
+## MODERATION NOTES
+
+**Quality Control:**
+
+- If discussion becomes circular, have bmad-master summarize and redirect
+- Balance fun and productivity based on conversation tone
+- Ensure all agents stay true to their merged personalities
+- Exit gracefully when user indicates completion
+
+**Conversation Management:**
+
+- Rotate agent participation to ensure inclusive discussion
+- Handle topic drift while maintaining productive conversation
+- Facilitate cross-agent collaboration and knowledge sharing

package/src/modules/bmb/README.md

@@ -5,6 +5,8 @@ Specialized tools and workflows for creating, customizing, and extending BMad co
 ## Table of Contents
 
 - [Module Structure](#module-structure)
+- [Documentation](#documentation)
+- [Reference Materials](#reference-materials)
 - [Core Workflows](#core-workflows)
 - [Agent Types](#agent-types)
 - [Quick Start](#quick-start)
@@ -16,124 +18,172 @@ Specialized tools and workflows for creating, customizing, and extending BMad co
 
 **BMad Builder** - Master builder agent orchestrating all creation workflows with deep knowledge of BMad architecture and conventions.
 
+- Location: `.bmad/bmb/agents/bmad-builder.md`
+
 ### 📋 Workflows
 
-Comprehensive suite for building and maintaining BMad components.
+**Active Workflows** (Step-File Architecture)
 
-## Core Workflows
+- Location: `src/modules/bmb/workflows/`
+- 5 core workflows with 41 step files total
+- Template-based execution with JIT loading
 
-### Creation Workflows
+**Legacy Workflows** (Being Migrated)
 
-**[create-agent](./workflows/create-agent/README.md)** - Build BMad agents
+- Location: `src/modules/bmb/workflows-legacy/`
+- Module-specific workflows pending conversion to step-file architecture
 
-- Interactive persona development
-- Command structure design
-- YAML source compilation to .md
+### 📚 Documentation
 
-**[create-workflow](./workflows/create-workflow/README.md)** - Design workflows
+- Location: `src/modules/bmb/docs/`
+- Comprehensive guides for agents and workflows
+- Architecture patterns and best practices
 
-- Structured multi-step processes
-- Configuration validation
-- Web bundle support
+### 🔍 Reference Materials
 
-**[create-module](./workflows/create-module/README.md)** - Build complete modules
+- Location: `src/modules/bmb/reference/`
+- Working examples of agents and workflows
+- Template patterns and implementation guides
 
-- Full module infrastructure
-- Agent and workflow integration
-- Installation automation
+## Documentation
 
-**[module-brief](./workflows/module-brief/README.md)** - Strategic planning
+### 📖 Agent Documentation
 
-- Module blueprint creation
-- Vision and architecture
-- Comprehensive analysis
+- **[Agent Index](./docs/agents/index.md)** - Complete agent architecture guide
+- **[Agent Types Guide](./docs/agents/understanding-agent-types.md)** - Simple vs Expert vs Module agents
+- **[Menu Patterns](./docs/agents/agent-menu-patterns.md)** - YAML menu design and handler types
+- **[Agent Compilation](./docs/agents/agent-compilation.md)** - Auto-injection rules and compilation process
 
-### Editing Workflows
+### 📋 Workflow Documentation
 
-**[edit-agent](./workflows/edit-agent/README.md)** - Modify existing agents
+- **[Workflow Index](./docs/workflows/index.md)** - Core workflow system overview
+- **[Architecture Guide](./docs/workflows/architecture.md)** - Step-file design and JIT loading
+- **[Template System](./docs/workflows/templates/step-template.md)** - Standard step file template
+- **[Intent vs Prescriptive](./docs/workflows/intent-vs-prescriptive-spectrum.md)** - Design philosophy
 
-- Persona refinement
-- Command updates
-- Best practice compliance
+## Reference Materials
 
-**[edit-workflow](./workflows/edit-workflow/README.md)** - Update workflows
+### 🤖 Agent Examples
 
-- Structure maintenance
-- Configuration updates
-- Documentation sync
+- **[Simple Agent Example](./reference/agents/simple-examples/commit-poet.agent.yaml)** - Self-contained agent
+- **[Expert Agent Example](./reference/agents/expert-examples/journal-keeper/)** - Agent with persistent memory
+- **[Module Agent Examples](./reference/agents/module-examples/)** - Integration patterns (BMM, CIS)
+
+### 📋 Workflow Examples
+
+- **[Meal Prep & Nutrition](./reference/workflows/meal-prep-nutrition/)** - Complete step-file workflow demonstration
+- **Template patterns** for document generation and state management
+
+## Core Workflows
 
-**[edit-module](./workflows/edit-module/README.md)** - Module enhancement
+### Creation Workflows (Step-File Architecture)
 
-- Component modifications
-- Dependency management
-- Version control
+**[create-agent](./workflows/create-agent/)** - Build BMad agents
 
-### Maintenance Workflows
+- 11 guided steps from brainstorming to celebration
+- 18 reference data files with validation checklists
+- Template-based agent generation
+
+**[create-workflow](./workflows/create-workflow/)** - Design workflows
+
+- 12 structured steps from init to review
+- 9 template files for workflow creation
+- Step-file architecture implementation
+
+### Editing Workflows
+
+**[edit-agent](./workflows/edit-agent/)** - Modify existing agents
+
+- 5 steps: discovery → validation
+- Intent-driven analysis and updates
+- Best practice compliance
 
-**[convert-legacy](./workflows/convert-legacy/README.md)** - Migration tool
+**[edit-workflow](./workflows/edit-workflow/)** - Update workflows
 
-- v4 to v6 conversion
-- Structure compliance
-- Convention updates
+- 5 steps: analyze → compliance check
+- Structure maintenance and validation
+- Template updates for consistency
 
-**[audit-workflow](./workflows/audit-workflow/README.md)** - Quality validation
+### Quality Assurance
 
-- Structure verification
-- Config standards check
-- Bloat detection
-- Web bundle completeness
+**[workflow-compliance-check](./workflows/workflow-compliance-check/)** - Validation
 
-**[redoc](./workflows/redoc/README.md)** - Auto-documentation
+- 8 systematic validation steps
+- Adversarial analysis approach
+- Detailed compliance reporting
 
-- Reverse-tree approach
-- Technical writer quality
-- Convention compliance
+### Legacy Migration (Pending)
+
+Workflows in `workflows-legacy/` are being migrated to step-file architecture:
+
+- Module-specific workflows
+- Historical implementations
+- Conversion planning in progress
 
 ## Agent Types
 
 BMB creates three agent architectures:
 
-### Full Module Agent
+### Simple Agent
 
-- Complete persona and role definition
-- Command structure with fuzzy matching
-- Workflow integration
-- Module-specific capabilities
+- **Self-contained**: All logic in single YAML file
+- **Stateless**: No persistent memory across sessions
+- **Purpose**: Single utilities and specialized tools
+- **Example**: Commit poet, code formatter
 
-### Hybrid Agent
+### Expert Agent
 
-- Shared core capabilities
-- Module-specific extensions
-- Cross-module compatibility
+- **Persistent Memory**: Maintains knowledge across sessions
+- **Sidecar Resources**: External files and data storage
+- **Domain-specific**: Focuses on particular knowledge areas
+- **Example**: Journal keeper, domain consultant
 
-### Standalone Agent
+### Module Agent
 
-- Independent operation
-- Minimal dependencies
-- Specialized single purpose
+- **Team Integration**: Orchestrates within specific modules
+- **Workflow Coordination**: Manages complex processes
+- **Professional Infrastructure**: Enterprise-grade capabilities
+- **Examples**: BMM project manager, CIS innovation strategist
 
 ## Quick Start
 
-1. **Load BMad Builder agent** in your IDE
-2. **Choose creation type:**
+### Using BMad Builder Agent
+
+1. **Load BMad Builder agent** in your IDE:
    ```
-   *create-agent     # New agent
-   *create-workflow  # New workflow
-   *create-module    # Complete module
+   /bmad:bmb:agents:bmad-builder
    ```
-3. **Follow interactive prompts**
+2. **Choose creation type:**
+   - `[CA]` Create Agent - Build new agents
+   - `[CW]` Create Workflow - Design workflows
+   - `[EA]` Edit Agent - Modify existing agents
+   - `[EW]` Edit Workflow - Update workflows
+   - `[VA]` Validate Agent - Quality check agents
+   - `[VW]` Validate Workflow - Quality check workflows
+
+3. **Follow interactive prompts** for step-by-step guidance
 
 ### Example: Creating an Agent
 
 ```
 User: I need a code review agent
-Builder: *create-agent
+Builder: [CA] Create Agent
+
+[11-step guided process]
+Step 1: Brainstorm agent concept
+Step 2: Define persona and role
+Step 3: Design command structure
+...
+Step 11: Celebrate and deploy
+```
 
-[Interactive session begins]
-- Brainstorming phase (optional)
-- Persona development
-- Command structure
-- Integration points
+### Direct Workflow Execution
+
+Workflows can also be run directly without the agent interface:
+
+```yaml
+# Execute specific workflow steps
+workflow: ./workflows/create-agent/workflow.yaml
 ```
 
 ## Use Cases
@@ -165,30 +215,47 @@ Package modules for:
 - Business processes
 - Educational frameworks
 
+## Architecture Principles
+
+### Step-File Workflow Design
+
+- **Micro-file Approach**: Each step is self-contained
+- **Just-In-Time Loading**: Only current step in memory
+- **Sequential Enforcement**: No skipping steps allowed
+- **State Tracking**: Progress documented in frontmatter
+- **Append-Only Building**: Documents grow through execution
+
+### Intent vs Prescriptive Spectrum
+
+- **Creative Workflows**: High user agency, AI as facilitator
+- **Structured Workflows**: Clear process, AI as guide
+- **Prescriptive Workflows**: Strict compliance, AI as validator
+
 ## Best Practices
 
-1. **Study existing patterns** - Review BMM/CIS implementations
-2. **Follow conventions** - Use established structures
-3. **Document thoroughly** - Clear instructions essential
-4. **Test iteratively** - Validate during creation
-5. **Consider reusability** - Build modular components
+1. **Study Reference Materials** - Review docs/ and reference/ examples
+2. **Choose Right Agent Type** - Simple vs Expert vs Module based on needs
+3. **Follow Step-File Patterns** - Use established templates and structures
+4. **Document Thoroughly** - Clear instructions and frontmatter metadata
+5. **Validate Continuously** - Use compliance workflows for quality
+6. **Maintain Consistency** - Follow YAML patterns and naming conventions
 
 ## Integration
 
 BMB components integrate with:
 
-- **BMad Core** - Framework foundation
-- **BMM** - Extend development capabilities
-- **CIS** - Leverage creative workflows
-- **Custom Modules** - Your domain solutions
+- **BMad Core** - Framework foundation and agent compilation
+- **BMM** - Development workflows and project management
+- **CIS** - Creative innovation and strategic workflows
+- **Custom Modules** - Domain-specific solutions
 
-## Related Documentation
+## Getting Help
 
-- **[Agent Creation Guide](./workflows/create-agent/README.md)** - Detailed instructions
-- **[Module Structure](./workflows/create-module/module-structure.md)** - Architecture patterns
-- **[BMM Module](../bmm/README.md)** - Reference implementation
-- **[Core Framework](../../core/README.md)** - Foundation concepts
+- **Documentation**: Check `docs/` for comprehensive guides
+- **Reference Materials**: See `reference/` for working examples
+- **Validation**: Use `workflow-compliance-check` for quality assurance
+- **Templates**: Leverage workflow templates for consistent patterns
 
 ---
 
-BMB empowers you to extend BMad Method for your specific needs while maintaining framework consistency and power.
+BMB provides a complete toolkit for extending BMad Method with disciplined, systematic approaches to agent and workflow development while maintaining framework consistency and power.

package/src/modules/bmb/_module-installer/install-config.yaml

@@ -15,17 +15,12 @@ subheader: "Configure the settings for the BoMB Factory!\nThe agent, workflow an
 ## install_user_docs
 ## kb_install
 
-custom_agent_location:
-  prompt: "Where do custom agents get created?"
-  default: "{bmad_folder}/custom/agents"
-  result: "{project-root}/{value}"
-
-custom_workflow_location:
-  prompt: "Where do custom workflows get stored?"
-  default: "{bmad_folder}/custom/workflows"
+custom_stand_alone_location:
+  prompt: "Where do custom agents and workflows get stored?"
+  default: "bmad-custom-src"
   result: "{project-root}/{value}"
 
 custom_module_location:
   prompt: "Where do custom modules get stored?"
-  default: "{bmad_folder}/custom/modules"
+  default: "bmad-custom-modules-src"
   result: "{project-root}/{value}"

package/src/modules/bmb/_module-installer/installer.js

@@ -0,0 +1,76 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+
+/**
+ * BMB Module Installer
+ * Sets up custom agent and workflow locations for the BMad Builder module
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-config.yaml
+ * @param {Object} options.coreConfig - Core configuration containing user_name
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, coreConfig, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🔧 Setting up BMB Module...'));
+
+    // Generate custom.yaml in custom_stand_alone_location
+    if (config['custom_stand_alone_location']) {
+      // The config value contains {project-root} which needs to be resolved
+      const rawLocation = config['custom_stand_alone_location'];
+      const customLocation = rawLocation.replace('{project-root}', projectRoot);
+      const customDestPath = path.join(customLocation, 'custom.yaml');
+
+      logger.log(chalk.cyan(`  Setting up custom agents at: ${customLocation}`));
+
+      // Ensure the directory exists
+      await fs.ensureDir(customLocation);
+
+      // Generate the custom.yaml content
+      const userName = (coreConfig && coreConfig.user_name) || 'my';
+      const customContent = `code: my-custom-bmad
+name: "${userName}-Custom-BMad: Sample Stand Alone Custom Agents and Workflows"
+default_selected: true
+`;
+
+      // Write the custom.yaml file (only if it doesn't exist to preserve user changes)
+      if (await fs.pathExists(customDestPath)) {
+        logger.log(chalk.yellow(`    ✓ custom.yaml already exists at ${customDestPath}`));
+      } else {
+        await fs.writeFile(customDestPath, customContent, 'utf8');
+        logger.log(chalk.green(`    ✓ Created custom.yaml at ${customDestPath}`));
+      }
+    }
+
+    // Set up custom module location if configured
+    if (config['custom_module_location']) {
+      const rawModuleLocation = config['custom_module_location'];
+      const moduleLocation = rawModuleLocation.replace('{project-root}', projectRoot);
+
+      logger.log(chalk.cyan(`  Setting up custom modules at: ${moduleLocation}`));
+
+      // Ensure the directory exists
+      await fs.ensureDir(moduleLocation);
+      logger.log(chalk.green(`    ✓ Created modules directory at ${moduleLocation}`));
+    }
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`  Configuring BMB for IDEs: ${installedIDEs.join(', ')}`));
+    }
+
+    logger.log(chalk.green('✓ BMB Module setup complete'));
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error setting up BMB module: ${error.message}`));
+    return false;
+  }
+}
+
+module.exports = { install };