@litmers/cursorflow-orchestrator 0.2.5 → 0.2.7

package/scripts/stream-logs.sh

@@ -57,7 +57,7 @@ trap 'kill $(jobs -p) 2>/dev/null' EXIT
 for lane_dir in "${LATEST_RUN}/lanes"/*; do
     if [ -d "$lane_dir" ]; then
         lane_name=$(basename "$lane_dir")
-        log_file="${lane_dir}/terminal.jsonl"
+        log_file="${lane_dir}/terminal-readable.log"
         color=${COLORS[$color_idx]}
         
         # Start streaming in background

package/scripts/test-log-parser.ts

@@ -70,13 +70,15 @@ async function main() {
   console.log('  📦 Test 2: StreamingMessageParser (JSONL Parsing)');
   console.log('━'.repeat(80) + '\n');
 
-  const jsonlLogPath = path.join(FIXTURES_DIR, 'lanes/test-lane/terminal.jsonl');
-  if (fs.existsSync(jsonlLogPath)) {
-    const jsonlLog = fs.readFileSync(jsonlLogPath, 'utf8');
-    const lines = jsonlLog.split('\n').filter(l => l.trim());
+  const rawLogPath = path.join(FIXTURES_DIR, 'lanes/test-lane/terminal-raw.log');
+  if (fs.existsSync(rawLogPath)) {
+    const rawLog = fs.readFileSync(rawLogPath, 'utf8');
+    const lines = rawLog.split('\n');
+    const jsonLines = lines.filter(l => l.trim().startsWith('{') && l.trim().endsWith('}'));
     
-    console.log(`📄 JSONL log: ${jsonlLogPath}`);
+    console.log(`📄 Raw log: ${rawLogPath}`);
     console.log(`   Total lines: ${lines.length}`);
+    console.log(`   JSON lines: ${jsonLines.length}`);
     
     // Parse with StreamingMessageParser
     const parsedMessages: ParsedMessage[] = [];
@@ -84,7 +86,7 @@ async function main() {
       parsedMessages.push(msg);
     });
     
-    for (const line of lines) {
+    for (const line of jsonLines) {
       parser.parseLine(line);
     }
     parser.flush();
@@ -115,11 +117,43 @@ async function main() {
       console.log(stripAnsi(formatted).substring(0, 100));
     }
   } else {
-    console.log('⚠️ JSONL log not found at:', jsonlLogPath);
+    console.log('⚠️ Raw log not found at:', rawLogPath);
   }
 
   // ===========================================================================
-  // Test 3: Summary
+  // Test 3: Compare with actual readable log
+  // ===========================================================================
+  console.log('\n' + '━'.repeat(80));
+  console.log('  🔍 Test 3: Compare Parser Output with Actual Log');
+  console.log('━'.repeat(80) + '\n');
+
+  const readableLogPath = path.join(FIXTURES_DIR, 'lanes/test-lane/terminal-readable.log');
+  if (fs.existsSync(readableLogPath)) {
+    const readableLog = fs.readFileSync(readableLogPath, 'utf8');
+    const readableLines = readableLog.split('\n');
+    
+    // Find agent message lines
+    const agentLines = readableLines.filter(line => 
+      line.includes('⚙️ SYS') || 
+      line.includes('🧑 USER') || 
+      line.includes('🤖 ASST') || 
+      line.includes('🔧 TOOL') || 
+      line.includes('📄 RESL')
+    );
+    
+    console.log(`📄 Readable log: ${readableLogPath}`);
+    console.log(`   Total lines: ${readableLines.length}`);
+    console.log(`   Agent message lines: ${agentLines.length}`);
+    
+    console.log(`\n📝 Actual terminal output (first 15 agent messages):`);
+    console.log('-'.repeat(60));
+    for (const line of agentLines.slice(0, 15)) {
+      console.log(stripAnsi(line).substring(0, 100));
+    }
+  }
+
+  // ===========================================================================
+  // Summary
   // ===========================================================================
   console.log('\n' + '='.repeat(80));
   console.log('✅ Log Parser Test Complete');

package/src/cli/complete.ts

@@ -200,17 +200,32 @@ async function complete(args: string[]): Promise<void> {
     for (const branch of laneBranches) {
       logger.info(`Merging ${branch}...`);
       
-      // Fetch remote branch if needed
-      if (!git.branchExists(branch, { cwd: repoRoot })) {
+      // Determine what ref to use for merge
+      let branchRef: string;
+      
+      if (git.branchExists(branch, { cwd: repoRoot })) {
+        // Local branch exists, use it directly
+        branchRef = branch;
+      } else {
+        // Local branch doesn't exist - fetch from remote with proper refspec
+        // Note: `git fetch origin <branch>` only updates FETCH_HEAD, not origin/<branch>
+        // We must use refspec to update the remote tracking ref
         logger.info(`  Fetching ${branch} from remote...`);
         try {
-          git.runGit(['fetch', 'origin', branch], { cwd: repoRoot });
+          git.runGit(['fetch', 'origin', `${branch}:refs/remotes/origin/${branch}`], { cwd: repoRoot });
+          branchRef = `origin/${branch}`;
         } catch (e) {
-          logger.warn(`  Failed to fetch ${branch}: ${e}`);
+          // Fallback: try fetching and use FETCH_HEAD directly
+          logger.warn(`  Failed to fetch with refspec, trying FETCH_HEAD: ${e}`);
+          try {
+            git.runGit(['fetch', 'origin', branch], { cwd: repoRoot });
+            branchRef = 'FETCH_HEAD';
+          } catch (e2) {
+            logger.warn(`  Failed to fetch ${branch}: ${e2}`);
+            throw new Error(`Cannot fetch branch ${branch} from remote`);
+          }
         }
       }
-
-      const branchRef = git.branchExists(branch, { cwd: repoRoot }) ? branch : `origin/${branch}`;
       
       const mergeResult = git.safeMerge(branchRef, {
         cwd: repoRoot,

package/src/cli/index.ts

@@ -22,6 +22,7 @@ const COMMANDS: Record<string, CommandFn> = {
   run: require('./run'),
   monitor: require('./monitor'),
   clean: require('./clean'),
+  complete: require('./complete'),
   resume: require('./resume'),
   doctor: require('./doctor'),
   signal: require('./signal'),
@@ -47,6 +48,7 @@ function printHelp(): void {
 \x1b[1mEXECUTION\x1b[0m
   \x1b[33mrun\x1b[0m <flow> [options]         Run orchestration (DAG-based)
   \x1b[33mmonitor\x1b[0m [run-dir] [options]  \x1b[36mInteractive\x1b[0m lane dashboard
+  \x1b[33mcomplete\x1b[0m <flow> [options]     Consolidate all lanes into one branch
   \x1b[33mstop\x1b[0m [run-id] [options]      Stop running workflows
   \x1b[33mresume\x1b[0m [lane] [options]      Resume lane(s)
 

package/src/cli/logs.ts

@@ -10,9 +10,10 @@ import { safeJoin } from '../utils/path';
 import { 
   readJsonLog, 
   exportLogs, 
+  stripAnsi,
   JsonLogEntry 
 } from '../utils/enhanced-logger';
-import { formatMessageForConsole, formatPotentialJsonMessage, stripAnsi } from '../services/logging/formatter';
+import { formatPotentialJsonMessage } from '../utils/log-formatter';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 import { startLogViewer } from '../ui/log-viewer';
 
@@ -151,33 +152,32 @@ function listLanes(runDir: string): string[] {
 }
 
 /**
- * Read and display text logs (converted from JSONL)
+ * Read and display text logs
  */
 function displayTextLogs(
   laneDir: string, 
   options: LogsOptions
 ): void {
-  const logFile = safeJoin(laneDir, 'terminal.jsonl');
+  let logFile: string;
+  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+
+  if (options.raw) {
+    logFile = rawLog;
+  } else {
+    // Default to readable log (clean option also uses readable now)
+    logFile = readableLog;
+  }
   
   if (!fs.existsSync(logFile)) {
     console.log('No log file found.');
     return;
   }
   
-  const entries = readJsonLog(logFile);
-  let lines = entries.map(entry => {
-    const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
-    const level = entry.level || 'info';
-    const content = entry.content || entry.message || '';
-    
-    if (options.raw) {
-      // In "raw" mode for JSONL, we show a basic text representation
-      return `[${ts}] [${level.toUpperCase()}] ${content}`;
-    }
-    return `[${ts}] [${level.toUpperCase()}] ${stripAnsi(content)}`;
-  });
+  let content = fs.readFileSync(logFile, 'utf8');
+  let lines = content.split('\n');
   
-  // Apply filter
+  // Apply filter (case-insensitive string match to avoid ReDoS)
   if (options.filter) {
     const filterLower = options.filter.toLowerCase();
     lines = lines.filter(line => line.toLowerCase().includes(filterLower));
@@ -188,6 +188,11 @@ function displayTextLogs(
     lines = lines.slice(-options.tail);
   }
   
+  // Clean ANSI if needed (for clean mode or default fallback)
+  if (!options.raw) {
+    lines = lines.map(line => stripAnsi(line));
+  }
+  
   console.log(lines.join('\n'));
 }
 
@@ -703,7 +708,16 @@ function escapeHtml(text: string): string {
  * Follow logs in real-time
  */
 function followLogs(laneDir: string, options: LogsOptions): void {
-  const logFile = safeJoin(laneDir, 'terminal.jsonl');
+  let logFile: string;
+  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+
+  if (options.raw) {
+    logFile = rawLog;
+  } else {
+    // Default to readable log
+    logFile = readableLog;
+  }
   
   if (!fs.existsSync(logFile)) {
     console.log('Waiting for log file...');
@@ -711,14 +725,17 @@ function followLogs(laneDir: string, options: LogsOptions): void {
   
   let lastSize = 0;
   try {
+    // Use statSync directly to avoid TOCTOU race condition
     lastSize = fs.statSync(logFile).size;
   } catch {
+    // File doesn't exist yet or other error - start from 0
     lastSize = 0;
   }
   
   console.log(`${logger.COLORS.cyan}Following ${logFile}... (Ctrl+C to stop)${logger.COLORS.reset}\n`);
   
   const checkInterval = setInterval(() => {
+    // Use fstat on open fd to avoid TOCTOU race condition
     let fd: number | null = null;
     try {
       fd = fs.openSync(logFile, 'r');
@@ -727,37 +744,28 @@ function followLogs(laneDir: string, options: LogsOptions): void {
         const buffer = Buffer.alloc(stats.size - lastSize);
         fs.readSync(fd, buffer, 0, buffer.length, lastSize);
         
-        const content = buffer.toString();
-        const lines = content.split('\n').filter(l => l.trim());
+        let content = buffer.toString();
         
-        for (const line of lines) {
-          try {
-            const entry = JSON.parse(line);
-            const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
-            const level = entry.level || 'info';
-            const levelColor = getLevelColor(level);
-            const message = entry.content || entry.message || '';
-            
-            // Apply level filter
-            if (options.level && level !== options.level) continue;
-            
-            // Apply filter
-            if (options.filter) {
-              const filterLower = options.filter.toLowerCase();
-              if (!message.toLowerCase().includes(filterLower)) continue;
-            }
-            
-            const displayMsg = options.raw ? message : stripAnsi(message);
-            console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${levelColor}[${level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${displayMsg}`);
-          } catch {
-            // Skip invalid JSON
-          }
+        // Apply filter (case-insensitive string match to avoid ReDoS)
+        if (options.filter) {
+          const filterLower = options.filter.toLowerCase();
+          const lines = content.split('\n');
+          content = lines.filter(line => line.toLowerCase().includes(filterLower)).join('\n');
+        }
+        
+        // Clean ANSI if needed (unless raw mode)
+        if (!options.raw) {
+          content = stripAnsi(content);
+        }
+        
+        if (content.trim()) {
+          process.stdout.write(content);
         }
         
         lastSize = stats.size;
       }
     } catch {
-      // Ignore errors
+      // Ignore errors (file might be rotating)
     } finally {
       if (fd !== null) {
         try { fs.closeSync(fd); } catch { /* ignore */ }
@@ -852,13 +860,19 @@ function displaySummary(runDir: string): void {
   
   for (const lane of lanes) {
     const laneDir = safeJoin(runDir, 'lanes', lane);
-    const jsonlLog = safeJoin(laneDir, 'terminal.jsonl');
+    const rawLog = safeJoin(laneDir, 'terminal-raw.log');
+    const readableLog = safeJoin(laneDir, 'terminal-readable.log');
     
     console.log(`  ${logger.COLORS.green}📁 ${lane}${logger.COLORS.reset}`);
     
-    if (fs.existsSync(jsonlLog)) {
-      const stats = fs.statSync(jsonlLog);
-      console.log(`     └─ terminal.jsonl ${formatSize(stats.size)} ${logger.COLORS.yellow}(unified)${logger.COLORS.reset}`);
+    if (fs.existsSync(readableLog)) {
+      const stats = fs.statSync(readableLog);
+      console.log(`     └─ terminal-readable.log ${formatSize(stats.size)} ${logger.COLORS.yellow}(default)${logger.COLORS.reset}`);
+    }
+    
+    if (fs.existsSync(rawLog)) {
+      const stats = fs.statSync(rawLog);
+      console.log(`     └─ terminal-raw.log      ${formatSize(stats.size)}`);
     }
     
     console.log('');

package/src/cli/monitor.ts

@@ -672,7 +672,7 @@ class InteractiveMonitor {
   private getLaneActions(lane: LaneInfo): ActionItem[] {
     const status = this.getLaneStatus(lane.path, lane.name);
     const isRunning = status.status === 'running';
-    const isCompleted = status.status === 'completed' || status.status === 'success';
+    const isCompleted = status.status === 'completed';
     
     return [
       {
@@ -691,14 +691,6 @@ class InteractiveMonitor {
         disabled: !isRunning,
         disabledReason: 'Lane not running',
       },
-      {
-        id: 'resume',
-        label: 'Resume Lane',
-        icon: '▶️',
-        action: () => this.resumeLane(lane),
-        disabled: isRunning || isCompleted,
-        disabledReason: isRunning ? 'Lane already running' : 'Lane already completed',
-      },
       {
         id: 'stop',
         label: 'Stop Lane',
@@ -725,8 +717,6 @@ class InteractiveMonitor {
   
   private getFlowActions(flow: FlowInfo): ActionItem[] {
     const isCurrent = flow.runDir === this.runDir;
-    const isAlive = flow.isAlive;
-    const isCompleted = flow.summary.completed === flow.summary.total && flow.summary.total > 0;
     
     return [
       {
@@ -737,14 +727,6 @@ class InteractiveMonitor {
         disabled: isCurrent,
         disabledReason: 'Already viewing this flow',
       },
-      {
-        id: 'resume',
-        label: 'Resume Flow',
-        icon: '▶️',
-        action: () => this.resumeFlow(flow),
-        disabled: isAlive || isCompleted,
-        disabledReason: isAlive ? 'Flow is already running' : 'Flow is already completed',
-      },
       {
         id: 'delete',
         label: 'Delete Flow',
@@ -893,45 +875,6 @@ class InteractiveMonitor {
     this.render();
   }
   
-  private resumeFlow(flow: FlowInfo) {
-    this.runResumeCommand(['--all', '--run-dir', flow.runDir]);
-  }
-
-  private resumeLane(lane: LaneInfo) {
-    this.runResumeCommand([lane.name, '--run-dir', this.runDir]);
-  }
-
-  private runResumeCommand(args: string[]) {
-    try {
-      const { spawn } = require('child_process');
-      
-      // Determine the script to run
-      // In production, it's dist/cli/index.js. In dev, it's src/cli/index.ts.
-      let entryPoint = path.resolve(__dirname, 'index.js');
-      if (!fs.existsSync(entryPoint)) {
-        entryPoint = path.resolve(__dirname, 'index.ts');
-      }
-
-      const spawnArgs = [entryPoint, 'resume', ...args, '--skip-doctor'];
-      
-      // If it's a .ts file, we need ts-node or similar (assuming it's available)
-      const nodeArgs = entryPoint.endsWith('.ts') ? ['-r', 'ts-node/register'] : [];
-
-      const child = spawn(process.execPath, [...nodeArgs, ...spawnArgs], {
-        detached: true,
-        stdio: 'ignore',
-        env: { ...process.env, NODE_OPTIONS: '' }
-      });
-      
-      child.unref();
-      
-      const target = args[0] === '--all' ? 'flow' : `lane ${args[0]}`;
-      this.showNotification(`Resume started for ${target}`, 'success');
-    } catch (error: any) {
-      this.showNotification(`Failed to spawn resume: ${error.message}`, 'error');
-    }
-  }
-  
   private switchToFlow(flow: FlowInfo) {
     this.runDir = flow.runDir;
     
@@ -1410,15 +1353,55 @@ class InteractiveMonitor {
   }
   
   private getTerminalLines(lanePath: string, maxLines: number): string[] {
-    const { dim, reset } = UI.COLORS;
+    const { dim, reset, cyan, green, yellow, red, gray } = UI.COLORS;
     
-    // Use terminal.jsonl as the only source for structured readable format
-    const jsonlPath = safeJoin(lanePath, 'terminal.jsonl');
-    if (fs.existsSync(jsonlPath)) {
-      return this.getJsonlLogLines(jsonlPath, maxLines);
+    // Choose log source based on format setting
+    if (this.state.readableFormat) {
+      // Try JSONL first for structured readable format
+      const jsonlPath = safeJoin(lanePath, 'terminal.jsonl');
+      if (fs.existsSync(jsonlPath)) {
+        return this.getJsonlLogLines(jsonlPath, maxLines);
+      }
+    }
+    
+    // Fallback to raw terminal log
+    const logPath = safeJoin(lanePath, 'terminal-readable.log');
+    if (!fs.existsSync(logPath)) {
+      return [`${dim}(No output yet)${reset}`];
     }
     
-    return [`${dim}(No output yet)${reset}`];
+    try {
+      const content = fs.readFileSync(logPath, 'utf8');
+      const allLines = content.split('\n');
+      const totalLines = allLines.length;
+      
+      // Calculate visible range (from end, accounting for scroll offset)
+      const end = Math.max(0, totalLines - this.state.terminalScrollOffset);
+      const start = Math.max(0, end - maxLines);
+      const visibleLines = allLines.slice(start, end);
+      
+      // Format lines with syntax highlighting
+      return visibleLines.map(line => {
+        if (line.includes('[HUMAN INTERVENTION]') || line.includes('Injecting intervention:')) {
+          return `${yellow}${line}${reset}`;
+        }
+        if (line.includes('=== Task:') || line.includes('Starting task:')) {
+          return `${green}${line}${reset}`;
+        }
+        if (line.includes('Executing cursor-agent') || line.includes('cursor-agent-v')) {
+          return `${cyan}${line}${reset}`;
+        }
+        if (line.toLowerCase().includes('error') || line.toLowerCase().includes('failed')) {
+          return `${red}${line}${reset}`;
+        }
+        if (line.toLowerCase().includes('success') || line.toLowerCase().includes('completed')) {
+          return `${green}${line}${reset}`;
+        }
+        return line;
+      });
+    } catch {
+      return [`${dim}(Error reading log)${reset}`];
+    }
   }
   
   /**

package/src/cli/resume.ts

@@ -17,7 +17,7 @@ import {
   createLogManager, 
   ParsedMessage
 } from '../utils/enhanced-logger';
-import { formatMessageForConsole } from '../services/logging/formatter';
+import { formatMessageForConsole } from '../utils/log-formatter';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 
 interface ResumeOptions {

package/src/core/git-lifecycle-manager.ts

@@ -977,9 +977,9 @@ export class GitLifecycleManager {
    */
   private log(message: string): void {
     if (this.verbose) {
-      logger.debug(`[GitLifecycle] ${message}`, { context: 'git' });
+      logger.debug(`[GitLifecycle] ${message}`);
     } else {
-      logger.info(`[GitLifecycle] ${message}`, { context: 'git' });
+      logger.info(`[GitLifecycle] ${message}`);
     }
   }
   

package/src/core/git-pipeline-coordinator.ts

@@ -21,12 +21,12 @@ export class GitPipelineCoordinator {
     const worktreeIsInvalid = !worktreeNeedsCreation && !git.isValidWorktree(worktreeDir);
 
     if (worktreeIsInvalid) {
-      logger.warn(`⚠️ Directory exists but is not a valid worktree: ${worktreeDir}`, { context: 'git' });
-      logger.info(`   Cleaning up invalid directory and recreating worktree...`, { context: 'git' });
+      logger.warn(`⚠️ Directory exists but is not a valid worktree: ${worktreeDir}`);
+      logger.info(`   Cleaning up invalid directory and recreating worktree...`);
       try {
         git.cleanupInvalidWorktreeDir(worktreeDir);
       } catch (e: any) {
-        logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`, { context: 'git' });
+        logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`);
         throw new Error(`Cannot proceed: worktree directory is invalid and cleanup failed`);
       }
     }
@@ -52,7 +52,7 @@ export class GitPipelineCoordinator {
           retries--;
           if (retries > 0) {
             const delay = Math.floor(Math.random() * 1000) + 500;
-            logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`, { context: 'git' });
+            logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`);
             await new Promise(resolve => setTimeout(resolve, delay));
           }
         }
@@ -62,11 +62,11 @@ export class GitPipelineCoordinator {
         throw new Error(`Failed to create Git worktree after retries: ${lastError.message}`);
       }
     } else {
-      logger.info(`Reusing existing worktree: ${worktreeDir}`, { context: 'git' });
+      logger.info(`Reusing existing worktree: ${worktreeDir}`);
       try {
         git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
       } catch (e) {
-        logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`, { context: 'git' });
+        logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
       }
     }
   }
@@ -82,7 +82,7 @@ export class GitPipelineCoordinator {
     const lanesRoot = path.dirname(runDir);
     const lanesToMerge = new Set(deps.map(d => d.split(':')[0]!));
 
-    logger.info(`🔄 Syncing with ${pipelineBranch} before merging dependencies`, { context: 'git' });
+    logger.info(`🔄 Syncing with ${pipelineBranch} before merging dependencies`);
     git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
 
     for (const laneName of lanesToMerge) {
@@ -93,15 +93,15 @@ export class GitPipelineCoordinator {
         const state = loadState<LaneState>(depStatePath);
         if (!state?.pipelineBranch) continue;
 
-        logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`, { context: 'git' });
+        logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
         git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
 
         const remoteBranchRef = `origin/${state.pipelineBranch}`;
         const conflictCheck = git.checkMergeConflict(remoteBranchRef, { cwd: worktreeDir });
 
         if (conflictCheck.willConflict) {
-          logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`, { context: 'git' });
-          logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`, { context: 'git' });
+          logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`);
+          logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
 
           events.emit('merge.conflict_detected', {
             laneName,
@@ -125,15 +125,15 @@ export class GitPipelineCoordinator {
 
         if (!mergeResult.success) {
           if (mergeResult.conflict) {
-            logger.error(`Merge conflict with ${laneName}: ${mergeResult.conflictingFiles.join(', ')}`, { context: 'git' });
+            logger.error(`Merge conflict with ${laneName}: ${mergeResult.conflictingFiles.join(', ')}`);
             throw new Error(`Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
           }
           throw new Error(mergeResult.error || 'Merge failed');
         }
 
-        logger.success(`✓ Merged ${laneName}`, { context: 'git' });
+        logger.success(`✓ Merged ${laneName}`);
       } catch (e) {
-        logger.error(`Failed to merge branch from ${laneName}: ${e}`, { context: 'git' });
+        logger.error(`Failed to merge branch from ${laneName}: ${e}`);
         throw e;
       }
     }
@@ -150,15 +150,15 @@ export class GitPipelineCoordinator {
     pipelineBranch: string;
     worktreeDir: string;
   }): void {
-    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`, { context: 'git' });
-    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`, { context: 'git' });
+    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
+    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`);
     git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
 
     const conflictCheck = git.checkMergeConflict(taskBranch, { cwd: worktreeDir });
     if (conflictCheck.willConflict) {
-      logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`, { context: 'git' });
-      logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`, { context: 'git' });
-      logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`, { context: 'git' });
+      logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`);
+      logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
+      logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`);
 
       events.emit('merge.conflict_detected', {
         taskName,
@@ -169,7 +169,7 @@ export class GitPipelineCoordinator {
       });
     }
 
-    logger.info(`🔀 Merging task ${taskName} (${taskBranch}) into ${pipelineBranch}`, { context: 'git' });
+    logger.info(`🔀 Merging task ${taskName} (${taskBranch}) into ${pipelineBranch}`);
     const mergeResult = git.safeMerge(taskBranch, {
       cwd: worktreeDir,
       noFf: true,
@@ -179,7 +179,7 @@ export class GitPipelineCoordinator {
 
     if (!mergeResult.success) {
       if (mergeResult.conflict) {
-        logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`, { context: 'git' });
+        logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
         throw new Error(
           `Merge conflict when integrating task ${taskName}: ${mergeResult.conflictingFiles.join(', ')}`
         );
@@ -189,7 +189,7 @@ export class GitPipelineCoordinator {
 
     const stats = git.getLastOperationStats(worktreeDir);
     if (stats) {
-      logger.info('Changed files:\n' + stats, { context: 'git' });
+      logger.info('Changed files:\n' + stats);
     }
   }
 
@@ -204,18 +204,18 @@ export class GitPipelineCoordinator {
   }): void {
     if (flowBranch === pipelineBranch) return;
 
-    logger.info(`🌿 Creating final flow branch: ${flowBranch}`, { context: 'git' });
+    logger.info(`🌿 Creating final flow branch: ${flowBranch}`);
     try {
       git.runGit(['checkout', '-B', flowBranch, pipelineBranch], { cwd: worktreeDir });
       git.push(flowBranch, { cwd: worktreeDir, setUpstream: true });
 
-      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`, { context: 'git' });
+      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`);
       git.runGit(['checkout', flowBranch], { cwd: worktreeDir });
       git.deleteBranch(pipelineBranch, { cwd: worktreeDir, force: true });
 
-      logger.success(`✓ Flow branch '${flowBranch}' created. Remote pipeline branch preserved for dependencies.`, { context: 'git' });
+      logger.success(`✓ Flow branch '${flowBranch}' created. Remote pipeline branch preserved for dependencies.`);
     } catch (e) {
-      logger.error(`❌ Failed during final consolidation: ${e}`, { context: 'git' });
+      logger.error(`❌ Failed during final consolidation: ${e}`);
     }
   }
 }