@litmers/cursorflow-orchestrator 0.1.14 → 0.1.18

package/dist/core/runner.js

@@ -44,6 +44,8 @@ exports.cursorAgentSend = cursorAgentSend;
 exports.extractDependencyRequest = extractDependencyRequest;
 exports.wrapPromptForDependencyPolicy = wrapPromptForDependencyPolicy;
 exports.applyDependencyFilePermissions = applyDependencyFilePermissions;
+exports.waitForTaskDependencies = waitForTaskDependencies;
+exports.mergeDependencyBranches = mergeDependencyBranches;
 exports.runTask = runTask;
 exports.runTasks = runTasks;
 const fs = __importStar(require("fs"));
@@ -56,6 +58,7 @@ const state_1 = require("../utils/state");
 const events_1 = require("../utils/events");
 const config_1 = require("../utils/config");
 const webhook_1 = require("../utils/webhook");
+const reviewer_1 = require("./reviewer");
 /**
  * Execute cursor-agent command with timeout and better error handling
  */
@@ -173,11 +176,14 @@ function validateTaskConfig(config) {
 /**
  * Execute cursor-agent command with streaming and better error handling
  */
-async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention }) {
+async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention, outputFormat }) {
     // 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,
@@ -210,18 +216,18 @@ async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir,
             stdio: [stdinMode, 'pipe', 'pipe'],
             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));
-                }
+                // 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 (e) {
-                // Best effort
+            catch {
+                // Best effort - file may not exist yet
             }
         }
         let fullStdout = '';
@@ -392,32 +398,25 @@ function extractDependencyRequest(text) {
 /**
  * Wrap prompt with dependency policy
  */
-function wrapPromptForDependencyPolicy(prompt, policy) {
-    if (policy.allowDependencyChange && !policy.lockfileReadOnly) {
+function wrapPromptForDependencyPolicy(prompt, policy, options = {}) {
+    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}`;
 }
 /**
  * Apply file permissions based on dependency policy
@@ -444,26 +443,105 @@ function applyDependencyFilePermissions(worktreeDir, policy) {
         }
     }
 }
+/**
+ * Wait for task-level dependencies to be completed by other lanes
+ */
+async function waitForTaskDependencies(deps, runDir) {
+    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'));
+                    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) {
+                    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
+ */
+async function mergeDependencyBranches(deps, runDir, worktreeDir) {
+    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'));
+            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
  */
-async function runTask({ task, config, index, worktreeDir, taskBranch, chatId, runDir, }) {
+async function runTask({ task, config, index, worktreeDir, pipelineBranch, taskBranch, chatId, runDir, noGit = false, }) {
     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_1.events.emit('task.started', {
         taskName: task.name,
         taskBranch,
         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 });
     (0, state_1.appendLog)(convoPath, (0, state_1.createConversationEntry)('user', prompt1, {
         task: task.name,
         model,
@@ -481,8 +559,9 @@ async function runTask({ task, config, index, worktreeDir, taskBranch, chatId, r
         prompt: prompt1,
         model,
         signalDir: runDir,
-        timeout: config.timeout,
+        timeout,
         enableIntervention: config.enableIntervention,
+        outputFormat: config.agentOutputFormat,
     });
     const duration = Date.now() - startTime;
     events_1.events.emit('agent.response_received', {
@@ -519,8 +598,38 @@ async function runTask({ task, config, index, worktreeDir, taskBranch, chatId, r
             dependencyRequest: depReq.plan || null,
         };
     }
-    // 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 (0, reviewer_1.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_1.events.emit('task.completed', {
         taskName: task.name,
         taskBranch,
@@ -537,6 +646,10 @@ async function runTask({ task, config, index, worktreeDir, taskBranch, chatId, r
  */
 async function runTasks(tasksFile, config, runDir, options = {}) {
     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...');
     try {
@@ -567,15 +680,25 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
         throw new Error('Cursor authentication required. Please authenticate and try again.');
     }
     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 = 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');
     }
@@ -585,12 +708,31 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
     logger.info(`Pipeline Branch: ${pipelineBranch}`);
     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
     logger.info('Creating chat session...');
@@ -610,6 +752,7 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
             dependencyRequest: null,
             tasksFile, // Store tasks file for resume
             dependsOn: config.dependsOn || [],
+            completedTasks: [],
         };
     }
     else {
@@ -617,10 +760,11 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
         state.error = null;
         state.dependencyRequest = null;
         state.dependsOn = config.dependsOn || [];
+        state.completedTasks = state.completedTasks || [];
     }
     (0, state_1.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
         const lanesRoot = path.dirname(runDir);
@@ -660,11 +804,74 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
         // 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'));
+                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, dest) => {
+                        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
     const results = [];
     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;
+            (0, state_1.saveState)(statePath, state);
+            try {
+                await waitForTaskDependencies(task.dependsOn, runDir);
+                if (!noGit) {
+                    await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir);
+                }
+                state.status = 'running';
+                state.waitingFor = [];
+                (0, state_1.saveState)(statePath, state);
+            }
+            catch (e) {
+                state.status = 'failed';
+                state.waitingFor = [];
+                state.error = e.message;
+                (0, state_1.saveState)(statePath, state);
+                logger.error(`Task dependency wait/merge failed: ${e.message}`);
+                process.exit(1);
+            }
+        }
         const result = await runTask({
             task,
             config,
@@ -674,10 +881,15 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
             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);
+        }
         (0, state_1.saveState)(statePath, state);
         // Handle blocked or error
         if (result.status === 'BLOCKED_DEPENDENCY') {
@@ -700,20 +912,61 @@ async function runTasks(tasksFile, config, runDir, options = {}) {
             logger.error(`Task failed: ${result.error}`);
             process.exit(1);
         }
-        // Merge into pipeline
-        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);
+        // 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)`);
         }
-        git.push(pipelineBranch, { cwd: worktreeDir });
     }
     // Complete
     state.status = 'completed';
     state.endTime = Date.now();
     (0, state_1.saveState)(statePath, state);
+    // Log final file summary
+    if (noGit) {
+        const getFileSummary = (dir) => {
+            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;
 }
@@ -730,6 +983,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;
     const forcedPipelineBranch = pipelineBranchIdx >= 0 ? args[pipelineBranchIdx + 1] : null;
@@ -738,9 +992,10 @@ if (require.main === module) {
     const runsIdx = parts.lastIndexOf('runs');
     const runId = runsIdx >= 0 && parts[runsIdx + 1] ? parts[runsIdx + 1] : `run-${Date.now()}`;
     events_1.events.setRunId(runId);
-    // Load global config to register webhooks in this process
+    // Load global config for defaults and webhooks
+    let globalConfig;
     try {
-        const globalConfig = (0, config_1.loadConfig)();
+        globalConfig = (0, config_1.loadConfig)();
         if (globalConfig.webhooks) {
             (0, webhook_1.registerWebhooks)(globalConfig.webhooks);
         }
@@ -764,13 +1019,15 @@ if (require.main === module) {
         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);
     })