@litmers/cursorflow-orchestrator 0.1.15 → 0.1.18

package/src/cli/prepare.ts

@@ -97,12 +97,16 @@ Prepare task files for a new feature - Terminal-first workflow.
     --prompt <text>           Task prompt (uses preset or single task)
     --criteria <list>         Comma-separated acceptance criteria
     --model <model>           Model to use (default: sonnet-4.5)
-    --task <spec>             Full task spec: "name|model|prompt|criteria" (repeatable)
+    --task <spec>             Full task spec: "name|model|prompt|criteria|dependsOn|timeout" (repeatable)
 
   Dependencies:
     --sequential              Chain lanes: 1 → 2 → 3
     --deps <spec>             Custom dependencies: "2:1;3:1,2"
     --depends-on <lanes>      Dependencies for --add-lane: "01-lane-1,02-lane-2"
+    Task-level deps:          In --task, add "lane:task" at the end.
+                              Example: "test|sonnet-4.5|Run tests|All pass|01-lane-1:setup"
+    Task-level timeout:       In --task, add milliseconds at the end.
+                              Example: "heavy|sonnet-4.5|Big task|Done||1200000"
 
   Incremental (add to existing):
     --add-lane <dir>          Add a new lane to existing task directory
@@ -203,23 +207,31 @@ function parseArgs(args: string[]): PrepareOptions {
 }
 
 function parseTaskSpec(spec: string): Task {
-  // Format: "name|model|prompt|criteria1,criteria2"
+  // Format: "name|model|prompt|criteria1,criteria2|lane:task1,lane:task2|timeoutMs"
   const parts = spec.split('|');
   
   if (parts.length < 3) {
-    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria1,criteria2]"`);
+    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria[|dependsOn[|timeout]]]"`);
   }
   
-  const [name, model, prompt, criteriaStr] = parts;
+  const [name, model, prompt, criteriaStr, depsStr, timeoutStr] = parts;
   const acceptanceCriteria = criteriaStr 
     ? criteriaStr.split(',').map(c => c.trim()).filter(c => c)
     : undefined;
   
+  const dependsOn = depsStr
+    ? depsStr.split(',').map(d => d.trim()).filter(d => d)
+    : undefined;
+
+  const timeout = timeoutStr ? parseInt(timeoutStr) : undefined;
+  
   return {
     name: name.trim(),
     model: model.trim() || 'sonnet-4.5',
     prompt: prompt.trim(),
     ...(acceptanceCriteria && acceptanceCriteria.length > 0 ? { acceptanceCriteria } : {}),
+    ...(dependsOn && dependsOn.length > 0 ? { dependsOn } : {}),
+    ...(timeout ? { timeout } : {}),
   };
 }
 
@@ -612,10 +624,6 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
   const fileName = `${laneNumber.toString().padStart(2, '0')}-${laneName}.json`;
   const filePath = path.join(taskDir, fileName);
   
-  if (fs.existsSync(filePath) && !options.force) {
-    throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
-  }
-  
   const hasDependencies = options.dependsOnLanes.length > 0;
   
   // Build tasks from options (auto-detects merge preset if has dependencies)
@@ -628,7 +636,16 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
     ...(hasDependencies ? { dependsOn: options.dependsOnLanes } : {}),
   };
   
-  fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', 'utf8');
+  // Use atomic write with wx flag to avoid TOCTOU race condition (unless force is set)
+  try {
+    const writeFlag = options.force ? 'w' : 'wx';
+    fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', { encoding: 'utf8', flag: writeFlag });
+  } catch (err: any) {
+    if (err.code === 'EEXIST') {
+      throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
+    }
+    throw err;
+  }
   
   const taskSummary = tasks.map(t => t.name).join(' → ');
   const depsInfo = hasDependencies ? ` (depends: ${options.dependsOnLanes.join(', ')})` : '';
@@ -645,16 +662,20 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
 async function addTaskToLane(options: PrepareOptions): Promise<void> {
   const laneFile = path.resolve(process.cwd(), options.addTask!);
   
-  if (!fs.existsSync(laneFile)) {
-    throw new Error(`Lane file not found: ${laneFile}`);
-  }
-  
   if (options.taskSpecs.length === 0) {
     throw new Error('No task specified. Use --task "name|model|prompt|criteria" to define a task.');
   }
   
-  // Read existing config
-  const existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  // Read existing config - let the error propagate if file doesn't exist (avoids TOCTOU)
+  let existingConfig: any;
+  try {
+    existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Lane file not found: ${laneFile}`);
+    }
+    throw err;
+  }
   
   if (!existingConfig.tasks || !Array.isArray(existingConfig.tasks)) {
     existingConfig.tasks = [];

package/src/cli/resume.ts

@@ -7,7 +7,7 @@ import * as fs from 'fs';
 import { spawn, ChildProcess } from 'child_process';
 import * as logger from '../utils/logger';
 import { loadConfig, getLogsDir } from '../utils/config';
-import { loadState, listLanesInRun } from '../utils/state';
+import { loadState } from '../utils/state';
 import { LaneState } from '../utils/types';
 import { runDoctor } from '../utils/doctor';
 

package/src/core/orchestrator.ts

@@ -153,13 +153,16 @@ export function spawnLane({
         case 'system':
           prefix = `${logger.COLORS.gray}⚙️  SYS${logger.COLORS.reset}`;
           break;
+        case 'thinking':
+          prefix = `${logger.COLORS.gray}🤔 THNK${logger.COLORS.reset}`;
+          break;
       }
       
       if (prefix) {
         const lines = content.split('\n');
         const tsPrefix = `${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneLabel}${logger.COLORS.reset}`;
         
-        if (msg.type === 'user' || msg.type === 'assistant' || msg.type === 'result') {
+        if (msg.type === 'user' || msg.type === 'assistant' || msg.type === 'result' || msg.type === 'thinking') {
           const header = `${prefix} ┌${'─'.repeat(60)}`;
           process.stdout.write(`${tsPrefix} ${header}\n`);
           for (const line of lines) {
@@ -202,8 +205,7 @@ export function spawnLane({
           if (trimmed && 
               !trimmed.startsWith('{') && 
               !trimmed.startsWith('[') && 
-              !trimmed.includes('{"type"') &&
-              !trimmed.includes('Heartbeat:')) {
+              !trimmed.includes('{"type"')) {
             process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneName.padEnd(10)}${logger.COLORS.reset} ${line}\n`);
           }
         }
@@ -412,7 +414,8 @@ async function resolveAllDependencies(
     const task = taskConfig.tasks[currentIdx];
     
     if (task) {
-      const taskBranch = `${pipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
+      const lanePipelineBranch = `${pipelineBranch}/${lane.name}`;
+      const taskBranch = `${lanePipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
       logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`);
       
       try {
@@ -467,7 +470,8 @@ export async function orchestrate(tasksDir: string, options: {
   
   fs.mkdirSync(runRoot, { recursive: true });
 
-  const pipelineBranch = `cursorflow/run-${Date.now().toString(36)}`;
+  const randomSuffix = Math.random().toString(36).substring(2, 7);
+  const pipelineBranch = `cursorflow/run-${Date.now().toString(36)}-${randomSuffix}`;
 
   // Initialize event system
   events.setRunId(runId);
@@ -570,7 +574,7 @@ export async function orchestrate(tasksDir: string, options: {
         laneRunDir: laneRunDirs[lane.name]!,
         executor: options.executor || 'cursor-agent',
         startIndex: lane.startIndex,
-        pipelineBranch,
+        pipelineBranch: `${pipelineBranch}/${lane.name}`,
         enhancedLogConfig: options.enhancedLogging,
         noGit: options.noGit,
       });

package/src/core/reviewer.ts

@@ -144,24 +144,25 @@ export function buildFeedbackPrompt(review: ReviewResult): string {
 /**
  * Review task
  */
-export async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgentSend, cursorAgentCreateChat }: { 
+export async function reviewTask({ taskResult, worktreeDir, runDir, config, model, cursorAgentSend, cursorAgentCreateChat }: { 
   taskResult: TaskResult; 
   worktreeDir: string; 
   runDir: string; 
   config: RunnerConfig; 
+  model?: string;
   cursorAgentSend: (options: { 
     workspaceDir: string; 
     chatId: string; 
     prompt: string; 
     model?: string;
     outputFormat?: 'stream-json' | 'json' | 'plain';
-  }) => AgentSendResult; 
+  }) => Promise<AgentSendResult>; 
   cursorAgentCreateChat: () => string; 
 }): Promise<ReviewResult> {
   const reviewPrompt = buildReviewPrompt({
     taskName: taskResult.taskName,
     taskBranch: taskResult.taskBranch,
-    acceptanceCriteria: config.acceptanceCriteria || [],
+    acceptanceCriteria: taskResult.acceptanceCriteria || config.acceptanceCriteria || [],
   });
   
   logger.info(`Reviewing: ${taskResult.taskName}`);
@@ -172,11 +173,13 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   });
 
   const reviewChatId = cursorAgentCreateChat();
+  const reviewModel = model || config.reviewModel || config.model || 'sonnet-4.5';
+  
   const reviewResult = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId: reviewChatId,
     prompt: reviewPrompt,
-    model: config.reviewModel || 'sonnet-4.5-thinking',
+    model: reviewModel,
     outputFormat: config.agentOutputFormat,
   });
   
@@ -186,7 +189,7 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   const convoPath = path.join(runDir, 'conversation.jsonl');
   appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText || 'No result', {
     task: taskResult.taskName,
-    model: config.reviewModel,
+    model: reviewModel,
   }));
   
   logger.info(`Review result: ${review.status} (${review.issues?.length || 0} issues)`);
@@ -204,20 +207,21 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
 /**
  * Review loop with feedback
  */
-export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, cursorAgentSend, cursorAgentCreateChat }: {
+export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, model, cursorAgentSend, cursorAgentCreateChat }: {
   taskResult: TaskResult;
   worktreeDir: string;
   runDir: string;
   config: RunnerConfig;
   workChatId: string;
+  model?: string;
   cursorAgentSend: (options: { 
     workspaceDir: string; 
     chatId: string; 
     prompt: string; 
     model?: string;
     outputFormat?: 'stream-json' | 'json' | 'plain';
-  }) => AgentSendResult; 
-  cursorAgentCreateChat: () => string;
+  }) => Promise<AgentSendResult>; 
+  cursorAgentCreateChat: () => string; 
 }): Promise<{ approved: boolean; review: ReviewResult; iterations: number; error?: string }> {
   const maxIterations = config.maxReviewIterations || 3;
   let iteration = 0;
@@ -229,10 +233,11 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
       worktreeDir,
       runDir,
       config,
+      model,
       cursorAgentSend,
       cursorAgentCreateChat,
     });
-    
+
     if (currentReview.status === 'approved') {
       logger.success(`Review passed: ${taskResult.taskName} (iteration ${iteration + 1})`);
       events.emit('review.approved', {

package/src/core/runner.ts

@@ -15,7 +15,7 @@ import { saveState, appendLog, createConversationEntry } from '../utils/state';
 import { events } from '../utils/events';
 import { loadConfig } from '../utils/config';
 import { registerWebhooks } from '../utils/webhook';
-import { stripAnsi } from '../utils/enhanced-logger';
+import { runReviewLoop } from './reviewer';
 import { 
   RunnerConfig, 
   Task, 
@@ -191,6 +191,8 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
   const format = outputFormat || 'stream-json';
   const args = [
     '--print',
+    '--force',
+    '--approve-mcps',
     '--output-format', format,
     '--workspace', workspaceDir,
     ...(model ? ['--model', model] : []),
@@ -232,17 +234,18 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
       env: childEnv,
     });
 
-    // Save PID to state if possible
+    logger.info(`Executing cursor-agent... (timeout: ${Math.round(timeoutMs / 1000)}s)`);
+
+    // Save PID to state if possible (avoid TOCTOU by reading directly)
     if (child.pid && signalDir) {
       try {
         const statePath = path.join(signalDir, 'state.json');
-        if (fs.existsSync(statePath)) {
-          const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-          state.pid = child.pid;
-          fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-        }
-      } catch (e) {
-        // Best effort
+        // Read directly without existence check to avoid race condition
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        state.pid = child.pid;
+        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+      } catch {
+        // Best effort - file may not exist yet
       }
     }
 
@@ -484,6 +487,82 @@ export function applyDependencyFilePermissions(worktreeDir: string, policy: Depe
   }
 }
 
+/**
+ * Wait for task-level dependencies to be completed by other lanes
+ */
+export async function waitForTaskDependencies(deps: string[], runDir: string): Promise<void> {
+  if (!deps || deps.length === 0) return;
+
+  const lanesRoot = path.dirname(runDir);
+  const pendingDeps = new Set(deps);
+
+  logger.info(`Waiting for task dependencies: ${deps.join(', ')}`);
+
+  while (pendingDeps.size > 0) {
+    for (const dep of pendingDeps) {
+      const [laneName, taskName] = dep.split(':');
+      if (!laneName || !taskName) {
+        logger.warn(`Invalid dependency format: ${dep}. Expected "lane:task"`);
+        pendingDeps.delete(dep);
+        continue;
+      }
+
+      const depStatePath = path.join(lanesRoot, laneName, 'state.json');
+      if (fs.existsSync(depStatePath)) {
+        try {
+          const state = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+          if (state.completedTasks && state.completedTasks.includes(taskName)) {
+            logger.info(`✓ Dependency met: ${dep}`);
+            pendingDeps.delete(dep);
+          } else if (state.status === 'failed') {
+            throw new Error(`Dependency failed: ${dep} (Lane ${laneName} failed)`);
+          }
+        } catch (e: any) {
+          if (e.message.includes('Dependency failed')) throw e;
+          // Ignore parse errors, file might be being written
+        }
+      }
+    }
+
+    if (pendingDeps.size > 0) {
+      await new Promise(resolve => setTimeout(resolve, 5000)); // Poll every 5 seconds
+    }
+  }
+}
+
+/**
+ * Merge branches from dependency lanes
+ */
+export async function mergeDependencyBranches(deps: string[], runDir: string, worktreeDir: string): Promise<void> {
+  if (!deps || deps.length === 0) return;
+
+  const lanesRoot = path.dirname(runDir);
+  const lanesToMerge = new Set(deps.map(d => d.split(':')[0]!));
+
+  for (const laneName of lanesToMerge) {
+    const depStatePath = path.join(lanesRoot, laneName, 'state.json');
+    if (!fs.existsSync(depStatePath)) continue;
+
+    try {
+      const state = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+      if (state.pipelineBranch) {
+        logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
+        
+        // Ensure we have the latest
+        git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
+        
+        git.merge(state.pipelineBranch, {
+          cwd: worktreeDir,
+          noFf: true,
+          message: `chore: merge task dependency from ${laneName}`
+        });
+      }
+    } catch (e) {
+      logger.error(`Failed to merge branch from ${laneName}: ${e}`);
+    }
+  }
+}
+
 /**
  * Run a single task
  */
@@ -509,6 +588,7 @@ export async function runTask({
   noGit?: boolean;
 }): Promise<TaskExecutionResult> {
   const model = task.model || config.model || 'sonnet-4.5';
+  const timeout = task.timeout || config.timeout;
   const convoPath = path.join(runDir, 'conversation.jsonl');
   
   logger.section(`[${index + 1}/${config.tasks.length}] ${task.name}`);
@@ -555,7 +635,7 @@ export async function runTask({
     prompt: prompt1,
     model,
     signalDir: runDir,
-    timeout: config.timeout,
+    timeout,
     enableIntervention: config.enableIntervention,
     outputFormat: config.agentOutputFormat,
   });
@@ -603,6 +683,37 @@ export async function runTask({
   if (!noGit) {
     git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
   }
+
+  // Automatic Review
+  const reviewEnabled = config.reviewAllTasks || task.acceptanceCriteria?.length || config.enableReview;
+  
+  if (reviewEnabled) {
+    logger.section(`🔍 Reviewing Task: ${task.name}`);
+    const reviewResult = await runReviewLoop({
+      taskResult: {
+        taskName: task.name,
+        taskBranch: taskBranch,
+        acceptanceCriteria: task.acceptanceCriteria,
+      },
+      worktreeDir,
+      runDir,
+      config,
+      workChatId: chatId,
+      model, // Use the same model as requested
+      cursorAgentSend,
+      cursorAgentCreateChat,
+    });
+
+    if (!reviewResult.approved) {
+      logger.error(`❌ Task review failed after ${reviewResult.iterations} iterations`);
+      return {
+        taskName: task.name,
+        taskBranch,
+        status: 'ERROR',
+        error: reviewResult.error || 'Task failed to pass review criteria',
+      };
+    }
+  }
   
   events.emit('task.completed', {
     taskName: task.name,
@@ -673,11 +784,16 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   const statePath = path.join(runDir, 'state.json');
   let state: LaneState | null = null;
   
-  if (startIndex > 0 && fs.existsSync(statePath)) {
-    state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (fs.existsSync(statePath)) {
+    try {
+      state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    } catch (e) {
+      logger.warn(`Failed to load existing state from ${statePath}: ${e}`);
+    }
   }
   
-  const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}`;
+  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
   const worktreeDir = state?.worktreeDir || (noGit 
     ? path.join(repoRoot, config.worktreeRoot || '_cursorflow/workdir', pipelineBranch.replace(/\//g, '-'))
@@ -693,8 +809,8 @@ 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
-  if (startIndex === 0 || !fs.existsSync(worktreeDir)) {
+  // 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}`);
@@ -705,6 +821,16 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
         cwd: repoRoot,
       });
     }
+  } else if (!noGit) {
+    // If it exists but we are in Git mode, ensure it's actually a worktree and on the right branch
+    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.
+      logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
+    }
   }
   
   // Create chat
@@ -726,12 +852,14 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       dependencyRequest: null,
       tasksFile, // Store tasks file for resume
       dependsOn: config.dependsOn || [],
+      completedTasks: [],
     };
   } else {
     state.status = 'running';
     state.error = null;
     state.dependencyRequest = null;
     state.dependsOn = config.dependsOn || [];
+    state.completedTasks = state.completedTasks || [];
   }
   
   saveState(statePath, state);
@@ -836,6 +964,32 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   for (let i = startIndex; i < config.tasks.length; i++) {
     const task = config.tasks[i]!;
     const taskBranch = `${pipelineBranch}--${String(i + 1).padStart(2, '0')}-${task.name}`;
+
+    // Handle task-level dependencies
+    if (task.dependsOn && task.dependsOn.length > 0) {
+      state.status = 'waiting';
+      state.waitingFor = task.dependsOn;
+      saveState(statePath, state);
+
+      try {
+        await waitForTaskDependencies(task.dependsOn, runDir);
+        
+        if (!noGit) {
+          await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir);
+        }
+        
+        state.status = 'running';
+        state.waitingFor = [];
+        saveState(statePath, state);
+      } catch (e: any) {
+        state.status = 'failed';
+        state.waitingFor = [];
+        state.error = e.message;
+        saveState(statePath, state);
+        logger.error(`Task dependency wait/merge failed: ${e.message}`);
+        process.exit(1);
+      }
+    }
     
     const result = await runTask({
       task,
@@ -853,6 +1007,10 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     
     // Update state
     state.currentTaskIndex = i + 1;
+    state.completedTasks = state.completedTasks || [];
+    if (!state.completedTasks.includes(task.name)) {
+      state.completedTasks.push(task.name);
+    }
     saveState(statePath, state);
     
     // Handle blocked or error

package/src/utils/config.ts

@@ -59,6 +59,7 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     // Review
     enableReview: false,
     reviewModel: 'sonnet-4.5-thinking',
+    reviewAllTasks: false,
     maxReviewIterations: 3,
     
     // Lane defaults
@@ -158,10 +159,6 @@ export function validateConfig(config: CursorFlowConfig): boolean {
 export function createDefaultConfig(projectRoot: string, force = false): string {
   const configPath = path.join(projectRoot, 'cursorflow.config.js');
   
-  if (fs.existsSync(configPath) && !force) {
-    throw new Error(`Config file already exists: ${configPath}`);
-  }
-  
   const template = `module.exports = {
   // Directory configuration
   tasksDir: '_cursorflow/tasks',
@@ -182,6 +179,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Review configuration
   enableReview: false,
   reviewModel: 'sonnet-4.5-thinking',
+  reviewAllTasks: false,
   maxReviewIterations: 3,
   
   // Lane configuration
@@ -222,6 +220,15 @@ export function createDefaultConfig(projectRoot: string, force = false): string
 };
 `;
   
-  fs.writeFileSync(configPath, template, 'utf8');
+  // Use atomic write with wx flag to avoid TOCTOU race condition (unless force is set)
+  try {
+    const writeFlag = force ? 'w' : 'wx';
+    fs.writeFileSync(configPath, template, { encoding: 'utf8', flag: writeFlag });
+  } catch (err: any) {
+    if (err.code === 'EEXIST') {
+      throw new Error(`Config file already exists: ${configPath}`);
+    }
+    throw err;
+  }
   return configPath;
 }

package/src/utils/doctor.ts

@@ -486,16 +486,46 @@ function validateBranchNames(
   const remoteBranches = getAllRemoteBranches(repoRoot);
   const allExistingBranches = new Set([...localBranches, ...remoteBranches]);
   
-  // Collect branch prefixes from lanes
+  // Collect branch prefixes and pipeline branches from lanes
   const branchPrefixes: { laneName: string; prefix: string }[] = [];
+  const pipelineBranches: { laneName: string; branch: string }[] = [];
   
   for (const lane of lanes) {
     const branchPrefix = lane.json?.branchPrefix;
     if (branchPrefix) {
       branchPrefixes.push({ laneName: lane.fileName, prefix: branchPrefix });
     }
+    
+    const pipelineBranch = lane.json?.pipelineBranch;
+    if (pipelineBranch) {
+      pipelineBranches.push({ laneName: lane.fileName, branch: pipelineBranch });
+    }
   }
   
+  // Check for pipeline branch collisions
+  const pipeMap = new Map<string, string[]>();
+  for (const { laneName, branch } of pipelineBranches) {
+    const existing = pipeMap.get(branch) || [];
+    existing.push(laneName);
+    pipeMap.set(branch, existing);
+  }
+  
+  for (const [branch, laneNames] of pipeMap) {
+    if (laneNames.length > 1) {
+      addIssue(issues, {
+        id: 'branch.pipeline_collision',
+        severity: 'error',
+        title: 'Pipeline branch collision',
+        message: `Multiple lanes use the same pipelineBranch "${branch}": ${laneNames.join(', ')}`,
+        details: 'Each lane should have a unique pipelineBranch to avoid worktree conflicts during parallel execution.',
+        fixes: [
+          'Update the pipelineBranch in each lane JSON file to be unique',
+          'Or remove pipelineBranch to let CursorFlow generate unique ones',
+        ],
+      });
+    }
+  }
+
   // Check for branch prefix collisions between lanes
   const prefixMap = new Map<string, string[]>();
   for (const { laneName, prefix } of branchPrefixes) {