@litmers/cursorflow-orchestrator 0.1.28 → 0.1.30

package/src/cli/prepare.ts

@@ -11,7 +11,6 @@ import { loadConfig, getTasksDir } from '../utils/config';
 import { Task, RunnerConfig } from '../utils/types';
 import { safeJoin } from '../utils/path';
 import { resolveTemplate } from '../utils/template';
-import * as git from '../utils/git';
 
 // Preset template types
 type PresetType = 'complex' | 'simple' | 'merge';
@@ -33,9 +32,6 @@ interface PrepareOptions {
   addLane: string | null;      // Add lane to existing task dir
   addTask: string | null;      // Add task to existing lane file
   dependsOnLanes: string[];    // --depends-on for new lane
-  // Git options
-  commit: boolean;             // Commit and push current changes before prepare
-  commitMessage: string | null; // Custom commit message
   force: boolean;
   help: boolean;
 }
@@ -118,10 +114,6 @@ Prepare task files for a new feature - Terminal-first workflow.
     --add-lane <dir>          Add a new lane to existing task directory
     --add-task <file>         Append task(s) to existing lane JSON file
 
-  Git (commit before prepare):
-    --commit                    Commit and push current changes before prepare
-    --commit-message <msg>      Custom commit message (default: auto-generated)
-
   Advanced:
     --template <path|url|name>  External template JSON file, URL, or built-in name
     --force                     Overwrite existing files
@@ -165,8 +157,6 @@ function parseArgs(args: string[]): PrepareOptions {
     addLane: null,
     addTask: null,
     dependsOnLanes: [],
-    commit: false,
-    commitMessage: null,
     force: false,
     help: false,
   };
@@ -208,11 +198,6 @@ function parseArgs(args: string[]): PrepareOptions {
       result.addTask = args[++i];
     } else if (arg === '--depends-on' && args[i + 1]) {
       result.dependsOnLanes = args[++i].split(',').map(d => d.trim()).filter(d => d);
-    } else if (arg === '--commit') {
-      result.commit = true;
-    } else if ((arg === '--commit-message' || arg === '-m') && args[i + 1]) {
-      result.commitMessage = args[++i];
-      result.commit = true; // Implicitly enable commit if message is provided
     } else if (!arg.startsWith('--') && !result.featureName) {
       result.featureName = arg;
     }
@@ -867,75 +852,6 @@ cursorflow prepare --add-task ${path.relative(config.projectRoot, taskDir)}/01-l
   console.log('');
 }
 
-/**
- * Commit and push current changes before prepare
- */
-async function commitAndPush(featureName: string, customMessage: string | null): Promise<boolean> {
-  // Check if there are uncommitted changes
-  const statusResult = git.runGitResult(['status', '--porcelain']);
-  if (!statusResult.success) {
-    logger.error('Failed to check git status');
-    return false;
-  }
-  
-  const hasChanges = statusResult.stdout.trim().length > 0;
-  
-  if (!hasChanges) {
-    logger.info('No uncommitted changes to commit');
-    return true;
-  }
-  
-  // Show what will be committed
-  logger.section('📦 Committing Current Changes');
-  const changedFiles = statusResult.stdout.trim().split('\n');
-  logger.info(`${changedFiles.length} file(s) to commit:`);
-  for (const file of changedFiles.slice(0, 5)) {
-    console.log(`  ${file}`);
-  }
-  if (changedFiles.length > 5) {
-    console.log(`  ... and ${changedFiles.length - 5} more`);
-  }
-  console.log('');
-  
-  // Stage all changes
-  const addResult = git.runGitResult(['add', '-A']);
-  if (!addResult.success) {
-    logger.error(`Failed to stage changes: ${addResult.stderr}`);
-    return false;
-  }
-  
-  // Generate commit message
-  const message = customMessage || `chore: pre-prepare checkpoint for ${featureName}`;
-  
-  // Commit
-  const commitResult = git.runGitResult(['commit', '-m', message]);
-  if (!commitResult.success) {
-    logger.error(`Failed to commit: ${commitResult.stderr}`);
-    return false;
-  }
-  logger.success(`Committed: ${message}`);
-  
-  // Push
-  logger.info('Pushing to remote...');
-  const currentBranch = git.getCurrentBranch();
-  const pushResult = git.runGitResult(['push', 'origin', currentBranch]);
-  if (!pushResult.success) {
-    // Try to provide helpful error message
-    if (pushResult.stderr.includes('rejected') || pushResult.stderr.includes('non-fast-forward')) {
-      logger.warn('Push rejected. Try pulling first:');
-      console.log(`  git pull --rebase origin ${currentBranch}`);
-      console.log('  Then run prepare again');
-    } else {
-      logger.error(`Failed to push: ${pushResult.stderr}`);
-    }
-    return false;
-  }
-  logger.success(`Pushed to origin/${currentBranch}`);
-  console.log('');
-  
-  return true;
-}
-
 async function prepare(args: string[]): Promise<void> {
   const options = parseArgs(args);
 
@@ -944,15 +860,6 @@ async function prepare(args: string[]): Promise<void> {
     return;
   }
 
-  // Handle --commit option first (before any prepare operation)
-  if (options.commit) {
-    const featureName = options.featureName || options.addLane || options.addTask || 'tasks';
-    const success = await commitAndPush(featureName, options.commitMessage);
-    if (!success) {
-      throw new Error('Failed to commit and push. Fix the issue and try again.');
-    }
-  }
-
   // Mode 1: Add task to existing lane
   if (options.addTask) {
     await addTaskToLane(options);

package/src/core/auto-recovery.ts

@@ -283,9 +283,11 @@ export class AutoRecoveryManager {
     if (!state) return;
 
     const now = Date.now();
-    state.lastActivityTime = now;
     
+    // Only update activity time if we actually received bytes
+    // This allows heartbeats to be recorded (for logs/bytes) without resetting the idle timer
     if (bytesReceived > 0) {
+      state.lastActivityTime = now;
       state.lastBytesReceived = bytesReceived;
       state.totalBytesReceived += bytesReceived;
     }

package/src/core/failure-policy.ts

@@ -149,7 +149,14 @@ export function analyzeStall(context: StallContext, config: StallDetectionConfig
   
   // Check if this might be a long operation
   const isLongOperation = lastOutput && config.longOperationPatterns.some(p => p.test(lastOutput));
-  const effectiveIdleTimeout = isLongOperation ? config.longOperationGraceMs : config.idleTimeoutMs;
+  
+  // If it's a long operation but we've received 0 real bytes for a while, 
+  // reduce the grace period to avoid waiting forever for a hung process.
+  // We use 2x the normal idle timeout as a "sanity check" for silent long operations.
+  const silentLongOpCappedTimeout = config.idleTimeoutMs * 2;
+  const effectiveIdleTimeout = isLongOperation 
+    ? (bytesReceived === 0 ? Math.min(config.longOperationGraceMs, silentLongOpCappedTimeout) : config.longOperationGraceMs)
+    : config.idleTimeoutMs;
   
   // Check for task timeout
   if (taskStartTimeMs && (Date.now() - taskStartTimeMs) > config.taskTimeoutMs) {

package/src/core/orchestrator.ts

@@ -86,6 +86,26 @@ interface RunningLaneInfo {
   continueSignalsSent: number; // Number of continue signals sent
 }
 
+/**
+ * Log the tail of a file
+ */
+function logFileTail(filePath: string, lines: number = 10): void {
+  if (!fs.existsSync(filePath)) return;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const allLines = content.split('\n');
+    const tail = allLines.slice(-lines).filter(l => l.trim());
+    if (tail.length > 0) {
+      logger.error(`  Last ${tail.length} lines of log:`);
+      for (const line of tail) {
+        logger.error(`    ${line}`);
+      }
+    }
+  } catch (e) {
+    // Ignore log reading errors
+  }
+}
+
 /**
  * Spawn a lane process
  */
@@ -651,7 +671,28 @@ export async function orchestrate(tasksDir: string, options: {
     printLaneStatus(lanes, laneRunDirs);
   }, options.pollInterval || 60000);
   
-  while (completedLanes.size + failedLanes.size + blockedLanes.size < lanes.length || (blockedLanes.size > 0 && running.size === 0)) {
+  // Handle process interruption
+  const sigIntHandler = () => {
+    logger.warn('\n⚠️  Orchestration interrupted! Stopping all lanes...');
+    for (const [name, info] of running.entries()) {
+      logger.info(`Stopping lane: ${name}`);
+      try {
+        info.child.kill('SIGTERM');
+      } catch {
+        // Ignore kill errors
+      }
+    }
+    printLaneStatus(lanes, laneRunDirs);
+    process.exit(130);
+  };
+  
+  process.on('SIGINT', sigIntHandler);
+  process.on('SIGTERM', sigIntHandler);
+  
+  let lastStallCheck = Date.now();
+  
+  try {
+    while (completedLanes.size + failedLanes.size + blockedLanes.size < lanes.length || (blockedLanes.size > 0 && running.size === 0)) {
     // 1. Identify lanes ready to start
     const readyToStart = lanes.filter(lane => {
       // Not already running or completed or failed or blocked
@@ -692,6 +733,23 @@ export async function orchestrate(tasksDir: string, options: {
       
       logger.info(`Lane started: ${lane.name}${lane.startIndex ? ` (resuming from ${lane.startIndex})` : ''}`);
       
+      const now = Date.now();
+      // Pre-register lane in running map so onActivity can find it immediately
+      running.set(lane.name, {
+        child: {} as any, // Placeholder, will be replaced below
+        logManager: undefined,
+        logPath: '',
+        lastActivity: now,
+        lastStateUpdate: now,
+        stallPhase: 0,
+        taskStartTime: now,
+        lastOutput: '',
+        statePath: laneStatePath,
+        bytesReceived: 0,
+        lastBytesCheck: 0,
+        continueSignalsSent: 0,
+      });
+
       let lastOutput = '';
       const spawnResult = spawnLane({
         laneName: lane.name,
@@ -706,44 +764,45 @@ export async function orchestrate(tasksDir: string, options: {
         onActivity: () => {
           const info = running.get(lane.name);
           if (info) {
-            const now = Date.now();
-            info.lastActivity = now;
-            // Also reset progress tracking when there's activity (THNK/TOOL events)
-            // This prevents STALL_NO_PROGRESS from firing when agent is actively working
-            info.lastStateUpdate = now;
-            info.stallPhase = 0; // Reset stall phase since agent is responding
+            const actNow = Date.now();
+            info.lastActivity = actNow;
+            info.lastStateUpdate = actNow;
+            info.stallPhase = 0;
           }
         }
       });
       
+      // Update with actual spawn result
+      const existingInfo = running.get(lane.name)!;
+      Object.assign(existingInfo, spawnResult);
+      
       // Track last output and bytes received for long operation and stall detection
       if (spawnResult.child.stdout) {
         spawnResult.child.stdout.on('data', (data: Buffer) => {
           const info = running.get(lane.name);
           if (info) {
-            info.lastOutput = data.toString().trim().split('\n').pop() || '';
-            info.bytesReceived += data.length;
+            const output = data.toString();
+            const lines = output.split('\n').filter(l => l.trim());
+            
+            // Filter out heartbeats from activity tracking to avoid resetting stall detection
+            const realLines = lines.filter(line => !(line.includes('Heartbeat') && line.includes('bytes received')));
             
-            // Update auto-recovery manager
-            autoRecoveryManager.recordActivity(lane.name, data.length, info.lastOutput);
+            if (realLines.length > 0) {
+              // Real activity detected
+              const lastRealLine = realLines[realLines.length - 1]!;
+              info.lastOutput = lastRealLine;
+              info.bytesReceived += data.length;
+              
+              // Update auto-recovery manager with real activity
+              autoRecoveryManager.recordActivity(lane.name, data.length, info.lastOutput);
+            } else if (lines.length > 0) {
+              // Only heartbeats received - update auto-recovery manager with 0 bytes to avoid resetting idle timer
+              autoRecoveryManager.recordActivity(lane.name, 0, info.lastOutput);
+            }
           }
         });
       }
       
-      const now = Date.now();
-      running.set(lane.name, {
-        ...spawnResult,
-        lastActivity: now,
-        lastStateUpdate: now,
-        stallPhase: 0,
-        taskStartTime: now,
-        lastOutput: '',
-        statePath: laneStatePath,
-        bytesReceived: 0,
-        lastBytesCheck: 0,
-        continueSignalsSent: 0,
-      });
-      
       // Register lane with auto-recovery manager
       autoRecoveryManager.registerLane(lane.name);
       
@@ -773,13 +832,19 @@ export async function orchestrate(tasksDir: string, options: {
       const result = await Promise.race([...promises, pollPromise]);
       if (pollTimeout) clearTimeout(pollTimeout);
       
-      if (result.name === '__poll__') {
+      const now = Date.now();
+      if (result.name === '__poll__' || (now - lastStallCheck >= 10000)) {
+        lastStallCheck = now;
+        
         // Periodic stall check with multi-layer detection and escalating recovery
         for (const [laneName, info] of running.entries()) {
-          const now = Date.now();
           const idleTime = now - info.lastActivity;
           const lane = lanes.find(l => l.name === laneName)!;
           
+          if (process.env['DEBUG_STALL']) {
+            logger.debug(`[${laneName}] Stall check: idle=${Math.round(idleTime/1000)}s, bytesDelta=${info.bytesReceived - info.lastBytesCheck}, phase=${info.stallPhase}`);
+          }
+
           // Check state file for progress updates
           let progressTime = 0;
           try {
@@ -1002,74 +1067,98 @@ export async function orchestrate(tasksDir: string, options: {
           }
         }
         continue;
-      }
-
-      const finished = result;
-      const info = running.get(finished.name)!;
-      running.delete(finished.name);
-      exitCodes[finished.name] = finished.code;
-      
-      // Unregister from auto-recovery manager
-      autoRecoveryManager.unregisterLane(finished.name);
-      
-      if (finished.code === 0) {
-        completedLanes.add(finished.name);
-        events.emit('lane.completed', {
-          laneName: finished.name,
-          exitCode: finished.code,
-        });
-      } else if (finished.code === 2) {
-        // Blocked by dependency
-        const statePath = safeJoin(laneRunDirs[finished.name]!, 'state.json');
-        const state = loadState<LaneState>(statePath);
+      } else {
+        const finished = result;
+        const info = running.get(finished.name)!;
+        running.delete(finished.name);
+        exitCodes[finished.name] = finished.code;
         
-        if (state && state.dependencyRequest) {
-          blockedLanes.set(finished.name, state.dependencyRequest);
-          const lane = lanes.find(l => l.name === finished.name);
-          if (lane) {
-            lane.startIndex = Math.max(0, state.currentTaskIndex - 1); // Task was blocked, retry it
-          }
-          
-          events.emit('lane.blocked', {
+        // Unregister from auto-recovery manager
+        autoRecoveryManager.unregisterLane(finished.name);
+        
+        if (finished.code === 0) {
+          completedLanes.add(finished.name);
+          events.emit('lane.completed', {
             laneName: finished.name,
-            dependencyRequest: state.dependencyRequest,
+            exitCode: finished.code,
           });
-          logger.warn(`Lane ${finished.name} is blocked on dependency change request`);
-        } else {
-          failedLanes.add(finished.name);
-          logger.error(`Lane ${finished.name} exited with code 2 but no dependency request found`);
-        }
-      } else {
-        // Check if it was a restart request
-        if (info.stallPhase === 2) {
-          logger.info(`🔄 Lane ${finished.name} is being restarted due to stall...`);
-          
-          // Update startIndex from current state to resume from the same task
+        } else if (finished.code === 2) {
+          // Blocked by dependency
           const statePath = safeJoin(laneRunDirs[finished.name]!, 'state.json');
           const state = loadState<LaneState>(statePath);
-          if (state) {
+          
+          if (state && state.dependencyRequest) {
+            blockedLanes.set(finished.name, state.dependencyRequest);
             const lane = lanes.find(l => l.name === finished.name);
             if (lane) {
-              lane.startIndex = state.currentTaskIndex;
+              lane.startIndex = Math.max(0, state.currentTaskIndex - 1); // Task was blocked, retry it
             }
+            
+            events.emit('lane.blocked', {
+              laneName: finished.name,
+              dependencyRequest: state.dependencyRequest,
+            });
+            logger.warn(`Lane ${finished.name} is blocked on dependency change request`);
+          } else {
+            failedLanes.add(finished.name);
+            logger.error(`Lane ${finished.name} exited with code 2 but no dependency request found`);
           }
+        } else {
+          // Check if it was a restart request
+          if (info.stallPhase === 2) {
+            logger.info(`🔄 Lane ${finished.name} is being restarted due to stall...`);
+            
+            // Update startIndex from current state to resume from the same task
+            const statePath = safeJoin(laneRunDirs[finished.name]!, 'state.json');
+            const state = loadState<LaneState>(statePath);
+            if (state) {
+              const lane = lanes.find(l => l.name === finished.name);
+              if (lane) {
+                lane.startIndex = state.currentTaskIndex;
+              }
+            }
+            
+            // Note: we don't add to failedLanes or completedLanes, 
+            // so it will be eligible to start again in the next iteration.
+            continue; 
+          }
+
+          failedLanes.add(finished.name);
           
-          // Note: we don't add to failedLanes or completedLanes, 
-          // so it will be eligible to start again in the next iteration.
-          continue; 
-        }
+          let errorMsg = 'Process exited with non-zero code';
+          if (info.stallPhase === 3) {
+            errorMsg = 'Stopped due to repeated stall';
+          } else if (info.logManager) {
+            const lastError = info.logManager.getLastError();
+            if (lastError) {
+              errorMsg = `Process failed: ${lastError}`;
+            }
+          }
 
-        failedLanes.add(finished.name);
-        events.emit('lane.failed', {
-          laneName: finished.name,
-          exitCode: finished.code,
-          error: info.stallPhase === 3 ? 'Stopped due to repeated stall' : 'Process exited with non-zero code',
-        });
+          logger.error(`[${finished.name}] Lane failed with exit code ${finished.code}: ${errorMsg}`);
+          
+          // Log log tail for visibility
+          if (info.logPath) {
+            logFileTail(info.logPath, 15);
+          }
+
+          events.emit('lane.failed', {
+            laneName: finished.name,
+            exitCode: finished.code,
+            error: errorMsg,
+          });
+        }
+        
+        printLaneStatus(lanes, laneRunDirs);
       }
-      
-      printLaneStatus(lanes, laneRunDirs);
     } else {
       // Nothing running. Are we blocked?
+      
+      // Wait a bit to avoid busy-spin while waiting for dependencies or new slots
+      if (completedLanes.size + failedLanes.size + blockedLanes.size < lanes.length) {
+        await new Promise(resolve => setTimeout(resolve, 2000));
+      }
+
       if (blockedLanes.size > 0 && autoResolve) {
         logger.section('🛠 Auto-Resolving Dependencies');
         
@@ -1098,10 +1187,14 @@ export async function orchestrate(tasksDir: string, options: {
         // All finished
         break;
       }
+      }
     }
+  } finally {
+    clearInterval(monitorInterval);
+    process.removeListener('SIGINT', sigIntHandler);
+    process.removeListener('SIGTERM', sigIntHandler);
   }
   
-  clearInterval(monitorInterval);
   printLaneStatus(lanes, laneRunDirs);
   
   // Check for failures

package/src/utils/config.ts

@@ -6,6 +6,7 @@
 
 import * as path from 'path';
 import * as fs from 'fs';
+import * as git from './git';
 import { CursorFlowConfig } from './types';
 import { safeJoin } from './path';
 export { CursorFlowConfig };
@@ -167,6 +168,7 @@ export function validateConfig(config: CursorFlowConfig): boolean {
  */
 export function createDefaultConfig(projectRoot: string, force = false): string {
   const configPath = safeJoin(projectRoot, 'cursorflow.config.js');
+  const currentBranch = git.getCurrentBranch() || 'main';
   
   const template = `module.exports = {
   // Directory configuration
@@ -175,7 +177,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   pofDir: '_cursorflow/pof',
   
   // Git configuration
-  baseBranch: git.getCurrentBranch() || 'main',
+  baseBranch: '${currentBranch}',
   branchPrefix: 'feature/',
   
   // Execution configuration

package/src/utils/enhanced-logger.ts

@@ -1024,7 +1024,7 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Close all log files
+   * Close all log files and ensure all data is flushed to disk
    */
   public close(): void {
     // Flush transform stream
@@ -1051,46 +1051,87 @@ export class EnhancedLogManager {
 `;
     
     if (this.cleanLogFd !== null) {
-      fs.writeSync(this.cleanLogFd, endMarker);
-      fs.closeSync(this.cleanLogFd);
+      try {
+        fs.writeSync(this.cleanLogFd, endMarker);
+        fs.fsyncSync(this.cleanLogFd);
+        fs.closeSync(this.cleanLogFd);
+      } catch {}
       this.cleanLogFd = null;
     }
     
     if (this.rawLogFd !== null) {
-      fs.writeSync(this.rawLogFd, endMarker);
-      fs.closeSync(this.rawLogFd);
+      try {
+        fs.writeSync(this.rawLogFd, endMarker);
+        fs.fsyncSync(this.rawLogFd);
+        fs.closeSync(this.rawLogFd);
+      } catch {}
       this.rawLogFd = null;
     }
     
     if (this.absoluteRawLogFd !== null) {
-      fs.closeSync(this.absoluteRawLogFd);
+      try {
+        fs.fsyncSync(this.absoluteRawLogFd);
+        fs.closeSync(this.absoluteRawLogFd);
+      } catch {}
       this.absoluteRawLogFd = null;
     }
     
     if (this.jsonLogFd !== null) {
-      this.writeJsonEntry({
-        timestamp: new Date().toISOString(),
-        level: 'session',
-        source: 'system',
-        lane: this.session.laneName,
-        message: 'Session ended',
-        metadata: {
-          sessionId: this.session.id,
-          duration: Date.now() - this.session.startTime,
-        },
-      });
-      fs.closeSync(this.jsonLogFd);
+      try {
+        this.writeJsonEntry({
+          timestamp: new Date().toISOString(),
+          level: 'session',
+          source: 'system',
+          lane: this.session.laneName,
+          message: 'Session ended',
+          metadata: {
+            sessionId: this.session.id,
+            duration: Date.now() - this.session.startTime,
+          },
+        });
+        fs.fsyncSync(this.jsonLogFd);
+        fs.closeSync(this.jsonLogFd);
+      } catch {}
       this.jsonLogFd = null;
     }
     
     // Close readable log
     if (this.readableLogFd !== null) {
-      fs.writeSync(this.readableLogFd, endMarker);
-      fs.closeSync(this.readableLogFd);
+      try {
+        fs.writeSync(this.readableLogFd, endMarker);
+        fs.fsyncSync(this.readableLogFd);
+        fs.closeSync(this.readableLogFd);
+      } catch {}
       this.readableLogFd = null;
     }
   }
 
+  /**
+   * Extract the last error message from the clean log file
+   */
+  public getLastError(): string | null {
+    try {
+      if (!fs.existsSync(this.cleanLogPath)) return null;
+      const content = fs.readFileSync(this.cleanLogPath, 'utf8');
+      // Look for lines containing error markers
+      const lines = content.split('\n').filter(l => 
+        l.includes('[ERROR]') || 
+        l.includes('❌') || 
+        l.includes('error:') || 
+        l.includes('Fatal') ||
+        l.includes('fail')
+      );
+      if (lines.length === 0) {
+        // Fallback to last 5 lines if no specific error marker found
+        const allLines = content.split('\n').filter(l => l.trim());
+        return allLines.slice(-5).join('\n');
+      }
+      return lines[lines.length - 1]!.trim();
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Format duration for display
    */