s9n-devops-agent 2.0.18-dev.1 → 2.0.18-dev.11

package/src/session-coordinator.js

@@ -133,17 +133,22 @@ export class SessionCoordinator {
   }
 
   cleanupStaleLocks() {
-    // Clean up locks older than 1 hour
-    const oneHourAgo = Date.now() - 3600000;
+    // Clean up locks older than 24 hours (increased from 1 hour to allow resuming next day)
+    const staleThreshold = Date.now() - 86400000;
     
     if (fs.existsSync(this.locksPath)) {
       const locks = fs.readdirSync(this.locksPath);
       locks.forEach(lockFile => {
         const lockPath = path.join(this.locksPath, lockFile);
-        const stats = fs.statSync(lockPath);
-        if (stats.mtimeMs < oneHourAgo) {
-          fs.unlinkSync(lockPath);
-          console.log(`${CONFIG.colors.dim}Cleaned stale lock: ${lockFile}${CONFIG.colors.reset}`);
+        try {
+          const stats = fs.statSync(lockPath);
+          // Only cleanup if VERY old
+          if (stats.mtimeMs < staleThreshold) {
+            fs.unlinkSync(lockPath);
+            console.log(`${CONFIG.colors.dim}Cleaned stale lock: ${lockFile}${CONFIG.colors.reset}`);
+          }
+        } catch (e) {
+          // Ignore errors
         }
       });
     }
@@ -152,7 +157,9 @@ export class SessionCoordinator {
   /**
    * Check for newer version on npm registry
    */
-  async checkForUpdates() {
+  async checkForUpdates(skip = false) {
+    if (skip) return;
+    
     const globalSettings = this.loadGlobalSettings();
     const now = Date.now();
     
@@ -165,22 +172,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 +226,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 +234,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 +251,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;
@@ -245,7 +275,9 @@ export class SessionCoordinator {
   /**
    * Ensure developer initials are configured globally
    */
-  async ensureGlobalSetup() {
+  async ensureGlobalSetup(skip = false) {
+    if (skip) return;
+    
     const globalSettings = this.loadGlobalSettings();
     
     // Check if global setup is needed (developer initials)
@@ -321,7 +353,9 @@ export class SessionCoordinator {
   /**
    * Ensure house rules are set up for the project
    */
-  async ensureHouseRulesSetup() {
+  async ensureHouseRulesSetup(skip = false) {
+    if (skip) return;
+    
     const houseRulesManager = new HouseRulesManager(this.repoRoot);
     const houseRulesPath = path.join(this.repoRoot, 'houserules.md');
     
@@ -427,13 +461,20 @@ export class SessionCoordinator {
   /**
    * Ensure project-specific version settings are configured
    */
-  async ensureProjectSetup() {
+  async ensureProjectSetup(options = {}) {
+    if (options.skip) return;
+    
     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 = {
@@ -555,7 +596,7 @@ export class SessionCoordinator {
     return {
       ...global,
       ...project,
-      developerInitials: global.developerInitials,
+      developerInitials: project.developerInitials || global.developerInitials,
       configured: global.configured
     };
   }
@@ -657,6 +698,8 @@ export class SessionCoordinator {
     const projectSettings = this.loadProjectSettings();
     if (projectSettings.dockerConfig && projectSettings.dockerConfig.neverAsk === true) {
       // User selected 'Never' - skip Docker configuration
+      // Show a subtle message so they know why it's skipped
+      console.log(`${CONFIG.colors.dim}Skipping Docker config (User preference: Never ask). Edit local_deploy/project-settings.json to enable.${CONFIG.colors.reset}`);
       return { enabled: false, neverAsk: true };
     }
     
@@ -797,6 +840,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
    */
@@ -1112,15 +1222,50 @@ export class SessionCoordinator {
    * Create a new session and generate Claude instructions
    */
   async createSession(options = {}) {
-    // Check for updates (once per day)
-    await this.checkForUpdates();
+    // Check for updates (once per day) - skip if requested (e.g. called from Kora)
+    await this.checkForUpdates(options.skipUpdate);
     
     // Ensure both global and project setup are complete
-    await this.ensureGlobalSetup();     // Developer initials (once per user)
-    await this.ensureProjectSetup();    // Version strategy (once per project)
-    await this.ensureHouseRulesSetup(); // House rules setup (once per project)
+    await this.ensureGlobalSetup(options.skipSetup);     // Developer initials (once per user)
+    await this.ensureProjectSetup({ force: false, skip: options.skipSetup });    // Version strategy (once per project)
+    await this.ensureHouseRulesSetup(options.skipSetup); // House rules setup (once per project)
     await this.ensureGroqApiKey();      // GROQ API key for AI commits (once per user)
     
+    // Resume Check: If task provided, check for existing sessions with similar task names
+    if (options.task && options.task !== 'development') {
+        const matchingSession = this.findSessionByTask(options.task);
+        if (matchingSession) {
+            console.log(`\\n${CONFIG.colors.yellow}Found existing session for '${options.task}'${CONFIG.colors.reset}`);
+            console.log(`Session ID: ${CONFIG.colors.bright}${matchingSession.sessionId}${CONFIG.colors.reset}`);
+            console.log(`Status: ${matchingSession.status}`);
+            console.log(`Branch: ${matchingSession.branchName}`);
+            
+            const rlResume = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const resume = await new Promise(resolve => {
+                rlResume.question(`\\nDo you want to resume this session instead? (Y/n): `, ans => {
+                    rlResume.close();
+                    resolve(ans.trim().toLowerCase() !== 'n');
+                });
+            });
+            
+            if (resume) {
+                // Return existing session info structure similar to createSession
+                // but we might need to "claim" it if it's inactive
+                if (matchingSession.status !== 'active') {
+                    // Claim/Restart it
+                    return this.claimSession(matchingSession, options.agent || 'claude');
+                } else {
+                    // It's already active, just return info so startAgent can pick it up
+                    // But startAgent requires lock file integrity.
+                    // If it's active, we might be double-attaching unless we check PID.
+                    // findAvailableSession logic already handles dead PIDs.
+                    // If PID is alive, we probably shouldn't interfere, but here we assume user knows best.
+                    return matchingSession;
+                }
+            }
+        }
+    }
+
     const sessionId = this.generateSessionId();
     const task = options.task || 'development';
     
@@ -1172,6 +1317,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 +1472,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,16 +1502,17 @@ 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
       };
       
       const lockFile = path.join(this.locksPath, `${sessionId}.lock`);
-      fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
       
       // Generate Claude instructions
       const instructions = this.generateClaudeInstructions(lockData);
@@ -1372,6 +1530,9 @@ export class SessionCoordinator {
       // Store instructions in lockData so createAndStart can access them
       lockData.instructions = instructions;
       
+      // Write lock file with instructions included
+      fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+      
       return {
         sessionId,
         worktreePath,
@@ -1387,6 +1548,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
    */
@@ -1403,7 +1604,7 @@ INSTRUCTIONS:
 1. Change to worktree directory: cd "${worktreePath}"
 2. Verify branch: git branch --show-current
 3. Make your changes for: ${task}
-4. Write commit message to: .devops-commit-${sessionId}.msg
+4. Write commit message to: .devops-commit-${sessionId}.msg (use >> to append)
 5. The DevOps agent will auto-commit and push your changes
 `;
 
@@ -1459,7 +1660,7 @@ Make changes for: **${task}**
 ### Step 5: Commit Your Changes
 Write your commit message to the session-specific file:
 \`\`\`bash
-echo "feat: your commit message here" > .devops-commit-${sessionId}.msg
+echo "feat: your commit message here" >> .devops-commit-${sessionId}.msg
 \`\`\`
 
 ### Step 6: Release Your File Locks
@@ -1550,6 +1751,7 @@ The DevOps agent will automatically:
     console.log(`}`);
     console.log(``);
     console.log(`Write commit messages to: .devops-commit-${sessionId}.msg`);
+    console.log(`(Use '>>' to append if you want to add to an existing message)`);
     console.log(`The DevOps agent will automatically commit and push changes.`);
     console.log(``);
     console.log(`⛔ IMPORTANT: STOP HERE AND WAIT`);
@@ -1709,7 +1911,33 @@ The DevOps agent is monitoring this worktree for changes.
   }
 
   /**
-   * Find an available unclaimed session
+   * Find a session by task name (fuzzy match)
+   */
+  findSessionByTask(taskName) {
+    if (!fs.existsSync(this.locksPath)) return null;
+    
+    const locks = fs.readdirSync(this.locksPath).filter(f => f.endsWith('.lock'));
+    const search = taskName.toLowerCase().replace(/[^a-z0-9]/g, '');
+    
+    for (const lockFile of locks) {
+      try {
+        const lockPath = path.join(this.locksPath, lockFile);
+        const session = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        const task = (session.task || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+        
+        // Exact match or significant partial match
+        if (task === search || (task.length > 4 && task.includes(search)) || (search.length > 4 && search.includes(task))) {
+          return session;
+        }
+      } catch (e) {
+        // Ignore invalid locks
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Find an available unclaimed session or orphaned session
    */
   findAvailableSession() {
     if (!fs.existsSync(this.locksPath)) {
@@ -1720,11 +1948,33 @@ The DevOps agent is monitoring this worktree for changes.
     
     for (const lockFile of locks) {
       const lockPath = path.join(this.locksPath, lockFile);
-      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      try {
+        const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
       
-      // Check if session is available (not claimed)
-      if (lockData.status === 'waiting' && !lockData.claimedBy) {
-        return lockData;
+        // Check if session is available (not claimed)
+        if (lockData.status === 'waiting' && !lockData.claimedBy) {
+          return lockData;
+        }
+        
+        // Check if session is orphaned/stopped but not cleaned up
+        // If the PID is no longer running, it might be orphaned
+        if (lockData.status === 'active' && lockData.agentPid) {
+          try {
+            // Check if process exists
+            process.kill(lockData.agentPid, 0);
+          } catch (e) {
+            // Process doesn't exist - it's orphaned!
+            console.log(`${CONFIG.colors.yellow}Found orphaned session: ${lockData.sessionId} (PID ${lockData.agentPid} dead)${CONFIG.colors.reset}`);
+            // Mark as stopped so it can be reclaimed
+            lockData.status = 'stopped';
+            lockData.agentPid = null;
+            lockData.agentStopped = new Date().toISOString();
+            fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2));
+            return lockData;
+          }
+        }
+      } catch (e) {
+        // Invalid lock file
       }
     }
     
@@ -1745,10 +1995,11 @@ The DevOps agent is monitoring this worktree for changes.
     const instructions = this.generateClaudeInstructions(session);
     // Don't display instructions here - they'll be shown after agent starts
     
-    return {
-      ...session,
-      instructions: instructions
-    };
+    // Add instructions to session object and save to lock file
+    session.instructions = instructions;
+    fs.writeFileSync(lockFile, JSON.stringify(session, null, 2));
+    
+    return session;
   }
 
   /**
@@ -1759,7 +2010,7 @@ The DevOps agent is monitoring this worktree for changes.
     
     if (!fs.existsSync(lockFile)) {
       console.error(`${CONFIG.colors.red}Session not found: ${sessionId}${CONFIG.colors.reset}`);
-      return;
+      return false;
     }
     
     const sessionData = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
@@ -1794,7 +2045,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');
@@ -1812,16 +2067,6 @@ The DevOps agent is monitoring this worktree for changes.
       silent: false
     });
     
-    // Wait for agent to initialize and display its interactive commands
-    // Then show the copy-paste instructions
-    setTimeout(async () => {
-      console.log('\n'); // Add spacing
-      
-      // Generate and display instructions
-      const instructions = this.generateClaudeInstructions(sessionData);
-      this.displayInstructions(instructions, sessionId, sessionData.task);
-    }, 3000); // Wait 3 seconds for agent to show interactive commands
-    
     child.on('exit', (code) => {
       console.log(`${CONFIG.colors.yellow}Agent exited with code: ${code}${CONFIG.colors.reset}`);
       
@@ -1837,6 +2082,8 @@ The DevOps agent is monitoring this worktree for changes.
       child.kill('SIGINT');
       setTimeout(() => process.exit(0), 1000);
     });
+    
+    return true;
   }
 
   /**
@@ -2171,8 +2418,114 @@ The DevOps agent is monitoring this worktree for changes.
   }
   
   /**
-   * Clean up all stale sessions and worktrees
+   * Recover sessions from existing worktrees that are missing lock files
    */
+  async recoverSessions() {
+    console.log(`\n${CONFIG.colors.yellow}Scanning for recoverable sessions...${CONFIG.colors.reset}`);
+    
+    if (!fs.existsSync(this.worktreesPath)) {
+      console.log('No worktrees directory found.');
+      return 0;
+    }
+
+    const worktrees = fs.readdirSync(this.worktreesPath);
+    let recovered = 0;
+
+    for (const dir of worktrees) {
+      // Skip .DS_Store and other system files
+      if (dir.startsWith('.')) continue;
+
+      const worktreePath = path.join(this.worktreesPath, dir);
+      
+      // Ensure it's a directory
+      try {
+        if (!fs.statSync(worktreePath).isDirectory()) continue;
+      } catch (e) { continue; }
+
+      const configPath = path.join(worktreePath, '.devops-session.json');
+
+      if (fs.existsSync(configPath)) {
+        try {
+          const sessionData = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+          
+          if (!sessionData.sessionId) continue;
+
+          const lockFile = path.join(this.locksPath, `${sessionData.sessionId}.lock`);
+
+          if (!fs.existsSync(lockFile)) {
+            // Restore lock file
+            // Reset status to 'stopped' so it can be resumed/claimed
+            sessionData.status = 'stopped'; 
+            sessionData.agentPid = null;
+            sessionData.agentStopped = new Date().toISOString();
+            sessionData.recoveredAt = new Date().toISOString();
+            
+            fs.writeFileSync(lockFile, JSON.stringify(sessionData, null, 2));
+            console.log(`${CONFIG.colors.green}✓ Recovered session ${sessionData.sessionId} (${sessionData.task})${CONFIG.colors.reset}`);
+            recovered++;
+
+            // Check for uncommitted changes in the recovered session
+            try {
+              const status = execSync(`git -C "${worktreePath}" status --porcelain`, { encoding: 'utf8' });
+              if (status.trim()) {
+                console.log(`\n${CONFIG.colors.yellow}Uncommitted changes found in recovered session ${sessionData.sessionId}${CONFIG.colors.reset}`);
+                
+                const rl = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout
+                });
+                
+                const commitNow = await new Promise(resolve => {
+                  rl.question('Would you like to commit these changes now? (Y/n): ', answer => {
+                    rl.close();
+                    resolve(answer.toLowerCase() !== 'n' && answer.toLowerCase() !== 'no');
+                  });
+                });
+                
+                if (commitNow) {
+                  const timestamp = new Date().toISOString();
+                  execSync(`git -C "${worktreePath}" add -A`, { stdio: 'ignore' });
+                  execSync(`git -C "${worktreePath}" commit -m "chore: recovered session auto-commit at ${timestamp}"`, { stdio: 'ignore' });
+                  console.log(`${CONFIG.colors.green}✓ Changes committed.${CONFIG.colors.reset}`);
+                  
+                  // Ask to push
+                  const rlPush = readline.createInterface({ input: process.stdin, output: process.stdout });
+                  const pushNow = await new Promise(resolve => {
+                    rlPush.question('Push changes to remote? (Y/n): ', answer => {
+                      rlPush.close();
+                      resolve(answer.toLowerCase() !== 'n' && answer.toLowerCase() !== 'no');
+                    });
+                  });
+                  
+                  if (pushNow) {
+                    try {
+                      execSync(`git -C "${worktreePath}" push origin ${sessionData.branchName}`, { stdio: 'ignore' });
+                      console.log(`${CONFIG.colors.green}✓ Changes pushed to ${sessionData.branchName}.${CONFIG.colors.reset}`);
+                    } catch (e) {
+                      console.log(`${CONFIG.colors.red}✗ Push failed. You may need to pull first or check remote.${CONFIG.colors.reset}`);
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              // Ignore git errors during recovery scan
+            }
+          }
+        } catch (err) {
+          console.error(`Failed to recover ${dir}: ${err.message}`);
+        }
+      }
+    }
+
+    if (recovered === 0) {
+      console.log('No orphaned sessions found to recover.');
+    } else {
+      console.log(`\n${CONFIG.colors.green}Recovered ${recovered} sessions. You can now resume them.${CONFIG.colors.reset}`);
+    }
+    
+    return recovered;
+  }
+
   async cleanupAll() {
     console.log(`\n${CONFIG.colors.yellow}Cleaning up stale sessions and worktrees...${CONFIG.colors.reset}`);
     
@@ -2248,7 +2601,7 @@ async function main() {
   console.log("  CS_DevOpsAgent - Intelligent Git Automation System");
   console.log(`  Version ${packageJson.version} | Build ${new Date().toISOString().split('T')[0].replace(/-/g, '')}`);
   console.log("  ");
-  console.log("  Copyright (c) 2024 SecondBrain Labs");
+  console.log("  Copyright (c) 2026 SeKondBrain AI Labs Limited");
   console.log("  Author: Sachin Dev Duggal");
   console.log("  ");
   console.log("  Licensed under the MIT License");
@@ -2281,8 +2634,36 @@ async function main() {
       // Start agent for a session
       const sessionId = args[1];
       if (!sessionId) {
+        // Ask if user wants Kora assistance
+        const koraRl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        
+        console.log(`\n${CONFIG.colors.magenta}🤖 Kora AI Assistant Available${CONFIG.colors.reset}`);
+        const useKora = await new Promise(resolve => {
+          koraRl.question(`Would you like Kora to guide you? (Y/n): `, answer => {
+            koraRl.close();
+            resolve(answer.toLowerCase() !== 'n' && answer.toLowerCase() !== 'no');
+          });
+        });
+        
+        if (useKora) {
+          console.log(`\n${CONFIG.colors.magenta}Launching Kora...${CONFIG.colors.reset}`);
+          const chatScript = path.join(__dirname, 'agent-chat.js');
+          const child = spawn('node', [chatScript], { 
+            stdio: 'inherit',
+            env: process.env 
+          });
+          
+          child.on('exit', (code) => {
+            process.exit(code);
+          });
+          return; // Hand off to Kora
+        }
+
         // No session ID provided - show interactive menu
-        console.log(`${CONFIG.colors.bright}DevOps Agent Session Manager${CONFIG.colors.reset}\n`);
+        console.log(`\n${CONFIG.colors.bright}DevOps Agent Session Manager${CONFIG.colors.reset}\n`);
         
         // Show existing sessions first
         const locks = fs.existsSync(coordinator.locksPath) ? 
@@ -2376,7 +2757,10 @@ async function main() {
         args[args.indexOf('--agent') + 1] : 
         undefined; // Pass undefined to trigger prompt in createSession
       
-      await coordinator.createAndStart({ task, agent });
+      const skipSetup = args.includes('--skip-setup');
+      const skipUpdate = args.includes('--skip-update');
+      
+      await coordinator.createAndStart({ task, agent, skipSetup, skipUpdate });
       break;
     }
     
@@ -2386,6 +2770,39 @@ async function main() {
       await coordinator.requestSession(agent);
       break;
     }
+
+    case 'resume': {
+      // Resume an existing session by ID or Task
+      const sessionId = args.includes('--session-id') ? 
+        args[args.indexOf('--session-id') + 1] : 
+        undefined;
+      
+      const task = args.includes('--task') ? 
+        args[args.indexOf('--task') + 1] : 
+        undefined;
+
+      let targetSessionId = sessionId;
+
+      if (!targetSessionId && task) {
+        const session = coordinator.findSessionByTask(task);
+        if (session) {
+          targetSessionId = session.sessionId;
+        }
+      }
+
+      if (targetSessionId) {
+        // Check if session is already active/claimed?
+        // startAgent checks existence.
+        const success = await coordinator.startAgent(targetSessionId);
+        if (!success) process.exit(1);
+      } else {
+        console.error(`${CONFIG.colors.red}Error: Could not find session to resume.${CONFIG.colors.reset}`);
+        if (task) console.error(`No session found matching task: ${task}`);
+        else console.error(`Please provide --session-id or --task`);
+        process.exit(1);
+      }
+      break;
+    }
     
   case 'list': {
     coordinator.listSessions();
@@ -2404,11 +2821,23 @@ async function main() {
     break;
   }
   
-  case 'cleanup': {
-    // Clean up stale sessions and worktrees
-    await coordinator.cleanupAll();
-    break;
-  }
+    case 'cleanup': {
+      // Clean up stale sessions and worktrees
+      await coordinator.cleanupAll();
+      break;
+    }
+
+    case 'recover': {
+      // Recover orphaned sessions from worktrees
+      await coordinator.recoverSessions();
+      break;
+    }
+
+    case 'recover': {
+      // Recover orphaned sessions from worktrees
+      await coordinator.recoverSessions();
+      break;
+    }
   
   case 'help':
   default: {