bmad-method 6.2.1-next.3 → 6.2.1-next.30

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

@@ -764,10 +764,10 @@ class Manifest {
     const configs = {};
 
     for (const moduleName of modules) {
-      // Handle core module differently - it's in src/core not src/modules/core
+      // Handle core module differently - it's in src/core-skills not src/modules/core
       const configPath =
         moduleName === 'core'
-          ? path.join(process.cwd(), 'src', 'core', 'config.yaml')
+          ? path.join(process.cwd(), 'src', 'core-skills', 'config.yaml')
           : path.join(process.cwd(), 'src', 'modules', moduleName, 'config.yaml');
 
       try {

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

@@ -2,19 +2,11 @@ const path = require('node:path');
 const fs = require('fs-extra');
 const yaml = require('yaml');
 const prompts = require('../../../lib/prompts');
-const { FileOps } = require('../../../lib/file-ops');
-const { XmlHandler } = require('../../../lib/xml-handler');
-
 /**
  * Handler for custom content (custom.yaml)
- * Installs custom agents and workflows without requiring a full module structure
+ * Discovers custom agents and workflows in the project
  */
 class CustomHandler {
-  constructor() {
-    this.fileOps = new FileOps();
-    this.xmlHandler = new XmlHandler();
-  }
-
   /**
    * Find all custom.yaml files in the project
    * @param {string} projectRoot - Project root directory
@@ -115,244 +107,6 @@ class CustomHandler {
       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 - compile and copy agents
-      const agentsDir = path.join(customPath, 'agents');
-      if (await fs.pathExists(agentsDir)) {
-        await this.compileAndCopyAgents(agentsDir, bmadAgentsDir, bmadDir, config, fileTrackingCallback, results);
-
-        // 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))) {
-              // Read source content
-              let content = await fs.readFile(sourcePath, 'utf8');
-
-              // Replace placeholders
-              content = content.replaceAll('{user_name}', config.user_name || 'User');
-              content = content.replaceAll('{communication_language}', config.communication_language || 'English');
-              content = content.replaceAll('{output_folder}', config.output_folder || 'docs');
-
-              // Write to target
-              await fs.ensureDir(path.dirname(targetPath));
-              await fs.writeFile(targetPath, content, 'utf8');
-            } else {
-              // Copy binary files as-is
-              await fs.copy(sourcePath, targetPath);
-            }
-
-            results.filesCopied++;
-            if (entry.name.endsWith('.md')) {
-              results.workflowsInstalled++;
-            }
-            if (fileTrackingCallback) {
-              fileTrackingCallback(targetPath);
-            }
-          }
-        } catch (error) {
-          results.errors.push(`Failed to copy ${entry.name}: ${error.message}`);
-        }
-      }
-    }
-  }
-
-  /**
-   * Compile .agent.yaml files to .md format and handle sidecars
-   * @param {string} sourceAgentsPath - Source agents directory
-   * @param {string} targetAgentsPath - Target agents directory
-   * @param {string} bmadDir - BMAD installation directory
-   * @param {Object} config - Configuration for placeholder replacement
-   * @param {Function} fileTrackingCallback - Optional callback to track installed files
-   * @param {Object} results - Results object to update
-   */
-  async compileAndCopyAgents(sourceAgentsPath, targetAgentsPath, bmadDir, config, fileTrackingCallback, results) {
-    // Get all .agent.yaml files recursively
-    const agentFiles = await this.findFilesRecursively(sourceAgentsPath, ['.agent.yaml']);
-
-    for (const agentFile of agentFiles) {
-      const relativePath = path.relative(sourceAgentsPath, agentFile).split(path.sep).join('/');
-      const targetDir = path.join(targetAgentsPath, path.dirname(relativePath));
-
-      await fs.ensureDir(targetDir);
-
-      const agentName = path.basename(agentFile, '.agent.yaml');
-      const targetMdPath = path.join(targetDir, `${agentName}.md`);
-      // Use the actual bmadDir if available (for when installing to temp dir)
-      const actualBmadDir = config._bmadDir || bmadDir;
-      const customizePath = path.join(actualBmadDir, '_config', 'agents', `custom-${agentName}.customize.yaml`);
-
-      // Read and compile the YAML
-      try {
-        const yamlContent = await fs.readFile(agentFile, 'utf8');
-        const { compileAgent } = require('../../../lib/agent/compiler');
-
-        // Create customize template if it doesn't exist
-        if (!(await fs.pathExists(customizePath))) {
-          const { getSourcePath } = require('../../../lib/project-root');
-          const genericTemplatePath = getSourcePath('utility', 'agent-components', 'agent.customize.template.yaml');
-          if (await fs.pathExists(genericTemplatePath)) {
-            let templateContent = await fs.readFile(genericTemplatePath, 'utf8');
-            await fs.writeFile(customizePath, templateContent, 'utf8');
-            // Only show customize creation in verbose mode
-            if (process.env.BMAD_VERBOSE_INSTALL === 'true') {
-              await prompts.log.message('  Created customize: custom-' + agentName + '.customize.yaml');
-            }
-          }
-        }
-
-        // Compile the agent
-        const { xml } = compileAgent(yamlContent, {}, agentName, relativePath, { config });
-
-        // Replace placeholders in the compiled content
-        let processedXml = xml;
-        processedXml = processedXml.replaceAll('{user_name}', config.user_name || 'User');
-        processedXml = processedXml.replaceAll('{communication_language}', config.communication_language || 'English');
-        processedXml = processedXml.replaceAll('{output_folder}', config.output_folder || 'docs');
-
-        // Write the compiled MD file
-        await fs.writeFile(targetMdPath, processedXml, 'utf8');
-
-        // Track the file
-        if (fileTrackingCallback) {
-          fileTrackingCallback(targetMdPath);
-        }
-
-        // Only show compilation details in verbose mode
-        if (process.env.BMAD_VERBOSE_INSTALL === 'true') {
-          await prompts.log.message('    Compiled agent: ' + agentName + ' -> ' + path.relative(targetAgentsPath, targetMdPath));
-        }
-      } catch (error) {
-        await prompts.log.warn('    Failed to compile agent ' + agentName + ': ' + error.message);
-        results.errors.push(`Failed to compile agent ${agentName}: ${error.message}`);
-      }
-    }
-  }
 }
 
 module.exports = { CustomHandler };

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

@@ -1,6 +1,5 @@
 const path = require('node:path');
 const fs = require('fs-extra');
-const { XmlHandler } = require('../../../lib/xml-handler');
 const prompts = require('../../../lib/prompts');
 const { getSourcePath } = require('../../../lib/project-root');
 const { BMAD_FOLDER_NAME } = require('./shared/path-utils');
@@ -18,7 +17,6 @@ class BaseIdeSetup {
     this.rulesDir = null; // Override in subclasses
     this.configFile = null; // Override in subclasses when detection is file-based
     this.detectionPaths = []; // Additional paths that indicate the IDE is configured
-    this.xmlHandler = new XmlHandler();
     this.bmadFolderName = BMAD_FOLDER_NAME; // Default, can be overridden
   }
 
@@ -30,15 +28,6 @@ class BaseIdeSetup {
     this.bmadFolderName = bmadFolderName;
   }
 
-  /**
-   * Get the agent command activation header from the central template
-   * @returns {string} The activation header text
-   */
-  async getAgentCommandHeader() {
-    const headerPath = getSourcePath('utility', 'agent-components', 'agent-command-header.md');
-    return await fs.readFile(headerPath, 'utf8');
-  }
-
   /**
    * Main setup method - must be implemented by subclasses
    * @param {string} projectDir - Project directory
@@ -511,11 +500,6 @@ class BaseIdeSetup {
     // Replace placeholders
     let processed = content;
 
-    // Inject activation block for agent files FIRST (before replacements)
-    if (metadata.name && content.includes('<agent')) {
-      processed = this.xmlHandler.injectActivationSimple(processed, metadata);
-    }
-
     // Only replace {project-root} if a specific projectDir is provided
     // Otherwise leave the placeholder intact
     // Note: Don't add trailing slash - paths in source include leading slash

package/tools/cli/installers/lib/ide/_config-driven.js

@@ -4,9 +4,6 @@ const fs = require('fs-extra');
 const yaml = require('yaml');
 const { BaseIdeSetup } = require('./_base-ide');
 const prompts = require('../../../lib/prompts');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
-const { TaskToolCommandGenerator } = require('./shared/task-tool-command-generator');
 const csv = require('csv-parse/sync');
 
 /**
@@ -115,53 +112,20 @@ class ConfigDrivenIdeSetup extends BaseIdeSetup {
    * @returns {Promise<Object>} Installation result
    */
   async installToTarget(projectDir, bmadDir, config, options) {
-    const { target_dir, template_type, artifact_types } = config;
+    const { target_dir } = config;
 
-    // Skip targets with explicitly empty artifact_types and no verbatim skills
-    // This prevents creating empty directories when no artifacts will be written
-    const skipStandardArtifacts = Array.isArray(artifact_types) && artifact_types.length === 0;
-    if (skipStandardArtifacts && !config.skill_format) {
-      return { success: true, results: { agents: 0, workflows: 0, tasks: 0, tools: 0, skills: 0 } };
+    if (!config.skill_format) {
+      return { success: false, reason: 'missing-skill-format', error: 'Installer config missing skill_format — cannot install skills' };
     }
 
     const targetPath = path.join(projectDir, target_dir);
     await this.ensureDir(targetPath);
 
-    const selectedModules = options.selectedModules || [];
-    const results = { agents: 0, workflows: 0, tasks: 0, tools: 0, skills: 0 };
-    this.skillWriteTracker = config.skill_format ? new Set() : null;
-
-    // Install standard artifacts (agents, workflows, tasks, tools)
-    if (!skipStandardArtifacts) {
-      // Install agents
-      if (!artifact_types || artifact_types.includes('agents')) {
-        const agentGen = new AgentCommandGenerator(this.bmadFolderName);
-        const { artifacts } = await agentGen.collectAgentArtifacts(bmadDir, selectedModules);
-        results.agents = await this.writeAgentArtifacts(targetPath, artifacts, template_type, config);
-      }
-
-      // Install workflows
-      if (!artifact_types || artifact_types.includes('workflows')) {
-        const workflowGen = new WorkflowCommandGenerator(this.bmadFolderName);
-        const { artifacts } = await workflowGen.collectWorkflowArtifacts(bmadDir);
-        results.workflows = await this.writeWorkflowArtifacts(targetPath, artifacts, template_type, config);
-      }
-
-      // Install tasks and tools using template system (supports TOML for Gemini, MD for others)
-      if (!artifact_types || artifact_types.includes('tasks') || artifact_types.includes('tools')) {
-        const taskToolGen = new TaskToolCommandGenerator(this.bmadFolderName);
-        const { artifacts } = await taskToolGen.collectTaskToolArtifacts(bmadDir);
-        const taskToolResult = await this.writeTaskToolArtifacts(targetPath, artifacts, template_type, config);
-        results.tasks = taskToolResult.tasks || 0;
-        results.tools = taskToolResult.tools || 0;
-      }
-    }
+    this.skillWriteTracker = new Set();
+    const results = { skills: 0 };
 
-    // Install verbatim skills (type: skill)
-    if (config.skill_format) {
-      results.skills = await this.installVerbatimSkills(projectDir, bmadDir, targetPath, config);
-      results.skillDirectories = this.skillWriteTracker ? this.skillWriteTracker.size : 0;
-    }
+    results.skills = await this.installVerbatimSkills(projectDir, bmadDir, targetPath, config);
+    results.skillDirectories = this.skillWriteTracker.size;
 
     await this.printSummary(results, target_dir, options);
     this.skillWriteTracker = null;
@@ -177,15 +141,11 @@ class ConfigDrivenIdeSetup extends BaseIdeSetup {
    * @returns {Promise<Object>} Installation result
    */
   async installToMultipleTargets(projectDir, bmadDir, targets, options) {
-    const allResults = { agents: 0, workflows: 0, tasks: 0, tools: 0, skills: 0 };
+    const allResults = { skills: 0 };
 
     for (const target of targets) {
       const result = await this.installToTarget(projectDir, bmadDir, target, options);
       if (result.success) {
-        allResults.agents += result.results.agents || 0;
-        allResults.workflows += result.results.workflows || 0;
-        allResults.tasks += result.results.tasks || 0;
-        allResults.tools += result.results.tools || 0;
         allResults.skills += result.results.skills || 0;
       }
     }
@@ -193,118 +153,6 @@ class ConfigDrivenIdeSetup extends BaseIdeSetup {
     return { success: true, results: allResults };
   }
 
-  /**
-   * Write agent artifacts to target directory
-   * @param {string} targetPath - Target directory path
-   * @param {Array} artifacts - Agent artifacts
-   * @param {string} templateType - Template type to use
-   * @param {Object} config - Installation configuration
-   * @returns {Promise<number>} Count of artifacts written
-   */
-  async writeAgentArtifacts(targetPath, artifacts, templateType, config = {}) {
-    // Try to load platform-specific template, fall back to default-agent
-    const { content: template, extension } = await this.loadTemplate(templateType, 'agent', config, 'default-agent');
-    let count = 0;
-
-    for (const artifact of artifacts) {
-      const content = this.renderTemplate(template, artifact);
-      const filename = this.generateFilename(artifact, 'agent', extension);
-
-      if (config.skill_format) {
-        await this.writeSkillFile(targetPath, artifact, content);
-      } else {
-        const filePath = path.join(targetPath, filename);
-        await this.writeFile(filePath, content);
-      }
-      count++;
-    }
-
-    return count;
-  }
-
-  /**
-   * Write workflow artifacts to target directory
-   * @param {string} targetPath - Target directory path
-   * @param {Array} artifacts - Workflow artifacts
-   * @param {string} templateType - Template type to use
-   * @param {Object} config - Installation configuration
-   * @returns {Promise<number>} Count of artifacts written
-   */
-  async writeWorkflowArtifacts(targetPath, artifacts, templateType, config = {}) {
-    let count = 0;
-
-    for (const artifact of artifacts) {
-      if (artifact.type === 'workflow-command') {
-        const workflowTemplateType = config.md_workflow_template || `${templateType}-workflow`;
-        const { content: template, extension } = await this.loadTemplate(workflowTemplateType, '', config, 'default-workflow');
-        const content = this.renderTemplate(template, artifact);
-        const filename = this.generateFilename(artifact, 'workflow', extension);
-
-        if (config.skill_format) {
-          await this.writeSkillFile(targetPath, artifact, content);
-        } else {
-          const filePath = path.join(targetPath, filename);
-          await this.writeFile(filePath, content);
-        }
-        count++;
-      }
-    }
-
-    return count;
-  }
-
-  /**
-   * Write task/tool artifacts to target directory using templates
-   * @param {string} targetPath - Target directory path
-   * @param {Array} artifacts - Task/tool artifacts
-   * @param {string} templateType - Template type to use
-   * @param {Object} config - Installation configuration
-   * @returns {Promise<Object>} Counts of tasks and tools written
-   */
-  async writeTaskToolArtifacts(targetPath, artifacts, templateType, config = {}) {
-    let taskCount = 0;
-    let toolCount = 0;
-
-    // Pre-load templates to avoid repeated file I/O in the loop
-    const taskTemplate = await this.loadTemplate(templateType, 'task', config, 'default-task');
-    const toolTemplate = await this.loadTemplate(templateType, 'tool', config, 'default-tool');
-
-    const { artifact_types } = config;
-
-    for (const artifact of artifacts) {
-      if (artifact.type !== 'task' && artifact.type !== 'tool') {
-        continue;
-      }
-
-      // Skip if the specific artifact type is not requested in config
-      if (artifact_types) {
-        if (artifact.type === 'task' && !artifact_types.includes('tasks')) continue;
-        if (artifact.type === 'tool' && !artifact_types.includes('tools')) continue;
-      }
-
-      // Use pre-loaded template based on artifact type
-      const { content: template, extension } = artifact.type === 'task' ? taskTemplate : toolTemplate;
-
-      const content = this.renderTemplate(template, artifact);
-      const filename = this.generateFilename(artifact, artifact.type, extension);
-
-      if (config.skill_format) {
-        await this.writeSkillFile(targetPath, artifact, content);
-      } else {
-        const filePath = path.join(targetPath, filename);
-        await this.writeFile(filePath, content);
-      }
-
-      if (artifact.type === 'task') {
-        taskCount++;
-      } else {
-        toolCount++;
-      }
-    }
-
-    return { tasks: taskCount, tools: toolCount };
-  }
-
   /**
    * Load template based on type and configuration
    * @param {string} templateType - Template type (claude, windsurf, etc.)
@@ -630,7 +478,7 @@ LOAD and execute from: {project-root}/{{bmadFolderName}}/{{path}}
   }
 
   /**
-   * Install verbatim skill directories (type: skill entries from skill-manifest.csv).
+   * Install verbatim native SKILL.md directories from skill-manifest.csv.
    * Copies the entire source directory as-is into the IDE skill directory.
    * The source SKILL.md is used directly — no frontmatter transformation or file generation.
    * @param {string} projectDir - Project directory
@@ -711,13 +559,10 @@ LOAD and execute from: {project-root}/{{bmadFolderName}}/{{path}}
    */
   async printSummary(results, targetDir, options = {}) {
     if (options.silent) return;
-    const parts = [];
-    const totalDirs =
-      results.skillDirectories || (results.workflows || 0) + (results.tasks || 0) + (results.tools || 0) + (results.skills || 0);
-    const skillCount = totalDirs - (results.agents || 0);
-    if (skillCount > 0) parts.push(`${skillCount} skills`);
-    if (results.agents > 0) parts.push(`${results.agents} agents`);
-    await prompts.log.success(`${this.name} configured: ${parts.join(', ')} → ${targetDir}`);
+    const count = results.skillDirectories || results.skills || 0;
+    if (count > 0) {
+      await prompts.log.success(`${this.name} configured: ${count} skills → ${targetDir}`);
+    }
   }
 
   /**

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

@@ -159,14 +159,9 @@ class IdeManager {
       // Build detail string from handler-returned data
       let detail = '';
       if (handlerResult && handlerResult.results) {
-        // Config-driven handlers return { success, results: { agents, workflows, tasks, tools } }
         const r = handlerResult.results;
-        const parts = [];
-        const totalDirs = r.skillDirectories || (r.workflows || 0) + (r.tasks || 0) + (r.tools || 0) + (r.skills || 0);
-        const skillCount = totalDirs - (r.agents || 0);
-        if (skillCount > 0) parts.push(`${skillCount} skills`);
-        if (r.agents > 0) parts.push(`${r.agents} agents`);
-        detail = parts.join(', ');
+        const count = r.skillDirectories || r.skills || 0;
+        if (count > 0) detail = `${count} skills`;
       }
       // Propagate handler's success status (default true for backward compat)
       const success = handlerResult?.success !== false;

package/tools/cli/installers/lib/ide/shared/agent-command-generator.js

@@ -4,7 +4,6 @@ const { toColonPath, toDashPath, customAgentColonName, customAgentDashName, BMAD
 
 /**
  * Generates launcher command files for each agent
- * Similar to WorkflowCommandGenerator but for agents
  */
 class AgentCommandGenerator {
   constructor(bmadFolderName = BMAD_FOLDER_NAME) {

package/tools/cli/installers/lib/ide/shared/skill-manifest.js

@@ -27,7 +27,7 @@ async function loadSkillManifest(dirPath) {
 /**
  * Get the canonicalId for a specific file from a loaded skill manifest.
  * @param {Object|null} manifest - Loaded manifest (from loadSkillManifest)
- * @param {string} filename - Source filename to look up (e.g., 'pm.md', 'help.md', 'pm.agent.yaml')
+ * @param {string} filename - Source filename to look up (e.g., 'pm.md', 'help.md')
  * @returns {string} canonicalId or empty string
  */
 function getCanonicalId(manifest, filename) {
@@ -36,12 +36,6 @@ function getCanonicalId(manifest, filename) {
   if (manifest.__single) return manifest.__single.canonicalId || '';
   // Multi-entry: look up by filename directly
   if (manifest[filename]) return manifest[filename].canonicalId || '';
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].canonicalId || '';
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].canonicalId || '';
   return '';
 }
 
@@ -57,12 +51,6 @@ function getArtifactType(manifest, filename) {
   if (manifest.__single) return manifest.__single.type || null;
   // Multi-entry: look up by filename directly
   if (manifest[filename]) return manifest[filename].type || null;
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].type || null;
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].type || null;
   return null;
 }
 
@@ -78,12 +66,6 @@ function getInstallToBmad(manifest, filename) {
   if (manifest.__single) return manifest.__single.install_to_bmad !== false;
   // Multi-entry: look up by filename directly
   if (manifest[filename]) return manifest[filename].install_to_bmad !== false;
-  // Fallback: try alternate extensions for compiled files
-  const baseName = filename.replace(/\.(md|xml)$/i, '');
-  const agentKey = `${baseName}.agent.yaml`;
-  if (manifest[agentKey]) return manifest[agentKey].install_to_bmad !== false;
-  const xmlKey = `${baseName}.xml`;
-  if (manifest[xmlKey]) return manifest[xmlKey].install_to_bmad !== false;
   return true;
 }