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

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);
@@ -287,7 +291,16 @@ async function stagedCount() {
   return r.ok ? r.stdout.split("\n").filter(Boolean).length : 0;
 }
 async function unstageIfStaged(file) {
-  await run("git", ["restore", "--staged", file]);
+  try {
+    // Check if file is actually staged first to avoid errors
+    // Use diff --cached to check without erroring on untracked files
+    const { ok, stdout } = await run("git", ["diff", "--name-only", "--cached", file]);
+    if (ok && stdout.trim().length > 0) {
+        await run("git", ["restore", "--staged", file]);
+    }
+  } catch (e) {
+    // Ignore errors
+  }
 }
 async function defaultRemote() {
   const r = await run("git", ["remote"]);
@@ -824,17 +837,20 @@ const REQUIRE_AI_COMMIT = (process.env.AC_AI_COMMIT || "false").toLowerCase() ==
 
     if (PUSH) {
       const ok = await pushBranch(BRANCH);
-      log(`push ${ok ? "ok" : "failed"}`);
+      // Ensure this log goes to the right panel
+      log(`[push] pushing branch ${BRANCH} result: ${ok ? "ok" : "failed"}`);
+      
       if (ok) {
         if (CLEAR_MSG_WHEN === "push") clearMsgFile(msgPath);
         
-        console.log(`\x1b[32m✓ PUSHED:\x1b[0m ${BRANCH} -> remote`);
-        console.log(""); // Empty line for spacing
+        // This log was going to stdout directly, bypassing TUI buffers
+        // Redirect to TUI log
+        log(`✓ PUSHED: ${BRANCH} -> remote`);
         
         // Handle Docker restart if configured
         await handleDockerRestart();
       } else {
-        console.log(`\x1b[31m✗ PUSH FAILED:\x1b[0m Check logs for details`);
+        console.error(`✗ PUSH FAILED: Check logs for details`);
       }
     }
   } finally {
@@ -953,6 +969,119 @@ 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...');
+      // Use -u to include untracked files, ensuring we capture everything status --porcelain sees
+      const stashRes = await run('git', ['stash', 'push', '-u', '-m', `Auto-stash before rebase ${new Date().toISOString()}`]);
+      
+      // Only mark as stashed if we actually saved something
+      // git stash returns 0 even if nothing to save, so we must check stdout
+      if (stashRes.ok && stashRes.stdout && stashRes.stdout.includes('Saved working directory')) {
+        stashed = true;
+        log('Changes stashed successfully.');
+      } else if (stashRes.ok && stashRes.stdout && stashRes.stdout.includes('No local changes to save')) {
+        stashed = false;
+        log('No changes needed stashing (git reported no local changes).');
+      } else {
+        console.error('\\x1b[31m✗ Failed to stash changes. Aborting rebase.\\x1b[0m');
+        if (stashRes.stdout) console.error(stashRes.stdout);
+        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
@@ -1418,8 +1547,8 @@ function saveProjectSettings(settings, settingsPath) {
 // Display copyright and license information immediately
 console.log("\n" + "=".repeat(70));
 console.log("  CS_DevOpsAgent - Intelligent Git Automation System");
-console.log("  Version 1.4.8 | Build 20251008.1");
-console.log("  \n  Copyright (c) 2024 SecondBrain Labs");
+console.log("  Version 2.0.18-dev.12 | Build 20260107");
+console.log("  Copyright (c) 2026 SeKondBrain AI Labs Limited");
 console.log("  Author: Sachin Dev Duggal");
 console.log("  \n  Licensed under the MIT License");
 console.log("  This software is provided 'as-is' without any warranty.");
@@ -1500,6 +1629,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
   // ============================================================================
@@ -1625,25 +1767,30 @@ console.log();
     ],
   })
   .on("all", async (evt, p) => {
+    // Define 'now' at the very top of the callback to avoid ReferenceError
+    const now = Date.now();
+
     // Check if file is in local_deploy or .file-coordination (internal agent files)
     if (p.includes('local_deploy/') || p.includes('.file-coordination/')) {
       return;
     }
 
+    const isMsg = samePath(p, relMsg);
+    
     // Check if file is ignored by git (respect .gitignore)
-    try {
-      // git check-ignore returns 0 if ignored, 1 if not ignored
-      // We use quiet mode (-q) and ignore stdio
-      execSync(`git check-ignore -q "${p}"`, { stdio: 'ignore' });
-      // If we get here, exit code was 0, so file IS ignored
-      if (DEBUG) console.log(`[debug] Ignoring gitignored file: ${p}`);
-      return;
-    } catch (e) {
-      // Exit code 1 means NOT ignored (or other error). Proceed.
+    // IMPORTANT: Do NOT ignore the message file, even if it's in .gitignore
+    if (!isMsg) {
+      try {
+        // git check-ignore returns 0 if ignored, 1 if not ignored
+        // We use quiet mode (-q) and ignore stdio
+        execSync(`git check-ignore -q "${p}"`, { stdio: 'ignore' });
+        // If we get here, exit code was 0, so file IS ignored
+        if (DEBUG) console.log(`[debug] Ignoring gitignored file: ${p}`);
+        return;
+      } catch (e) {
+        // Exit code 1 means NOT ignored (or other error). Proceed.
+      }
     }
-
-    const now = Date.now();
-    const isMsg = samePath(p, relMsg);
     
     // Track timing of non-message changes
     if (!isMsg) {
@@ -1731,12 +1878,161 @@ console.log();
   const rl = readline.createInterface({
     input: input,
     output: output,
-    prompt: '\\x1b[36m[agent] >\\x1b[0m ',
+    prompt: '', // We'll manage the prompt manually
     terminal: true
   });
-  
+
+  // TUI STATE
+  const TUI = {
+    leftLogs: [],
+    rightLogs: [],
+    maxLogs: 200,
+    status: 'ACTIVE',
+    inputBuffer: '',
+    sessionId: sessionId,
+    branch: await currentBranch(),
+    inputMode: 'command' // 'command' or 'prompt'
+  };
+
+  // Helper to strip ANSI codes
+  const stripAnsi = (str) => str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+
+  // Override log output to split into two panels
+  // Right Panel: [cs-devops-agent], [debug], [cmd], [err] (Background Activity)
+  // Left Panel: Interactive output (status, help, etc)
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+
+  const addToBuffers = (msg, isError = false) => {
+    const cleanMsg = stripAnsi(msg);
+    const isBackground = cleanMsg.startsWith('[cs-devops-agent]') || 
+                         cleanMsg.startsWith('[debug]') || 
+                         cleanMsg.startsWith('[cmd]') || 
+                         cleanMsg.startsWith('[err]') ||
+                         cleanMsg.startsWith('ignore') || 
+                         cleanMsg.startsWith('watcher:');
+
+    const targetBuffer = isBackground ? TUI.rightLogs : TUI.leftLogs;
+    
+    // Add timestamp for background logs only
+    let line = msg;
+    if (isBackground) {
+        const time = new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute:'2-digit', second:'2-digit' });
+        line = `\x1b[2m[${time}]\x1b[0m ${msg}`;
+    }
+    
+    // Split newlines and push
+    const lines = line.split('\n');
+    lines.forEach(l => {
+        targetBuffer.push(l);
+        if (targetBuffer.length > TUI.maxLogs) targetBuffer.shift();
+    });
+    
+    renderTUI();
+  };
+
+  console.log = (...args) => {
+    const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+    // Filter TUI artifacts
+    if (msg.includes('\x1b[2J') || msg.includes('\x1b[0f')) return;
+    addToBuffers(msg, false);
+  };
+
+  console.error = (...args) => {
+    const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+    const colored = msg.startsWith('\x1b') ? msg : `\x1b[31m${msg}\x1b[0m`;
+    addToBuffers(colored, true);
+  };
+
+  // Vertical Split Renderer
+  function renderTUI() {
+    const width = process.stdout.columns || 80;
+    const height = process.stdout.rows || 24;
+    const contentHeight = height - 4; // Header, Divider, Prompt, Margin
+    
+    // Split: Left (Interactive) 40%, Right (Logs) 60%
+    // Ensure minimum widths
+    const leftPercent = 0.4;
+    const leftWidth = Math.floor(width * leftPercent) - 2; 
+    const rightWidth = width - leftWidth - 3; // -3 for separator " | "
+    
+    if (leftWidth < 10 || rightWidth < 10) {
+        // Fallback for very narrow screens? Just clear and print prompt? 
+        // Or simple stacked? Let's just proceed, it will look messy but functional.
+    }
+
+    // Prepare views (Bottom-Anchored)
+    const leftView = TUI.leftLogs.slice(-contentHeight);
+    const rightView = TUI.rightLogs.slice(-contentHeight);
+    
+    const leftEmpty = contentHeight - leftView.length;
+    const rightEmpty = contentHeight - rightView.length;
+
+    // Draw Frame
+    process.stdout.write('\x1b[2J');   // Clear
+    process.stdout.write('\x1b[H');    // Home (standard ANSI)
+    
+    // 1. Header
+    const headerText = ` DEVOPS AGENT | Session: ${TUI.sessionId || 'N/A'} | Branch: ${TUI.branch} `;
+    const headPad = Math.max(0, width - headerText.length);
+    process.stdout.write(`\x1b[44m\x1b[37m${headerText}${' '.repeat(headPad)}\x1b[0m\n`);
+    
+    // 2. Columns
+    for (let i = 0; i < contentHeight; i++) {
+        let lLine = (i >= leftEmpty) ? leftView[i - leftEmpty] : '';
+        let rLine = (i >= rightEmpty) ? rightView[i - rightEmpty] : '';
+        
+        // Removing ANSI for length calculation is essential for alignment
+        const lPlain = stripAnsi(lLine);
+        const rPlain = stripAnsi(rLine);
+        
+        // Truncate to prevent wrapping and breaking layout
+        let lDisp = lLine;
+        let rDisp = rLine;
+        
+        if (lPlain.length > leftWidth) {
+            // Simple truncation (note: might cut ansi codes, but prevents layout break)
+            // We use the plain length to determine cut point
+            // For safety, we just display the plain truncated text to avoid hanging colors
+            lDisp = lPlain.substring(0, leftWidth - 3) + '...';
+        }
+        
+        if (rPlain.length > rightWidth) {
+            rDisp = rPlain.substring(0, rightWidth - 3) + '...';
+        }
+        
+        // Pad using the length of the *displayed* string (re-strip to be sure)
+        const lDispLen = stripAnsi(lDisp).length;
+        const rDispLen = stripAnsi(rDisp).length;
+        
+        const lPad = Math.max(0, leftWidth - lDispLen);
+        const rPad = Math.max(0, rightWidth - rDispLen);
+        
+        process.stdout.write(lDisp + ' '.repeat(lPad));
+        process.stdout.write('\x1b[90m │ \x1b[0m');
+        process.stdout.write(rDisp + ' '.repeat(rPad));
+        process.stdout.write('\n');
+    }
+    
+    // 3. Divider
+    const lDiv = '─'.repeat(leftWidth);
+    const rDiv = '─'.repeat(rightWidth);
+    process.stdout.write(`\x1b[90m${lDiv}─┴─${rDiv}\x1b[0m\n`);
+    
+    // 4. Prompt
+    process.stdout.write(`\x1b[36m[agent] >\x1b[0m ${TUI.inputBuffer}`);
+  }
+
+  // Initial render
+  renderTUI();
+
   // Command handler
   rl.on('line', async (line) => {
+    // If in prompt mode, ignore this handler (let the prompt handler take it)
+    if (TUI.inputMode !== 'command') return;
+
+    TUI.inputBuffer = ''; 
+    addToBuffers(`> ${line}`); // Echo command to left panel
     const cmd = line.trim().toLowerCase();
     
     switch (cmd) {
@@ -1802,10 +2098,22 @@ console.log();
           let commitMsg = readMsgFile(msgPath);
           if (!commitMsg) {
             console.log("No commit message found. Enter message (or 'cancel' to abort):");
-            rl.prompt();
+            
+            // Switch to prompt mode to prevent main loop interference
+            TUI.inputMode = 'prompt';
+            
+            // Use a temporary prompt interface
             const msgInput = await new Promise(resolve => {
-              rl.once('line', resolve);
+              // We need to use a one-time listener that doesn't conflict
+              const handler = (input) => {
+                resolve(input);
+              };
+              rl.once('line', handler);
             });
+            
+            // Switch back to command mode
+            TUI.inputMode = 'command';
+            
             if (msgInput.trim().toLowerCase() === 'cancel') {
               console.log("Commit cancelled.");
               break;
@@ -1818,7 +2126,7 @@ console.log();
           console.log("No changes to commit.");
         }
         break;
-        
+
       case 'push':
       case 'p':
         const branchName = await currentBranch();
@@ -1840,11 +2148,18 @@ console.log();
         const uncommitted = await hasUncommittedChanges();
         if (uncommitted) {
           console.log("You have uncommitted changes. Commit them before exit? (y/n)");
-          rl.prompt();
+          
+          TUI.inputMode = 'prompt';
+          
           const answer = await new Promise(resolve => {
-            rl.once('line', resolve);
+            const handler = (input) => {
+              resolve(input);
+            };
+            rl.once('line', handler);
           });
           
+          TUI.inputMode = 'command';
+          
           if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
             console.log("Committing changes...");
             const exitMsg = "chore: session cleanup - final commit before exit";
@@ -1941,74 +2256,128 @@ console.log();
             let mergeCompleted = false;
             if (shouldMerge) {
               try {
-                console.log(`\n\x1b[34mMerging ${currentBranchName} into ${targetBranch}...\x1b[0m`);
-                
-                // Check if target branch exists locally
-                let branchExists = false;
+                // Check if repoRoot is clean before attempting merge operations
+                // We use --porcelain to check for modifications
+                let isDirty = false;
                 try {
-                  execSync(`git rev-parse --verify ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                  branchExists = true;
-                } catch (err) {
-                  // Branch doesn't exist locally
-                }
-                
-                if (!branchExists) {
-                  // Check if branch exists on remote
-                  try {
-                    const remoteCheck = execSync(`git ls-remote --heads origin ${targetBranch}`, { 
-                      cwd: repoRoot, 
-                      encoding: 'utf8' 
-                    }).trim();
+                  const status = execSync(`git status --porcelain`, { cwd: repoRoot, encoding: 'utf8' });
+                  if (status && status.trim().length > 0) {
+                    isDirty = true;
+                    console.log(`\n\x1b[33m⚠️  The main repository has uncommitted changes:\x1b[0m`);
+                    const lines = status.trim().split('\n').slice(0, 5);
+                    lines.forEach(l => console.log(`   ${l}`));
+                    if (status.trim().split('\n').length > 5) console.log('   ...');
+                    
+                    console.log(`\nMerge cannot proceed with a dirty working tree.`);
+                    console.log(`You can stash these changes to proceed with the merge, or skip the merge.`);
+                    console.log(`  y/yes - Stash changes and merge`);
+                    console.log(`  n/no  - Skip merge`);
                     
-                    if (remoteCheck) {
-                      // Branch exists on remote, fetch it
-                      console.log(`\x1b[2mTarget branch doesn't exist locally, fetching from remote...\x1b[0m`);
-                      execSync(`git fetch origin ${targetBranch}:${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                    rl.prompt();
+                    const stashAnswer = await new Promise(resolve => {
+                      rl.once('line', resolve);
+                    });
+                    
+                    if (stashAnswer.toLowerCase() === 'y' || stashAnswer.toLowerCase() === 'yes') {
+                      console.log(`\nStashing changes in main repo...`);
+                      execSync(`git stash push -m "Auto-stash before session merge ${sessionId}"`, { cwd: repoRoot, stdio: 'pipe' });
+                      isDirty = false;
                     } else {
-                      // Branch doesn't exist on remote either, create it
-                      console.log(`\x1b[33mTarget branch '${targetBranch}' doesn't exist. Creating it...\x1b[0m`);
-                      execSync(`git checkout -b ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                      execSync(`git push -u origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                      console.log(`\x1b[32m✓\x1b[0m Created new branch ${targetBranch}`);
+                      console.log(`\nSkipping merge due to dirty working tree.`);
+                      shouldMerge = false;
                     }
-                  } catch (err) {
-                    console.error(`\x1b[31m✗ Error checking/creating remote branch: ${err.message}\x1b[0m`);
-                    throw err;
-                  }
-                }
-                
-                // Switch to target branch
-                execSync(`git checkout ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                
-                // Pull latest (if branch already existed)
-                if (branchExists) {
-                  try {
-                    execSync(`git pull origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                  } catch (err) {
-                    console.log(`\x1b[2mCould not pull latest changes (may be new branch)\x1b[0m`);
                   }
-                }
-                
-                // Merge the session branch
-                execSync(`git merge --no-ff ${currentBranchName} -m "Merge session ${sessionId}: session work"`, { 
-                  cwd: repoRoot, 
-                  stdio: 'pipe' 
-                });
-                
-                // Push merged changes
-                execSync(`git push origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
-                
-                console.log(`\x1b[32m✓\x1b[0m Successfully merged to ${targetBranch}`);
-                
-                // Delete remote branch after successful merge
-                try {
-                  execSync(`git push origin --delete ${currentBranchName}`, { cwd: repoRoot, stdio: 'pipe' });
-                  console.log(`\x1b[32m✓\x1b[0m Deleted remote branch ${currentBranchName}`);
                 } catch (err) {
-                  console.log(`\x1b[2mCould not delete remote branch\x1b[0m`);
+                   console.log(`\x1b[31mError checking git status: ${err.message}\x1b[0m`);
+                   shouldMerge = false; // Err on side of caution
+                }
+
+                if (shouldMerge && !isDirty) {
+                    console.log(`\n\x1b[34mMerging ${currentBranchName} into ${targetBranch}...\x1b[0m`);
+                    
+                    // Check if target branch exists locally
+                    let branchExists = false;
+                    try {
+                      execSync(`git rev-parse --verify ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                      branchExists = true;
+                    } catch (err) {
+                      // Branch doesn't exist locally
+                    }
+                    
+                    if (!branchExists) {
+                      // Check if branch exists on remote
+                      try {
+                        const remoteCheck = execSync(`git ls-remote --heads origin ${targetBranch}`, { 
+                          cwd: repoRoot, 
+                          encoding: 'utf8' 
+                        }).trim();
+                        
+                        if (remoteCheck) {
+                          // Branch exists on remote, fetch it
+                          console.log(`\x1b[2mTarget branch doesn't exist locally, fetching from remote...\x1b[0m`);
+                          execSync(`git fetch origin ${targetBranch}:${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                        } else {
+                          // Branch doesn't exist on remote either, create it
+                          console.log(`\x1b[33mTarget branch '${targetBranch}' doesn't exist. Creating it...\x1b[0m`);
+                          execSync(`git checkout -b ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                          execSync(`git push -u origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                          console.log(`\x1b[32m✓\x1b[0m Created new branch ${targetBranch}`);
+                        }
+                      } catch (err) {
+                        console.error(`\x1b[31m✗ Error checking/creating remote branch: ${err.message}\x1b[0m`);
+                        throw err;
+                      }
+                    }
+                    
+                    // Switch to target branch
+                    execSync(`git checkout ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                    
+                    // Pull latest (if branch already existed)
+                    if (branchExists) {
+                      try {
+                        execSync(`git pull origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                      } catch (err) {
+                        console.log(`\x1b[2mCould not pull latest changes (may be new branch)\x1b[0m`);
+                      }
+                    }
+
+                    // Rebase session branch onto target branch
+                    try {
+                      console.log(`\x1b[34mRebasing ${currentBranchName} onto ${targetBranch}...\x1b[0m`);
+                      execSync(`git checkout ${currentBranchName}`, { cwd: repoRoot, stdio: 'pipe' });
+                      execSync(`git rebase ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                      console.log(`\x1b[32m✓\x1b[0m Rebase successful`);
+                      
+                      // Switch back to target for merge
+                      execSync(`git checkout ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                    } catch (err) {
+                      console.error(`\x1b[31m✗ Rebase failed: ${err.message}\x1b[0m`);
+                      console.log(`\x1b[33mAborting rebase and trying direct merge...\x1b[0m`);
+                      try { execSync(`git rebase --abort`, { cwd: repoRoot, stdio: 'pipe' }); } catch (e) {}
+                      execSync(`git checkout ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                    }
+                    
+                    // Merge the session branch
+                    execSync(`git merge --no-ff ${currentBranchName} -m "Merge session ${sessionId}: session work"`, { 
+                      cwd: repoRoot, 
+                      stdio: 'pipe' 
+                    });
+                    
+                    // Push merged changes
+                    execSync(`git push origin ${targetBranch}`, { cwd: repoRoot, stdio: 'pipe' });
+                    
+                    console.log(`\x1b[32m✓\x1b[0m Successfully merged to ${targetBranch}`);
+                    
+                    // Delete remote branch after successful merge
+                    try {
+                      execSync(`git push origin --delete ${currentBranchName}`, { cwd: repoRoot, stdio: 'pipe' });
+                      console.log(`\x1b[32m✓\x1b[0m Deleted remote branch ${currentBranchName}`);
+                    } catch (err) {
+                      console.log(`\x1b[2mCould not delete remote branch\x1b[0m`);
+                    }
+                    
+                    mergeCompleted = true;
                 }
-                
-                mergeCompleted = true;
               } catch (err) {
                 console.error(`\x1b[31m✗ Merge failed: ${err.message}\x1b[0m`);
                 console.log(`\x1b[33mYou may need to resolve conflicts manually\x1b[0m`);