@litmers/cursorflow-orchestrator 0.1.37 → 0.1.40

package/src/cli/resume.ts

@@ -29,7 +29,6 @@ interface ResumeOptions {
   status: boolean;
   maxConcurrent: number;
   help: boolean;
-  noGit: boolean;
   executor: string | null;
 }
 
@@ -48,7 +47,6 @@ Options:
   --clean                Clean up existing worktree before resuming
   --restart              Restart from the first task (index 0)
   --skip-doctor          Skip environment/branch checks (not recommended)
-  --no-git               Disable Git operations (must match original run)
   --executor <type>      Override executor (default: cursor-agent)
   --help, -h             Show help
 
@@ -56,7 +54,7 @@ Examples:
   cursorflow resume --status                 # Check status of all lanes
   cursorflow resume --all                    # Resume all incomplete lanes
   cursorflow resume lane-1                   # Resume single lane
-  cursorflow resume _cursorflow/tasks/feat1  # Resume all lanes in directory
+  cursorflow resume _cursorflow/flows/MyFeature  # Resume all lanes in flow
   cursorflow resume --all --restart          # Restart all incomplete lanes from task 0
   `);
 }
@@ -76,7 +74,6 @@ function parseArgs(args: string[]): ResumeOptions {
     status: args.includes('--status'),
     maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '3') : 3,
     help: args.includes('--help') || args.includes('-h'),
-    noGit: args.includes('--no-git'),
     executor: executorIdx >= 0 ? args[executorIdx + 1] || null : null,
   };
 }
@@ -397,10 +394,10 @@ function spawnLaneResume(
   state: LaneState,
   options: { 
     restart: boolean;
-    noGit?: boolean;
     pipelineBranch?: string;
     executor?: string | null;
     enhancedLogConfig?: any;
+    laneIndex?: number;
   }
 ): { child: ChildProcess; logManager: EnhancedLogManager } {
   const runnerPath = require.resolve('../core/runner');
@@ -417,10 +414,6 @@ function spawnLaneResume(
     runnerArgs.push('--worktree-dir', state.worktreeDir);
   }
 
-  if (options.noGit) {
-    runnerArgs.push('--no-git');
-  }
-
   // Explicitly pass pipeline branch if available (either from state or override)
   const branch = options.pipelineBranch || state.pipelineBranch;
   if (branch) {
@@ -432,16 +425,26 @@ function spawnLaneResume(
     runnerArgs.push('--executor', options.executor);
   }
 
-  const shortLaneName = laneName.substring(0, 10);
+  // Generate lane label: [laneIdx-taskIdx-laneName] format, padded to 18 chars
+  // Note: taskName will be updated dynamically via logManager.setTask()
+  let currentTaskName = '';
+  let currentTaskIdx = (state.currentTaskIndex ?? 0) + 1;
+  const getLaneLabel = () => {
+    const laneIdx = options.laneIndex ?? 1;
+    const combined = `${laneIdx}-${currentTaskIdx}-${laneName}`;
+    const label = combined.substring(0, 18).padEnd(18);
+    return `[${label}]`;
+  };
+  
   const logManager = createLogManager(laneDir, laneName, options.enhancedLogConfig || {}, (msg) => {
     const formatted = formatMessageForConsole(msg, { 
-      laneLabel: `[${shortLaneName}]`,
+      laneLabel: getLaneLabel(),
       includeTimestamp: true 
     });
     process.stdout.write(formatted + '\n');
-  });
+  }, options.laneIndex);
   
-  const child = spawn('node', runnerArgs, {
+  const child = spawn(process.execPath, runnerArgs, {
     stdio: ['ignore', 'pipe', 'pipe'],
     env: process.env,
   });
@@ -489,7 +492,6 @@ async function resumeLanes(
     restart: boolean; 
     maxConcurrent: number; 
     skipDoctor: boolean; 
-    noGit: boolean;
     executor: string | null;
     enhancedLogConfig?: any;
   }
@@ -547,6 +549,8 @@ async function resumeLanes(
   const pending = new Set<string>(resolvableLanes.map(l => l.name));
   const active: Map<string, ChildProcess> = new Map();
   const laneMap = new Map<string, LaneInfo>(resolvableLanes.map(l => [l.name, l]));
+  // Track lane indices for consistent logging
+  const laneIndexMap = new Map<string, number>(allLanes.map((l, i) => [l.name, i + 1]));
   
   const findReadyLane = (): LaneInfo | null => {
     for (const laneName of pending) {
@@ -558,7 +562,7 @@ async function resumeLanes(
     return null;
   };
   
-  const processNext = (): void => {
+  const processNext = async (): Promise<void> => {
     while (active.size < options.maxConcurrent) {
       const lane = findReadyLane();
       if (!lane) {
@@ -572,13 +576,19 @@ async function resumeLanes(
       }
       
       pending.delete(lane.name);
+      
+      // Add a small delay between starting lanes to reduce initial resource contention
+      if (active.size > 0) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+      }
+      
       logger.info(`Starting: ${lane.name} (task ${lane.state!.currentTaskIndex}/${lane.state!.totalTasks})`);
       
       const { child } = spawnLaneResume(lane.name, lane.dir, lane.state!, {
         restart: options.restart,
-        noGit: options.noGit,
         executor: options.executor,
         enhancedLogConfig: options.enhancedLogConfig,
+        laneIndex: laneIndexMap.get(lane.name) ?? 1,
       });
       
       active.set(lane.name, child);
@@ -606,12 +616,12 @@ async function resumeLanes(
     }
   };
   
-  processNext();
+  await processNext();
   
   while (active.size > 0 || pending.size > 0) {
     await new Promise(resolve => setTimeout(resolve, 1000));
     if (active.size < options.maxConcurrent && pending.size > 0) {
-      processNext();
+      await processNext();
     }
   }
   
@@ -725,7 +735,6 @@ async function resume(args: string[]): Promise<void> {
     restart: options.restart,
     maxConcurrent: options.maxConcurrent,
     skipDoctor: options.skipDoctor,
-    noGit: options.noGit,
     executor: options.executor,
     enhancedLogConfig: config.enhancedLogging,
   });

package/src/cli/run.ts

@@ -118,7 +118,6 @@ interface RunOptions {
   maxConcurrent: number | null;
   skipDoctor: boolean;
   skipPreflight: boolean;
-  noGit: boolean;
   raw: boolean;
   help: boolean;
 }
@@ -138,14 +137,13 @@ Options:
   --executor <type>      cursor-agent | cloud
   --skip-doctor          Skip environment checks (not recommended)
   --skip-preflight       Skip preflight checks (Git remote, etc.)
-  --no-git               Disable Git operations (worktree, push, commit)
   --raw                  Save raw logs (absolute raw, no processing)
   --dry-run              Show execution plan without starting agents
   --help, -h             Show help
 
 Examples:
   cursorflow run _cursorflow/tasks
-  cursorflow run _cursorflow/tasks --no-git --skip-doctor
+  cursorflow run _cursorflow/flows/MyFeature
   `);
 }
 
@@ -161,7 +159,6 @@ function parseArgs(args: string[]): RunOptions {
     maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '0') || null : null,
     skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
     skipPreflight: args.includes('--skip-preflight'),
-    noGit: args.includes('--no-git'),
     raw: args.includes('--raw'),
     help: args.includes('--help') || args.includes('-h'),
   };
@@ -260,7 +257,6 @@ async function run(args: string[]): Promise<void> {
     
     if (options.skipDoctor) resumeArgs.push('--skip-doctor');
     if (options.skipPreflight) resumeArgs.push('--skip-preflight');
-    if (options.noGit) resumeArgs.push('--no-git');
     if (options.executor) {
       resumeArgs.push('--executor', options.executor);
     }
@@ -321,7 +317,6 @@ async function run(args: string[]): Promise<void> {
         ...config.enhancedLogging,
         ...(options.raw ? { raw: true } : {}),
       },
-      noGit: options.noGit,
       skipPreflight: options.skipPreflight,
     });
   } catch (error: any) {

package/src/cli/setup-commands.ts

@@ -202,7 +202,7 @@ export function areCommandsInstalled(): boolean {
   return sourceFiles.every(f => targetFiles.includes(f));
 }
 
-async function main(args: string[]): Promise<any> {
+export async function main(args: string[]): Promise<any> {
   const options = parseArgs(args);
   
   try {

package/src/core/orchestrator.ts

@@ -278,12 +278,13 @@ export function spawnLane({
   };
   
   if (logConfig.enabled) {
-    // Helper to get dynamic lane label like [L1-T1-lanename10]
+    // Helper to get dynamic lane label like [1-1-lanename10]
     const getDynamicLabel = () => {
-      const laneNum = `L${laneIndex + 1}`;
-      const taskPart = info.currentTaskIndex ? `-T${info.currentTaskIndex}` : '';
+      const laneNum = `${laneIndex + 1}`;
+      const taskPart = `-${info.currentTaskIndex || 1}`;
       const shortLaneName = laneName.substring(0, 10);
-      return `[${laneNum}${taskPart}-${shortLaneName}]`;
+      const combined = `${laneNum}${taskPart}-${shortLaneName}`.substring(0, 18).padEnd(18);
+      return `[${combined}]`;
     };
 
     // Create callback for clean console output
@@ -838,8 +839,10 @@ export async function orchestrate(tasksDir: string, options: {
       const now = Date.now();
       
       // Register lane with unified stall detection service FIRST
+      // Pass intervention capability so stall service knows if continue signals will work
       stallService.registerLane(lane.name, {
         laneRunDir: laneRunDirs[lane.name]!,
+        interventionEnabled: config.enableIntervention ?? true,
       });
       
       const laneIdx = lanes.findIndex(l => l.name === lane.name);
@@ -931,13 +934,19 @@ export async function orchestrate(tasksDir: string, options: {
         for (const [laneName, info] of running.entries()) {
           const lane = lanes.find(l => l.name === laneName)!;
           
-          // Check state file for progress updates
+          // Check state file for progress updates and sync lane status
           try {
             const stateStat = fs.statSync(info.statePath);
             const stallState = stallService.getState(laneName);
             if (stallState && stateStat.mtimeMs > stallState.lastStateUpdateTime) {
               stallService.recordStateUpdate(laneName);
             }
+            
+            // Sync lane status to stall service (skips stall detection when 'waiting' for dependencies)
+            const laneState = loadState<LaneState>(info.statePath);
+            if (laneState && stallState && laneState.status !== stallState.laneStatus) {
+              stallService.setLaneStatus(laneName, laneState.status || 'running');
+            }
           } catch {
             // State file might not exist yet
           }

package/src/core/runner/agent.ts

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from 'child_process';
+import { spawn, spawnSync, ChildProcess } from 'child_process';
 import * as logger from '../../utils/logger';
 import { AgentSendResult, DependencyRequestPlan } from '../../types';
 import { withRetry } from '../failure-policy';
@@ -6,6 +6,30 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { appendLog, createConversationEntry } from '../../utils/state';
 
+/**
+ * Track active child processes for cleanup
+ */
+const activeChildren = new Set<ChildProcess>();
+
+/**
+ * Cleanup all active children
+ */
+export function cleanupAgentChildren(): void {
+  if (activeChildren.size > 0) {
+    logger.warn(`Cleaning up ${activeChildren.size} active agent child processes...`);
+    for (const child of activeChildren) {
+      if (!child.killed) {
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // Ignore
+        }
+      }
+    }
+    activeChildren.clear();
+  }
+}
+
 /**
  * Execute cursor-agent command with timeout and better error handling
  */
@@ -115,7 +139,7 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
   signalDir?: string;
   timeout?: number;
   enableIntervention?: boolean;
-  outputFormat?: 'json' | 'plain';
+  outputFormat?: 'json' | 'plain' | 'stream-json';
   taskName?: string;
 }): Promise<AgentSendResult> {
   const timeoutMs = timeout || 10 * 60 * 1000; // 10 minutes default
@@ -125,7 +149,7 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
     args.push('--model', model);
   }
   
-  if (outputFormat === 'json') {
+  if (outputFormat === 'json' || outputFormat === 'stream-json') {
     args.push('--print', '--output-format', 'json');
   }
 
@@ -145,6 +169,12 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
       stdio: enableIntervention ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
     });
 
+    activeChildren.add(child);
+
+    if (!enableIntervention) {
+      logger.info('ℹ️ Intervention is disabled. Stall recovery using "continue" will not be available for this agent session.');
+    }
+
     let fullStdout = '';
     let fullStderr = '';
     let timeoutHandle: NodeJS.Timeout;
@@ -235,6 +265,7 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
     }, timeoutMs);
 
     child.on('close', (code) => {
+      activeChildren.delete(child);
       clearTimeout(timeoutHandle);
       clearInterval(heartbeatInterval);
       if (signalWatcher) signalWatcher.close();
@@ -255,6 +286,7 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
     });
 
     child.on('error', (err) => {
+      activeChildren.delete(child);
       clearTimeout(timeoutHandle);
       if (signalWatcher) signalWatcher.close();
       resolve({ ok: false, exitCode: -1, error: `Failed to start cursor-agent: ${err.message}` });
@@ -273,7 +305,7 @@ export async function cursorAgentSend(options: {
   signalDir?: string;
   timeout?: number;
   enableIntervention?: boolean;
-  outputFormat?: 'json' | 'plain';
+  outputFormat?: 'json' | 'plain' | 'stream-json';
   taskName?: string;
 }): Promise<AgentSendResult> {
   const laneName = options.signalDir ? path.basename(path.dirname(options.signalDir)) : 'agent';