@litmers/cursorflow-orchestrator 0.1.14 → 0.1.18

package/src/utils/config.ts

@@ -17,7 +17,9 @@ export function findProjectRoot(cwd = process.cwd()): string {
   
   while (current !== path.parse(current).root) {
     const packagePath = path.join(current, 'package.json');
-    if (fs.existsSync(packagePath)) {
+    const configPath = path.join(current, 'cursorflow.config.js');
+    
+    if (fs.existsSync(packagePath) || fs.existsSync(configPath)) {
       return current;
     }
     current = path.dirname(current);
@@ -57,6 +59,7 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     // Review
     enableReview: false,
     reviewModel: 'sonnet-4.5-thinking',
+    reviewAllTasks: false,
     maxReviewIterations: 3,
     
     // Lane defaults
@@ -72,6 +75,7 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     // Advanced
     worktreePrefix: 'cursorflow-',
     maxConcurrentLanes: 10,
+    agentOutputFormat: 'stream-json',
     
     // Webhooks
     webhooks: [],
@@ -155,10 +159,6 @@ export function validateConfig(config: CursorFlowConfig): boolean {
 export function createDefaultConfig(projectRoot: string, force = false): string {
   const configPath = path.join(projectRoot, 'cursorflow.config.js');
   
-  if (fs.existsSync(configPath) && !force) {
-    throw new Error(`Config file already exists: ${configPath}`);
-  }
-  
   const template = `module.exports = {
   // Directory configuration
   tasksDir: '_cursorflow/tasks',
@@ -179,6 +179,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Review configuration
   enableReview: false,
   reviewModel: 'sonnet-4.5-thinking',
+  reviewAllTasks: false,
   maxReviewIterations: 3,
   
   // Lane configuration
@@ -194,6 +195,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Advanced
   worktreePrefix: 'cursorflow-',
   maxConcurrentLanes: 10,
+  agentOutputFormat: 'stream-json', // 'stream-json' | 'json' | 'plain'
 
   // Webhook configuration
   // webhooks: [
@@ -218,6 +220,15 @@ export function createDefaultConfig(projectRoot: string, force = false): string
 };
 `;
   
-  fs.writeFileSync(configPath, template, 'utf8');
+  // Use atomic write with wx flag to avoid TOCTOU race condition (unless force is set)
+  try {
+    const writeFlag = force ? 'w' : 'wx';
+    fs.writeFileSync(configPath, template, { encoding: 'utf8', flag: writeFlag });
+  } catch (err: any) {
+    if (err.code === 'EEXIST') {
+      throw new Error(`Config file already exists: ${configPath}`);
+    }
+    throw err;
+  }
   return configPath;
 }

package/src/utils/doctor.ts

@@ -486,16 +486,46 @@ function validateBranchNames(
   const remoteBranches = getAllRemoteBranches(repoRoot);
   const allExistingBranches = new Set([...localBranches, ...remoteBranches]);
   
-  // Collect branch prefixes from lanes
+  // Collect branch prefixes and pipeline branches from lanes
   const branchPrefixes: { laneName: string; prefix: string }[] = [];
+  const pipelineBranches: { laneName: string; branch: string }[] = [];
   
   for (const lane of lanes) {
     const branchPrefix = lane.json?.branchPrefix;
     if (branchPrefix) {
       branchPrefixes.push({ laneName: lane.fileName, prefix: branchPrefix });
     }
+    
+    const pipelineBranch = lane.json?.pipelineBranch;
+    if (pipelineBranch) {
+      pipelineBranches.push({ laneName: lane.fileName, branch: pipelineBranch });
+    }
   }
   
+  // Check for pipeline branch collisions
+  const pipeMap = new Map<string, string[]>();
+  for (const { laneName, branch } of pipelineBranches) {
+    const existing = pipeMap.get(branch) || [];
+    existing.push(laneName);
+    pipeMap.set(branch, existing);
+  }
+  
+  for (const [branch, laneNames] of pipeMap) {
+    if (laneNames.length > 1) {
+      addIssue(issues, {
+        id: 'branch.pipeline_collision',
+        severity: 'error',
+        title: 'Pipeline branch collision',
+        message: `Multiple lanes use the same pipelineBranch "${branch}": ${laneNames.join(', ')}`,
+        details: 'Each lane should have a unique pipelineBranch to avoid worktree conflicts during parallel execution.',
+        fixes: [
+          'Update the pipelineBranch in each lane JSON file to be unique',
+          'Or remove pipelineBranch to let CursorFlow generate unique ones',
+        ],
+      });
+    }
+  }
+
   // Check for branch prefix collisions between lanes
   const prefixMap = new Map<string, string[]>();
   for (const { laneName, prefix } of branchPrefixes) {

package/src/utils/enhanced-logger.ts

@@ -13,7 +13,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { PassThrough, Transform, TransformCallback } from 'stream';
+import { Transform, TransformCallback } from 'stream';
 import { EnhancedLogConfig } from './types';
 
 // Re-export for backwards compatibility
@@ -163,6 +163,23 @@ export class StreamingMessageParser {
           },
         });
         break;
+        
+      case 'thinking':
+        // Thinking message (Claude 3.7+ etc.)
+        if (json.subtype === 'delta' && json.text) {
+          // Check if this is a new message or continuation
+          if (this.currentRole !== 'thinking') {
+            // Flush previous message if any
+            this.flush();
+            this.currentRole = 'thinking';
+            this.messageStartTime = json.timestamp_ms || Date.now();
+          }
+          this.currentMessage += json.text;
+        } else if (json.subtype === 'completed') {
+          // Thinking completed - flush immediately
+          this.flush();
+        }
+        break;
     }
   }
   
@@ -191,7 +208,7 @@ export class StreamingMessageParser {
 }
 
 export interface ParsedMessage {
-  type: 'system' | 'user' | 'assistant' | 'tool' | 'tool_result' | 'result';
+  type: 'system' | 'user' | 'assistant' | 'tool' | 'tool_result' | 'result' | 'thinking';
   role: string;
   content: string;
   timestamp: number;
@@ -384,11 +401,13 @@ export class EnhancedLogManager {
   private cleanTransform: CleanLogTransform | null = null;
   private streamingParser: StreamingMessageParser | null = null;
   private lineBuffer: string = '';
+  private onParsedMessage?: (msg: ParsedMessage) => void;
 
-  constructor(logDir: string, session: LogSession, config: Partial<EnhancedLogConfig> = {}) {
+  constructor(logDir: string, session: LogSession, config: Partial<EnhancedLogConfig> = {}, onParsedMessage?: (msg: ParsedMessage) => void) {
     this.config = { ...DEFAULT_LOG_CONFIG, ...config };
     this.session = session;
     this.logDir = logDir;
+    this.onParsedMessage = onParsedMessage;
     
     // Ensure log directory exists
     fs.mkdirSync(logDir, { recursive: true });
@@ -450,6 +469,9 @@ export class EnhancedLogManager {
     // Create streaming parser for readable log
     this.streamingParser = new StreamingMessageParser((msg) => {
       this.writeReadableMessage(msg);
+      if (this.onParsedMessage) {
+        this.onParsedMessage(msg);
+      }
     });
   }
   
@@ -464,41 +486,59 @@ export class EnhancedLogManager {
     
     switch (msg.type) {
       case 'system':
-        formatted = `\n${ts}\n${msg.content}\n`;
+        formatted = `[${ts}] ⚙️ SYSTEM: ${msg.content}\n`;
         break;
         
       case 'user':
-        // Format user prompt nicely
-        const promptPreview = msg.content.length > 200 
-          ? msg.content.substring(0, 200) + '...'
-          : msg.content;
-        formatted = `\n${ts}\n┌─ 🧑 USER ─────────────────────────────────────────────\n${this.indentText(promptPreview, '│ ')}\n└───────────────────────────────────────────────────────\n`;
-        break;
-        
       case 'assistant':
       case 'result':
-        // Format assistant response
+        // Format with brackets and line (compact)
+        const isUser = msg.type === 'user';
         const isResult = msg.type === 'result';
-        const header = isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
+        const headerText = isUser ? '🧑 USER' : isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
         const duration = msg.metadata?.duration_ms 
           ? ` (${Math.round(msg.metadata.duration_ms / 1000)}s)`
           : '';
-        formatted = `\n${ts}\n┌─ ${header}${duration} ──────────────────────────────────\n${this.indentText(msg.content, '│ ')}\n└───────────────────────────────────────────────────────\n`;
+        
+        const label = `[ ${headerText}${duration} ] `;
+        const totalWidth = 80;
+        const topBorder = `┌─${label}${'─'.repeat(Math.max(0, totalWidth - label.length - 2))}`;
+        const bottomBorder = `└─${'─'.repeat(totalWidth - 2)}`;
+
+        const lines = msg.content.split('\n');
+        formatted = `[${ts}] ${topBorder}\n`;
+        for (const line of lines) {
+          formatted += `[${ts}] │ ${line}\n`;
+        }
+        formatted += `[${ts}] ${bottomBorder}\n`;
         break;
         
       case 'tool':
-        // Format tool call
-        formatted = `${ts} 🔧 ${msg.content}\n`;
+        formatted = `[${ts}] 🔧 TOOL: ${msg.content}\n`;
         break;
         
       case 'tool_result':
-        // Format tool result (truncated)
-        const lines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
-        formatted = `${ts} 📄 ${msg.metadata?.toolName || 'Tool'}${lines}\n`;
+        const toolResultLines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
+        formatted = `[${ts}] 📄 RESL: ${msg.metadata?.toolName || 'Tool'}${toolResultLines}\n`;
+        break;
+        
+      case 'thinking':
+        // Format thinking block
+        const thinkLabel = `[ 🤔 THINKING ] `;
+        const thinkWidth = 80;
+        const thinkTop = `┌─${thinkLabel}${'─'.repeat(Math.max(0, thinkWidth - thinkLabel.length - 2))}`;
+        const thinkBottom = `└─${'─'.repeat(thinkWidth - 2)}`;
+
+        const thinkLines = msg.content.trim().split('\n');
+        formatted = `[${ts}] ${thinkTop}\n`;
+        for (const line of thinkLines) {
+          formatted += `[${ts}] │ ${line}\n`;
+        }
+        formatted += `[${ts}] ${thinkBottom}\n`;
         break;
         
       default:
-        formatted = `${ts} ${msg.content}\n`;
+        formatted = `[${ts}] ${msg.content}\n`;
     }
     
     try {
@@ -661,45 +701,106 @@ export class EnhancedLogManager {
       this.cleanTransform.write(data);
     }
     
-    // Parse streaming JSON for readable log
-    this.parseStreamingData(text);
+    // Process lines for readable log and JSON entries
+    this.lineBuffer += text;
+    const lines = this.lineBuffer.split('\n');
+    this.lineBuffer = lines.pop() || '';
     
-    // Write JSON entry (for significant lines only)
-    if (this.config.writeJsonLog) {
-      const cleanText = stripAnsi(text).trim();
-      if (cleanText && !this.isNoiseLog(cleanText)) {
+    for (const line of lines) {
+      const cleanLine = stripAnsi(line).trim();
+      if (!cleanLine) continue;
+
+      // Handle streaming JSON messages (for boxes, etc. in readable log)
+      if (cleanLine.startsWith('{')) {
+        if (this.streamingParser) {
+          this.streamingParser.parseLine(cleanLine);
+        }
+
+        // Special handling for terminal.jsonl entries for AI messages
+        if (this.config.writeJsonLog) {
+          try {
+            const json = JSON.parse(cleanLine);
+            let displayMsg = cleanLine;
+            let metadata = { ...json };
+
+            // Extract cleaner text for significant AI message types
+            if (json.type === 'thinking' && json.text) {
+              displayMsg = json.text;
+            } else if (json.type === 'assistant' && json.message?.content) {
+              displayMsg = json.message.content
+                .filter((c: any) => c.type === 'text')
+                .map((c: any) => c.text)
+                .join('');
+            } else if (json.type === 'user' && json.message?.content) {
+              displayMsg = json.message.content
+                .filter((c: any) => c.type === 'text')
+                .map((c: any) => c.text)
+                .join('');
+            } else if (json.type === 'tool_call' && json.subtype === 'started') {
+              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+              const args = json.tool_call[toolName]?.args || {};
+              displayMsg = `🔧 CALL: ${toolName}(${JSON.stringify(args)})`;
+            } else if (json.type === 'tool_call' && json.subtype === 'completed') {
+              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+              displayMsg = `📄 RESL: ${toolName}`;
+            } else if (json.type === 'result') {
+              displayMsg = json.result || 'Task completed';
+            }
+
+            this.writeJsonEntry({
+              timestamp: new Date().toISOString(),
+              level: 'stdout',
+              lane: this.session.laneName,
+              task: this.session.taskName,
+              message: displayMsg.substring(0, 2000), // Larger limit for AI text
+              metadata,
+            });
+            continue; // Already logged this JSON line
+          } catch {
+            // Not valid JSON or error, fall through to regular logging
+          }
+        }
+      }
+
+      // Also include significant info/status lines in readable log (compact)
+      if (this.readableLogFd !== null) {
+        // Look for log lines: [ISO_DATE] [LEVEL] ...
+        if (!this.isNoiseLog(cleanLine) && /\[\d{4}-\d{2}-\d{2}T/.test(cleanLine)) {
+          try {
+            // Check if it has a level marker
+            if (/\[(INFO|WARN|ERROR|SUCCESS|DEBUG)\]/.test(cleanLine)) {
+              // Special formatting for summary
+              if (cleanLine.includes('Final Workspace Summary')) {
+                const tsMatch = cleanLine.match(/\[(\d{4}-\d{2}-\d{2}T[^\]]+)\]/);
+                const ts = tsMatch ? tsMatch[1] : new Date().toISOString();
+                fs.writeSync(this.readableLogFd, `[${ts}] 📊 SUMMARY: ${cleanLine.split(']').slice(2).join(']').trim()}\n`);
+              } else {
+                fs.writeSync(this.readableLogFd, `${cleanLine}\n`);
+              }
+            }
+          } catch {}
+        }
+      }
+      
+      // Write regular non-JSON lines to terminal.jsonl
+      if (this.config.writeJsonLog && !this.isNoiseLog(cleanLine)) {
         this.writeJsonEntry({
           timestamp: new Date().toISOString(),
           level: 'stdout',
           lane: this.session.laneName,
           task: this.session.taskName,
-          message: cleanText.substring(0, 1000), // Truncate very long lines
-          raw: this.config.keepRawLogs ? undefined : text.substring(0, 1000),
+          message: cleanLine.substring(0, 1000),
+          raw: this.config.keepRawLogs ? undefined : line.substring(0, 1000),
         });
       }
     }
   }
   
   /**
-   * Parse streaming JSON data for readable log
+   * Parse streaming JSON data for readable log - legacy, integrated into writeStdout
    */
   private parseStreamingData(text: string): void {
-    if (!this.streamingParser) return;
-    
-    // Buffer incomplete lines
-    this.lineBuffer += text;
-    const lines = this.lineBuffer.split('\n');
-    
-    // Keep the last incomplete line in buffer
-    this.lineBuffer = lines.pop() || '';
-    
-    // Parse complete lines
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith('{')) {
-        this.streamingParser.parseLine(trimmed);
-      }
-    }
+    // Legacy method, no longer used but kept for internal references if any
   }
 
   /**
@@ -717,6 +818,20 @@ export class EnhancedLogManager {
     if (this.cleanTransform) {
       this.cleanTransform.write(data);
     }
+
+    // Also include error lines in readable log (compact)
+    if (this.readableLogFd !== null) {
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const cleanLine = stripAnsi(line).trim();
+        if (cleanLine && !this.isNoiseLog(cleanLine)) {
+          try {
+            const ts = new Date().toISOString();
+            fs.writeSync(this.readableLogFd, `[${ts}] ❌ STDERR: ${cleanLine}\n`);
+          } catch {}
+        }
+      }
+    }
     
     // Write JSON entry
     if (this.config.writeJsonLog) {
@@ -747,6 +862,15 @@ export class EnhancedLogManager {
       this.writeToRawLog(line);
     }
     
+    // Write to readable log (compact)
+    if (this.readableLogFd !== null) {
+      const typeLabel = level === 'error' ? '❌ ERROR' : level === 'info' ? 'ℹ️ INFO' : '🔍 DEBUG';
+      const formatted = `${new Date().toISOString()} ${typeLabel}: ${message}\n`;
+      try {
+        fs.writeSync(this.readableLogFd, formatted);
+      } catch {}
+    }
+
     if (this.config.writeJsonLog) {
       this.writeJsonEntry({
         timestamp: new Date().toISOString(),
@@ -770,6 +894,15 @@ export class EnhancedLogManager {
     if (this.config.keepRawLogs) {
       this.writeToRawLog(line);
     }
+
+    // Write to readable log (compact)
+    if (this.readableLogFd !== null) {
+      const ts = new Date().toISOString();
+      const formatted = `[${ts}] ━━━ ${title} ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+      try {
+        fs.writeSync(this.readableLogFd, formatted);
+      } catch {}
+    }
   }
 
   /**
@@ -805,7 +938,7 @@ export class EnhancedLogManager {
     
     // Skip common progress/spinner patterns
     const noisePatterns = [
-      /^[\s│├└─┌┐┘┴┬┤├]+$/, // Box drawing only
+      /^[\s│├└─┌┐┘┴┬┤]+$/, // Box drawing only (removed duplicate ├)
       /^[.\s]+$/, // Dots only
       /^[=>\s-]+$/, // Progress bar characters
       /^\d+%$/, // Percentage only
@@ -922,7 +1055,8 @@ export class EnhancedLogManager {
 export function createLogManager(
   laneRunDir: string,
   laneName: string,
-  config?: Partial<EnhancedLogConfig>
+  config?: Partial<EnhancedLogConfig>,
+  onParsedMessage?: (msg: ParsedMessage) => void
 ): EnhancedLogManager {
   const session: LogSession = {
     id: `${laneName}-${Date.now().toString(36)}`,
@@ -930,7 +1064,7 @@ export function createLogManager(
     startTime: Date.now(),
   };
   
-  return new EnhancedLogManager(laneRunDir, session, config);
+  return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
 }
 
 /**

package/src/utils/git.ts

@@ -217,12 +217,27 @@ export function commit(message: string, options: { cwd?: string; addAll?: boolea
   runGit(['commit', '-m', message], { cwd });
 }
 
+/**
+ * Check if a remote exists
+ */
+export function remoteExists(remoteName = 'origin', options: { cwd?: string } = {}): boolean {
+  const result = runGitResult(['remote'], { cwd: options.cwd });
+  if (!result.success) return false;
+  return result.stdout.split('\n').map(r => r.trim()).includes(remoteName);
+}
+
 /**
  * Push to remote
  */
 export function push(branchName: string, options: { cwd?: string; force?: boolean; setUpstream?: boolean } = {}): void {
   const { cwd, force = false, setUpstream = false } = options;
   
+  // Check if origin exists before pushing
+  if (!remoteExists('origin', { cwd })) {
+    // If no origin, just skip pushing (useful for local tests)
+    return;
+  }
+
   const args = ['push'];
   
   if (force) {

package/src/utils/logger.ts

@@ -16,7 +16,9 @@ export const COLORS = {
   green: '\x1b[32m',
   blue: '\x1b[34m',
   cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
   gray: '\x1b[90m',
+  bold: '\x1b[1m',
 };
 
 let currentLogLevel: number = LogLevel.info;
@@ -38,7 +40,8 @@ export function setLogLevel(level: string | number): void {
 function formatMessage(level: string, message: string, emoji = ''): string {
   const timestamp = new Date().toISOString();
   const prefix = emoji ? `${emoji} ` : '';
-  return `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
+  const lines = String(message).split('\n');
+  return lines.map(line => `[${timestamp}] [${level.toUpperCase()}] ${prefix}${line}`).join('\n');
 }
 
 /**

package/src/utils/repro-thinking-logs.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogManager } from './enhanced-logger';
+
+async function testThinkingLogs() {
+  const testDir = path.join(process.cwd(), '_test_thinking_logs');
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+
+  console.log('--- Initializing Log Manager ---');
+  const manager = createLogManager(testDir, 'test-lane-thinking', {
+    writeJsonLog: true,
+    keepRawLogs: true
+  });
+
+  manager.setTask('repro-thinking-task', 'sonnet-4.5-thinking');
+
+  const logLines = [
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_54a8fcc9-6981-4f59-aeb6-3ab6d37b2","tool_call":{"readToolCall":{"args":{"path":"/home/eugene/workbench/workbench-os-eungjin/_cursorflow/worktrees/cursorflow/run-mjfxp57i/agent_output.txt"}}}}',
+    '{"type":"thinking","subtype":"delta","text":"**Defining Installation Strategy**\\n\\nI\'ve considered the `package.json` file as the central point for installation in automated environments. Thinking now about how that impacts the user\'s ultimate goal, given this is how the process begins in these environments.\\n\\n\\n"}',
+    '{"type":"thinking","subtype":"delta","text":"**Clarifying Execution Context**\\n\\nI\'m focused on the user\'s explicit command: `pnpm add @convex-dev/agent ai @ai-sdk/google zod`. My inability to directly execute this is a key constraint. I\'m exploring ways to inform the user about this. I\'ve considered that, without the tools required to run the original command, any attempt to run a command like `grep` or `date` is pointless and will fail.\\n\\n\\n"}',
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_d8f826c8-9d8f-4cab-9ff8-1c47d1ac1","tool_call":{"shellToolCall":{"args":{"command":"date"}}}}'
+  ];
+
+  console.log('\n--- Feeding Log Lines to Manager ---');
+  for (const line of logLines) {
+    console.log('Processing:', line.substring(0, 100) + '...');
+    manager.writeStdout(line + '\n');
+  }
+
+  manager.close();
+
+  console.log('\n--- Verifying terminal-readable.log ---');
+  const readableLog = fs.readFileSync(path.join(testDir, 'terminal-readable.log'), 'utf8');
+  console.log(readableLog);
+
+  console.log('\n--- Verifying terminal.jsonl (last 3 entries) ---');
+  const jsonlLog = fs.readFileSync(path.join(testDir, 'terminal.jsonl'), 'utf8');
+  const lines = jsonlLog.trim().split('\n');
+  for (const line of lines.slice(-3)) {
+    const parsed = JSON.parse(line);
+    console.log(JSON.stringify({
+      level: parsed.level,
+      message: parsed.message.substring(0, 50) + '...',
+      hasMetadata: !!parsed.metadata,
+      metadataType: parsed.metadata?.type
+    }, null, 2));
+  }
+}
+
+testThinkingLogs().catch(console.error);
+

package/src/utils/types.ts

@@ -18,6 +18,7 @@ export interface CursorFlowConfig {
   lockfileReadOnly: boolean;
   enableReview: boolean;
   reviewModel: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations: number;
   defaultLaneConfig: LaneConfig;
   logLevel: string;
@@ -25,6 +26,8 @@ export interface CursorFlowConfig {
   worktreePrefix: string;
   maxConcurrentLanes: number;
   projectRoot: string;
+  /** Output format for cursor-agent (default: 'stream-json') */
+  agentOutputFormat: 'stream-json' | 'json' | 'plain';
   webhooks?: WebhookConfig[];
   /** Enhanced logging configuration */
   enhancedLogging?: Partial<EnhancedLogConfig>;
@@ -187,6 +190,10 @@ export interface Task {
   model?: string;
   /** Acceptance criteria for the AI reviewer to validate */
   acceptanceCriteria?: string[];
+  /** Task-level dependencies (format: "lane:task") */
+  dependsOn?: string[];
+  /** Task execution timeout in milliseconds. Overrides lane-level timeout. */
+  timeout?: number;
 }
 
 export interface RunnerConfig {
@@ -198,7 +205,11 @@ export interface RunnerConfig {
   baseBranch?: string;
   model?: string;
   dependencyPolicy: DependencyPolicy;
+  enableReview?: boolean;
+  /** Output format for cursor-agent (default: 'stream-json') */
+  agentOutputFormat?: 'stream-json' | 'json' | 'plain';
   reviewModel?: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations?: number;
   acceptanceCriteria?: string[];
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
@@ -209,6 +220,12 @@ 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;
 }
 
 export interface DependencyRequestPlan {
@@ -253,6 +270,7 @@ export interface ReviewResult {
 export interface TaskResult {
   taskName: string;
   taskBranch: string;
+  acceptanceCriteria?: string[];
   [key: string]: any;
 }
 
@@ -271,6 +289,10 @@ export interface LaneState {
   tasksFile?: string; // Original tasks file path
   dependsOn?: string[];
   pid?: number;
+  /** List of completed task names in this lane */
+  completedTasks?: string[];
+  /** Task-level dependencies currently being waited for (format: "lane:task") */
+  waitingFor?: string[];
 }
 
 export interface ConversationEntry {

package/src/utils/webhook.ts

@@ -56,6 +56,9 @@ async function sendWebhook(config: WebhookConfig, event: CursorFlowEvent) {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
+      // SECURITY NOTE: Intentionally sending event data to configured webhook URLs.
+      // This is the expected behavior - users explicitly configure webhook endpoints
+      // to receive CursorFlow events. The data is JSON-serialized event metadata.
       const response = await fetch(config.url, {
         method: 'POST',
         headers,