bmad-method 6.0.0-alpha.7 → 6.0.0-alpha.8

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

@@ -205,6 +205,18 @@ class WebBundler {
       this.stats.warnings.push({ agent: agentName, warnings: dependencyWarnings });
     }
 
+    // Check for module's default-party.csv and include it as agent manifest
+    const defaultPartyPath = path.join(this.modulesPath, moduleName, 'teams', 'default-party.csv');
+    if (await fs.pathExists(defaultPartyPath)) {
+      const partyContent = await fs.readFile(defaultPartyPath, 'utf8');
+      // Process any placeholders in the CSV content
+      const processedPartyContent = this.processProjectRootReferences(partyContent);
+      // Wrap as text to preserve raw CSV format in CDATA
+      const wrappedParty = this.wrapContentInXml(processedPartyContent, 'bmad/_cfg/agent-manifest.csv', 'text');
+      dependencies.set('bmad/_cfg/agent-manifest.csv', wrappedParty);
+      console.log(chalk.gray(`    + Added party manifest from module default-party.csv`));
+    }
+
     // Remove commands for skipped workflows from agent XML
     if (skippedWorkflows.length > 0) {
       agentXml = this.removeSkippedWorkflowCommands(agentXml, skippedWorkflows);
@@ -260,6 +272,24 @@ class WebBundler {
     const allAgentXmls = [];
     const warnings = [];
 
+    // Check if team has a party CSV file (agent manifest)
+    const hasPartyFile = teamConfig.party && teamConfig.party.endsWith('.csv');
+    if (hasPartyFile) {
+      // Load the party CSV and add it as bmad/_cfg/agent-manifest.csv
+      const partyPath = path.join(path.dirname(teamPath), teamConfig.party.replace(/^\.\//, ''));
+      if (await fs.pathExists(partyPath)) {
+        const partyContent = await fs.readFile(partyPath, 'utf8');
+        // Process any placeholders in the CSV content
+        const processedPartyContent = this.processProjectRootReferences(partyContent);
+        // Wrap as text/csv to preserve raw CSV format in CDATA
+        const wrappedParty = this.wrapContentInXml(processedPartyContent, 'bmad/_cfg/agent-manifest.csv', 'text');
+        dependencies.set('bmad/_cfg/agent-manifest.csv', wrappedParty);
+        console.log(chalk.gray(`    + Added agent manifest from: ${teamConfig.party}`));
+      } else {
+        console.log(chalk.yellow(`    ⚠ Party file not found: ${partyPath}`));
+      }
+    }
+
     // 1. First, always add the bmad-web-orchestrator (XML file only, no transformation needed)
     const orchestratorXmlPath = path.join(this.sourceDir, 'core', 'agents', 'bmad-web-orchestrator.agent.xml');
 
@@ -476,8 +506,9 @@ class WebBundler {
         }
 
         // Parse paths to extract module and workflow location
-        const sourceMatch = sourceWorkflowPath.match(/\{project-root\}\/bmad\/([^/]+)\/workflows\/(.+)/);
-        const installMatch = installWorkflowPath.match(/\{project-root\}\/bmad\/([^/]+)\/workflows\/(.+)/);
+        // Support both {project-root}/bmad/... and {project-root}/{bmad_folder}/... patterns
+        const sourceMatch = sourceWorkflowPath.match(/\{project-root\}\/(?:\{bmad_folder\}|bmad)\/([^/]+)\/workflows\/(.+)/);
+        const installMatch = installWorkflowPath.match(/\{project-root\}\/(?:\{bmad_folder\}|bmad)\/([^/]+)\/workflows\/(.+)/);
 
         if (!sourceMatch || !installMatch) {
           continue;
@@ -528,8 +559,9 @@ class WebBundler {
     let yamlContent = await fs.readFile(workflowYamlPath, 'utf8');
 
     // Replace config_source with new module reference
-    const configSourcePattern = /config_source:\s*["']?\{project-root\}\/bmad\/[^/]+\/config\.yaml["']?/g;
-    const newConfigSource = `config_source: "{project-root}/bmad/${newModuleName}/config.yaml"`;
+    // Support both old format (bmad) and new format ({bmad_folder})
+    const configSourcePattern = /config_source:\s*["']?\{project-root\}\/(?:\{bmad_folder\}|bmad)\/[^/]+\/config\.yaml["']?/g;
+    const newConfigSource = `config_source: "{project-root}/{bmad_folder}/${newModuleName}/config.yaml"`;
 
     const updatedYaml = yamlContent.replaceAll(configSourcePattern, newConfigSource);
     await fs.writeFile(workflowYamlPath, updatedYaml, 'utf8');
@@ -651,7 +683,8 @@ class WebBundler {
       /system-prompts="([^"]+)"/g,
       /tools="([^"]+)"/g,
       /knowledge="([^"]+)"/g,
-      /{project-root}\/([^"'\s<>]+)/g,
+      /{project-root}\/([^"'\s<>]+)/g, // Legacy {project-root} paths
+      /\bbmad\/([^"'\s<>]+)/g, // Direct bmad/ paths (after {bmad_folder} replacement)
     ];
 
     for (const pattern of patterns) {
@@ -660,9 +693,16 @@ class WebBundler {
         let filePath = match[1];
         // Remove {project-root} prefix if present
         filePath = filePath.replace(/^{project-root}\//, '');
+        // Remove {bmad_folder} prefix if present (should be rare, mostly replaced already)
+        filePath = filePath.replace(/^{bmad_folder}\//, 'bmad/');
+
+        // For bmad/ pattern, prepend 'bmad/' since it was captured without it
+        if (pattern.source.includes(String.raw`\bbmad\/`)) {
+          filePath = 'bmad/' + filePath;
+        }
 
         // Skip obvious placeholder/example paths
-        if (filePath && !filePath.includes('path/to/') && !filePath.includes('example')) {
+        if (filePath && !filePath.includes('path/to/') && !filePath.includes('example') && !filePath.includes('...')) {
           refs.add(filePath);
         }
       }
@@ -680,6 +720,8 @@ class WebBundler {
       while ((match = pattern.exec(xml)) !== null) {
         let workflowPath = match[1];
         workflowPath = workflowPath.replace(/^{project-root}\//, '');
+        // Remove {bmad_folder} prefix if present and replace with bmad
+        workflowPath = workflowPath.replace(/^{bmad_folder}\//, 'bmad/');
 
         // Skip obvious placeholder/example paths
         if (workflowPath && workflowPath.endsWith('.yaml') && !workflowPath.includes('path/to/') && !workflowPath.includes('example')) {
@@ -725,6 +767,11 @@ class WebBundler {
    * Process a file dependency recursively
    */
   async processFileDependency(filePath, dependencies, processed, moduleName, warnings = []) {
+    // Skip workflow YAML files - they're handled by processWorkflowDependency
+    if (filePath.includes('/workflow') && filePath.endsWith('workflow.yaml')) {
+      return;
+    }
+
     // Skip if already processed
     if (processed.has(filePath)) {
       return;
@@ -766,7 +813,8 @@ class WebBundler {
         const deps = depMatch[1].match(/['"]([^'"]+)['"]/g);
         if (deps) {
           for (const dep of deps) {
-            const depPath = dep.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
+            let depPath = dep.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
+            depPath = depPath.replace(/^{bmad_folder}\//, 'bmad/');
             if (depPath && !processed.has(depPath)) {
               await this.processFileDependency(depPath, dependencies, processed, moduleName, warnings);
             }
@@ -779,7 +827,8 @@ class WebBundler {
         const templates = templateMatch[1].match(/['"]([^'"]+)['"]/g);
         if (templates) {
           for (const template of templates) {
-            const templatePath = template.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
+            let templatePath = template.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
+            templatePath = templatePath.replace(/^{bmad_folder}\//, 'bmad/');
             if (templatePath && !processed.has(templatePath)) {
               await this.processFileDependency(templatePath, dependencies, processed, moduleName, warnings);
             }
@@ -967,8 +1016,13 @@ class WebBundler {
       bundleYamlContent = yamlContent;
     }
 
+    // Process {project-root} and {bmad_folder} references in the YAML content
+    bundleYamlContent = this.processProjectRootReferences(bundleYamlContent);
+
     // Include the YAML file with only web_bundle content, wrapped in XML
-    const yamlId = workflowPath.replace(/^{project-root}\//, '');
+    // Process the workflow path to create a clean ID
+    let yamlId = workflowPath.replace(/^{project-root}\//, '');
+    yamlId = yamlId.replace(/^{bmad_folder}\//, 'bmad/');
     const wrappedYaml = this.wrapContentInXml(bundleYamlContent, yamlId, 'yaml');
     dependencies.set(yamlId, wrappedYaml);
 
@@ -985,7 +1039,11 @@ class WebBundler {
       const bundleFiles = workflowConfig.web_bundle.web_bundle_files;
 
       for (const bundleFilePath of bundleFiles) {
-        if (processed.has(bundleFilePath)) {
+        // Process the file path to create a clean ID for checking if already processed
+        let cleanFilePath = bundleFilePath.replace(/^{project-root}\//, '');
+        cleanFilePath = cleanFilePath.replace(/^{bmad_folder}\//, 'bmad/');
+
+        if (processed.has(cleanFilePath)) {
           continue;
         }
 
@@ -1002,7 +1060,7 @@ class WebBundler {
           await this.processWorkflowDependency(bundleFilePath, dependencies, processed, moduleName, warnings);
         } else {
           // Regular file - process normally
-          processed.add(bundleFilePath);
+          processed.add(cleanFilePath);
 
           // Read the file content
           let fileContent = await fs.readFile(bundleActualPath, 'utf8');
@@ -1012,8 +1070,8 @@ class WebBundler {
           fileContent = this.processProjectRootReferences(fileContent);
 
           // Wrap in XML with proper escaping
-          const wrappedContent = this.wrapContentInXml(fileContent, bundleFilePath, fileExt);
-          dependencies.set(bundleFilePath, wrappedContent);
+          const wrappedContent = this.wrapContentInXml(fileContent, cleanFilePath, fileExt);
+          dependencies.set(cleanFilePath, wrappedContent);
         }
       }
     }
@@ -1039,7 +1097,9 @@ class WebBundler {
       return;
     }
 
-    const fileContent = await fs.readFile(actualPath, 'utf8');
+    let fileContent = await fs.readFile(actualPath, 'utf8');
+    // Process {project-root} and {bmad_folder} references
+    fileContent = this.processProjectRootReferences(fileContent);
     const wrappedContent = this.wrapContentInXml(fileContent, coreWorkflowPath, 'xml');
     dependencies.set(coreWorkflowPath, wrappedContent);
   }
@@ -1063,7 +1123,9 @@ class WebBundler {
         continue;
       }
 
-      const fileContent = await fs.readFile(actualPath, 'utf8');
+      let fileContent = await fs.readFile(actualPath, 'utf8');
+      // Process {project-root} and {bmad_folder} references
+      fileContent = this.processProjectRootReferences(fileContent);
       const fileExt = path.extname(actualPath).toLowerCase().replace('.', '');
       const wrappedContent = this.wrapContentInXml(fileContent, filePath, fileExt);
       dependencies.set(filePath, wrappedContent);
@@ -1096,6 +1158,8 @@ class WebBundler {
   async processWildcardDependency(pattern, dependencies, processed, moduleName, warnings = []) {
     // Remove {project-root} prefix
     pattern = pattern.replace(/^{project-root}\//, '');
+    // Replace {bmad_folder} with bmad
+    pattern = pattern.replace(/^{bmad_folder}\//, 'bmad/');
 
     // Get directory and file pattern
     const lastSlash = pattern.lastIndexOf('/');
@@ -1163,6 +1227,9 @@ class WebBundler {
   resolveFilePath(filePath, moduleName) {
     // Remove {project-root} prefix
     filePath = filePath.replace(/^{project-root}\//, '');
+    // Replace {bmad_folder} with bmad
+    filePath = filePath.replace(/^{bmad_folder}\//, 'bmad/');
+    filePath = filePath.replace(/^{bmad_folder}$/, 'bmad');
 
     // Check temp directory first for _cfg files
     if (filePath.startsWith('bmad/_cfg/')) {
@@ -1229,13 +1296,15 @@ class WebBundler {
   }
 
   /**
-   * Process and remove {project-root} references
+   * Process and remove {project-root} references and replace {bmad_folder} with bmad
    */
   processProjectRootReferences(content) {
     // Remove {project-root}/ prefix (with slash)
     content = content.replaceAll('{project-root}/', '');
     // Also remove {project-root} without slash
     content = content.replaceAll('{project-root}', '');
+    // Replace {bmad_folder} with bmad
+    content = content.replaceAll('{bmad_folder}', 'bmad');
     return content;
   }
 

package/tools/cli/commands/install.js

@@ -56,10 +56,7 @@ module.exports = {
       // Check if installation succeeded
       if (result && result.success) {
         console.log(chalk.green('\n✨ Installation complete!'));
-        console.log(
-          chalk.cyan('BMAD Core and Selected Modules have been installed to:'),
-          chalk.bold(result.path || path.resolve(config.directory, 'bmad')),
-        );
+        console.log(chalk.cyan('BMAD Core and Selected Modules have been installed to:'), chalk.bold(result.path));
         console.log(chalk.yellow('\nThank you for helping test the early release version of the new BMad Core and BMad Method!'));
         console.log(chalk.cyan('Stable Beta coming soon - please read the full readme.md and linked documentation to get started!'));
         process.exit(0);

package/tools/cli/installers/lib/core/config-collector.js

@@ -13,14 +13,56 @@ class ConfigCollector {
     this.currentProjectDir = null;
   }
 
+  /**
+   * Find the bmad installation directory in a project
+   * V6+ installations can use ANY folder name but ALWAYS have _cfg/manifest.yaml
+   * @param {string} projectDir - Project directory
+   * @returns {Promise<string>} Path to bmad directory
+   */
+  async findBmadDir(projectDir) {
+    // Check if project directory exists
+    if (!(await fs.pathExists(projectDir))) {
+      // Project doesn't exist yet, return default
+      return path.join(projectDir, 'bmad');
+    }
+
+    // V6+ strategy: Look for ANY directory with _cfg/manifest.yaml
+    // This is the definitive marker of a V6+ installation
+    try {
+      const entries = await fs.readdir(projectDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const manifestPath = path.join(projectDir, entry.name, '_cfg', 'manifest.yaml');
+          if (await fs.pathExists(manifestPath)) {
+            // Found a V6+ installation
+            return path.join(projectDir, entry.name);
+          }
+        }
+      }
+    } catch {
+      // Ignore errors, fall through to default
+    }
+
+    // No V6+ installation found, return default
+    // This will be used for new installations
+    return path.join(projectDir, 'bmad');
+  }
+
   /**
    * Load existing config if it exists from module config files
    * @param {string} projectDir - Target project directory
    */
   async loadExistingConfig(projectDir) {
-    const bmadDir = path.join(projectDir, 'bmad');
     this.existingConfig = {};
 
+    // Check if project directory exists first
+    if (!(await fs.pathExists(projectDir))) {
+      return false;
+    }
+
+    // Find the actual bmad directory (handles custom folder names)
+    const bmadDir = await this.findBmadDir(projectDir);
+
     // Check if bmad directory exists
     if (!(await fs.pathExists(bmadDir))) {
       return false;
@@ -159,27 +201,25 @@ class ConfigCollector {
           this.allAnswers[`${moduleName}_${key}`] = value;
         }
       }
+      // Show "no config" message for modules with no new questions
+      CLIUtils.displayModuleNoConfig(moduleName, moduleConfig.header, moduleConfig.subheader);
       return false; // No new fields
     }
 
-    // If we have new fields, show prompt section and collect only new fields
+    // If we have new fields, build questions first
     if (newKeys.length > 0) {
-      console.log(chalk.yellow(`\n📋 New configuration options available for ${moduleName}`));
-      if (moduleConfig.prompt) {
-        const prompts = Array.isArray(moduleConfig.prompt) ? moduleConfig.prompt : [moduleConfig.prompt];
-        CLIUtils.displayPromptSection(prompts);
-      }
-
       const questions = [];
       for (const key of newKeys) {
         const item = moduleConfig[key];
-        const question = await this.buildQuestion(moduleName, key, item);
+        const question = await this.buildQuestion(moduleName, key, item, moduleConfig);
         if (question) {
           questions.push(question);
         }
       }
 
       if (questions.length > 0) {
+        // Only show header if we actually have questions
+        CLIUtils.displayModuleConfigHeader(moduleName, moduleConfig.header, moduleConfig.subheader);
         console.log(); // Line break before questions
         const answers = await inquirer.prompt(questions);
 
@@ -206,6 +246,9 @@ class ConfigCollector {
           }
           this.collectedConfig[moduleName][originalKey] = result;
         }
+      } else {
+        // New keys exist but no questions generated - show no config message
+        CLIUtils.displayModuleNoConfig(moduleName, moduleConfig.header, moduleConfig.subheader);
       }
     }
 
@@ -325,12 +368,6 @@ class ConfigCollector {
       return;
     }
 
-    // Display module prompts using better formatting
-    if (moduleConfig.prompt) {
-      const prompts = Array.isArray(moduleConfig.prompt) ? moduleConfig.prompt : [moduleConfig.prompt];
-      CLIUtils.displayPromptSection(prompts);
-    }
-
     // Process each config item
     const questions = [];
     const configKeys = Object.keys(moduleConfig).filter((key) => key !== 'prompt');
@@ -343,13 +380,15 @@ class ConfigCollector {
         continue;
       }
 
-      const question = await this.buildQuestion(moduleName, key, item);
+      const question = await this.buildQuestion(moduleName, key, item, moduleConfig);
       if (question) {
         questions.push(question);
       }
     }
 
+    // Display appropriate header based on whether there are questions
     if (questions.length > 0) {
+      CLIUtils.displayModuleConfigHeader(moduleName, moduleConfig.header, moduleConfig.subheader);
       console.log(); // Line break before questions
       const answers = await inquirer.prompt(questions);
 
@@ -450,20 +489,68 @@ class ConfigCollector {
         this.collectedConfig[moduleName][originalKey] = result;
       }
 
-      // Display module completion message after collecting all answers (unless skipped)
-      if (!skipCompletion) {
-        CLIUtils.displayModuleComplete(moduleName);
-      }
+      // No longer display completion boxes - keep output clean
+    } else {
+      // No questions for this module - show completion message
+      CLIUtils.displayModuleNoConfig(moduleName, moduleConfig.header, moduleConfig.subheader);
     }
   }
 
+  /**
+   * Replace placeholders in a string with collected config values
+   * @param {string} str - String with placeholders
+   * @param {string} currentModule - Current module name (to look up defaults in same module)
+   * @param {Object} moduleConfig - Current module's config schema (to look up defaults)
+   * @returns {string} String with placeholders replaced
+   */
+  replacePlaceholders(str, currentModule = null, moduleConfig = null) {
+    if (typeof str !== 'string') {
+      return str;
+    }
+
+    return str.replaceAll(/{([^}]+)}/g, (match, configKey) => {
+      // Preserve special placeholders
+      if (configKey === 'project-root' || configKey === 'value' || configKey === 'directory_name') {
+        return match;
+      }
+
+      // Look for the config value in allAnswers (already answered questions)
+      let configValue = this.allAnswers[configKey] || this.allAnswers[`core_${configKey}`];
+
+      // Check in already collected config
+      if (!configValue) {
+        for (const mod of Object.keys(this.collectedConfig)) {
+          if (mod !== '_meta' && this.collectedConfig[mod] && this.collectedConfig[mod][configKey]) {
+            configValue = this.collectedConfig[mod][configKey];
+            // Remove {project-root}/ prefix if present for cleaner display
+            if (typeof configValue === 'string' && configValue.includes('{project-root}/')) {
+              configValue = configValue.replace('{project-root}/', '');
+            }
+            break;
+          }
+        }
+      }
+
+      // If still not found and we're in the same module, use the default from the config schema
+      if (!configValue && currentModule && moduleConfig && moduleConfig[configKey]) {
+        const referencedItem = moduleConfig[configKey];
+        if (referencedItem && referencedItem.default !== undefined) {
+          configValue = referencedItem.default;
+        }
+      }
+
+      return configValue || match;
+    });
+  }
+
   /**
    * Build an inquirer question from a config item
    * @param {string} moduleName - Module name
    * @param {string} key - Config key
    * @param {Object} item - Config item definition
+   * @param {Object} moduleConfig - Full module config schema (for resolving defaults)
    */
-  async buildQuestion(moduleName, key, item) {
+  async buildQuestion(moduleName, key, item, moduleConfig = null) {
     const questionName = `${moduleName}_${key}`;
 
     // Check for existing value
@@ -483,9 +570,42 @@ class ConfigCollector {
     let defaultValue = item.default;
     let choices = null;
 
-    if (typeof defaultValue === 'string' && defaultValue.includes('{directory_name}') && this.currentProjectDir) {
-      const dirName = path.basename(this.currentProjectDir);
-      defaultValue = defaultValue.replaceAll('{directory_name}', dirName);
+    // Check if default contains references to other fields in the same module
+    const hasSameModuleReference = typeof defaultValue === 'string' && defaultValue.match(/{([^}]+)}/);
+    let dynamicDefault = false;
+
+    // Replace placeholders in default value with collected config values
+    if (typeof defaultValue === 'string') {
+      if (defaultValue.includes('{directory_name}') && this.currentProjectDir) {
+        const dirName = path.basename(this.currentProjectDir);
+        defaultValue = defaultValue.replaceAll('{directory_name}', dirName);
+      }
+
+      // Check if this references another field in the same module (for dynamic defaults)
+      if (hasSameModuleReference && moduleConfig) {
+        const matches = defaultValue.match(/{([^}]+)}/g);
+        if (matches) {
+          for (const match of matches) {
+            const fieldName = match.slice(1, -1); // Remove { }
+            // Check if this field exists in the same module config
+            if (moduleConfig[fieldName]) {
+              dynamicDefault = true;
+              break;
+            }
+          }
+        }
+      }
+
+      // If not dynamic, replace placeholders now
+      if (!dynamicDefault) {
+        defaultValue = this.replacePlaceholders(defaultValue, moduleName, moduleConfig);
+      }
+
+      // Strip {project-root}/ from defaults since it will be added back by result template
+      // This makes the display cleaner and user input simpler
+      if (defaultValue.includes('{project-root}/')) {
+        defaultValue = defaultValue.replace('{project-root}/', '');
+      }
     }
 
     // Handle different question types
@@ -548,31 +668,67 @@ class ConfigCollector {
       message = item.prompt;
     }
 
+    // Replace placeholders in prompt message with collected config values
+    if (typeof message === 'string') {
+      message = this.replacePlaceholders(message, moduleName, moduleConfig);
+    }
+
     // Add current value indicator for existing configs
     if (existingValue !== null && existingValue !== undefined) {
       if (typeof existingValue === 'boolean') {
         message += chalk.dim(` (current: ${existingValue ? 'true' : 'false'})`);
-        defaultValue = existingValue;
       } else if (Array.isArray(existingValue)) {
         message += chalk.dim(` (current: ${existingValue.join(', ')})`);
       } else if (questionType !== 'list') {
         // Show the cleaned value (without {project-root}/) for display
         message += chalk.dim(` (current: ${existingValue})`);
-        defaultValue = existingValue;
       }
     } else if (item.example && questionType === 'input') {
       // Show example for input fields
-      const exampleText = typeof item.example === 'string' ? item.example.replace('{project-root}/', '') : JSON.stringify(item.example);
+      let exampleText = typeof item.example === 'string' ? item.example : JSON.stringify(item.example);
+      // Replace placeholders in example
+      if (typeof exampleText === 'string') {
+        exampleText = this.replacePlaceholders(exampleText, moduleName, moduleConfig);
+        exampleText = exampleText.replace('{project-root}/', '');
+      }
       message += chalk.dim(` (e.g., ${exampleText})`);
     }
 
+    // Build the question object
     const question = {
       type: questionType,
       name: questionName,
       message: message,
-      default: defaultValue,
     };
 
+    // Set default - if it's dynamic, use a function that inquirer will evaluate with current answers
+    // But if we have an existing value, always use that instead
+    if (existingValue !== null && existingValue !== undefined && questionType !== 'list') {
+      question.default = existingValue;
+    } else if (dynamicDefault && typeof item.default === 'string') {
+      const originalDefault = item.default;
+      question.default = (answers) => {
+        // Replace placeholders using answers from previous questions in the same batch
+        let resolved = originalDefault;
+        resolved = resolved.replaceAll(/{([^}]+)}/g, (match, fieldName) => {
+          // Look for the answer in the current batch (prefixed with module name)
+          const answerKey = `${moduleName}_${fieldName}`;
+          if (answers[answerKey] !== undefined) {
+            return answers[answerKey];
+          }
+          // Fall back to collected config
+          return this.collectedConfig[moduleName]?.[fieldName] || match;
+        });
+        // Strip {project-root}/ for cleaner display
+        if (resolved.includes('{project-root}/')) {
+          resolved = resolved.replace('{project-root}/', '');
+        }
+        return resolved;
+      };
+    } else {
+      question.default = defaultValue;
+    }
+
     // Add choices for select types
     if (choices) {
       question.choices = choices;
@@ -584,6 +740,23 @@ class ConfigCollector {
         if (!input && item.required) {
           return 'This field is required';
         }
+        // Validate against regex pattern if provided
+        if (input && item.regex) {
+          const regex = new RegExp(item.regex);
+          if (!regex.test(input)) {
+            return `Invalid format. Must match pattern: ${item.regex}`;
+          }
+        }
+        return true;
+      };
+    }
+
+    // Add validation for checkbox (multi-select) fields
+    if (questionType === 'checkbox' && item.required) {
+      question.validate = (answers) => {
+        if (!answers || answers.length === 0) {
+          return 'At least one option must be selected';
+        }
         return true;
       };
     }