@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

package/dist/utils/enhanced-logger.js

@@ -1,15 +1,10 @@
 "use strict";
 /**
- * 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
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,7 +40,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnhancedLogManager = exports.CleanLogTransform = exports.StreamingMessageParser = exports.DEFAULT_LOG_CONFIG = void 0;
+exports.CleanLogTransform = exports.StreamingMessageParser = exports.EnhancedLogManager = exports.DEFAULT_LOG_CONFIG = void 0;
 exports.stripAnsi = stripAnsi;
 exports.formatTimestamp = formatTimestamp;
 exports.createLogManager = createLogManager;
@@ -53,8 +48,7 @@ exports.readJsonLog = readJsonLog;
 exports.exportLogs = exportLogs;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const stream_1 = require("stream");
-const logger = __importStar(require("./logger"));
+const log_formatter_1 = require("./log-formatter");
 const path_1 = require("./path");
 exports.DEFAULT_LOG_CONFIG = {
     enabled: true,
@@ -65,181 +59,13 @@ exports.DEFAULT_LOG_CONFIG = {
     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
- */
-class StreamingMessageParser {
-    currentMessage = '';
-    currentRole = '';
-    messageStartTime = 0;
-    onMessage;
-    constructor(onMessage) {
-        this.onMessage = onMessage;
-    }
-    /**
-     * Parse a line of JSON output from cursor-agent
-     */
-    parseLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed || !trimmed.startsWith('{'))
-            return;
-        try {
-            const json = JSON.parse(trimmed);
-            this.handleJsonMessage(json);
-        }
-        catch {
-            // Not valid JSON, ignore
-        }
-    }
-    handleJsonMessage(json) {
-        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) => c.type === 'text')
-                        .map((c) => 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) => c.type === 'text')
-                        .map((c) => 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() {
-        if (this.currentMessage && this.currentRole) {
-            this.emitMessage({
-                type: this.currentRole,
-                role: this.currentRole,
-                content: this.currentMessage,
-                timestamp: this.messageStartTime,
-            });
-        }
-        this.currentMessage = '';
-        this.currentRole = '';
-        this.messageStartTime = 0;
-    }
-    emitMessage(msg) {
-        if (msg.content.trim()) {
-            this.onMessage(msg);
-        }
-    }
-}
-exports.StreamingMessageParser = StreamingMessageParser;
 /**
  * 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;
 /**
  * Strip ANSI escape sequences from text
@@ -248,13 +74,11 @@ function stripAnsi(text) {
     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
  */
 function formatTimestamp(format, startTime) {
     const now = Date.now();
@@ -285,239 +109,68 @@ function formatTimestamp(format, 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) {
-    return EXISTING_TIMESTAMP_REGEX.test(line.trim());
-}
-/**
- * Transform stream that strips ANSI and adds timestamps
- */
-class CleanLogTransform extends stream_1.Transform {
-    config;
-    session;
-    buffer = '';
-    constructor(config, session) {
-        super({ encoding: 'utf8' });
-        this.config = config;
-        this.session = session;
-    }
-    _transform(chunk, encoding, callback) {
-        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) {
-        // 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();
-    }
-}
-exports.CleanLogTransform = CleanLogTransform;
-/**
- * Enhanced Log Manager - Manages log files with rotation and multiple outputs
+ * Simplified Log Manager - Only raw and readable logs
  */
 class EnhancedLogManager {
     config;
     session;
     logDir;
-    cleanLogPath;
     rawLogPath;
-    absoluteRawLogPath;
-    jsonLogPath;
     readableLogPath;
-    cleanLogFd = null;
     rawLogFd = null;
-    absoluteRawLogFd = null;
-    jsonLogFd = null;
     readableLogFd = null;
-    cleanLogSize = 0;
     rawLogSize = 0;
-    absoluteRawLogSize = 0;
-    cleanTransform = null;
-    streamingParser = null;
-    lineBuffer = '';
     onParsedMessage;
     constructor(logDir, session, config = {}, onParsedMessage) {
         this.config = { ...exports.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;
         // Ensure log directory exists
         fs.mkdirSync(logDir, { recursive: true });
-        // Set up log file paths
-        this.cleanLogPath = (0, path_1.safeJoin)(logDir, 'terminal.log');
+        // Set up log file paths (simplified)
         this.rawLogPath = (0, path_1.safeJoin)(logDir, 'terminal-raw.log');
-        this.absoluteRawLogPath = (0, path_1.safeJoin)(logDir, 'terminal-absolute-raw.log');
-        this.jsonLogPath = (0, path_1.safeJoin)(logDir, 'terminal.jsonl');
         this.readableLogPath = (0, path_1.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)
+     */
+    getShortTime() {
+        return new Date().toLocaleTimeString('en-US', { hour12: false });
+    }
+    /**
+     * Get lane-task label like [L1-T2-lanename10]
+     */
+    getLaneTaskLabel() {
+        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
      */
     initLogFiles() {
         // 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;
             }
-            if (this.config.keepAbsoluteRawLogs) {
-                this.absoluteRawLogSize = fs.statSync(this.absoluteRawLogPath).size;
+            catch {
+                this.rawLogSize = 0;
             }
         }
-        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) => {
-            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
-     */
-    writeReadableMessage(msg) {
-        if (this.readableLogFd === null)
-            return;
-        const ts = new Date(msg.timestamp).toISOString();
-        let formatted;
-        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
-     */
-    indentText(text, prefix) {
-        return text.split('\n').map(line => prefix + line).join('\n');
     }
     /**
      * Write session header to logs
@@ -535,29 +188,13 @@ 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
      */
-    rotateIfNeeded(logPath, type) {
+    rotateIfNeeded(logPath) {
         if (!fs.existsSync(logPath))
             return;
         try {
@@ -594,30 +231,13 @@ class EnhancedLogManager {
         const rotatedPath = (0, path_1.safeJoin)(dir, `${base}.1${ext}`);
         fs.renameSync(logPath, rotatedPath);
     }
-    /**
-     * Write to clean log with size tracking
-     */
-    writeToCleanLog(data) {
-        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
      */
     writeToRawLog(data) {
         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;
         // Check if rotation needed
@@ -629,212 +249,197 @@ class EnhancedLogManager {
         }
     }
     /**
-     * Write to absolute raw log with size tracking
+     * Write to readable log
      */
-    writeToAbsoluteRawLog(data) {
-        if (this.absoluteRawLogFd === null)
+    writeToReadableLog(data) {
+        if (this.readableLogFd === null)
             return;
-        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
-        fs.writeSync(this.absoluteRawLogFd, buffer);
-        this.absoluteRawLogSize += buffer.length;
-        // 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
      */
-    writeJsonEntry(entry) {
-        if (this.jsonLogFd === null)
-            return;
-        const line = JSON.stringify(entry) + '\n';
-        fs.writeSync(this.jsonLogFd, line);
+    writeReadableMessage(msg) {
+        // Use formatMessageForConsole for consistent formatting
+        // Use short lane-task label like [L01-T02]
+        const formatted = (0, log_formatter_1.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`);
+        // Callback for console output
+        if (this.onParsedMessage) {
+            this.onParsedMessage(msg);
+        }
     }
     /**
      * Write stdout data
      */
     writeStdout(data) {
         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)
+            const trimmed = line.trim();
+            if (!trimmed)
                 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) => c.type === 'text')
-                                .map((c) => c.text)
-                                .join('');
-                        }
-                        else if (json.type === 'user' && json.message?.content) {
-                            displayMsg = json.message.content
-                                .filter((c) => c.type === 'text')
-                                .map((c) => 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
+            // 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'),
-                        role: 'system',
-                        content: `${emoji} ${content}`,
-                        timestamp,
-                    });
+                catch {
+                    // Not valid JSON, fall through
                 }
             }
-            // 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 { }
+            // 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`);
                 }
-            }
-            // 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),
-                });
             }
         }
     }
     /**
-     * Parse streaming JSON data for readable log - legacy, integrated into writeStdout
+     * Parse cursor-agent JSON output to ParsedMessage
      */
-    parseStreamingData(text) {
-        // Legacy method, no longer used but kept for internal references if any
+    parseJsonToMessage(json) {
+        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) => c.type === 'text')
+                        .map((c) => 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) => c.type === 'text')
+                        .map((c) => 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;
+        }
     }
     /**
      * Write stderr data
      */
     writeStderr(data) {
         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);
-        }
-        // 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 { }
+        this.writeToRawLog(data);
+        // 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),
-                });
             }
         }
     }
@@ -842,35 +447,12 @@ class EnhancedLogManager {
      * Write a custom log entry
      */
     log(level, message, metadata) {
-        const ts = formatTimestamp(this.config.timestampFormat, this.session.startTime);
-        const prefix = level.toUpperCase().padEnd(8);
-        const line = `[${ts}] [${prefix}] ${message}\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 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,
-            });
-        }
+        const ts = this.getShortTime();
+        const label = this.getLaneTaskLabel();
+        const emoji = level === 'error' ? '❌' : level === 'info' ? 'ℹ️' : '🔍';
+        const line = `[${ts}] [${label}] ${emoji} ${level.toUpperCase()} ${message}\n`;
+        this.writeToRawLog(line);
+        this.writeToReadableLog(line);
     }
     /**
      * Add a section marker
@@ -878,58 +460,34 @@ class EnhancedLogManager {
     section(title) {
         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
      */
-    setTask(taskName, model) {
+    setTask(taskName, model, taskIndex) {
         this.session.taskName = taskName;
         if (model) {
             this.session.model = model;
         }
-        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 },
-            });
+        if (taskIndex !== undefined) {
+            this.session.taskIndex = taskIndex;
         }
+        this.section(`Task: ${taskName}${model ? ` (Model: ${model})` : ''}`);
     }
     /**
-     * Check if a log line is noise (progress bars, spinners, etc.)
+     * Check if a log line is noise
      */
     isNoiseLog(text) {
-        // 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));
     }
@@ -938,10 +496,8 @@ class EnhancedLogManager {
      */
     getLogPaths() {
         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,
         };
     }
@@ -949,26 +505,13 @@ class EnhancedLogManager {
      * Create file descriptors for process stdio redirection
      */
     getFileDescriptors() {
-        // 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
      */
     close() {
-        // 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 = `
 ╔══════════════════════════════════════════════════════════════════════════════╗
@@ -977,15 +520,6 @@ 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);
@@ -995,34 +529,6 @@ class EnhancedLogManager {
             catch { }
             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);
@@ -1034,21 +540,19 @@ class EnhancedLogManager {
         }
     }
     /**
-     * Extract the last error message from the clean log file
+     * Extract the last error message from the log
      */
     getLastError() {
         try {
-            if (!fs.existsSync(this.cleanLogPath))
+            if (!fs.existsSync(this.readableLogPath))
                 return null;
-            const content = fs.readFileSync(this.cleanLogPath, 'utf8');
-            // Look for lines containing error markers
-            const lines = content.split('\n').filter(l => l.includes('[ERROR]') ||
-                l.includes('❌') ||
+            const content = fs.readFileSync(this.readableLogPath, 'utf8');
+            const lines = content.split('\n').filter(l => 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');
             }
@@ -1078,154 +582,45 @@ exports.EnhancedLogManager = EnhancedLogManager;
 /**
  * Create a log manager for a lane
  */
-function createLogManager(laneRunDir, laneName, config, onParsedMessage) {
+function createLogManager(laneRunDir, laneName, config, onParsedMessage, laneIndex) {
     const session = {
         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)
  */
 function readJsonLog(logPath) {
-    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);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((entry) => entry !== null);
-    }
-    catch {
-        return [];
-    }
+    return [];
 }
 /**
- * Export logs to various formats
+ * Export logs (legacy compatibility)
  */
 function exportLogs(laneRunDir, format, outputPath) {
-    const cleanLogPath = (0, path_1.safeJoin)(laneRunDir, 'terminal.log');
-    const jsonLogPath = (0, path_1.safeJoin)(laneRunDir, 'terminal.jsonl');
+    const readableLogPath = (0, path_1.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) {
         fs.writeFileSync(outputPath, output, 'utf8');
     }
     return output;
 }
-/**
- * Export logs to Markdown format
- */
-function exportToMarkdown(jsonLogPath, cleanLogPath) {
-    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();
-    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, cleanLogPath) {
-    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
+class StreamingMessageParser {
+    constructor(onMessage) { }
+    parseLine(line) { }
+    flush() { }
 }
-function escapeHtml(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#039;');
+exports.StreamingMessageParser = StreamingMessageParser;
+class CleanLogTransform {
+    constructor(config, session) { }
 }
+exports.CleanLogTransform = CleanLogTransform;
 //# sourceMappingURL=enhanced-logger.js.map