@litmers/cursorflow-orchestrator 0.1.14 → 0.1.15

package/src/core/runner.ts

@@ -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,14 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
   timeout?: number;
   /** Enable stdin piping for intervention feature (may cause buffering issues on some systems) */
   enableIntervention?: boolean;
+  /** Output format for cursor-agent (default: 'stream-json') */
+  outputFormat?: 'stream-json' | 'json' | 'plain';
 }): Promise<AgentSendResult> {
   // Use stream-json format for structured output with tool calls and results
+  const format = outputFormat || 'stream-json';
   const args = [
     '--print',
-    '--output-format', 'stream-json',
+    '--output-format', format,
     '--workspace', workspaceDir,
     ...(model ? ['--model', model] : []),
     '--resume', chatId,
@@ -426,33 +429,31 @@ export function extractDependencyRequest(text: string): { required: boolean; pla
 /**
  * Wrap prompt with dependency policy
  */
-export function wrapPromptForDependencyPolicy(prompt: string, policy: DependencyPolicy): string {
-  if (policy.allowDependencyChange && !policy.lockfileReadOnly) {
+export function wrapPromptForDependencyPolicy(prompt: string, policy: DependencyPolicy, options: { noGit?: boolean } = {}): string {
+  const { noGit = false } = options;
+  
+  if (policy.allowDependencyChange && !policy.lockfileReadOnly && !noGit) {
     return prompt;
   }
   
-  return `# Dependency Policy (MUST FOLLOW)
-
-You are running in a restricted lane.
-
-- allowDependencyChange: ${policy.allowDependencyChange}
-- lockfileReadOnly: ${policy.lockfileReadOnly}
-
-Rules:
-- BEFORE making any code changes, decide whether dependency changes are required.
-- If dependency changes are required, DO NOT change any files. Instead reply with:
-
-DEPENDENCY_CHANGE_REQUIRED
-\`\`\`json
-{ "reason": "...", "changes": [...], "commands": ["pnpm add ..."], "notes": "..." }
-\`\`\`
-
-Then STOP.
-- If dependency changes are NOT required, proceed normally.
-
----
-
-${prompt}`;
+  let rules = '# Dependency Policy (MUST FOLLOW)\n\nYou are running in a restricted lane.\n\n';
+  
+  rules += `- allowDependencyChange: ${policy.allowDependencyChange}\n`;
+  rules += `- lockfileReadOnly: ${policy.lockfileReadOnly}\n`;
+  
+  if (noGit) {
+    rules += '- NO_GIT_MODE: Git is disabled. DO NOT run any git commands (commit, push, etc.). Just edit files.\n';
+  }
+  
+  rules += '\nRules:\n';
+  rules += '- BEFORE making any code changes, decide whether dependency changes are required.\n';
+  rules += '- If dependency changes are required, DO NOT change any files. Instead reply with:\n\n';
+  rules += 'DEPENDENCY_CHANGE_REQUIRED\n';
+  rules += '```json\n{ "reason": "...", "changes": [...], "commands": ["pnpm add ..."], "notes": "..." }\n```\n\n';
+  rules += 'Then STOP.\n';
+  rules += '- If dependency changes are NOT required, proceed normally.\n';
+  
+  return `${rules}\n---\n\n${prompt}`;
 }
 
 /**
@@ -491,9 +492,11 @@ export async function runTask({
   config,
   index,
   worktreeDir,
+  pipelineBranch,
   taskBranch,
   chatId,
   runDir,
+  noGit = false,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -503,13 +506,18 @@ export async function runTask({
   taskBranch: string;
   chatId: string;
   runDir: string;
+  noGit?: boolean;
 }): Promise<TaskExecutionResult> {
   const model = task.model || config.model || 'sonnet-4.5';
   const convoPath = path.join(runDir, 'conversation.jsonl');
   
   logger.section(`[${index + 1}/${config.tasks.length}] ${task.name}`);
   logger.info(`Model: ${model}`);
-  logger.info(`Branch: ${taskBranch}`);
+  if (noGit) {
+    logger.info('🚫 noGit mode: skipping branch operations');
+  } else {
+    logger.info(`Branch: ${taskBranch}`);
+  }
   
   events.emit('task.started', {
     taskName: task.name,
@@ -517,14 +525,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,
@@ -547,6 +557,7 @@ export async function runTask({
     signalDir: runDir,
     timeout: config.timeout,
     enableIntervention: config.enableIntervention,
+    outputFormat: config.agentOutputFormat,
   });
   
   const duration = Date.now() - startTime;
@@ -588,8 +599,10 @@ export async function runTask({
     };
   }
   
-  // Push task branch
-  git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
+  // Push task branch (skip in noGit mode)
+  if (!noGit) {
+    git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
+  }
   
   events.emit('task.completed', {
     taskName: task.name,
@@ -607,8 +620,13 @@ export async function runTask({
 /**
  * Run all tasks in sequence
  */
-export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number } = {}): Promise<TaskExecutionResult[]> {
+export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number; noGit?: boolean } = {}): Promise<TaskExecutionResult[]> {
   const startIndex = options.startIndex || 0;
+  const noGit = options.noGit || config.noGit || false;
+  
+  if (noGit) {
+    logger.info('🚫 Running in noGit mode - Git operations will be skipped');
+  }
   
   // Validate configuration before starting
   logger.info('Validating task configuration...');
@@ -648,7 +666,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   logger.success('✓ Cursor authentication OK');
   
-  const repoRoot = git.getRepoRoot();
+  // In noGit mode, we don't need repoRoot - use current directory
+  const repoRoot = noGit ? process.cwd() : git.getRepoRoot();
   
   // Load existing state if resuming
   const statePath = path.join(runDir, 'state.json');
@@ -659,7 +678,10 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   }
   
   const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}`;
-  const worktreeDir = state?.worktreeDir || path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch);
+  // In noGit mode, use a simple local directory instead of worktree
+  const worktreeDir = state?.worktreeDir || (noGit 
+    ? path.join(repoRoot, config.worktreeRoot || '_cursorflow/workdir', pipelineBranch.replace(/\//g, '-'))
+    : path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch));
   
   if (startIndex === 0) {
     logger.section('🚀 Starting Pipeline');
@@ -673,10 +695,16 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   // Create worktree only if starting fresh
   if (startIndex === 0 || !fs.existsSync(worktreeDir)) {
-    git.createWorktree(worktreeDir, pipelineBranch, { 
-      baseBranch: config.baseBranch || 'main',
-      cwd: repoRoot,
-    });
+    if (noGit) {
+      // In noGit mode, just create the directory
+      logger.info(`Creating work directory: ${worktreeDir}`);
+      fs.mkdirSync(worktreeDir, { recursive: true });
+    } else {
+      git.createWorktree(worktreeDir, pipelineBranch, { 
+        baseBranch: config.baseBranch || 'main',
+        cwd: repoRoot,
+      });
+    }
   }
   
   // Create chat
@@ -708,8 +736,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   saveState(statePath, state);
   
-  // Merge dependencies if any
-  if (startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
+  // Merge dependencies if any (skip in noGit mode)
+  if (!noGit && startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
     logger.section('🔗 Merging Dependencies');
     
     // The runDir for the lane is passed in. Dependencies are in ../<depName> relative to this runDir
@@ -756,6 +784,50 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     
     // Push the merged state
     git.push(pipelineBranch, { cwd: worktreeDir });
+  } else if (noGit && startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
+    logger.info('⚠️ Dependencies specified but Git is disabled - copying files instead of merging');
+    
+    // The runDir for the lane is passed in. Dependencies are in ../<depName> relative to this runDir
+    const lanesRoot = path.dirname(runDir);
+    
+    for (const depName of config.dependsOn) {
+      const depRunDir = path.join(lanesRoot, depName);
+      const depStatePath = path.join(depRunDir, 'state.json');
+      
+      if (!fs.existsSync(depStatePath)) {
+        continue;
+      }
+      
+      try {
+        const depState = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+        if (depState.worktreeDir && fs.existsSync(depState.worktreeDir)) {
+          logger.info(`Copying files from dependency ${depName}: ${depState.worktreeDir} → ${worktreeDir}`);
+          
+          // Use a simple recursive copy (excluding Git and internal dirs)
+          const copyFiles = (src: string, dest: string) => {
+            if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+            const entries = fs.readdirSync(src, { withFileTypes: true });
+            
+            for (const entry of entries) {
+              if (entry.name === '.git' || entry.name === '_cursorflow' || entry.name === 'node_modules') continue;
+              
+              const srcPath = path.join(src, entry.name);
+              const destPath = path.join(dest, entry.name);
+              
+              if (entry.isDirectory()) {
+                copyFiles(srcPath, destPath);
+              } else {
+                fs.copyFileSync(srcPath, destPath);
+              }
+            }
+          };
+          
+          copyFiles(depState.worktreeDir, worktreeDir);
+        }
+      } catch (e) {
+        logger.error(`Failed to copy dependency ${depName}: ${e}`);
+      }
+    }
   }
   
   // Run tasks
@@ -774,6 +846,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       taskBranch,
       chatId,
       runDir,
+      noGit,
     });
     
     results.push(result);
@@ -807,17 +880,21 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       process.exit(1);
     }
     
-    // Merge into pipeline
-    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
-    git.merge(taskBranch, { cwd: worktreeDir, noFf: true });
-
-    // 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 });
+      git.push(pipelineBranch, { cwd: worktreeDir });
+    } else {
+      logger.info(`✓ Task ${task.name} completed (noGit mode - no branch operations)`);
+    }
   }
   
   // Complete
@@ -825,6 +902,41 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   state.endTime = Date.now();
   saveState(statePath, state);
   
+  // Log final file summary
+  if (noGit) {
+    const getFileSummary = (dir: string): { files: number; dirs: number } => {
+      let stats = { files: 0, dirs: 0 };
+      if (!fs.existsSync(dir)) return stats;
+      
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === '.git' || entry.name === '_cursorflow' || entry.name === 'node_modules') continue;
+        
+        if (entry.isDirectory()) {
+          stats.dirs++;
+          const sub = getFileSummary(path.join(dir, entry.name));
+          stats.files += sub.files;
+          stats.dirs += sub.dirs;
+        } else {
+          stats.files++;
+        }
+      }
+      return stats;
+    };
+    
+    const summary = getFileSummary(worktreeDir);
+    logger.info(`Final Workspace Summary (noGit): ${summary.files} files, ${summary.dirs} directories created/modified`);
+  } else {
+    try {
+      const stats = git.runGit(['diff', '--stat', config.baseBranch || 'main', pipelineBranch], { cwd: repoRoot, silent: true });
+      if (stats) {
+        logger.info('Final Workspace Summary (Git):\n' + stats);
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+  
   logger.success('All tasks completed!');
   return results;
 }
@@ -844,6 +956,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 +969,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 +997,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);
     })

package/src/utils/config.ts

@@ -17,7 +17,9 @@ export function findProjectRoot(cwd = process.cwd()): string {
   
   while (current !== path.parse(current).root) {
     const packagePath = path.join(current, 'package.json');
-    if (fs.existsSync(packagePath)) {
+    const configPath = path.join(current, 'cursorflow.config.js');
+    
+    if (fs.existsSync(packagePath) || fs.existsSync(configPath)) {
       return current;
     }
     current = path.dirname(current);
@@ -72,6 +74,7 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     // Advanced
     worktreePrefix: 'cursorflow-',
     maxConcurrentLanes: 10,
+    agentOutputFormat: 'stream-json',
     
     // Webhooks
     webhooks: [],
@@ -194,6 +197,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Advanced
   worktreePrefix: 'cursorflow-',
   maxConcurrentLanes: 10,
+  agentOutputFormat: 'stream-json', // 'stream-json' | 'json' | 'plain'
 
   // Webhook configuration
   // webhooks: [

package/src/utils/enhanced-logger.ts

@@ -384,11 +384,13 @@ export class EnhancedLogManager {
   private cleanTransform: CleanLogTransform | null = null;
   private streamingParser: StreamingMessageParser | null = null;
   private lineBuffer: string = '';
+  private onParsedMessage?: (msg: ParsedMessage) => void;
 
-  constructor(logDir: string, session: LogSession, config: Partial<EnhancedLogConfig> = {}) {
+  constructor(logDir: string, session: LogSession, config: Partial<EnhancedLogConfig> = {}, onParsedMessage?: (msg: ParsedMessage) => void) {
     this.config = { ...DEFAULT_LOG_CONFIG, ...config };
     this.session = session;
     this.logDir = logDir;
+    this.onParsedMessage = onParsedMessage;
     
     // Ensure log directory exists
     fs.mkdirSync(logDir, { recursive: true });
@@ -450,6 +452,9 @@ export class EnhancedLogManager {
     // Create streaming parser for readable log
     this.streamingParser = new StreamingMessageParser((msg) => {
       this.writeReadableMessage(msg);
+      if (this.onParsedMessage) {
+        this.onParsedMessage(msg);
+      }
     });
   }
   
@@ -464,41 +469,44 @@ export class EnhancedLogManager {
     
     switch (msg.type) {
       case 'system':
-        formatted = `\n${ts}\n${msg.content}\n`;
+        formatted = `[${ts}] ⚙️ SYSTEM: ${msg.content}\n`;
         break;
         
       case 'user':
-        // Format user prompt nicely
-        const promptPreview = msg.content.length > 200 
-          ? msg.content.substring(0, 200) + '...'
-          : msg.content;
-        formatted = `\n${ts}\n┌─ 🧑 USER ─────────────────────────────────────────────\n${this.indentText(promptPreview, '│ ')}\n└───────────────────────────────────────────────────────\n`;
-        break;
-        
       case 'assistant':
       case 'result':
-        // Format assistant response
+        // Format with brackets and line (compact)
+        const isUser = msg.type === 'user';
         const isResult = msg.type === 'result';
-        const header = isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
+        const headerText = isUser ? '🧑 USER' : isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
         const duration = msg.metadata?.duration_ms 
           ? ` (${Math.round(msg.metadata.duration_ms / 1000)}s)`
           : '';
-        formatted = `\n${ts}\n┌─ ${header}${duration} ──────────────────────────────────\n${this.indentText(msg.content, '│ ')}\n└───────────────────────────────────────────────────────\n`;
+        
+        const label = `[ ${headerText}${duration} ] `;
+        const totalWidth = 80;
+        const topBorder = `┌─${label}${'─'.repeat(Math.max(0, totalWidth - label.length - 2))}`;
+        const bottomBorder = `└─${'─'.repeat(totalWidth - 2)}`;
+
+        const lines = msg.content.split('\n');
+        formatted = `[${ts}] ${topBorder}\n`;
+        for (const line of lines) {
+          formatted += `[${ts}] │ ${line}\n`;
+        }
+        formatted += `[${ts}] ${bottomBorder}\n`;
         break;
         
       case 'tool':
-        // Format tool call
-        formatted = `${ts} 🔧 ${msg.content}\n`;
+        formatted = `[${ts}] 🔧 TOOL: ${msg.content}\n`;
         break;
         
       case 'tool_result':
-        // Format tool result (truncated)
-        const lines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
-        formatted = `${ts} 📄 ${msg.metadata?.toolName || 'Tool'}${lines}\n`;
+        const toolResultLines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
+        formatted = `[${ts}] 📄 RESL: ${msg.metadata?.toolName || 'Tool'}${toolResultLines}\n`;
         break;
         
       default:
-        formatted = `${ts} ${msg.content}\n`;
+        formatted = `[${ts}] ${msg.content}\n`;
     }
     
     try {
@@ -661,9 +669,37 @@ export class EnhancedLogManager {
       this.cleanTransform.write(data);
     }
     
-    // Parse streaming JSON for readable log
+    // Parse streaming JSON for readable log (handles boxes, messages, tool calls)
     this.parseStreamingData(text);
     
+    // Also include significant info/status lines in readable log (compact)
+    if (this.readableLogFd !== null) {
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const cleanLine = stripAnsi(line).trim();
+        // Look for log lines: [ISO_DATE] [LEVEL] ...
+        if (cleanLine && 
+            !cleanLine.startsWith('{') && 
+            !this.isNoiseLog(cleanLine) && 
+            /\[\d{4}-\d{2}-\d{2}T/.test(cleanLine)) {
+          
+          try {
+            // Check if it has a level marker
+            if (/\[(INFO|WARN|ERROR|SUCCESS|DEBUG)\]/.test(cleanLine)) {
+              // Special formatting for summary
+              if (cleanLine.includes('Final Workspace Summary')) {
+                const tsMatch = cleanLine.match(/\[(\d{4}-\d{2}-\d{2}T[^\]]+)\]/);
+                const ts = tsMatch ? tsMatch[1] : new Date().toISOString();
+                fs.writeSync(this.readableLogFd, `[${ts}] 📊 SUMMARY: ${cleanLine.split(']').slice(2).join(']').trim()}\n`);
+              } else {
+                fs.writeSync(this.readableLogFd, `${cleanLine}\n`);
+              }
+            }
+          } catch {}
+        }
+      }
+    }
+    
     // Write JSON entry (for significant lines only)
     if (this.config.writeJsonLog) {
       const cleanText = stripAnsi(text).trim();
@@ -717,6 +753,20 @@ export class EnhancedLogManager {
     if (this.cleanTransform) {
       this.cleanTransform.write(data);
     }
+
+    // Also include error lines in readable log (compact)
+    if (this.readableLogFd !== null) {
+      const lines = text.split('\n');
+      for (const line of lines) {
+        const cleanLine = stripAnsi(line).trim();
+        if (cleanLine && !this.isNoiseLog(cleanLine)) {
+          try {
+            const ts = new Date().toISOString();
+            fs.writeSync(this.readableLogFd, `[${ts}] ❌ STDERR: ${cleanLine}\n`);
+          } catch {}
+        }
+      }
+    }
     
     // Write JSON entry
     if (this.config.writeJsonLog) {
@@ -747,6 +797,15 @@ export class EnhancedLogManager {
       this.writeToRawLog(line);
     }
     
+    // Write to readable log (compact)
+    if (this.readableLogFd !== null) {
+      const typeLabel = level === 'error' ? '❌ ERROR' : level === 'info' ? 'ℹ️ INFO' : '🔍 DEBUG';
+      const formatted = `${new Date().toISOString()} ${typeLabel}: ${message}\n`;
+      try {
+        fs.writeSync(this.readableLogFd, formatted);
+      } catch {}
+    }
+
     if (this.config.writeJsonLog) {
       this.writeJsonEntry({
         timestamp: new Date().toISOString(),
@@ -770,6 +829,15 @@ export class EnhancedLogManager {
     if (this.config.keepRawLogs) {
       this.writeToRawLog(line);
     }
+
+    // Write to readable log (compact)
+    if (this.readableLogFd !== null) {
+      const ts = new Date().toISOString();
+      const formatted = `[${ts}] ━━━ ${title} ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+      try {
+        fs.writeSync(this.readableLogFd, formatted);
+      } catch {}
+    }
   }
 
   /**
@@ -922,7 +990,8 @@ export class EnhancedLogManager {
 export function createLogManager(
   laneRunDir: string,
   laneName: string,
-  config?: Partial<EnhancedLogConfig>
+  config?: Partial<EnhancedLogConfig>,
+  onParsedMessage?: (msg: ParsedMessage) => void
 ): EnhancedLogManager {
   const session: LogSession = {
     id: `${laneName}-${Date.now().toString(36)}`,
@@ -930,7 +999,7 @@ export function createLogManager(
     startTime: Date.now(),
   };
   
-  return new EnhancedLogManager(laneRunDir, session, config);
+  return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
 }
 
 /**

package/src/utils/git.ts

@@ -217,12 +217,27 @@ export function commit(message: string, options: { cwd?: string; addAll?: boolea
   runGit(['commit', '-m', message], { cwd });
 }
 
+/**
+ * Check if a remote exists
+ */
+export function remoteExists(remoteName = 'origin', options: { cwd?: string } = {}): boolean {
+  const result = runGitResult(['remote'], { cwd: options.cwd });
+  if (!result.success) return false;
+  return result.stdout.split('\n').map(r => r.trim()).includes(remoteName);
+}
+
 /**
  * Push to remote
  */
 export function push(branchName: string, options: { cwd?: string; force?: boolean; setUpstream?: boolean } = {}): void {
   const { cwd, force = false, setUpstream = false } = options;
   
+  // Check if origin exists before pushing
+  if (!remoteExists('origin', { cwd })) {
+    // If no origin, just skip pushing (useful for local tests)
+    return;
+  }
+
   const args = ['push'];
   
   if (force) {

package/src/utils/logger.ts

@@ -16,7 +16,9 @@ export const COLORS = {
   green: '\x1b[32m',
   blue: '\x1b[34m',
   cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
   gray: '\x1b[90m',
+  bold: '\x1b[1m',
 };
 
 let currentLogLevel: number = LogLevel.info;
@@ -38,7 +40,8 @@ export function setLogLevel(level: string | number): void {
 function formatMessage(level: string, message: string, emoji = ''): string {
   const timestamp = new Date().toISOString();
   const prefix = emoji ? `${emoji} ` : '';
-  return `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
+  const lines = String(message).split('\n');
+  return lines.map(line => `[${timestamp}] [${level.toUpperCase()}] ${prefix}${line}`).join('\n');
 }
 
 /**