@litmers/cursorflow-orchestrator 0.1.37 → 0.1.40

package/src/core/runner.ts

@@ -18,6 +18,7 @@ export * from './runner/index';
 
 // Import necessary parts for the CLI entry point
 import { runTasks } from './runner/pipeline';
+import { cleanupAgentChildren } from './runner/agent';
 
 /**
  * CLI entry point
@@ -35,7 +36,6 @@ if (require.main === module) {
   const startIdxIdx = args.indexOf('--start-index');
   const pipelineBranchIdx = args.indexOf('--pipeline-branch');
   const worktreeDirIdx = args.indexOf('--worktree-dir');
-  const noGit = args.includes('--no-git');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
   const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
@@ -89,8 +89,23 @@ if (require.main === module) {
   // Add agent output format default
   config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'json';
   
+  // Merge intervention and logging settings
+  config.enableIntervention = config.enableIntervention ?? globalConfig?.enableIntervention ?? true;
+  config.verboseGit = config.verboseGit ?? globalConfig?.verboseGit ?? false;
+  
+  // Handle process interruption to ensure cleanup
+  const handleSignal = (signal: string) => {
+    logger.warn(`\n⚠️ Runner received ${signal}. Shutting down...`);
+    // Cleanup any active agent child processes
+    cleanupAgentChildren();
+    process.exit(1);
+  };
+
+  process.on('SIGINT', () => handleSignal('SIGINT'));
+  process.on('SIGTERM', () => handleSignal('SIGTERM'));
+
   // Run tasks
-  runTasks(tasksFile, config, runDir, { startIndex, noGit })
+  runTasks(tasksFile, config, runDir, { startIndex })
     .then(() => {
       process.exit(0);
     })

package/src/core/stall-detection.ts

@@ -142,6 +142,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 변경) */
@@ -201,6 +205,21 @@ export interface FailureRecord {
   lastOutput: string;
 }
 
+// ============================================================================
+// 분석 컨텍스트 (Analysis Context)
+// ============================================================================
+
+/** 분석에 필요한 시간 및 상태 컨텍스트 */
+interface AnalysisContext {
+  state: LaneStallState;
+  idleTime: number;
+  progressTime: number;
+  taskTime: number;
+  timeSincePhaseChange: number;
+  bytesDelta: number;
+  effectiveIdleTimeout: number;
+}
+
 // ============================================================================
 // Stall Detection Service
 // ============================================================================
@@ -279,6 +298,7 @@ export class StallDetectionService {
       laneRunDir?: string;
       childProcess?: ChildProcess;
       startIndex?: number;
+      interventionEnabled?: boolean;
     } = {}
   ): void {
     const now = Date.now();
@@ -286,6 +306,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,
@@ -303,7 +324,7 @@ export class StallDetectionService {
     });
     
     if (this.config.verbose) {
-      logger.debug(`[StallService] Lane registered: ${laneName}`);
+      logger.debug(`[StallService] Lane registered: ${laneName} (intervention: ${options.interventionEnabled ?? true})`);
     }
   }
   
@@ -345,6 +366,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)
   // --------------------------------------------------------------------------
@@ -420,207 +479,248 @@ export class StallDetectionService {
   // Stall 분석 (Analysis)
   // --------------------------------------------------------------------------
   
+  /** StallAnalysis 생성 헬퍼 */
+  private buildAnalysis(
+    type: StallType, 
+    action: RecoveryAction, 
+    message: string, 
+    isTransient: boolean, 
+    details?: Record<string, any>
+  ): StallAnalysis {
+    return { type, action, message, isTransient, details };
+  }
+  
   /**
    * Stall 상태 분석 - 현재 상태에서 필요한 액션 결정
    * 
    * 분석 우선순위:
+   * 0. waiting 상태면 스킵 (의존성 대기 중)
    * 1. Task timeout (30분) → RESTART/DOCTOR
-   * 2. Zero bytes + idle → AGENT_NO_RESPONSE
+   * 2. Zero bytes + idle → phase별 에스컬레이션
    * 3. No progress (10분) → 단계별 에스컬레이션
    * 4. Idle timeout (2분) → 단계별 에스컬레이션
    */
   analyzeStall(laneName: string): StallAnalysis {
     const state = this.laneStates.get(laneName);
     if (!state) {
-      return {
-        type: StallType.IDLE,
-        action: RecoveryAction.NONE,
-        message: 'Lane not found',
-        isTransient: false,
-      };
+      return this.buildAnalysis(StallType.IDLE, RecoveryAction.NONE, 'Lane not found', false);
     }
     
-    const now = Date.now();
-    const idleTime = now - state.lastRealActivityTime;
-    const progressTime = now - state.lastStateUpdateTime;
-    const taskTime = now - state.taskStartTime;
-    const timeSincePhaseChange = now - state.lastPhaseChangeTime;
+    // 0. waiting 상태는 stall 분석 스킵 (의존성 대기 중이므로 정상)
+    if (state.laneStatus === 'waiting') {
+      return this.buildAnalysis(
+        StallType.IDLE, 
+        RecoveryAction.NONE, 
+        'Waiting for dependencies', 
+        true,
+        { laneStatus: 'waiting' }
+      );
+    }
     
-    // 바이트 델타 계산
-    const bytesDelta = state.totalBytesReceived - state.bytesAtLastCheck;
+    const ctx = this.buildAnalysisContext(state);
     
-    // 장기 작업 유예 시간 적용
-    const effectiveIdleTimeout = state.isLongOperation 
-      ? this.config.longOperationGraceMs 
-      : this.config.idleTimeoutMs;
+    // 1. Task timeout (최우선)
+    const taskResult = this.checkTaskTimeout(ctx);
+    if (taskResult) return taskResult;
     
-    // 1. Task timeout 체크 (최우선)
-    if (taskTime > this.config.taskTimeoutMs) {
-      return {
-        type: StallType.TASK_TIMEOUT,
-        action: state.restartCount < this.config.maxRestarts 
-          ? RecoveryAction.REQUEST_RESTART 
-          : RecoveryAction.RUN_DOCTOR,
-        message: `Task exceeded maximum timeout of ${Math.round(this.config.taskTimeoutMs / 60000)} minutes`,
-        isTransient: state.restartCount < this.config.maxRestarts,
-        details: { taskTimeMs: taskTime, restartCount: state.restartCount },
-      };
-    }
+    // 2. Zero bytes + idle (에이전트 무응답)
+    const zeroByteResult = this.checkZeroBytes(ctx);
+    if (zeroByteResult) return zeroByteResult;
     
-    // 2. Zero bytes + idle 체크 (에이전트 무응답)
-    if (bytesDelta === 0 && idleTime > effectiveIdleTimeout) {
-      return {
-        type: StallType.ZERO_BYTES,
-        action: state.phase < StallPhase.STRONGER_PROMPT_SENT 
-          ? RecoveryAction.SEND_CONTINUE 
-          : RecoveryAction.REQUEST_RESTART,
-        message: `Agent produced 0 bytes for ${Math.round(idleTime / 1000)}s - possible API issue`,
-        isTransient: true,
-        details: { idleTimeMs: idleTime, bytesDelta, phase: state.phase },
-      };
-    }
+    // 3. Progress timeout
+    const progressResult = this.checkProgressTimeout(ctx);
+    if (progressResult) return progressResult;
     
-    // 3. Progress timeout 체크
-    if (progressTime > this.config.progressTimeoutMs) {
-      return this.getEscalatedAction(state, StallType.NO_PROGRESS, progressTime);
+    // 4. Phase별 idle 체크
+    const idleResult = this.checkPhaseBasedIdle(ctx);
+    if (idleResult) return idleResult;
+    
+    // 액션 필요 없음
+    return this.buildAnalysis(StallType.IDLE, RecoveryAction.NONE, 'Monitoring', true);
+  }
+  
+  /** 분석 컨텍스트 생성 */
+  private buildAnalysisContext(state: LaneStallState): AnalysisContext {
+    const now = Date.now();
+    return {
+      state,
+      idleTime: now - state.lastRealActivityTime,
+      progressTime: now - state.lastStateUpdateTime,
+      taskTime: now - state.taskStartTime,
+      timeSincePhaseChange: now - state.lastPhaseChangeTime,
+      bytesDelta: state.totalBytesReceived - state.bytesAtLastCheck,
+      effectiveIdleTimeout: state.isLongOperation 
+        ? this.config.longOperationGraceMs 
+        : this.config.idleTimeoutMs,
+    };
+  }
+  
+  /** Task timeout 체크 */
+  private checkTaskTimeout(ctx: AnalysisContext): StallAnalysis | null {
+    if (ctx.taskTime <= this.config.taskTimeoutMs) return null;
+    
+    const canRestart = ctx.state.restartCount < this.config.maxRestarts;
+    return this.buildAnalysis(
+      StallType.TASK_TIMEOUT,
+      canRestart ? RecoveryAction.REQUEST_RESTART : RecoveryAction.RUN_DOCTOR,
+      `Task exceeded maximum timeout of ${Math.round(this.config.taskTimeoutMs / 60000)} minutes`,
+      canRestart,
+      { taskTimeMs: ctx.taskTime, restartCount: ctx.state.restartCount }
+    );
+  }
+  
+  /** Zero bytes 체크 (grace period 존중) */
+  private checkZeroBytes(ctx: AnalysisContext): StallAnalysis | null {
+    const { state, idleTime, timeSincePhaseChange, bytesDelta, effectiveIdleTimeout } = ctx;
+    
+    if (bytesDelta !== 0 || idleTime <= effectiveIdleTimeout) return null;
+    
+    const baseDetails = { idleTimeMs: idleTime, bytesDelta, phase: state.phase, timeSincePhaseChange };
+    
+    switch (state.phase) {
+      case StallPhase.NORMAL:
+        return this.buildAnalysis(
+          StallType.ZERO_BYTES,
+          RecoveryAction.SEND_CONTINUE,
+          `Agent produced 0 bytes for ${Math.round(idleTime / 1000)}s - possible API issue`,
+          true, baseDetails
+        );
+        
+      case StallPhase.CONTINUE_SENT:
+        if (timeSincePhaseChange > this.config.continueGraceMs) {
+          return this.buildAnalysis(
+            StallType.ZERO_BYTES,
+            RecoveryAction.SEND_STRONGER_PROMPT,
+            `Still 0 bytes after continue signal (${Math.round(timeSincePhaseChange / 1000)}s). Escalating...`,
+            true, baseDetails
+          );
+        }
+        return null; // Grace period 내 → 대기
+        
+      case StallPhase.STRONGER_PROMPT_SENT:
+        if (timeSincePhaseChange > this.config.strongerPromptGraceMs) {
+          return this.buildAnalysis(
+            StallType.ZERO_BYTES,
+            RecoveryAction.REQUEST_RESTART,
+            `Still 0 bytes after stronger prompt (${Math.round(timeSincePhaseChange / 1000)}s). Restarting...`,
+            true, baseDetails
+          );
+        }
+        return null; // Grace period 내 → 대기
+        
+      default:
+        // RESTART_REQUESTED, DIAGNOSED, ABORTED
+        return this.buildAnalysis(
+          StallType.ZERO_BYTES,
+          RecoveryAction.REQUEST_RESTART,
+          `Agent produced 0 bytes for ${Math.round(idleTime / 1000)}s - possible API issue`,
+          true, baseDetails
+        );
     }
+  }
+  
+  /** Progress timeout 체크 */
+  private checkProgressTimeout(ctx: AnalysisContext): StallAnalysis | null {
+    if (ctx.progressTime <= this.config.progressTimeoutMs) return null;
+    return this.getEscalatedAction(ctx.state, StallType.NO_PROGRESS, ctx.progressTime);
+  }
+  
+  /** Phase별 idle 상태 체크 */
+  private checkPhaseBasedIdle(ctx: AnalysisContext): StallAnalysis | null {
+    const { state, idleTime, timeSincePhaseChange, effectiveIdleTimeout } = ctx;
     
-    // 4. Phase별 상태 체크
     switch (state.phase) {
       case StallPhase.NORMAL:
-        // Idle timeout 체크
         if (idleTime > effectiveIdleTimeout) {
-          return {
-            type: StallType.IDLE,
-            action: RecoveryAction.SEND_CONTINUE,
-            message: `Lane idle for ${Math.round(idleTime / 1000)}s. Sending continue signal...`,
-            isTransient: true,
-            details: { idleTimeMs: idleTime, isLongOperation: state.isLongOperation },
-          };
+          return this.buildAnalysis(
+            StallType.IDLE,
+            RecoveryAction.SEND_CONTINUE,
+            `Lane idle for ${Math.round(idleTime / 1000)}s. Sending continue signal...`,
+            true,
+            { idleTimeMs: idleTime, isLongOperation: state.isLongOperation }
+          );
         }
         break;
         
       case StallPhase.CONTINUE_SENT:
-        // Continue 신호 후 유예 시간 초과
         if (timeSincePhaseChange > this.config.continueGraceMs) {
-          return {
-            type: StallType.IDLE,
-            action: RecoveryAction.SEND_STRONGER_PROMPT,
-            message: `Still idle after continue signal. Sending stronger prompt...`,
-            isTransient: true,
-            details: { timeSincePhaseChange, continueSignalCount: state.continueSignalCount },
-          };
+          return this.buildAnalysis(
+            StallType.IDLE,
+            RecoveryAction.SEND_STRONGER_PROMPT,
+            `Still idle after continue signal. Sending stronger prompt...`,
+            true,
+            { timeSincePhaseChange, continueSignalCount: state.continueSignalCount }
+          );
         }
         break;
         
       case StallPhase.STRONGER_PROMPT_SENT:
-        // Stronger prompt 후 유예 시간 초과
         if (timeSincePhaseChange > this.config.strongerPromptGraceMs) {
-          if (state.restartCount < this.config.maxRestarts) {
-            return {
-              type: StallType.IDLE,
-              action: RecoveryAction.REQUEST_RESTART,
-              message: `No response after stronger prompt. Killing and restarting process...`,
-              isTransient: true,
-              details: { restartCount: state.restartCount, maxRestarts: this.config.maxRestarts },
-            };
-          } else {
-            return {
-              type: StallType.IDLE,
-              action: RecoveryAction.RUN_DOCTOR,
-              message: `Lane failed after ${state.restartCount} restarts. Running diagnostics...`,
-              isTransient: false,
-              details: { restartCount: state.restartCount },
-            };
-          }
+          return this.buildRestartOrDoctorAnalysis(state, 
+            'No response after stronger prompt. Killing and restarting process...',
+            `Lane failed after ${state.restartCount} restarts. Running diagnostics...`
+          );
         }
         break;
         
       case StallPhase.RESTART_REQUESTED:
-        // 재시작 후 idle timeout의 75%로 더 짧게 감지
         const postRestartTimeout = effectiveIdleTimeout * 0.75;
         if (idleTime > postRestartTimeout) {
-          if (state.restartCount < this.config.maxRestarts) {
-            return {
-              type: StallType.IDLE,
-              action: RecoveryAction.SEND_CONTINUE,
-              message: `Lane idle after restart. Retrying continue signal...`,
-              isTransient: true,
-              details: { idleTimeMs: idleTime, restartCount: state.restartCount },
-            };
-          } else {
-            return {
-              type: StallType.IDLE,
-              action: RecoveryAction.RUN_DOCTOR,
-              message: `Lane repeatedly stalled. Running diagnostics...`,
-              isTransient: false,
-              details: { restartCount: state.restartCount },
-            };
-          }
+          return this.buildRestartOrDoctorAnalysis(state,
+            'Lane idle after restart. Retrying continue signal...',
+            'Lane repeatedly stalled. Running diagnostics...',
+            RecoveryAction.SEND_CONTINUE  // restart 후에는 continue부터 시작
+          );
         }
         break;
         
       case StallPhase.DIAGNOSED:
       case StallPhase.ABORTED:
-        // 더 이상 복구 시도 안함
-        return {
-          type: StallType.IDLE,
-          action: RecoveryAction.ABORT_LANE,
-          message: 'Lane recovery exhausted',
-          isTransient: false,
-        };
+        return this.buildAnalysis(StallType.IDLE, RecoveryAction.ABORT_LANE, 'Lane recovery exhausted', false);
     }
     
-    // 액션 필요 없음
-    return {
-      type: StallType.IDLE,
-      action: RecoveryAction.NONE,
-      message: 'Monitoring',
-      isTransient: true,
-    };
+    return null;
   }
   
-  /**
-   * Progress timeout에 대한 에스컬레이션 액션 결정
-   */
+  /** 재시작 또는 Doctor 실행 결정 헬퍼 */
+  private buildRestartOrDoctorAnalysis(
+    state: LaneStallState, 
+    restartMsg: string, 
+    doctorMsg: string,
+    restartAction: RecoveryAction = RecoveryAction.REQUEST_RESTART
+  ): StallAnalysis {
+    const canRestart = state.restartCount < this.config.maxRestarts;
+    return this.buildAnalysis(
+      StallType.IDLE,
+      canRestart ? restartAction : RecoveryAction.RUN_DOCTOR,
+      canRestart ? restartMsg : doctorMsg,
+      canRestart,
+      { restartCount: state.restartCount, maxRestarts: this.config.maxRestarts }
+    );
+  }
+  
+  /** Progress timeout에 대한 에스컬레이션 액션 결정 */
   private getEscalatedAction(state: LaneStallState, type: StallType, progressTime: number): StallAnalysis {
+    const details = { progressTimeMs: progressTime };
+    
     switch (state.phase) {
       case StallPhase.NORMAL:
-        return {
-          type,
-          action: RecoveryAction.SEND_CONTINUE,
-          message: `No progress for ${Math.round(progressTime / 60000)} minutes. Sending continue signal...`,
-          isTransient: true,
-          details: { progressTimeMs: progressTime },
-        };
+        return this.buildAnalysis(type, RecoveryAction.SEND_CONTINUE,
+          `No progress for ${Math.round(progressTime / 60000)} minutes. Sending continue signal...`,
+          true, details);
         
       case StallPhase.CONTINUE_SENT:
-        return {
-          type,
-          action: RecoveryAction.SEND_STRONGER_PROMPT,
-          message: `Still no progress. Sending stronger prompt...`,
-          isTransient: true,
-          details: { progressTimeMs: progressTime },
-        };
+        return this.buildAnalysis(type, RecoveryAction.SEND_STRONGER_PROMPT,
+          'Still no progress. Sending stronger prompt...', true, details);
         
       default:
-        if (state.restartCount < this.config.maxRestarts) {
-          return {
-            type,
-            action: RecoveryAction.REQUEST_RESTART,
-            message: `No progress after interventions. Restarting...`,
-            isTransient: true,
-            details: { progressTimeMs: progressTime, restartCount: state.restartCount },
-          };
-        } else {
-          return {
-            type,
-            action: RecoveryAction.RUN_DOCTOR,
-            message: `Persistent no-progress state. Running diagnostics...`,
-            isTransient: false,
-            details: { progressTimeMs: progressTime, restartCount: state.restartCount },
-          };
-        }
+        const canRestart = state.restartCount < this.config.maxRestarts;
+        return this.buildAnalysis(type,
+          canRestart ? RecoveryAction.REQUEST_RESTART : RecoveryAction.RUN_DOCTOR,
+          canRestart ? 'No progress after interventions. Restarting...' : 'Persistent no-progress state. Running diagnostics...',
+          canRestart,
+          { ...details, restartCount: state.restartCount }
+        );
     }
   }
   
@@ -690,6 +790,14 @@ export class StallDetectionService {
    * Continue 신호 발송
    */
   private sendContinueSignal(state: LaneStallState): 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;
@@ -720,6 +828,14 @@ export class StallDetectionService {
    * Stronger prompt 발송
    */
   private sendStrongerPrompt(state: LaneStallState): 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;

package/src/services/logging/console.ts

@@ -140,11 +140,21 @@ export function withContext(context: string) {
 
 /**
  * Lane-specific output
+ * @param laneName - Lane name
+ * @param message - Message to output
+ * @param isError - Whether this is an error message
+ * @param laneIndex - Optional lane index
+ * @param taskIndex - Optional task index
+ * @param taskName - Optional task name
  */
-export function laneOutput(laneName: string, message: string, isError = false): void {
+export function laneOutput(laneName: string, message: string, isError = false, laneIndex?: number, taskIndex?: number, taskName?: string): void {
   const timestamp = `${COLORS.gray}[${formatTimestamp()}]${COLORS.reset}`;
-  const shortName = laneName.substring(0, 10).padEnd(10);
-  const laneLabel = `${COLORS.magenta}${shortName}${COLORS.reset}`;
+  // Format: [laneIdx-taskIdx-laneName] padded to 18 chars inside brackets
+  const lIdx = laneIndex ?? 1;
+  const tIdx = taskIndex ?? 1;
+  const combined = `${lIdx}-${tIdx}-${laneName}`;
+  const label = combined.substring(0, 18).padEnd(18);
+  const laneLabel = `${COLORS.magenta}[${label}]${COLORS.reset}`;
   const output = isError ? `${COLORS.red}${message}${COLORS.reset}` : message;
   
   if (isError) {

package/src/services/logging/formatter.ts

@@ -7,6 +7,7 @@
  * - Box format only for: user, assistant, system, result
  * - Compact format for: tool, tool_result, thinking (gray/dim)
  * - Tool names simplified: ShellToolCall → Shell
+ * - Lane labels fixed 20 chars: [1-1-backend       ]
  */
 
 import { COLORS } from './console';
@@ -64,10 +65,10 @@ export function formatMessageForConsole(
     : '';
   const tsPrefix = ts ? `${COLORS.gray}[${ts}]${COLORS.reset} ` : '';
   
-  // Lane label max 16 chars
-  const truncatedLabel = laneLabel.length > 16 ? laneLabel.substring(0, 16) : laneLabel;
+  // Lane label max 20 chars
+  const truncatedLabel = laneLabel.length > 20 ? laneLabel.substring(0, 20) : laneLabel;
   const labelPrefix = truncatedLabel 
-    ? `${COLORS.magenta}${truncatedLabel.padEnd(16)}${COLORS.reset} ` 
+    ? `${COLORS.magenta}${truncatedLabel.padEnd(20)}${COLORS.reset} ` 
     : '';
 
   // Determine if should use box format
@@ -231,6 +232,8 @@ function getTypeInfo(type: MessageType): { label: string; color: string } {
     info: { label: 'INFO  ', color: COLORS.cyan },
     warn: { label: 'WARN  ', color: COLORS.yellow },
     error: { label: 'ERROR ', color: COLORS.red },
+    debug: { label: 'DEBUG ', color: COLORS.gray },
+    progress: { label: 'PROG  ', color: COLORS.blue || COLORS.cyan },
     stdout: { label: 'STDOUT', color: COLORS.white },
     stderr: { label: 'STDERR', color: COLORS.red },
   };

package/src/types/config.ts

@@ -69,8 +69,10 @@ export interface CursorFlowConfig {
   maxConcurrentLanes: number;
   projectRoot: string;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat: 'json' | 'plain';
+  agentOutputFormat: 'json' | 'plain' | 'stream-json';
   webhooks?: WebhookConfig[];
+  /** Enable intervention feature (stdin piping for message injection) */
+  enableIntervention?: boolean;
   /** Enhanced logging configuration */
   enhancedLogging?: Partial<EnhancedLogConfig>;
   /** Default AI model for tasks (default: 'gemini-3-flash') */

package/src/types/logging.ts

@@ -22,8 +22,10 @@ export type MessageType =
   | 'success'
   | 'info'
   | 'warn'
-  | 'error'
-  | 'stdout'
+  | 'error' 
+  | 'debug'
+  | 'progress'
+  | 'stdout' 
   | 'stderr';
 
 export interface ParsedMessage {