@litmers/cursorflow-orchestrator 0.1.39 → 0.2.2

package/src/core/runner/task.ts

@@ -1,17 +1,12 @@
-import * as fs from 'fs';
 import * as path from 'path';
 import * as git from '../../utils/git';
 import * as logger from '../../utils/logger';
 import { events } from '../../utils/events';
 import { safeJoin } from '../../utils/path';
 import { appendLog, createConversationEntry } from '../../utils/state';
-import { Task, RunnerConfig, TaskExecutionResult, LaneState } from '../../types';
-import { loadState } from '../../utils/state';
+import { Task, RunnerConfig, TaskExecutionResult } from '../../types';
 import { waitForTaskDependencies as waitForDeps, DependencyWaitOptions } from '../../utils/dependency';
-import { 
-  cursorAgentSend, 
-  extractDependencyRequest 
-} from './agent';
+import { extractDependencyRequest } from './agent';
 import { 
   wrapPrompt, 
   applyDependencyFilePermissions 
@@ -23,6 +18,7 @@ import {
   clearDependencyRequestFile,
   DependencyResult
 } from './utils';
+import { AgentSupervisor } from '../agent-supervisor';
 
 /**
  * Wait for task-level dependencies to be completed by other lanes
@@ -56,74 +52,6 @@ export async function waitForTaskDependencies(
   }
 }
 
-/**
- * Merge branches from dependency lanes with safe merge and conflict pre-check
- */
-export async function mergeDependencyBranches(deps: string[], runDir: string, worktreeDir: string, pipelineBranch: string): Promise<void> {
-  if (!deps || deps.length === 0) return;
-
-  const lanesRoot = path.dirname(runDir);
-  const lanesToMerge = new Set(deps.map(d => d.split(':')[0]!));
-
-  // Ensure we are on the pipeline branch before merging dependencies
-  logger.info(`🔄 Syncing with ${pipelineBranch} before merging dependencies`);
-  git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
-
-  for (const laneName of lanesToMerge) {
-    const depStatePath = safeJoin(lanesRoot, laneName, 'state.json');
-    if (!fs.existsSync(depStatePath)) continue;
-
-    try {
-      const state = loadState<LaneState>(depStatePath);
-      if (!state?.pipelineBranch) continue;
-      
-      logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
-      
-      // Ensure we have the latest
-      git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
-      
-      // Pre-check for conflicts before attempting merge
-      const conflictCheck = git.checkMergeConflict(state.pipelineBranch, { cwd: worktreeDir });
-      
-      if (conflictCheck.willConflict) {
-        logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`);
-        logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
-        
-        // Emit event for potential auto-recovery or notification
-        events.emit('merge.conflict_detected', {
-          laneName,
-          targetBranch: state.pipelineBranch,
-          conflictingFiles: conflictCheck.conflictingFiles,
-          preCheck: true,
-        });
-        
-        throw new Error(`Pre-merge conflict check failed: ${conflictCheck.conflictingFiles.join(', ')}. Consider rebasing or resolving conflicts manually.`);
-      }
-      
-      // Use safe merge with conflict detection
-      const mergeResult = git.safeMerge(state.pipelineBranch, {
-        cwd: worktreeDir,
-        noFf: true,
-        message: `chore: merge task dependency from ${laneName}`,
-        abortOnConflict: true,
-      });
-      
-      if (!mergeResult.success) {
-        if (mergeResult.conflict) {
-          logger.error(`Merge conflict with ${laneName}: ${mergeResult.conflictingFiles.join(', ')}`);
-          throw new Error(`Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
-        }
-        throw new Error(mergeResult.error || 'Merge failed');
-      }
-      
-      logger.success(`✓ Merged ${laneName}`);
-    } catch (e) {
-      logger.error(`Failed to merge branch from ${laneName}: ${e}`);
-      throw e;
-    }
-  }
-}
-
 /**
  * Run a single task
  */
@@ -137,6 +65,8 @@ export async function runTask({
   chatId,
   runDir,
   runRoot,
+  agentSupervisor,
+  laneName,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -147,6 +77,8 @@ export async function runTask({
   chatId: string;
   runDir: string;
   runRoot?: string;
+  agentSupervisor: AgentSupervisor;
+  laneName: string;
 }): Promise<TaskExecutionResult> {
   // Calculate runRoot if not provided (runDir is lanes/{laneName}/, runRoot is parent of lanes/)
   const calculatedRunRoot = runRoot || path.dirname(path.dirname(runDir));
@@ -212,32 +144,20 @@ export async function runTask({
   }));
   
   logger.info('Sending prompt to agent...');
-  const startTime = Date.now();
-  events.emit('agent.prompt_sent', {
-    taskName: task.name,
-    model,
-    promptLength: wrappedPrompt.length,
-  });
-
-  const r1 = await cursorAgentSend({
+  const r1 = await agentSupervisor.sendTaskPrompt({
     workspaceDir: worktreeDir,
     chatId,
     prompt: wrappedPrompt,
     model,
+    laneName,
     signalDir: runDir,
     timeout,
     enableIntervention: config.enableIntervention,
     outputFormat: config.agentOutputFormat,
     taskName: task.name,
-  });
-  
-  const duration = Date.now() - startTime;
-  events.emit('agent.response_received', {
-    taskName: task.name,
-    ok: r1.ok,
-    duration,
-    responseLength: r1.resultText?.length || 0,
-    error: r1.error,
+    browser: task.browser || config.browser,
+    autoApproveCommands: config.autoApproveCommands,
+    autoApproveMcps: config.autoApproveMcps,
   });
 
   appendLog(convoPath, createConversationEntry('assistant', r1.resultText || r1.error || 'No response', {
@@ -304,4 +224,3 @@ export async function runTask({
     status: 'FINISHED',
   };
 }
-

package/src/core/runner.ts

@@ -36,6 +36,8 @@ if (require.main === module) {
   const startIdxIdx = args.indexOf('--start-index');
   const pipelineBranchIdx = args.indexOf('--pipeline-branch');
   const worktreeDirIdx = args.indexOf('--worktree-dir');
+  const browser = args.includes('--browser');
+  const skipPreflight = args.includes('--skip-preflight');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
   const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
@@ -75,6 +77,9 @@ if (require.main === module) {
     if (forcedWorktreeDir) {
       config.worktreeDir = forcedWorktreeDir;
     }
+    if (browser) {
+      config.browser = true;
+    }
   } catch (error: any) {
     console.error(`Failed to load tasks file: ${error.message}`);
     process.exit(1);
@@ -87,7 +92,12 @@ if (require.main === module) {
   };
   
   // Add agent output format default
-  config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'json';
+  config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'stream-json';
+  
+  // Merge intervention and logging settings
+  config.enableIntervention = config.enableIntervention ?? globalConfig?.enableIntervention ?? true;
+  config.verboseGit = config.verboseGit ?? globalConfig?.verboseGit ?? false;
+  config.browser = config.browser ?? globalConfig?.browser ?? false;
   
   // Handle process interruption to ensure cleanup
   const handleSignal = (signal: string) => {
@@ -101,7 +111,7 @@ if (require.main === module) {
   process.on('SIGTERM', () => handleSignal('SIGTERM'));
 
   // Run tasks
-  runTasks(tasksFile, config, runDir, { startIndex })
+  runTasks(tasksFile, config, runDir, { startIndex, skipPreflight })
     .then(() => {
       process.exit(0);
     })

package/src/core/stall-detection.ts

@@ -18,6 +18,14 @@ import { ChildProcess } from 'child_process';
 import * as logger from '../utils/logger';
 import { events } from '../utils/events';
 import { safeJoin } from '../utils/path';
+import {
+  createInterventionRequest,
+  InterventionType,
+  createContinueMessage,
+  createStrongerPromptMessage,
+  createRestartMessage,
+  killAndWait,
+} from './intervention';
 
 // ============================================================================
 // 설정 (Configuration)
@@ -142,6 +150,10 @@ export interface LaneStallState {
   laneName: string;
   /** 현재 복구 단계 */
   phase: StallPhase;
+  /** Lane의 현재 상태 (waiting, running 등) - waiting 시 stall 분석 스킵 */
+  laneStatus?: string;
+  /** Intervention 활성화 여부 - false면 continue 신호 스킵 */
+  interventionEnabled?: boolean;
   /** 마지막 실제 활동 시간 (bytes > 0) */
   lastRealActivityTime: number;
   /** 마지막 상태 변경 시간 (phase 변경) */
@@ -294,6 +306,7 @@ export class StallDetectionService {
       laneRunDir?: string;
       childProcess?: ChildProcess;
       startIndex?: number;
+      interventionEnabled?: boolean;
     } = {}
   ): void {
     const now = Date.now();
@@ -301,6 +314,7 @@ export class StallDetectionService {
     this.laneStates.set(laneName, {
       laneName,
       phase: StallPhase.NORMAL,
+      interventionEnabled: options.interventionEnabled ?? true, // default to true
       lastRealActivityTime: now,
       lastPhaseChangeTime: now,
       lastStateUpdateTime: now,
@@ -318,7 +332,7 @@ export class StallDetectionService {
     });
     
     if (this.config.verbose) {
-      logger.debug(`[StallService] Lane registered: ${laneName}`);
+      logger.debug(`[StallService] Lane registered: ${laneName} (intervention: ${options.interventionEnabled ?? true})`);
     }
   }
   
@@ -360,6 +374,44 @@ export class StallDetectionService {
     }
   }
   
+  /**
+   * Lane 상태 업데이트 (waiting, running 등)
+   * waiting 상태일 때는 stall 분석을 스킵함
+   */
+  setLaneStatus(laneName: string, status: string): void {
+    const state = this.laneStates.get(laneName);
+    if (state) {
+      state.laneStatus = status;
+      
+      // waiting 상태로 전환 시 타이머 리셋 (의존성 대기 시간을 stall로 간주하지 않음)
+      if (status === 'waiting') {
+        const now = Date.now();
+        state.lastRealActivityTime = now;
+        state.lastStateUpdateTime = now;
+        state.taskStartTime = now;
+      }
+      
+      if (this.config.verbose) {
+        logger.debug(`[StallService] [${laneName}] Lane status updated: ${status}`);
+      }
+    }
+  }
+  
+  /**
+   * Intervention 활성화 상태 설정
+   * false로 설정하면 continue 신호를 보내지 않음
+   */
+  setInterventionEnabled(laneName: string, enabled: boolean): void {
+    const state = this.laneStates.get(laneName);
+    if (state) {
+      state.interventionEnabled = enabled;
+      
+      if (this.config.verbose) {
+        logger.debug(`[StallService] [${laneName}] Intervention ${enabled ? 'enabled' : 'disabled'}`);
+      }
+    }
+  }
+  
   // --------------------------------------------------------------------------
   // 활동 기록 (Activity Recording)
   // --------------------------------------------------------------------------
@@ -450,6 +502,7 @@ export class StallDetectionService {
    * Stall 상태 분석 - 현재 상태에서 필요한 액션 결정
    * 
    * 분석 우선순위:
+   * 0. waiting 상태면 스킵 (의존성 대기 중)
    * 1. Task timeout (30분) → RESTART/DOCTOR
    * 2. Zero bytes + idle → phase별 에스컬레이션
    * 3. No progress (10분) → 단계별 에스컬레이션
@@ -461,6 +514,17 @@ export class StallDetectionService {
       return this.buildAnalysis(StallType.IDLE, RecoveryAction.NONE, 'Lane not found', false);
     }
     
+    // 0. waiting 상태는 stall 분석 스킵 (의존성 대기 중이므로 정상)
+    if (state.laneStatus === 'waiting') {
+      return this.buildAnalysis(
+        StallType.IDLE, 
+        RecoveryAction.NONE, 
+        'Waiting for dependencies', 
+        true,
+        { laneStatus: 'waiting' }
+      );
+    }
+    
     const ctx = this.buildAnalysisContext(state);
     
     // 1. Task timeout (최우선)
@@ -676,8 +740,10 @@ export class StallDetectionService {
    * Stall 체크 및 복구 액션 실행
    * 
    * @returns 실행된 분석 결과 (orchestrator에서 추가 처리 필요시 사용)
+   * 
+   * 새로운 방식에서는 복구 액션이 프로세스 중단을 포함하므로 async
    */
-  checkAndRecover(laneName: string): StallAnalysis {
+  async checkAndRecover(laneName: string): Promise<StallAnalysis> {
     const state = this.laneStates.get(laneName);
     if (!state) {
       return {
@@ -704,18 +770,18 @@ export class StallDetectionService {
     // 실패 이력 기록
     this.recordFailure(state, analysis);
     
-    // 액션 실행
+    // 액션 실행 (프로세스 중단 포함 - await 필요)
     switch (analysis.action) {
       case RecoveryAction.SEND_CONTINUE:
-        this.sendContinueSignal(state);
+        await this.sendContinueSignal(state);
         break;
         
       case RecoveryAction.SEND_STRONGER_PROMPT:
-        this.sendStrongerPrompt(state);
+        await this.sendStrongerPrompt(state);
         break;
         
       case RecoveryAction.REQUEST_RESTART:
-        this.requestRestart(state);
+        await this.requestRestart(state);
         break;
         
       case RecoveryAction.RUN_DOCTOR:
@@ -731,24 +797,47 @@ export class StallDetectionService {
   }
   
   /**
-   * Continue 신호 발송
+   * Continue 신호 발송 - 프로세스 중단 및 개입 메시지와 함께 resume
+   * 
+   * 새로운 방식:
+   * 1. pending-intervention.json 생성
+   * 2. 현재 프로세스 SIGTERM으로 종료
+   * 3. Orchestrator가 감지하여 개입 메시지와 함께 resume
    */
-  private sendContinueSignal(state: LaneStallState): void {
+  private async sendContinueSignal(state: LaneStallState): Promise<void> {
+    // Intervention이 비활성화된 경우 신호를 보내지 않고 phase만 업데이트
+    if (state.interventionEnabled === false) {
+      logger.warn(`[${state.laneName}] Continue signal skipped (intervention disabled). Stall will escalate on next check.`);
+      state.phase = StallPhase.CONTINUE_SENT;
+      state.lastPhaseChangeTime = Date.now();
+      return;
+    }
+    
     if (!state.laneRunDir) {
       logger.error(`[StallService] [${state.laneName}] Cannot send continue signal: laneRunDir not set`);
       return;
     }
     
-    const interventionPath = safeJoin(state.laneRunDir, 'intervention.txt');
-    
     try {
-      fs.writeFileSync(interventionPath, 'continue');
+      // 1. 개입 요청 생성
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.CONTINUE_SIGNAL,
+        message: createContinueMessage(),
+        source: 'stall-detector',
+        priority: 5,
+      });
+      
+      // 2. 프로세스 종료 (있는 경우)
+      if (state.childProcess?.pid && !state.childProcess.killed) {
+        logger.info(`[${state.laneName}] Interrupting process ${state.childProcess.pid} for continue signal`);
+        await killAndWait(state.childProcess.pid);
+      }
       
       state.phase = StallPhase.CONTINUE_SENT;
       state.lastPhaseChangeTime = Date.now();
       state.continueSignalCount++;
       
-      logger.info(`[${state.laneName}] Sent continue signal (#${state.continueSignalCount})`);
+      logger.info(`[${state.laneName}] Continue signal queued (#${state.continueSignalCount}) - agent will resume with intervention`);
       
       events.emit('recovery.continue_signal', {
         laneName: state.laneName,
@@ -761,28 +850,41 @@ export class StallDetectionService {
   }
   
   /**
-   * Stronger prompt 발송
+   * Stronger prompt 발송 - 프로세스 중단 및 강력한 개입 메시지와 함께 resume
    */
-  private sendStrongerPrompt(state: LaneStallState): void {
+  private async sendStrongerPrompt(state: LaneStallState): Promise<void> {
+    // Intervention이 비활성화된 경우 신호를 보내지 않고 phase만 업데이트
+    if (state.interventionEnabled === false) {
+      logger.warn(`[${state.laneName}] Stronger prompt skipped (intervention disabled). Will escalate to restart.`);
+      state.phase = StallPhase.STRONGER_PROMPT_SENT;
+      state.lastPhaseChangeTime = Date.now();
+      return;
+    }
+    
     if (!state.laneRunDir) {
       logger.error(`[StallService] [${state.laneName}] Cannot send stronger prompt: laneRunDir not set`);
       return;
     }
     
-    const interventionPath = safeJoin(state.laneRunDir, 'intervention.txt');
-    const prompt = `[SYSTEM INTERVENTION] You seem to be stuck or waiting. 
-Please continue with your current task immediately. 
-If you're waiting for something, explain what you need and proceed with what you can do now.
-If you've completed the task, please summarize your work and finish.
-If you encountered a git error, resolve it and continue.`;
-    
     try {
-      fs.writeFileSync(interventionPath, prompt);
+      // 1. 개입 요청 생성
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.STRONGER_PROMPT,
+        message: createStrongerPromptMessage(),
+        source: 'stall-detector',
+        priority: 7,
+      });
+      
+      // 2. 프로세스 종료 (있는 경우)
+      if (state.childProcess?.pid && !state.childProcess.killed) {
+        logger.warn(`[${state.laneName}] Interrupting process ${state.childProcess.pid} for stronger prompt`);
+        await killAndWait(state.childProcess.pid);
+      }
       
       state.phase = StallPhase.STRONGER_PROMPT_SENT;
       state.lastPhaseChangeTime = Date.now();
       
-      logger.warn(`[${state.laneName}] Sent stronger prompt after continue signal failed`);
+      logger.warn(`[${state.laneName}] Stronger prompt queued - agent will resume with intervention`);
       
       events.emit('recovery.stronger_prompt', {
         laneName: state.laneName,
@@ -793,16 +895,31 @@ If you encountered a git error, resolve it and continue.`;
   }
   
   /**
-   * 재시작 요청 (프로세스 종료)
+   * 재시작 요청 - 프로세스 종료 및 재시작 메시지와 함께 resume
    */
-  private requestRestart(state: LaneStallState): void {
+  private async requestRestart(state: LaneStallState): Promise<void> {
     state.restartCount++;
     state.phase = StallPhase.RESTART_REQUESTED;
     state.lastPhaseChangeTime = Date.now();
     
-    // 프로세스 종료
-    if (state.childProcess && !state.childProcess.killed) {
+    // 1. 개입 요청 생성 (재시작 메시지)
+    if (state.laneRunDir) {
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.SYSTEM_RESTART,
+        message: createRestartMessage('Agent became unresponsive after multiple intervention attempts'),
+        source: 'stall-detector',
+        priority: 9,
+        metadata: {
+          restartCount: state.restartCount,
+          maxRestarts: this.config.maxRestarts,
+        },
+      });
+    }
+    
+    // 2. 프로세스 종료 (SIGKILL 사용 - 강제 종료)
+    if (state.childProcess?.pid && !state.childProcess.killed) {
       try {
+        // SIGKILL로 즉시 종료 (SIGTERM이 안 먹힐 수 있으므로)
         state.childProcess.kill('SIGKILL');
         logger.info(`[StallService] [${state.laneName}] Killed process ${state.childProcess.pid}`);
       } catch (error: any) {
@@ -810,7 +927,7 @@ If you encountered a git error, resolve it and continue.`;
       }
     }
     
-    logger.warn(`[${state.laneName}] Killing and restarting lane (restart #${state.restartCount})`);
+    logger.warn(`[${state.laneName}] Restart requested (restart #${state.restartCount}/${this.config.maxRestarts})`);
     
     events.emit('recovery.restart', {
       laneName: state.laneName,