@litmers/cursorflow-orchestrator 0.1.39 → 0.2.2

package/src/services/logging/buffer.ts

@@ -9,6 +9,7 @@ import * as path from 'path';
 import { EventEmitter } from 'events';
 import { LogImportance, JsonLogEntry, BufferedLogEntry as BufferedLogEntryType, MessageType } from '../../types/logging';
 import { COLORS } from './console';
+import { stripAnsi } from './formatter';
 
 // Re-export types for convenience
 export type { BufferedLogEntry } from '../../types/logging';
@@ -108,13 +109,13 @@ export class LogBufferService extends EventEmitter {
     const newEntries: BufferedLogEntryType[] = [];
 
     for (const laneName of this.lanes) {
-      const jsonlPath = path.join(lanesDir, laneName, 'terminal.jsonl');
+      const readablePath = path.join(lanesDir, laneName, 'terminal-readable.log');
 
       let fd: number | null = null;
       try {
         // Read file content atomically to avoid TOCTOU race condition
-        const lastPos = this.filePositions.get(jsonlPath) || 0;
-        fd = fs.openSync(jsonlPath, 'r');
+        const lastPos = this.filePositions.get(readablePath) || 0;
+        fd = fs.openSync(readablePath, 'r');
         const stat = fs.fstatSync(fd); // Use fstat on open fd to avoid race
         
         if (stat.size > lastPos) {
@@ -125,14 +126,11 @@ export class LogBufferService extends EventEmitter {
           const lines = newContent.split('\n').filter(line => line.trim());
 
           for (const line of lines) {
-            try {
-              const entry = JSON.parse(line) as JsonLogEntry;
-              const processed = this.processEntry(entry, laneName);
-              if (processed) newEntries.push(processed);
-            } catch { /* Skip invalid JSON */ }
+            const processed = this.processReadableLine(line, laneName);
+            if (processed) newEntries.push(processed);
           }
 
-          this.filePositions.set(jsonlPath, stat.size);
+          this.filePositions.set(readablePath, stat.size);
         }
       } catch { /* File in use, skip */ }
       finally {
@@ -156,11 +154,11 @@ export class LogBufferService extends EventEmitter {
     }
   }
 
-  private processEntry(entry: JsonLogEntry, laneName: string): BufferedLogEntryType | null {
-    const timestamp = new Date(entry.timestamp || Date.now());
-    const type = (entry.type || 'unknown') as MessageType;
-    const level = entry.level || this.inferLevel(type);
-    const message = entry.content || entry.message || JSON.stringify(entry);
+  private processReadableLine(line: string, laneName: string): BufferedLogEntryType | null {
+    const cleaned = stripAnsi(line).trim();
+    if (!cleaned) return null;
+
+    const { timestamp, message, level, type } = this.parseReadableMessage(cleaned);
     const importance = this.inferImportance(type, level);
 
     return {
@@ -172,23 +170,63 @@ export class LogBufferService extends EventEmitter {
       message: this.truncateMessage(message),
       importance,
       laneColor: this.laneColorMap.get(laneName) || COLORS.white,
-      raw: entry,
+      raw: {
+        timestamp: timestamp.toISOString(),
+        level: level as JsonLogEntry['level'],
+        lane: laneName,
+        message,
+      },
     };
   }
 
-  private inferLevel(type: string): string {
-    switch (type.toLowerCase()) {
-      case 'error':
-      case 'stderr':
-        return 'error';
-      case 'warning':
-        return 'warn';
-      case 'debug':
-      case 'thinking':
-        return 'debug';
-      default:
-        return 'info';
+  private parseReadableMessage(line: string): {
+    timestamp: Date;
+    message: string;
+    level: string;
+    type: MessageType | string;
+  } {
+    let remaining = line;
+    let timestamp = new Date();
+
+    const isoMatch = remaining.match(/^\[(\d{4}-\d{2}-\d{2}T[^\]]+)\]\s*/);
+    if (isoMatch) {
+      timestamp = new Date(isoMatch[1]!);
+      remaining = remaining.slice(isoMatch[0].length);
+    } else {
+      const timeMatch = remaining.match(/^\[(\d{2}:\d{2}:\d{2})\]\s*/);
+      if (timeMatch) {
+        const [hours, minutes, seconds] = timeMatch[1]!.split(':').map(Number);
+        const now = new Date();
+        now.setHours(hours || 0, minutes || 0, seconds || 0, 0);
+        timestamp = now;
+        remaining = remaining.slice(timeMatch[0].length);
+      }
     }
+
+    const labelMatch = remaining.match(/^\[[^\]]+\]\s*/);
+    if (labelMatch) {
+      remaining = remaining.slice(labelMatch[0].length);
+    }
+
+    const upper = remaining.toUpperCase();
+    let level = 'info';
+    let type: MessageType | string = 'stdout';
+
+    if (remaining.includes('❌') || upper.includes('ERR') || upper.includes('ERROR')) {
+      level = 'error';
+      type = 'error';
+    } else if (remaining.includes('⚠️') || upper.includes('WARN')) {
+      level = 'warn';
+      type = 'warn';
+    } else if (remaining.includes('🔍') || upper.includes('DEBUG')) {
+      level = 'debug';
+      type = 'debug';
+    } else if (remaining.includes('ℹ️') || upper.includes('INFO')) {
+      level = 'info';
+      type = 'info';
+    }
+
+    return { timestamp, message: remaining, level, type };
   }
 
   private inferImportance(type: string, level: string): LogImportance {
@@ -295,32 +333,55 @@ export class LogBufferService extends EventEmitter {
     }
 
     if (showLane) {
-      parts.push(`${entry.laneColor}[${entry.laneName.padEnd(12)}]${COLORS.reset}`);
+      // Lane label: fixed 14 chars inside brackets
+      const truncatedLane = entry.laneName.length > 14 ? entry.laneName.substring(0, 14) : entry.laneName;
+      parts.push(`${COLORS.magenta}[${truncatedLane.padEnd(14)}]${COLORS.reset}`);
     }
 
-    parts.push(this.getTypeIndicator(entry.type));
-    parts.push(entry.message);
+    const { indicator, messageColor } = this.getTypeIndicator(entry.type);
+    parts.push(indicator);
+    
+    // Apply message color if needed
+    const coloredMessage = messageColor ? `${messageColor}${entry.message}${COLORS.reset}` : entry.message;
+    parts.push(coloredMessage);
 
     return parts.join(' ');
   }
 
-  private getTypeIndicator(type: string): string {
-    const indicators: Record<string, string> = {
-      user: `${COLORS.cyan}[USER  ]${COLORS.reset}`,
-      assistant: `${COLORS.green}[ASST  ]${COLORS.reset}`,
-      tool: `${COLORS.yellow}[TOOL  ]${COLORS.reset}`,
-      tool_result: `${COLORS.gray}[RESULT]${COLORS.reset}`,
-      error: `${COLORS.red}[ERROR ]${COLORS.reset}`,
-      stderr: `${COLORS.red}[ERROR ]${COLORS.reset}`,
-      thinking: `${COLORS.gray}[THINK ]${COLORS.reset}`,
-      result: `${COLORS.green}[DONE  ]${COLORS.reset}`,
-      stdout: `${COLORS.white}[STDOUT]${COLORS.reset}`,
+  private getTypeIndicator(type: string): { indicator: string; messageColor: string } {
+    // Color rules:
+    // - Important (colored): user(cyan), assistant(green), result(green), error(red), warn(yellow)
+    // - Less important (gray): tool, tool_result, thinking, system, debug, stdout, info, raw
+    const indicators: Record<string, { indicator: string; messageColor: string }> = {
+      user: { indicator: `${COLORS.cyan}🧑 USER${COLORS.reset}`, messageColor: '' },
+      assistant: { indicator: `${COLORS.green}🤖 ASST${COLORS.reset}`, messageColor: '' },
+      tool: { indicator: `${COLORS.gray}🔧 TOOL${COLORS.reset}`, messageColor: COLORS.gray },
+      tool_result: { indicator: `${COLORS.gray}📄 RESL${COLORS.reset}`, messageColor: COLORS.gray },
+      error: { indicator: `${COLORS.red}❌ ERR${COLORS.reset}`, messageColor: COLORS.red },
+      stderr: { indicator: `${COLORS.red}   >>${COLORS.reset}`, messageColor: COLORS.red },
+      thinking: { indicator: `${COLORS.gray}🤔 THNK${COLORS.reset}`, messageColor: COLORS.gray },
+      result: { indicator: `${COLORS.green}✅ DONE${COLORS.reset}`, messageColor: '' },
+      success: { indicator: `${COLORS.green}✅ DONE${COLORS.reset}`, messageColor: '' },
+      stdout: { indicator: `${COLORS.gray}   >>${COLORS.reset}`, messageColor: COLORS.gray },
+      raw: { indicator: `${COLORS.gray}   >>${COLORS.reset}`, messageColor: COLORS.gray },
+      info: { indicator: `${COLORS.gray}ℹ️  INFO${COLORS.reset}`, messageColor: COLORS.gray },
+      warn: { indicator: `${COLORS.yellow}⚠️  WARN${COLORS.reset}`, messageColor: '' },
+      debug: { indicator: `${COLORS.gray}🔍 DBUG${COLORS.reset}`, messageColor: COLORS.gray },
+      system: { indicator: `${COLORS.gray}⚙️  SYS${COLORS.reset}`, messageColor: COLORS.gray },
+      progress: { indicator: `${COLORS.blue}🔄 PROG${COLORS.reset}`, messageColor: '' },
+    };
+    
+    const match = indicators[type.toLowerCase()];
+    if (match) return match;
+    
+    // Default: gray for unknown types
+    return { 
+      indicator: `${COLORS.gray}   ${type.toUpperCase().substring(0, 4).padEnd(4)}${COLORS.reset}`,
+      messageColor: COLORS.gray 
     };
-    return indicators[type.toLowerCase()] || `${COLORS.gray}[${type.toUpperCase().padEnd(6)}]${COLORS.reset}`;
   }
 }
 
 export function createLogBuffer(runDir: string, options?: LogBufferOptions): LogBufferService {
   return new LogBufferService(runDir, options);
 }
-

package/src/services/logging/console.ts

@@ -94,6 +94,10 @@ function normalizeOptions(options: LogOptions | string | undefined, defaultEmoji
 }
 
 // Primary logging functions
+// Color rules:
+// - Important (colored): error(red), warn(yellow), success(green)
+// - Less important (gray): info, debug
+
 export function error(message: string, options?: LogOptions | string): void {
   logWithColor(COLORS.red, 'error', message, normalizeOptions(options, '❌'));
 }
@@ -103,7 +107,8 @@ export function warn(message: string, options?: LogOptions | string): void {
 }
 
 export function info(message: string, options?: LogOptions | string): void {
-  logWithColor(COLORS.cyan, 'info', message, normalizeOptions(options, 'ℹ️'));
+  // Info is gray (less important) - focus on important messages
+  logWithColor(COLORS.gray, 'info', message, normalizeOptions(options, 'ℹ️'));
 }
 
 export function success(message: string, options?: LogOptions | string): void {
@@ -115,6 +120,7 @@ export function debug(message: string, options?: LogOptions | string): void {
 }
 
 export function progress(message: string, options?: LogOptions | string): void {
+  // Progress is blue (visible but not critical)
   logWithColor(COLORS.blue, 'info', message, normalizeOptions(options, '🔄'));
 }
 
@@ -149,12 +155,10 @@ export function withContext(context: string) {
  */
 export function laneOutput(laneName: string, message: string, isError = false, laneIndex?: number, taskIndex?: number, taskName?: string): void {
   const timestamp = `${COLORS.gray}[${formatTimestamp()}]${COLORS.reset}`;
-  // Format: [laneIdx-taskIdx-laneName-taskName] padded to 18 chars inside brackets
+  // Format: [laneIdx-taskIdx-laneName] 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 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;

package/src/services/logging/formatter.ts

@@ -3,17 +3,26 @@
  * 
  * Formats log messages for console display with various styles.
  * 
- * Rules:
- * - Box format only for: user, assistant, system, result
- * - Compact format for: tool, tool_result, thinking (gray/dim)
+ * ## Color Rules (by importance):
+ * - HIGH (colored): user(cyan), assistant(green), result(green), error(red), warn(yellow)
+ * - LOW (gray/dim): tool, tool_result, thinking, system, debug, stdout, raw, info
+ * 
+ * ## Format Rules:
+ * - Box format only for: user, assistant, result
+ * - Compact format for: tool, tool_result, thinking, system (gray/dim)
  * - Tool names simplified: ShellToolCall → Shell
+ * - Lane labels fixed 14 chars: [1-1-lanename  ]
+ * - Type labels: emoji + 4char (USER, ASST, TOOL, RESL, SYS, DONE, THNK)
  */
 
 import { COLORS } from './console';
 import { ParsedMessage, MessageType } from '../../types/logging';
 
-// Types that should use box format
-const BOX_TYPES = new Set(['user', 'assistant', 'system', 'result']);
+// Types that should use box format (important messages)
+const BOX_TYPES = new Set(['user', 'assistant', 'result']);
+
+// Types that should be gray/dim (less important)
+const GRAY_TYPES = new Set(['tool', 'tool_result', 'thinking', 'system', 'debug', 'stdout', 'raw', 'info']);
 
 /**
  * Strip ANSI escape sequences from text
@@ -64,10 +73,11 @@ 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: fixed 14 chars inside brackets [1-1-lanename  ]
+  const labelContent = laneLabel.replace(/^\[|\]$/g, ''); // Remove existing brackets if any
+  const truncatedLabel = labelContent.length > 14 ? labelContent.substring(0, 14) : labelContent;
   const labelPrefix = truncatedLabel 
-    ? `${COLORS.magenta}${truncatedLabel.padEnd(16)}${COLORS.reset} ` 
+    ? `${COLORS.magenta}[${truncatedLabel.padEnd(14)}]${COLORS.reset} ` 
     : '';
 
   // Determine if should use box format
@@ -77,17 +87,17 @@ export function formatMessageForConsole(
   if (!typePrefix) return `${tsPrefix}${labelPrefix}${formattedContent}`;
 
   if (!useBox) {
-    return `${tsPrefix}${labelPrefix}${typePrefix.padEnd(12)} ${formattedContent}`;
+    // Compact format: type prefix is already formatted with proper spacing
+    return `${tsPrefix}${labelPrefix}${typePrefix} ${formattedContent}`;
   }
 
-  // Multi-line box format (only for user, assistant, system, result)
-  // Emoji width is 2, so we need to account for that in indent calculation
+  // Multi-line box format (only for user, assistant, result)
   const lines = formattedContent.split('\n');
   const fullPrefix = `${tsPrefix}${labelPrefix}`;
   const strippedPrefix = stripAnsi(typePrefix);
   // Count emojis (they take 2 terminal columns but 1-2 chars in string)
   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 visualWidth = strippedPrefix.length + emojiCount;
   
   const boxWidth = 60;
   const header = `${typePrefix}┌${'─'.repeat(boxWidth)}`;
@@ -111,6 +121,9 @@ function formatMessageContent(msg: ParsedMessage, forceCompact: boolean): { type
     formattedContent = formattedContent.replace(/\n\s*\n/g, ' ').replace(/\n/g, ' ').trim();
   }
 
+  // Determine if this type should be gray (less important)
+  const isGray = GRAY_TYPES.has(msg.type);
+
   switch (msg.type) {
     case 'user':
       typePrefix = `${COLORS.cyan}🧑 USER${COLORS.reset}`;
@@ -123,20 +136,20 @@ function formatMessageContent(msg: ParsedMessage, forceCompact: boolean): { type
       break;
       
     case 'tool':
-      // Tool calls are always gray
+      // Tool calls are always gray (less important)
       typePrefix = `${COLORS.gray}🔧 TOOL${COLORS.reset}`;
       formattedContent = formatToolCall(formattedContent);
       break;
       
     case 'tool_result':
-      // Tool results are always gray
+      // Tool results are always gray (less important)
       typePrefix = `${COLORS.gray}📄 RESL${COLORS.reset}`;
       const resMatch = formattedContent.match(/\[Tool Result: ([^\]]+)\]/);
       if (resMatch) {
         const simpleName = simplifyToolName(resMatch[1]!);
         formattedContent = `${COLORS.gray}${simpleName} OK${COLORS.reset}`;
       } else {
-        formattedContent = `${COLORS.gray}result${COLORS.reset}`;
+        formattedContent = `${COLORS.gray}OK${COLORS.reset}`;
       }
       break;
       
@@ -145,14 +158,57 @@ function formatMessageContent(msg: ParsedMessage, forceCompact: boolean): { type
       break;
       
     case 'system':
-      typePrefix = `${COLORS.gray}⚙️ SYS${COLORS.reset}`;
+      // System messages are gray (less important)
+      typePrefix = `${COLORS.gray}⚙️  SYS${COLORS.reset}`;
+      formattedContent = `${COLORS.gray}${formattedContent}${COLORS.reset}`;
       break;
       
     case 'thinking':
-      // Thinking is always gray and compact
+      // Thinking is always gray and compact (less important)
       typePrefix = `${COLORS.gray}🤔 THNK${COLORS.reset}`;
       formattedContent = `${COLORS.gray}${truncate(formattedContent, 100)}${COLORS.reset}`;
       break;
+      
+    case 'info':
+      // Info messages are gray (less important)
+      typePrefix = `${COLORS.gray}ℹ️  INFO${COLORS.reset}`;
+      formattedContent = `${COLORS.gray}${formattedContent}${COLORS.reset}`;
+      break;
+      
+    case 'warn':
+      // Warnings are yellow (important)
+      typePrefix = `${COLORS.yellow}⚠️  WARN${COLORS.reset}`;
+      break;
+      
+    case 'error':
+      // Errors are red (important)
+      typePrefix = `${COLORS.red}❌ ERR${COLORS.reset}`;
+      break;
+      
+    case 'success':
+      typePrefix = `${COLORS.green}✅ DONE${COLORS.reset}`;
+      break;
+      
+    case 'debug':
+      // Debug is gray (less important)
+      typePrefix = `${COLORS.gray}🔍 DBUG${COLORS.reset}`;
+      formattedContent = `${COLORS.gray}${formattedContent}${COLORS.reset}`;
+      break;
+      
+    case 'progress':
+      typePrefix = `${COLORS.blue}🔄 PROG${COLORS.reset}`;
+      break;
+      
+    case 'stdout':
+    case 'raw':
+      // Raw output is gray (less important)
+      typePrefix = `${COLORS.gray}   >>${COLORS.reset}`;
+      formattedContent = `${COLORS.gray}${formattedContent}${COLORS.reset}`;
+      break;
+      
+    case 'stderr':
+      typePrefix = `${COLORS.red}   >>${COLORS.reset}`;
+      break;
   }
 
   return { typePrefix, formattedContent };
@@ -235,6 +291,7 @@ function getTypeInfo(type: MessageType): { label: string; color: string } {
     progress: { label: 'PROG  ', color: COLORS.blue || COLORS.cyan },
     stdout: { label: 'STDOUT', color: COLORS.white },
     stderr: { label: 'STDERR', color: COLORS.red },
+    raw: { label: 'RAW   ', color: COLORS.white },
   };
   
   return typeMap[type] || { label: type.toUpperCase().padEnd(6), color: COLORS.white };

package/src/services/logging/index.ts

@@ -9,8 +9,6 @@ export * from './console';
 export * from './formatter';
 export * from './parser';
 export * from './buffer';
-export * from './file-writer';
 
 // Re-export types
 export * from '../../types/logging';
-

package/src/services/logging/paths.ts

@@ -0,0 +1,14 @@
+import * as path from 'path';
+
+export const LOG_FILE_NAMES = {
+  clean: 'terminal.log',
+  raw: 'terminal-raw.log',
+  jsonl: 'terminal.jsonl',
+  readable: 'terminal-readable.log',
+} as const;
+
+export type LogFileType = keyof typeof LOG_FILE_NAMES;
+
+export function getLaneLogPath(laneDir: string, type: LogFileType): string {
+  return path.join(laneDir, LOG_FILE_NAMES[type]);
+}

package/src/services/logging/raw-log.ts

@@ -0,0 +1,43 @@
+import { stripAnsi } from './formatter';
+
+export interface ParsedRawLogLine {
+  timestamp: Date;
+  message: string;
+  level: string;
+}
+
+const ISO_TIMESTAMP = /^\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\]\s*/;
+const SHORT_TIMESTAMP = /^\[(\d{2}:\d{2}:\d{2})\]\s*/;
+
+export function parseRawLogLine(line: string, fallbackTime: Date): ParsedRawLogLine {
+  const cleanLine = stripAnsi(line).trimEnd();
+  let timestamp = fallbackTime;
+  let message = cleanLine;
+
+  const isoMatch = cleanLine.match(ISO_TIMESTAMP);
+  if (isoMatch) {
+    const parsed = new Date(isoMatch[1]);
+    if (!Number.isNaN(parsed.getTime())) {
+      timestamp = parsed;
+    }
+    message = cleanLine.slice(isoMatch[0].length);
+  } else {
+    const shortMatch = cleanLine.match(SHORT_TIMESTAMP);
+    if (shortMatch) {
+      const [hours, minutes, seconds] = shortMatch[1].split(':').map(Number);
+      const candidate = new Date(fallbackTime);
+      candidate.setHours(hours, minutes, seconds, 0);
+      timestamp = candidate;
+      message = cleanLine.slice(shortMatch[0].length);
+    }
+  }
+
+  const lower = message.toLowerCase();
+  const level = lower.includes('error') || lower.includes('failed') || lower.includes('❌')
+    ? 'error'
+    : lower.includes('warn')
+      ? 'warn'
+      : 'info';
+
+  return { timestamp, message, level };
+}

package/src/services/process/index.ts

@@ -154,7 +154,7 @@ export function getLaneProcessStatus(lanePath: string, laneName: string): LanePr
     if (result.startTime) {
       if (result.endTime) {
         result.duration = result.endTime - result.startTime;
-      } else if (result.stateStatus === 'running' || result.stateStatus === 'reviewing') {
+      } else if (result.stateStatus === 'running') {
         result.duration = Date.now() - result.startTime;
       }
     }

package/src/types/agent.ts

@@ -15,10 +15,25 @@ export interface DependencyRequestPlan {
 }
 
 export interface AgentSendResult {
+  /** Whether the operation succeeded */
   ok: boolean;
+  /** Process exit code */
   exitCode: number;
+  /** Error message if failed */
   error?: string;
+  /** Session ID from cursor-agent */
   sessionId?: string;
+  /** Result text from the agent response */
   resultText?: string;
+  /** Total execution time in milliseconds */
+  durationMs?: number;
+  /** API call time in milliseconds */
+  durationApiMs?: number;
+  /** Unique request ID for debugging */
+  requestId?: string;
+  /** Result subtype: 'success' or 'error' */
+  subtype?: 'success' | 'error';
+  /** Model used for this request */
+  model?: string;
 }
 

package/src/types/config.ts

@@ -49,6 +49,20 @@ export interface EnhancedLogConfig {
   raw?: boolean;
 }
 
+/**
+ * Hook 시스템 설정
+ */
+export interface HooksConfig {
+  /** Hook 정의 파일 경로 (e.g., './cursorflow.hooks.ts') */
+  file?: string;
+  /** Hook 실행 타임아웃 (ms, 기본: 30000) */
+  timeout?: number;
+  /** 에러 시 계속 진행 여부 (기본: false) */
+  continueOnError?: boolean;
+  /** 디버그 모드 */
+  debug?: boolean;
+}
+
 export interface CursorFlowConfig {
   tasksDir: string;
   /** New flows directory (replaces tasksDir in new architecture) */
@@ -69,11 +83,21 @@ export interface CursorFlowConfig {
   maxConcurrentLanes: number;
   projectRoot: string;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat: 'json' | 'plain' | 'stream-json';
+  agentOutputFormat: 'json' | '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') */
   defaultModel: string;
+  /** Auto-approve agent commands (--force flag). Default: true for automation. */
+  autoApproveCommands?: boolean;
+  /** Auto-approve MCP servers (--approve-mcps flag). Default: true for automation. */
+  autoApproveMcps?: boolean;
+  /** Enable browser automation (--browser flag). Required for web testing/scraping. */
+  browser?: boolean;
+  /** Hook 시스템 설정 */
+  hooks?: HooksConfig;
 }