bmad-method 6.0.0-alpha.16 → 6.0.0-alpha.18

package/tools/cli/lib/activation-builder.js

@@ -7,13 +7,13 @@ const { getSourcePath } = require('./project-root');
  */
 class ActivationBuilder {
   constructor() {
-    this.fragmentsDir = getSourcePath('utility', 'models', 'fragments');
+    this.agentComponents = getSourcePath('utility', 'agent-components');
     this.fragmentCache = new Map();
   }
 
   /**
    * Load a fragment file
-   * @param {string} fragmentName - Name of fragment file (e.g., 'activation-init.xml')
+   * @param {string} fragmentName - Name of fragment file (e.g., 'activation-init.txt')
    * @returns {string} Fragment content
    */
   async loadFragment(fragmentName) {
@@ -22,7 +22,7 @@ class ActivationBuilder {
       return this.fragmentCache.get(fragmentName);
     }
 
-    const fragmentPath = path.join(this.fragmentsDir, fragmentName);
+    const fragmentPath = path.join(this.agentComponents, fragmentName);
 
     if (!(await fs.pathExists(fragmentPath))) {
       throw new Error(`Fragment not found: ${fragmentName}`);
@@ -49,7 +49,7 @@ class ActivationBuilder {
     activation += this.indent(steps, 2) + '\n';
 
     // 2. Build menu handlers section with dynamic handlers
-    const menuHandlers = await this.loadFragment('menu-handlers.xml');
+    const menuHandlers = await this.loadFragment('menu-handlers.txt');
 
     // Build handlers (load only needed handlers)
     const handlers = await this.buildHandlers(profile);
@@ -63,11 +63,8 @@ class ActivationBuilder {
 
     activation += '\n' + this.indent(processedHandlers, 2) + '\n';
 
-    // 3. Include rules (skip for web bundles as they're in web-bundle-activation-steps.xml)
-    if (!forWebBundle) {
-      const rules = await this.loadFragment('activation-rules.xml');
-      activation += this.indent(rules, 2) + '\n';
-    }
+    const rules = await this.loadFragment('activation-rules.txt');
+    activation += this.indent(rules, 2) + '\n';
 
     activation += '</activation>';
 
@@ -83,7 +80,7 @@ class ActivationBuilder {
     const handlerFragments = [];
 
     for (const attrType of profile.usedAttributes) {
-      const fragmentName = `handler-${attrType}.xml`;
+      const fragmentName = `handler-${attrType}.txt`;
       try {
         const handler = await this.loadFragment(fragmentName);
         handlerFragments.push(handler);
@@ -103,9 +100,7 @@ class ActivationBuilder {
    * @returns {string} Steps XML
    */
   async buildSteps(metadata = {}, agentSpecificActions = [], forWebBundle = false) {
-    // Use web-specific fragment for web bundles, standard fragment otherwise
-    const fragmentName = forWebBundle ? 'web-bundle-activation-steps.xml' : 'activation-steps.xml';
-    const stepsTemplate = await this.loadFragment(fragmentName);
+    const stepsTemplate = await this.loadFragment('activation-steps.txt');
 
     // Extract basename from agent ID (e.g., "bmad/bmm/agents/pm.md" → "pm")
     const agentBasename = metadata.id ? metadata.id.split('/').pop().replace('.md', '') : metadata.name || 'agent';

package/tools/cli/lib/agent/compiler.js

@@ -8,22 +8,9 @@ const yaml = require('yaml');
 const fs = require('node:fs');
 const path = require('node:path');
 const { processAgentYaml, extractInstallConfig, stripInstallConfig, getDefaultValues } = require('./template-engine');
-
-// Use existing BMAD builder if available
-let YamlXmlBuilder;
-try {
-  YamlXmlBuilder = require('../../lib/yaml-xml-builder').YamlXmlBuilder;
-} catch {
-  YamlXmlBuilder = null;
-}
-
-/**
- * Escape XML special characters
- */
-function escapeXml(text) {
-  if (!text) return '';
-  return text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&apos;');
-}
+const { escapeXml } = require('../../../lib/xml-utils');
+const { ActivationBuilder } = require('../activation-builder');
+const { AgentAnalyzer } = require('../agent-analyzer');
 
 /**
  * Build frontmatter for agent
@@ -45,137 +32,7 @@ You must fully embody this agent's persona and follow all activation instruction
 `;
 }
 
-/**
- * Build simple activation block for custom agents
- * @param {Array} criticalActions - Agent-specific critical actions
- * @param {Array} menuItems - Menu items to determine which handlers to include
- * @param {string} deploymentType - 'ide' or 'web' - filters commands based on ide-only/web-only flags
- * @returns {string} Activation XML
- */
-function buildSimpleActivation(criticalActions = [], menuItems = [], deploymentType = 'ide') {
-  let activation = '<activation critical="MANDATORY">\n';
-
-  let stepNum = 1;
-
-  // Standard steps
-  activation += `  <step n="${stepNum++}">Load persona from this current agent file (already in context)</step>\n`;
-  activation += `  <step n="${stepNum++}">Load and read {project-root}/.bmad/core/config.yaml to get {user_name}, {communication_language}, {output_folder}</step>\n`;
-  activation += `  <step n="${stepNum++}">Remember: user's name is {user_name}</step>\n`;
-
-  // Agent-specific steps from critical_actions
-  for (const action of criticalActions) {
-    activation += `  <step n="${stepNum++}">${action}</step>\n`;
-  }
-
-  // Menu and interaction steps
-  activation += `  <step n="${stepNum++}">ALWAYS communicate in {communication_language}</step>\n`;
-  activation += `  <step n="${stepNum++}">Show greeting using {user_name} from config, communicate in {communication_language}, then display numbered list of
-      ALL menu items from menu section</step>\n`;
-  activation += `  <step n="${stepNum++}">STOP and WAIT for user input - do NOT execute menu items automatically - accept number or cmd trigger or fuzzy command
-      match</step>\n`;
-  activation += `  <step n="${stepNum++}">On user input: Number → execute menu item[n] | Text → case-insensitive substring match | Multiple matches → ask user
-      to clarify | No match → show "Not recognized"</step>\n`;
-
-  // Filter menu items based on deployment type
-  const filteredMenuItems = menuItems.filter((item) => {
-    // Skip web-only commands for IDE deployment
-    if (deploymentType === 'ide' && item['web-only'] === true) {
-      return false;
-    }
-    // Skip ide-only commands for web deployment
-    if (deploymentType === 'web' && item['ide-only'] === true) {
-      return false;
-    }
-    return true;
-  });
-
-  // Detect which handlers are actually used in the filtered menu
-  const usedHandlers = new Set();
-  for (const item of filteredMenuItems) {
-    if (item.action) usedHandlers.add('action');
-    if (item.workflow) usedHandlers.add('workflow');
-    if (item.exec) usedHandlers.add('exec');
-    if (item.tmpl) usedHandlers.add('tmpl');
-    if (item.data) usedHandlers.add('data');
-    if (item['validate-workflow']) usedHandlers.add('validate-workflow');
-  }
-
-  // Only include menu-handlers section if handlers are used
-  if (usedHandlers.size > 0) {
-    activation += `  <step n="${stepNum++}">When executing a menu item: Check menu-handlers section below - extract any attributes from the selected menu item and follow the corresponding handler instructions</step>\n`;
-
-    // Menu handlers - only include what's used
-    activation += `
-  <menu-handlers>
-    <handlers>\n`;
-
-    if (usedHandlers.has('action')) {
-      activation += `      <handler type="action">
-        When menu item has: action="#id" → Find prompt with id="id" in current agent XML, execute its content
-        When menu item has: action="text" → Execute the text directly as an inline instruction
-      </handler>\n`;
-    }
-
-    if (usedHandlers.has('workflow')) {
-      activation += `      <handler type="workflow">
-        When menu item has: workflow="path/to/workflow.yaml"
-        1. CRITICAL: Always LOAD {project-root}/.bmad/core/tasks/workflow.xml
-        2. Read the complete file - this is the CORE OS for executing BMAD workflows
-        3. Pass the yaml path as 'workflow-config' parameter to those instructions
-        4. Execute workflow.xml instructions precisely following all steps
-        5. Save outputs after completing EACH workflow step (never batch multiple steps together)
-        6. If workflow.yaml path is "todo", inform user the workflow hasn't been implemented yet
-      </handler>\n`;
-    }
-
-    if (usedHandlers.has('exec')) {
-      activation += `      <handler type="exec">
-        When menu item has: exec="command" → Execute the command directly
-      </handler>\n`;
-    }
-
-    if (usedHandlers.has('tmpl')) {
-      activation += `      <handler type="tmpl">
-        When menu item has: tmpl="template-path" → Load and apply the template
-      </handler>\n`;
-    }
-
-    if (usedHandlers.has('data')) {
-      activation += `      <handler type="data">
-        When menu item has: data="path/to/x.json|yaml|yml"
-        Load the file, parse as JSON/YAML, make available as {data} to subsequent operations
-      </handler>\n`;
-    }
-
-    if (usedHandlers.has('validate-workflow')) {
-      activation += `      <handler type="validate-workflow">
-        When menu item has: validate-workflow="path/to/workflow.yaml"
-        1. CRITICAL: Always LOAD {project-root}/.bmad/core/tasks/validate-workflow.xml
-        2. Read the complete file - this is the CORE OS for validating BMAD workflows
-        3. Pass the workflow.yaml path as 'workflow' parameter to those instructions
-        4. Pass any checklist.md from the workflow location as 'checklist' parameter if available
-        5. Execute validate-workflow.xml instructions precisely following all steps
-        6. Generate validation report with thorough analysis
-      </handler>\n`;
-    }
-
-    activation += `    </handlers>
-  </menu-handlers>\n`;
-  }
-
-  activation += `
-  <rules>
-    - ALWAYS communicate in {communication_language} UNLESS contradicted by communication_style
-    - Stay in character until exit selected
-    - Menu triggers use asterisk (*) - NOT markdown, display exactly as shown
-    - Number all lists, use letters for sub-options
-    - Load files ONLY when executing menu items or a workflow or command requires it. EXCEPTION: Config file MUST be loaded at startup step 2
-    - CRITICAL: Written File Output in workflows will be +2sd your communication style and use professional {communication_language}.
-  </rules>
-</activation>\n`;
-
-  return activation;
-}
+// buildSimpleActivation function removed - replaced by ActivationBuilder for proper fragment loading from src/utility/agent-components/
 
 /**
  * Build persona XML section
@@ -241,6 +98,25 @@ function buildPromptsXml(prompts) {
   return xml;
 }
 
+/**
+ * Build memories XML section
+ * @param {Array} memories - Memories array
+ * @returns {string} Memories XML
+ */
+function buildMemoriesXml(memories) {
+  if (!memories || memories.length === 0) return '';
+
+  let xml = '  <memories>\n';
+
+  for (const memory of memories) {
+    xml += `    <memory>${escapeXml(String(memory))}</memory>\n`;
+  }
+
+  xml += '  </memories>\n';
+
+  return xml;
+}
+
 /**
  * Build menu XML section
  * Supports both legacy and multi format menu items
@@ -385,9 +261,9 @@ function processExecArray(execArray) {
  * @param {Object} agentYaml - Parsed and processed agent YAML
  * @param {string} agentName - Final agent name (for ID and frontmatter)
  * @param {string} targetPath - Target path for agent ID
- * @returns {string} Compiled XML string with frontmatter
+ * @returns {Promise<string>} Compiled XML string with frontmatter
  */
-function compileToXml(agentYaml, agentName = '', targetPath = '') {
+async function compileToXml(agentYaml, agentName = '', targetPath = '') {
   const agent = agentYaml.agent;
   const meta = agent.metadata;
 
@@ -409,8 +285,16 @@ function compileToXml(agentYaml, agentName = '', targetPath = '') {
 
   xml += `<agent ${agentAttrs.join(' ')}>\n`;
 
-  // Activation block - pass menu items and deployment type to determine which handlers to include
-  xml += buildSimpleActivation(agent.critical_actions || [], agent.menu || [], 'ide');
+  // Activation block - use ActivationBuilder for proper fragment loading
+  const activationBuilder = new ActivationBuilder();
+  const analyzer = new AgentAnalyzer();
+  const profile = analyzer.analyzeAgentObject(agentYaml);
+  xml += await activationBuilder.buildActivation(
+    profile,
+    meta,
+    agent.critical_actions || [],
+    false, // forWebBundle - set to false for IDE deployment
+  );
 
   // Persona section
   xml += buildPersonaXml(agent.persona);
@@ -420,6 +304,11 @@ function compileToXml(agentYaml, agentName = '', targetPath = '') {
     xml += buildPromptsXml(agent.prompts);
   }
 
+  // Memories section (if present)
+  if (agent.memories && agent.memories.length > 0) {
+    xml += buildMemoriesXml(agent.memories);
+  }
+
   // Menu section
   xml += buildMenuXml(agent.menu || []);
 
@@ -439,15 +328,98 @@ function compileToXml(agentYaml, agentName = '', targetPath = '') {
  * @param {string} agentName - Optional final agent name (user's custom persona name)
  * @param {string} targetPath - Optional target path for agent ID
  * @param {Object} options - Additional options including config
- * @returns {Object} { xml: string, metadata: Object }
+ * @returns {Promise<Object>} { xml: string, metadata: Object }
  */
-function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = '', options = {}) {
+async function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = '', options = {}) {
   // Parse YAML
-  const agentYaml = yaml.parse(yamlContent);
+  let agentYaml = yaml.parse(yamlContent);
+
+  // Apply customization merges before template processing
+  // Handle metadata overrides (like name)
+  if (answers.metadata) {
+    // Filter out empty values from metadata
+    const filteredMetadata = filterCustomizationData(answers.metadata);
+    if (Object.keys(filteredMetadata).length > 0) {
+      agentYaml.agent.metadata = { ...agentYaml.agent.metadata, ...filteredMetadata };
+    }
+    // Remove from answers so it doesn't get processed as template variables
+    const { metadata, ...templateAnswers } = answers;
+    answers = templateAnswers;
+  }
+
+  // Handle other customization properties
+  // These should be merged into the agent structure, not processed as template variables
+  const customizationKeys = ['persona', 'critical_actions', 'memories', 'menu', 'prompts'];
+  const customizations = {};
+  const remainingAnswers = { ...answers };
+
+  for (const key of customizationKeys) {
+    if (answers[key]) {
+      let filtered;
+
+      // Handle different data types
+      if (Array.isArray(answers[key])) {
+        // For arrays, filter out empty/null/undefined values
+        filtered = answers[key].filter((item) => item !== null && item !== undefined && item !== '');
+      } else {
+        // For objects, use filterCustomizationData
+        filtered = filterCustomizationData(answers[key]);
+      }
+
+      // Check if we have valid content
+      const hasContent = Array.isArray(filtered) ? filtered.length > 0 : Object.keys(filtered).length > 0;
+
+      if (hasContent) {
+        customizations[key] = filtered;
+      }
+      delete remainingAnswers[key];
+    }
+  }
 
-  // Note: agentName parameter is for UI display only, not for modifying the YAML
-  // The persona name (metadata.name) should always come from the YAML file
-  // We should NEVER modify metadata.name as it's part of the agent's identity
+  // Merge customizations into agentYaml
+  if (Object.keys(customizations).length > 0) {
+    // For persona: replace entire section
+    if (customizations.persona) {
+      agentYaml.agent.persona = customizations.persona;
+    }
+
+    // For critical_actions: append to existing or create new
+    if (customizations.critical_actions) {
+      const existing = agentYaml.agent.critical_actions || [];
+      agentYaml.agent.critical_actions = [...existing, ...customizations.critical_actions];
+    }
+
+    // For memories: append to existing or create new
+    if (customizations.memories) {
+      const existing = agentYaml.agent.memories || [];
+      agentYaml.agent.memories = [...existing, ...customizations.memories];
+    }
+
+    // For menu: append to existing or create new
+    if (customizations.menu) {
+      const existing = agentYaml.agent.menu || [];
+      agentYaml.agent.menu = [...existing, ...customizations.menu];
+    }
+
+    // For prompts: append to existing or create new (by id)
+    if (customizations.prompts) {
+      const existing = agentYaml.agent.prompts || [];
+      // Merge by id, with customizations taking precedence
+      const mergedPrompts = [...existing];
+      for (const customPrompt of customizations.prompts) {
+        const existingIndex = mergedPrompts.findIndex((p) => p.id === customPrompt.id);
+        if (existingIndex === -1) {
+          mergedPrompts.push(customPrompt);
+        } else {
+          mergedPrompts[existingIndex] = customPrompt;
+        }
+      }
+      agentYaml.agent.prompts = mergedPrompts;
+    }
+  }
+
+  // Use remaining answers for template processing
+  answers = remainingAnswers;
 
   // Extract install_config
   const installConfig = extractInstallConfig(agentYaml);
@@ -459,21 +431,17 @@ function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = ''
     finalAnswers = { ...defaults, ...answers };
   }
 
-  // Add agent_sidecar_folder to answers if provided in config
-  if (options.config && options.config.agent_sidecar_folder) {
-    finalAnswers.agent_sidecar_folder = options.config.agent_sidecar_folder;
-  }
-
   // Process templates with answers
   const processedYaml = processAgentYaml(agentYaml, finalAnswers);
 
   // Strip install_config from output
   const cleanYaml = stripInstallConfig(processedYaml);
 
-  // Replace {agent_sidecar_folder} in XML content
-  let xml = compileToXml(cleanYaml, agentName, targetPath);
-  if (finalAnswers.agent_sidecar_folder) {
-    xml = xml.replaceAll('{agent_sidecar_folder}', finalAnswers.agent_sidecar_folder);
+  let xml = await compileToXml(cleanYaml, agentName, targetPath);
+
+  // Ensure xml is a string before attempting replaceAll
+  if (typeof xml !== 'string') {
+    throw new TypeError('compileToXml did not return a string');
   }
 
   return {
@@ -483,6 +451,36 @@ function compileAgent(yamlContent, answers = {}, agentName = '', targetPath = ''
   };
 }
 
+/**
+ * Filter customization data to remove empty/null values
+ * @param {Object} data - Raw customization data
+ * @returns {Object} Filtered customization data
+ */
+function filterCustomizationData(data) {
+  const filtered = {};
+
+  for (const [key, value] of Object.entries(data)) {
+    if (value === null || value === undefined || value === '') {
+      continue; // Skip null/undefined/empty values
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        filtered[key] = value;
+      }
+    } else if (typeof value === 'object') {
+      const nested = filterCustomizationData(value);
+      if (Object.keys(nested).length > 0) {
+        filtered[key] = nested;
+      }
+    } else {
+      filtered[key] = value;
+    }
+  }
+
+  return filtered;
+}
+
 /**
  * Process TTS injection markers in content
  * @param {string} content - Content to process
@@ -558,8 +556,9 @@ module.exports = {
   compileAgentFile,
   escapeXml,
   buildFrontmatter,
-  buildSimpleActivation,
   buildPersonaXml,
   buildPromptsXml,
+  buildMemoriesXml,
   buildMenuXml,
+  filterCustomizationData,
 };

package/tools/cli/lib/agent/installer.js

@@ -17,7 +17,7 @@ const { extractInstallConfig, getDefaultValues } = require('./template-engine');
  */
 function findBmadConfig(startPath = process.cwd()) {
   // Look for common BMAD folder names
-  const possibleNames = ['.bmad', 'bmad', '.bmad-method'];
+  const possibleNames = ['_bmad'];
 
   for (const name of possibleNames) {
     const configPath = path.join(startPath, name, 'bmb', 'config.yaml');
@@ -42,7 +42,7 @@ function findBmadConfig(startPath = process.cwd()) {
  * @returns {string} Resolved path
  */
 function resolvePath(pathStr, context) {
-  return pathStr.replaceAll('{project-root}', context.projectRoot).replaceAll('{bmad-folder}', context.bmadFolder);
+  return pathStr.replaceAll('{project-root}', context.projectRoot).replaceAll('{bmad-folder}', context_bmadFolder);
 }
 
 /**
@@ -262,129 +262,11 @@ function installAgent(agentInfo, answers, targetPath, options = {}) {
     agentName: metadata.name || agentInfo.name,
     targetDir: agentTargetDir,
     compiledFile: compiledPath,
-    sidecarCopied: false,
   };
 
-  // Handle sidecar files for agents with hasSidecar flag
-  if (agentInfo.hasSidecar === true && agentInfo.type === 'expert') {
-    // Get agent sidecar folder from config or use default
-    const agentSidecarFolder = options.config?.agent_sidecar_folder || '{project-root}/.myagent-data';
-
-    // Resolve path variables
-    const resolvedSidecarFolder = agentSidecarFolder
-      .replaceAll('{project-root}', options.projectRoot || process.cwd())
-      .replaceAll('.bmad', options.bmadFolder || '.bmad');
-
-    // Create sidecar directory for this agent
-    const agentSidecarDir = path.join(resolvedSidecarFolder, agentFolderName);
-    if (!fs.existsSync(agentSidecarDir)) {
-      fs.mkdirSync(agentSidecarDir, { recursive: true });
-    }
-
-    // Find and copy sidecar folder
-    const sidecarFiles = copyAgentSidecarFiles(agentInfo.path, agentSidecarDir, agentInfo.yamlFile);
-    result.sidecarCopied = true;
-    result.sidecarFiles = sidecarFiles;
-    result.sidecarDir = agentSidecarDir;
-  }
-
   return result;
 }
 
-/**
- * Recursively copy sidecar files (everything except the .agent.yaml)
- * @param {string} sourceDir - Source agent directory
- * @param {string} targetDir - Target agent directory
- * @param {string} excludeYaml - The .agent.yaml file to exclude
- * @returns {Array} List of copied files
- */
-function copySidecarFiles(sourceDir, targetDir, excludeYaml) {
-  const copied = [];
-
-  function copyDir(src, dest) {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      // Skip the source YAML file
-      if (srcPath === excludeYaml) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        copyDir(srcPath, destPath);
-      } else {
-        fs.copyFileSync(srcPath, destPath);
-        copied.push(destPath);
-      }
-    }
-  }
-
-  copyDir(sourceDir, targetDir);
-  return copied;
-}
-
-/**
- * Find and copy agent sidecar folders
- * @param {string} sourceDir - Source agent directory
- * @param {string} targetSidecarDir - Target sidecar directory for the agent
- * @param {string} excludeYaml - The .agent.yaml file to exclude
- * @returns {Array} List of copied files
- */
-function copyAgentSidecarFiles(sourceDir, targetSidecarDir, excludeYaml) {
-  const copied = [];
-  const preserved = [];
-
-  // Find folders with "sidecar" in the name
-  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.isDirectory() && entry.name.toLowerCase().includes('sidecar')) {
-      const sidecarSourcePath = path.join(sourceDir, entry.name);
-
-      // Recursively sync the sidecar folder contents (preserve existing, add new)
-      function syncSidecarDir(src, dest) {
-        if (!fs.existsSync(dest)) {
-          fs.mkdirSync(dest, { recursive: true });
-        }
-
-        // Get all files in source
-        const sourceEntries = fs.readdirSync(src, { withFileTypes: true });
-
-        for (const sourceEntry of sourceEntries) {
-          const srcPath = path.join(src, sourceEntry.name);
-          const destPath = path.join(dest, sourceEntry.name);
-
-          if (sourceEntry.isDirectory()) {
-            // Recursively sync subdirectories
-            syncSidecarDir(srcPath, destPath);
-          } else {
-            // Check if file already exists in destination
-            if (fs.existsSync(destPath)) {
-              // File exists - preserve it
-              preserved.push(destPath);
-            } else {
-              // File doesn't exist - copy it
-              fs.copyFileSync(srcPath, destPath);
-              copied.push(destPath);
-            }
-          }
-        }
-      }
-
-      syncSidecarDir(sidecarSourcePath, targetSidecarDir);
-    }
-  }
-
-  // Return info about what was preserved and what was copied
-  return { copied, preserved };
-}
-
 /**
  * Update agent metadata ID to reflect installed location
  * @param {string} compiledContent - Compiled XML content
@@ -407,10 +289,10 @@ function detectBmadProject(targetPath) {
 
   // Walk up directory tree looking for BMAD installation
   while (checkPath !== root) {
-    const possibleNames = ['.bmad'];
+    const possibleNames = ['_bmad'];
     for (const name of possibleNames) {
       const bmadFolder = path.join(checkPath, name);
-      const cfgFolder = path.join(bmadFolder, '_cfg');
+      const cfgFolder = path.join(bmadFolder, '_config');
       const manifestFile = path.join(cfgFolder, 'agent-manifest.csv');
 
       if (fs.existsSync(manifestFile)) {
@@ -596,16 +478,16 @@ function addToManifest(manifestFile, agentData) {
 }
 
 /**
- * Save agent source YAML to _cfg/custom/agents/ for reinstallation
+ * Save agent source YAML to _config/custom/agents/ for reinstallation
  * Stores user answers in a top-level saved_answers section (cleaner than overwriting defaults)
  * @param {Object} agentInfo - Agent info (path, type, etc.)
- * @param {string} cfgFolder - Path to _cfg folder
+ * @param {string} cfgFolder - Path to _config folder
  * @param {string} agentName - Final agent name (e.g., "fred-commit-poet")
  * @param {Object} answers - User answers to save for reinstallation
  * @returns {Object} Info about saved source
  */
 function saveAgentSource(agentInfo, cfgFolder, agentName, answers = {}) {
-  // Save to _cfg/custom/agents/ instead of _cfg/agents/
+  // Save to _config/custom/agents/ instead of _config/agents/
   const customAgentsCfgDir = path.join(cfgFolder, 'custom', 'agents');
 
   if (!fs.existsSync(customAgentsCfgDir)) {
@@ -689,7 +571,7 @@ function saveAgentSource(agentInfo, cfgFolder, agentName, answers = {}) {
  */
 async function createIdeSlashCommands(projectRoot, agentName, agentPath, metadata) {
   // Read manifest.yaml to get installed IDEs
-  const manifestPath = path.join(projectRoot, '.bmad', '_cfg', 'manifest.yaml');
+  const manifestPath = path.join(projectRoot, '_bmad', '_config', 'manifest.yaml');
   let installedIdes = ['claude-code']; // Default to Claude Code if no manifest
 
   if (fs.existsSync(manifestPath)) {
@@ -820,8 +702,6 @@ module.exports = {
   loadAgentConfig,
   promptInstallQuestions,
   installAgent,
-  copySidecarFiles,
-  copyAgentSidecarFiles,
   updateAgentId,
   detectBmadProject,
   addToManifest,