@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

package/src/utils/enhanced-logger.ts

@@ -1,24 +1,31 @@
 /**
- * Enhanced Logger - Comprehensive terminal output capture and management
+ * Enhanced Logger - Simplified terminal output capture
  * 
  * Features:
- * - ANSI escape sequence stripping for clean logs
- * - Automatic timestamps on each line
- * - Log rotation and size management
- * - Session headers with context
- * - Raw and clean log file options
- * - Structured JSON logs for programmatic access
- * - Streaming output support for real-time capture
+ * - Raw log: Original output as-is
+ * - Readable log: Formatted with formatMessageForConsole style
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { Transform, TransformCallback } from 'stream';
-import * as logger from './logger';
-import { EnhancedLogConfig, ParsedMessage, JsonLogEntry, LogSession } from '../types';
-export { EnhancedLogConfig, ParsedMessage, JsonLogEntry, LogSession };
+import { EnhancedLogConfig, ParsedMessage, LogSession } from '../types';
+import { formatMessageForConsole } from './log-formatter';
 import { safeJoin } from './path';
 
+export { EnhancedLogConfig, ParsedMessage, LogSession };
+
+// Re-export JsonLogEntry for backward compatibility (empty type)
+export interface JsonLogEntry {
+  timestamp: string;
+  level: string;
+  lane?: string;
+  task?: string;
+  message: string;
+  metadata?: Record<string, any>;
+  source?: string;
+  raw?: string;
+}
+
 export const DEFAULT_LOG_CONFIG: EnhancedLogConfig = {
   enabled: true,
   stripAnsi: true,
@@ -28,199 +35,14 @@ export const DEFAULT_LOG_CONFIG: EnhancedLogConfig = {
   keepRawLogs: true,
   keepAbsoluteRawLogs: false,
   raw: false,
-  writeJsonLog: true,
+  writeJsonLog: false, // Disabled by default now
   timestampFormat: 'iso',
 };
 
-/**
- * Streaming JSON Parser - Parses cursor-agent stream-json output
- * and combines tokens into readable messages
- */
-export class StreamingMessageParser {
-  private currentMessage: string = '';
-  private currentRole: string = '';
-  private messageStartTime: number = 0;
-  private onMessage: (msg: ParsedMessage) => void;
-  
-  constructor(onMessage: (msg: ParsedMessage) => void) {
-    this.onMessage = onMessage;
-  }
-  
-  /**
-   * Parse a line of JSON output from cursor-agent
-   */
-  parseLine(line: string): void {
-    const trimmed = line.trim();
-    if (!trimmed || !trimmed.startsWith('{')) return;
-    
-    try {
-      const json = JSON.parse(trimmed);
-      this.handleJsonMessage(json);
-    } catch {
-      // Not valid JSON, ignore
-    }
-  }
-  
-  private handleJsonMessage(json: any): void {
-    const type = json.type;
-    
-    switch (type) {
-      case 'system':
-        // System init message
-        this.emitMessage({
-          type: 'system',
-          role: 'system',
-          content: `[System] Model: ${json.model || 'unknown'}, Mode: ${json.permissionMode || 'default'}`,
-          timestamp: json.timestamp_ms || Date.now(),
-        });
-        break;
-        
-      case 'user':
-        // User message - emit as complete message
-        if (json.message?.content) {
-          const textContent = json.message.content
-            .filter((c: any) => c.type === 'text')
-            .map((c: any) => c.text)
-            .join('');
-          
-          this.emitMessage({
-            type: 'user',
-            role: 'user',
-            content: textContent,
-            timestamp: json.timestamp_ms || Date.now(),
-          });
-        }
-        break;
-        
-      case 'assistant':
-        // Streaming assistant message - accumulate tokens
-        if (json.message?.content) {
-          const textContent = json.message.content
-            .filter((c: any) => c.type === 'text')
-            .map((c: any) => c.text)
-            .join('');
-          
-          // Check if this is a new message or continuation
-          if (this.currentRole !== 'assistant') {
-            // Flush previous message if any
-            this.flush();
-            this.currentRole = 'assistant';
-            this.messageStartTime = json.timestamp_ms || Date.now();
-          }
-          
-          this.currentMessage += textContent;
-        }
-        break;
-        
-      case 'tool_call':
-        // Tool call - emit as formatted message
-        if (json.subtype === 'started' && json.tool_call) {
-          const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-          const toolArgs = json.tool_call[toolName]?.args || {};
-          
-          this.flush(); // Flush any pending assistant message
-          
-          this.emitMessage({
-            type: 'tool',
-            role: 'tool',
-            content: `[Tool: ${toolName}] ${JSON.stringify(toolArgs)}`,
-            timestamp: json.timestamp_ms || Date.now(),
-            metadata: { callId: json.call_id, toolName },
-          });
-        } else if (json.subtype === 'completed' && json.tool_call) {
-          const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-          const result = json.tool_call[toolName]?.result;
-          
-          if (result?.success) {
-            // Truncate large results
-            const content = result.success.content || '';
-            const truncated = content.length > 500 
-              ? content.substring(0, 500) + '... (truncated)'
-              : content;
-            
-            this.emitMessage({
-              type: 'tool_result',
-              role: 'tool',
-              content: `[Tool Result: ${toolName}] ${truncated}`,
-              timestamp: json.timestamp_ms || Date.now(),
-              metadata: { callId: json.call_id, toolName, lines: result.success.totalLines },
-            });
-          }
-        }
-        break;
-        
-      case 'result':
-        // Final result - flush any pending and emit result
-        this.flush();
-        
-        this.emitMessage({
-          type: 'result',
-          role: 'assistant',
-          content: json.result || '',
-          timestamp: json.timestamp_ms || Date.now(),
-          metadata: {
-            duration_ms: json.duration_ms,
-            is_error: json.is_error,
-            subtype: json.subtype,
-          },
-        });
-        break;
-        
-      case 'thinking':
-        // Thinking message (Claude 3.7+ etc.)
-        if (json.subtype === 'delta' && json.text) {
-          // Check if this is a new message or continuation
-          if (this.currentRole !== 'thinking') {
-            // Flush previous message if any
-            this.flush();
-            this.currentRole = 'thinking';
-            this.messageStartTime = json.timestamp_ms || Date.now();
-          }
-          this.currentMessage += json.text;
-        } else if (json.subtype === 'completed') {
-          // Thinking completed - flush immediately
-          this.flush();
-        }
-        break;
-    }
-  }
-  
-  /**
-   * Flush accumulated message
-   */
-  flush(): void {
-    if (this.currentMessage && this.currentRole) {
-      this.emitMessage({
-        type: this.currentRole as any,
-        role: this.currentRole,
-        content: this.currentMessage,
-        timestamp: this.messageStartTime,
-      });
-    }
-    this.currentMessage = '';
-    this.currentRole = '';
-    this.messageStartTime = 0;
-  }
-  
-  private emitMessage(msg: ParsedMessage): void {
-    if (msg.content.trim()) {
-      this.onMessage(msg);
-    }
-  }
-}
-
 /**
  * ANSI escape sequence regex pattern
- * Matches:
- * - CSI sequences (colors, cursor movement, etc.)
- * - OSC sequences (terminal titles, etc.)
- * - Single-character escape codes
  */
 const ANSI_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
-
-/**
- * Extended ANSI regex for more complete stripping
- */
 const EXTENDED_ANSI_REGEX = /(?:\x1B[@-Z\\-_]|\x1B\[[0-?]*[ -/]*[@-~]|\x1B\][^\x07]*(?:\x07|\x1B\\)|\x1B[PX^_][^\x1B]*\x1B\\|\x1B.)/g;
 
 /**
@@ -230,14 +52,12 @@ export function stripAnsi(text: string): string {
   return text
     .replace(EXTENDED_ANSI_REGEX, '')
     .replace(ANSI_REGEX, '')
-    // Also remove carriage returns that overwrite lines (progress bars, etc.)
     .replace(/\r[^\n]/g, '\n')
-    // Clean up any remaining control characters except newlines/tabs
     .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
 }
 
 /**
- * Format timestamp based on format preference
+ * Format timestamp
  */
 export function formatTimestamp(format: 'iso' | 'relative' | 'short', startTime?: number): string {
   const now = Date.now();
@@ -269,122 +89,25 @@ export function formatTimestamp(format: 'iso' | 'relative' | 'short', startTime?
 }
 
 /**
- * Regex to detect if a line already has a timestamp at the start
- * Matches:
- * - ISO format: [2024-01-01T12:34:56...]
- * - Short format: [12:34:56]
- */
-const EXISTING_TIMESTAMP_REGEX = /^\[(\d{4}-\d{2}-\d{2}T)?\d{2}:\d{2}:\d{2}/;
-
-/**
- * Check if a line already has a timestamp
- */
-function hasExistingTimestamp(line: string): boolean {
-  return EXISTING_TIMESTAMP_REGEX.test(line.trim());
-}
-
-/**
- * Transform stream that strips ANSI and adds timestamps
- */
-export class CleanLogTransform extends Transform {
-  private config: EnhancedLogConfig;
-  private session: LogSession;
-  private buffer: string = '';
-
-  constructor(config: EnhancedLogConfig, session: LogSession) {
-    super({ encoding: 'utf8' });
-    this.config = config;
-    this.session = session;
-  }
-
-  _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void {
-    let text = chunk.toString();
-    
-    // Buffer partial lines
-    this.buffer += text;
-    const lines = this.buffer.split('\n');
-    
-    // Keep the last incomplete line in buffer
-    this.buffer = lines.pop() || '';
-    
-    for (const line of lines) {
-      let processed = line;
-      
-      // Strip ANSI if enabled
-      if (this.config.stripAnsi) {
-        processed = stripAnsi(processed);
-      }
-      
-      // Add timestamp if enabled AND line doesn't already have one
-      if (this.config.addTimestamps && processed.trim() && !hasExistingTimestamp(processed)) {
-        const ts = formatTimestamp(this.config.timestampFormat, this.session.startTime);
-        processed = `[${ts}] ${processed}`;
-      }
-      
-      this.push(processed + '\n');
-    }
-    
-    callback();
-  }
-
-  _flush(callback: TransformCallback): void {
-    // Process any remaining buffered content
-    if (this.buffer.trim()) {
-      let processed = this.buffer;
-      
-      if (this.config.stripAnsi) {
-        processed = stripAnsi(processed);
-      }
-      
-      if (this.config.addTimestamps && processed.trim() && !hasExistingTimestamp(processed)) {
-        const ts = formatTimestamp(this.config.timestampFormat, this.session.startTime);
-        processed = `[${ts}] ${processed}`;
-      }
-      
-      this.push(processed + '\n');
-    }
-    
-    callback();
-  }
-}
-
-/**
- * Enhanced Log Manager - Manages log files with rotation and multiple outputs
+ * Simplified Log Manager - Only raw and readable logs
  */
 export class EnhancedLogManager {
   private config: EnhancedLogConfig;
   private session: LogSession;
   private logDir: string;
   
-  private cleanLogPath: string;
   private rawLogPath: string;
-  private absoluteRawLogPath: string;
-  private jsonLogPath: string;
   private readableLogPath: string;
   
-  private cleanLogFd: number | null = null;
   private rawLogFd: number | null = null;
-  private absoluteRawLogFd: number | null = null;
-  private jsonLogFd: number | null = null;
   private readableLogFd: number | null = null;
   
-  private cleanLogSize: number = 0;
   private rawLogSize: number = 0;
-  private absoluteRawLogSize: number = 0;
   
-  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> = {}, onParsedMessage?: (msg: ParsedMessage) => void) {
     this.config = { ...DEFAULT_LOG_CONFIG, ...config };
-    
-    // Support 'raw' as alias for 'keepAbsoluteRawLogs'
-    if (this.config.raw) {
-      this.config.keepAbsoluteRawLogs = true;
-    }
-    
     this.session = session;
     this.logDir = logDir;
     this.onParsedMessage = onParsedMessage;
@@ -392,163 +115,55 @@ export class EnhancedLogManager {
     // Ensure log directory exists
     fs.mkdirSync(logDir, { recursive: true });
     
-    // Set up log file paths
-    this.cleanLogPath = safeJoin(logDir, 'terminal.log');
+    // Set up log file paths (simplified)
     this.rawLogPath = safeJoin(logDir, 'terminal-raw.log');
-    this.absoluteRawLogPath = safeJoin(logDir, 'terminal-absolute-raw.log');
-    this.jsonLogPath = safeJoin(logDir, 'terminal.jsonl');
     this.readableLogPath = safeJoin(logDir, 'terminal-readable.log');
-
-    if (this.config.raw) {
-      logger.info(`[${session.laneName}] 📄 Raw data capture enabled: ${this.absoluteRawLogPath}`);
-    }
     
     // Initialize log files
     this.initLogFiles();
   }
 
+  /**
+   * Get short time format (HH:MM:SS)
+   */
+  private getShortTime(): string {
+    return new Date().toLocaleTimeString('en-US', { hour12: false });
+  }
+
+  /**
+   * Get lane-task label like [L1-T2-lanename10]
+   */
+  private getLaneTaskLabel(): string {
+    const laneNum = (this.session.laneIndex ?? 0) + 1;
+    const taskNum = (this.session.taskIndex ?? 0) + 1;
+    const shortLaneName = this.session.laneName.substring(0, 10);
+    return `L${laneNum}-T${taskNum}-${shortLaneName}`;
+  }
+
   /**
    * Initialize log files and write session headers
    */
   private initLogFiles(): void {
     // Check and rotate if necessary
-    this.rotateIfNeeded(this.cleanLogPath, 'clean');
-    if (this.config.keepRawLogs) {
-      this.rotateIfNeeded(this.rawLogPath, 'raw');
-    }
-    if (this.config.keepAbsoluteRawLogs) {
-      this.rotateIfNeeded(this.absoluteRawLogPath, 'raw');
-    }
-    
-    // Open file descriptors
-    this.cleanLogFd = fs.openSync(this.cleanLogPath, 'a');
-    
     if (this.config.keepRawLogs) {
+      this.rotateIfNeeded(this.rawLogPath);
       this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
     }
-
-    if (this.config.keepAbsoluteRawLogs) {
-      this.absoluteRawLogFd = fs.openSync(this.absoluteRawLogPath, 'a');
-    }
     
-    if (this.config.writeJsonLog) {
-      this.jsonLogFd = fs.openSync(this.jsonLogPath, 'a');
-    }
-    
-    // Open readable log file (for parsed streaming output)
+    this.rotateIfNeeded(this.readableLogPath);
     this.readableLogFd = fs.openSync(this.readableLogPath, 'a');
     
-    // Get initial file sizes
-    try {
-      this.cleanLogSize = fs.statSync(this.cleanLogPath).size;
-      if (this.config.keepRawLogs) {
+    // Get initial file size for raw log if enabled
+    if (this.rawLogFd !== null) {
+      try {
         this.rawLogSize = fs.statSync(this.rawLogPath).size;
+      } catch {
+        this.rawLogSize = 0;
       }
-      if (this.config.keepAbsoluteRawLogs) {
-        this.absoluteRawLogSize = fs.statSync(this.absoluteRawLogPath).size;
-      }
-    } catch {
-      this.cleanLogSize = 0;
-      this.rawLogSize = 0;
-      this.absoluteRawLogSize = 0;
     }
     
     // Write session header
     this.writeSessionHeader();
-    
-    // Create transform stream
-    this.cleanTransform = new CleanLogTransform(this.config, this.session);
-    this.cleanTransform.on('data', (data: string) => {
-      this.writeToCleanLog(data);
-    });
-    
-    // Create streaming parser for readable log
-    this.streamingParser = new StreamingMessageParser((msg) => {
-      this.writeReadableMessage(msg);
-      if (this.onParsedMessage) {
-        this.onParsedMessage(msg);
-      }
-    });
-  }
-  
-  /**
-   * Write a parsed message to the readable log
-   */
-  private writeReadableMessage(msg: ParsedMessage): void {
-    if (this.readableLogFd === null) return;
-    
-    const ts = new Date(msg.timestamp).toISOString();
-    let formatted: string;
-    
-    switch (msg.type) {
-      case 'system':
-        formatted = `[${ts}] ⚙️ SYSTEM: ${msg.content}\n`;
-        break;
-        
-      case 'user':
-      case 'assistant':
-      case 'result':
-        // Format with brackets and line (compact)
-        const isUser = msg.type === 'user';
-        const isResult = msg.type === 'result';
-        const headerText = isUser ? '🧑 USER' : isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
-        const duration = msg.metadata?.duration_ms 
-          ? ` (${Math.round(msg.metadata.duration_ms / 1000)}s)`
-          : '';
-        
-        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':
-        formatted = `[${ts}] 🔧 TOOL: ${msg.content}\n`;
-        break;
-        
-      case 'tool_result':
-        const toolResultLines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
-        formatted = `[${ts}] 📄 RESL: ${msg.metadata?.toolName || 'Tool'}${toolResultLines}\n`;
-        break;
-        
-      case 'thinking':
-        // Format thinking block
-        const thinkLabel = `[ 🤔 THINKING ] `;
-        const thinkWidth = 80;
-        const thinkTop = `┌─${thinkLabel}${'─'.repeat(Math.max(0, thinkWidth - thinkLabel.length - 2))}`;
-        const thinkBottom = `└─${'─'.repeat(thinkWidth - 2)}`;
-
-        const thinkLines = msg.content.trim().split('\n');
-        formatted = `[${ts}] ${thinkTop}\n`;
-        for (const line of thinkLines) {
-          formatted += `[${ts}] │ ${line}\n`;
-        }
-        formatted += `[${ts}] ${thinkBottom}\n`;
-        break;
-        
-      default:
-        formatted = `[${ts}] ${msg.content}\n`;
-    }
-    
-    try {
-      fs.writeSync(this.readableLogFd, formatted);
-    } catch {
-      // Ignore write errors
-    }
-  }
-  
-  /**
-   * Indent text with a prefix
-   */
-  private indentText(text: string, prefix: string): string {
-    return text.split('\n').map(line => prefix + line).join('\n');
   }
 
   /**
@@ -568,32 +183,14 @@ export class EnhancedLogManager {
 
 `;
     
-    this.writeToCleanLog(header);
-    
-    if (this.config.keepRawLogs && this.rawLogFd !== null) {
-      fs.writeSync(this.rawLogFd, header);
-    }
-    
-    // Write JSON session entry
-    this.writeJsonEntry({
-      timestamp: new Date(this.session.startTime).toISOString(),
-      level: 'session',
-      source: 'system',
-      lane: this.session.laneName,
-      task: this.session.taskName,
-      message: 'Session started',
-      metadata: {
-        sessionId: this.session.id,
-        model: this.session.model,
-        ...this.session.metadata,
-      },
-    });
+    this.writeToRawLog(header);
+    this.writeToReadableLog(header);
   }
 
   /**
    * Rotate log file if it exceeds max size
    */
-  private rotateIfNeeded(logPath: string, type: 'clean' | 'raw'): void {
+  private rotateIfNeeded(logPath: string): void {
     if (!fs.existsSync(logPath)) return;
     
     try {
@@ -633,32 +230,13 @@ export class EnhancedLogManager {
     fs.renameSync(logPath, rotatedPath);
   }
 
-  /**
-   * Write to clean log with size tracking
-   */
-  private writeToCleanLog(data: string): void {
-    if (this.cleanLogFd === null) return;
-    
-    const buffer = Buffer.from(data);
-    fs.writeSync(this.cleanLogFd, buffer);
-    this.cleanLogSize += buffer.length;
-    
-    // Check if rotation needed
-    if (this.cleanLogSize >= this.config.maxFileSize) {
-      fs.closeSync(this.cleanLogFd);
-      this.rotateLog(this.cleanLogPath);
-      this.cleanLogFd = fs.openSync(this.cleanLogPath, 'a');
-      this.cleanLogSize = 0;
-    }
-  }
-
   /**
    * Write to raw log with size tracking
    */
-  private writeToRawLog(data: string): void {
+  private writeToRawLog(data: string | Buffer): void {
     if (this.rawLogFd === null) return;
     
-    const buffer = Buffer.from(data);
+    const buffer = typeof data === 'string' ? Buffer.from(data) : data;
     fs.writeSync(this.rawLogFd, buffer);
     this.rawLogSize += buffer.length;
     
@@ -672,32 +250,38 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Write to absolute raw log with size tracking
+   * Write to readable log
    */
-  private writeToAbsoluteRawLog(data: string | Buffer): void {
-    if (this.absoluteRawLogFd === null) return;
-    
-    const buffer = typeof data === 'string' ? Buffer.from(data) : data;
-    fs.writeSync(this.absoluteRawLogFd, buffer);
-    this.absoluteRawLogSize += buffer.length;
+  private writeToReadableLog(data: string): void {
+    if (this.readableLogFd === null) return;
     
-    // Check if rotation needed
-    if (this.absoluteRawLogSize >= this.config.maxFileSize) {
-      fs.closeSync(this.absoluteRawLogFd);
-      this.rotateLog(this.absoluteRawLogPath);
-      this.absoluteRawLogFd = fs.openSync(this.absoluteRawLogPath, 'a');
-      this.absoluteRawLogSize = 0;
+    try {
+      fs.writeSync(this.readableLogFd, data);
+    } catch {
+      // Ignore write errors
     }
   }
 
   /**
-   * Write a JSON log entry
+   * Write a parsed message to the readable log using formatMessageForConsole style
    */
-  private writeJsonEntry(entry: JsonLogEntry): void {
-    if (this.jsonLogFd === null) return;
+  public writeReadableMessage(msg: ParsedMessage): void {
+    // Use formatMessageForConsole for consistent formatting
+    // Use short lane-task label like [L01-T02]
+    const formatted = formatMessageForConsole(msg, {
+      laneLabel: `[${this.getLaneTaskLabel()}]`,
+      includeTimestamp: false, // We'll add our own short timestamp
+    });
+    
+    // Strip ANSI codes and add short timestamp for file output
+    const clean = stripAnsi(formatted);
+    const ts = this.getShortTime();
+    this.writeToReadableLog(`[${ts}] ${clean}\n`);
     
-    const line = JSON.stringify(entry) + '\n';
-    fs.writeSync(this.jsonLogFd, line);
+    // Callback for console output
+    if (this.onParsedMessage) {
+      this.onParsedMessage(msg);
+    }
   }
 
   /**
@@ -706,142 +290,144 @@ export class EnhancedLogManager {
   public writeStdout(data: Buffer | string): void {
     const text = data.toString();
     
-    // Write absolute raw log
-    if (this.config.keepAbsoluteRawLogs) {
-      this.writeToAbsoluteRawLog(data);
-    }
-    
-    // Write raw log
-    if (this.config.keepRawLogs) {
-      this.writeToRawLog(text);
-    }
-    
-    // Process through transform for clean log
-    if (this.cleanTransform) {
-      this.cleanTransform.write(data);
-    }
-    
-    // Process lines for readable log and JSON entries
-    this.lineBuffer += text;
-    const lines = this.lineBuffer.split('\n');
-    this.lineBuffer = lines.pop() || '';
+    // Write raw log (original data)
+    this.writeToRawLog(data);
     
+    // Parse JSON output and write to readable log
+    const lines = text.split('\n');
     for (const line of lines) {
-      const cleanLine = stripAnsi(line).trim();
-      if (!cleanLine) continue;
-
-      // Handle streaming JSON messages
-      if (cleanLine.startsWith('{')) {
-        if (this.streamingParser) {
-          this.streamingParser.parseLine(cleanLine);
-        }
-
-        // Special handling for terminal.jsonl entries for AI messages
-        if (this.config.writeJsonLog) {
-          try {
-            const json = JSON.parse(cleanLine);
-            let displayMsg = cleanLine;
-            let metadata = { ...json };
-
-            // Extract cleaner text for significant AI message types
-            if ((json.type === 'thinking' || json.type === 'thought') && (json.text || json.thought)) {
-              displayMsg = json.text || json.thought;
-              // Clean up any double newlines at the end of deltas
-              displayMsg = displayMsg.replace(/\n+$/, '\n');
-            } else if (json.type === 'assistant' && json.message?.content) {
-              displayMsg = json.message.content
-                .filter((c: any) => c.type === 'text')
-                .map((c: any) => c.text)
-                .join('');
-            } else if (json.type === 'user' && json.message?.content) {
-              displayMsg = json.message.content
-                .filter((c: any) => c.type === 'text')
-                .map((c: any) => c.text)
-                .join('');
-            } else if (json.type === 'tool_call' && json.subtype === 'started') {
-              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-              const args = json.tool_call[toolName]?.args || {};
-              displayMsg = `🔧 CALL: ${toolName}(${JSON.stringify(args)})`;
-            } else if (json.type === 'tool_call' && json.subtype === 'completed') {
-              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-              displayMsg = `📄 RESL: ${toolName}`;
-            } else if (json.type === 'result') {
-              displayMsg = json.result || 'Task completed';
-            }
-
-            this.writeJsonEntry({
-              timestamp: new Date().toISOString(),
-              level: 'stdout',
-              lane: this.session.laneName,
-              task: this.session.taskName,
-              message: displayMsg.substring(0, 2000), // Larger limit for AI text
-              metadata,
-            });
-            continue; // Already logged this JSON line
-          } catch {
-            // Not valid JSON or error, fall through to regular logging
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      
+      // Try to parse as JSON (cursor-agent output)
+      if (trimmed.startsWith('{')) {
+        try {
+          const json = JSON.parse(trimmed);
+          const msg = this.parseJsonToMessage(json);
+          if (msg) {
+            this.writeReadableMessage(msg);
+            continue;
           }
-        }
-      } else {
-        // Parse standard text logs into ParsedMessage
-        // Format: [HH:MM:SS] [LANE] ℹ️  INFO    message
-        const textLogRegex = /^\[(\d{2}:\d{2}:\d{2})\]\s+\[(.*?)\]\s+(.*?)\s+(INFO|WARN|ERROR|SUCCESS|DONE|PROGRESS)\s+(.*)/;
-        const match = cleanLine.match(textLogRegex);
-        
-        if (match && this.onParsedMessage) {
-          const [, time, , emoji, level, content] = match;
-          // Convert HH:MM:SS to a timestamp for today
-          const [h, m, s] = time!.split(':').map(Number);
-          const timestamp = new Date().setHours(h!, m!, s!, 0);
-          
-          this.onParsedMessage({
-            type: level!.toLowerCase().replace('done', 'result').replace('success', 'result') as any,
-            role: 'system',
-            content: `${emoji} ${content}`,
-            timestamp,
-          });
-        }
-      }
-
-      // Also include significant info/status lines in readable log (compact)
-      if (this.readableLogFd !== null) {
-        // Look for log lines: [ISO_DATE] [LEVEL] ...
-        if (!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 {}
+        } catch {
+          // Not valid JSON, fall through
         }
       }
       
-      // Write regular non-JSON lines to terminal.jsonl
-      if (this.config.writeJsonLog && !this.isNoiseLog(cleanLine)) {
-        this.writeJsonEntry({
-          timestamp: new Date().toISOString(),
-          level: 'stdout',
-          lane: this.session.laneName,
-          task: this.session.taskName,
-          message: cleanLine.substring(0, 1000),
-          raw: this.config.keepRawLogs ? undefined : line.substring(0, 1000),
-        });
+      // Non-JSON line - write as-is with short timestamp and lane-task label
+      const cleanLine = stripAnsi(trimmed);
+      if (cleanLine && !this.isNoiseLog(cleanLine)) {
+        const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
+        const label = this.getLaneTaskLabel();
+        
+        if (hasTimestamp) {
+          // If already has timestamp, just ensure label is present
+          const formatted = cleanLine.includes(`[${label}]`) 
+            ? cleanLine 
+            : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
+          this.writeToReadableLog(`${formatted}\n`);
+        } else {
+          const ts = this.getShortTime();
+          this.writeToReadableLog(`[${ts}] [${label}] ${cleanLine}\n`);
+        }
       }
     }
   }
-  
+
   /**
-   * Parse streaming JSON data for readable log - legacy, integrated into writeStdout
+   * Parse cursor-agent JSON output to ParsedMessage
    */
-  private parseStreamingData(text: string): void {
-    // Legacy method, no longer used but kept for internal references if any
+  private parseJsonToMessage(json: any): ParsedMessage | null {
+    const type = json.type;
+    const timestamp = json.timestamp_ms || Date.now();
+    
+    switch (type) {
+      case 'system':
+        return {
+          type: 'system',
+          role: 'system',
+          content: `Model: ${json.model || 'unknown'}, Mode: ${json.permissionMode || 'default'}`,
+          timestamp,
+        };
+        
+      case 'user':
+        if (json.message?.content) {
+          const textContent = json.message.content
+            .filter((c: any) => c.type === 'text')
+            .map((c: any) => c.text)
+            .join('');
+          return {
+            type: 'user',
+            role: 'user',
+            content: textContent,
+            timestamp,
+          };
+        }
+        return null;
+        
+      case 'assistant':
+        if (json.message?.content) {
+          const textContent = json.message.content
+            .filter((c: any) => c.type === 'text')
+            .map((c: any) => c.text)
+            .join('');
+          return {
+            type: 'assistant',
+            role: 'assistant',
+            content: textContent,
+            timestamp,
+          };
+        }
+        return null;
+        
+      case 'tool_call':
+        if (json.subtype === 'started' && json.tool_call) {
+          const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+          const toolArgs = json.tool_call[toolName]?.args || {};
+          return {
+            type: 'tool',
+            role: 'tool',
+            content: `[Tool: ${toolName}] ${JSON.stringify(toolArgs)}`,
+            timestamp,
+            metadata: { callId: json.call_id, toolName },
+          };
+        } else if (json.subtype === 'completed' && json.tool_call) {
+          const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+          return {
+            type: 'tool_result',
+            role: 'tool',
+            content: `[Tool Result: ${toolName}]`,
+            timestamp,
+            metadata: { callId: json.call_id, toolName },
+          };
+        }
+        return null;
+        
+      case 'result':
+        return {
+          type: 'result',
+          role: 'assistant',
+          content: json.result || '',
+          timestamp,
+          metadata: {
+            duration_ms: json.duration_ms,
+            is_error: json.is_error,
+          },
+        };
+        
+      case 'thinking':
+        if (json.text) {
+          return {
+            type: 'thinking',
+            role: 'assistant',
+            content: json.text,
+            timestamp,
+          };
+        }
+        return null;
+        
+      default:
+        return null;
+    }
   }
 
   /**
@@ -850,87 +436,41 @@ export class EnhancedLogManager {
   public writeStderr(data: Buffer | string): void {
     const text = data.toString();
     
-    // Write absolute raw log
-    if (this.config.keepAbsoluteRawLogs) {
-      this.writeToAbsoluteRawLog(data);
-    }
-    
     // Write raw log
-    if (this.config.keepRawLogs) {
-      this.writeToRawLog(text);
-    }
+    this.writeToRawLog(data);
     
-    // Process through transform for clean log
-    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 to readable log with error prefix
+    const lines = text.split('\n');
+    for (const line of lines) {
+      const cleanLine = stripAnsi(line).trim();
+      if (cleanLine && !this.isNoiseLog(cleanLine)) {
+        const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
+        const label = this.getLaneTaskLabel();
+        
+        if (hasTimestamp) {
+          const formatted = cleanLine.includes(`[${label}]`) 
+            ? cleanLine 
+            : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}] ❌ ERR`);
+          this.writeToReadableLog(`${formatted}\n`);
+        } else {
+          const ts = this.getShortTime();
+          this.writeToReadableLog(`[${ts}] [${label}] ❌ ERR ${cleanLine}\n`);
         }
       }
     }
-    
-    // Write JSON entry
-    if (this.config.writeJsonLog) {
-      const cleanText = stripAnsi(text).trim();
-      if (cleanText) {
-        this.writeJsonEntry({
-          timestamp: new Date().toISOString(),
-          level: 'stderr',
-          lane: this.session.laneName,
-          task: this.session.taskName,
-          message: cleanText.substring(0, 1000),
-        });
-      }
-    }
   }
 
   /**
    * Write a custom log entry
    */
   public log(level: 'info' | 'error' | 'debug', message: string, metadata?: Record<string, any>): void {
-    const ts = formatTimestamp(this.config.timestampFormat, this.session.startTime);
-    const prefix = level.toUpperCase().padEnd(8);
-    
-    const line = `[${ts}] [${prefix}] ${message}\n`;
-    this.writeToCleanLog(line);
+    const ts = this.getShortTime();
+    const label = this.getLaneTaskLabel();
+    const emoji = level === 'error' ? '❌' : level === 'info' ? 'ℹ️' : '🔍';
+    const line = `[${ts}] [${label}] ${emoji} ${level.toUpperCase()} ${message}\n`;
     
-    if (this.config.keepRawLogs) {
-      this.writeToRawLog(line);
-    }
-    
-    if (this.config.keepAbsoluteRawLogs) {
-      this.writeToAbsoluteRawLog(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(),
-        level,
-        lane: this.session.laneName,
-        task: this.session.taskName,
-        message,
-        metadata,
-      });
-    }
+    this.writeToRawLog(line);
+    this.writeToReadableLog(line);
   }
 
   /**
@@ -940,62 +480,37 @@ export class EnhancedLogManager {
     const divider = '═'.repeat(78);
     const line = `\n${divider}\n  ${title}\n${divider}\n`;
     
-    this.writeToCleanLog(line);
-    if (this.config.keepRawLogs) {
-      this.writeToRawLog(line);
-    }
-    if (this.config.keepAbsoluteRawLogs) {
-      this.writeToAbsoluteRawLog(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 {}
-    }
+    this.writeToRawLog(line);
+    this.writeToReadableLog(line);
   }
 
   /**
    * Update task context
    */
-  public setTask(taskName: string, model?: string): void {
+  public setTask(taskName: string, model?: string, taskIndex?: number): void {
     this.session.taskName = taskName;
     if (model) {
       this.session.model = model;
     }
+    if (taskIndex !== undefined) {
+      this.session.taskIndex = taskIndex;
+    }
     
     this.section(`Task: ${taskName}${model ? ` (Model: ${model})` : ''}`);
-    
-    if (this.config.writeJsonLog) {
-      this.writeJsonEntry({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        source: 'system',
-        lane: this.session.laneName,
-        task: taskName,
-        message: `Task started: ${taskName}`,
-        metadata: { model },
-      });
-    }
   }
 
   /**
-   * Check if a log line is noise (progress bars, spinners, etc.)
+   * Check if a log line is noise
    */
   private isNoiseLog(text: string): boolean {
-    // Skip empty or whitespace-only
     if (!text.trim()) return true;
     
-    // Skip common progress/spinner patterns
     const noisePatterns = [
-      /^[\s│├└─┌┐┘┴┬┤]+$/, // Box drawing only (removed duplicate ├)
-      /^[.\s]+$/, // Dots only
-      /^[=>\s-]+$/, // Progress bar characters
-      /^\d+%$/, // Percentage only
-      /^⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/, // Spinner characters
+      /^[\s│├└─┌┐┘┴┬┤]+$/,
+      /^[.\s]+$/,
+      /^[=>\s-]+$/,
+      /^\d+%$/,
+      /^⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/,
     ];
     
     return noisePatterns.some(p => p.test(text));
@@ -1004,12 +519,10 @@ export class EnhancedLogManager {
   /**
    * Get paths to all log files
    */
-  public getLogPaths(): { clean: string; raw?: string; absoluteRaw?: string; json?: string; readable: string } {
+  public getLogPaths(): { clean: string; raw: string; readable: string } {
     return {
-      clean: this.cleanLogPath,
-      raw: this.config.keepRawLogs ? this.rawLogPath : undefined,
-      absoluteRaw: this.config.keepAbsoluteRawLogs ? this.absoluteRawLogPath : undefined,
-      json: this.config.writeJsonLog ? this.jsonLogPath : undefined,
+      clean: this.readableLogPath, // For backward compatibility
+      raw: this.rawLogPath,
       readable: this.readableLogPath,
     };
   }
@@ -1018,29 +531,14 @@ export class EnhancedLogManager {
    * Create file descriptors for process stdio redirection
    */
   public getFileDescriptors(): { stdout: number; stderr: number } {
-    // For process spawning, use the raw log fd if available, otherwise clean
-    const fd = this.rawLogFd !== null ? this.rawLogFd : this.cleanLogFd!;
+    const fd = this.rawLogFd!;
     return { stdout: fd, stderr: fd };
   }
 
   /**
-   * Close all log files and ensure all data is flushed to disk
+   * Close all log files
    */
   public close(): void {
-    // Flush transform stream
-    if (this.cleanTransform) {
-      this.cleanTransform.end();
-    }
-    
-    // Flush streaming parser
-    if (this.streamingParser) {
-      // Parse any remaining buffered data
-      if (this.lineBuffer.trim()) {
-        this.streamingParser.parseLine(this.lineBuffer);
-      }
-      this.streamingParser.flush();
-    }
-    
     // Write session end marker
     const endMarker = `
 ╔══════════════════════════════════════════════════════════════════════════════╗
@@ -1050,15 +548,6 @@ export class EnhancedLogManager {
 
 `;
     
-    if (this.cleanLogFd !== null) {
-      try {
-        fs.writeSync(this.cleanLogFd, endMarker);
-        fs.fsyncSync(this.cleanLogFd);
-        fs.closeSync(this.cleanLogFd);
-      } catch {}
-      this.cleanLogFd = null;
-    }
-    
     if (this.rawLogFd !== null) {
       try {
         fs.writeSync(this.rawLogFd, endMarker);
@@ -1068,34 +557,6 @@ export class EnhancedLogManager {
       this.rawLogFd = null;
     }
     
-    if (this.absoluteRawLogFd !== null) {
-      try {
-        fs.fsyncSync(this.absoluteRawLogFd);
-        fs.closeSync(this.absoluteRawLogFd);
-      } catch {}
-      this.absoluteRawLogFd = null;
-    }
-    
-    if (this.jsonLogFd !== null) {
-      try {
-        this.writeJsonEntry({
-          timestamp: new Date().toISOString(),
-          level: 'session',
-          source: 'system',
-          lane: this.session.laneName,
-          message: 'Session ended',
-          metadata: {
-            sessionId: this.session.id,
-            duration: Date.now() - this.session.startTime,
-          },
-        });
-        fs.fsyncSync(this.jsonLogFd);
-        fs.closeSync(this.jsonLogFd);
-      } catch {}
-      this.jsonLogFd = null;
-    }
-    
-    // Close readable log
     if (this.readableLogFd !== null) {
       try {
         fs.writeSync(this.readableLogFd, endMarker);
@@ -1107,22 +568,20 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Extract the last error message from the clean log file
+   * Extract the last error message from the log
    */
   public getLastError(): string | null {
     try {
-      if (!fs.existsSync(this.cleanLogPath)) return null;
-      const content = fs.readFileSync(this.cleanLogPath, 'utf8');
-      // Look for lines containing error markers
+      if (!fs.existsSync(this.readableLogPath)) return null;
+      const content = fs.readFileSync(this.readableLogPath, 'utf8');
       const lines = content.split('\n').filter(l => 
-        l.includes('[ERROR]') || 
         l.includes('❌') || 
+        l.includes('[ERROR]') || 
         l.includes('error:') || 
         l.includes('Fatal') ||
         l.includes('fail')
       );
       if (lines.length === 0) {
-        // Fallback to last 5 lines if no specific error marker found
         const allLines = content.split('\n').filter(l => l.trim());
         return allLines.slice(-5).join('\n');
       }
@@ -1156,75 +615,41 @@ export function createLogManager(
   laneRunDir: string,
   laneName: string,
   config?: Partial<EnhancedLogConfig>,
-  onParsedMessage?: (msg: ParsedMessage) => void
+  onParsedMessage?: (msg: ParsedMessage) => void,
+  laneIndex?: number
 ): EnhancedLogManager {
   const session: LogSession = {
     id: `${laneName}-${Date.now().toString(36)}`,
     laneName,
     startTime: Date.now(),
+    laneIndex: laneIndex ?? 0,
+    taskIndex: 0,
   };
   
   return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
 }
 
 /**
- * Read and parse JSON log file
+ * Read and parse JSON log file (legacy compatibility - returns empty array)
  */
 export function readJsonLog(logPath: string): JsonLogEntry[] {
-  if (!fs.existsSync(logPath)) {
-    return [];
-  }
-  
-  try {
-    const content = fs.readFileSync(logPath, 'utf8');
-    return content
-      .split('\n')
-      .filter(line => line.trim())
-      .map(line => {
-        try {
-          return JSON.parse(line) as JsonLogEntry;
-        } catch {
-          return null;
-        }
-      })
-      .filter((entry): entry is JsonLogEntry => entry !== null);
-  } catch {
-    return [];
-  }
+  return [];
 }
 
 /**
- * Export logs to various formats
+ * Export logs (legacy compatibility)
  */
 export function exportLogs(
   laneRunDir: string,
   format: 'text' | 'json' | 'markdown' | 'html',
   outputPath?: string
 ): string {
-  const cleanLogPath = safeJoin(laneRunDir, 'terminal.log');
-  const jsonLogPath = safeJoin(laneRunDir, 'terminal.jsonl');
+  const readableLogPath = safeJoin(laneRunDir, 'terminal-readable.log');
   
   let output = '';
   
-  switch (format) {
-    case 'text':
-      if (fs.existsSync(cleanLogPath)) {
-        output = fs.readFileSync(cleanLogPath, 'utf8');
-      }
-      break;
-      
-    case 'json':
-      const entries = readJsonLog(jsonLogPath);
-      output = JSON.stringify(entries, null, 2);
-      break;
-      
-    case 'markdown':
-      output = exportToMarkdown(jsonLogPath, cleanLogPath);
-      break;
-      
-    case 'html':
-      output = exportToHtml(jsonLogPath, cleanLogPath);
-      break;
+  if (fs.existsSync(readableLogPath)) {
+    output = fs.readFileSync(readableLogPath, 'utf8');
   }
   
   if (outputPath) {
@@ -1234,101 +659,13 @@ export function exportLogs(
   return output;
 }
 
-/**
- * Export logs to Markdown format
- */
-function exportToMarkdown(jsonLogPath: string, cleanLogPath: string): string {
-  const entries = readJsonLog(jsonLogPath);
-  
-  let md = '# CursorFlow Session Log\n\n';
-  
-  // Find session info
-  const sessionStart = entries.find(e => e.level === 'session' && e.message === 'Session started');
-  if (sessionStart?.metadata) {
-    md += '## Session Info\n\n';
-    md += `- **Session ID**: ${sessionStart.metadata.sessionId}\n`;
-    md += `- **Lane**: ${sessionStart.lane}\n`;
-    md += `- **Model**: ${sessionStart.metadata.model || 'default'}\n`;
-    md += `- **Started**: ${sessionStart.timestamp}\n\n`;
-  }
-  
-  md += '## Log Entries\n\n';
-  
-  // Group by task
-  const byTask = new Map<string, JsonLogEntry[]>();
-  for (const entry of entries) {
-    const task = entry.task || '(no task)';
-    if (!byTask.has(task)) {
-      byTask.set(task, []);
-    }
-    byTask.get(task)!.push(entry);
-  }
-  
-  for (const [task, taskEntries] of byTask) {
-    md += `### Task: ${task}\n\n`;
-    md += '```\n';
-    for (const entry of taskEntries) {
-      const level = entry.level || 'info';
-      const message = entry.message || '';
-      if (level !== 'session') {
-        md += `[${entry.timestamp}] [${level.toUpperCase()}] ${message}\n`;
-      }
-    }
-    md += '```\n\n';
-  }
-  
-  return md;
-}
-
-/**
- * Export logs to HTML format
- */
-function exportToHtml(jsonLogPath: string, cleanLogPath: string): string {
-  const entries = readJsonLog(jsonLogPath);
-  
-  let html = `<!DOCTYPE html>
-<html>
-<head>
-  <title>CursorFlow Session Log</title>
-  <style>
-    body { font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace; margin: 20px; background: #1e1e1e; color: #d4d4d4; }
-    h1, h2 { color: #569cd6; }
-    .entry { padding: 4px 8px; margin: 2px 0; border-radius: 4px; }
-    .entry.stdout { background: #252526; }
-    .entry.stderr { background: #3c1f1f; color: #f48771; }
-    .entry.info { background: #1e3a5f; color: #9cdcfe; }
-    .entry.error { background: #5f1e1e; color: #f48771; }
-    .entry.session { background: #1e4620; color: #6a9955; }
-    .timestamp { color: #808080; font-size: 0.9em; }
-    .level { font-weight: bold; text-transform: uppercase; }
-    .task { color: #dcdcaa; }
-    pre { white-space: pre-wrap; word-wrap: break-word; }
-  </style>
-</head>
-<body>
-  <h1>CursorFlow Session Log</h1>
-`;
-  
-  for (const entry of entries) {
-    const level = entry.level || 'info';
-    const message = entry.message || '';
-    html += `  <div class="entry ${level}">
-    <span class="timestamp">${entry.timestamp}</span>
-    <span class="level">[${level}]</span>
-    ${entry.task ? `<span class="task">[${entry.task}]</span>` : ''}
-    <pre>${escapeHtml(message)}</pre>
-  </div>\n`;
-  }
-  
-  html += '</body></html>';
-  return html;
+// Legacy exports for backward compatibility
+export class StreamingMessageParser {
+  constructor(onMessage: (msg: ParsedMessage) => void) {}
+  parseLine(line: string): void {}
+  flush(): void {}
 }
 
-function escapeHtml(text: string): string {
-  return text
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#039;');
+export class CleanLogTransform {
+  constructor(config: EnhancedLogConfig, session: LogSession) {}
 }