s9n-devops-agent 2.0.18-dev.2 → 2.0.18-dev.3

package/docs/RELEASE_NOTES.md

@@ -1,3 +1,18 @@
+# Release Notes - s9n-devops-agent v2.0.18-dev.3
+
+## 🚀 Enhancements
+- **Base Branch Selection**: You can now select a base branch (e.g., main, develop) when starting a session, allowing for cleaner feature branching from stable points.
+- **Enhanced Setup Wizard**: 
+  - Finds and merges contract files from subdirectories.
+  - Ensures versioning strategy is configured.
+  - Persists credentials in user home directory to survive package updates.
+
+## 🐛 Fixes
+- **Update Logic**: Fixed update checker to respect dev versions.
+- **Credentials**: Fixed issue where API keys were lost during updates.
+
+---
+
 # Release Notes - s9n-devops-agent v2.0.11-dev.0
 
 ## 🐛 Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s9n-devops-agent",
-  "version": "2.0.18-dev.2",
+  "version": "2.0.18-dev.3",
   "description": "CS_DevOpsAgent - Intelligent Git Automation System with multi-agent support and session management",
   "type": "module",
   "main": "src/cs-devops-agent-worker.js",

package/src/credentials-manager.js

@@ -3,11 +3,15 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 
+import os from 'os';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const rootDir = path.join(__dirname, '..');
 
-const CREDENTIALS_PATH = process.env.DEVOPS_CREDENTIALS_PATH || path.join(rootDir, 'local_deploy', 'credentials.json');
+// Use home directory for persistent storage across package updates
+const HOME_DIR = os.homedir();
+const CONFIG_DIR = path.join(HOME_DIR, '.devops-agent');
+const CREDENTIALS_PATH = process.env.DEVOPS_CREDENTIALS_PATH || path.join(CONFIG_DIR, 'credentials.json');
 
 // Simple obfuscation to prevent casual shoulder surfing
 // NOTE: This is NOT strong encryption. In a production environment with sensitive keys,
@@ -38,15 +42,33 @@ export class CredentialsManager {
         console.error('Failed to load credentials:', error.message);
         this.credentials = {};
       }
+    } else {
+        // Migration: Check for old local_deploy location
+        const oldPath = path.join(__dirname, '..', 'local_deploy', 'credentials.json');
+        if (fs.existsSync(oldPath)) {
+            try {
+                const rawData = fs.readFileSync(oldPath, 'utf8');
+                const data = JSON.parse(rawData);
+                 // Deobfuscate sensitive values
+                if (data.groqApiKey) {
+                    data.groqApiKey = deobfuscate(data.groqApiKey);
+                }
+                this.credentials = data;
+                // Save to new location immediately
+                this.save();
+            } catch (e) {
+                // Ignore migration errors
+            }
+        }
     }
   }
 
   save() {
     try {
-      // Ensure local_deploy exists
-      const localDeployDir = path.dirname(CREDENTIALS_PATH);
-      if (!fs.existsSync(localDeployDir)) {
-        fs.mkdirSync(localDeployDir, { recursive: true });
+      // Ensure config dir exists
+      const configDir = path.dirname(CREDENTIALS_PATH);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
       }
 
       // Clone and obfuscate

package/src/session-coordinator.js

@@ -165,22 +165,42 @@ export class SessionCoordinator {
       // Show checking message
       console.log(`${CONFIG.colors.dim}🔍 Checking for DevOps Agent updates...${CONFIG.colors.reset}`);
       
-      // Check npm for latest version
-      const result = execSync('npm view s9n-devops-agent version', {
+      // Check npm for dist-tags
+      const distTags = JSON.parse(execSync('npm view s9n-devops-agent dist-tags --json', {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore'],
         timeout: 5000
-      }).trim();
+      }).trim());
+      
+      const latest = distTags.latest;
+      const dev = distTags.dev;
       
       // Update last check time
       globalSettings.lastUpdateCheck = now;
       this.saveGlobalSettings(globalSettings);
       
-      // Compare versions
-      if (result && this.compareVersions(result, this.currentVersion) > 0) {
+      // Determine which version to compare against
+      // If current is a dev version, we check dev tag as well
+      const isDev = this.currentVersion.includes('dev') || this.currentVersion.includes('-');
+      
+      let updateAvailable = false;
+      let targetVersion = latest;
+      let updateTag = 'latest';
+      
+      if (isDev && dev && this.compareVersions(dev, this.currentVersion) > 0) {
+          updateAvailable = true;
+          targetVersion = dev;
+          updateTag = 'dev';
+      } else if (this.compareVersions(latest, this.currentVersion) > 0) {
+          updateAvailable = true;
+          targetVersion = latest;
+          updateTag = 'latest';
+      }
+      
+      if (updateAvailable) {
         console.log(`\n${CONFIG.colors.yellow}▲ Update Available!${CONFIG.colors.reset}`);
         console.log(`${CONFIG.colors.dim}Current version: ${this.currentVersion}${CONFIG.colors.reset}`);
-        console.log(`${CONFIG.colors.bright}Latest version:  ${result}${CONFIG.colors.reset}`);
+        console.log(`${CONFIG.colors.bright}New version:     ${targetVersion} (${updateTag})${CONFIG.colors.reset}`);
         console.log();
         
         // Ask if user wants to update now
@@ -199,7 +219,7 @@ export class SessionCoordinator {
         if (updateNow) {
           console.log(`\n${CONFIG.colors.blue}Updating s9n-devops-agent...${CONFIG.colors.reset}`);
           try {
-            execSync('npm install -g s9n-devops-agent@latest', {
+            execSync(`npm install -g s9n-devops-agent@${updateTag}`, {
               stdio: 'inherit',
               cwd: process.cwd()
             });
@@ -207,10 +227,10 @@ export class SessionCoordinator {
             process.exit(0);
           } catch (err) {
             console.log(`\n${CONFIG.colors.red}✗ Update failed: ${err.message}${CONFIG.colors.reset}`);
-            console.log(`${CONFIG.colors.dim}You can manually update with: npm install -g s9n-devops-agent@latest${CONFIG.colors.reset}`);
+            console.log(`${CONFIG.colors.dim}You can manually update with: npm install -g s9n-devops-agent@${updateTag}${CONFIG.colors.reset}`);
           }
         } else {
-          console.log(`${CONFIG.colors.dim}You can update later with: npm install -g s9n-devops-agent@latest${CONFIG.colors.reset}`);
+          console.log(`${CONFIG.colors.dim}You can update later with: npm install -g s9n-devops-agent@${updateTag}${CONFIG.colors.reset}`);
         }
         console.log();
       } else {
@@ -224,19 +244,22 @@ export class SessionCoordinator {
   }
   
   /**
-   * Compare semantic versions
+   * Compare semantic versions (robust to suffixes)
    * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
    */
   compareVersions(v1, v2) {
-    const parts1 = v1.split('.').map(Number);
-    const parts2 = v2.split('.').map(Number);
+    if (!v1 || !v2) return 0;
     
-    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-      const p1 = parts1[i] || 0;
-      const p2 = parts2[i] || 0;
+    const normalize = v => v.replace(/^v/, '').split('.').map(p => parseInt(p, 10));
+    const p1 = normalize(v1);
+    const p2 = normalize(v2);
+    
+    for (let i = 0; i < Math.max(p1.length, p2.length); i++) {
+      const n1 = isNaN(p1[i]) ? 0 : p1[i];
+      const n2 = isNaN(p2[i]) ? 0 : p2[i];
       
-      if (p1 > p2) return 1;
-      if (p1 < p2) return -1;
+      if (n1 > n2) return 1;
+      if (n1 < n2) return -1;
     }
     
     return 0;
@@ -427,13 +450,18 @@ export class SessionCoordinator {
   /**
    * Ensure project-specific version settings are configured
    */
-  async ensureProjectSetup() {
+  async ensureProjectSetup(options = {}) {
     const projectSettings = this.loadProjectSettings();
     
     // Check if project setup is needed (version strategy)
-    if (!projectSettings.versioningStrategy || !projectSettings.versioningStrategy.configured) {
-      console.log(`\n${CONFIG.colors.yellow}First-time project setup for this repository!${CONFIG.colors.reset}`);
-      console.log(`${CONFIG.colors.dim}Let's configure the versioning strategy for this project${CONFIG.colors.reset}`);
+    if (options.force || !projectSettings.versioningStrategy || !projectSettings.versioningStrategy.configured) {
+      console.log(`\n${CONFIG.colors.yellow}Project Versioning Setup${CONFIG.colors.reset}`);
+      if (options.force) {
+          console.log(`${CONFIG.colors.dim}Reconfiguring version strategy...${CONFIG.colors.reset}`);
+      } else {
+          console.log(`${CONFIG.colors.yellow}First-time project setup for this repository!${CONFIG.colors.reset}`);
+          console.log(`${CONFIG.colors.dim}Let's configure the versioning strategy for this project${CONFIG.colors.reset}`);
+      }
       
       const versionInfo = await this.promptForStartingVersion();
       projectSettings.versioningStrategy = {
@@ -797,6 +825,73 @@ export class SessionCoordinator {
     return config;
   }
 
+  /**
+   * Prompt for base branch (source)
+   */
+  async promptForBaseBranch() {
+    console.log(`\n${CONFIG.colors.yellow}═══ Base Branch Selection ═══${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}Select the branch you want to start your work FROM.${CONFIG.colors.reset}`);
+    
+    // Get available branches
+    const branches = this.getAvailableBranches();
+    // Prioritize main/develop/master
+    const priorityBranches = ['main', 'master', 'develop', 'development'];
+    
+    const sortedBranches = branches.sort((a, b) => {
+        const aP = priorityBranches.indexOf(a);
+        const bP = priorityBranches.indexOf(b);
+        if (aP !== -1 && bP !== -1) return aP - bP;
+        if (aP !== -1) return -1;
+        if (bP !== -1) return 1;
+        return a.localeCompare(b);
+    });
+    
+    const uniqueBranches = [...new Set(sortedBranches)].slice(0, 10);
+    
+    console.log();
+    uniqueBranches.forEach((branch, index) => {
+      const isPriority = priorityBranches.includes(branch);
+      const marker = isPriority ? ` ${CONFIG.colors.green}⭐${CONFIG.colors.reset}` : '';
+      console.log(`  ${index + 1}) ${branch}${marker}`);
+    });
+    console.log(`  0) Enter a different branch name`);
+    console.log(`  Hit Enter for default (HEAD)`);
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    return new Promise((resolve) => {
+      rl.question(`\nSelect base branch (1-${uniqueBranches.length}, 0, or Enter): `, (answer) => {
+        rl.close();
+        const choice = answer.trim();
+        
+        if (choice === '') {
+             resolve('HEAD');
+             return;
+        }
+        
+        const num = parseInt(choice);
+        
+        if (num === 0) {
+           const rl2 = readline.createInterface({
+               input: process.stdin,
+               output: process.stdout
+           });
+           rl2.question('Enter custom branch name: ', (custom) => {
+               rl2.close();
+               resolve(custom.trim() || 'HEAD');
+           });
+        } else if (num >= 1 && num <= uniqueBranches.length) {
+            resolve(uniqueBranches[num - 1]);
+        } else {
+            resolve('HEAD');
+        }
+      });
+    });
+  }
+
   /**
    * Prompt for auto-merge configuration
    */
@@ -1172,6 +1267,9 @@ export class SessionCoordinator {
     // Ask for auto-merge configuration
     const mergeConfig = await this.promptForMergeConfig();
     
+    // Ask for base branch (where to start work from)
+    const baseBranch = await this.promptForBaseBranch();
+    
     // Check for Docker configuration and ask about restart preference
     let dockerConfig = null;
     
@@ -1321,7 +1419,10 @@ export class SessionCoordinator {
       
       // Create worktree
       console.log(`\n${CONFIG.colors.yellow}Creating worktree...${CONFIG.colors.reset}`);
-      execSync(`git worktree add -b ${branchName} "${worktreePath}" HEAD`, { stdio: 'pipe' });
+      const baseRef = baseBranch || 'HEAD';
+      console.log(`${CONFIG.colors.dim}Branching off: ${baseRef}${CONFIG.colors.reset}`);
+      
+      execSync(`git worktree add -b ${branchName} "${worktreePath}" ${baseRef}`, { stdio: 'pipe' });
       console.log(`${CONFIG.colors.green}✓${CONFIG.colors.reset} Worktree created at: ${worktreePath}`);
       
       // If we're in a submodule, set up the correct remote for the worktree

package/src/setup-cs-devops-agent.js

@@ -28,6 +28,7 @@ import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { credentialsManager } from './credentials-manager.js';
+import { SessionCoordinator } from './session-coordinator.js';
 import {
   colors,
   status,
@@ -149,25 +150,9 @@ This structure is compatible with the DevOps Agent's automation tools.
   return missingFolders;
 }
 
-function checkContractsExist(projectRoot) {
-  // Search recursively for contract folders
+async function checkContractsExist(projectRoot) {
+  // Search recursively for contract folders and files
   try {
-    // Find all directories named 'House_Rules_Contracts' or 'contracts'
-    // Ignoring node_modules and .git
-    const findCommand = `find "${projectRoot}" -type d \\( -name "House_Rules_Contracts" -o -name "contracts" \\) -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/local_deploy/*"`;
-    
-    const output = execSync(findCommand, { encoding: 'utf8' }).trim();
-    const locations = output.split('\n').filter(Boolean);
-
-    let contractsDir = null;
-    if (locations.length > 0) {
-      // Prefer House_Rules_Contracts if available
-      contractsDir = locations.find(l => l.endsWith('House_Rules_Contracts')) || locations[0];
-      log.info(`Found contracts directory at: ${contractsDir}`);
-    }
-
-    if (!contractsDir) return false;
-    
     const requiredContracts = [
       'FEATURES_CONTRACT.md',
       'API_CONTRACT.md',
@@ -176,21 +161,122 @@ function checkContractsExist(projectRoot) {
       'THIRD_PARTY_INTEGRATIONS.md',
       'INFRA_CONTRACT.md'
     ];
+
+    // Map to hold found files for each type
+    const contractMap = {};
+    requiredContracts.forEach(c => contractMap[c] = []);
+
+    // Find all files that look like contracts
+    // We look for files containing "CONTRACT" in the name, excluding typical ignores
+    const findCommand = `find "${projectRoot}" -type f \\( -name "*CONTRACT*.md" -o -name "*CONTRACT*.json" \\) -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/local_deploy/*"`;
+    
+    let files = [];
+    try {
+        const output = execSync(findCommand, { encoding: 'utf8' }).trim();
+        files = output.split('\n').filter(Boolean);
+    } catch (e) {
+        // find might fail if no matches or other issues, just treat as empty
+    }
+
+    // Categorize found files
+    for (const file of files) {
+        const basename = path.basename(file).toUpperCase();
+        
+        // Skip files in the target directory itself (House_Rules_Contracts) to avoid self-merging if we run this multiple times
+        // actually we SHOULD include them to see if we have them, but valid if we are merging duplicates from elsewhere
+        
+        let matched = false;
+        
+        if (basename.includes('FEATURE')) contractMap['FEATURES_CONTRACT.md'].push(file);
+        else if (basename.includes('API')) contractMap['API_CONTRACT.md'].push(file);
+        else if (basename.includes('DATABASE') || basename.includes('SCHEMA')) contractMap['DATABASE_SCHEMA_CONTRACT.md'].push(file);
+        else if (basename.includes('SQL')) contractMap['SQL_CONTRACT.json'].push(file);
+        else if (basename.includes('INFRA')) contractMap['INFRA_CONTRACT.md'].push(file);
+        else if (basename.includes('THIRD') || basename.includes('INTEGRATION')) contractMap['THIRD_PARTY_INTEGRATIONS.md'].push(file);
+        else {
+             // Fallback or ignore
+        }
+    }
+
+    const targetDir = path.join(projectRoot, 'House_Rules_Contracts');
+    let hasChanges = false;
+
+    // Process each contract type
+    for (const [type, foundFiles] of Object.entries(contractMap)) {
+        // Filter out unique paths (resolve them)
+        const uniqueFiles = [...new Set(foundFiles.map(f => path.resolve(f)))];
+        
+        if (uniqueFiles.length > 1) {
+             console.log();
+             log.info(`Found multiple files for contract type: ${colors.cyan}${type}${colors.reset}`);
+             uniqueFiles.forEach(f => console.log(` - ${path.relative(projectRoot, f)}`));
+             
+             const shouldMerge = await confirm(`Do you want to merge these into House_Rules_Contracts/${type}?`, true);
+             
+             if (shouldMerge) {
+                 ensureDirectoryExists(targetDir);
+                 const targetPath = path.join(targetDir, type);
+                 
+                 let mergedContent = '';
+                 // Handle JSON vs MD
+                 if (type.endsWith('.json')) {
+                     // For JSON, we try to merge arrays/objects or just list them
+                     const mergedJson = [];
+                     for (const file of uniqueFiles) {
+                         try {
+                             const content = JSON.parse(fs.readFileSync(file, 'utf8'));
+                             mergedJson.push({ source: path.relative(projectRoot, file), content });
+                         } catch (e) {
+                             log.warn(`Skipping invalid JSON in ${path.basename(file)}`);
+                         }
+                     }
+                     mergedContent = JSON.stringify(mergedJson, null, 2);
+                 } else {
+                     // Markdown
+                     mergedContent = `# Merged ${type}\n\nGenerated on ${new Date().toISOString()}\n\n`;
+                     for (const file of uniqueFiles) {
+                         const content = fs.readFileSync(file, 'utf8');
+                         mergedContent += `\n<!-- SOURCE: ${path.relative(projectRoot, file)} -->\n`;
+                         mergedContent += `## Source: ${path.basename(file)}\n(Path: ${path.relative(projectRoot, file)})\n\n`;
+                         mergedContent += `${content}\n\n---\n`;
+                     }
+                 }
+                 
+                 fs.writeFileSync(targetPath, mergedContent);
+                 log.success(`Merged contracts into ${path.relative(projectRoot, targetPath)}`);
+                 hasChanges = true;
+             }
+        } else if (uniqueFiles.length === 1) {
+            // If single file exists but is NOT in House_Rules_Contracts, ask to move/copy
+            const file = uniqueFiles[0];
+            const targetPath = path.join(targetDir, type);
+            
+            if (file !== path.resolve(targetPath)) {
+                console.log();
+                log.info(`Found ${type} at: ${path.relative(projectRoot, file)}`);
+                const shouldCopy = await confirm(`Copy this to central House_Rules_Contracts/${type}?`, true);
+                if (shouldCopy) {
+                    ensureDirectoryExists(targetDir);
+                    fs.copyFileSync(file, targetPath);
+                    log.success(`Copied to ${path.relative(projectRoot, targetPath)}`);
+                    hasChanges = true;
+                }
+            }
+        }
+    }
+
+    // Final check: Do we have all required contracts in the target directory?
+    const missing = requiredContracts.filter(file => !fs.existsSync(path.join(targetDir, file)));
     
-    // Check if we have multiple similar contracts that might need merging
-    const files = fs.readdirSync(contractsDir);
-    const potentialDuplicates = files.filter(f => 
-      (f.includes('FEATURE') && f !== 'FEATURES_CONTRACT.md') ||
-      (f.includes('API') && f !== 'API_CONTRACT.md')
-    );
-
-    if (potentialDuplicates.length > 0) {
-      log.info(`Found potential split contract files in ${contractsDir}:`);
-      potentialDuplicates.forEach(f => console.log(` - ${f}`));
-      console.log('You may want to merge these into single contract files per type.');
+    if (missing.length === 0) {
+        if (hasChanges) log.success('Contract files consolidated successfully.');
+        return true;
     }
     
-    return requiredContracts.every(file => fs.existsSync(path.join(contractsDir, file)));
+    // If we are missing some, but have others, we still return false so generateContracts can run for the missing ones?
+    // Or we return false and generateContracts will run.
+    return false;
+    
   } catch (error) {
     log.warn(`Error searching for contracts: ${error.message}`);
     return false;
@@ -866,30 +952,50 @@ async function setupEnvFile(projectRoot) {
     log.info('Creating .env file');
   }
   
-  // Check for OPENAI_API_KEY
+  // Check if OPENAI_API_KEY is already present in memory (from credentials.json)
+  const existingKey = credentialsManager.getGroqApiKey();
+  
+  // Check for OPENAI_API_KEY in .env content
   if (!envContent.includes('OPENAI_API_KEY=')) {
-    console.log();
-    explain(`
-${colors.bright}Groq API Key Setup${colors.reset}
-The contract automation features use Groq LLM (via OpenAI compatibility).
-You can enter your API key now, or set it later in the .env file.
-    `);
-    
-    const apiKey = await prompt('Enter Groq API Key (leave empty to skip)');
-    
-    if (apiKey) {
+    if (existingKey) {
+      log.info('Found existing Groq API Key in credentials store.');
       const newLine = envContent.endsWith('\n') || envContent === '' ? '' : '\n';
-      envContent += `${newLine}# Groq API Key for Contract Automation\nOPENAI_API_KEY=${apiKey}\n`;
+      envContent += `${newLine}# Groq API Key for Contract Automation\nOPENAI_API_KEY=${existingKey}\n`;
       fs.writeFileSync(envPath, envContent);
-      log.success('Added OPENAI_API_KEY to .env');
+      log.success('Restored OPENAI_API_KEY to .env');
     } else {
-      log.warn('Skipped Groq API Key. Contract automation features may not work.');
-      if (!fs.existsSync(envPath)) {
-        fs.writeFileSync(envPath, '# Environment Variables\n');
+      console.log();
+      explain(`
+${colors.bright}Groq API Key Setup${colors.reset}
+The contract automation features use Groq LLM (via OpenAI compatibility).
+You can enter your API key now, or set it later in the .env file.
+      `);
+      
+      const apiKey = await prompt('Enter Groq API Key (leave empty to skip)');
+      
+      if (apiKey) {
+        const newLine = envContent.endsWith('\n') || envContent === '' ? '' : '\n';
+        envContent += `${newLine}# Groq API Key for Contract Automation\nOPENAI_API_KEY=${apiKey}\n`;
+        fs.writeFileSync(envPath, envContent);
+        
+        // Also save to credentials manager for persistence across updates
+        credentialsManager.setGroqApiKey(apiKey);
+        
+        log.success('Added OPENAI_API_KEY to .env');
+      } else {
+        log.warn('Skipped Groq API Key. Contract automation features may not work.');
+        if (!fs.existsSync(envPath)) {
+          fs.writeFileSync(envPath, '# Environment Variables\n');
+        }
       }
     }
   } else {
     log.info('OPENAI_API_KEY is already configured in .env');
+    // Ensure it's backed up in credentials manager if it exists in .env
+    const match = envContent.match(/OPENAI_API_KEY=(.+)/);
+    if (match && match[1] && !existingKey) {
+        credentialsManager.setGroqApiKey(match[1].trim());
+    }
   }
 }
 
@@ -1125,7 +1231,7 @@ ${colors.bright}Security:${colors.reset} Stored locally in ${colors.yellow}local
     }
 
     // Check for contracts
-    if (!checkContractsExist(projectRoot)) {
+    if (!(await checkContractsExist(projectRoot))) {
       log.header();
       log.title('📜 Contract Files Missing');
       
@@ -1162,6 +1268,34 @@ We can scan your codebase and generate them now.
             log.success('Created .env file');
         }
     }
+
+    // Initialize SessionCoordinator for versioning setup
+    const coordinator = new SessionCoordinator();
+    
+    // Check/Setup versioning strategy
+    if (!skipPrompts) {
+        const settings = coordinator.loadProjectSettings();
+        if (!settings.versioningStrategy?.configured) {
+             log.header();
+             log.title('📅 Project Versioning Strategy');
+             await coordinator.ensureProjectSetup();
+        } else {
+             // Optional reconfigure
+             log.info('Versioning strategy is already configured.');
+             const reconfigure = await confirm('Do you want to reconfigure versioning?', false);
+             if (reconfigure) {
+                 await coordinator.ensureProjectSetup({ force: true });
+             }
+        }
+    } else {
+         // In non-interactive mode, we only ensure if missing (and hope it doesn't block or has defaults)
+         // Actually promptForStartingVersion is interactive-only, so we skip if missing in non-interactive
+         // or we could force defaults. For now, we skip to avoid hanging.
+         const settings = coordinator.loadProjectSettings();
+         if (!settings.versioningStrategy?.configured) {
+             log.warn('Skipping versioning setup (interactive-only). Run setup without --yes to configure.');
+         }
+    }
     
     // Clean up DevOpsAgent files to avoid duplicates
     cleanupDevOpsAgentFiles(projectRoot, agentName);