@litmers/cursorflow-orchestrator 0.1.15 → 0.1.20

package/src/cli/run.ts

@@ -9,6 +9,7 @@ import { orchestrate } from '../core/orchestrator';
 import { getLogsDir, loadConfig } from '../utils/config';
 import { runDoctor, getDoctorStatus } from '../utils/doctor';
 import { areCommandsInstalled, setupCommands } from './setup-commands';
+import { safeJoin } from '../utils/path';
 
 interface RunOptions {
   tasksDir?: string;
@@ -90,8 +91,8 @@ async function run(args: string[]): Promise<void> {
     path.isAbsolute(options.tasksDir)
       ? options.tasksDir
       : (fs.existsSync(options.tasksDir)
-        ? path.resolve(process.cwd(), options.tasksDir)
-        : path.join(config.projectRoot, options.tasksDir));
+        ? path.resolve(process.cwd(), options.tasksDir) // nosemgrep
+        : safeJoin(config.projectRoot, options.tasksDir));
 
   if (!fs.existsSync(tasksDir)) {
     throw new Error(`Tasks directory not found: ${tasksDir}`);

package/src/cli/signal.ts

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as logger from '../utils/logger';
 import { loadConfig, getLogsDir } from '../utils/config';
 import { appendLog, createConversationEntry } from '../utils/state';
+import { safeJoin } from '../utils/path';
 
 interface SignalOptions {
   lane: string | null;
@@ -51,7 +52,7 @@ function parseArgs(args: string[]): SignalOptions {
 }
 
 function findLatestRunDir(logsDir: string): string | null {
-  const runsDir = path.join(logsDir, 'runs');
+  const runsDir = safeJoin(logsDir, 'runs');
   if (!fs.existsSync(runsDir)) return null;
   
   const runs = fs.readdirSync(runsDir)
@@ -59,7 +60,7 @@ function findLatestRunDir(logsDir: string): string | null {
     .sort()
     .reverse();
     
-  return runs.length > 0 ? path.join(runsDir, runs[0]!) : null;
+  return runs.length > 0 ? safeJoin(runsDir, runs[0]!) : null;
 }
 
 async function signal(args: string[]): Promise<void> {
@@ -86,14 +87,14 @@ async function signal(args: string[]): Promise<void> {
     throw new Error(`Run directory not found: ${runDir || 'latest'}`);
   }
 
-  const laneDir = path.join(runDir, 'lanes', options.lane);
+  const laneDir = safeJoin(runDir, 'lanes', options.lane);
   if (!fs.existsSync(laneDir)) {
     throw new Error(`Lane directory not found: ${laneDir}`);
   }
 
   // Case 1: Timeout update
   if (options.timeout !== null) {
-    const timeoutPath = path.join(laneDir, 'timeout.txt');
+    const timeoutPath = safeJoin(laneDir, 'timeout.txt');
     fs.writeFileSync(timeoutPath, String(options.timeout));
     logger.success(`Timeout update signal sent to ${options.lane}: ${options.timeout}ms`);
     return;
@@ -101,8 +102,8 @@ async function signal(args: string[]): Promise<void> {
 
   // Case 2: Intervention message
   if (options.message) {
-    const interventionPath = path.join(laneDir, 'intervention.txt');
-    const convoPath = path.join(laneDir, 'conversation.jsonl');
+    const interventionPath = safeJoin(laneDir, 'intervention.txt');
+    const convoPath = safeJoin(laneDir, 'conversation.jsonl');
     
     logger.info(`Sending signal to lane: ${options.lane}`);
     logger.info(`Message: "${options.message}"`);

package/src/core/orchestrator.ts

@@ -9,13 +9,14 @@ import * as path from 'path';
 import { spawn, ChildProcess } from 'child_process';
 
 import * as logger from '../utils/logger';
-import { loadState } from '../utils/state';
+import { loadState, saveState, createLaneState } from '../utils/state';
 import { LaneState, RunnerConfig, WebhookConfig, DependencyRequestPlan, EnhancedLogConfig } from '../utils/types';
 import { events } from '../utils/events';
 import { registerWebhooks } from '../utils/webhook';
 import { loadConfig, getLogsDir } from '../utils/config';
 import * as git from '../utils/git';
 import { execSync } from 'child_process';
+import { safeJoin } from '../utils/path';
 import { 
   EnhancedLogManager, 
   createLogManager, 
@@ -23,6 +24,7 @@ import {
   ParsedMessage,
   stripAnsi
 } from '../utils/enhanced-logger';
+import { formatMessageForConsole } from '../utils/log-formatter';
 
 export interface LaneInfo {
   name: string;
@@ -47,6 +49,7 @@ export function spawnLane({
   executor, 
   startIndex = 0, 
   pipelineBranch,
+  worktreeDir,
   enhancedLogConfig,
   noGit = false,
 }: { 
@@ -56,6 +59,7 @@ export function spawnLane({
   executor: string; 
   startIndex?: number;
   pipelineBranch?: string;
+  worktreeDir?: string;
   enhancedLogConfig?: Partial<EnhancedLogConfig>;
   noGit?: boolean;
 }): SpawnLaneResult {
@@ -75,6 +79,10 @@ export function spawnLane({
   if (pipelineBranch) {
     args.push('--pipeline-branch', pipelineBranch);
   }
+
+  if (worktreeDir) {
+    args.push('--worktree-dir', worktreeDir);
+  }
   
   if (noGit) {
     args.push('--no-git');
@@ -94,82 +102,11 @@ export function spawnLane({
   if (logConfig.enabled) {
     // Create callback for clean console output
     const onParsedMessage = (msg: ParsedMessage) => {
-      // Print a clean, colored version of the message to the console
-      const ts = new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false });
-      const laneLabel = `[${laneName}]`.padEnd(12);
-      
-      let prefix = '';
-      let content = msg.content;
-      
-      switch (msg.type) {
-        case 'user':
-          prefix = `${logger.COLORS.cyan}🧑 USER${logger.COLORS.reset}`;
-          // No truncation for user prompt to ensure full command visibility
-          content = content.replace(/\n/g, ' ');
-          break;
-        case 'assistant':
-          prefix = `${logger.COLORS.green}🤖 ASST${logger.COLORS.reset}`;
-          break;
-        case 'tool':
-          prefix = `${logger.COLORS.yellow}🔧 TOOL${logger.COLORS.reset}`;
-          // Simplify tool call: [Tool: read_file] {"target_file":"..."} -> read_file(target_file: ...)
-          const toolMatch = content.match(/\[Tool: ([^\]]+)\] (.*)/);
-          if (toolMatch) {
-            const [, name, args] = toolMatch;
-            try {
-              const parsedArgs = JSON.parse(args!);
-              let argStr = '';
-              
-              if (name === 'read_file' && parsedArgs.target_file) {
-                argStr = parsedArgs.target_file;
-              } else if (name === 'run_terminal_cmd' && parsedArgs.command) {
-                argStr = parsedArgs.command;
-              } else if (name === 'write' && parsedArgs.file_path) {
-                argStr = parsedArgs.file_path;
-              } else if (name === 'search_replace' && parsedArgs.file_path) {
-                argStr = parsedArgs.file_path;
-              } else {
-                // Generic summary for other tools
-                const keys = Object.keys(parsedArgs);
-                if (keys.length > 0) {
-                  argStr = String(parsedArgs[keys[0]]).substring(0, 50);
-                }
-              }
-              content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}(${argStr})`;
-            } catch {
-              content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}: ${args}`;
-            }
-          }
-          break;
-        case 'tool_result':
-          prefix = `${logger.COLORS.gray}📄 RESL${logger.COLORS.reset}`;
-          // Simplify tool result: [Tool Result: read_file] ... -> read_file OK
-          const resMatch = content.match(/\[Tool Result: ([^\]]+)\]/);
-          content = resMatch ? `${resMatch[1]} OK` : 'result';
-          break;
-        case 'result':
-          prefix = `${logger.COLORS.green}✅ DONE${logger.COLORS.reset}`;
-          break;
-        case 'system':
-          prefix = `${logger.COLORS.gray}⚙️  SYS${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') {
-          const header = `${prefix} ┌${'─'.repeat(60)}`;
-          process.stdout.write(`${tsPrefix} ${header}\n`);
-          for (const line of lines) {
-            process.stdout.write(`${tsPrefix} ${' '.repeat(stripAnsi(prefix).length)} │ ${line}\n`);
-          }
-          process.stdout.write(`${tsPrefix} ${' '.repeat(stripAnsi(prefix).length)} └${'─'.repeat(60)}\n`);
-        } else {
-          process.stdout.write(`${tsPrefix} ${prefix} ${content}\n`);
-        }
-      }
+      const formatted = formatMessageForConsole(msg, { 
+        laneLabel: `[${laneName}]`,
+        includeTimestamp: true 
+      });
+      process.stdout.write(formatted + '\n');
     };
 
     logManager = createLogManager(laneRunDir, laneName, logConfig, onParsedMessage);
@@ -202,8 +139,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`);
           }
         }
@@ -240,7 +176,7 @@ export function spawnLane({
     });
   } else {
     // Fallback to simple file logging
-    logPath = path.join(laneRunDir, 'terminal.log');
+    logPath = safeJoin(laneRunDir, 'terminal.log');
     const logFd = fs.openSync(logPath, 'a');
     
     child = spawn('node', args, {
@@ -287,7 +223,7 @@ export function listLaneFiles(tasksDir: string): LaneInfo[] {
     .filter(f => f.endsWith('.json'))
     .sort()
     .map(f => {
-      const filePath = path.join(tasksDir, f);
+      const filePath = safeJoin(tasksDir, f);
       const name = path.basename(f, '.json');
       let dependsOn: string[] = [];
       
@@ -314,7 +250,7 @@ export function printLaneStatus(lanes: LaneInfo[], laneRunDirs: Record<string, s
     const dir = laneRunDirs[lane.name];
     if (!dir) return { lane: lane.name, status: '(unknown)', task: '-' };
     
-    const statePath = path.join(dir, 'state.json');
+    const statePath = safeJoin(dir, 'state.json');
     const state = loadState<LaneState>(statePath);
     
     if (!state) {
@@ -362,9 +298,9 @@ async function resolveAllDependencies(
 
   // 2. Setup a temporary worktree for resolution if needed, or use the first available one
   const firstLaneName = Array.from(blockedLanes.keys())[0]!;
-  const statePath = path.join(laneRunDirs[firstLaneName]!, 'state.json');
+  const statePath = safeJoin(laneRunDirs[firstLaneName]!, 'state.json');
   const state = loadState<LaneState>(statePath);
-  const worktreeDir = state?.worktreeDir || path.join(runRoot, 'resolution-worktree');
+  const worktreeDir = state?.worktreeDir || safeJoin(runRoot, 'resolution-worktree');
 
   if (!fs.existsSync(worktreeDir)) {
     logger.info(`Creating resolution worktree at ${worktreeDir}`);
@@ -403,7 +339,7 @@ async function resolveAllDependencies(
     const laneDir = laneRunDirs[lane.name];
     if (!laneDir) continue;
 
-    const laneState = loadState<LaneState>(path.join(laneDir, 'state.json'));
+    const laneState = loadState<LaneState>(safeJoin(laneDir, 'state.json'));
     if (!laneState || laneState.status === 'completed' || laneState.status === 'failed') continue;
 
     // Merge pipelineBranch into the lane's current task branch
@@ -412,7 +348,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 {
@@ -462,12 +399,13 @@ export async function orchestrate(tasksDir: string, options: {
   const runId = `run-${Date.now()}`;
   // Use absolute path for runRoot to avoid issues with subfolders
   const runRoot = options.runDir 
-    ? (path.isAbsolute(options.runDir) ? options.runDir : path.resolve(process.cwd(), options.runDir))
-    : path.join(logsDir, 'runs', runId);
+    ? (path.isAbsolute(options.runDir) ? options.runDir : path.resolve(process.cwd(), options.runDir)) // nosemgrep
+    : safeJoin(logsDir, 'runs', runId);
   
   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);
@@ -495,9 +433,45 @@ export async function orchestrate(tasksDir: string, options: {
   }
   
   const laneRunDirs: Record<string, string> = {};
+  const laneWorktreeDirs: Record<string, string> = {};
+  const repoRoot = git.getRepoRoot();
+  
   for (const lane of lanes) {
-    laneRunDirs[lane.name] = path.join(runRoot, 'lanes', lane.name);
-    fs.mkdirSync(laneRunDirs[lane.name], { recursive: true });
+    laneRunDirs[lane.name] = safeJoin(runRoot, 'lanes', lane.name);
+    fs.mkdirSync(laneRunDirs[lane.name]!, { recursive: true });
+    
+    // Create initial state for ALL lanes so resume can find them even if they didn't start
+    try {
+      const taskConfig = JSON.parse(fs.readFileSync(lane.path, 'utf8')) as RunnerConfig;
+      
+      // Calculate unique branch and worktree for this lane
+      const lanePipelineBranch = `${pipelineBranch}/${lane.name}`;
+      
+      // Use a flat worktree directory name to avoid race conditions in parent directory creation
+      // repoRoot/_cursorflow/worktrees/cursorflow-run-xxx-lane-name
+      const laneWorktreeDir = safeJoin(
+        repoRoot, 
+        taskConfig.worktreeRoot || '_cursorflow/worktrees', 
+        lanePipelineBranch.replace(/\//g, '-')
+      );
+      
+      // Ensure the parent directory exists before spawning the runner
+      // to avoid race conditions in git worktree add or fs operations
+      const worktreeParent = path.dirname(laneWorktreeDir);
+      if (!fs.existsSync(worktreeParent)) {
+        fs.mkdirSync(worktreeParent, { recursive: true });
+      }
+      
+      laneWorktreeDirs[lane.name] = laneWorktreeDir;
+      
+      const initialState = createLaneState(lane.name, taskConfig, lane.path, {
+        pipelineBranch: lanePipelineBranch,
+        worktreeDir: laneWorktreeDir
+      });
+      saveState(safeJoin(laneRunDirs[lane.name]!, 'state.json'), initialState);
+    } catch (e) {
+      logger.warn(`Failed to create initial state for lane ${lane.name}: ${e}`);
+    }
   }
   
   logger.section('🧭 Starting Orchestration');
@@ -570,7 +544,8 @@ export async function orchestrate(tasksDir: string, options: {
         laneRunDir: laneRunDirs[lane.name]!,
         executor: options.executor || 'cursor-agent',
         startIndex: lane.startIndex,
-        pipelineBranch,
+        pipelineBranch: `${pipelineBranch}/${lane.name}`,
+        worktreeDir: laneWorktreeDirs[lane.name],
         enhancedLogConfig: options.enhancedLogging,
         noGit: options.noGit,
       });
@@ -603,7 +578,7 @@ export async function orchestrate(tasksDir: string, options: {
         });
       } else if (finished.code === 2) {
         // Blocked by dependency
-        const statePath = path.join(laneRunDirs[finished.name]!, 'state.json');
+        const statePath = safeJoin(laneRunDirs[finished.name]!, 'state.json');
         const state = loadState<LaneState>(statePath);
         
         if (state && state.dependencyRequest) {

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', {