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

package/README.md

@@ -81,6 +81,7 @@ s9n-devops-agent start
 ### 🌲 Smart Branch Management
 - **Hierarchy:** `session/task` → `daily/date` → `main`.
 - **Auto-Merge:** Sessions automatically merge into daily branches, which roll over to main.
+- **Base Branch Selection:** Choose any branch (main, develop, etc.) as the starting point for your session worktree.
 
 ### 📋 House Rules System
 - **Context Injection:** AI agents read `docs/houserules.md` to understand your coding conventions.

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.4",
   "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/cs-devops-agent-worker.js

@@ -165,6 +165,10 @@ const FORCE_ROLLOVER  = (process.env.AC_FORCE_ROLLOVER  || "false").toLowerCase(
 const VERSION_PREFIX       = process.env.AC_VERSION_PREFIX || "v0.";
 const VERSION_START_MINOR  = Number(process.env.AC_VERSION_START_MINOR || "20");     // Start at v0.20 for micro-revisions
 const VERSION_BASE_REF     = process.env.AC_VERSION_BASE_REF || "origin/main";      // where new version branches start
+
+// Rebase configuration
+const REBASE_INTERVAL_HOURS = Number(process.env.AC_REBASE_INTERVAL || 0);
+const BASE_BRANCH           = process.env.AC_BASE_BRANCH || 'HEAD';
 // ------------------------------------------------
 
 const log  = (...a) => console.log("[cs-devops-agent]", ...a);
@@ -953,6 +957,109 @@ function detectInfrastructureChanges(changedFiles) {
   return detected;
 }
 
+// ============================================================================
+// AUTO-REBASE FUNCTIONALITY
+// ============================================================================
+
+/**
+ * Check if it's time to rebase and perform the operation
+ * @param {string} repoRoot - Repository root
+ * @returns {Promise<boolean>} - True if rebase occurred
+ */
+async function checkAndPerformRebase(repoRoot) {
+  if (REBASE_INTERVAL_HOURS <= 0) return false;
+  if (BASE_BRANCH === 'HEAD') return false; // Can't rebase from HEAD (relative)
+  
+  // Calculate interval in ms
+  const intervalMs = REBASE_INTERVAL_HOURS * 60 * 60 * 1000;
+  const now = Date.now();
+  
+  // Check if enough time has passed
+  if (!global.lastRebaseTime) global.lastRebaseTime = now; // Initialize on first run
+  if (now - global.lastRebaseTime < intervalMs) return false;
+  
+  // Don't rebase if we are busy
+  if (busy) return false;
+  
+  try {
+    busy = true;
+    
+    console.log('\n' + '━'.repeat(60));
+    console.log(`\x1b[33m⚠️  AUTO-REBASE IN PROGRESS - PAUSING AGENT...\x1b[0m`);
+    console.log(`Interval: ${REBASE_INTERVAL_HOURS} hours reached.`);
+    console.log(`Base: ${BASE_BRANCH}`);
+    console.log('━'.repeat(60) + '\n');
+    
+    // Check for uncommitted changes
+    const dirty = await hasUncommittedChanges();
+    let stashed = false;
+    
+    if (dirty) {
+      log('Stashing uncommitted changes before rebase...');
+      const stashRes = await run('git', ['stash', 'push', '-m', `Auto-stash before rebase ${new Date().toISOString()}`]);
+      if (stashRes.ok) stashed = true;
+      else {
+        console.error('\x1b[31m✗ Failed to stash changes. Aborting rebase.\x1b[0m');
+        busy = false;
+        return false;
+      }
+    }
+    
+    // Fetch latest
+    log(`Fetching latest changes from origin...`);
+    await run('git', ['fetch', 'origin', BASE_BRANCH]);
+    
+    // Rebase
+    log(`Rebasing onto origin/${BASE_BRANCH}...`);
+    const rebaseRes = await run('git', ['pull', '--rebase', 'origin', BASE_BRANCH]);
+    
+    if (rebaseRes.ok) {
+      console.log(`\x1b[32m✓ Rebase successful!\x1b[0m`);
+      
+      // Pop stash if needed
+      if (stashed) {
+        log('Restoring stashed changes...');
+        const popRes = await run('git', ['stash', 'pop']);
+        if (!popRes.ok) {
+          console.error('\x1b[31m⚠️  Conflict during stash pop. Manual intervention required.\x1b[0m');
+          console.log('\x1b[33mPlease resolve conflicts and continue.\x1b[0m');
+        } else {
+          console.log('\x1b[32m✓ Stash restored.\x1b[0m');
+        }
+      }
+      
+      global.lastRebaseTime = Date.now();
+    } else {
+      console.error(`\x1b[31m✗ REBASE CONFLICT DETECTED\x1b[0m`);
+      console.error(rebaseRes.stdout);
+      
+      // Abort rebase
+      log('Aborting rebase...');
+      await run('git', ['rebase', '--abort']);
+      
+      // Restore stash if we stashed
+      if (stashed) {
+        await run('git', ['stash', 'pop']);
+      }
+      
+      console.log('\x1b[33mRebase aborted. Please manually rebase your branch.\x1b[0m');
+      // Disable auto-rebase for this session to avoid loop?
+      // Or just wait for next interval.
+    }
+    
+    console.log(`\x1b[32m✓ RESUMING AGENT OPERATION\x1b[0m\n`);
+    return true;
+    
+  } catch (err) {
+    console.error(`Rebase error: ${err.message}`);
+    // Try to recover state
+    try { await run('git', ['rebase', '--abort']); } catch (e) {}
+    return false;
+  } finally {
+    busy = false;
+  }
+}
+
 /**
  * Update infrastructure documentation
  * @param {object} infraChanges - Infrastructure change details
@@ -1500,6 +1607,19 @@ console.log();
     log("watching…");
   }
 
+  // Schedule auto-rebase if configured
+  if (REBASE_INTERVAL_HOURS > 0) {
+    log(`Auto-rebase scheduled every ${REBASE_INTERVAL_HOURS} hours (checking every 5m)`);
+    // Initial check (in case we started overdue)
+    // Don't await this so we don't block startup
+    checkAndPerformRebase(repoRoot).catch(err => console.error(err));
+    
+    // Periodic check
+    setInterval(async () => {
+      await checkAndPerformRebase(repoRoot);
+    }, 5 * 60 * 1000); // Check every 5 minutes
+  }
+
   // ============================================================================
   // FILE WATCHER SETUP - Monitor for changes and trigger commits
   // ============================================================================

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}Which branch should I use as the starting point for your work?${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,12 @@ 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();
+    
+    // Ask for auto-rebase interval
+    const rebaseInterval = await this.promptForRebaseInterval();
+    
     // Check for Docker configuration and ask about restart preference
     let dockerConfig = null;
     
@@ -1321,9 +1422,15 @@ 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}`);
       
+      // Store base branch in session data for rebase logic
+      const sessionBaseBranch = baseRef === 'HEAD' ? await this.resolveHeadBranch() : baseRef;
+      
       // If we're in a submodule, set up the correct remote for the worktree
       if (isSubmodule && parentRemote) {
         console.log(`${CONFIG.colors.yellow}Configuring worktree to use parent repository remote...${CONFIG.colors.reset}`);
@@ -1345,11 +1452,13 @@ export class SessionCoordinator {
         task,
         worktreePath,
         branchName,
+        baseBranch: sessionBaseBranch,
         created: new Date().toISOString(),
         status: 'active',
         pid: process.pid,
         developerInitials: devInitials,
         mergeConfig: mergeConfig,
+        rebaseInterval: rebaseInterval,
         dockerConfig: dockerConfig
       };
       
@@ -1387,6 +1496,46 @@ export class SessionCoordinator {
     }
   }
 
+  /**
+   * Prompt for auto-rebase interval
+   */
+  async promptForRebaseInterval() {
+    console.log(`\n${CONFIG.colors.yellow}═══ Auto-Rebase Configuration ═══${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}I can automatically pull updates from the base branch to keep you up-to-date.${CONFIG.colors.reset}`);
+    console.log(`${CONFIG.colors.dim}This helps prevent conflicts later by rebasing your work periodically.${CONFIG.colors.reset}`);
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    return new Promise((resolve) => {
+      rl.question(`\nHow often should I rebase? (in hours, 0 to disable) [0]: `, (answer) => {
+        rl.close();
+        const hours = parseFloat(answer.trim());
+        if (isNaN(hours) || hours <= 0) {
+            console.log(`${CONFIG.colors.dim}Auto-rebase disabled. I'll let you manage updates manually.${CONFIG.colors.reset}`);
+            resolve(0);
+        } else {
+            console.log(`${CONFIG.colors.green}✓ I'll check for updates and rebase every ${hours} hour(s).${CONFIG.colors.reset}`);
+            resolve(hours);
+        }
+      });
+    });
+  }
+
+  /**
+   * Resolve HEAD to actual branch name
+   */
+  async resolveHeadBranch() {
+      try {
+          const head = execSync('git rev-parse --abbrev-ref HEAD', { cwd: this.repoRoot, encoding: 'utf8' }).trim();
+          return head;
+      } catch (e) {
+          return 'main';
+      }
+  }
+
   /**
    * Generate instructions for the coding agent
    */
@@ -1794,7 +1943,11 @@ The DevOps agent is monitoring this worktree for changes.
       AC_DATE_STYLE: process.env.AC_DATE_STYLE || 'dash',  // Preserve date style
       // Apply version configuration if set
       ...(projectSettings.versioningStrategy?.prefix && { AC_VERSION_PREFIX: projectSettings.versioningStrategy.prefix }),
-      ...(projectSettings.versioningStrategy?.startMinor && { AC_VERSION_START_MINOR: projectSettings.versioningStrategy.startMinor.toString() })
+      ...(projectSettings.versioningStrategy?.startMinor && { AC_VERSION_START_MINOR: projectSettings.versioningStrategy.startMinor.toString() }),
+      
+      // Rebase configuration
+      AC_REBASE_INTERVAL: (sessionData.rebaseInterval || 0).toString(),
+      AC_BASE_BRANCH: sessionData.baseBranch || 'HEAD' // We need to pass the base branch for rebasing
     };
     
     const agentScript = path.join(__dirname, 'cs-devops-agent-worker.js');

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);