bmad-method 5.1.3 → 6.0.0-alpha.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method",
-  "version": "5.1.3",
+  "version": "6.0.0-alpha.0",
   "description": "Breakthrough Method of Agile AI-driven Development",
   "keywords": [
     "agile",
@@ -14,72 +14,63 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bmadcode/BMAD-METHOD.git"
+    "url": "git+https://github.com/bmad-code-org/BMAD-METHOD.git"
   },
   "license": "MIT",
   "author": "Brian (BMad) Madison",
-  "main": "tools/cli.js",
+  "main": "tools/cli/bmad-cli.js",
   "bin": {
-    "bmad": "tools/bmad-npx-wrapper.js",
-    "bmad-method": "tools/bmad-npx-wrapper.js"
+    "bmad": "tools/cli/bmad-cli.js"
   },
   "scripts": {
-    "build": "node tools/cli.js build",
-    "build:agents": "node tools/cli.js build --agents-only",
-    "build:teams": "node tools/cli.js build --teams-only",
+    "bmad:install": "node tools/cli/bmad-cli.js install",
+    "bmad:status": "node tools/cli/bmad-cli.js status",
+    "bundle": "node tools/cli/bundlers/bundle-web.js all",
     "flatten": "node tools/flattener/main.js",
-    "format": "prettier --write \"**/*.{js,cjs,mjs,json,md,yaml}\"",
     "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,md,yaml}\"",
-    "install:bmad": "node tools/installer/bin/bmad.js install",
+    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,md,yaml}\"",
+    "install:bmad": "node tools/cli/bmad-cli.js install",
     "lint": "eslint . --ext .js,.cjs,.mjs,.yaml --max-warnings=0",
     "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
-    "list:agents": "node tools/cli.js list:agents",
     "prepare": "husky",
-    "preview:release": "node tools/preview-release-notes.js",
+    "rebundle": "node tools/cli/bundlers/bundle-web.js rebundle",
     "release:major": "gh workflow run \"Manual Release\" -f version_bump=major",
     "release:minor": "gh workflow run \"Manual Release\" -f version_bump=minor",
     "release:patch": "gh workflow run \"Manual Release\" -f version_bump=patch",
     "release:watch": "gh run watch",
-    "validate": "node tools/cli.js validate",
-    "version:all": "node tools/bump-all-versions.js",
-    "version:all:major": "node tools/bump-all-versions.js major",
-    "version:all:minor": "node tools/bump-all-versions.js minor",
-    "version:all:patch": "node tools/bump-all-versions.js patch",
-    "version:expansion": "node tools/bump-expansion-version.js",
-    "version:expansion:all": "node tools/bump-all-versions.js",
-    "version:expansion:all:major": "node tools/bump-all-versions.js major",
-    "version:expansion:all:minor": "node tools/bump-all-versions.js minor",
-    "version:expansion:all:patch": "node tools/bump-all-versions.js patch",
-    "version:expansion:set": "node tools/update-expansion-version.js",
-    "version:major": "node tools/version-bump.js major",
-    "version:minor": "node tools/version-bump.js minor",
-    "version:patch": "node tools/version-bump.js patch"
+    "validate:bundles": "node tools/validate-bundles.js"
   },
   "lint-staged": {
-    "**/*.{js,cjs,mjs}": [
-      "eslint --fix --max-warnings=0",
-      "prettier --write"
+    "*.{js,cjs,mjs}": [
+      "npm run lint:fix",
+      "npm run format:fix"
     ],
-    "**/*.yaml": [
+    "*.yaml": [
       "eslint --fix",
-      "prettier --write"
+      "npm run format:fix"
     ],
-    "**/*.{json,md}": [
-      "prettier --write"
+    "*.{json,md}": [
+      "npm run format:fix"
     ]
   },
   "dependencies": {
     "@kayvan/markdown-tree-parser": "^1.5.0",
     "bmad-method": "^4.30.3",
+    "boxen": "^5.1.2",
     "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
     "commander": "^14.0.0",
+    "csv-parse": "^6.1.0",
+    "figlet": "^1.8.0",
     "fs-extra": "^11.3.0",
     "glob": "^11.0.3",
     "ignore": "^7.0.5",
     "inquirer": "^8.2.6",
     "js-yaml": "^4.1.0",
     "ora": "^5.4.1",
-    "semver": "^7.6.3"
+    "semver": "^7.6.3",
+    "wrap-ansi": "^7.0.0",
+    "xml2js": "^0.6.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.33.0",
@@ -97,7 +88,7 @@
     "yaml-lint": "^1.7.0"
   },
   "engines": {
-    "node": ">=20.10.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
     "access": "public"

package/prettier.config.mjs

@@ -1,6 +1,6 @@
 export default {
   $schema: 'https://json.schemastore.org/prettierrc',
-  printWidth: 100,
+  printWidth: 140,
   tabWidth: 2,
   useTabs: false,
   semi: true,

package/readme.md

@@ -0,0 +1,216 @@
+# BMad CORE v6 Alpha
+
+[![Version](https://img.shields.io/npm/v/bmad-method?color=blue&label=version)](https://www.npmjs.com/package/bmad-method)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
+
+**The Universal Human-AI Collaboration Platform**
+
+IMPORTANT NOTE: ALPHA is potentially an unstable release that could drastically change in many ways. While we hope that is not the case, know that it could - your using and testing it during this time though is much appreciated. Please help us out by filing issues or reaching out in Discord to discuss.
+
+IMPORTANT NOTE 2: ALPHA is not complete - there are still many small and big features, polish, doc improvements, and more agents and workflows coming ahead of the beta release!
+
+IMPORTANT NOTE 3: ALPHA Web Bundles and Agents are not fully working yet - so you will need to use a good quality IDE to test many of the features, especially with the BMad Method module. BUT - the new agent builder and stand alone agent feature can work great with weaker models - this will still evolve over the coming weeks.
+
+BMad-CORE (Collaboration Optimized Reflection Engine) is a framework that brings out the best in you through AI agents designed to enhance human thinking rather than replace it. Unlike traditional AI tools that do the work for you, BMad-CORE's specialized agents guide you through the facilitation of optimized collaborative reflective workflows to unlock your full potential across any domain. It is this magic that powers the BMad Method, which is just one of the many modules that exist or are coming soon.
+
+**[Subscribe to BMadCode on YouTube](https://www.youtube.com/@BMadCode?sub_confirmation=1)** and **[Join our amazing, active Discord Community](https://discord.gg/gk8jAdXWmj)**
+
+⭐ **If you find this project helpful or useful, please give it a star in the upper right-hand corner!** It helps others discover BMad-CORE and you will be notified of updates!
+
+## What Makes BMad-Core Different
+
+**Traditional AI**: Does the thinking for you, providing average, bland answers and solutions
+**BMad-CORE**: Brings out the best thinking in you and the AI through guided collaboration, elicitation, and facilitation
+
+### Core Philosophy: Human Amplification, Not Replacement
+
+BMad-Core's AI agents act as expert coaches, mentors, and collaborators who:
+
+- Ask the right questions to stimulate your thinking
+- Provide structured frameworks for complex problems
+- Guide you through reflective processes to discover insights
+- Help you develop mastery in your chosen domains
+- Amplify your natural abilities rather than substituting for them
+
+## The Collaboration Optimized Reflection Engine
+
+At the heart of BMad-Core lies the **C.O.R.E.** system:
+
+- **Collaboration**: Human-AI partnership where both contribute unique strengths
+- **Optimized**: The collaborative process has been refined for maximum effectiveness
+- **Reflection**: Guided thinking that helps you discover better solutions and insights
+- **Engine**: The powerful framework that orchestrates specialized agents and workflows
+
+## Universal Domain Coverage Through Modules
+
+BMad-CORE works in ANY domain through specialized modules (previously called expansion packs)!
+
+### Available Modules with Alpha Release
+
+- **BMad Core (core)**: Included and used to power every current and future module; includes a master orchestrator for the local environment and one for the web bundles used with ChatGPT or Gemini Gems, for example.
+- **BMad Method (bmm)**: Agile AI-driven software development - the classic that started it all and is still the best - but with v6, massively improved thanks to a rebuild from the ground up built on the new powerful BMad-CORE engine. The BMad Method has also been expanded to use a new "Scale Adaptive Workflow Engine"™.
+- **BMad BoMB (bmb)**: The BMad Builder is your Custom Agent, Workflow, and Module authoring tool - it's now easier than ever to customize existing modules or create whatever you can imagine as a standalone module.
+- **Creative Intelligence Suite (cis)**: Unlock innovation, problem-solving, and creative thinking! Brainstorming that was part of the BMad Method in the past is now part of this standalone module along with other workflows. The power of BMad modules still allows modules to borrow from each other - so the CIS, while standalone, also powers the brainstorming abilities for certain agents within the BMad Method!
+
+## Alpha Installation and Testing
+
+**Prerequisites**: [Node.js](https://nodejs.org) v20+ required
+
+Clone this repo ALPHA BRANCH to a folder. From the root of the folder, run `npm run install:bmad` and follow the installer questions.
+
+The Core Module will always be installed. The default initial module selection will be BMM for all the core BMad Method functionality and flow from brainstorming through software development.
+
+Note on installation: All installs now go to a single folder called `bmad` instead of multiple folders. When you install a module, you may still see folders other than the one you selected in the destination/bmad folder. This is intentional and not a bug - it will copy over to those other folders only the minimum that is needed because it is shared across the modules. For example, for now during Alpha to test this feature - BMM relies on the brainstorming feature of the CIS and some items from CORE - so this is why even if you only select BMM, you will still see bmad/core and bmad/cis along with bmad/bmm.
+
+## What's New in V6-ALPHA
+
+Stability, customizability, installation Q&A, massive prompt improvements.
+
+Everything has been rewritten from the ground up with best practices and advances learned over previous versions, standardizing on prompt format techniques. There is a lot more core usage of XML or XML-type tags within markdown, with many conventions and standards that drastically increase adherence of the agents.
+
+Customizability is a key theme of this new version. All agents are now customizable by modifying a file under the installation bmad/\_cfg/agents. Every agent installed will generate an agent file that you can customize. The nice thing about this is when agents change or update in future versions, your customizations in these sidecar files will never be lost! You can change the name, their personas, how they talk, what they call you, and most exciting - what language they communicate in!
+
+The BMad installer is 100% new from the ground up. First, along the way you will add your name (what the agents will call you and what you will author documents as), what language you want the agents to talk to you in, and every module you select will have its own set of questions to customize the experience. Also, when you install, a consolidated agent party is created so now when you use party-mode in the IDE, it is super efficient for the agent running the party to simulate all installed agents. Post alpha release, this will manifest itself in many interesting ways in time for beta - but for now, have fun with party mode and epic sprint retrospectives!
+
+Speaking of installation - everything will now install to a single core bmad folder. No more separate root folders for every module! Instead, all will be contained within bmad/.
+
+All IDE selections now support the option to add in special install functionality per module. As an example with the alpha release, if you select the BMad Method and Claude Code, you will have an option to install pre-created Claude sub-agents. Not only do they get installed, but certain workflows will have injected into their instructions key indicators to the agent when to activate the sub-agents, removing some non-determinism. The sub-agent experience is still undergoing some work, so install them if you choose, and remove them if they become a pain.
+
+Also, when you read about the BoMB below, it will link to more information about various features in this new evolution of the BMad Code - one of the exciting ones is the new agent types - there are 3 now! The most exciting, with more info coming soon, are the new standalone tiny agents that you can easily generate and deploy free from any module - specialized for your own exact needs.
+
+### BMad Method
+
+The BMad Method is significantly transforming and yet more powerful than ever. **Scale Adaptive** is a new term that means when you start the workflow to create a PRD or a GDD (or a simple tech-spec in the case of simple tasks), you will first answer some questions about the scope of the project, new vs. existing codebase and its state, and other questions. This will trigger a leveling of the effort from 0-4, and based on this scale adaptation, it will guide the workflow in different directions.
+
+Right now, this is still a bit alpha feeling and disjointed, but before beta it will be tied together through all four workflow phases with a potential single orchestration if you choose - or you can still jump right in, especially for simple tasks that just need a simple tech-spec and then right off to development.
+
+To test and experience this now, here is the new main flow for BMM v6 alpha:
+
+(Docs will be all linked in soon with new user guide and workflow diagrams coming this week)
+
+NOTE: Game Development expansion packs are all being rolled into the official BNad Method module - along with any more game engine platforms being added. Additionally game development planning for the GDD is not only scale adpative, but also adapts to the type of game you are making - so you can plan all that is needed for your dream game!
+
+#### **PHASE 1 - Analysis**
+
+**Analyst:**
+
+- `brainstorm-project`
+- `research` (market research, deep research, deep research prompt generation)
+- `product-brief`
+
+**Game Designer (Optional):**
+
+- `brainstorm-game`
+- `game-brief`
+- `research`
+
+---
+
+#### **PHASE 2 - Planning**
+
+**PM:**
+
+- `plan-project`
+
+**Game Designer:**
+
+- `plan-game` (calls the same plan-project workflow, but input docs or your answers should drive it towards GDD)
+
+---
+
+#### **PHASE 3 - Solutioning**
+
+**Architect or Game Architect:**
+
+Just like the scale-adjusted planning, architecture is the same. No more document sharding though!! Now in the IDE you create an architecture that adapts to the type of project you are working on - based on the inputs from your PRD, it will adapt the sections it includes to your project type. No longer is the architecture biased just towards full stack or back-end APIs. There are many more options now, from embedded hardware to mobile to many other options - with many more coming with beta.
+
+- `solution-architecture`
+
+> **Note:** Testing, DevOps, or security concerns beyond the basics are generally not included in the architecture. If it is more complicated, especially for complex massive undertakings, you will be suggested to pull in specific agents to help with those areas. _(Not released with alpha.0, coming soon)_
+
+Once the full architecture is complete, you can still use the PO to run the checklist to validate the epics and stories are still correct - although the architect should also be keeping them updated as needed (needs some tuning during alpha). Once done, then it's time to create the tech spec for your first epic.
+
+- `tech-spec`
+
+The tech spec pulls all technical information from all planning thus far, along with any further research needed from the web to produce an **Epic Tech Spec** - each epic will have one. This is going to make the SM even more capable of finding the info it needs for each story when we get to phase 4!!
+
+---
+
+#### **PHASE 4 - Implementation**
+
+And now here we are at phase 4 - where we, just like in BMad Method of yore, use the SM and the Dev Agent. No more QA agent here though; the dev now has a dev task and also a senior dev agent review task.
+
+**Scrum Master (SM) Tasks:**
+
+Before the dev starts, the SM will:
+
+1. `create-story`
+2. `story-context` _(NEW!)_
+
+**Story-context** is a game-changing new feature beyond what we had with create-story in the past. Create-story still pulls in all the info it needs from the tech-spec and elsewhere as needed (including previously completed stories), but the generation of the new story-context takes it up a whole new level.
+
+This real-time prep means no more generic devLoadAlways list of story files. During the alpha phase, we will be tuning what goes into this context, but this is going to supercharge and specialize your dev to the story at hand!
+
+---
+
+> **🎉 There are many other exciting changes throughout for you to discover during the alpha BMad Method module!**
+
+## CIS
+
+The CIS has 5 agents to try out, each with their own workflow! This is a new module that will drastically change over time.
+
+- [CIS Readme](./src/modules/cis/readme.md)
+
+### BoMB: BMad Builder
+
+#### Agent Docs
+
+- [Agent Architecture](src/modules/bmb/workflows/create-agent/agent-architecture)
+- [Agent command patterns](src/modules/bmb/workflows/create-agent/agent-command-patterns.md)
+- [Agent Types](src/modules/bmb/workflows/create-agent/agent-types.md)
+- [Communication Styles](src/modules/bmb/workflows/create-agent/communication-styles.md)
+
+#### Modules
+
+Modules are what we used to call Expansion Packs. A new repository to contribute modules is coming very soon with the beta release where you can start contributing modules - we just want to make sure the final format and conventions are stable. A module will generally be made up of agents and workflows. Tasks are still also possible, but generally should be avoided in favor of more flexible workflows. Workflows can have sub-workflows and soon will support a standardized multi-workflow orchestration pattern that the BMad master will be able to guide users through.
+
+- [Module Structure](src/modules/bmb/workflows/create-module/module-structure.md)
+
+#### Workflows
+
+What used to be tasks and create-doc templates are now all workflows! Simpler, yet more powerful and support many ways of achieving many different outcomes! A lot more documentation will be coming. This document is used by the agent builder to generate workflows or convert to workflows, but there is a lot more than what we have documented here in this alpha doc.
+
+- [Workflow Creation Guide](src/modules/bmb/workflows/create-workflow/workflow-creation-guide)
+
+### Installer Changes
+
+- [IDE Injections](docs/installers-bundlers/ide-injections)
+- [Installers Modules Platforms References](docs/installers-bundlers/installers-modules-platforms-reference)
+- [Web Bundler Usage](docs/installers-bundlers/web-bundler-usage)
+- [Claude Code Sub Module BMM Installer](src/modules/bmm/sub-modules/claude-code/readme.md)
+
+## Support & Community
+
+- 💬 [Discord Community](https://discord.gg/gk8jAdXWmj) - Get help, share ideas, collaborate
+- 🐛 [Issue Tracker](https://github.com/bmad-code-org/BMAD-METHOD/issues) - Bug reports and feature requests
+- 💬 [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) - Community conversations
+
+## Contributing
+
+We welcome contributions and new module development!
+
+📋 **[Read CONTRIBUTING.md](CONTRIBUTING.md)** - Complete contribution guide
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Trademark Notice
+
+BMAD™ and BMAD-METHOD™ are trademarks of BMad Code, LLC. All rights reserved.
+
+[![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
+
+<sub>Built with ❤️ for the human-AI collaboration community</sub>

package/src/core/_module-installer/install-menu-config.yaml

@@ -0,0 +1,24 @@
+# BMAD™ Core Configuration
+
+prompt:
+  - "Welcome and thank you for choosing BMAD™! This is the Core Configuration."
+  - "Core Config is personalized configuration that is git ignored."
+  - "This will impact all selected modules, either additions or upgrades."
+
+# This is injected into the custom agent activation rules
+user_name:
+  prompt: "What is your name?"
+  default: "Jane"
+  result: "{value}"
+
+# This is injected into the custom agent activation rules
+communication_language:
+  prompt: "Preferred language?"
+  default: "English"
+  result: "{value}"
+
+# This is injected into the custom agent activation rules
+output_folder:
+  prompt: "Where should the generated output default save location be?"
+  default: "docs"
+  result: "{project-root}/{value}"

package/src/core/_module-installer/installer.js

@@ -0,0 +1,68 @@
+const chalk = require('chalk');
+
+/**
+ * Core Module Installer
+ * Standard module installer function that executes after IDE installations
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-menu-config.yaml
+ * @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, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🏗️  Installing Core Module...'));
+
+    // Core agent configs are created by the main installer's createAgentConfigs method
+    // No need to create them here - they'll be handled along with all other agents
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`Configuring Core for IDEs: ${installedIDEs.join(', ')}`));
+
+      // Add any IDE-specific Core configurations here
+      for (const ide of installedIDEs) {
+        await configureForIDE(ide, projectRoot, config, logger);
+      }
+    }
+
+    logger.log(chalk.green('✓ Core Module installation complete'));
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing Core module: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Configure Core module for specific IDE
+ * @private
+ */
+async function configureForIDE(ide) {
+  // Add IDE-specific configurations here
+  switch (ide) {
+    case 'claude-code': {
+      // Claude Code specific Core configurations
+      break;
+    }
+    case 'cursor': {
+      // Cursor specific Core configurations
+      break;
+    }
+    case 'windsurf': {
+      // Windsurf specific Core configurations
+      break;
+    }
+    // Add more IDEs as needed
+    default: {
+      // No specific configuration needed
+      break;
+    }
+  }
+}
+
+module.exports = { install };

package/src/core/agents/bmad-master.md

@@ -0,0 +1,27 @@
+<!-- Powered by BMAD-CORE™ -->
+
+# BMad Master Task Executor
+
+```xml
+<agent id="bmad/core/agents/bmad-master.md" name="BMad Master" title="BMad Master Task Executor" icon="🧙">
+  <persona>
+    <role>Master Task Executor + BMad Expert</role>
+    <identity>Master-level expert in the BMAD Core Platform and all loaded modules with comprehensive knowledge of all resources, tasks, and workflows. Experienced in direct task execution and runtime resource management, serving as the primary execution engine for BMAD operations.</identity>
+    <communication_style>Direct and comprehensive, refers to himself in the 3rd person. Expert-level communication focused on efficient task execution, presenting information systematically using numbered lists with immediate command response capability.</communication_style>
+    <principles>Load resources at runtime never pre-load, and always present numbered lists for choices.</principles>
+  </persona>
+  <critical-actions>
+    <i>Load into memory {project-root}/bmad/core/config.yaml and set variable project_name, output_folder, user_name, communication_language</i>
+    <i>Remember the users name is {user_name}</i>
+    <i>ALWAYS communicate in {communication_language}</i>
+  </critical-actions>
+  <cmds>
+    <c cmd="*help">Show numbered cmd list</c>
+    <c cmd="*list-tasks" action="list all tasks from {project-root}/bmad/_cfg/task-manifest.csv">List Available Tasks</c>
+    <c cmd="*list-workflows" action="list all workflows from {project-root}/bmad/_cfg/workflow-manifest.csv">List Workflows</c>
+    <c cmd="*party-mode" run-workflow="{project-root}/bmad/core/workflows/party-mode/workflow.yaml">Group chat with all agents</c>
+    <c cmd="*bmad-init" run-workflow="{project-root}/bmad/core/workflows/bmad-init/workflow.yaml">Initialize or Update BMAD system agent manifest, customization, or workflow selection</c>
+    <c cmd="*exit">Exit with confirmation</c>
+  </cmds>
+</agent>
+```

package/src/core/agents/bmad-web-orchestrator.md

@@ -0,0 +1,71 @@
+```xml
+<agent id="bmad/core/agents/bmad-orchestrator.md" name="BMad Orchestrator" title="BMad Web Orchestrator" icon="🎭" localskip="true">
+  <activation critical="true">
+    <notice>PRIMARY OPERATING PROCEDURE - Read and follow this entire node EXACTLY</notice>
+    <steps>
+      <s>1:Read this entire XML node - this is your complete persona and operating procedure</s>
+      <s>2:Greet user as BMad Orchestrator + run *help to show available commands</s>
+      <s>3:HALT and await user commands (except if activation included specific commands to execute)</s>
+    </steps>
+    <rules>
+      <r critical="true">NO external agent files - all agents are in 'agent' XML nodes findable by id</r>
+      <r critical="true">NO external task files - all tasks are in 'task' XML nodes findable by id</r>
+      <r>Tasks are complete workflows, not references - follow exactly as written</r>
+      <r>elicit=true attributes require user interaction before proceeding</r>
+      <r>Options ALWAYS presented to users as numbered lists</r>
+      <r>STAY IN CHARACTER until *exit command received</r>
+      <r>Resource Navigation: All resources found by XML Node ID within this bundle</r>
+      <r>Execution Context: Web environment only - no file system access, use canvas if available for document drafting</r>
+    </rules>
+  </activation>
+
+  <command-resolution critical="true">
+    <rule>ONLY execute commands of the CURRENT AGENT PERSONA you are inhabiting</rule>
+    <rule>If user requests command from another agent, instruct them to switch agents first using *agents command</rule>
+    <rule>Numeric input → Execute command at cmd_map[n] of current agent</rule>
+    <rule>Text input → Fuzzy match against *cmd commands of current agent</rule>
+    <action>Extract exec, tmpl, and data attributes from matched command</action>
+    <action>Resolve ALL paths by XML node id, treating each node as complete self-contained file</action>
+    <action>Verify XML node existence BEFORE attempting execution</action>
+    <action>Show exact XML node id in any error messages</action>
+    <rule>NEVER improvise - only execute loaded XML node instructions as active agent persona</rule>
+  </command-resolution>
+
+  <execution-rules critical="true">
+    <rule>Stay in character until *exit command - then return to primary orchestrator</rule>
+    <rule>Load referenced nodes by id ONLY when user commands require specific node</rule>
+    <rule>Follow loaded instructions EXACTLY as written</rule>
+    <rule>AUTO-SAVE after EACH major section, update CANVAS if available</rule>
+    <rule>NEVER TRUNCATE output document sections</rule>
+    <rule>Process all commands starting with * immediately</rule>
+    <rule>Always remind users that commands require * prefix</rule>
+  </execution-rules>
+
+  <persona>
+    <role>Master Orchestrator + Module Expert</role>
+    <identity>Master orchestrator with deep expertise across all loaded agents and workflows. Expert at assessing user needs and recommending optimal approaches. Skilled in dynamic persona transformation and workflow guidance. Technical brilliance balanced with approachable communication.</identity>
+    <communication_style>Knowledgeable, guiding, approachable. Adapts to current persona/task context. Encouraging and efficient with clear next steps. Always explicit about active state and requirements.</communication_style>
+    <core_principles>
+      <p>Transform into any loaded agent on demand</p>
+      <p>Assess needs and recommend best agent/workflow/approach</p>
+      <p>Track current state and guide to logical next steps</p>
+      <p>When embodying specialized persona, their principles take precedence</p>
+      <p>Be explicit about active persona and current task</p>
+      <p>Present all options as numbered lists</p>
+      <p>Process * commands immediately without delay</p>
+      <p>Remind users that commands require * prefix</p>
+    </core_principles>
+  </persona>
+  <cmds>
+    <c cmd="*help">Show numbered command list for current agent</c>
+    <c cmd="*list-agents" exec="list available agents from bmad/web-manifest.xml nodes type agent">List all available agents</c>
+    <c cmd="*agents [agent]" exec="Transform into the selected agent">Transform into specific agent</c>
+    <c cmd="*list-tasks" exec="list all tasks from node bmad/web-manifest.xml nodes type task">List available tasks</c>
+    <c cmd="*list-templates" exec="list all templates from bmad/web-manifest.xml nodes type templates">List available templates</c>
+    <c cmd="*kb-mode" exec="bmad/core/tasks/kb-interact.md">Load full BMad knowledge base</c>
+    <c cmd="*party-mode" run-workflow="{project-root}/bmad/core/workflows/party-mode/workflow.yaml">Group chat with all agents</c>
+    <c cmd="*yolo">Toggle skip confirmations mode</c>
+    <c cmd="*exit">Return to BMad Orchestrator or exit session</c>
+  </cmds>
+</agent>
+```

package/src/core/tasks/adv-elicit-methods.csv

@@ -0,0 +1,39 @@
+category,method_name,description,output_pattern
+advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches where finding the optimal path matters,paths → evaluation → selection
+advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns in complex multi-factor situations,nodes → connections → patterns
+advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency in lengthy analyses,context → thread → synthesis
+advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification and consensus building matter,approaches → comparison → consensus
+advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving strategies,current → analysis → optimization
+advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making tasks,model → planning → strategy
+collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
+collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
+competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions through adversarial thinking,defense → attack → hardening
+core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - essential when content needs to match specific reader capabilities,audience → adjustments → refined content
+core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts needing polish and enhancement,strengths/weaknesses → improvements → refined version
+core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency and helping others understand complex logic,steps → logic → conclusion
+core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving seemingly impossible problems,assumptions → truths → new approach
+core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures and fixing problems at their source,why chain → root cause → solution
+core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and helping others reach insights themselves,questions → revelations → understanding
+creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding how to reach specific endpoints,end state → steps backward → path forward
+creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and creative exploration,scenarios → implications → insights
+creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation and improvement,S→C→A→M→P→E→R
+learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding and excellent for knowledge transfer,complex → simple → gaps → mastery
+learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps and reinforcing mastery,test → gaps → reinforcement
+narrative,Unreliable Narrator Mode,Question assumptions and biases by adopting skeptical perspective - crucial for detecting hidden agendas and finding balanced truth,perspective → biases → balanced view
+optimization,Speedrun Optimization,Find the fastest most efficient path by eliminating waste - perfect when time pressure demands maximum efficiency,current → bottlenecks → optimized
+optimization,New Game Plus,Revisit challenges with enhanced capabilities from prior experience - excellent for iterative improvement and mastery building,initial → enhanced → improved
+optimization,Roguelike Permadeath,Treat decisions as irreversible to force careful high-stakes analysis - ideal for critical decisions with no second chances,decision → consequences → execution
+philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging and theory selection,options → simplification → selection
+philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and making difficult ethical decisions,dilemma → analysis → decision
+quantum,Observer Effect Consideration,Analyze how the act of measurement changes what's being measured - important for understanding metrics impact and self-aware systems,unmeasured → observation → impact
+retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews and extracting wisdom from experience,future view → insights → application
+retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for knowledge transfer and continuous improvement,experience → lessons → actions
+risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
+risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink and building robust solutions,assumptions → challenges → strengthening
+risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
+risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
+scientific,Peer Review Simulation,Apply rigorous academic evaluation standards - ensures quality through methodology review and critical assessment,methodology → analysis → recommendations
+scientific,Reproducibility Check,Verify results can be replicated independently - fundamental for reliability and scientific validity,method → replication → validation
+structural,Dependency Mapping,Visualize interconnections to understand requirements and impacts - essential for complex systems and integration planning,components → dependencies → impacts
+structural,Information Architecture Review,Optimize organization and hierarchy for better user experience - crucial for fixing navigation and findability problems,current → pain points → restructure
+structural,Skeleton of Thought,Create structure first then expand branches in parallel - efficient for generating long content quickly with good organization,skeleton → branches → integration