@litmers/cursorflow-orchestrator 0.1.14 → 0.1.18

package/src/core/runner.ts

@@ -15,7 +15,7 @@ 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 { runReviewLoop } from './reviewer';
 import { 
   RunnerConfig, 
   Task, 
@@ -175,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; 
@@ -184,11 +184,16 @@ 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', 'stream-json',
+    '--force',
+    '--approve-mcps',
+    '--output-format', format,
     '--workspace', workspaceDir,
     ...(model ? ['--model', model] : []),
     '--resume', chatId,
@@ -229,17 +234,18 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
       env: childEnv,
     });
 
-    // Save PID to state if possible
+    logger.info(`Executing cursor-agent... (timeout: ${Math.round(timeoutMs / 1000)}s)`);
+
+    // Save PID to state if possible (avoid TOCTOU by reading directly)
     if (child.pid && signalDir) {
       try {
         const statePath = path.join(signalDir, 'state.json');
-        if (fs.existsSync(statePath)) {
-          const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
-          state.pid = child.pid;
-          fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-        }
-      } catch (e) {
-        // Best effort
+        // Read directly without existence check to avoid race condition
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        state.pid = child.pid;
+        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+      } catch {
+        // Best effort - file may not exist yet
       }
     }
 
@@ -426,33 +432,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}`;
 }
 
 /**
@@ -483,6 +487,82 @@ export function applyDependencyFilePermissions(worktreeDir: string, policy: Depe
   }
 }
 
+/**
+ * Wait for task-level dependencies to be completed by other lanes
+ */
+export async function waitForTaskDependencies(deps: string[], runDir: string): Promise<void> {
+  if (!deps || deps.length === 0) return;
+
+  const lanesRoot = path.dirname(runDir);
+  const pendingDeps = new Set(deps);
+
+  logger.info(`Waiting for task dependencies: ${deps.join(', ')}`);
+
+  while (pendingDeps.size > 0) {
+    for (const dep of pendingDeps) {
+      const [laneName, taskName] = dep.split(':');
+      if (!laneName || !taskName) {
+        logger.warn(`Invalid dependency format: ${dep}. Expected "lane:task"`);
+        pendingDeps.delete(dep);
+        continue;
+      }
+
+      const depStatePath = path.join(lanesRoot, laneName, 'state.json');
+      if (fs.existsSync(depStatePath)) {
+        try {
+          const state = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+          if (state.completedTasks && state.completedTasks.includes(taskName)) {
+            logger.info(`✓ Dependency met: ${dep}`);
+            pendingDeps.delete(dep);
+          } else if (state.status === 'failed') {
+            throw new Error(`Dependency failed: ${dep} (Lane ${laneName} failed)`);
+          }
+        } catch (e: any) {
+          if (e.message.includes('Dependency failed')) throw e;
+          // Ignore parse errors, file might be being written
+        }
+      }
+    }
+
+    if (pendingDeps.size > 0) {
+      await new Promise(resolve => setTimeout(resolve, 5000)); // Poll every 5 seconds
+    }
+  }
+}
+
+/**
+ * Merge branches from dependency lanes
+ */
+export async function mergeDependencyBranches(deps: string[], runDir: string, worktreeDir: string): Promise<void> {
+  if (!deps || deps.length === 0) return;
+
+  const lanesRoot = path.dirname(runDir);
+  const lanesToMerge = new Set(deps.map(d => d.split(':')[0]!));
+
+  for (const laneName of lanesToMerge) {
+    const depStatePath = path.join(lanesRoot, laneName, 'state.json');
+    if (!fs.existsSync(depStatePath)) continue;
+
+    try {
+      const state = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+      if (state.pipelineBranch) {
+        logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
+        
+        // Ensure we have the latest
+        git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
+        
+        git.merge(state.pipelineBranch, {
+          cwd: worktreeDir,
+          noFf: true,
+          message: `chore: merge task dependency from ${laneName}`
+        });
+      }
+    } catch (e) {
+      logger.error(`Failed to merge branch from ${laneName}: ${e}`);
+    }
+  }
+}
+
 /**
  * Run a single task
  */
@@ -491,9 +571,11 @@ export async function runTask({
   config,
   index,
   worktreeDir,
+  pipelineBranch,
   taskBranch,
   chatId,
   runDir,
+  noGit = false,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -503,13 +585,19 @@ export async function runTask({
   taskBranch: string;
   chatId: string;
   runDir: string;
+  noGit?: boolean;
 }): Promise<TaskExecutionResult> {
   const model = task.model || config.model || 'sonnet-4.5';
+  const timeout = task.timeout || config.timeout;
   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}`);
+  }
   
   events.emit('task.started', {
     taskName: task.name,
@@ -517,14 +605,16 @@ export async function runTask({
     index,
   });
 
-  // Checkout task branch
-  git.runGit(['checkout', '-B', taskBranch], { cwd: worktreeDir });
+  // 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,
@@ -545,8 +635,9 @@ export async function runTask({
     prompt: prompt1,
     model,
     signalDir: runDir,
-    timeout: config.timeout,
+    timeout,
     enableIntervention: config.enableIntervention,
+    outputFormat: config.agentOutputFormat,
   });
   
   const duration = Date.now() - startTime;
@@ -588,8 +679,41 @@ 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 });
+  }
+
+  // Automatic Review
+  const reviewEnabled = config.reviewAllTasks || task.acceptanceCriteria?.length || config.enableReview;
+  
+  if (reviewEnabled) {
+    logger.section(`🔍 Reviewing Task: ${task.name}`);
+    const reviewResult = await runReviewLoop({
+      taskResult: {
+        taskName: task.name,
+        taskBranch: taskBranch,
+        acceptanceCriteria: task.acceptanceCriteria,
+      },
+      worktreeDir,
+      runDir,
+      config,
+      workChatId: chatId,
+      model, // Use the same model as requested
+      cursorAgentSend,
+      cursorAgentCreateChat,
+    });
+
+    if (!reviewResult.approved) {
+      logger.error(`❌ Task review failed after ${reviewResult.iterations} iterations`);
+      return {
+        taskName: task.name,
+        taskBranch,
+        status: 'ERROR',
+        error: reviewResult.error || 'Task failed to pass review criteria',
+      };
+    }
+  }
   
   events.emit('task.completed', {
     taskName: task.name,
@@ -607,8 +731,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...');
@@ -648,18 +777,27 @@ 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');
   let state: LaneState | null = null;
   
-  if (startIndex > 0 && fs.existsSync(statePath)) {
-    state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (fs.existsSync(statePath)) {
+    try {
+      state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    } catch (e) {
+      logger.warn(`Failed to load existing state from ${statePath}: ${e}`);
+    }
   }
   
-  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);
+  const randomSuffix = Math.random().toString(36).substring(2, 7);
+  const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}-${randomSuffix}`;
+  // 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');
@@ -671,12 +809,28 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   logger.info(`Worktree: ${worktreeDir}`);
   logger.info(`Tasks: ${config.tasks.length}`);
   
-  // Create worktree only if starting fresh
-  if (startIndex === 0 || !fs.existsSync(worktreeDir)) {
-    git.createWorktree(worktreeDir, pipelineBranch, { 
-      baseBranch: config.baseBranch || 'main',
-      cwd: repoRoot,
-    });
+  // Create worktree only if starting fresh and worktree doesn't exist
+  if (!fs.existsSync(worktreeDir)) {
+    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,
+      });
+    }
+  } else if (!noGit) {
+    // If it exists but we are in Git mode, ensure it's actually a worktree and on the right branch
+    logger.info(`Reusing existing worktree: ${worktreeDir}`);
+    try {
+      git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
+    } catch (e) {
+      // If checkout fails, maybe the worktree is in a weird state. 
+      // For now, just log it. In a more robust impl, we might want to repair it.
+      logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
+    }
   }
   
   // Create chat
@@ -698,18 +852,20 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       dependencyRequest: null,
       tasksFile, // Store tasks file for resume
       dependsOn: config.dependsOn || [],
+      completedTasks: [],
     };
   } else {
     state.status = 'running';
     state.error = null;
     state.dependencyRequest = null;
     state.dependsOn = config.dependsOn || [];
+    state.completedTasks = state.completedTasks || [];
   }
   
   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
@@ -756,6 +912,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
@@ -764,6 +964,32 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   for (let i = startIndex; i < config.tasks.length; i++) {
     const task = config.tasks[i]!;
     const taskBranch = `${pipelineBranch}--${String(i + 1).padStart(2, '0')}-${task.name}`;
+
+    // Handle task-level dependencies
+    if (task.dependsOn && task.dependsOn.length > 0) {
+      state.status = 'waiting';
+      state.waitingFor = task.dependsOn;
+      saveState(statePath, state);
+
+      try {
+        await waitForTaskDependencies(task.dependsOn, runDir);
+        
+        if (!noGit) {
+          await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir);
+        }
+        
+        state.status = 'running';
+        state.waitingFor = [];
+        saveState(statePath, state);
+      } catch (e: any) {
+        state.status = 'failed';
+        state.waitingFor = [];
+        state.error = e.message;
+        saveState(statePath, state);
+        logger.error(`Task dependency wait/merge failed: ${e.message}`);
+        process.exit(1);
+      }
+    }
     
     const result = await runTask({
       task,
@@ -774,12 +1000,17 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       taskBranch,
       chatId,
       runDir,
+      noGit,
     });
     
     results.push(result);
     
     // Update state
     state.currentTaskIndex = i + 1;
+    state.completedTasks = state.completedTasks || [];
+    if (!state.completedTasks.includes(task.name)) {
+      state.completedTasks.push(task.name);
+    }
     saveState(statePath, state);
     
     // Handle blocked or error
@@ -807,17 +1038,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 });
+    // 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);
-    }
+      // Log changed files
+      const stats = git.getLastOperationStats(worktreeDir);
+      if (stats) {
+        logger.info('Changed files:\n' + stats);
+      }
 
-    git.push(pipelineBranch, { cwd: worktreeDir });
+      git.push(pipelineBranch, { cwd: worktreeDir });
+    } else {
+      logger.info(`✓ Task ${task.name} completed (noGit mode - no branch operations)`);
+    }
   }
   
   // Complete
@@ -825,6 +1060,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;
 }
@@ -844,6 +1114,7 @@ if (require.main === module) {
   const runDirIdx = args.indexOf('--run-dir');
   const startIdxIdx = args.indexOf('--start-index');
   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;
@@ -856,9 +1127,10 @@ if (require.main === module) {
   
   events.setRunId(runId);
 
-  // Load global config to register webhooks in this process
+  // Load global config for defaults and webhooks
+  let globalConfig;
   try {
-    const globalConfig = loadConfig();
+    globalConfig = loadConfig();
     if (globalConfig.webhooks) {
       registerWebhooks(globalConfig.webhooks);
     }
@@ -883,14 +1155,17 @@ if (require.main === module) {
     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);
     })