@litmers/cursorflow-orchestrator 0.2.3 → 0.2.5

package/src/cli/logs.ts

@@ -10,10 +10,9 @@ import { safeJoin } from '../utils/path';
 import { 
   readJsonLog, 
   exportLogs, 
-  stripAnsi,
   JsonLogEntry 
 } from '../utils/enhanced-logger';
-import { formatPotentialJsonMessage } from '../utils/log-formatter';
+import { formatMessageForConsole, formatPotentialJsonMessage, stripAnsi } from '../services/logging/formatter';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 import { startLogViewer } from '../ui/log-viewer';
 
@@ -152,32 +151,33 @@ function listLanes(runDir: string): string[] {
 }
 
 /**
- * Read and display text logs
+ * Read and display text logs (converted from JSONL)
  */
 function displayTextLogs(
   laneDir: string, 
   options: LogsOptions
 ): void {
-  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;
-  }
+  const logFile = safeJoin(laneDir, 'terminal.jsonl');
   
   if (!fs.existsSync(logFile)) {
     console.log('No log file found.');
     return;
   }
   
-  let content = fs.readFileSync(logFile, 'utf8');
-  let lines = content.split('\n');
+  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)}`;
+  });
   
-  // Apply filter (case-insensitive string match to avoid ReDoS)
+  // Apply filter
   if (options.filter) {
     const filterLower = options.filter.toLowerCase();
     lines = lines.filter(line => line.toLowerCase().includes(filterLower));
@@ -188,11 +188,6 @@ 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'));
 }
 
@@ -708,16 +703,7 @@ function escapeHtml(text: string): string {
  * Follow logs in real-time
  */
 function followLogs(laneDir: string, options: LogsOptions): void {
-  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;
-  }
+  const logFile = safeJoin(laneDir, 'terminal.jsonl');
   
   if (!fs.existsSync(logFile)) {
     console.log('Waiting for log file...');
@@ -725,17 +711,14 @@ 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');
@@ -744,28 +727,37 @@ function followLogs(laneDir: string, options: LogsOptions): void {
         const buffer = Buffer.alloc(stats.size - lastSize);
         fs.readSync(fd, buffer, 0, buffer.length, lastSize);
         
-        let content = buffer.toString();
-        
-        // 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);
-        }
+        const content = buffer.toString();
+        const lines = content.split('\n').filter(l => l.trim());
         
-        if (content.trim()) {
-          process.stdout.write(content);
+        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
+          }
         }
         
         lastSize = stats.size;
       }
     } catch {
-      // Ignore errors (file might be rotating)
+      // Ignore errors
     } finally {
       if (fd !== null) {
         try { fs.closeSync(fd); } catch { /* ignore */ }
@@ -860,19 +852,13 @@ function displaySummary(runDir: string): void {
   
   for (const lane of lanes) {
     const laneDir = safeJoin(runDir, 'lanes', lane);
-    const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-    const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+    const jsonlLog = safeJoin(laneDir, 'terminal.jsonl');
     
     console.log(`  ${logger.COLORS.green}📁 ${lane}${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)}`);
+    if (fs.existsSync(jsonlLog)) {
+      const stats = fs.statSync(jsonlLog);
+      console.log(`     └─ terminal.jsonl ${formatSize(stats.size)} ${logger.COLORS.yellow}(unified)${logger.COLORS.reset}`);
     }
     
     console.log('');

package/src/cli/monitor.ts

@@ -672,6 +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';
     
     return [
       {
@@ -690,6 +691,14 @@ 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',
@@ -716,6 +725,8 @@ 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 [
       {
@@ -726,6 +737,14 @@ 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',
@@ -874,6 +893,45 @@ 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;
     
@@ -1352,55 +1410,15 @@ class InteractiveMonitor {
   }
   
   private getTerminalLines(lanePath: string, maxLines: number): string[] {
-    const { dim, reset, cyan, green, yellow, red, gray } = UI.COLORS;
+    const { dim, reset } = UI.COLORS;
     
-    // 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}`];
+    // 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);
     }
     
-    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}`];
-    }
+    return [`${dim}(No output yet)${reset}`];
   }
   
   /**

package/src/cli/resume.ts

@@ -17,7 +17,7 @@ import {
   createLogManager, 
   ParsedMessage
 } from '../utils/enhanced-logger';
-import { formatMessageForConsole } from '../utils/log-formatter';
+import { formatMessageForConsole } from '../services/logging/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}`);
+      logger.debug(`[GitLifecycle] ${message}`, { context: 'git' });
     } else {
-      logger.info(`[GitLifecycle] ${message}`);
+      logger.info(`[GitLifecycle] ${message}`, { context: 'git' });
     }
   }
   

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}`);
-      logger.info(`   Cleaning up invalid directory and recreating worktree...`);
+      logger.warn(`⚠️ Directory exists but is not a valid worktree: ${worktreeDir}`, { context: 'git' });
+      logger.info(`   Cleaning up invalid directory and recreating worktree...`, { context: 'git' });
       try {
         git.cleanupInvalidWorktreeDir(worktreeDir);
       } catch (e: any) {
-        logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`);
+        logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`, { context: 'git' });
         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)`);
+            logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`, { context: 'git' });
             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}`);
+      logger.info(`Reusing existing worktree: ${worktreeDir}`, { context: 'git' });
       try {
         git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
       } catch (e) {
-        logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
+        logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`, { context: 'git' });
       }
     }
   }
@@ -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`);
+    logger.info(`🔄 Syncing with ${pipelineBranch} before merging dependencies`, { context: 'git' });
     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}`);
+        logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`, { context: 'git' });
         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}`);
-          logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
+          logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`, { context: 'git' });
+          logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`, { context: 'git' });
 
           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(', ')}`);
+            logger.error(`Merge conflict with ${laneName}: ${mergeResult.conflictingFiles.join(', ')}`, { context: 'git' });
             throw new Error(`Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
           }
           throw new Error(mergeResult.error || 'Merge failed');
         }
 
-        logger.success(`✓ Merged ${laneName}`);
+        logger.success(`✓ Merged ${laneName}`, { context: 'git' });
       } catch (e) {
-        logger.error(`Failed to merge branch from ${laneName}: ${e}`);
+        logger.error(`Failed to merge branch from ${laneName}: ${e}`, { context: 'git' });
         throw e;
       }
     }
@@ -150,15 +150,15 @@ export class GitPipelineCoordinator {
     pipelineBranch: string;
     worktreeDir: string;
   }): void {
-    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
-    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`);
+    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`, { context: 'git' });
+    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`, { context: 'git' });
     git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
 
     const conflictCheck = git.checkMergeConflict(taskBranch, { cwd: worktreeDir });
     if (conflictCheck.willConflict) {
-      logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`);
-      logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
-      logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`);
+      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' });
 
       events.emit('merge.conflict_detected', {
         taskName,
@@ -169,7 +169,7 @@ export class GitPipelineCoordinator {
       });
     }
 
-    logger.info(`🔀 Merging task ${taskName} (${taskBranch}) into ${pipelineBranch}`);
+    logger.info(`🔀 Merging task ${taskName} (${taskBranch}) into ${pipelineBranch}`, { context: 'git' });
     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(', ')}`);
+        logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`, { context: 'git' });
         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);
+      logger.info('Changed files:\n' + stats, { context: 'git' });
     }
   }
 
@@ -204,18 +204,18 @@ export class GitPipelineCoordinator {
   }): void {
     if (flowBranch === pipelineBranch) return;
 
-    logger.info(`🌿 Creating final flow branch: ${flowBranch}`);
+    logger.info(`🌿 Creating final flow branch: ${flowBranch}`, { context: 'git' });
     try {
       git.runGit(['checkout', '-B', flowBranch, pipelineBranch], { cwd: worktreeDir });
       git.push(flowBranch, { cwd: worktreeDir, setUpstream: true });
 
-      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`);
+      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`, { context: 'git' });
       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.`);
+      logger.success(`✓ Flow branch '${flowBranch}' created. Remote pipeline branch preserved for dependencies.`, { context: 'git' });
     } catch (e) {
-      logger.error(`❌ Failed during final consolidation: ${e}`);
+      logger.error(`❌ Failed during final consolidation: ${e}`, { context: 'git' });
     }
   }
 }

package/src/core/orchestrator.ts

@@ -26,11 +26,10 @@ import {
   EnhancedLogManager, 
   createLogManager, 
   DEFAULT_LOG_CONFIG,
-  ParsedMessage,
-  stripAnsi
+  ParsedMessage
 } from '../utils/enhanced-logger';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
-import { formatMessageForConsole } from '../utils/log-formatter';
+import { formatMessageForConsole, stripAnsi } from '../services/logging/formatter';
 import { FailureType, analyzeFailure as analyzeFailureFromPolicy } from './failure-policy';
 import { 
   savePOF,
@@ -293,6 +292,7 @@ export function spawnLane({
   // Build environment for child process
   const childEnv = {
     ...process.env,
+    CURSORFLOW_LANE: 'true',
   };
   
   if (logConfig.enabled) {
@@ -392,7 +392,7 @@ export function spawnLane({
     return { child, logPath, logManager, info };
   } else {
     // Fallback to simple file logging
-    logPath = getLaneLogPath(laneRunDir, 'raw');
+    logPath = getLaneLogPath(laneRunDir, 'jsonl');
     const logFd = fs.openSync(logPath, 'a');
     
     child = spawn('node', args, {
@@ -519,12 +519,12 @@ async function resolveAllDependencies(
   const worktreeDir = state?.worktreeDir || safeJoin(runRoot, 'resolution-worktree');
 
   if (!fs.existsSync(worktreeDir)) {
-    logger.info(`🏗️ Creating resolution worktree at ${worktreeDir}`);
+    logger.info(`🏗️ Creating resolution worktree at ${worktreeDir}`, { context: 'git' });
     git.createWorktree(worktreeDir, pipelineBranch, { baseBranch: git.getCurrentBranch() });
   }
 
   // 3. Resolve on pipeline branch
-  logger.info(`🔄 Resolving dependencies on branch ${pipelineBranch}`);
+  logger.info(`🔄 Resolving dependencies on branch ${pipelineBranch}`, { context: 'git' });
   git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
   
   for (const cmd of uniqueCommands) {
@@ -566,7 +566,7 @@ async function resolveAllDependencies(
     if (task) {
       const lanePipelineBranch = `${pipelineBranch}/${lane.name}`;
       const taskBranch = `${lanePipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
-      logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`);
+      logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`, { context: 'git' });
       
       try {
         // If task branch doesn't exist yet, it will be created from pipelineBranch when the lane starts

package/src/core/runner/pipeline.ts

@@ -156,7 +156,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   // ALWAYS use current branch as base - ignore config.baseBranch
   // This ensures dependency structure is maintained in the worktree
   const currentBranch = git.getCurrentBranch(repoRoot);
-  logger.info(`📍 Base branch: ${currentBranch} (current branch)`);
+  logger.info(`📍 Base branch: ${currentBranch} (current branch)`, { context: 'git' });
   
   // Load existing state if resuming
   const statePath = safeJoin(runDir, 'state.json');
@@ -207,8 +207,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     logger.section(`🔁 Resuming Pipeline from task ${startIndex + 1}`);
   }
   
-  logger.info(`Pipeline Branch: ${pipelineBranch}`);
-  logger.info(`Worktree: ${worktreeDir}`);
+  logger.info(`Pipeline Branch: ${pipelineBranch}`, { context: 'git' });
+  logger.info(`Worktree: ${worktreeDir}`, { context: 'git' });
   logger.info(`Tasks: ${config.tasks.length}`);
   
   const gitCoordinator = new GitPipelineCoordinator();

package/src/hooks/data-accessor.ts

@@ -333,9 +333,9 @@ export class HookDataAccessorImpl implements HookDataAccessor {
       }
       
       try {
-        // Try multiple possible log file locations
+        // Try multiple possible log file locations, preferring terminal.jsonl
         const possiblePaths = [
-          safeJoin(this.options.runDir, 'terminal-raw.log'),
+          safeJoin(this.options.runDir, 'terminal.jsonl'),
           safeJoin(this.options.runDir, 'terminal.log'),
           safeJoin(this.options.runDir, 'agent-output.log'),
         ];