@litmers/cursorflow-orchestrator 0.1.37 → 0.1.39

package/src/core/stall-detection.ts

@@ -201,6 +201,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
 // ============================================================================
@@ -420,207 +435,236 @@ 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 상태 분석 - 현재 상태에서 필요한 액션 결정
    * 
    * 분석 우선순위:
    * 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;
+    const ctx = this.buildAnalysisContext(state);
     
-    // 바이트 델타 계산
-    const bytesDelta = state.totalBytesReceived - state.bytesAtLastCheck;
+    // 1. Task timeout (최우선)
+    const taskResult = this.checkTaskTimeout(ctx);
+    if (taskResult) return taskResult;
     
-    // 장기 작업 유예 시간 적용
-    const effectiveIdleTimeout = state.isLongOperation 
-      ? this.config.longOperationGraceMs 
-      : this.config.idleTimeoutMs;
+    // 2. Zero bytes + idle (에이전트 무응답)
+    const zeroByteResult = this.checkZeroBytes(ctx);
+    if (zeroByteResult) return zeroByteResult;
     
-    // 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 },
-      };
-    }
+    // 3. Progress timeout
+    const progressResult = this.checkProgressTimeout(ctx);
+    if (progressResult) return progressResult;
     
-    // 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 },
-      };
-    }
+    // 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 };
     
-    // 3. Progress timeout 체크
-    if (progressTime > this.config.progressTimeoutMs) {
-      return this.getEscalatedAction(state, StallType.NO_PROGRESS, progressTime);
+    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 }
+        );
     }
   }
   

package/src/services/logging/console.ts

@@ -140,11 +140,23 @@ 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-taskName] padded to 18 chars inside brackets
+  const lIdx = laneIndex ?? 1;
+  const tIdx = taskIndex ?? 1;
+  const combined = taskName 
+    ? `${lIdx}-${tIdx}-${laneName}-${taskName}`
+    : `${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

@@ -231,6 +231,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,7 +69,7 @@ export interface CursorFlowConfig {
   maxConcurrentLanes: number;
   projectRoot: string;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat: 'json' | 'plain';
+  agentOutputFormat: 'json' | 'plain' | 'stream-json';
   webhooks?: WebhookConfig[];
   /** Enhanced logging configuration */
   enhancedLogging?: Partial<EnhancedLogConfig>;

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 {

package/src/types/task.ts

@@ -17,6 +17,7 @@ export interface Task {
 
 export interface RunnerConfig {
   tasks: Task[];
+  dependsOn?: string[];
   pipelineBranch?: string;
   worktreeDir?: string;
   branchPrefix?: string;
@@ -25,7 +26,7 @@ export interface RunnerConfig {
   model?: string;
   dependencyPolicy: DependencyPolicy;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat?: 'json' | 'plain';
+  agentOutputFormat?: 'json' | 'plain' | 'stream-json';
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
   timeout?: number;
   /** 
@@ -34,12 +35,6 @@ export interface RunnerConfig {
    * Default: false
    */
   enableIntervention?: boolean;
-  /**
-   * Disable Git operations (worktree, branch, push, commit).
-   * Useful for testing or environments without Git remote.
-   * Default: false
-   */
-  noGit?: boolean;
   /**
    * Enable verbose Git logging.
    * Default: false

package/src/utils/doctor.ts

@@ -618,7 +618,7 @@ function validateBranchNames(
 /**
  * Status file to track when doctor was last run successfully.
  */
-const DOCTOR_STATUS_FILE = '.cursorflow/doctor-status.json';
+const DOCTOR_STATUS_FILE = '_cursorflow/doctor-status.json';
 
 export function saveDoctorStatus(repoRoot: string, report: DoctorReport): void {
   const statusPath = safeJoin(repoRoot, DOCTOR_STATUS_FILE);
@@ -720,6 +720,10 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
     }
   }
 
+  const repoRoot = resolveRepoRoot(cwd) || undefined;
+  context.repoRoot = repoRoot;
+  const gitCwd = repoRoot || cwd;
+
   // 1) Git repository checks
   if (!isInsideGitWorktree(cwd)) {
     addIssue(issues, {
@@ -736,10 +740,6 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
     return { ok: false, issues, context };
   }
 
-  const repoRoot = resolveRepoRoot(cwd) || undefined;
-  context.repoRoot = repoRoot;
-  const gitCwd = repoRoot || cwd;
-
   if (!hasAtLeastOneCommit(gitCwd)) {
     addIssue(issues, {
       id: 'git.no_commits',

package/src/utils/git.ts

@@ -156,6 +156,7 @@ export function runGit(args: string[], options: GitRunOptions = {}): string {
       cwd: cwd || process.cwd(),
       encoding: 'utf8',
       stdio: stdioMode as any,
+      timeout: 30000, // 30 second timeout for all git operations
     });
     
     if (result.error) {
@@ -206,6 +207,7 @@ export function runGitResult(args: string[], options: GitRunOptions = {}): GitRe
     cwd: cwd || process.cwd(),
     encoding: 'utf8',
     stdio: 'pipe',
+    timeout: 30000, // 30 second timeout
   });
   
   const gitResult = {

package/src/utils/health.ts

@@ -455,14 +455,6 @@ export async function preflightCheck(options: {
     blockers.push(`Git: ${gitHealth.message}`);
   }
 
-  // Check authentication
-  if (options.requireAuth !== false) {
-    const authHealth = await checkAuthHealth();
-    if (!authHealth.ok) {
-      blockers.push(`Authentication: ${authHealth.message}`);
-    }
-  }
-
   // Check Git remote (warning only unless required)
   const remoteHealth = await checkGitRemoteHealth(options.cwd);
   if (!remoteHealth.ok) {
@@ -473,6 +465,21 @@ export async function preflightCheck(options: {
     }
   }
 
+  // Check worktrees
+  const worktreeHealth = await checkWorktrees(options.cwd);
+  if (!worktreeHealth.ok) {
+    warnings.push(`Worktrees: ${worktreeHealth.message}`);
+    recommendations.push('Run `cursorflow clean worktrees` to clean up orphaned worktrees');
+  }
+
+  // Check authentication
+  if (options.requireAuth !== false) {
+    const authHealth = await checkAuthHealth();
+    if (!authHealth.ok) {
+      blockers.push(`Authentication: ${authHealth.message}`);
+    }
+  }
+
   // Check disk space
   const diskHealth = await checkDiskSpace();
   if (!diskHealth.ok) {
@@ -486,13 +493,6 @@ export async function preflightCheck(options: {
     recommendations.push('Run `cursorflow clean locks` to remove stale locks');
   }
 
-  // Check worktrees
-  const worktreeHealth = await checkWorktrees(options.cwd);
-  if (!worktreeHealth.ok) {
-    warnings.push(`Worktrees: ${worktreeHealth.message}`);
-    recommendations.push('Run `cursorflow clean worktrees` to clean up orphaned worktrees');
-  }
-
   // Check system resources
   const resourceHealth = await checkSystemResources();
   if (!resourceHealth.ok) {

package/src/utils/log-formatter.ts

@@ -44,12 +44,17 @@ export function formatMessageForConsole(
   const ts = includeTimestamp ? new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false }) : '';
   const tsPrefix = ts ? `${COLORS.gray}[${ts}]${COLORS.reset} ` : '';
   
-  // Handle context (e.g. from logger.info) - max 16 chars
-  const effectiveLaneLabel = laneLabel || (context ? `[${context}]` : '');
-  const truncatedLabel = effectiveLaneLabel.length > 16 
-    ? effectiveLaneLabel.substring(0, 16) 
-    : effectiveLaneLabel;
-  const labelPrefix = truncatedLabel ? `${COLORS.magenta}${truncatedLabel.padEnd(16)}${COLORS.reset} ` : '';
+  // Handle context (e.g. from logger.info) - max 18 chars inside brackets
+  // Format: [1-1-lanename1234] padded to fixed width 20 (including brackets)
+  let effectiveLaneLabel = laneLabel || (context ? `[${context.substring(0, 18).padEnd(18)}]` : '');
+  
+  // Smart truncation: ensure it always ends with ]
+  if (effectiveLaneLabel.length > 20) {
+    effectiveLaneLabel = effectiveLaneLabel.substring(0, 19) + ']';
+  }
+  
+  // Fixed width 20 chars for consistent alignment
+  const labelPrefix = effectiveLaneLabel ? `${COLORS.magenta}${effectiveLaneLabel.padEnd(20)}${COLORS.reset} ` : '';
   
   let typePrefix = '';
   let content = msg.content;
@@ -155,6 +160,44 @@ export function formatMessageForConsole(
   
   if (!typePrefix) return `${tsPrefix}${labelPrefix}${content}`;
 
+  // Avoid double prefixes (e.g. INFO INFO)
+  const plainTypePrefix = stripAnsi(typePrefix).replace(/[^\x00-\x7F]/g, '').trim(); // "INFO", "DONE", etc.
+  const plainContent = stripAnsi(content);
+  if (plainContent.includes(` ${plainTypePrefix} `) || plainContent.startsWith(`${plainTypePrefix} `)) {
+    // If content already has the prefix, try to strip it from content or just use content as is
+    // For simplicity, if it's already there, we can just skip adding our typePrefix
+    // but we still want the colors. This is tricky. 
+    // Usually it's better to just return the content if it looks already formatted.
+  }
+
+  // A better way: if content starts with an emoji that matches our type, skip typePrefix
+  const emojiMap: Record<string, string> = {
+    'info': 'ℹ️',
+    'success': '✅',
+    'result': '✅',
+    'warn': '⚠️',
+    'error': '❌',
+    'tool': '🔧',
+    'thinking': '🤔',
+    'user': '🧑',
+    'assistant': '🤖'
+  };
+  
+  const targetEmoji = emojiMap[msg.type];
+  if (targetEmoji && plainContent.trim().startsWith(targetEmoji)) {
+    return `${tsPrefix}${labelPrefix}${content}`;
+  }
+
+  // Handle separator lines - if content is just a repeat of ━ or ─, extend it
+  const separatorMatch = content.match(/^([━─=]+)$/);
+  if (separatorMatch) {
+    const char = separatorMatch[1]![0]!;
+    // Use a fixed width for now (80 is a good standard)
+    // In a real terminal we could use process.stdout.columns
+    const targetWidth = 80;
+    content = char.repeat(targetWidth);
+  }
+
   // Compact format (single line)
   if (!useBox) {
     return `${tsPrefix}${labelPrefix}${typePrefix.padEnd(12)} ${content}`;
@@ -169,7 +212,7 @@ export function formatMessageForConsole(
   const emojiCount = (strippedPrefix.match(/[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2300}-\u{23FF}]|[\u{2B50}-\u{2B55}]|[\u{231A}-\u{231B}]|[\u{23E9}-\u{23F3}]|[\u{23F8}-\u{23FA}]|✅|❌|⚙️|ℹ️|⚠️|🔧|📄|🤔|🧑|🤖/gu) || []).length;
   const visualWidth = strippedPrefix.length + emojiCount; // emoji adds 1 extra width
   
-  const boxWidth = 60;
+  const boxWidth = 80;
   const header = `${typePrefix}┌${'─'.repeat(boxWidth)}`;
   let result = `${fullPrefix}${header}\n`;