bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.2

package/tools/cli/bundlers/web-bundler.js

@@ -1,8 +1,10 @@
 const path = require('node:path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
+const yaml = require('js-yaml');
 const { DependencyResolver } = require('../installers/lib/core/dependency-resolver');
 const { XmlHandler } = require('../lib/xml-handler');
+const { YamlXmlBuilder } = require('../lib/yaml-xml-builder');
 const { AgentPartyGenerator } = require('../lib/agent-party-generator');
 const xml2js = require('xml2js');
 const { getProjectRoot, getSourcePath, getModulePath } = require('../lib/project-root');
@@ -16,6 +18,7 @@ class WebBundler {
 
     this.dependencyResolver = new DependencyResolver();
     this.xmlHandler = new XmlHandler();
+    this.yamlBuilder = new YamlXmlBuilder();
 
     // Cache for resolved dependencies to avoid duplicates
     this.dependencyCache = new Map();
@@ -108,16 +111,16 @@ class WebBundler {
       }
     }
 
-    // Process teams (Phase 4 - to be implemented)
-    // const teams = await this.discoverTeams(modulePath);
-    // for (const team of teams) {
-    //   try {
-    //     await this.bundleTeam(moduleName, team);
-    //     results.teams.push(team);
-    //   } catch (error) {
-    //     console.error(`    Failed to bundle team ${team}:`, error.message);
-    //   }
-    // }
+    // Process teams
+    const teams = await this.discoverTeams(modulePath);
+    for (const team of teams) {
+      try {
+        await this.bundleTeam(moduleName, team);
+        results.teams.push(team);
+      } catch (error) {
+        console.error(`    Failed to bundle team ${team}:`, error.message);
+      }
+    }
 
     return results;
   }
@@ -126,7 +129,7 @@ class WebBundler {
    * Bundle a single agent
    */
   async bundleAgent(moduleName, agentFile, shouldTrack = true) {
-    const agentName = path.basename(agentFile, '.md');
+    const agentName = agentFile.endsWith('.agent.yaml') ? path.basename(agentFile, '.agent.yaml') : path.basename(agentFile, '.md');
     this.stats.totalAgents++;
 
     console.log(chalk.dim(`  → Processing: ${agentName}`));
@@ -140,11 +143,24 @@ class WebBundler {
       throw new Error(`Agent file not found: ${agentPath}`);
     }
 
-    // Read agent file
-    const content = await fs.readFile(agentPath, 'utf8');
+    let content;
+    let agentXml;
 
-    // Extract agent XML from markdown
-    let agentXml = this.extractAgentXml(content);
+    // Handle YAML agents - build in-memory to XML
+    if (agentFile.endsWith('.agent.yaml')) {
+      // Build agent from YAML (no customize file for web bundles)
+      const xmlContent = await this.yamlBuilder.buildFromYaml(agentPath, null, {
+        includeMetadata: false, // Don't include build metadata in web bundles
+        forWebBundle: true, // Use web-specific activation fragments
+      });
+
+      content = xmlContent;
+      agentXml = this.extractAgentXml(xmlContent);
+    } else {
+      // Legacy MD format - read and extract XML
+      content = await fs.readFile(agentPath, 'utf8');
+      agentXml = this.extractAgentXml(content);
+    }
 
     if (!agentXml) {
       this.stats.failedAgents++;
@@ -172,12 +188,17 @@ class WebBundler {
 
     // Resolve dependencies with warning tracking
     const dependencyWarnings = [];
-    const dependencies = await this.resolveAgentDependencies(agentXml, moduleName, dependencyWarnings);
+    const { dependencies, skippedWorkflows } = await this.resolveAgentDependencies(agentXml, moduleName, dependencyWarnings);
 
     if (dependencyWarnings.length > 0) {
       this.stats.warnings.push({ agent: agentName, warnings: dependencyWarnings });
     }
 
+    // Remove commands for skipped workflows from agent XML
+    if (skippedWorkflows.length > 0) {
+      agentXml = this.removeSkippedWorkflowCommands(agentXml, skippedWorkflows);
+    }
+
     // Build the bundle (no manifests for individual agents)
     const bundle = this.buildAgentBundle(agentXml, dependencies);
 
@@ -198,6 +219,220 @@ class WebBundler {
     console.log(`    ${statusIcon} Bundled: ${agentName}.xml${isValid ? '' : chalk.yellow(' (invalid XML)')}`);
   }
 
+  /**
+   * Bundle a team - includes orchestrator and all agents with their dependencies
+   */
+  async bundleTeam(moduleName, teamFile) {
+    const teamName = path.basename(teamFile, path.extname(teamFile));
+    console.log(chalk.dim(`  → Processing team: ${teamName}`));
+
+    const teamPath = path.join(this.modulesPath, moduleName, 'teams', teamFile);
+
+    // Check if team file exists
+    if (!(await fs.pathExists(teamPath))) {
+      console.log(chalk.red(`    ✗ Team file not found`));
+      throw new Error(`Team file not found: ${teamPath}`);
+    }
+
+    // Read and parse team YAML
+    const teamContent = await fs.readFile(teamPath, 'utf8');
+    const teamConfig = yaml.load(teamContent);
+
+    if (!teamConfig || !teamConfig.bundle) {
+      console.log(chalk.red(`    ✗ Invalid team configuration`));
+      return;
+    }
+
+    // Start building the team bundle
+    const dependencies = new Map();
+    const processed = new Set();
+    const allAgentXmls = [];
+    const warnings = [];
+
+    // 1. First, always add the bmad-web-orchestrator (XML file only, no transformation needed)
+    const orchestratorXmlPath = path.join(this.sourceDir, 'core', 'agents', 'bmad-web-orchestrator.agent.xml');
+
+    if (await fs.pathExists(orchestratorXmlPath)) {
+      // Read the XML file directly - no transformation needed
+      const xmlContent = await fs.readFile(orchestratorXmlPath, 'utf8');
+      let orchestratorXml = xmlContent.trim();
+
+      // Process {project-root} references
+      orchestratorXml = this.processProjectRootReferences(orchestratorXml);
+
+      // Inject help/exit menu items only (orchestrator has its own activation)
+      orchestratorXml = this.injectHelpExitMenuItems(orchestratorXml);
+
+      // Resolve orchestrator dependencies
+      const { dependencies: orchDeps } = await this.resolveAgentDependencies(orchestratorXml, 'core', warnings);
+
+      // Merge orchestrator dependencies
+      for (const [id, content] of orchDeps) {
+        if (!dependencies.has(id)) {
+          dependencies.set(id, content);
+        }
+      }
+
+      // Add orchestrator XML first
+      allAgentXmls.push(orchestratorXml);
+      console.log(chalk.gray(`    + Added orchestrator: bmad-web-orchestrator`));
+    } else {
+      console.log(chalk.yellow(`    ⚠ Orchestrator not found at: ${orchestratorXmlPath}`));
+    }
+
+    // 2. Determine which agents to include
+    let agentsToBundle = [];
+
+    if (teamConfig.agents === '*' || (Array.isArray(teamConfig.agents) && teamConfig.agents.includes('*'))) {
+      // Include all agents from the module
+      const agentsPath = path.join(this.modulesPath, moduleName, 'agents');
+      if (await fs.pathExists(agentsPath)) {
+        const agentFiles = await fs.readdir(agentsPath);
+        agentsToBundle = agentFiles
+          .filter((file) => file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme')))
+          .map((file) => file.replace(/\.(agent\.yaml|md)$/, ''));
+      }
+    } else if (Array.isArray(teamConfig.agents)) {
+      // Include specific agents listed
+      agentsToBundle = teamConfig.agents;
+    } else {
+      console.log(chalk.yellow(`    ⚠ No agents specified in team configuration`));
+    }
+
+    // 3. Process each agent and their dependencies
+    for (const agentName of agentsToBundle) {
+      // Try YAML first, then MD
+      let agentPath = path.join(this.modulesPath, moduleName, 'agents', `${agentName}.agent.yaml`);
+      let isYaml = await fs.pathExists(agentPath);
+
+      if (!isYaml) {
+        agentPath = path.join(this.modulesPath, moduleName, 'agents', `${agentName}.md`);
+        if (!(await fs.pathExists(agentPath))) {
+          console.log(chalk.yellow(`    ⚠ Agent not found: ${agentName}`));
+          continue;
+        }
+      }
+
+      let agentXml;
+
+      if (isYaml) {
+        // Build YAML agent in-memory - skip activation for team agents (orchestrator handles it)
+        const xmlContent = await this.yamlBuilder.buildFromYaml(agentPath, null, {
+          includeMetadata: false,
+          skipActivation: true, // Skip activation for team agents
+        });
+        agentXml = this.extractAgentXml(xmlContent);
+      } else {
+        // Read legacy MD agent
+        const agentContent = await fs.readFile(agentPath, 'utf8');
+        agentXml = this.extractAgentXml(agentContent);
+      }
+
+      if (!agentXml) {
+        console.log(chalk.yellow(`    ⚠ No XML found in agent: ${agentName}`));
+        continue;
+      }
+
+      // Skip agents with bundle="false"
+      if (this.shouldSkipBundling(agentXml)) {
+        console.log(chalk.gray(`    ⊘ Skipped agent (bundle="false"): ${agentName}`));
+        continue;
+      }
+
+      // Process {project-root} references
+      agentXml = this.processProjectRootReferences(agentXml);
+
+      // Resolve agent dependencies
+      const agentWarnings = [];
+      const { dependencies: agentDeps, skippedWorkflows } = await this.resolveAgentDependencies(agentXml, moduleName, agentWarnings);
+
+      if (agentWarnings.length > 0) {
+        warnings.push({ agent: agentName, warnings: agentWarnings });
+      }
+
+      // Remove commands for skipped workflows from agent XML
+      if (skippedWorkflows.length > 0) {
+        agentXml = this.removeSkippedWorkflowCommands(agentXml, skippedWorkflows);
+      }
+
+      // Merge agent dependencies (deduplicate)
+      for (const [id, content] of agentDeps) {
+        if (!dependencies.has(id)) {
+          dependencies.set(id, content);
+        }
+      }
+
+      // Skip web activation injection for team agents - orchestrator handles everything
+      // Only inject help/exit menu items if missing
+      agentXml = this.injectHelpExitMenuItems(agentXml);
+
+      // Add agent XML to the collection
+      allAgentXmls.push(agentXml);
+      console.log(chalk.gray(`    + Added agent: ${agentName}`));
+    }
+
+    // 4. Build the team bundle XML
+    const bundle = this.buildTeamBundle(teamConfig.bundle, allAgentXmls, dependencies);
+
+    // 5. Validate XML
+    const isValid = await this.validateXml(bundle);
+    if (!isValid) {
+      console.log(chalk.red(`    ⚠ Invalid XML generated for team!`));
+    }
+
+    // 6. Write bundle to output
+    const outputPath = path.join(this.outputDir, moduleName, 'teams', `${teamName}.xml`);
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, bundle, 'utf8');
+
+    const statusIcon = isValid ? chalk.green('✓') : chalk.yellow('⚠');
+    console.log(`    ${statusIcon} Bundled team: ${teamName}.xml${isValid ? '' : chalk.yellow(' (invalid XML)')}`);
+
+    // Track warnings
+    if (warnings.length > 0) {
+      this.stats.warnings.push(...warnings);
+    }
+  }
+
+  /**
+   * Build the final team bundle XML
+   */
+  buildTeamBundle(teamMetadata, agentXmls, dependencies) {
+    const parts = ['<?xml version="1.0" encoding="UTF-8"?>', '<team-bundle>', '  <!-- Agent Definitions -->', '  <agents>'];
+
+    for (const agentXml of agentXmls) {
+      // Indent each agent XML properly (add 4 spaces to each line)
+      const indentedAgent = agentXml
+        .split('\n')
+        .map((line) => '    ' + line)
+        .join('\n');
+      parts.push(indentedAgent);
+    }
+
+    parts.push('  </agents>');
+
+    // Add all dependencies
+    if (dependencies && dependencies.size > 0) {
+      parts.push('', '  <!-- Shared Dependencies -->', '  <dependencies>');
+
+      for (const [id, content] of dependencies) {
+        // All dependencies are now consistently wrapped in <file> elements
+        // Indent properly (add 4 spaces to each line)
+        const indentedContent = content
+          .split('\n')
+          .map((line) => '    ' + line)
+          .join('\n');
+        parts.push(indentedContent);
+      }
+
+      parts.push('  </dependencies>');
+    }
+
+    parts.push('</team-bundle>');
+
+    return parts.join('\n');
+  }
+
   /**
    * Pre-discover all agents and teams in a module for manifest generation
    */
@@ -212,9 +447,20 @@ class WebBundler {
     if (await fs.pathExists(agentsPath)) {
       const files = await fs.readdir(agentsPath);
       for (const file of files) {
-        if (file.endsWith('.md')) {
+        if (file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme'))) {
           const agentPath = path.join(agentsPath, file);
-          const content = await fs.readFile(agentPath, 'utf8');
+          let content;
+
+          if (file.endsWith('.agent.yaml')) {
+            // Build YAML agent in-memory
+            content = await this.yamlBuilder.buildFromYaml(agentPath, null, {
+              includeMetadata: false,
+            });
+          } else {
+            // Read legacy MD agent
+            content = await fs.readFile(agentPath, 'utf8');
+          }
+
           const agentXml = this.extractAgentXml(content);
 
           if (agentXml) {
@@ -223,7 +469,7 @@ class WebBundler {
               continue;
             }
 
-            const agentName = path.basename(file, '.md');
+            const agentName = file.endsWith('.agent.yaml') ? path.basename(file, '.agent.yaml') : path.basename(file, '.md');
             // Use the shared generator to extract agent details (pass full content)
             const agentDetails = AgentPartyGenerator.extractAgentDetails(content, moduleName, agentName);
             if (agentDetails) {
@@ -265,16 +511,25 @@ class WebBundler {
   async resolveAgentDependencies(agentXml, moduleName, warnings = []) {
     const dependencies = new Map();
     const processed = new Set();
+    const skippedWorkflows = [];
 
     // Extract file references from agent XML
-    const fileRefs = this.extractFileReferences(agentXml);
+    const { refs, workflowRefs } = this.extractFileReferences(agentXml);
 
-    // Process each file reference
-    for (const ref of fileRefs) {
+    // Process regular file references
+    for (const ref of refs) {
       await this.processFileDependency(ref, dependencies, processed, moduleName, warnings);
     }
 
-    return dependencies;
+    // Process workflow references with special handling
+    for (const workflowRef of workflowRefs) {
+      const result = await this.processWorkflowDependency(workflowRef, dependencies, processed, moduleName, warnings);
+      if (result && result.skipped) {
+        skippedWorkflows.push(workflowRef);
+      }
+    }
+
+    return { dependencies, skippedWorkflows };
   }
 
   /**
@@ -282,6 +537,7 @@ class WebBundler {
    */
   extractFileReferences(xml) {
     const refs = new Set();
+    const workflowRefs = new Set();
 
     // Match various file reference patterns
     const patterns = [
@@ -292,7 +548,6 @@ class WebBundler {
       /src="([^"]+)"/g, // Source paths
       /system-prompts="([^"]+)"/g,
       /tools="([^"]+)"/g,
-      /workflows="([^"]+)"/g,
       /knowledge="([^"]+)"/g,
       /{project-root}\/([^"'\s<>]+)/g,
     ];
@@ -303,13 +558,56 @@ class WebBundler {
         let filePath = match[1];
         // Remove {project-root} prefix if present
         filePath = filePath.replace(/^{project-root}\//, '');
-        if (filePath) {
+
+        // Skip obvious placeholder/example paths
+        if (filePath && !filePath.includes('path/to/') && !filePath.includes('example')) {
           refs.add(filePath);
         }
       }
     }
 
-    return [...refs];
+    // Extract workflow references - both 'workflow' and 'run-workflow' attributes
+    const workflowPatterns = [
+      /workflow="([^"]+)"/g, // Menu items with workflow attribute
+      /run-workflow="([^"]+)"/g, // Commands with run-workflow attribute
+      /validate-workflow="([^"]+)"/g, // Validation workflow references
+    ];
+
+    for (const pattern of workflowPatterns) {
+      let match;
+      while ((match = pattern.exec(xml)) !== null) {
+        let workflowPath = match[1];
+        workflowPath = workflowPath.replace(/^{project-root}\//, '');
+
+        // Skip obvious placeholder/example paths
+        if (workflowPath && workflowPath.endsWith('.yaml') && !workflowPath.includes('path/to/') && !workflowPath.includes('example')) {
+          workflowRefs.add(workflowPath);
+        }
+      }
+    }
+
+    return { refs: [...refs], workflowRefs: [...workflowRefs] };
+  }
+
+  /**
+   * Remove commands from agent XML that reference skipped workflows
+   */
+  removeSkippedWorkflowCommands(agentXml, skippedWorkflows) {
+    let modifiedXml = agentXml;
+
+    // For each skipped workflow, find and remove the corresponding <c> command
+    for (const workflowPath of skippedWorkflows) {
+      // Match: <c cmd="..." run-workflow="workflowPath">...</c>
+      // Need to escape special regex characters in the path
+      const escapedPath = workflowPath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+
+      // Pattern to match the command line with this workflow
+      const pattern = new RegExp(`\\s*<c\\s+cmd="[^"]*"\\s+run-workflow="[^"]*${escapedPath}"[^>]*>.*?</c>\\s*`, 'gs');
+
+      modifiedXml = modifiedXml.replace(pattern, '');
+    }
+
+    return modifiedXml;
   }
 
   /**
@@ -322,6 +620,11 @@ class WebBundler {
     }
     processed.add(filePath);
 
+    // Skip agent-manifest.csv manifest for web bundles (agents are already bundled)
+    if (filePath === 'bmad/_cfg/agent-manifest.csv' || filePath.endsWith('/agent-manifest.csv')) {
+      return;
+    }
+
     // Handle wildcard patterns
     if (filePath.includes('*')) {
       await this.processWildcardDependency(filePath, dependencies, processed, moduleName, warnings);
@@ -447,8 +750,10 @@ class WebBundler {
 
         indexParts.push('  </items>', '</file-index>');
 
-        // Store the XML version
-        dependencies.set(filePath, indexParts.join('\n'));
+        // Store the XML version wrapped in a file element
+        const csvXml = indexParts.join('\n');
+        const wrappedCsv = `<file id="${filePath}" type="xml">\n${csvXml}\n</file>`;
+        dependencies.set(filePath, wrappedCsv);
 
         // Process referenced files from CSV
         for (const refId of referencedFiles) {
@@ -470,16 +775,207 @@ class WebBundler {
       }
     }
 
-    // Store the processed content
-    dependencies.set(filePath, processedContent);
+    // Determine file type for wrapping
+    let fileType = 'text';
+    if (ext === '.xml' || (ext === '.md' && processedContent.trim().startsWith('<'))) {
+      fileType = 'xml';
+    } else
+      switch (ext) {
+        case '.yaml':
+        case '.yml': {
+          fileType = 'yaml';
+
+          break;
+        }
+        case '.json': {
+          fileType = 'json';
+
+          break;
+        }
+        case '.md': {
+          fileType = 'md';
+
+          break;
+        }
+        // No default
+      }
+
+    // Wrap content in file element and store
+    const wrappedContent = this.wrapContentInXml(processedContent, filePath, fileType);
+    dependencies.set(filePath, wrappedContent);
 
     // Recursively scan for more dependencies
-    const nestedRefs = this.extractFileReferences(processedContent);
+    const { refs: nestedRefs } = this.extractFileReferences(processedContent);
     for (const ref of nestedRefs) {
       await this.processFileDependency(ref, dependencies, processed, moduleName, warnings);
     }
   }
 
+  /**
+   * Process a workflow YAML file and its bundle files
+   */
+  async processWorkflowDependency(workflowPath, dependencies, processed, moduleName, warnings = []) {
+    // Skip if already processed
+    if (processed.has(workflowPath)) {
+      return { skipped: false };
+    }
+    processed.add(workflowPath);
+
+    // Resolve actual file path
+    const actualPath = this.resolveFilePath(workflowPath, moduleName);
+
+    if (!actualPath || !(await fs.pathExists(actualPath))) {
+      warnings.push(workflowPath);
+      return { skipped: true };
+    }
+
+    // Read and parse YAML file
+    const yamlContent = await fs.readFile(actualPath, 'utf8');
+    let workflowConfig;
+
+    try {
+      workflowConfig = yaml.load(yamlContent);
+    } catch (error) {
+      warnings.push(`${workflowPath} (invalid YAML: ${error.message})`);
+      return { skipped: true };
+    }
+
+    // Check if web_bundle is explicitly set to false
+    if (workflowConfig.web_bundle === false) {
+      // Mark this workflow as skipped so we can remove the command from agent
+      return { skipped: true, workflowPath };
+    }
+
+    // Create YAML content with only web_bundle section (flattened)
+    let bundleYamlContent;
+    if (workflowConfig.web_bundle && typeof workflowConfig.web_bundle === 'object') {
+      // Only include the web_bundle content, flattened to root level
+      bundleYamlContent = yaml.dump(workflowConfig.web_bundle);
+    } else {
+      // If no web_bundle section, include full YAML
+      bundleYamlContent = yamlContent;
+    }
+
+    // Include the YAML file with only web_bundle content, wrapped in XML
+    const yamlId = workflowPath.replace(/^{project-root}\//, '');
+    const wrappedYaml = this.wrapContentInXml(bundleYamlContent, yamlId, 'yaml');
+    dependencies.set(yamlId, wrappedYaml);
+
+    // Always include core workflow task when processing workflows
+    await this.includeCoreWorkflowFiles(dependencies, processed, moduleName, warnings);
+
+    // Check if advanced elicitation is enabled
+    if (workflowConfig.web_bundle && workflowConfig.web_bundle.use_advanced_elicitation) {
+      await this.includeAdvancedElicitationFiles(dependencies, processed, moduleName, warnings);
+    }
+
+    // Process web_bundle_files if they exist
+    if (workflowConfig.web_bundle && workflowConfig.web_bundle.web_bundle_files) {
+      const bundleFiles = workflowConfig.web_bundle.web_bundle_files;
+
+      for (const bundleFilePath of bundleFiles) {
+        if (processed.has(bundleFilePath)) {
+          continue;
+        }
+
+        const bundleActualPath = this.resolveFilePath(bundleFilePath, moduleName);
+
+        if (!bundleActualPath || !(await fs.pathExists(bundleActualPath))) {
+          warnings.push(bundleFilePath);
+          continue;
+        }
+
+        // Check if this is another workflow.yaml file - if so, recursively process it
+        if (bundleFilePath.endsWith('workflow.yaml')) {
+          // Recursively process this workflow and its dependencies
+          await this.processWorkflowDependency(bundleFilePath, dependencies, processed, moduleName, warnings);
+        } else {
+          // Regular file - process normally
+          processed.add(bundleFilePath);
+
+          // Read the file content
+          const fileContent = await fs.readFile(bundleActualPath, 'utf8');
+          const fileExt = path.extname(bundleActualPath).toLowerCase().replace('.', '');
+
+          // Wrap in XML with proper escaping
+          const wrappedContent = this.wrapContentInXml(fileContent, bundleFilePath, fileExt);
+          dependencies.set(bundleFilePath, wrappedContent);
+        }
+      }
+    }
+
+    return { skipped: false };
+  }
+
+  /**
+   * Include core workflow task files
+   */
+  async includeCoreWorkflowFiles(dependencies, processed, moduleName, warnings = []) {
+    const coreWorkflowPath = 'bmad/core/tasks/workflow.xml';
+
+    if (processed.has(coreWorkflowPath)) {
+      return;
+    }
+    processed.add(coreWorkflowPath);
+
+    const actualPath = this.resolveFilePath(coreWorkflowPath, moduleName);
+
+    if (!actualPath || !(await fs.pathExists(actualPath))) {
+      warnings.push(coreWorkflowPath);
+      return;
+    }
+
+    const fileContent = await fs.readFile(actualPath, 'utf8');
+    const wrappedContent = this.wrapContentInXml(fileContent, coreWorkflowPath, 'xml');
+    dependencies.set(coreWorkflowPath, wrappedContent);
+  }
+
+  /**
+   * Include advanced elicitation files
+   */
+  async includeAdvancedElicitationFiles(dependencies, processed, moduleName, warnings = []) {
+    const elicitationFiles = ['bmad/core/tasks/adv-elicit.xml', 'bmad/core/tasks/adv-elicit-methods.csv'];
+
+    for (const filePath of elicitationFiles) {
+      if (processed.has(filePath)) {
+        continue;
+      }
+      processed.add(filePath);
+
+      const actualPath = this.resolveFilePath(filePath, moduleName);
+
+      if (!actualPath || !(await fs.pathExists(actualPath))) {
+        warnings.push(filePath);
+        continue;
+      }
+
+      const fileContent = await fs.readFile(actualPath, 'utf8');
+      const fileExt = path.extname(actualPath).toLowerCase().replace('.', '');
+      const wrappedContent = this.wrapContentInXml(fileContent, filePath, fileExt);
+      dependencies.set(filePath, wrappedContent);
+    }
+  }
+
+  /**
+   * Wrap file content in XML with proper escaping
+   */
+  wrapContentInXml(content, id, type = 'text') {
+    // For XML files, include directly without CDATA (they're already valid XML)
+    if (type === 'xml') {
+      // XML files can be included directly as they're already well-formed
+      // Just wrap in a file element
+      return `<file id="${id}" type="${type}">\n${content}\n</file>`;
+    }
+
+    // For all other file types, use CDATA to preserve content exactly
+    // Escape any ]]> sequences in the content by splitting CDATA sections
+    // Replace ]]> with ]]]]><![CDATA[> to properly escape it within CDATA
+    const escapedContent = content.replaceAll(']]>', ']]]]><![CDATA[>');
+
+    // Use CDATA to preserve content exactly as-is, including special characters
+    return `<file id="${id}" type="${type}"><![CDATA[${escapedContent}]]></file>`;
+  }
+
   /**
    * Process wildcard dependency patterns
    */
@@ -665,10 +1161,113 @@ class WebBundler {
     return parts.join('');
   }
 
+  /**
+   * Inject help and exit menu items into agent XML
+   */
+  injectHelpExitMenuItems(agentXml) {
+    // Check if menu already has help and exit
+    const hasHelp = agentXml.includes('cmd="*help"') || agentXml.includes('trigger="*help"');
+    const hasExit = agentXml.includes('cmd="*exit"') || agentXml.includes('trigger="*exit"');
+
+    if (hasHelp && hasExit) {
+      return agentXml; // Already has both, skip injection
+    }
+
+    // Find the menu section
+    const menuMatch = agentXml.match(/(<menu>[\s\S]*?<\/menu>)/);
+    if (!menuMatch) {
+      return agentXml; // No menu found, skip injection
+    }
+
+    const menuContent = menuMatch[1];
+    const menuClosingMatch = menuContent.match(/(\s*)<\/menu>/);
+    if (!menuClosingMatch) {
+      return agentXml;
+    }
+
+    const indent = menuClosingMatch[1];
+    const menuItems = [];
+
+    if (!hasHelp) {
+      menuItems.push(`${indent}<item cmd="*help">Show numbered menu</item>`);
+    }
+
+    if (!hasExit) {
+      menuItems.push(`${indent}<item cmd="*exit">Exit with confirmation</item>`);
+    }
+
+    if (menuItems.length === 0) {
+      return agentXml;
+    }
+
+    // Inject menu items before closing </menu> tag
+    const newMenuContent = menuContent.replace(/(\s*)<\/menu>/, `\n${menuItems.join('\n')}\n${indent}</menu>`);
+    return agentXml.replace(menuContent, newMenuContent);
+  }
+
+  /**
+   * Inject web activation instructions into agent XML
+   */
+  injectWebActivation(agentXml) {
+    // First, always inject help/exit menu items
+    agentXml = this.injectHelpExitMenuItems(agentXml);
+
+    // Load the web activation template
+    const activationPath = path.join(this.sourceDir, 'utility', 'models', 'agent-activation-web.xml');
+
+    if (!fs.existsSync(activationPath)) {
+      console.warn(chalk.yellow('Warning: agent-activation-web.xml not found, skipping activation injection'));
+      return agentXml;
+    }
+
+    const activationXml = fs.readFileSync(activationPath, 'utf8');
+
+    // For web bundles, ALWAYS replace existing activation with web activation
+    // This is because fragment-based activation assumes filesystem access which won't work in web bundles
+    const hasActivation = agentXml.includes('<activation');
+
+    if (hasActivation) {
+      // Replace existing activation block with web activation
+      const injectedXml = agentXml.replace(/<activation[^>]*>[\s\S]*?<\/activation>/, activationXml);
+      return injectedXml;
+    }
+
+    // Check for critical-actions block (legacy)
+    const hasCriticalActions = agentXml.includes('<critical-actions');
+
+    if (hasCriticalActions) {
+      // Replace critical-actions block with activation
+      const injectedXml = agentXml.replace(/<critical-actions>[\s\S]*?<\/critical-actions>/, activationXml);
+      return injectedXml;
+    }
+
+    // If no critical-actions, inject before closing </agent> tag
+    const closingTagMatch = agentXml.match(/(\s*)<\/agent>/);
+    if (!closingTagMatch) {
+      console.warn(chalk.yellow('Warning: Could not find </agent> tag for activation injection'));
+      return agentXml;
+    }
+
+    // Inject the activation block before the closing </agent> tag
+    // Properly indent each line of the activation XML
+    const indent = closingTagMatch[1];
+    const indentedActivation = activationXml
+      .split('\n')
+      .map((line) => (line.trim() ? indent + line : ''))
+      .join('\n');
+
+    const injectedXml = agentXml.replace(/(\s*)<\/agent>/, `\n${indentedActivation}\n${indent}</agent>`);
+
+    return injectedXml;
+  }
+
   /**
    * Build the final agent bundle XML
    */
   buildAgentBundle(agentXml, dependencies) {
+    // Web activation is now handled by fragments during YAML building
+    // agentXml = this.injectWebActivation(agentXml);
+
     const parts = [
       '<?xml version="1.0" encoding="UTF-8"?>',
       '<agent-bundle>',
@@ -676,14 +1275,13 @@ class WebBundler {
       '  ' + agentXml.replaceAll('\n', '\n  '),
     ];
 
-    // Add dependencies without wrapper tags
+    // Add dependencies (all are now consistently wrapped in <file> elements)
     if (dependencies && dependencies.size > 0) {
       parts.push('\n  <!-- Dependencies -->');
       for (const [id, content] of dependencies) {
-        // Escape XML content while preserving tags
-        const escapedContent = this.escapeXmlContent(content);
+        // All dependencies are now wrapped in <file> elements
         // Indent properly
-        const indentedContent = escapedContent
+        const indentedContent = content
           .split('\n')
           .map((line) => '  ' + line)
           .join('\n');
@@ -732,7 +1330,8 @@ class WebBundler {
     const files = await fs.readdir(agentsPath);
 
     for (const file of files) {
-      if (file.endsWith('.md')) {
+      // Look for .agent.yaml files (new format) or .md files (legacy format)
+      if (file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme'))) {
         agents.push(file);
       }
     }
@@ -754,7 +1353,7 @@ class WebBundler {
     const files = await fs.readdir(teamsPath);
 
     for (const file of files) {
-      if (file.endsWith('.md')) {
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
         teams.push(file);
       }
     }
@@ -794,8 +1393,8 @@ class WebBundler {
     // Ensure temp directory exists
     await fs.ensureDir(this.tempManifestDir);
 
-    // Generate agent-party.xml using shared generator
-    const agentPartyPath = path.join(this.tempManifestDir, 'agent-party.xml');
+    // Generate agent-manifest.csv using shared generator
+    const agentPartyPath = path.join(this.tempManifestDir, 'agent-manifest.csv');
     await AgentPartyGenerator.writeAgentParty(agentPartyPath, this.discoveredAgents, { forWeb: true });
 
     console.log(chalk.dim('  ✓ Created temporary manifest files'));
@@ -853,7 +1452,7 @@ class WebBundler {
 
       // Group and display warnings by agent
       for (const agentWarning of this.stats.warnings) {
-        if (agentWarning.warnings.length > 0) {
+        if (agentWarning && agentWarning.warnings && agentWarning.warnings.length > 0) {
           console.log(chalk.bold(`\n  ${agentWarning.agent}:`));
           // Display unique warnings for this agent
           const uniqueWarnings = [...new Set(agentWarning.warnings)];