@litmers/cursorflow-orchestrator 0.1.13 → 0.1.15

package/src/core/reviewer.ts

@@ -8,6 +8,7 @@ import * as logger from '../utils/logger';
 import { appendLog, createConversationEntry } from '../utils/state';
 import * as path from 'path';
 import { ReviewResult, ReviewIssue, TaskResult, RunnerConfig, AgentSendResult } from '../utils/types';
+import { events } from '../utils/events';
 
 /**
  * Build review prompt
@@ -148,7 +149,13 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   worktreeDir: string; 
   runDir: string; 
   config: RunnerConfig; 
-  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult; 
+  cursorAgentSend: (options: { 
+    workspaceDir: string; 
+    chatId: string; 
+    prompt: string; 
+    model?: string;
+    outputFormat?: 'stream-json' | 'json' | 'plain';
+  }) => AgentSendResult; 
   cursorAgentCreateChat: () => string; 
 }): Promise<ReviewResult> {
   const reviewPrompt = buildReviewPrompt({
@@ -159,12 +166,18 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   
   logger.info(`Reviewing: ${taskResult.taskName}`);
   
+  events.emit('review.started', {
+    taskName: taskResult.taskName,
+    taskBranch: taskResult.taskBranch,
+  });
+
   const reviewChatId = cursorAgentCreateChat();
-  const reviewResult = cursorAgentSend({
+  const reviewResult = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId: reviewChatId,
     prompt: reviewPrompt,
     model: config.reviewModel || 'sonnet-4.5-thinking',
+    outputFormat: config.agentOutputFormat,
   });
   
   const review = parseReviewResult(reviewResult.resultText || '');
@@ -178,6 +191,13 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   
   logger.info(`Review result: ${review.status} (${review.issues?.length || 0} issues)`);
   
+  events.emit('review.completed', {
+    taskName: taskResult.taskName,
+    status: review.status,
+    issueCount: review.issues?.length || 0,
+    summary: review.summary,
+  });
+
   return review;
 }
 
@@ -190,7 +210,13 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
   runDir: string;
   config: RunnerConfig;
   workChatId: string;
-  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult;
+  cursorAgentSend: (options: { 
+    workspaceDir: string; 
+    chatId: string; 
+    prompt: string; 
+    model?: string;
+    outputFormat?: 'stream-json' | 'json' | 'plain';
+  }) => AgentSendResult; 
   cursorAgentCreateChat: () => string;
 }): Promise<{ approved: boolean; review: ReviewResult; iterations: number; error?: string }> {
   const maxIterations = config.maxReviewIterations || 3;
@@ -209,6 +235,10 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
     
     if (currentReview.status === 'approved') {
       logger.success(`Review passed: ${taskResult.taskName} (iteration ${iteration + 1})`);
+      events.emit('review.approved', {
+        taskName: taskResult.taskName,
+        iterations: iteration + 1,
+      });
       return { approved: true, review: currentReview, iterations: iteration + 1 };
     }
     
@@ -216,6 +246,11 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
     
     if (iteration >= maxIterations) {
       logger.warn(`Max review iterations (${maxIterations}) reached: ${taskResult.taskName}`);
+      events.emit('review.rejected', {
+        taskName: taskResult.taskName,
+        reason: 'Max iterations reached',
+        iterations: iteration,
+      });
       break;
     }
     
@@ -223,11 +258,12 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
     logger.info(`Sending feedback (iteration ${iteration}/${maxIterations})`);
     const feedbackPrompt = buildFeedbackPrompt(currentReview);
     
-    const fixResult = cursorAgentSend({
+    const fixResult = await cursorAgentSend({
       workspaceDir: worktreeDir,
       chatId: workChatId,
       prompt: feedbackPrompt,
       model: config.model,
+      outputFormat: config.agentOutputFormat,
     });
     
     if (!fixResult.ok) {

package/src/core/runner.ts

@@ -12,6 +12,10 @@ import * as git from '../utils/git';
 import * as logger from '../utils/logger';
 import { ensureCursorAgent, checkCursorAuth, printAuthHelp } from '../utils/cursor-agent';
 import { saveState, appendLog, createConversationEntry } from '../utils/state';
+import { events } from '../utils/events';
+import { loadConfig } from '../utils/config';
+import { registerWebhooks } from '../utils/webhook';
+import { stripAnsi } from '../utils/enhanced-logger';
 import { 
   RunnerConfig, 
   Task, 
@@ -107,8 +111,8 @@ function parseJsonFromStdout(stdout: string): any {
   return null;
 }
 
-/** Default timeout: 5 minutes */
-const DEFAULT_TIMEOUT_MS = 300000;
+/** Default timeout: 10 minutes */
+const DEFAULT_TIMEOUT_MS = 600000;
 
 /** Heartbeat interval: 30 seconds */
 const HEARTBEAT_INTERVAL_MS = 30000;
@@ -171,7 +175,7 @@ export function validateTaskConfig(config: RunnerConfig): void {
 /**
  * Execute cursor-agent command with streaming and better error handling
  */
-export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention }: { 
+export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention, outputFormat }: { 
   workspaceDir: string; 
   chatId: string; 
   prompt: string; 
@@ -180,10 +184,14 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
   timeout?: number;
   /** Enable stdin piping for intervention feature (may cause buffering issues on some systems) */
   enableIntervention?: boolean;
+  /** Output format for cursor-agent (default: 'stream-json') */
+  outputFormat?: 'stream-json' | 'json' | 'plain';
 }): Promise<AgentSendResult> {
+  // Use stream-json format for structured output with tool calls and results
+  const format = outputFormat || 'stream-json';
   const args = [
     '--print',
-    '--output-format', 'json',
+    '--output-format', format,
     '--workspace', workspaceDir,
     ...(model ? ['--model', model] : []),
     '--resume', chatId,
@@ -240,6 +248,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
 
     let fullStdout = '';
     let fullStderr = '';
+    let timeoutHandle: NodeJS.Timeout;
 
     // Heartbeat logging to show progress
     let lastHeartbeat = Date.now();
@@ -251,13 +260,15 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
     }, HEARTBEAT_INTERVAL_MS);
     const startTime = Date.now();
 
-    // Watch for "intervention.txt" signal file if any
+    // Watch for "intervention.txt" or "timeout.txt" signal files
     const interventionPath = signalDir ? path.join(signalDir, 'intervention.txt') : null;
-    let interventionWatcher: fs.FSWatcher | null = null;
+    const timeoutPath = signalDir ? path.join(signalDir, 'timeout.txt') : null;
+    let signalWatcher: fs.FSWatcher | null = null;
 
-    if (interventionPath && fs.existsSync(path.dirname(interventionPath))) {
-      interventionWatcher = fs.watch(path.dirname(interventionPath), (event, filename) => {
-        if (filename === 'intervention.txt' && fs.existsSync(interventionPath)) {
+    if (signalDir && fs.existsSync(signalDir)) {
+      signalWatcher = fs.watch(signalDir, (event, filename) => {
+        // Handle intervention
+        if (filename === 'intervention.txt' && interventionPath && fs.existsSync(interventionPath)) {
           try {
             const message = fs.readFileSync(interventionPath, 'utf8').trim();
             if (message) {
@@ -274,6 +285,40 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
             logger.warn('Failed to read intervention file');
           }
         }
+        
+        // Handle dynamic timeout update
+        if (filename === 'timeout.txt' && timeoutPath && fs.existsSync(timeoutPath)) {
+          try {
+            const newTimeoutStr = fs.readFileSync(timeoutPath, 'utf8').trim();
+            const newTimeoutMs = parseInt(newTimeoutStr);
+            
+            if (!isNaN(newTimeoutMs) && newTimeoutMs > 0) {
+              logger.info(`⏱ Dynamic timeout update: ${Math.round(newTimeoutMs / 1000)}s`);
+              
+              // Clear old timeout
+              if (timeoutHandle) clearTimeout(timeoutHandle);
+              
+              // Set new timeout based on total elapsed time
+              const elapsed = Date.now() - startTime;
+              const remaining = Math.max(1000, newTimeoutMs - elapsed);
+              
+              timeoutHandle = setTimeout(() => {
+                clearInterval(heartbeatInterval);
+                child.kill();
+                const totalSec = Math.round(newTimeoutMs / 1000);
+                resolve({
+                  ok: false,
+                  exitCode: -1,
+                  error: `cursor-agent timed out after updated limit of ${totalSec} seconds.`,
+                });
+              }, remaining);
+              
+              fs.unlinkSync(timeoutPath); // Clear it
+            }
+          } catch (e) {
+            logger.warn('Failed to read timeout update file');
+          }
+        }
       });
     }
 
@@ -295,7 +340,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
       });
     }
 
-    const timeoutHandle = setTimeout(() => {
+    timeoutHandle = setTimeout(() => {
       clearInterval(heartbeatInterval);
       child.kill();
       const timeoutSec = Math.round(timeoutMs / 1000);
@@ -309,7 +354,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
     child.on('close', (code) => {
       clearTimeout(timeoutHandle);
       clearInterval(heartbeatInterval);
-      if (interventionWatcher) interventionWatcher.close();
+      if (signalWatcher) signalWatcher.close();
       
       const json = parseJsonFromStdout(fullStdout);
       
@@ -384,33 +429,31 @@ export function extractDependencyRequest(text: string): { required: boolean; pla
 /**
  * Wrap prompt with dependency policy
  */
-export function wrapPromptForDependencyPolicy(prompt: string, policy: DependencyPolicy): string {
-  if (policy.allowDependencyChange && !policy.lockfileReadOnly) {
+export function wrapPromptForDependencyPolicy(prompt: string, policy: DependencyPolicy, options: { noGit?: boolean } = {}): string {
+  const { noGit = false } = options;
+  
+  if (policy.allowDependencyChange && !policy.lockfileReadOnly && !noGit) {
     return prompt;
   }
   
-  return `# Dependency Policy (MUST FOLLOW)
-
-You are running in a restricted lane.
-
-- allowDependencyChange: ${policy.allowDependencyChange}
-- lockfileReadOnly: ${policy.lockfileReadOnly}
-
-Rules:
-- BEFORE making any code changes, decide whether dependency changes are required.
-- If dependency changes are required, DO NOT change any files. Instead reply with:
-
-DEPENDENCY_CHANGE_REQUIRED
-\`\`\`json
-{ "reason": "...", "changes": [...], "commands": ["pnpm add ..."], "notes": "..." }
-\`\`\`
-
-Then STOP.
-- If dependency changes are NOT required, proceed normally.
-
----
-
-${prompt}`;
+  let rules = '# Dependency Policy (MUST FOLLOW)\n\nYou are running in a restricted lane.\n\n';
+  
+  rules += `- allowDependencyChange: ${policy.allowDependencyChange}\n`;
+  rules += `- lockfileReadOnly: ${policy.lockfileReadOnly}\n`;
+  
+  if (noGit) {
+    rules += '- NO_GIT_MODE: Git is disabled. DO NOT run any git commands (commit, push, etc.). Just edit files.\n';
+  }
+  
+  rules += '\nRules:\n';
+  rules += '- BEFORE making any code changes, decide whether dependency changes are required.\n';
+  rules += '- If dependency changes are required, DO NOT change any files. Instead reply with:\n\n';
+  rules += 'DEPENDENCY_CHANGE_REQUIRED\n';
+  rules += '```json\n{ "reason": "...", "changes": [...], "commands": ["pnpm add ..."], "notes": "..." }\n```\n\n';
+  rules += 'Then STOP.\n';
+  rules += '- If dependency changes are NOT required, proceed normally.\n';
+  
+  return `${rules}\n---\n\n${prompt}`;
 }
 
 /**
@@ -449,9 +492,11 @@ export async function runTask({
   config,
   index,
   worktreeDir,
+  pipelineBranch,
   taskBranch,
   chatId,
   runDir,
+  noGit = false,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -461,22 +506,35 @@ export async function runTask({
   taskBranch: string;
   chatId: string;
   runDir: string;
+  noGit?: boolean;
 }): Promise<TaskExecutionResult> {
   const model = task.model || config.model || 'sonnet-4.5';
   const convoPath = path.join(runDir, 'conversation.jsonl');
   
   logger.section(`[${index + 1}/${config.tasks.length}] ${task.name}`);
   logger.info(`Model: ${model}`);
-  logger.info(`Branch: ${taskBranch}`);
+  if (noGit) {
+    logger.info('🚫 noGit mode: skipping branch operations');
+  } else {
+    logger.info(`Branch: ${taskBranch}`);
+  }
   
-  // Checkout task branch
-  git.runGit(['checkout', '-B', taskBranch], { cwd: worktreeDir });
+  events.emit('task.started', {
+    taskName: task.name,
+    taskBranch,
+    index,
+  });
+
+  // Checkout task branch (skip in noGit mode)
+  if (!noGit) {
+    git.runGit(['checkout', '-B', taskBranch], { cwd: worktreeDir });
+  }
   
   // Apply dependency permissions
   applyDependencyFilePermissions(worktreeDir, config.dependencyPolicy);
   
   // Run prompt
-  const prompt1 = wrapPromptForDependencyPolicy(task.prompt, config.dependencyPolicy);
+  const prompt1 = wrapPromptForDependencyPolicy(task.prompt, config.dependencyPolicy, { noGit });
   
   appendLog(convoPath, createConversationEntry('user', prompt1, {
     task: task.name,
@@ -484,6 +542,13 @@ export async function runTask({
   }));
   
   logger.info('Sending prompt to agent...');
+  const startTime = Date.now();
+  events.emit('agent.prompt_sent', {
+    taskName: task.name,
+    model,
+    promptLength: prompt1.length,
+  });
+
   const r1 = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId,
@@ -492,14 +557,29 @@ export async function runTask({
     signalDir: runDir,
     timeout: config.timeout,
     enableIntervention: config.enableIntervention,
+    outputFormat: config.agentOutputFormat,
   });
   
+  const duration = Date.now() - startTime;
+  events.emit('agent.response_received', {
+    taskName: task.name,
+    ok: r1.ok,
+    duration,
+    responseLength: r1.resultText?.length || 0,
+    error: r1.error,
+  });
+
   appendLog(convoPath, createConversationEntry('assistant', r1.resultText || r1.error || 'No response', {
     task: task.name,
     model,
   }));
   
   if (!r1.ok) {
+    events.emit('task.failed', {
+      taskName: task.name,
+      taskBranch,
+      error: r1.error,
+    });
     return {
       taskName: task.name,
       taskBranch,
@@ -519,9 +599,17 @@ export async function runTask({
     };
   }
   
-  // Push task branch
-  git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
+  // Push task branch (skip in noGit mode)
+  if (!noGit) {
+    git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
+  }
   
+  events.emit('task.completed', {
+    taskName: task.name,
+    taskBranch,
+    status: 'FINISHED',
+  });
+
   return {
     taskName: task.name,
     taskBranch,
@@ -532,8 +620,13 @@ export async function runTask({
 /**
  * Run all tasks in sequence
  */
-export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number } = {}): Promise<TaskExecutionResult[]> {
+export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number; noGit?: boolean } = {}): Promise<TaskExecutionResult[]> {
   const startIndex = options.startIndex || 0;
+  const noGit = options.noGit || config.noGit || false;
+  
+  if (noGit) {
+    logger.info('🚫 Running in noGit mode - Git operations will be skipped');
+  }
   
   // Validate configuration before starting
   logger.info('Validating task configuration...');
@@ -573,7 +666,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   logger.success('✓ Cursor authentication OK');
   
-  const repoRoot = git.getRepoRoot();
+  // In noGit mode, we don't need repoRoot - use current directory
+  const repoRoot = noGit ? process.cwd() : git.getRepoRoot();
   
   // Load existing state if resuming
   const statePath = path.join(runDir, 'state.json');
@@ -584,7 +678,10 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   }
   
   const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}`;
-  const worktreeDir = state?.worktreeDir || path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch);
+  // In noGit mode, use a simple local directory instead of worktree
+  const worktreeDir = state?.worktreeDir || (noGit 
+    ? path.join(repoRoot, config.worktreeRoot || '_cursorflow/workdir', pipelineBranch.replace(/\//g, '-'))
+    : path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch));
   
   if (startIndex === 0) {
     logger.section('🚀 Starting Pipeline');
@@ -598,10 +695,16 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   // Create worktree only if starting fresh
   if (startIndex === 0 || !fs.existsSync(worktreeDir)) {
-    git.createWorktree(worktreeDir, pipelineBranch, { 
-      baseBranch: config.baseBranch || 'main',
-      cwd: repoRoot,
-    });
+    if (noGit) {
+      // In noGit mode, just create the directory
+      logger.info(`Creating work directory: ${worktreeDir}`);
+      fs.mkdirSync(worktreeDir, { recursive: true });
+    } else {
+      git.createWorktree(worktreeDir, pipelineBranch, { 
+        baseBranch: config.baseBranch || 'main',
+        cwd: repoRoot,
+      });
+    }
   }
   
   // Create chat
@@ -633,8 +736,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   saveState(statePath, state);
   
-  // Merge dependencies if any
-  if (startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
+  // Merge dependencies if any (skip in noGit mode)
+  if (!noGit && startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
     logger.section('🔗 Merging Dependencies');
     
     // The runDir for the lane is passed in. Dependencies are in ../<depName> relative to this runDir
@@ -667,6 +770,12 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
             noFf: true, 
             message: `chore: merge dependency ${depName} (${depState.pipelineBranch})` 
           });
+
+          // Log changed files
+          const stats = git.getLastOperationStats(worktreeDir);
+          if (stats) {
+            logger.info('Changed files:\n' + stats);
+          }
         }
       } catch (e) {
         logger.error(`Failed to merge dependency ${depName}: ${e}`);
@@ -675,6 +784,50 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     
     // Push the merged state
     git.push(pipelineBranch, { cwd: worktreeDir });
+  } else if (noGit && startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
+    logger.info('⚠️ Dependencies specified but Git is disabled - copying files instead of merging');
+    
+    // The runDir for the lane is passed in. Dependencies are in ../<depName> relative to this runDir
+    const lanesRoot = path.dirname(runDir);
+    
+    for (const depName of config.dependsOn) {
+      const depRunDir = path.join(lanesRoot, depName);
+      const depStatePath = path.join(depRunDir, 'state.json');
+      
+      if (!fs.existsSync(depStatePath)) {
+        continue;
+      }
+      
+      try {
+        const depState = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+        if (depState.worktreeDir && fs.existsSync(depState.worktreeDir)) {
+          logger.info(`Copying files from dependency ${depName}: ${depState.worktreeDir} → ${worktreeDir}`);
+          
+          // Use a simple recursive copy (excluding Git and internal dirs)
+          const copyFiles = (src: string, dest: string) => {
+            if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+            const entries = fs.readdirSync(src, { withFileTypes: true });
+            
+            for (const entry of entries) {
+              if (entry.name === '.git' || entry.name === '_cursorflow' || entry.name === 'node_modules') continue;
+              
+              const srcPath = path.join(src, entry.name);
+              const destPath = path.join(dest, entry.name);
+              
+              if (entry.isDirectory()) {
+                copyFiles(srcPath, destPath);
+              } else {
+                fs.copyFileSync(srcPath, destPath);
+              }
+            }
+          };
+          
+          copyFiles(depState.worktreeDir, worktreeDir);
+        }
+      } catch (e) {
+        logger.error(`Failed to copy dependency ${depName}: ${e}`);
+      }
+    }
   }
   
   // Run tasks
@@ -693,6 +846,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       taskBranch,
       chatId,
       runDir,
+      noGit,
     });
     
     results.push(result);
@@ -706,6 +860,14 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       state.status = 'failed';
       state.dependencyRequest = result.dependencyRequest || null;
       saveState(statePath, state);
+      
+      if (result.dependencyRequest) {
+        events.emit('lane.dependency_requested', {
+          laneName: state.label,
+          dependencyRequest: result.dependencyRequest,
+        });
+      }
+      
       logger.warn('Task blocked on dependency change');
       process.exit(2);
     }
@@ -718,10 +880,21 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       process.exit(1);
     }
     
-    // Merge into pipeline
-    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
-    git.merge(taskBranch, { cwd: worktreeDir, noFf: true });
-    git.push(pipelineBranch, { cwd: worktreeDir });
+    // Merge into pipeline (skip in noGit mode)
+    if (!noGit) {
+      logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
+      git.merge(taskBranch, { cwd: worktreeDir, noFf: true });
+
+      // Log changed files
+      const stats = git.getLastOperationStats(worktreeDir);
+      if (stats) {
+        logger.info('Changed files:\n' + stats);
+      }
+
+      git.push(pipelineBranch, { cwd: worktreeDir });
+    } else {
+      logger.info(`✓ Task ${task.name} completed (noGit mode - no branch operations)`);
+    }
   }
   
   // Complete
@@ -729,6 +902,41 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   state.endTime = Date.now();
   saveState(statePath, state);
   
+  // Log final file summary
+  if (noGit) {
+    const getFileSummary = (dir: string): { files: number; dirs: number } => {
+      let stats = { files: 0, dirs: 0 };
+      if (!fs.existsSync(dir)) return stats;
+      
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === '.git' || entry.name === '_cursorflow' || entry.name === 'node_modules') continue;
+        
+        if (entry.isDirectory()) {
+          stats.dirs++;
+          const sub = getFileSummary(path.join(dir, entry.name));
+          stats.files += sub.files;
+          stats.dirs += sub.dirs;
+        } else {
+          stats.files++;
+        }
+      }
+      return stats;
+    };
+    
+    const summary = getFileSummary(worktreeDir);
+    logger.info(`Final Workspace Summary (noGit): ${summary.files} files, ${summary.dirs} directories created/modified`);
+  } else {
+    try {
+      const stats = git.runGit(['diff', '--stat', config.baseBranch || 'main', pipelineBranch], { cwd: repoRoot, silent: true });
+      if (stats) {
+        logger.info('Final Workspace Summary (Git):\n' + stats);
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+  
   logger.success('All tasks completed!');
   return results;
 }
@@ -747,11 +955,30 @@ if (require.main === module) {
   const tasksFile = args[0]!;
   const runDirIdx = args.indexOf('--run-dir');
   const startIdxIdx = args.indexOf('--start-index');
-  // const executorIdx = args.indexOf('--executor');
+  const pipelineBranchIdx = args.indexOf('--pipeline-branch');
+  const noGit = args.includes('--no-git');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
   const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
-  // const executor = executorIdx >= 0 ? args[executorIdx + 1] : 'cursor-agent';
+  const forcedPipelineBranch = pipelineBranchIdx >= 0 ? args[pipelineBranchIdx + 1] : null;
+
+  // Extract runId from runDir (format: .../runs/run-123/lanes/lane-name)
+  const parts = runDir.split(path.sep);
+  const runsIdx = parts.lastIndexOf('runs');
+  const runId = runsIdx >= 0 && parts[runsIdx + 1] ? parts[runsIdx + 1]! : `run-${Date.now()}`;
+  
+  events.setRunId(runId);
+
+  // Load global config for defaults and webhooks
+  let globalConfig;
+  try {
+    globalConfig = loadConfig();
+    if (globalConfig.webhooks) {
+      registerWebhooks(globalConfig.webhooks);
+    }
+  } catch (e) {
+    // Non-blocking
+  }
   
   if (!fs.existsSync(tasksFile)) {
     console.error(`Tasks file not found: ${tasksFile}`);
@@ -762,19 +989,25 @@ if (require.main === module) {
   let config: RunnerConfig;
   try {
     config = JSON.parse(fs.readFileSync(tasksFile, 'utf8')) as RunnerConfig;
+    if (forcedPipelineBranch) {
+      config.pipelineBranch = forcedPipelineBranch;
+    }
   } catch (error: any) {
     console.error(`Failed to load tasks file: ${error.message}`);
     process.exit(1);
   }
   
-  // Add dependency policy defaults
+  // Add defaults from global config or hardcoded
   config.dependencyPolicy = config.dependencyPolicy || {
-    allowDependencyChange: false,
-    lockfileReadOnly: true,
+    allowDependencyChange: globalConfig?.allowDependencyChange ?? false,
+    lockfileReadOnly: globalConfig?.lockfileReadOnly ?? true,
   };
   
+  // Add agent output format default
+  config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'stream-json';
+  
   // Run tasks
-  runTasks(tasksFile, config, runDir, { startIndex })
+  runTasks(tasksFile, config, runDir, { startIndex, noGit })
     .then(() => {
       process.exit(0);
     })