bmad-method 4.27.6 → 5.0.0

package/tools/installer/lib/installer.js

@@ -2,7 +2,6 @@ const path = require("node:path");
 const fileManager = require("./file-manager");
 const configLoader = require("./config-loader");
 const ideSetup = require("./ide-setup");
-const { extractYamlFromAgent } = require("../../lib/yaml-utils");
 
 // Dynamic imports for ES modules
 let chalk, ora, inquirer;
@@ -17,20 +16,6 @@ async function initializeModules() {
 }
 
 class Installer {
-  async getCoreVersion() {
-    const yaml = require("js-yaml");
-    const fs = require("fs-extra");
-    const coreConfigPath = path.join(__dirname, "../../../bmad-core/core-config.yaml");
-    try {
-      const coreConfigContent = await fs.readFile(coreConfigPath, "utf8");
-      const coreConfig = yaml.load(coreConfigContent);
-      return coreConfig.version || "unknown";
-    } catch (error) {
-      console.warn("Could not read version from core-config.yaml, using 'unknown'");
-      return "unknown";
-    }
-  }
-
   async install(config) {
     // Initialize ES modules
     await initializeModules();
@@ -38,23 +23,12 @@ class Installer {
     const spinner = ora("Analyzing installation directory...").start();
 
     try {
-      // Store the original CWD where npx was executed
-      const originalCwd = process.env.INIT_CWD || process.env.PWD || process.cwd();
-      
-      // Resolve installation directory relative to where the user ran the command
-      let installDir = path.isAbsolute(config.directory) 
-        ? config.directory 
-        : path.resolve(originalCwd, config.directory);
-        
+      // Resolve installation directory
+      let installDir = path.resolve(config.directory);
       if (path.basename(installDir) === '.bmad-core') {
         // If user points directly to .bmad-core, treat its parent as the project root
         installDir = path.dirname(installDir);
       }
-      
-      // Log resolved path for clarity
-      if (!path.isAbsolute(config.directory)) {
-        spinner.text = `Resolving "${config.directory}" to: ${installDir}`;
-      }
 
       // Check if directory exists and handle non-existent directories
       if (!(await fileManager.pathExists(installDir))) {
@@ -100,7 +74,6 @@ class Installer {
               }
             }
           ]);
-          // Preserve the original CWD for the recursive call
           config.directory = newDirectory;
           return await this.install(config); // Recursive call with new directory
         } else if (action === 'create') {
@@ -117,17 +90,6 @@ class Installer {
         spinner.start("Analyzing installation directory...");
       }
 
-      // If this is an update request from early detection, handle it directly
-      if (config.installType === 'update') {
-        const state = await this.detectInstallationState(installDir);
-        if (state.type === 'v4_existing') {
-          return await this.performUpdate(config, installDir, state.manifest, spinner);
-        } else {
-          spinner.fail('No existing v4 installation found to update');
-          throw new Error('No existing v4 installation found');
-        }
-      }
-
       // Detect current state
       const state = await this.detectInstallationState(installDir);
 
@@ -176,7 +138,6 @@ class Installer {
       hasBmadCore: false,
       hasOtherFiles: false,
       manifest: null,
-      expansionPacks: {},
     };
 
     // Check if directory exists
@@ -186,7 +147,7 @@ class Installer {
 
     // Check for V4 installation (has .bmad-core with manifest)
     const bmadCorePath = path.join(installDir, ".bmad-core");
-    const manifestPath = path.join(bmadCorePath, "install-manifest.yaml");
+    const manifestPath = path.join(bmadCorePath, "install-manifest.yml");
 
     if (await fileManager.pathExists(manifestPath)) {
       state.type = "v4_existing";
@@ -220,22 +181,18 @@ class Installer {
     });
 
     if (files.length > 0) {
-      // Directory has other files, but no BMad installation.
+      // Directory has other files, but no BMAD installation.
       // Treat as clean install but record that it isn't empty.
       state.hasOtherFiles = true;
     }
 
-    // Check for expansion packs (folders starting with .)
-    const expansionPacks = await this.detectExpansionPacks(installDir);
-    state.expansionPacks = expansionPacks;
-
     return state; // clean install
   }
 
-  async performFreshInstall(config, installDir, spinner, options = {}) {
+  async performFreshInstall(config, installDir, spinner) {
     // Ensure modules are initialized
     await initializeModules();
-    spinner.text = "Installing BMad Method...";
+    spinner.text = "Installing BMAD Method...";
 
     let files = [];
 
@@ -244,11 +201,7 @@ class Installer {
       spinner.text = "Copying complete .bmad-core folder...";
       const sourceDir = configLoader.getBmadCorePath();
       const bmadCoreDestDir = path.join(installDir, ".bmad-core");
-      await fileManager.copyDirectoryWithRootReplacement(sourceDir, bmadCoreDestDir, ".bmad-core");
-      
-      // Copy common/ items to .bmad-core
-      spinner.text = "Copying common utilities...";
-      await this.copyCommonItems(installDir, ".bmad-core", spinner);
+      await fileManager.copyDirectory(sourceDir, bmadCoreDestDir);
 
       // Get list of all files for manifest
       const glob = require("glob");
@@ -263,16 +216,15 @@ class Installer {
       // Single agent installation
       spinner.text = `Installing ${config.agent} agent...`;
 
-      // Copy agent file with {root} replacement
+      // Copy agent file
       const agentPath = configLoader.getAgentPath(config.agent);
       const destAgentPath = path.join(
         installDir,
-        ".bmad-core",
         "agents",
         `${config.agent}.md`
       );
-      await fileManager.copyFileWithRootReplacement(agentPath, destAgentPath, ".bmad-core");
-      files.push(`.bmad-core/agents/${config.agent}.md`);
+      await fileManager.copyFile(agentPath, destAgentPath);
+      files.push(`agents/${config.agent}.md`);
 
       // Copy dependencies
       const dependencies = await configLoader.getAgentDependencies(
@@ -284,108 +236,29 @@ class Installer {
         spinner.text = `Copying dependency: ${dep}`;
 
         if (dep.includes("*")) {
-          // Handle glob patterns with {root} replacement
+          // Handle glob patterns
           const copiedFiles = await fileManager.copyGlobPattern(
             dep.replace(".bmad-core/", ""),
             sourceBase,
-            path.join(installDir, ".bmad-core"),
-            ".bmad-core"
+            installDir
           );
-          files.push(...copiedFiles.map(f => `.bmad-core/${f}`));
+          files.push(...copiedFiles);
         } else {
-          // Handle single files with {root} replacement if needed
+          // Handle single files
           const sourcePath = path.join(
             sourceBase,
             dep.replace(".bmad-core/", "")
           );
           const destPath = path.join(
             installDir,
-            dep
-          );
-
-          const needsRootReplacement = dep.endsWith('.md') || dep.endsWith('.yaml') || dep.endsWith('.yml');
-          let success = false;
-          
-          if (needsRootReplacement) {
-            success = await fileManager.copyFileWithRootReplacement(sourcePath, destPath, ".bmad-core");
-          } else {
-            success = await fileManager.copyFile(sourcePath, destPath);
-          }
-
-          if (success) {
-            files.push(dep);
-          }
-        }
-      }
-      
-      // Copy common/ items to .bmad-core
-      spinner.text = "Copying common utilities...";
-      const commonFiles = await this.copyCommonItems(installDir, ".bmad-core", spinner);
-      files.push(...commonFiles);
-    } else if (config.installType === "team") {
-      // Team installation
-      spinner.text = `Installing ${config.team} team...`;
-      
-      // Get team dependencies
-      const teamDependencies = await configLoader.getTeamDependencies(config.team);
-      const sourceBase = configLoader.getBmadCorePath();
-      
-      // Install all team dependencies
-      for (const dep of teamDependencies) {
-        spinner.text = `Copying team dependency: ${dep}`;
-        
-        if (dep.includes("*")) {
-          // Handle glob patterns with {root} replacement
-          const copiedFiles = await fileManager.copyGlobPattern(
-            dep.replace(".bmad-core/", ""),
-            sourceBase,
-            path.join(installDir, ".bmad-core"),
-            ".bmad-core"
+            dep.replace(".bmad-core/", "")
           );
-          files.push(...copiedFiles.map(f => `.bmad-core/${f}`));
-        } else {
-          // Handle single files with {root} replacement if needed
-          const sourcePath = path.join(sourceBase, dep.replace(".bmad-core/", ""));
-          const destPath = path.join(installDir, dep);
-          
-          const needsRootReplacement = dep.endsWith('.md') || dep.endsWith('.yaml') || dep.endsWith('.yml');
-          let success = false;
-          
-          if (needsRootReplacement) {
-            success = await fileManager.copyFileWithRootReplacement(sourcePath, destPath, ".bmad-core");
-          } else {
-            success = await fileManager.copyFile(sourcePath, destPath);
-          }
 
-          if (success) {
-            files.push(dep);
+          if (await fileManager.copyFile(sourcePath, destPath)) {
+            files.push(dep.replace(".bmad-core/", ""));
           }
         }
       }
-      
-      // Copy common/ items to .bmad-core
-      spinner.text = "Copying common utilities...";
-      const commonFiles = await this.copyCommonItems(installDir, ".bmad-core", spinner);
-      files.push(...commonFiles);
-    } else if (config.installType === "expansion-only") {
-      // Expansion-only installation - DO NOT create .bmad-core
-      // Only install expansion packs
-      spinner.text = "Installing expansion packs only...";
-    }
-
-    // Install expansion packs if requested
-    const expansionFiles = await this.installExpansionPacks(installDir, config.expansionPacks, spinner, config);
-    files.push(...expansionFiles);
-
-    // Install web bundles if requested
-    if (config.includeWebBundles && config.webBundlesDirectory) {
-      spinner.text = "Installing web bundles...";
-      // Resolve web bundles directory using the same logic as the main installation directory
-      const originalCwd = process.env.INIT_CWD || process.env.PWD || process.cwd();
-      let resolvedWebBundlesDir = path.isAbsolute(config.webBundlesDirectory) 
-        ? config.webBundlesDirectory 
-        : path.resolve(originalCwd, config.webBundlesDirectory);
-      await this.installWebBundles(resolvedWebBundlesDir, config, spinner);
     }
 
     // Set up IDE integration if requested
@@ -393,25 +266,16 @@ class Installer {
     if (ides.length > 0) {
       for (const ide of ides) {
         spinner.text = `Setting up ${ide} integration...`;
-        const preConfiguredSettings = ide === 'github-copilot' ? config.githubCopilotConfig : null;
-        await ideSetup.setup(ide, installDir, config.agent, spinner, preConfiguredSettings);
+        await ideSetup.setup(ide, installDir, config.agent);
       }
     }
 
-    // Modify core-config.yaml if sharding preferences were provided
-    if (config.installType !== "expansion-only" && (config.prdSharded !== undefined || config.architectureSharded !== undefined)) {
-      spinner.text = "Configuring document sharding settings...";
-      await fileManager.modifyCoreConfig(installDir, config);
-    }
-
-    // Create manifest (skip for expansion-only installations)
-    if (config.installType !== "expansion-only") {
-      spinner.text = "Creating installation manifest...";
-      await fileManager.createManifest(installDir, config, files);
-    }
+    // Create manifest
+    spinner.text = "Creating installation manifest...";
+    await fileManager.createManifest(installDir, config, files);
 
     spinner.succeed("Installation complete!");
-    this.showSuccessMessage(config, installDir, options);
+    this.showSuccessMessage(config, installDir);
   }
 
   async handleExistingV4Installation(config, installDir, state, spinner) {
@@ -419,137 +283,33 @@ class Installer {
     await initializeModules();
     spinner.stop();
 
-    const currentVersion = state.manifest.version;
-    const newVersion = await this.getCoreVersion();
-    const versionCompare = this.compareVersions(currentVersion, newVersion);
-
-    console.log(chalk.yellow("\n🔍 Found existing BMad v4 installation"));
+    console.log(chalk.yellow("\n🔍 Found existing BMAD v4 installation"));
     console.log(`   Directory: ${installDir}`);
-    console.log(`   Current version: ${currentVersion}`);
-    console.log(`   Available version: ${newVersion}`);
+    console.log(`   Version: ${state.manifest.version}`);
     console.log(
       `   Installed: ${new Date(
         state.manifest.installed_at
       ).toLocaleDateString()}`
     );
 
-    // Check file integrity
-    spinner.start("Checking installation integrity...");
-    const integrity = await fileManager.checkFileIntegrity(installDir, state.manifest);
-    spinner.stop();
-    
-    const hasMissingFiles = integrity.missing.length > 0;
-    const hasModifiedFiles = integrity.modified.length > 0;
-    const hasIntegrityIssues = hasMissingFiles || hasModifiedFiles;
-    
-    if (hasIntegrityIssues) {
-      console.log(chalk.red("\n⚠️  Installation issues detected:"));
-      if (hasMissingFiles) {
-        console.log(chalk.red(`   Missing files: ${integrity.missing.length}`));
-        if (integrity.missing.length <= 5) {
-          integrity.missing.forEach(file => console.log(chalk.dim(`     - ${file}`)));
-        }
-      }
-      if (hasModifiedFiles) {
-        console.log(chalk.yellow(`   Modified files: ${integrity.modified.length}`));
-        if (integrity.modified.length <= 5) {
-          integrity.modified.forEach(file => console.log(chalk.dim(`     - ${file}`)));
-        }
-      }
-    }
-
-    // Show existing expansion packs
-    if (Object.keys(state.expansionPacks).length > 0) {
-      console.log(chalk.cyan("\n📦 Installed expansion packs:"));
-      for (const [packId, packInfo] of Object.entries(state.expansionPacks)) {
-        if (packInfo.hasManifest && packInfo.manifest) {
-          console.log(`   - ${packId} (v${packInfo.manifest.version || 'unknown'})`);
-        } else {
-          console.log(`   - ${packId} (no manifest)`);
-        }
-      }
-    }
-
-    let choices = [];
-    
-    if (versionCompare < 0) {
-      console.log(chalk.cyan("\n⬆️  Upgrade available for BMad core"));
-      choices.push({ name: `Upgrade BMad core (v${currentVersion} → v${newVersion})`, value: "upgrade" });
-    } else if (versionCompare === 0) {
-      if (hasIntegrityIssues) {
-        // Offer repair option when files are missing or modified
-        choices.push({ 
-          name: "Repair installation (restore missing/modified files)", 
-          value: "repair" 
-        });
-      }
-      console.log(chalk.yellow("\n⚠️  Same version already installed"));
-      choices.push({ name: `Force reinstall BMad core (v${currentVersion} - reinstall)`, value: "reinstall" });
-    } else {
-      console.log(chalk.yellow("\n⬇️  Installed version is newer than available"));
-      choices.push({ name: `Downgrade BMad core (v${currentVersion} → v${newVersion})`, value: "reinstall" });
-    }
-    
-    choices.push(
-      { name: "Add/update expansion packs only", value: "expansions" },
-      { name: "Cancel", value: "cancel" }
-    );
-
     const { action } = await inquirer.prompt([
       {
         type: "list",
         name: "action",
         message: "What would you like to do?",
-        choices: choices,
+        choices: [
+          { name: "Update existing installation", value: "update" },
+          { name: "Reinstall (overwrite)", value: "reinstall" },
+          { name: "Cancel", value: "cancel" },
+        ],
       },
     ]);
 
     switch (action) {
-      case "upgrade":
+      case "update":
         return await this.performUpdate(config, installDir, state.manifest, spinner);
-      case "repair":
-        // For repair, restore missing/modified files while backing up modified ones
-        return await this.performRepair(config, installDir, state.manifest, integrity, spinner);
       case "reinstall":
-        // For reinstall, don't check for modifications - just overwrite
         return await this.performReinstall(config, installDir, spinner);
-      case "expansions":
-        // Ask which expansion packs to install
-        const availableExpansionPacks = await this.getAvailableExpansionPacks();
-        
-        if (availableExpansionPacks.length === 0) {
-          console.log(chalk.yellow("No expansion packs available."));
-          return;
-        }
-        
-        const { selectedPacks } = await inquirer.prompt([
-          {
-            type: 'checkbox',
-            name: 'selectedPacks',
-            message: 'Select expansion packs to install/update:',
-            choices: availableExpansionPacks.map(pack => ({
-              name: `${pack.name} v${pack.version} - ${pack.description}`,
-              value: pack.id,
-              checked: state.expansionPacks[pack.id] !== undefined
-            }))
-          }
-        ]);
-        
-        if (selectedPacks.length === 0) {
-          console.log(chalk.yellow("No expansion packs selected."));
-          return;
-        }
-        
-        spinner.start("Installing expansion packs...");
-        const expansionFiles = await this.installExpansionPacks(installDir, selectedPacks, spinner, { ides: config.ides || [] });
-        spinner.succeed("Expansion packs installed successfully!");
-        
-        console.log(chalk.green("\n✓ Installation complete!"));
-        console.log(chalk.green(`✓ Expansion packs installed/updated:`));
-        for (const packId of selectedPacks) {
-          console.log(chalk.green(`  - ${packId} → .${packId}/`));
-        }
-        return;
       case "cancel":
         console.log("Installation cancelled.");
         return;
@@ -562,7 +322,7 @@ class Installer {
     spinner.stop();
 
     console.log(
-      chalk.yellow("\n🔍 Found BMad v3 installation (bmad-agent/ directory)")
+      chalk.yellow("\n🔍 Found BMAD v3 installation (bmad-agent/ directory)")
     );
     console.log(`   Directory: ${installDir}`);
 
@@ -584,10 +344,7 @@ class Installer {
         console.log(chalk.cyan("\n📦 Starting v3 to v4 upgrade process..."));
         const V3ToV4Upgrader = require("../../upgraders/v3-to-v4-upgrader");
         const upgrader = new V3ToV4Upgrader();
-        return await upgrader.upgrade({ 
-          projectPath: installDir,
-          ides: config.ides || [] // Pass IDE selections from initial config
-        });
+        return await upgrader.upgrade({ projectPath: installDir });
       }
       case "alongside":
         return await this.performFreshInstall(config, installDir, spinner);
@@ -650,20 +407,12 @@ class Installer {
     spinner.start("Checking for updates...");
 
     try {
-      // Get current and new versions
-      const currentVersion = manifest.version;
-      const newVersion = await this.getCoreVersion();
-      const versionCompare = this.compareVersions(currentVersion, newVersion);
-      
-      // Only check for modified files if it's an actual version upgrade
-      let modifiedFiles = [];
-      if (versionCompare !== 0) {
-        spinner.text = "Checking for modified files...";
-        modifiedFiles = await fileManager.checkModifiedFiles(
-          installDir,
-          manifest
-        );
-      }
+      // Check for modified files
+      spinner.text = "Checking for modified files...";
+      const modifiedFiles = await fileManager.checkModifiedFiles(
+        installDir,
+        manifest
+      );
 
       if (modifiedFiles.length > 0) {
         spinner.warn("Found modified files");
@@ -703,138 +452,35 @@ class Installer {
       }
 
       // Perform update by re-running installation
-      spinner.text = versionCompare === 0 ? "Reinstalling files..." : "Updating files...";
+      spinner.text = "Updating files...";
       const config = {
         installType: manifest.install_type,
         agent: manifest.agent,
         directory: installDir,
-        ides: newConfig?.ides || manifest.ides_setup || [],
+        ide: newConfig.ide || manifest.ide_setup, // Use new IDE choice if provided
       };
 
-      await this.performFreshInstall(config, installDir, spinner, { isUpdate: true });
-      
-      // Clean up .yml files that now have .yaml counterparts
-      spinner.text = "Cleaning up legacy .yml files...";
-      await this.cleanupLegacyYmlFiles(installDir, spinner);
+      await this.performFreshInstall(config, installDir, spinner);
     } catch (error) {
       spinner.fail("Update failed");
       throw error;
     }
   }
 
-  async performRepair(config, installDir, manifest, integrity, spinner) {
-    spinner.start("Preparing to repair installation...");
-
-    try {
-      // Back up modified files
-      if (integrity.modified.length > 0) {
-        spinner.text = "Backing up modified files...";
-        for (const file of integrity.modified) {
-          const filePath = path.join(installDir, file);
-          if (await fileManager.pathExists(filePath)) {
-            const backupPath = await fileManager.backupFile(filePath);
-            console.log(chalk.dim(`  Backed up: ${file} → ${path.basename(backupPath)}`));
-          }
-        }
-      }
-
-      // Restore missing and modified files
-      spinner.text = "Restoring files...";
-      const sourceBase = configLoader.getBmadCorePath();
-      const filesToRestore = [...integrity.missing, ...integrity.modified];
-      
-      for (const file of filesToRestore) {
-        // Skip the manifest file itself
-        if (file.endsWith('install-manifest.yaml')) continue;
-        
-        const relativePath = file.replace('.bmad-core/', '');
-        const destPath = path.join(installDir, file);
-        
-        // Check if this is a common/ file that needs special processing
-        const commonBase = path.dirname(path.dirname(path.dirname(path.dirname(__filename))));
-        const commonSourcePath = path.join(commonBase, 'common', relativePath);
-        
-        if (await fileManager.pathExists(commonSourcePath)) {
-          // This is a common/ file - needs template processing
-          const fs = require('fs').promises;
-          const content = await fs.readFile(commonSourcePath, 'utf8');
-          const updatedContent = content.replace(/\{root\}/g, '.bmad-core');
-          await fileManager.ensureDirectory(path.dirname(destPath));
-          await fs.writeFile(destPath, updatedContent, 'utf8');
-          spinner.text = `Restored: ${file}`;
-        } else {
-          // Regular file from bmad-core
-          const sourcePath = path.join(sourceBase, relativePath);
-          if (await fileManager.pathExists(sourcePath)) {
-            await fileManager.copyFile(sourcePath, destPath);
-            spinner.text = `Restored: ${file}`;
-            
-            // If this is a .yaml file, check for and remove corresponding .yml file
-            if (file.endsWith('.yaml')) {
-              const ymlFile = file.replace(/\.yaml$/, '.yml');
-              const ymlPath = path.join(installDir, ymlFile);
-              if (await fileManager.pathExists(ymlPath)) {
-                const fs = require('fs').promises;
-                await fs.unlink(ymlPath);
-                console.log(chalk.dim(`  Removed legacy: ${ymlFile} (replaced by ${file})`));
-              }
-            }
-          } else {
-            console.warn(chalk.yellow(`  Warning: Source file not found: ${file}`));
-          }
-        }
-      }
-      
-      // Clean up .yml files that now have .yaml counterparts
-      spinner.text = "Cleaning up legacy .yml files...";
-      await this.cleanupLegacyYmlFiles(installDir, spinner);
-      
-      spinner.succeed("Repair completed successfully!");
-      
-      // Show summary
-      console.log(chalk.green("\n✓ Installation repaired!"));
-      if (integrity.missing.length > 0) {
-        console.log(chalk.green(`  Restored ${integrity.missing.length} missing files`));
-      }
-      if (integrity.modified.length > 0) {
-        console.log(chalk.green(`  Restored ${integrity.modified.length} modified files (backups created)`));
-      }
-      
-      // Warning for Cursor custom modes if agents were repaired
-      const ides = manifest.ides_setup || [];
-      if (ides.includes('cursor')) {
-        console.log(chalk.yellow.bold("\n⚠️  IMPORTANT: Cursor Custom Modes Update Required"));
-        console.log(chalk.yellow("Since agent files have been repaired, you need to update any custom agent modes configured in the Cursor custom agent GUI per the Cursor docs."));
-      }
-      
-    } catch (error) {
-      spinner.fail("Repair failed");
-      throw error;
-    }
-  }
-
   async performReinstall(config, installDir, spinner) {
-    spinner.start("Preparing to reinstall BMad Method...");
+    spinner.start("Reinstalling BMAD Method...");
 
     // Remove existing .bmad-core
     const bmadCorePath = path.join(installDir, ".bmad-core");
     if (await fileManager.pathExists(bmadCorePath)) {
-      spinner.text = "Removing existing installation...";
       await fileManager.removeDirectory(bmadCorePath);
     }
-    
-    spinner.text = "Installing fresh copy...";
-    const result = await this.performFreshInstall(config, installDir, spinner, { isUpdate: true });
-    
-    // Clean up .yml files that now have .yaml counterparts
-    spinner.text = "Cleaning up legacy .yml files...";
-    await this.cleanupLegacyYmlFiles(installDir, spinner);
-    
-    return result;
+
+    return await this.performFreshInstall(config, installDir, spinner);
   }
 
-  showSuccessMessage(config, installDir, options = {}) {
-    console.log(chalk.green("\n✓ BMad Method installed successfully!\n"));
+  showSuccessMessage(config, installDir) {
+    console.log(chalk.green("\n✓ BMAD Method installed successfully!\n"));
 
     const ides = config.ides || (config.ide ? [config.ide] : []);
     if (ides.length > 0) {
@@ -842,7 +488,7 @@ class Installer {
         const ideConfig = configLoader.getIdeConfiguration(ide);
         if (ideConfig?.instructions) {
           console.log(
-            chalk.bold(`To use BMad agents in ${ideConfig.name}:`)
+            chalk.bold(`To use BMAD agents in ${ideConfig.name}:`)
           );
           console.log(ideConfig.instructions);
         }
@@ -857,26 +503,7 @@ class Installer {
 
     // Information about installation components
     console.log(chalk.bold("\n🎯 Installation Summary:"));
-    if (config.installType !== "expansion-only") {
-      console.log(chalk.green("✓ .bmad-core framework installed with all agents and workflows"));
-    }
-    
-    if (config.expansionPacks && config.expansionPacks.length > 0) {
-      console.log(chalk.green(`✓ Expansion packs installed:`));
-      for (const packId of config.expansionPacks) {
-        console.log(chalk.green(`  - ${packId} → .${packId}/`));
-      }
-    }
-    
-    if (config.includeWebBundles && config.webBundlesDirectory) {
-      const bundleInfo = this.getWebBundleInfo(config);
-      // Resolve the web bundles directory for display
-      const originalCwd = process.env.INIT_CWD || process.env.PWD || process.cwd();
-      const resolvedWebBundlesDir = path.isAbsolute(config.webBundlesDirectory) 
-        ? config.webBundlesDirectory 
-        : path.resolve(originalCwd, config.webBundlesDirectory);
-      console.log(chalk.green(`✓ Web bundles (${bundleInfo}) installed to: ${resolvedWebBundlesDir}`));
-    }
+    console.log(chalk.green("✓ .bmad-core framework installed with all agents and workflows"));
     
     if (ides.length > 0) {
       const ideNames = ides.map(ide => {
@@ -887,13 +514,11 @@ class Installer {
     }
 
     // Information about web bundles
-    if (!config.includeWebBundles) {
-      console.log(chalk.bold("\n📦 Web Bundles Available:"));
-      console.log("Pre-built web bundles are available and can be added later:");
-      console.log(chalk.cyan("  Run the installer again to add them to your project"));
-      console.log("These bundles work independently and can be shared, moved, or used");
-      console.log("in other projects as standalone files.");
-    }
+    console.log(chalk.bold("\n📦 Web Bundles Available:"));
+    console.log("Self-contained web bundles have been included in your installation:");
+    console.log(chalk.cyan(`  ${installDir}/.bmad-core/web-bundles/`));
+    console.log("These bundles work independently without this installation and can be");
+    console.log("shared, moved, or used in other projects as standalone files.");
 
     if (config.installType === "single-agent") {
       console.log(
@@ -905,12 +530,6 @@ class Installer {
         chalk.dim("Need everything? Run: npx bmad-method install --full")
       );
     }
-
-    // Warning for Cursor custom modes if agents were updated
-    if (options.isUpdate && ides.includes('cursor')) {
-      console.log(chalk.yellow.bold("\n⚠️  IMPORTANT: Cursor Custom Modes Update Required"));
-      console.log(chalk.yellow("Since agents have been updated, you need to update any custom agent modes configured in the Cursor custom agent GUI per the Cursor docs."));
-    }
   }
 
   // Legacy method for backward compatibility
@@ -931,7 +550,7 @@ class Installer {
       };
       return await this.install(config);
     }
-    console.log(chalk.red("No BMad installation found."));
+    console.log(chalk.red("No BMAD installation found."));
   }
 
   async listAgents() {
@@ -939,7 +558,7 @@ class Installer {
     await initializeModules();
     const agents = await configLoader.getAvailableAgents();
 
-    console.log(chalk.bold("\nAvailable BMad Agents:\n"));
+    console.log(chalk.bold("\nAvailable BMAD Agents:\n"));
 
     for (const agent of agents) {
       console.log(chalk.cyan(`  ${agent.id.padEnd(20)}`), agent.description);
@@ -950,33 +569,6 @@ class Installer {
     );
   }
 
-  async listExpansionPacks() {
-    // Initialize ES modules
-    await initializeModules();
-    const expansionPacks = await this.getAvailableExpansionPacks();
-
-    console.log(chalk.bold("\nAvailable BMad Expansion Packs:\n"));
-
-    if (expansionPacks.length === 0) {
-      console.log(chalk.yellow("No expansion packs found."));
-      return;
-    }
-
-    for (const pack of expansionPacks) {
-      console.log(chalk.cyan(`  ${pack.id.padEnd(20)}`), 
-                  `${pack.name} v${pack.version}`);
-      console.log(chalk.dim(`  ${' '.repeat(22)}${pack.description}`));
-      if (pack.author && pack.author !== 'Unknown') {
-        console.log(chalk.dim(`  ${' '.repeat(22)}by ${pack.author}`));
-      }
-      console.log();
-    }
-
-    console.log(
-      chalk.dim("Install with: npx bmad-method install --full --expansion-packs <id>\n")
-    );
-  }
-
   async showStatus() {
     // Initialize ES modules
     await initializeModules();
@@ -984,7 +576,7 @@ class Installer {
 
     if (!installDir) {
       console.log(
-        chalk.yellow("No BMad installation found in current directory tree")
+        chalk.yellow("No BMAD installation found in current directory tree")
       );
       return;
     }
@@ -996,7 +588,7 @@ class Installer {
       return;
     }
 
-    console.log(chalk.bold("\nBMad Installation Status:\n"));
+    console.log(chalk.bold("\nBMAD Installation Status:\n"));
     console.log(`  Directory:      ${installDir}`);
     console.log(`  Version:        ${manifest.version}`);
     console.log(
@@ -1010,8 +602,8 @@ class Installer {
       console.log(`  Agent:          ${manifest.agent}`);
     }
 
-    if (manifest.ides_setup && manifest.ides_setup.length > 0) {
-      console.log(`  IDE Setup:      ${manifest.ides_setup.join(', ')}`);
+    if (manifest.ide_setup) {
+      console.log(`  IDE Setup:      ${manifest.ide_setup}`);
     }
 
     console.log(`  Total Files:    ${manifest.files.length}`);
@@ -1032,715 +624,13 @@ class Installer {
     return configLoader.getAvailableAgents();
   }
 
-  async getAvailableExpansionPacks() {
-    return configLoader.getAvailableExpansionPacks();
-  }
-
-  async getAvailableTeams() {
-    return configLoader.getAvailableTeams();
-  }
-
-  async installExpansionPacks(installDir, selectedPacks, spinner, config = {}) {
-    if (!selectedPacks || selectedPacks.length === 0) {
-      return [];
-    }
-
-    const installedFiles = [];
-    const glob = require('glob');
-
-    for (const packId of selectedPacks) {
-      spinner.text = `Installing expansion pack: ${packId}...`;
-      
-      try {
-        const expansionPacks = await this.getAvailableExpansionPacks();
-        const pack = expansionPacks.find(p => p.id === packId);
-        
-        if (!pack) {
-          console.warn(`Expansion pack ${packId} not found, skipping...`);
-          continue;
-        }
-        
-        // Check if expansion pack already exists
-        let expansionDotFolder = path.join(installDir, `.${packId}`);
-        const existingManifestPath = path.join(expansionDotFolder, 'install-manifest.yaml');
-        
-        if (await fileManager.pathExists(existingManifestPath)) {
-          spinner.stop();
-          const existingManifest = await fileManager.readExpansionPackManifest(installDir, packId);
-          
-          console.log(chalk.yellow(`\n🔍 Found existing ${pack.name} installation`));
-          console.log(`   Current version: ${existingManifest.version || 'unknown'}`);
-          console.log(`   New version: ${pack.version}`);
-          
-          // Check integrity of existing expansion pack
-          const packIntegrity = await fileManager.checkFileIntegrity(installDir, existingManifest);
-          const hasPackIntegrityIssues = packIntegrity.missing.length > 0 || packIntegrity.modified.length > 0;
-          
-          if (hasPackIntegrityIssues) {
-            console.log(chalk.red("   ⚠️  Installation issues detected:"));
-            if (packIntegrity.missing.length > 0) {
-              console.log(chalk.red(`     Missing files: ${packIntegrity.missing.length}`));
-            }
-            if (packIntegrity.modified.length > 0) {
-              console.log(chalk.yellow(`     Modified files: ${packIntegrity.modified.length}`));
-            }
-          }
-          
-          const versionCompare = this.compareVersions(existingManifest.version || '0.0.0', pack.version);
-          
-          if (versionCompare === 0) {
-            console.log(chalk.yellow('   ⚠️  Same version already installed'));
-            
-            const choices = [];
-            if (hasPackIntegrityIssues) {
-              choices.push({ name: 'Repair (restore missing/modified files)', value: 'repair' });
-            }
-            choices.push(
-              { name: 'Force reinstall (overwrite)', value: 'overwrite' },
-              { name: 'Skip this expansion pack', value: 'skip' },
-              { name: 'Cancel installation', value: 'cancel' }
-            );
-            
-            const { action } = await inquirer.prompt([{
-              type: 'list',
-              name: 'action',
-              message: `${pack.name} v${pack.version} is already installed. What would you like to do?`,
-              choices: choices
-            }]);
-            
-            if (action === 'skip') {
-              spinner.start();
-              continue;
-            } else if (action === 'cancel') {
-              console.log(chalk.red('Installation cancelled.'));
-              process.exit(0);
-            } else if (action === 'repair') {
-              // Repair the expansion pack
-              await this.repairExpansionPack(installDir, packId, pack, packIntegrity, spinner);
-              continue;
-            }
-          } else if (versionCompare < 0) {
-            console.log(chalk.cyan('   ⬆️  Upgrade available'));
-            
-            const { proceed } = await inquirer.prompt([{
-              type: 'confirm',
-              name: 'proceed',
-              message: `Upgrade ${pack.name} from v${existingManifest.version} to v${pack.version}?`,
-              default: true
-            }]);
-            
-            if (!proceed) {
-              spinner.start();
-              continue;
-            }
-          } else {
-            console.log(chalk.yellow('   ⬇️  Installed version is newer than available version'));
-            
-            const { action } = await inquirer.prompt([{
-              type: 'list',
-              name: 'action',
-              message: 'What would you like to do?',
-              choices: [
-                { name: 'Keep current version', value: 'skip' },
-                { name: 'Downgrade to available version', value: 'downgrade' },
-                { name: 'Cancel installation', value: 'cancel' }
-              ]
-            }]);
-            
-            if (action === 'skip') {
-              spinner.start();
-              continue;
-            } else if (action === 'cancel') {
-              console.log(chalk.red('Installation cancelled.'));
-              process.exit(0);
-            }
-          }
-          
-          // If we get here, we're proceeding with installation
-          spinner.start(`Removing old ${pack.name} installation...`);
-          await fileManager.removeDirectory(expansionDotFolder);
-        }
-
-        const expansionPackDir = pack.packPath;
-        
-        // Ensure dedicated dot folder exists for this expansion pack
-        expansionDotFolder = path.join(installDir, `.${packId}`);
-        await fileManager.ensureDirectory(expansionDotFolder);
-        
-        // Define the folders to copy from expansion packs
-        const foldersToSync = [
-          'agents',
-          'agent-teams',
-          'templates',
-          'tasks',
-          'checklists',
-          'workflows',
-          'data',
-          'utils',
-          'schemas'
-        ];
-
-        // Copy each folder if it exists
-        for (const folder of foldersToSync) {
-          const sourceFolder = path.join(expansionPackDir, folder);
-          
-          // Check if folder exists in expansion pack
-          if (await fileManager.pathExists(sourceFolder)) {
-            // Get all files in this folder
-            const files = glob.sync('**/*', {
-              cwd: sourceFolder,
-              nodir: true
-            });
-
-            // Copy each file to the expansion pack's dot folder with {root} replacement
-            for (const file of files) {
-              const sourcePath = path.join(sourceFolder, file);
-              const destPath = path.join(expansionDotFolder, folder, file);
-              
-              const needsRootReplacement = file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml');
-              let success = false;
-              
-              if (needsRootReplacement) {
-                success = await fileManager.copyFileWithRootReplacement(sourcePath, destPath, `.${packId}`);
-              } else {
-                success = await fileManager.copyFile(sourcePath, destPath);
-              }
-              
-              if (success) {
-                installedFiles.push(path.join(`.${packId}`, folder, file));
-              }
-            }
-          }
-        }
-
-        // Copy config.yaml with {root} replacement
-        const configPath = path.join(expansionPackDir, 'config.yaml');
-        if (await fileManager.pathExists(configPath)) {
-          const configDestPath = path.join(expansionDotFolder, 'config.yaml');
-          if (await fileManager.copyFileWithRootReplacement(configPath, configDestPath, `.${packId}`)) {
-            installedFiles.push(path.join(`.${packId}`, 'config.yaml'));
-          }
-        }
-        
-        // Copy README if it exists with {root} replacement
-        const readmePath = path.join(expansionPackDir, 'README.md');
-        if (await fileManager.pathExists(readmePath)) {
-          const readmeDestPath = path.join(expansionDotFolder, 'README.md');
-          if (await fileManager.copyFileWithRootReplacement(readmePath, readmeDestPath, `.${packId}`)) {
-            installedFiles.push(path.join(`.${packId}`, 'README.md'));
-          }
-        }
-
-        // Copy common/ items to expansion pack folder
-        spinner.text = `Copying common utilities to ${packId}...`;
-        await this.copyCommonItems(installDir, `.${packId}`, spinner);
-        
-        // Check and resolve core dependencies
-        await this.resolveExpansionPackCoreDependencies(installDir, expansionDotFolder, packId, spinner);
-        
-        // Check and resolve core agents referenced by teams
-        await this.resolveExpansionPackCoreAgents(installDir, expansionDotFolder, packId, spinner);
-
-        // Create manifest for this expansion pack
-        spinner.text = `Creating manifest for ${packId}...`;
-        const expansionConfig = {
-          installType: 'expansion-pack',
-          expansionPackId: packId,
-          expansionPackName: pack.name,
-          expansionPackVersion: pack.version,
-          ides: config.ides || []  // Use ides_setup instead of ide_setup
-        };
-        
-        // Get all files installed in this expansion pack
-        const expansionPackFiles = glob.sync('**/*', {
-          cwd: expansionDotFolder,
-          nodir: true
-        }).map(f => path.join(`.${packId}`, f));
-        
-        await fileManager.createExpansionPackManifest(installDir, packId, expansionConfig, expansionPackFiles);
-
-        console.log(chalk.green(`✓ Installed expansion pack: ${pack.name} to ${`.${packId}`}`));
-      } catch (error) {
-        console.error(chalk.red(`Failed to install expansion pack ${packId}: ${error.message}`));
-        console.error(chalk.red(`Stack trace: ${error.stack}`));
-      }
-    }
-
-    return installedFiles;
-  }
-
-  async resolveExpansionPackCoreDependencies(installDir, expansionDotFolder, packId, spinner) {
-    const glob = require('glob');
-    const yaml = require('js-yaml');
-    const fs = require('fs').promises;
-    
-    // Find all agent files in the expansion pack
-    const agentFiles = glob.sync('agents/*.md', {
-      cwd: expansionDotFolder
-    });
-
-    for (const agentFile of agentFiles) {
-      const agentPath = path.join(expansionDotFolder, agentFile);
-      const agentContent = await fs.readFile(agentPath, 'utf8');
-      
-      // Extract YAML frontmatter to check dependencies
-      const yamlContent = extractYamlFromAgent(agentContent);
-      if (yamlContent) {
-        try {
-          const agentConfig = yaml.load(yamlContent);
-          const dependencies = agentConfig.dependencies || {};
-          
-          // Check for core dependencies (those that don't exist in the expansion pack)
-          for (const depType of ['tasks', 'templates', 'checklists', 'workflows', 'utils', 'data']) {
-            const deps = dependencies[depType] || [];
-            
-            for (const dep of deps) {
-              const depFileName = dep.endsWith('.md') ? dep : `${dep}.md`;
-              const expansionDepPath = path.join(expansionDotFolder, depType, depFileName);
-              
-              // Check if dependency exists in expansion pack
-              if (!(await fileManager.pathExists(expansionDepPath))) {
-                // Try to find it in core
-                const coreDepPath = path.join(configLoader.getBmadCorePath(), depType, depFileName);
-                
-                if (await fileManager.pathExists(coreDepPath)) {
-                  spinner.text = `Copying core dependency ${dep} for ${packId}...`;
-                  
-                  // Copy from core to expansion pack dot folder with {root} replacement
-                  const destPath = path.join(expansionDotFolder, depType, depFileName);
-                  await fileManager.copyFileWithRootReplacement(coreDepPath, destPath, `.${packId}`);
-                  
-                  console.log(chalk.dim(`  Added core dependency: ${depType}/${depFileName}`));
-                } else {
-                  console.warn(chalk.yellow(`  Warning: Dependency ${depType}/${dep} not found in core or expansion pack`));
-                }
-              }
-            }
-          }
-        } catch (error) {
-          console.warn(chalk.yellow(`  Warning: Could not parse agent dependencies: ${error.message}`));
-        }
-      }
-    }
-  }
-
-  async resolveExpansionPackCoreAgents(installDir, expansionDotFolder, packId, spinner) {
-    const glob = require('glob');
-    const yaml = require('js-yaml');
-    const fs = require('fs').promises;
-    
-    // Find all team files in the expansion pack
-    const teamFiles = glob.sync('agent-teams/*.yaml', {
-      cwd: expansionDotFolder
-    });
-
-    // Also get existing agents in the expansion pack
-    const existingAgents = new Set();
-    const agentFiles = glob.sync('agents/*.md', {
-      cwd: expansionDotFolder
-    });
-    for (const agentFile of agentFiles) {
-      const agentName = path.basename(agentFile, '.md');
-      existingAgents.add(agentName);
-    }
-
-    // Process each team file
-    for (const teamFile of teamFiles) {
-      const teamPath = path.join(expansionDotFolder, teamFile);
-      const teamContent = await fs.readFile(teamPath, 'utf8');
-      
-      try {
-        const teamConfig = yaml.load(teamContent);
-        const agents = teamConfig.agents || [];
-        
-        // Add bmad-orchestrator if not present (required for all teams)
-        if (!agents.includes('bmad-orchestrator')) {
-          agents.unshift('bmad-orchestrator');
-        }
-        
-        // Check each agent in the team
-        for (const agentId of agents) {
-          if (!existingAgents.has(agentId)) {
-            // Agent not in expansion pack, try to get from core
-            const coreAgentPath = path.join(configLoader.getBmadCorePath(), 'agents', `${agentId}.md`);
-            
-            if (await fileManager.pathExists(coreAgentPath)) {
-              spinner.text = `Copying core agent ${agentId} for ${packId}...`;
-              
-              // Copy agent file with {root} replacement
-              const destPath = path.join(expansionDotFolder, 'agents', `${agentId}.md`);
-              await fileManager.copyFileWithRootReplacement(coreAgentPath, destPath, `.${packId}`);
-              existingAgents.add(agentId);
-              
-              console.log(chalk.dim(`  Added core agent: ${agentId}`));
-              
-              // Now resolve this agent's dependencies too
-              const agentContent = await fs.readFile(coreAgentPath, 'utf8');
-              const yamlContent = extractYamlFromAgent(agentContent, true);
-              
-              if (yamlContent) {
-                try {
-                  
-                  const agentConfig = yaml.load(yamlContent);
-                  const dependencies = agentConfig.dependencies || {};
-                  
-                  // Copy all dependencies for this agent
-                  for (const depType of ['tasks', 'templates', 'checklists', 'workflows', 'utils', 'data']) {
-                    const deps = dependencies[depType] || [];
-                    
-                    for (const dep of deps) {
-                      const depFileName = dep.endsWith('.md') || dep.endsWith('.yaml') ? dep : `${dep}.md`;
-                      const expansionDepPath = path.join(expansionDotFolder, depType, depFileName);
-                      
-                      // Check if dependency exists in expansion pack
-                      if (!(await fileManager.pathExists(expansionDepPath))) {
-                        // Try to find it in core
-                        const coreDepPath = path.join(configLoader.getBmadCorePath(), depType, depFileName);
-                        
-                        if (await fileManager.pathExists(coreDepPath)) {
-                          const destDepPath = path.join(expansionDotFolder, depType, depFileName);
-                          await fileManager.copyFileWithRootReplacement(coreDepPath, destDepPath, `.${packId}`);
-                          console.log(chalk.dim(`    Added agent dependency: ${depType}/${depFileName}`));
-                        } else {
-                          // Try common folder
-                          const sourceBase = path.dirname(path.dirname(path.dirname(path.dirname(__filename)))); // Go up to project root
-                          const commonDepPath = path.join(sourceBase, 'common', depType, depFileName);
-                          if (await fileManager.pathExists(commonDepPath)) {
-                            const destDepPath = path.join(expansionDotFolder, depType, depFileName);
-                            await fileManager.copyFile(commonDepPath, destDepPath);
-                            console.log(chalk.dim(`    Added agent dependency from common: ${depType}/${depFileName}`));
-                          }
-                        }
-                      }
-                    }
-                  }
-                } catch (error) {
-                  console.warn(chalk.yellow(`  Warning: Could not parse agent ${agentId} dependencies: ${error.message}`));
-                }
-              }
-            } else {
-              console.warn(chalk.yellow(`  Warning: Core agent ${agentId} not found for team ${path.basename(teamFile, '.yaml')}`));
-            }
-          }
-        }
-      } catch (error) {
-        console.warn(chalk.yellow(`  Warning: Could not parse team file ${teamFile}: ${error.message}`));
-      }
-    }
-  }
-
-  getWebBundleInfo(config) {
-    const webBundleType = config.webBundleType || 'all';
-    
-    switch (webBundleType) {
-      case 'all':
-        return 'all bundles';
-      case 'agents':
-        return 'individual agents only';
-      case 'teams':
-        return config.selectedWebBundleTeams ? 
-          `teams: ${config.selectedWebBundleTeams.join(', ')}` : 
-          'selected teams';
-      case 'custom':
-        const parts = [];
-        if (config.selectedWebBundleTeams && config.selectedWebBundleTeams.length > 0) {
-          parts.push(`teams: ${config.selectedWebBundleTeams.join(', ')}`);
-        }
-        if (config.includeIndividualAgents) {
-          parts.push('individual agents');
-        }
-        return parts.length > 0 ? parts.join(' + ') : 'custom selection';
-      default:
-        return 'selected bundles';
-    }
-  }
-
-  async installWebBundles(webBundlesDirectory, config, spinner) {
-    // Ensure modules are initialized
-    await initializeModules();
-    
-    try {
-      // Find the dist directory in the BMad installation
-      const distDir = configLoader.getDistPath();
-      
-      if (!(await fileManager.pathExists(distDir))) {
-        console.warn(chalk.yellow('Web bundles not found. Run "npm run build" to generate them.'));
-        return;
-      }
-
-      // Ensure web bundles directory exists
-      await fileManager.ensureDirectory(webBundlesDirectory);
-      
-      const webBundleType = config.webBundleType || 'all';
-      
-      if (webBundleType === 'all') {
-        // Copy the entire dist directory structure
-        await fileManager.copyDirectory(distDir, webBundlesDirectory);
-        console.log(chalk.green(`✓ Installed all web bundles to: ${webBundlesDirectory}`));
-      } else {
-        let copiedCount = 0;
-        
-        // Copy specific selections based on type
-        if (webBundleType === 'agents' || (webBundleType === 'custom' && config.includeIndividualAgents)) {
-          const agentsSource = path.join(distDir, 'agents');
-          const agentsTarget = path.join(webBundlesDirectory, 'agents');
-          if (await fileManager.pathExists(agentsSource)) {
-            await fileManager.copyDirectory(agentsSource, agentsTarget);
-            console.log(chalk.green(`✓ Copied individual agent bundles`));
-            copiedCount += 10; // Approximate count for agents
-          }
-        }
-        
-        if (webBundleType === 'teams' || webBundleType === 'custom') {
-          if (config.selectedWebBundleTeams && config.selectedWebBundleTeams.length > 0) {
-            const teamsSource = path.join(distDir, 'teams');
-            const teamsTarget = path.join(webBundlesDirectory, 'teams');
-            await fileManager.ensureDirectory(teamsTarget);
-            
-            for (const teamId of config.selectedWebBundleTeams) {
-              const teamFile = `${teamId}.txt`;
-              const sourcePath = path.join(teamsSource, teamFile);
-              const targetPath = path.join(teamsTarget, teamFile);
-              
-              if (await fileManager.pathExists(sourcePath)) {
-                await fileManager.copyFile(sourcePath, targetPath);
-                copiedCount++;
-                console.log(chalk.green(`✓ Copied team bundle: ${teamId}`));
-              }
-            }
-          }
-        }
-        
-        // Always copy expansion packs if they exist
-        const expansionSource = path.join(distDir, 'expansion-packs');
-        const expansionTarget = path.join(webBundlesDirectory, 'expansion-packs');
-        if (await fileManager.pathExists(expansionSource)) {
-          await fileManager.copyDirectory(expansionSource, expansionTarget);
-          console.log(chalk.green(`✓ Copied expansion pack bundles`));
-        }
-        
-        console.log(chalk.green(`✓ Installed ${copiedCount} selected web bundles to: ${webBundlesDirectory}`));
-      }
-    } catch (error) {
-      console.error(chalk.red(`Failed to install web bundles: ${error.message}`));
-    }
-  }
-
-  async copyCommonItems(installDir, targetSubdir, spinner) {
-    // Ensure modules are initialized
-    await initializeModules();
-    
-    const glob = require('glob');
-    const fs = require('fs').promises;
-    const sourceBase = path.dirname(path.dirname(path.dirname(path.dirname(__filename)))); // Go up to project root
-    const commonPath = path.join(sourceBase, 'common');
-    const targetPath = path.join(installDir, targetSubdir);
-    const copiedFiles = [];
-    
-    // Check if common/ exists
-    if (!(await fileManager.pathExists(commonPath))) {
-      console.warn(chalk.yellow('Warning: common/ folder not found'));
-      return copiedFiles;
-    }
-    
-    // Copy all items from common/ to target
-    const commonItems = glob.sync('**/*', {
-      cwd: commonPath,
-      nodir: true
-    });
-    
-    for (const item of commonItems) {
-      const sourcePath = path.join(commonPath, item);
-      const destPath = path.join(targetPath, item);
-      
-      // Read the file content
-      const content = await fs.readFile(sourcePath, 'utf8');
-      
-      // Replace {root} with the target subdirectory
-      const updatedContent = content.replace(/\{root\}/g, targetSubdir);
-      
-      // Ensure directory exists
-      await fileManager.ensureDirectory(path.dirname(destPath));
-      
-      // Write the updated content
-      await fs.writeFile(destPath, updatedContent, 'utf8');
-      copiedFiles.push(path.join(targetSubdir, item));
-    }
-    
-    console.log(chalk.dim(`  Added ${commonItems.length} common utilities`));
-    return copiedFiles;
-  }
-
-  async detectExpansionPacks(installDir) {
-    const expansionPacks = {};
-    const glob = require("glob");
-    
-    // Find all dot folders that might be expansion packs
-    const dotFolders = glob.sync(".*", {
-      cwd: installDir,
-      ignore: [".git", ".git/**", ".bmad-core", ".bmad-core/**"],
-    });
-    
-    for (const folder of dotFolders) {
-      const folderPath = path.join(installDir, folder);
-      const stats = await fileManager.pathExists(folderPath);
-      
-      if (stats) {
-        // Check if it has a manifest
-        const manifestPath = path.join(folderPath, "install-manifest.yaml");
-        if (await fileManager.pathExists(manifestPath)) {
-          const manifest = await fileManager.readExpansionPackManifest(installDir, folder.substring(1));
-          if (manifest) {
-            expansionPacks[folder.substring(1)] = {
-              path: folderPath,
-              manifest: manifest,
-              hasManifest: true
-            };
-          }
-        } else {
-          // Check if it has a config.yaml (expansion pack without manifest)
-          const configPath = path.join(folderPath, "config.yaml");
-          if (await fileManager.pathExists(configPath)) {
-            expansionPacks[folder.substring(1)] = {
-              path: folderPath,
-              manifest: null,
-              hasManifest: false
-            };
-          }
-        }
-      }
-    }
-    
-    return expansionPacks;
-  }
-
-  async repairExpansionPack(installDir, packId, pack, integrity, spinner) {
-    spinner.start(`Repairing ${pack.name}...`);
-    
-    try {
-      const expansionDotFolder = path.join(installDir, `.${packId}`);
-      
-      // Back up modified files
-      if (integrity.modified.length > 0) {
-        spinner.text = "Backing up modified files...";
-        for (const file of integrity.modified) {
-          const filePath = path.join(installDir, file);
-          if (await fileManager.pathExists(filePath)) {
-            const backupPath = await fileManager.backupFile(filePath);
-            console.log(chalk.dim(`  Backed up: ${file} → ${path.basename(backupPath)}`));
-          }
-        }
-      }
-      
-      // Restore missing and modified files
-      spinner.text = "Restoring files...";
-      const filesToRestore = [...integrity.missing, ...integrity.modified];
-      
-      for (const file of filesToRestore) {
-        // Skip the manifest file itself
-        if (file.endsWith('install-manifest.yaml')) continue;
-        
-        const relativePath = file.replace(`.${packId}/`, '');
-        const sourcePath = path.join(pack.packPath, relativePath);
-        const destPath = path.join(installDir, file);
-        
-        // Check if this is a common/ file that needs special processing
-        const commonBase = path.dirname(path.dirname(path.dirname(path.dirname(__filename))));
-        const commonSourcePath = path.join(commonBase, 'common', relativePath);
-        
-        if (await fileManager.pathExists(commonSourcePath)) {
-          // This is a common/ file - needs template processing
-          const fs = require('fs').promises;
-          const content = await fs.readFile(commonSourcePath, 'utf8');
-          const updatedContent = content.replace(/\{root\}/g, `.${packId}`);
-          await fileManager.ensureDirectory(path.dirname(destPath));
-          await fs.writeFile(destPath, updatedContent, 'utf8');
-          spinner.text = `Restored: ${file}`;
-        } else if (await fileManager.pathExists(sourcePath)) {
-          // Regular file from expansion pack
-          await fileManager.copyFile(sourcePath, destPath);
-          spinner.text = `Restored: ${file}`;
-        } else {
-          console.warn(chalk.yellow(`  Warning: Source file not found: ${file}`));
-        }
-      }
-      
-      spinner.succeed(`${pack.name} repaired successfully!`);
-      
-      // Show summary
-      console.log(chalk.green(`\n✓ ${pack.name} repaired!`));
-      if (integrity.missing.length > 0) {
-        console.log(chalk.green(`  Restored ${integrity.missing.length} missing files`));
-      }
-      if (integrity.modified.length > 0) {
-        console.log(chalk.green(`  Restored ${integrity.modified.length} modified files (backups created)`));
-      }
-      
-    } catch (error) {
-      spinner.fail(`Failed to repair ${pack.name}`);
-      console.error(chalk.red(`Error: ${error.message}`));
-    }
-  }
-
-  compareVersions(v1, v2) {
-    // Simple semver comparison
-    const parts1 = v1.split('.').map(Number);
-    const parts2 = v2.split('.').map(Number);
-    
-    for (let i = 0; i < 3; i++) {
-      const part1 = parts1[i] || 0;
-      const part2 = parts2[i] || 0;
-      
-      if (part1 > part2) return 1;
-      if (part1 < part2) return -1;
-    }
-    
-    return 0;
-  }
-
-  async cleanupLegacyYmlFiles(installDir, spinner) {
-    const glob = require('glob');
-    const fs = require('fs').promises;
-    
-    try {
-      // Find all .yml files in the installation directory
-      const ymlFiles = glob.sync('**/*.yml', {
-        cwd: installDir,
-        ignore: ['**/node_modules/**', '**/.git/**']
-      });
-      
-      let deletedCount = 0;
-      
-      for (const ymlFile of ymlFiles) {
-        // Check if corresponding .yaml file exists
-        const yamlFile = ymlFile.replace(/\.yml$/, '.yaml');
-        const ymlPath = path.join(installDir, ymlFile);
-        const yamlPath = path.join(installDir, yamlFile);
-        
-        if (await fileManager.pathExists(yamlPath)) {
-          // .yaml counterpart exists, delete the .yml file
-          await fs.unlink(ymlPath);
-          deletedCount++;
-          console.log(chalk.dim(`  Removed legacy: ${ymlFile} (replaced by ${yamlFile})`));
-        }
-      }
-      
-      if (deletedCount > 0) {
-        console.log(chalk.green(`✓ Cleaned up ${deletedCount} legacy .yml files`));
-      }
-      
-    } catch (error) {
-      console.warn(chalk.yellow(`Warning: Could not cleanup legacy .yml files: ${error.message}`));
-    }
-  }
-
   async findInstallation() {
     // Look for .bmad-core in current directory or parent directories
     let currentDir = process.cwd();
 
     while (currentDir !== path.dirname(currentDir)) {
       const bmadDir = path.join(currentDir, ".bmad-core");
-      const manifestPath = path.join(bmadDir, "install-manifest.yaml");
+      const manifestPath = path.join(bmadDir, "install-manifest.yml");
 
       if (await fileManager.pathExists(manifestPath)) {
         return bmadDir;
@@ -1751,7 +641,7 @@ class Installer {
 
     // Also check if we're inside a .bmad-core directory
     if (path.basename(process.cwd()) === ".bmad-core") {
-      const manifestPath = path.join(process.cwd(), "install-manifest.yaml");
+      const manifestPath = path.join(process.cwd(), "install-manifest.yml");
       if (await fileManager.pathExists(manifestPath)) {
         return process.cwd();
       }