@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

package/src/cli/resume.ts

@@ -11,6 +11,7 @@ import { loadState, saveState } from '../utils/state';
 import { LaneState } from '../types';
 import { runDoctor } from '../utils/doctor';
 import { safeJoin } from '../utils/path';
+import { findFlowDir } from '../utils/flow';
 import { 
   EnhancedLogManager, 
   createLogManager, 
@@ -115,7 +116,6 @@ interface LaneInfo {
   dir: string;
   state: LaneState | null;
   needsResume: boolean;
-  dependsOn: string[];
   isCompleted: boolean;
 }
 
@@ -295,39 +295,22 @@ function getAllLaneStatuses(runDir: string): LaneInfo[] {
       ) : true;
       
       const isCompleted = state?.status === 'completed';
-      const dependsOn = state?.dependsOn || [];
       
-      return { name, dir, state, needsResume, dependsOn, isCompleted };
+      return { name, dir, state, needsResume, isCompleted };
     });
   
   return lanes;
 }
 
 /**
- * Check if all dependencies of a lane are completed
+ * Check if lane can be resumed (lane-level deps removed, always true)
  */
 function areDependenciesCompleted(
-  lane: LaneInfo, 
-  allLanes: LaneInfo[],
-  completedLanes: Set<string>
+  _lane: LaneInfo, 
+  _allLanes: LaneInfo[],
+  _completedLanes: Set<string>
 ): boolean {
-  if (!lane.dependsOn || lane.dependsOn.length === 0) {
-    return true;
-  }
-  
-  for (const depName of lane.dependsOn) {
-    // Check if dependency is in completed set (already succeeded in this resume session)
-    if (completedLanes.has(depName)) {
-      continue;
-    }
-    
-    // Check if dependency was already completed before this resume
-    const depLane = allLanes.find(l => l.name === depName);
-    if (!depLane || !depLane.isCompleted) {
-      return false;
-    }
-  }
-  
+  // Lane-level dependencies removed - use task-level dependsOn instead
   return true;
 }
 
@@ -371,40 +354,25 @@ function printAllLaneStatus(runDir: string): { total: number; completed: number;
     const status = state?.status || 'unknown';
     const color = STATUS_COLORS[status] || STATUS_COLORS.unknown;
     const progress = state ? `${state.currentTaskIndex}/${state.totalTasks}` : '-/-';
-    const dependsOnStr = lane.dependsOn.length > 0 ? lane.dependsOn.join(',').substring(0, 12) : '-';
-    
-    // Check if dependencies are met
-    const depsCompleted = areDependenciesCompleted(lane, lanes, completedSet);
-    const canResume = lane.needsResume && depsCompleted;
-    const blockedByDep = lane.needsResume && !depsCompleted;
     
     if (status === 'completed') completedCount++;
     if (lane.needsResume) needsResumeCount++;
     
     let resumeIndicator = '';
-    if (canResume) {
-      resumeIndicator = '\x1b[33m✓\x1b[0m';
-    } else if (blockedByDep) {
-      resumeIndicator = '\x1b[90m⏳ waiting\x1b[0m';
+    if (lane.needsResume) {
+      resumeIndicator = '\x1b[33m✓ resumable\x1b[0m';
     }
     
     console.log('  ' + 
-      lane.name.padEnd(25) + 
+      lane.name.padEnd(30) + 
       `${color}${status.padEnd(12)}${RESET}` +
       progress.padEnd(12) +
-      dependsOnStr.padEnd(15) +
       resumeIndicator
     );
     
     // Show error if failed
     if (status === 'failed' && state?.error) {
-      console.log(`  ${''.padEnd(25)}\x1b[31m└─ ${state.error.substring(0, 50)}${state.error.length > 50 ? '...' : ''}\x1b[0m`);
-    }
-    
-    // Show blocked dependency info
-    if (blockedByDep) {
-      const pendingDeps = lane.dependsOn.filter(d => !completedSet.has(d));
-      console.log(`  ${''.padEnd(25)}\x1b[90m└─ waiting for: ${pendingDeps.join(', ')}\x1b[0m`);
+      console.log(`  ${''.padEnd(30)}\x1b[31m└─ ${state.error.substring(0, 50)}${state.error.length > 50 ? '...' : ''}\x1b[0m`);
     }
   }
   
@@ -464,9 +432,10 @@ function spawnLaneResume(
     runnerArgs.push('--executor', options.executor);
   }
 
+  const shortLaneName = laneName.substring(0, 10);
   const logManager = createLogManager(laneDir, laneName, options.enhancedLogConfig || {}, (msg) => {
     const formatted = formatMessageForConsole(msg, { 
-      laneLabel: `[${laneName}]`,
+      laneLabel: `[${shortLaneName}]`,
       includeTimestamp: true 
     });
     process.stdout.write(formatted + '\n');
@@ -532,17 +501,8 @@ async function resumeLanes(
   const resolvableLanes: LaneInfo[] = [];
   
   for (const lane of lanesToResume) {
-    // Check if all dependencies can be satisfied (either already completed or in the resume list)
-    const unmetDeps = lane.dependsOn.filter(dep => 
-      !completedSet.has(dep) && !toResumeNames.has(dep)
-    );
-    
-    if (unmetDeps.length > 0) {
-      logger.warn(`⏭ Skipping ${lane.name}: unresolvable dependencies (${unmetDeps.join(', ')})`);
-      skippedLanes.push(lane.name);
-    } else {
-      resolvableLanes.push(lane);
-    }
+    // Lane-level dependencies removed - all lanes can be resumed
+    resolvableLanes.push(lane);
   }
   
   if (resolvableLanes.length === 0) {
@@ -612,8 +572,7 @@ async function resumeLanes(
       }
       
       pending.delete(lane.name);
-      const depsInfo = lane.dependsOn.length > 0 ? ` (after: ${lane.dependsOn.join(', ')})` : '';
-      logger.info(`Starting: ${lane.name} (task ${lane.state!.currentTaskIndex}/${lane.state!.totalTasks})${depsInfo}`);
+      logger.info(`Starting: ${lane.name} (task ${lane.state!.currentTaskIndex}/${lane.state!.totalTasks})`);
       
       const { child } = spawnLaneResume(lane.name, lane.dir, lane.state!, {
         restart: options.restart,
@@ -675,8 +634,19 @@ async function resume(args: string[]): Promise<void> {
 
   const config = loadConfig();
   const logsDir = getLogsDir(config);
+  const originalCwd = process.cwd();
+
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
   
   let runDir = options.runDir;
+  if (runDir && !path.isAbsolute(runDir)) {
+    runDir = path.resolve(originalCwd, runDir);
+  }
+
   if (!runDir) {
     runDir = findLatestRunDir(logsDir);
   }
@@ -688,30 +658,45 @@ async function resume(args: string[]): Promise<void> {
   const allLanes = getAllLaneStatuses(runDir);
   let lanesToResume: LaneInfo[] = [];
 
-  // Check if the lane argument is actually a tasks directory
-  if (options.lane && fs.existsSync(options.lane) && fs.statSync(options.lane).isDirectory()) {
-    const tasksDir = path.resolve(options.lane);
-    lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile && path.resolve(l.state.tasksFile).startsWith(tasksDir));
+  // Check if the lane argument is actually a tasks directory or a flow name
+  if (options.lane) {
+    let tasksDir = '';
+    const lanePathAbs = path.resolve(originalCwd, options.lane);
     
-    if (lanesToResume.length > 0) {
-      logger.info(`📂 Task directory detected: ${options.lane}`);
-      logger.info(`Resuming ${lanesToResume.length} lane(s) from this directory.`);
+    if (fs.existsSync(lanePathAbs) && fs.statSync(lanePathAbs).isDirectory()) {
+      tasksDir = lanePathAbs;
     } else {
-      logger.warn(`No incomplete lanes found using tasks from directory: ${options.lane}`);
-      return;
+      // Try finding in flowsDir
+      const flowsDir = safeJoin(config.projectRoot, config.flowsDir);
+      const foundFlow = findFlowDir(flowsDir, options.lane);
+      if (foundFlow) {
+        tasksDir = foundFlow;
+      }
+    }
+
+    if (tasksDir) {
+      lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile && path.resolve(l.state.tasksFile).startsWith(tasksDir));
+      
+      if (lanesToResume.length > 0) {
+        logger.info(`📂 Flow/Task directory detected: ${options.lane}`);
+        logger.info(`Resuming ${lanesToResume.length} lane(s) from this directory.`);
+      } else {
+        logger.warn(`No incomplete lanes found using tasks from directory: ${options.lane}`);
+        return;
+      }
+    } else {
+      const lane = allLanes.find(l => l.name === options.lane);
+      if (!lane) {
+        throw new Error(`Lane '${options.lane}' not found in run directory.`);
+      }
+      if (!lane.needsResume) {
+        logger.success(`Lane '${options.lane}' is already completed.`);
+        return;
+      }
+      lanesToResume = [lane];
     }
   } else if (options.all) {
     lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile);
-  } else if (options.lane) {
-    const lane = allLanes.find(l => l.name === options.lane);
-    if (!lane) {
-      throw new Error(`Lane '${options.lane}' not found in run directory.`);
-    }
-    if (!lane.needsResume) {
-      logger.success(`Lane '${options.lane}' is already completed.`);
-      return;
-    }
-    lanesToResume = [lane];
   }
 
   // Check for zombie lanes