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

package/tools/cli/lib/yaml-xml-builder.js

@@ -342,14 +342,15 @@ class YamlXmlBuilder {
   /**
    * Build menu XML section (renamed from commands for clarity)
    * Auto-injects *help and *exit, adds * prefix to all triggers
+   * Supports both legacy format and new multi format with nested handlers
    * @param {Array} menuItems - Menu items from YAML
    * @param {boolean} forWebBundle - Whether building for web bundle
    */
   buildCommandsXml(menuItems, forWebBundle = false) {
     let xml = '  <menu>\n';
 
-    // Always inject *help first
-    xml += `    <item cmd="*help">Show numbered menu</item>\n`;
+    // Always inject menu display option first
+    xml += `    <item cmd="*menu">[M] Redisplay Menu Options</item>\n`;
 
     // Add user-defined menu items with * prefix
     if (menuItems && menuItems.length > 0) {
@@ -362,42 +363,140 @@ class YamlXmlBuilder {
         if (!forWebBundle && item['web-only'] === true) {
           continue;
         }
-        // Build command attributes - add * prefix if not present
-        let trigger = item.trigger || '';
-        if (!trigger.startsWith('*')) {
-          trigger = '*' + trigger;
+
+        // Handle multi format menu items with nested handlers
+        if (item.multi && item.triggers && Array.isArray(item.triggers)) {
+          xml += `    <item type="multi">${this.escapeXml(item.multi)}\n`;
+          xml += this.buildNestedHandlers(item.triggers);
+          xml += `    </item>\n`;
         }
+        // Handle legacy format menu items
+        else if (item.trigger) {
+          // For legacy items, keep using cmd with *<trigger> format
+          let trigger = item.trigger || '';
+          if (!trigger.startsWith('*')) {
+            trigger = '*' + trigger;
+          }
 
-        const attrs = [`cmd="${trigger}"`];
+          const attrs = [`cmd="${trigger}"`];
 
-        // Add handler attributes
-        // If workflow-install exists, use its value for workflow attribute (vendoring)
-        // workflow-install is build-time metadata - tells installer where to copy workflows
-        // The final XML should only have workflow pointing to the install location
-        if (item['workflow-install']) {
-          attrs.push(`workflow="${item['workflow-install']}"`);
-        } else if (item.workflow) {
-          attrs.push(`workflow="${item.workflow}"`);
-        }
+          // Add handler attributes
+          // If workflow-install exists, use its value for workflow attribute (vendoring)
+          // workflow-install is build-time metadata - tells installer where to copy workflows
+          // The final XML should only have workflow pointing to the install location
+          if (item['workflow-install']) {
+            attrs.push(`workflow="${item['workflow-install']}"`);
+          } else if (item.workflow) {
+            attrs.push(`workflow="${item.workflow}"`);
+          }
 
-        if (item['validate-workflow']) attrs.push(`validate-workflow="${item['validate-workflow']}"`);
-        if (item.exec) attrs.push(`exec="${item.exec}"`);
-        if (item.tmpl) attrs.push(`tmpl="${item.tmpl}"`);
-        if (item.data) attrs.push(`data="${item.data}"`);
-        if (item.action) attrs.push(`action="${item.action}"`);
+          if (item['validate-workflow']) attrs.push(`validate-workflow="${item['validate-workflow']}"`);
+          if (item.exec) attrs.push(`exec="${item.exec}"`);
+          if (item.tmpl) attrs.push(`tmpl="${item.tmpl}"`);
+          if (item.data) attrs.push(`data="${item.data}"`);
+          if (item.action) attrs.push(`action="${item.action}"`);
 
-        xml += `    <item ${attrs.join(' ')}>${this.escapeXml(item.description || '')}</item>\n`;
+          xml += `    <item ${attrs.join(' ')}>${this.escapeXml(item.description || '')}</item>\n`;
+        }
       }
     }
 
-    // Always inject *exit last
-    xml += `    <item cmd="*exit">Exit with confirmation</item>\n`;
+    // Always inject dismiss last
+    xml += `    <item cmd="*dismiss">[D] Dismiss Agent</item>\n`;
 
     xml += '  </menu>\n';
 
     return xml;
   }
 
+  /**
+   * Build nested handlers for multi format menu items
+   * @param {Array} triggers - Triggers array from multi format
+   * @returns {string} Handler XML
+   */
+  buildNestedHandlers(triggers) {
+    let xml = '';
+
+    for (const triggerGroup of triggers) {
+      for (const [triggerName, execArray] of Object.entries(triggerGroup)) {
+        // Build trigger with * prefix
+        let trigger = triggerName.startsWith('*') ? triggerName : '*' + triggerName;
+
+        // Extract the relevant execution data
+        const execData = this.processExecArray(execArray);
+
+        // For nested handlers in multi items, we don't need cmd attribute
+        // The match attribute will handle fuzzy matching
+        const attrs = [`match="${this.escapeXml(execData.description || '')}"`];
+
+        // Add handler attributes based on exec data
+        if (execData.route) attrs.push(`exec="${execData.route}"`);
+        if (execData.workflow) attrs.push(`workflow="${execData.workflow}"`);
+        if (execData['validate-workflow']) attrs.push(`validate-workflow="${execData['validate-workflow']}"`);
+        if (execData.action) attrs.push(`action="${execData.action}"`);
+        if (execData.data) attrs.push(`data="${execData.data}"`);
+        if (execData.tmpl) attrs.push(`tmpl="${execData.tmpl}"`);
+        // Only add type if it's not 'exec' (exec is already implied by the exec attribute)
+        if (execData.type && execData.type !== 'exec') attrs.push(`type="${execData.type}"`);
+
+        xml += `      <handler ${attrs.join(' ')}></handler>\n`;
+      }
+    }
+
+    return xml;
+  }
+
+  /**
+   * Process the execution array from multi format triggers
+   * Extracts relevant data for XML attributes
+   * @param {Array} execArray - Array of execution objects
+   * @returns {Object} Processed execution data
+   */
+  processExecArray(execArray) {
+    const result = {
+      description: '',
+      route: null,
+      workflow: null,
+      data: null,
+      action: null,
+      type: null,
+    };
+
+    if (!Array.isArray(execArray)) {
+      return result;
+    }
+
+    for (const exec of execArray) {
+      if (exec.input) {
+        // Use input as description if no explicit description is provided
+        result.description = exec.input;
+      }
+
+      if (exec.route) {
+        // Determine if it's a workflow or exec based on file extension or context
+        if (exec.route.endsWith('.yaml') || exec.route.endsWith('.yml')) {
+          result.workflow = exec.route;
+        } else {
+          result.route = exec.route;
+        }
+      }
+
+      if (exec.data !== null && exec.data !== undefined) {
+        result.data = exec.data;
+      }
+
+      if (exec.action) {
+        result.action = exec.action;
+      }
+
+      if (exec.type) {
+        result.type = exec.type;
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Escape XML special characters
    */

package/tools/platform-codes.yaml

@@ -55,6 +55,12 @@ platforms:
     category: ide
     description: "Enhanced Cline fork"
 
+  rovo:
+    name: "Rovo Dev"
+    preferred: false
+    category: ide
+    description: "Atlassian's AI coding assistant"
+
   github-copilot:
     name: "GitHub Copilot"
     preferred: false
@@ -97,6 +103,12 @@ platforms:
     category: ide
     description: "AI development assistant"
 
+  antigravity:
+    name: "Google Antigravity"
+    preferred: false
+    category: ide
+    description: "Google's AI development environment"
+
   trae:
     name: "Trae"
     preferred: false

package/tools/schema/agent.js

@@ -2,7 +2,7 @@
 const assert = require('node:assert');
 const { z } = require('zod');
 
-const COMMAND_TARGET_KEYS = ['workflow', 'validate-workflow', 'exec', 'action', 'tmpl', 'data', 'run-workflow'];
+const COMMAND_TARGET_KEYS = ['workflow', 'validate-workflow', 'exec', 'action', 'tmpl', 'data'];
 const TRIGGER_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 // Public API ---------------------------------------------------------------
@@ -49,30 +49,70 @@ function agentSchema(options = {}) {
 
         let index = 0;
         for (const item of value.agent.menu) {
-          const triggerValue = item.trigger;
+          // Handle legacy format with trigger field
+          if (item.trigger) {
+            const triggerValue = item.trigger;
 
-          if (!TRIGGER_PATTERN.test(triggerValue)) {
-            ctx.addIssue({
-              code: 'custom',
-              path: ['agent', 'menu', index, 'trigger'],
-              message: 'agent.menu[].trigger must be kebab-case (lowercase words separated by hyphen)',
-            });
-            return;
+            if (!TRIGGER_PATTERN.test(triggerValue)) {
+              ctx.addIssue({
+                code: 'custom',
+                path: ['agent', 'menu', index, 'trigger'],
+                message: 'agent.menu[].trigger must be kebab-case (lowercase words separated by hyphen)',
+              });
+              return;
+            }
+
+            if (seenTriggers.has(triggerValue)) {
+              ctx.addIssue({
+                code: 'custom',
+                path: ['agent', 'menu', index, 'trigger'],
+                message: `agent.menu[].trigger duplicates "${triggerValue}" within the same agent`,
+              });
+              return;
+            }
+
+            seenTriggers.add(triggerValue);
           }
+          // Handle multi format with triggers array (new format)
+          else if (item.triggers && Array.isArray(item.triggers)) {
+            for (const triggerGroup of item.triggers) {
+              for (const triggerKey of Object.keys(triggerGroup)) {
+                if (!TRIGGER_PATTERN.test(triggerKey)) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    path: ['agent', 'menu', index, 'triggers'],
+                    message: `agent.menu[].triggers key must be kebab-case (lowercase words separated by hyphen) - got "${triggerKey}"`,
+                  });
+                  return;
+                }
 
-          if (seenTriggers.has(triggerValue)) {
-            ctx.addIssue({
-              code: 'custom',
-              path: ['agent', 'menu', index, 'trigger'],
-              message: `agent.menu[].trigger duplicates "${triggerValue}" within the same agent`,
-            });
-            return;
+                if (seenTriggers.has(triggerKey)) {
+                  ctx.addIssue({
+                    code: 'custom',
+                    path: ['agent', 'menu', index, 'triggers'],
+                    message: `agent.menu[].triggers key duplicates "${triggerKey}" within the same agent`,
+                  });
+                  return;
+                }
+
+                seenTriggers.add(triggerKey);
+              }
+            }
           }
 
-          seenTriggers.add(triggerValue);
           index += 1;
         }
       })
+      // Refinement: suggest conversational_knowledge when discussion is true
+      .superRefine((value, ctx) => {
+        if (value.agent.discussion === true && !value.agent.conversational_knowledge) {
+          ctx.addIssue({
+            code: 'custom',
+            path: ['agent', 'conversational_knowledge'],
+            message: 'It is recommended to include conversational_knowledge when discussion is true',
+          });
+        }
+      })
   );
 }
 
@@ -89,6 +129,8 @@ function buildAgentSchema(expectedModule) {
       menu: z.array(buildMenuItemSchema()).min(1, { message: 'agent.menu must include at least one entry' }),
       prompts: z.array(buildPromptSchema()).optional(),
       webskip: z.boolean().optional(),
+      discussion: z.boolean().optional(),
+      conversational_knowledge: z.array(z.object({}).passthrough()).min(1).optional(),
     })
     .strict();
 }
@@ -167,9 +209,11 @@ function buildPromptSchema() {
 
 /**
  * Schema for individual menu entries ensuring they are actionable.
+ * Supports both legacy format and new multi format.
  */
 function buildMenuItemSchema() {
-  return z
+  // Legacy menu item format
+  const legacyMenuItemSchema = z
     .object({
       trigger: createNonEmptyString('agent.menu[].trigger'),
       description: createNonEmptyString('agent.menu[].description'),
@@ -179,12 +223,12 @@ function buildMenuItemSchema() {
       exec: createNonEmptyString('agent.menu[].exec').optional(),
       action: createNonEmptyString('agent.menu[].action').optional(),
       tmpl: createNonEmptyString('agent.menu[].tmpl').optional(),
-      data: createNonEmptyString('agent.menu[].data').optional(),
-      'run-workflow': createNonEmptyString('agent.menu[].run-workflow').optional(),
+      data: z.string().optional(),
       checklist: createNonEmptyString('agent.menu[].checklist').optional(),
       document: createNonEmptyString('agent.menu[].document').optional(),
       'ide-only': z.boolean().optional(),
       'web-only': z.boolean().optional(),
+      discussion: z.boolean().optional(),
     })
     .strict()
     .superRefine((value, ctx) => {
@@ -200,6 +244,111 @@ function buildMenuItemSchema() {
         });
       }
     });
+
+  // Multi menu item format
+  const multiMenuItemSchema = z
+    .object({
+      multi: createNonEmptyString('agent.menu[].multi'),
+      triggers: z
+        .array(z.object({}).passthrough())
+        .refine(
+          (triggers) => {
+            // Each item in triggers array should be an object with exactly one key
+            for (const trigger of triggers) {
+              const keys = Object.keys(trigger);
+              if (keys.length !== 1) {
+                return false;
+              }
+
+              const execArray = trigger[keys[0]];
+              if (!Array.isArray(execArray)) {
+                return false;
+              }
+
+              // Check required fields
+              const hasInput = execArray.some((item) => 'input' in item);
+              const hasRouteOrAction = execArray.some((item) => 'route' in item || 'action' in item);
+
+              if (!hasInput) {
+                return false;
+              }
+
+              // If not TODO, must have route or action
+              const isTodo = execArray.some((item) => item.route === 'TODO' || item.action === 'TODO');
+              if (!isTodo && !hasRouteOrAction) {
+                return false;
+              }
+            }
+            return true;
+          },
+          {
+            message: 'agent.menu[].triggers must be an array of trigger objects with input and either route/action or TODO',
+          },
+        )
+        .transform((triggers) => {
+          // Validate and clean up the triggers
+          for (const trigger of triggers) {
+            const keys = Object.keys(trigger);
+            if (keys.length !== 1) {
+              throw new Error('Each trigger object must have exactly one key');
+            }
+
+            const execArray = trigger[keys[0]];
+            if (!Array.isArray(execArray)) {
+              throw new TypeError(`Trigger "${keys[0]}" must be an array`);
+            }
+
+            // Validate each item in the exec array
+            for (const item of execArray) {
+              if ('input' in item && typeof item.input !== 'string') {
+                throw new Error('Input must be a string');
+              }
+              if ('route' in item && typeof item.route !== 'string' && item.route !== 'TODO') {
+                throw new Error('Route must be a string or TODO');
+              }
+              if ('type' in item && !['exec', 'action', 'workflow', 'TODO'].includes(item.type)) {
+                throw new Error('Type must be one of: exec, action, workflow, TODO');
+              }
+            }
+          }
+          return triggers;
+        }),
+      discussion: z.boolean().optional(),
+    })
+    .strict()
+    .superRefine((value, ctx) => {
+      // Extract all trigger keys for validation
+      const triggerKeys = [];
+      for (const triggerGroup of value.triggers) {
+        for (const key of Object.keys(triggerGroup)) {
+          triggerKeys.push(key);
+
+          // Validate trigger key format
+          if (!TRIGGER_PATTERN.test(key)) {
+            ctx.addIssue({
+              code: 'custom',
+              path: ['agent', 'menu', 'triggers'],
+              message: `Trigger key "${key}" must be kebab-case (lowercase words separated by hyphen)`,
+            });
+          }
+        }
+      }
+
+      // Check for duplicates
+      const seenTriggers = new Set();
+      for (const triggerKey of triggerKeys) {
+        if (seenTriggers.has(triggerKey)) {
+          ctx.addIssue({
+            code: 'custom',
+            path: ['agent', 'menu', 'triggers'],
+            message: `Trigger key "${triggerKey}" is duplicated`,
+          });
+        }
+        seenTriggers.add(triggerKey);
+      }
+    });
+
+  return z.union([legacyMenuItemSchema, multiMenuItemSchema]);
 }
 
 /**

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

@@ -1,39 +0,0 @@
-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