@litmers/cursorflow-orchestrator 0.1.37 → 0.1.40

package/src/core/runner/pipeline.ts

@@ -40,18 +40,13 @@ function validateTaskConfig(config: RunnerConfig): void {
 /**
  * Run all tasks in sequence
  */
-export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number; noGit?: boolean; skipPreflight?: boolean } = {}): Promise<TaskExecutionResult[]> {
+export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number; skipPreflight?: boolean } = {}): Promise<TaskExecutionResult[]> {
   const startIndex = options.startIndex || 0;
-  const noGit = options.noGit || config.noGit || false;
   
   // Ensure paths are absolute before potentially changing directory
   runDir = path.resolve(runDir);
   tasksFile = path.resolve(tasksFile);
   
-  if (noGit) {
-    logger.info('🚫 Running in noGit mode - Git operations will be skipped');
-  }
-  
   // Validate configuration before starting
   logger.info('Validating task configuration...');
   try {
@@ -67,7 +62,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   if (!options.skipPreflight && startIndex === 0) {
     logger.info('Running preflight checks...');
     const preflight = await preflightCheck({
-      requireRemote: !noGit,
+      requireRemote: true,
       requireAuth: true,
     });
     
@@ -120,12 +115,11 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   logger.success('✓ Cursor authentication OK');
   
-  // In noGit mode, we don't need repoRoot - use current directory
-  const repoRoot = noGit ? process.cwd() : git.getMainRepoRoot();
+  const repoRoot = git.getMainRepoRoot();
   
   // ALWAYS use current branch as base - ignore config.baseBranch
   // This ensures dependency structure is maintained in the worktree
-  const currentBranch = noGit ? 'main' : git.getCurrentBranch(repoRoot);
+  const currentBranch = git.getCurrentBranch(repoRoot);
   logger.info(`📍 Base branch: ${currentBranch} (current branch)`);
   
   // Load existing state if resuming
@@ -149,8 +143,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       // Validate loaded state
       if (state) {
         const validation = validateLaneState(statePath, {
-          checkWorktree: !noGit,
-          checkBranch: !noGit,
+          checkWorktree: true,
+          checkBranch: true,
           autoRepair: true,
         });
         
@@ -168,11 +162,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   const randomSuffix = Math.random().toString(36).substring(2, 7);
   const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}-${randomSuffix}`;
   
-  // In noGit mode, use a simple local directory instead of worktree
   // Flatten the path by replacing slashes with hyphens to avoid race conditions in parent directory creation
-  const worktreeDir = state?.worktreeDir || config.worktreeDir || (noGit 
-    ? safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/workdir', pipelineBranch.replace(/\//g, '-'))
-    : safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch.replace(/\//g, '-')));
+  const worktreeDir = state?.worktreeDir || config.worktreeDir || safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch.replace(/\//g, '-'));
   
   if (startIndex === 0) {
     logger.section('🚀 Starting Pipeline');
@@ -184,54 +175,65 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   logger.info(`Worktree: ${worktreeDir}`);
   logger.info(`Tasks: ${config.tasks.length}`);
   
-  // Create worktree only if starting fresh and worktree doesn't exist
-  if (!fs.existsSync(worktreeDir)) {
-    if (noGit) {
-      // In noGit mode, just create the directory
-      logger.info(`Creating work directory: ${worktreeDir}`);
-      fs.mkdirSync(worktreeDir, { recursive: true });
-    } else {
-      // Use a simple retry mechanism for Git worktree creation to handle potential race conditions
-      let retries = 3;
-      let lastError: Error | null = null;
-      
-      while (retries > 0) {
-        try {
-          // Ensure parent directory exists before calling git worktree
-          const worktreeParent = path.dirname(worktreeDir);
-          if (!fs.existsSync(worktreeParent)) {
-            fs.mkdirSync(worktreeParent, { recursive: true });
-          }
+  // Check if worktree needs to be created or repaired
+  const worktreeNeedsCreation = !fs.existsSync(worktreeDir);
+  const worktreeIsInvalid = !worktreeNeedsCreation && !git.isValidWorktree(worktreeDir);
+  
+  if (worktreeIsInvalid) {
+    // Directory exists but is NOT a valid worktree - this can cause branch leakage!
+    // Clean it up and recreate
+    logger.warn(`⚠️ Directory exists but is not a valid worktree: ${worktreeDir}`);
+    logger.info(`   Cleaning up invalid directory and recreating worktree...`);
+    try {
+      git.cleanupInvalidWorktreeDir(worktreeDir);
+    } catch (e: any) {
+      logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`);
+      throw new Error(`Cannot proceed: worktree directory is invalid and cleanup failed`);
+    }
+  }
+  
+  // Create worktree if it doesn't exist or was just cleaned up
+  if (worktreeNeedsCreation || worktreeIsInvalid) {
+    // Use a simple retry mechanism for Git worktree creation to handle potential race conditions
+    let retries = 3;
+    let lastError: Error | null = null;
+    
+    while (retries > 0) {
+      try {
+        // Ensure parent directory exists before calling git worktree
+        const worktreeParent = path.dirname(worktreeDir);
+        if (!fs.existsSync(worktreeParent)) {
+          fs.mkdirSync(worktreeParent, { recursive: true });
+        }
 
-          // Always use the current branch (already captured at start) as the base branch
-          git.createWorktree(worktreeDir, pipelineBranch, { 
-            baseBranch: currentBranch,
-            cwd: repoRoot,
-          });
-          break; // Success
-        } catch (e: any) {
-          lastError = e;
-          retries--;
-          if (retries > 0) {
-            const delay = Math.floor(Math.random() * 1000) + 500;
-            logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`);
-            await new Promise(resolve => setTimeout(resolve, delay));
-          }
+        // Always use the current branch (already captured at start) as the base branch
+        await git.createWorktreeAsync(worktreeDir, pipelineBranch, { 
+          baseBranch: currentBranch,
+          cwd: repoRoot,
+        });
+        break; // Success
+      } catch (e: any) {
+        lastError = e;
+        retries--;
+        if (retries > 0) {
+          const delay = Math.floor(Math.random() * 1000) + 500;
+          logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`);
+          await new Promise(resolve => setTimeout(resolve, delay));
         }
       }
-      
-      if (retries === 0 && lastError) {
-        throw new Error(`Failed to create Git worktree after retries: ${lastError.message}`);
-      }
     }
-  } else if (!noGit) {
-    // If it exists but we are in Git mode, ensure it's actually a worktree and on the right branch
+    
+    if (retries === 0 && lastError) {
+      throw new Error(`Failed to create Git worktree after retries: ${lastError.message}`);
+    }
+  } else {
+    // Worktree exists and is valid - reuse it
     logger.info(`Reusing existing worktree: ${worktreeDir}`);
     try {
       git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
     } catch (e) {
-      // If checkout fails, maybe the worktree is in a weird state. 
-      // For now, just log it. In a more robust impl, we might want to repair it.
+      // If checkout fails in a valid worktree, log warning but continue
+      // The worktree might be on a different branch that will be handled later
       logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
     }
   }
@@ -310,7 +312,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     const taskBranch = `${pipelineBranch}--${String(i + 1).padStart(2, '0')}-${task.name}`;
 
     // Delete previous task branch if it exists (Task 1 deleted when Task 2 starts, etc.)
-    if (!noGit && previousTaskBranch) {
+    if (previousTaskBranch) {
       logger.info(`🧹 Deleting previous task branch: ${previousTaskBranch}`);
       try {
         // Only delete if it's not the current branch
@@ -325,7 +327,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
 
     // Create checkpoint before each task
     try {
-      await createCheckpoint(laneName, runDir, noGit ? null : worktreeDir, {
+      await createCheckpoint(laneName, runDir, worktreeDir, {
         description: `Before task ${i + 1}: ${task.name}`,
         maxCheckpoints: 5,
       });
@@ -346,9 +348,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
           onTimeout: 'fail',
         });
         
-        if (!noGit) {
-          await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir, pipelineBranch);
-        }
+        await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir, pipelineBranch);
         
         state.status = 'running';
         state.waitingFor = [];
@@ -380,7 +380,6 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       taskBranch,
       chatId,
       runDir,
-      noGit,
     });
     
     results.push(result);
@@ -418,105 +417,98 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       process.exit(1);
     }
     
-    // Merge into pipeline (skip in noGit mode)
-    if (!noGit) {
-      logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
-      
-      // Ensure we are on the pipeline branch before merging the task branch
-      logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`);
-      git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
-      
-      // Pre-check for conflicts (should be rare since task branch was created from pipeline)
-      const conflictCheck = git.checkMergeConflict(taskBranch, { cwd: worktreeDir });
-      if (conflictCheck.willConflict) {
-        logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`);
-        logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
-        logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`);
-        
-        events.emit('merge.conflict_detected', {
-          taskName: task.name,
-          taskBranch,
-          pipelineBranch,
-          conflictingFiles: conflictCheck.conflictingFiles,
-          preCheck: true,
-        });
-      }
+    // Merge into pipeline
+    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
+    
+    // Ensure we are on the pipeline branch before merging the task branch
+    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`);
+    git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
+    
+    // Pre-check for conflicts (should be rare since task branch was created from pipeline)
+    const conflictCheck = git.checkMergeConflict(taskBranch, { cwd: worktreeDir });
+    if (conflictCheck.willConflict) {
+      logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`);
+      logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
+      logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`);
       
-      // Use safeMerge instead of plain merge for better error handling
-      logger.info(`🔀 Merging task ${task.name} (${taskBranch}) into ${pipelineBranch}`);
-      const mergeResult = git.safeMerge(taskBranch, { 
-        cwd: worktreeDir, 
-        noFf: true,
-        message: `chore: merge task ${task.name} into pipeline`,
-        abortOnConflict: true,
+      events.emit('merge.conflict_detected', {
+        taskName: task.name,
+        taskBranch,
+        pipelineBranch,
+        conflictingFiles: conflictCheck.conflictingFiles,
+        preCheck: true,
       });
-      
-      if (!mergeResult.success) {
-        if (mergeResult.conflict) {
-          logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
-          state.status = 'failed';
-          state.error = `Merge conflict when integrating task ${task.name}: ${mergeResult.conflictingFiles.join(', ')}`;
-          saveState(statePath, state);
-          process.exit(1);
-        }
-        throw new Error(mergeResult.error || 'Merge failed');
-      }
-      
-      // Log changed files
-      const stats = git.getLastOperationStats(worktreeDir);
-      if (stats) {
-        logger.info('Changed files:\n' + stats);
+    }
+    
+    // Use safeMerge instead of plain merge for better error handling
+    logger.info(`🔀 Merging task ${task.name} (${taskBranch}) into ${pipelineBranch}`);
+    const mergeResult = git.safeMerge(taskBranch, { 
+      cwd: worktreeDir, 
+      noFf: true,
+      message: `chore: merge task ${task.name} into pipeline`,
+      abortOnConflict: true,
+    });
+    
+    if (!mergeResult.success) {
+      if (mergeResult.conflict) {
+        logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
+        state.status = 'failed';
+        state.error = `Merge conflict when integrating task ${task.name}: ${mergeResult.conflictingFiles.join(', ')}`;
+        saveState(statePath, state);
+        process.exit(1);
       }
-
-      git.push(pipelineBranch, { cwd: worktreeDir });
-    } else {
-      logger.info(`✓ Task ${task.name} completed (noGit mode - no branch operations)`);
+      throw new Error(mergeResult.error || 'Merge failed');
     }
     
+    // Log changed files
+    const stats = git.getLastOperationStats(worktreeDir);
+    if (stats) {
+      logger.info('Changed files:\n' + stats);
+    }
+
+    git.push(pipelineBranch, { cwd: worktreeDir });
+    
     // Set previousTaskBranch for cleanup in the next iteration
-    previousTaskBranch = noGit ? null : taskBranch;
+    previousTaskBranch = taskBranch;
   }
   
   // Final Consolidation: Create flow branch and cleanup
-  if (!noGit) {
-    const flowBranch = laneName;
-    logger.section(`🏁 Final Consolidation: ${flowBranch}`);
-    
-    // 1. Delete the very last task branch
-    if (previousTaskBranch) {
-      logger.info(`🧹 Deleting last task branch: ${previousTaskBranch}`);
-      try {
-        git.deleteBranch(previousTaskBranch, { cwd: worktreeDir, force: true });
-      } catch (e) {
-        logger.warn(`   Failed to delete last task branch: ${e}`);
-      }
+  const flowBranch = laneName;
+  logger.section(`🏁 Final Consolidation: ${flowBranch}`);
+  
+  // 1. Delete the very last task branch
+  if (previousTaskBranch) {
+    logger.info(`🧹 Deleting last task branch: ${previousTaskBranch}`);
+    try {
+      git.deleteBranch(previousTaskBranch, { cwd: worktreeDir, force: true });
+    } catch (e) {
+      logger.warn(`   Failed to delete last task branch: ${e}`);
     }
+  }
 
-    // 2. Create flow branch from pipelineBranch and cleanup
-    if (flowBranch !== pipelineBranch) {
-      logger.info(`🌿 Creating final flow branch: ${flowBranch}`);
-      try {
-        // Create/Overwrite flow branch from pipeline branch
-        git.runGit(['checkout', '-B', flowBranch, pipelineBranch], { cwd: worktreeDir });
-        git.push(flowBranch, { cwd: worktreeDir, setUpstream: true });
-        
-        // 3. Delete temporary pipeline branch
-        logger.info(`🗑️ Deleting temporary pipeline branch: ${pipelineBranch}`);
-        // Must be on another branch to delete pipelineBranch
-        git.runGit(['checkout', flowBranch], { cwd: worktreeDir });
-        git.deleteBranch(pipelineBranch, { cwd: worktreeDir, force: true });
-        
-        try {
-          git.deleteBranch(pipelineBranch, { cwd: worktreeDir, force: true, remote: true });
-          logger.info(`   Deleted remote branch: origin/${pipelineBranch}`);
-        } catch {
-          // May not exist on remote or delete failed
-        }
-        
-        logger.success(`✓ Flow branch '${flowBranch}' is now the only remaining branch.`);
-      } catch (e) {
-        logger.error(`❌ Failed during final consolidation: ${e}`);
-      }
+  // 2. Create flow branch from pipelineBranch and cleanup
+  if (flowBranch !== pipelineBranch) {
+    logger.info(`🌿 Creating final flow branch: ${flowBranch}`);
+    try {
+      // Create/Overwrite flow branch from pipeline branch
+      git.runGit(['checkout', '-B', flowBranch, pipelineBranch], { cwd: worktreeDir });
+      git.push(flowBranch, { cwd: worktreeDir, setUpstream: true });
+      
+      // 3. Delete temporary pipeline branch (LOCAL ONLY)
+      // Keep remote branch for dependency lanes that may need to merge it!
+      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`);
+      // Must be on another branch to delete pipelineBranch
+      git.runGit(['checkout', flowBranch], { cwd: worktreeDir });
+      git.deleteBranch(pipelineBranch, { cwd: worktreeDir, force: true });
+      
+      // NOTE: We intentionally keep the remote pipeline branch alive
+      // because other lanes with dependsOn may need to merge it.
+      // The pipeline branch on remote serves as the "official" completion branch
+      // that dependency-tracking code in task.ts uses (via state.pipelineBranch).
+      
+      logger.success(`✓ Flow branch '${flowBranch}' created. Remote pipeline branch preserved for dependencies.`);
+    } catch (e) {
+      logger.error(`❌ Failed during final consolidation: ${e}`);
     }
   }
 
@@ -526,39 +518,14 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   saveState(statePath, state);
   
   // Log final file summary
-  if (noGit) {
-    const getFileSummary = (dir: string): { files: number; dirs: number } => {
-      let stats = { files: 0, dirs: 0 };
-      if (!fs.existsSync(dir)) return stats;
-      
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name === '.git' || entry.name === '_cursorflow' || entry.name === 'node_modules') continue;
-        
-        if (entry.isDirectory()) {
-          stats.dirs++;
-          const sub = getFileSummary(safeJoin(dir, entry.name));
-          stats.files += sub.files;
-          stats.dirs += sub.dirs;
-        } else {
-          stats.files++;
-        }
-      }
-      return stats;
-    };
-    
-    const summary = getFileSummary(worktreeDir);
-    logger.info(`Final Workspace Summary (noGit): ${summary.files} files, ${summary.dirs} directories created/modified`);
-  } else {
-    try {
-      // Always use current branch for comparison (already captured at start)
-      const stats = git.runGit(['diff', '--stat', currentBranch, pipelineBranch], { cwd: repoRoot, silent: true });
-      if (stats) {
-        logger.info('Final Workspace Summary (Git):\n' + stats);
-      }
-    } catch (e) {
-      // Ignore
+  try {
+    // Always use current branch for comparison (already captured at start)
+    const finalStats = git.runGit(['diff', '--stat', currentBranch, pipelineBranch], { cwd: repoRoot, silent: true });
+    if (finalStats) {
+      logger.info('Final Workspace Summary:\n' + finalStats);
     }
+  } catch (e) {
+    // Ignore
   }
   
   logger.success('All tasks completed!');

package/src/core/runner/prompt.ts

@@ -32,7 +32,6 @@ export function wrapPrompt(
   prompt: string, 
   config: RunnerConfig, 
   options: { 
-    noGit?: boolean; 
     isWorktree?: boolean;
     dependencyResults?: DependencyResult[];
     worktreePath?: string;
@@ -40,18 +39,18 @@ export function wrapPrompt(
     pipelineBranch?: string;
   } = {}
 ): string {
-  const { noGit = false, isWorktree = true, dependencyResults = [], worktreePath, taskBranch, pipelineBranch } = options;
+  const { isWorktree = true, dependencyResults = [], worktreePath, taskBranch, pipelineBranch } = options;
   
   // 1. PREFIX: Environment & Worktree context
   let wrapped = `### 🛠 Environment & Context\n`;
   wrapped += `- **Workspace**: 당신은 독립된 **Git 워크트리** (프로젝트 루트)에서 작업 중입니다.\n`;
   wrapped += `- **CWD**: 현재 터미널과 작업 경로는 이미 워크트리 루트(\`${worktreePath || 'current'}\`)로 설정되어 있습니다.\n`;
   
-  if (taskBranch && !noGit) {
+  if (taskBranch) {
     wrapped += `- **Current Branch**: \`${taskBranch}\` (현재 작업 중인 브랜치)\n`;
     wrapped += `- **Branch Check**: 만약 브랜치가 다르다면 \`git checkout ${taskBranch}\`를 실행하세요.\n`;
   }
-  if (pipelineBranch && !noGit) {
+  if (pipelineBranch) {
     wrapped += `- **Base Branch**: \`${pipelineBranch}\` (이 작업의 기준이 되는 상위 브랜치)\n`;
   }
 
@@ -97,10 +96,6 @@ export function wrapPrompt(
   wrapped += `\n### 📦 Dependency Policy\n`;
   wrapped += `- allowDependencyChange: ${policy.allowDependencyChange}\n`;
   wrapped += `- lockfileReadOnly: ${policy.lockfileReadOnly}\n`;
-  
-  if (noGit) {
-    wrapped += `- NO_GIT_MODE: Git 명령어를 사용하지 마세요. 파일 수정만 가능합니다.\n`;
-  }
 
   wrapped += `\n**📦 Dependency Change Rules:**\n`;
   wrapped += `1. 코드를 수정하기 전, 의존성 변경이 필요한지 **먼저** 판단하세요.\n`;
@@ -124,16 +119,14 @@ export function wrapPrompt(
   wrapped += `\n### 📝 Task Completion Requirements\n`;
   wrapped += `**반드시 다음 순서로 작업을 마무리하세요 (매우 중요):**\n\n`;
   
-  if (!noGit) {
-    wrapped += `1. **변경 사항 확인**: \`git status\`와 \`git diff\`로 수정된 내용을 최종 확인하세요.\n`;
-    wrapped += `2. **Git Commit & Push** (필수!):\n`;
-    wrapped += `   \`\`\`bash\n`;
-    wrapped += `   git add -A\n`;
-    wrapped += `   git commit -m "feat: <작업 내용 요약>"\n`;
-    wrapped += `   git push origin HEAD\n`;
-    wrapped += `   \`\`\`\n`;
-    wrapped += `   ⚠️ **주의**: 커밋과 푸시를 생략하면 오케스트레이터가 변경 사항을 인식하지 못하며 작업이 손실됩니다.\n\n`;
-  }
+  wrapped += `1. **변경 사항 확인**: \`git status\`와 \`git diff\`로 수정된 내용을 최종 확인하세요.\n`;
+  wrapped += `2. **Git Commit & Push** (필수!):\n`;
+  wrapped += `   \`\`\`bash\n`;
+  wrapped += `   git add -A\n`;
+  wrapped += `   git commit -m "feat: <작업 내용 요약>"\n`;
+  wrapped += `   git push origin HEAD\n`;
+  wrapped += `   \`\`\`\n`;
+  wrapped += `   ⚠️ **주의**: 커밋과 푸시를 생략하면 오케스트레이터가 변경 사항을 인식하지 못하며 작업이 손실됩니다.\n\n`;
   
   wrapped += `3. **최종 요약**: 작업 완료 후 아래 형식을 포함하여 요약해 주세요:\n`;
   wrapped += `   - **수정된 파일**: [파일명1, 파일명2, ...]\n`;

package/src/core/runner/task.ts

@@ -79,11 +79,15 @@ export async function mergeDependencyBranches(deps: string[], runDir: string, wo
       
       logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
       
-      // Ensure we have the latest
+      // Ensure we have the latest from remote
       git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
       
+      // Use the remote ref for merging (origin/<branch>) since dependency branches
+      // are pushed to remote by other lanes and may not exist as local branches
+      const remoteBranchRef = `origin/${state.pipelineBranch}`;
+      
       // Pre-check for conflicts before attempting merge
-      const conflictCheck = git.checkMergeConflict(state.pipelineBranch, { cwd: worktreeDir });
+      const conflictCheck = git.checkMergeConflict(remoteBranchRef, { cwd: worktreeDir });
       
       if (conflictCheck.willConflict) {
         logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`);
@@ -100,8 +104,8 @@ export async function mergeDependencyBranches(deps: string[], runDir: string, wo
         throw new Error(`Pre-merge conflict check failed: ${conflictCheck.conflictingFiles.join(', ')}. Consider rebasing or resolving conflicts manually.`);
       }
       
-      // Use safe merge with conflict detection
-      const mergeResult = git.safeMerge(state.pipelineBranch, {
+      // Use safe merge with conflict detection - merge from remote ref
+      const mergeResult = git.safeMerge(remoteBranchRef, {
         cwd: worktreeDir,
         noFf: true,
         message: `chore: merge task dependency from ${laneName}`,
@@ -137,7 +141,6 @@ export async function runTask({
   chatId,
   runDir,
   runRoot,
-  noGit = false,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -148,7 +151,6 @@ export async function runTask({
   chatId: string;
   runDir: string;
   runRoot?: string;
-  noGit?: boolean;
 }): Promise<TaskExecutionResult> {
   // Calculate runRoot if not provided (runDir is lanes/{laneName}/, runRoot is parent of lanes/)
   const calculatedRunRoot = runRoot || path.dirname(path.dirname(runDir));
@@ -158,11 +160,7 @@ export async function runTask({
   
   logger.section(`[${index + 1}/${config.tasks.length}] ${task.name}`);
   logger.info(`Model: ${model}`);
-  if (noGit) {
-    logger.info('🚫 noGit mode: skipping branch operations');
-  } else {
-    logger.info(`Branch: ${taskBranch}`);
-  }
+  logger.info(`Branch: ${taskBranch}`);
   
   events.emit('task.started', {
     taskName: task.name,
@@ -170,32 +168,28 @@ export async function runTask({
     index,
   });
 
-  // Sync pipelineBranch with remote before starting (skip in noGit mode)
-  if (!noGit) {
-    logger.info(`🔄 Syncing ${pipelineBranch} with remote...`);
-    
-    // Fetch latest from remote
-    try {
-      git.runGit(['fetch', 'origin', pipelineBranch], { cwd: worktreeDir, silent: true });
-    } catch {
-      // Branch might not exist on remote yet - that's OK
-      logger.info(`  Branch ${pipelineBranch} not yet on remote, skipping sync`);
-    }
-    
-    // Try to fast-forward if behind
-    const syncResult = git.syncBranchWithRemote(pipelineBranch, { cwd: worktreeDir, createIfMissing: true });
-    if (syncResult.updated) {
-      logger.info(`  ✓ Updated ${pipelineBranch} with ${syncResult.behind || 0} new commits from remote`);
-    } else if (syncResult.error) {
-      logger.warn(`  ⚠️ Could not sync: ${syncResult.error}`);
-    }
+  // Sync pipelineBranch with remote before starting
+  logger.info(`🔄 Syncing ${pipelineBranch} with remote...`);
+  
+  // Fetch latest from remote
+  try {
+    git.runGit(['fetch', 'origin', pipelineBranch], { cwd: worktreeDir, silent: true });
+  } catch {
+    // Branch might not exist on remote yet - that's OK
+    logger.info(`  Branch ${pipelineBranch} not yet on remote, skipping sync`);
   }
-
-  // Checkout task branch from pipeline branch (skip in noGit mode)
-  if (!noGit) {
-    logger.info(`🌿 Forking task branch: ${taskBranch} from ${pipelineBranch}`);
-    git.runGit(['checkout', '-B', taskBranch, pipelineBranch], { cwd: worktreeDir });
+  
+  // Try to fast-forward if behind
+  const syncResult = git.syncBranchWithRemote(pipelineBranch, { cwd: worktreeDir, createIfMissing: true });
+  if (syncResult.updated) {
+    logger.info(`  ✓ Updated ${pipelineBranch} with ${syncResult.behind || 0} new commits from remote`);
+  } else if (syncResult.error) {
+    logger.warn(`  ⚠️ Could not sync: ${syncResult.error}`);
   }
+
+  // Checkout task branch from pipeline branch
+  logger.info(`🌿 Forking task branch: ${taskBranch} from ${pipelineBranch}`);
+  git.runGit(['checkout', '-B', taskBranch, pipelineBranch], { cwd: worktreeDir });
   
   // Apply dependency permissions
   applyDependencyFilePermissions(worktreeDir, config.dependencyPolicy);
@@ -208,8 +202,7 @@ export async function runTask({
 
   // Wrap prompt with context, dependency results, and completion instructions
   const wrappedPrompt = wrapPrompt(task.prompt, config, { 
-    noGit, 
-    isWorktree: !noGit,
+    isWorktree: true,
     dependencyResults,
     worktreePath: worktreeDir,
     taskBranch,
@@ -297,10 +290,8 @@ export async function runTask({
     }
   }
   
-  // Push task branch (skip in noGit mode)
-  if (!noGit) {
-    git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
-  }
+  // Push task branch
+  git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
   
   // Save task result for dependency handoff
   saveTaskResult(runDir, index, task.name, r1.resultText || '');