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

package/tools/cli/installers/lib/core/manifest-generator.js

@@ -34,9 +34,13 @@ class ManifestGenerator {
 
     // Store modules list (all modules including preserved ones)
     const preservedModules = options.preservedModules || [];
+
+    // Scan the bmad directory to find all actually installed modules
+    const installedModules = await this.scanInstalledModules(bmadDir);
+
     // Deduplicate modules list to prevent duplicates
-    this.modules = [...new Set(['core', ...selectedModules, ...preservedModules])];
-    this.updatedModules = [...new Set(['core', ...selectedModules])]; // Only these get rescanned
+    this.modules = [...new Set(['core', ...selectedModules, ...preservedModules, ...installedModules])];
+    this.updatedModules = [...new Set(['core', ...selectedModules, ...installedModules])]; // All installed modules get rescanned
     this.preservedModules = preservedModules; // These stay as-is in CSVs
     this.bmadDir = bmadDir;
     this.bmadFolderName = path.basename(bmadDir); // Get the actual folder name (e.g., '.bmad' or 'bmad')
@@ -105,7 +109,7 @@ class ManifestGenerator {
   }
 
   /**
-   * Recursively find and parse workflow.yaml files
+   * Recursively find and parse workflow.yaml and workflow.md files
    */
   async getWorkflowsFromPath(basePath, moduleName) {
     const workflows = [];
@@ -126,11 +130,23 @@ class ManifestGenerator {
           // Recurse into subdirectories
           const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
           await findWorkflows(fullPath, newRelativePath);
-        } else if (entry.name === 'workflow.yaml') {
-          // Parse workflow file
+        } else if (entry.name === 'workflow.yaml' || entry.name === 'workflow.md') {
+          // Parse workflow file (both YAML and MD formats)
           try {
             const content = await fs.readFile(fullPath, 'utf8');
-            const workflow = yaml.load(content);
+
+            let workflow;
+            if (entry.name === 'workflow.yaml') {
+              // Parse YAML workflow
+              workflow = yaml.load(content);
+            } else {
+              // Parse MD workflow with YAML frontmatter
+              const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+              if (!frontmatterMatch) {
+                continue; // Skip MD files without frontmatter
+              }
+              workflow = yaml.load(frontmatterMatch[1]);
+            }
 
             // Skip template workflows (those with placeholder values)
             if (workflow.name && workflow.name.includes('{') && workflow.name.includes('}')) {
@@ -141,18 +157,15 @@ class ManifestGenerator {
               // Build relative path for installation
               const installPath =
                 moduleName === 'core'
-                  ? `${this.bmadFolderName}/core/workflows/${relativePath}/workflow.yaml`
-                  : `${this.bmadFolderName}/${moduleName}/workflows/${relativePath}/workflow.yaml`;
-
-              // Check for standalone property (default: false)
-              const standalone = workflow.standalone === true;
+                  ? `${this.bmadFolderName}/core/workflows/${relativePath}/${entry.name}`
+                  : `${this.bmadFolderName}/${moduleName}/workflows/${relativePath}/${entry.name}`;
 
+              // ALL workflows now generate commands - no standalone property needed
               workflows.push({
                 name: workflow.name,
                 description: workflow.description.replaceAll('"', '""'), // Escape quotes for CSV
                 module: moduleName,
                 path: installPath,
-                standalone: standalone,
               });
 
               // Add to files list
@@ -207,18 +220,23 @@ class ManifestGenerator {
   }
 
   /**
-   * Get agents from a directory
+   * Get agents from a directory recursively
    * Only includes compiled .md files (not .agent.yaml source files)
    */
-  async getAgentsFromDir(dirPath, moduleName) {
+  async getAgentsFromDir(dirPath, moduleName, relativePath = '') {
     const agents = [];
-    const files = await fs.readdir(dirPath);
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
 
-    for (const file of files) {
-      // Only include .md files, skip .agent.yaml source files and README.md
-      if (file.endsWith('.md') && !file.endsWith('.agent.yaml') && file.toLowerCase() !== 'readme.md') {
-        const filePath = path.join(dirPath, file);
-        const content = await fs.readFile(filePath, 'utf8');
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recurse into subdirectories
+        const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        const subDirAgents = await this.getAgentsFromDir(fullPath, moduleName, newRelativePath);
+        agents.push(...subDirAgents);
+      } else if (entry.name.endsWith('.md') && !entry.name.endsWith('.agent.yaml') && entry.name.toLowerCase() !== 'readme.md') {
+        const content = await fs.readFile(fullPath, 'utf8');
 
         // Skip files that don't contain <agent> tag (e.g., README files)
         if (!content.includes('<agent')) {
@@ -242,10 +260,13 @@ class ManifestGenerator {
         const principlesMatch = content.match(/<principles>([\s\S]*?)<\/principles>/);
 
         // Build relative path for installation
+        const fileRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
         const installPath =
-          moduleName === 'core' ? `${this.bmadFolderName}/core/agents/${file}` : `${this.bmadFolderName}/${moduleName}/agents/${file}`;
+          moduleName === 'core'
+            ? `${this.bmadFolderName}/core/agents/${fileRelativePath}`
+            : `${this.bmadFolderName}/${moduleName}/agents/${fileRelativePath}`;
 
-        const agentName = file.replace('.md', '');
+        const agentName = entry.name.replace('.md', '');
 
         // Helper function to clean and escape CSV content
         const cleanForCSV = (text) => {
@@ -541,12 +562,12 @@ class ManifestGenerator {
   async writeWorkflowManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'workflow-manifest.csv');
 
-    // Create CSV header with standalone column
-    let csv = 'name,description,module,path,standalone\n';
+    // Create CSV header - removed standalone column as ALL workflows now generate commands
+    let csv = 'name,description,module,path\n';
 
-    // Add all workflows
+    // Add all workflows - no standalone property needed anymore
     for (const workflow of this.workflows) {
-      csv += `"${workflow.name}","${workflow.description}","${workflow.module}","${workflow.path}","${workflow.standalone}"\n`;
+      csv += `"${workflow.name}","${workflow.description}","${workflow.module}","${workflow.path}"\n`;
     }
 
     await fs.writeFile(csvPath, csv);
@@ -641,13 +662,14 @@ class ManifestGenerator {
     if (this.allInstalledFiles && this.allInstalledFiles.length > 0) {
       // Process all installed files
       for (const filePath of this.allInstalledFiles) {
-        const relativePath = 'bmad' + filePath.replace(this.bmadDir, '').replaceAll('\\', '/');
+        // Store paths relative to bmadDir (no folder prefix)
+        const relativePath = filePath.replace(this.bmadDir, '').replaceAll('\\', '/').replace(/^\//, '');
         const ext = path.extname(filePath).toLowerCase();
         const fileName = path.basename(filePath, ext);
 
-        // Determine module from path
+        // Determine module from path (first directory component)
         const pathParts = relativePath.split('/');
-        const module = pathParts.length > 1 ? pathParts[1] : 'unknown';
+        const module = pathParts.length > 0 ? pathParts[0] : 'unknown';
 
         // Calculate hash
         const hash = await this.calculateFileHash(filePath);
@@ -663,10 +685,13 @@ class ManifestGenerator {
     } else {
       // Fallback: use the collected workflows/agents/tasks
       for (const file of this.files) {
-        const filePath = path.join(this.bmadDir, file.path.replace(this.bmadFolderName + '/', ''));
+        // Strip the folder prefix if present (for consistency)
+        const relPath = file.path.replace(this.bmadFolderName + '/', '');
+        const filePath = path.join(this.bmadDir, relPath);
         const hash = await this.calculateFileHash(filePath);
         allFiles.push({
           ...file,
+          path: relPath,
           hash: hash,
         });
       }
@@ -687,6 +712,42 @@ class ManifestGenerator {
     await fs.writeFile(csvPath, csv);
     return csvPath;
   }
+
+  /**
+   * Scan the bmad directory to find all installed modules
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Array} List of module names
+   */
+  async scanInstalledModules(bmadDir) {
+    const modules = [];
+
+    try {
+      const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        // Skip if not a directory or is a special directory
+        if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === '_cfg') {
+          continue;
+        }
+
+        // Check if this looks like a module (has agents, workflows, or tasks directory)
+        const modulePath = path.join(bmadDir, entry.name);
+        const hasAgents = await fs.pathExists(path.join(modulePath, 'agents'));
+        const hasWorkflows = await fs.pathExists(path.join(modulePath, 'workflows'));
+        const hasTasks = await fs.pathExists(path.join(modulePath, 'tasks'));
+        const hasTools = await fs.pathExists(path.join(modulePath, 'tools'));
+
+        // If it has any of these directories, it's likely a module
+        if (hasAgents || hasWorkflows || hasTasks || hasTools) {
+          modules.push(entry.name);
+        }
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not scan for installed modules: ${error.message}`);
+    }
+
+    return modules;
+  }
 }
 
 module.exports = { ManifestGenerator };

package/tools/cli/installers/lib/core/post-install-sidecar-replacement.js

@@ -0,0 +1,79 @@
+/**
+ * Post-installation sidecar folder replacement utility
+ * Replaces {agent_sidecar_folder} placeholders in all installed agents
+ */
+
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('yaml');
+const glob = require('glob');
+const chalk = require('chalk');
+
+/**
+ * Replace {agent_sidecar_folder} placeholders in all agent files
+ * @param {string} bmadDir - Path to .bmad directory
+ * @returns {Object} Statistics about replacements made
+ */
+async function replaceAgentSidecarFolders(bmadDir) {
+  const results = {
+    filesScanned: 0,
+    filesReplaced: 0,
+    totalReplacements: 0,
+    errors: [],
+  };
+
+  try {
+    // Load core config to get agent_sidecar_folder value
+    const coreConfigPath = path.join(bmadDir, 'bmb', 'config.yaml');
+
+    if (!(await fs.pathExists(coreConfigPath))) {
+      throw new Error(`Core config not found at ${coreConfigPath}`);
+    }
+
+    const coreConfigContent = await fs.readFile(coreConfigPath, 'utf8');
+    const coreConfig = yaml.parse(coreConfigContent);
+    const agentSidecarFolder = coreConfig.agent_sidecar_folder;
+
+    // Use the literal value from config, don't resolve the placeholders
+    console.log(chalk.dim(`\n  Replacing {agent_sidecar_folder} with: ${agentSidecarFolder}`));
+
+    // Find all agent .md files
+    const agentPattern = path.join(bmadDir, '**/*.md');
+    const agentFiles = glob.sync(agentPattern);
+
+    for (const agentFile of agentFiles) {
+      results.filesScanned++;
+
+      try {
+        let content = await fs.readFile(agentFile, 'utf8');
+
+        // Check if file contains {agent_sidecar_folder}
+        if (content.includes('{agent_sidecar_folder}')) {
+          // Replace all occurrences
+          const originalContent = content;
+          content = content.replaceAll('{agent_sidecar_folder}', agentSidecarFolder);
+
+          // Only write if content changed
+          if (content !== originalContent) {
+            await fs.writeFile(agentFile, content, 'utf8');
+
+            const replacementCount = (originalContent.match(/{agent_sidecar_folder}/g) || []).length;
+            results.filesReplaced++;
+            results.totalReplacements += replacementCount;
+
+            console.log(chalk.dim(`    ✓ Replaced ${replacementCount} occurrence(s) in ${path.relative(bmadDir, agentFile)}`));
+          }
+        }
+      } catch (error) {
+        results.errors.push(`Error processing ${agentFile}: ${error.message}`);
+      }
+    }
+
+    return results;
+  } catch (error) {
+    results.errors.push(`Fatal error: ${error.message}`);
+    return results;
+  }
+}
+
+module.exports = { replaceAgentSidecarFolders };

package/tools/cli/installers/lib/custom/handler.js

@@ -0,0 +1,266 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const { FileOps } = require('../../../lib/file-ops');
+
+/**
+ * Handler for custom content (custom.yaml)
+ * Installs custom agents and workflows without requiring a full module structure
+ */
+class CustomHandler {
+  constructor() {
+    this.fileOps = new FileOps();
+  }
+
+  /**
+   * Find all custom.yaml files in the project
+   * @param {string} projectRoot - Project root directory
+   * @returns {Array} List of custom content paths
+   */
+  async findCustomContent(projectRoot) {
+    const customPaths = [];
+
+    // Helper function to recursively scan directories
+    async function scanDirectory(dir, excludePaths = []) {
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+
+          // Skip hidden directories and common exclusions
+          if (
+            entry.name.startsWith('.') ||
+            entry.name === 'node_modules' ||
+            entry.name === 'dist' ||
+            entry.name === 'build' ||
+            entry.name === '.git' ||
+            entry.name === 'bmad'
+          ) {
+            continue;
+          }
+
+          // Skip excluded paths
+          if (excludePaths.some((exclude) => fullPath.startsWith(exclude))) {
+            continue;
+          }
+
+          if (entry.isDirectory()) {
+            // Recursively scan subdirectories
+            await scanDirectory(fullPath, excludePaths);
+          } else if (entry.name === 'custom.yaml') {
+            // Found a custom.yaml file
+            customPaths.push(fullPath);
+          }
+        }
+      } catch {
+        // Ignore errors (e.g., permission denied)
+      }
+    }
+
+    // Scan the entire project, but exclude source directories
+    await scanDirectory(projectRoot, [path.join(projectRoot, 'src'), path.join(projectRoot, 'tools'), path.join(projectRoot, 'test')]);
+
+    return customPaths;
+  }
+
+  /**
+   * Get custom content info from a custom.yaml file
+   * @param {string} customYamlPath - Path to custom.yaml file
+   * @returns {Object|null} Custom content info
+   */
+  async getCustomInfo(customYamlPath) {
+    try {
+      const configContent = await fs.readFile(customYamlPath, 'utf8');
+
+      // Try to parse YAML with error handling
+      let config;
+      try {
+        config = yaml.load(configContent);
+      } catch (parseError) {
+        console.warn(chalk.yellow(`Warning: YAML parse error in ${customYamlPath}:`, parseError.message));
+        return null;
+      }
+
+      const customDir = path.dirname(customYamlPath);
+      const relativePath = path.relative(process.cwd(), customDir);
+
+      return {
+        id: config.code || path.basename(customDir),
+        name: config.name || `Custom: ${path.basename(customDir)}`,
+        description: config.description || 'Custom agents and workflows',
+        path: customDir,
+        relativePath: relativePath,
+        defaultSelected: config.default_selected === true,
+        config: config,
+      };
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Failed to read ${customYamlPath}:`, error.message));
+      return null;
+    }
+  }
+
+  /**
+   * Install custom content
+   * @param {string} customPath - Path to custom content directory
+   * @param {string} bmadDir - Target bmad directory
+   * @param {Object} config - Configuration from custom.yaml
+   * @param {Function} fileTrackingCallback - Optional callback to track installed files
+   * @returns {Object} Installation result
+   */
+  async install(customPath, bmadDir, config, fileTrackingCallback = null) {
+    const results = {
+      agentsInstalled: 0,
+      workflowsInstalled: 0,
+      filesCopied: 0,
+      preserved: 0,
+      errors: [],
+    };
+
+    try {
+      // Create custom directories in bmad
+      const bmadCustomDir = path.join(bmadDir, 'custom');
+      const bmadAgentsDir = path.join(bmadCustomDir, 'agents');
+      const bmadWorkflowsDir = path.join(bmadCustomDir, 'workflows');
+
+      await fs.ensureDir(bmadCustomDir);
+      await fs.ensureDir(bmadAgentsDir);
+      await fs.ensureDir(bmadWorkflowsDir);
+
+      // Process agents - copy entire agents directory structure
+      const agentsDir = path.join(customPath, 'agents');
+      if (await fs.pathExists(agentsDir)) {
+        await this.copyDirectory(agentsDir, bmadAgentsDir, results, fileTrackingCallback, config);
+
+        // Count agent files
+        const agentFiles = await this.findFilesRecursively(agentsDir, ['.agent.yaml', '.md']);
+        results.agentsInstalled = agentFiles.length;
+      }
+
+      // Process workflows - copy entire workflows directory structure
+      const workflowsDir = path.join(customPath, 'workflows');
+      if (await fs.pathExists(workflowsDir)) {
+        await this.copyDirectory(workflowsDir, bmadWorkflowsDir, results, fileTrackingCallback, config);
+
+        // Count workflow files
+        const workflowFiles = await this.findFilesRecursively(workflowsDir, ['.md']);
+        results.workflowsInstalled = workflowFiles.length;
+      }
+
+      // Process any additional files at root
+      const entries = await fs.readdir(customPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name !== 'custom.yaml' && !entry.name.startsWith('.') && !entry.name.endsWith('.md')) {
+          // Skip .md files at root as they're likely docs
+          const sourcePath = path.join(customPath, entry.name);
+          const targetPath = path.join(bmadCustomDir, entry.name);
+
+          try {
+            // Check if file already exists
+            if (await fs.pathExists(targetPath)) {
+              // File already exists, preserve it
+              results.preserved = (results.preserved || 0) + 1;
+            } else {
+              await fs.copy(sourcePath, targetPath);
+              results.filesCopied++;
+
+              if (fileTrackingCallback) {
+                fileTrackingCallback(targetPath);
+              }
+            }
+          } catch (error) {
+            results.errors.push(`Failed to copy file ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+    } catch (error) {
+      results.errors.push(`Installation failed: ${error.message}`);
+    }
+
+    return results;
+  }
+
+  /**
+   * Find all files with specific extensions recursively
+   * @param {string} dir - Directory to search
+   * @param {Array} extensions - File extensions to match
+   * @returns {Array} List of matching files
+   */
+  async findFilesRecursively(dir, extensions) {
+    const files = [];
+
+    async function search(currentDir) {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        if (entry.isDirectory()) {
+          await search(fullPath);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          files.push(fullPath);
+        }
+      }
+    }
+
+    await search(dir);
+    return files;
+  }
+
+  /**
+   * Recursively copy a directory
+   * @param {string} sourceDir - Source directory
+   * @param {string} targetDir - Target directory
+   * @param {Object} results - Results object to update
+   * @param {Function} fileTrackingCallback - Optional callback
+   * @param {Object} config - Configuration for placeholder replacement
+   */
+  async copyDirectory(sourceDir, targetDir, results, fileTrackingCallback, config) {
+    await fs.ensureDir(targetDir);
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const sourcePath = path.join(sourceDir, entry.name);
+      const targetPath = path.join(targetDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(sourcePath, targetPath, results, fileTrackingCallback, config);
+      } else {
+        try {
+          // Check if file already exists
+          if (await fs.pathExists(targetPath)) {
+            // File already exists, preserve it
+            results.preserved = (results.preserved || 0) + 1;
+          } else {
+            // Copy with placeholder replacement for text files
+            const textExtensions = ['.md', '.yaml', '.yml', '.txt', '.json'];
+            if (textExtensions.some((ext) => entry.name.endsWith(ext))) {
+              await this.fileOps.copyFile(sourcePath, targetPath, {
+                bmadFolder: config.bmad_folder || 'bmad',
+                userName: config.user_name || 'User',
+                communicationLanguage: config.communication_language || 'English',
+                outputFolder: config.output_folder || 'docs',
+              });
+            } else {
+              await fs.copy(sourcePath, targetPath);
+            }
+
+            results.filesCopied++;
+            if (fileTrackingCallback) {
+              fileTrackingCallback(targetPath);
+            }
+          }
+
+          if (entry.name.endsWith('.md')) {
+            results.workflowsInstalled++;
+          }
+        } catch (error) {
+          results.errors.push(`Failed to copy ${entry.name}: ${error.message}`);
+        }
+      }
+    }
+  }
+}
+
+module.exports = { CustomHandler };

package/tools/cli/installers/lib/ide/_base-ide.js

@@ -536,6 +536,11 @@ class BaseIdeSetup {
     if (typeof content === 'string' && content.includes('{bmad_folder}')) {
       content = content.replaceAll('{bmad_folder}', this.bmadFolderName);
     }
+
+    // Replace escape sequence {*bmad_folder*} with literal {bmad_folder}
+    if (typeof content === 'string' && content.includes('{*bmad_folder*}')) {
+      content = content.replaceAll('{*bmad_folder*}', '{bmad_folder}');
+    }
     await this.ensureDir(path.dirname(filePath));
     await fs.writeFile(filePath, content, 'utf8');
   }
@@ -563,6 +568,11 @@ class BaseIdeSetup {
           content = content.replaceAll('{bmad_folder}', this.bmadFolderName);
         }
 
+        // Replace escape sequence {*bmad_folder*} with literal {bmad_folder}
+        if (content.includes('{*bmad_folder*}')) {
+          content = content.replaceAll('{*bmad_folder*}', '{bmad_folder}');
+        }
+
         // Write to dest with replaced content
         await fs.writeFile(dest, content, 'utf8');
       } catch {

package/tools/cli/installers/lib/ide/auggie.js

@@ -3,6 +3,7 @@ const fs = require('fs-extra');
 const { BaseIdeSetup } = require('./_base-ide');
 const chalk = require('chalk');
 const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
 
 /**
  * Auggie CLI setup handler
@@ -33,10 +34,23 @@ class AuggieSetup extends BaseIdeSetup {
     const agentGen = new AgentCommandGenerator(this.bmadFolderName);
     const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
 
-    // Get tasks, tools, and workflows (standalone only)
+    // Get tasks, tools, and workflows (ALL workflows now generate commands)
     const tasks = await this.getTasks(bmadDir, true);
     const tools = await this.getTools(bmadDir, true);
-    const workflows = await this.getWorkflows(bmadDir, true);
+
+    // Get ALL workflows using the new workflow command generator
+    const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
+    const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
+
+    // Convert workflow artifacts to expected format
+    const workflows = workflowArtifacts
+      .filter((artifact) => artifact.type === 'workflow-command')
+      .map((artifact) => ({
+        module: artifact.module,
+        name: path.basename(artifact.relativePath, '.md'),
+        path: artifact.sourcePath,
+        content: artifact.content,
+      }));
 
     const bmadCommandsDir = path.join(location, 'bmad');
     const agentsDir = path.join(bmadCommandsDir, 'agents');
@@ -73,13 +87,11 @@ class AuggieSetup extends BaseIdeSetup {
       await this.writeFile(targetPath, commandContent);
     }
 
-    // Install workflows
+    // Install workflows (already generated commands)
     for (const workflow of workflows) {
-      const content = await this.readFile(workflow.path);
-      const commandContent = this.createWorkflowCommand(workflow, content);
-
+      // Use the pre-generated workflow command content
       const targetPath = path.join(workflowsDir, `${workflow.module}-${workflow.name}.md`);
-      await this.writeFile(targetPath, commandContent);
+      await this.writeFile(targetPath, workflow.content);
     }
 
     const totalInstalled = agentArtifacts.length + tasks.length + tools.length + workflows.length;