@orbytautomation/engine 0.4.1 → 0.6.0

package/dist/logging/EngineLogger.js

@@ -20,34 +20,124 @@
  * - Monitoring systems
  * - Audit trails
  *
- * @module core
+ * @module logging
  */
 import { LogLevel, LogLevelSeverity, formatLog, createLogEntry, shouldLog, formatTimestamp, } from '@dev-ecosystem/core';
-import { EngineLogType } from '../types/log-types.js';
+import { EngineLogType, LogCategoryEnum, } from '../types/log-types.js';
+// ─── CategoryLogger ────────────────────────────────────────────────────────────
 /**
- * Re-export formatTimestamp for external use
- * Allows other parts of the system to format timestamps consistently
+ * A thin wrapper that pins every log call to a specific category.
+ *
+ * Obtain instances via `EngineLogger.runtime`, `.analysis`, `.system`, or `.security`.
+ *
+ * ```typescript
+ * const logger = LoggerManager.getLogger();
+ *
+ * // inside run() — runtime category
+ * logger.runtime.info('Step started', { stepId });
+ *
+ * // inside explain() / validate() — analysis category
+ * logger.analysis.debug('Building execution plan');
+ * ```
  */
-export { formatTimestamp };
+export class CategoryLogger {
+    parent;
+    category;
+    constructor(parent, category) {
+        this.parent = parent;
+        this.category = category;
+    }
+    debug(message, context) {
+        this.parent._logWithCategory(LogLevel.DEBUG, message, context, undefined, this.category);
+    }
+    info(message, context) {
+        this.parent._logWithCategory(LogLevel.INFO, message, context, undefined, this.category);
+    }
+    warn(message, context) {
+        this.parent._logWithCategory(LogLevel.WARN, message, context, undefined, this.category);
+    }
+    error(message, error, context) {
+        this.parent._logWithCategory(LogLevel.ERROR, message, context, error, this.category);
+    }
+    fatal(message, error, context) {
+        this.parent._logWithCategory(LogLevel.FATAL, message, context, error, this.category);
+    }
+    /**
+     * Measure execution time of `fn` and log the result under this category.
+     *
+     * ```typescript
+     * const result = await logger.runtime.measureExecution(
+     *   'step:http-request',
+     *   () => httpAdapter.run(step),
+     *   { warn: 3000, error: 10000 },
+     * );
+     * ```
+     */
+    async measureExecution(label, fn, thresholds) {
+        const start = Date.now();
+        try {
+            const result = await fn();
+            const duration = Date.now() - start;
+            let level = LogLevel.INFO;
+            if (thresholds?.error && duration > thresholds.error)
+                level = LogLevel.ERROR;
+            else if (thresholds?.warn && duration > thresholds.warn)
+                level = LogLevel.WARN;
+            this.parent._logWithCategory(level, `${label} completed`, { duration: `${duration}ms` }, undefined, this.category, EngineLogType.EXECUTION_TIME);
+            return result;
+        }
+        catch (err) {
+            const duration = Date.now() - start;
+            this.parent._logWithCategory(LogLevel.ERROR, `${label} failed`, { duration: `${duration}ms` }, err instanceof Error ? err : new Error(String(err)), this.category, EngineLogType.ERROR_DETECTED);
+            throw err;
+        }
+    }
+}
+// ─── EngineLogger ──────────────────────────────────────────────────────────────
 /**
  * Engine Logger
  *
  * Wraps ecosystem-core logging utilities with engine-specific configuration.
+ * Emits structured JSON logs and maintains a typed log history.
+ *
+ * ### Category sub-loggers
+ * Every log is tagged with a phase-based category so tooling / formatters can
+ * filter or colour-code entries without parsing the message text.
+ *
+ * | Sub-logger         | Category     | When to use                                       |
+ * |--------------------|--------------|---------------------------------------------------|
+ * | `logger.runtime`   | `runtime`    | `run()` — step start/complete/fail/retry          |
+ * | `logger.analysis`  | `analysis`   | `explain()` / `validate()` — plan & parse phase   |
+ * | `logger.system`    | `system`     | Engine init/shutdown, adapter registration        |
+ * | `logger.security`  | `security`   | Reserved-field violations, permission rejections  |
+ *
+ * Generic `logger.info(...)` etc. fall back to the category set at construction.
  */
 export class EngineLogger {
     config;
     formatOptions;
-    eventListeners;
-    logBuffer; // Structured JSON log buffer
-    maxBufferSize = 10000; // Prevent memory leaks
+    logHistory = [];
+    /** Workflow context set by the engine before run/explain/validate */
+    workflowContext = null;
+    // ─── Category sub-loggers ────────────────────────────────────────────────
+    /** Use inside `run()` and step-execution paths. Category: `runtime` */
+    runtime;
+    /** Use inside `explain()` and `validate()` paths. Category: `analysis` */
+    analysis;
+    /** Use for engine init, shutdown, adapter registration. Category: `system` */
+    system;
+    /** Use for reserved-field violations, permission rejections. Category: `security` */
+    security;
     constructor(config) {
         this.config = {
             level: config.level,
-            format: config.format || 'text',
+            format: config.format || 'json',
             colors: config.colors ?? true,
             timestamp: config.timestamp ?? true,
             source: config.source || 'Orbyt',
-            structuredEvents: config.structuredEvents ?? true, // Default to true for JSON collection
+            structuredEvents: config.structuredEvents ?? true,
+            category: config.category || LogCategoryEnum.SYSTEM,
+            maxHistorySize: config.maxHistorySize ?? 0,
         };
         this.formatOptions = {
             format: this.config.format,
@@ -55,8 +145,11 @@ export class EngineLogger {
             timestamp: this.config.timestamp,
             includeSource: true,
         };
-        this.eventListeners = new Map();
-        this.logBuffer = [];
+        // Bind category sub-loggers
+        this.runtime = new CategoryLogger(this, LogCategoryEnum.RUNTIME);
+        this.analysis = new CategoryLogger(this, LogCategoryEnum.ANALYSIS);
+        this.system = new CategoryLogger(this, LogCategoryEnum.SYSTEM);
+        this.security = new CategoryLogger(this, LogCategoryEnum.SECURITY);
     }
     /**
      * Log a debug message
@@ -88,670 +181,417 @@ export class EngineLogger {
     fatal(message, error, context) {
         this.log(LogLevel.FATAL, message, context, error);
     }
-    // ============================================================================
-    // WORKFLOW LIFECYCLE LOGGING
-    // ============================================================================
-    /**
-     * Log workflow started event
-     */
-    workflowStarted(workflowName, context) {
-        this.logEvent({
-            type: EngineLogType.WORKFLOW_STARTED,
-            timestamp: new Date(),
-            message: `Workflow "${workflowName}" started`,
-            context,
-        });
-    }
-    /**
-     * Log workflow completed event
-     */
-    workflowCompleted(workflowName, duration, context) {
-        this.logEvent({
-            type: EngineLogType.WORKFLOW_COMPLETED,
-            timestamp: new Date(),
-            message: `Workflow "${workflowName}" completed successfully`,
-            context,
-            metrics: { duration },
-        });
-    }
-    /**
-     * Log workflow failed event
-     */
-    workflowFailed(workflowName, error, duration, context) {
-        this.logEvent({
-            type: EngineLogType.WORKFLOW_FAILED,
-            timestamp: new Date(),
-            message: `Workflow "${workflowName}" failed: ${error.message}`,
-            context,
-            error,
-            metrics: { duration },
-        });
-    }
-    /**
-     * Log workflow validation event
-     */
-    workflowValidation(workflowName, isValid, errors) {
-        this.logEvent({
-            type: EngineLogType.WORKFLOW_VALIDATION,
-            timestamp: new Date(),
-            message: `Workflow "${workflowName}" validation: ${isValid ? 'PASSED' : 'FAILED'}`,
-            context: errors ? { errors } : undefined,
-        });
-    }
-    // ============================================================================
-    // STEP LIFECYCLE LOGGING
-    // ============================================================================
-    /**
-     * Log step started event
-     */
-    stepStarted(stepId, stepName, context) {
-        this.logEvent({
-            type: EngineLogType.STEP_STARTED,
-            timestamp: new Date(),
-            message: `Step "${stepName}" (${stepId}) started`,
-            context,
-        });
-    }
-    /**
-     * Log step completed event
-     */
-    stepCompleted(stepId, stepName, duration, context) {
-        this.logEvent({
-            type: EngineLogType.STEP_COMPLETED,
-            timestamp: new Date(),
-            message: `Step "${stepName}" (${stepId}) completed`,
-            context,
-            metrics: { duration },
-        });
-    }
-    /**
-     * Log step failed event
-     */
-    stepFailed(stepId, stepName, error, context) {
-        this.logEvent({
-            type: EngineLogType.STEP_FAILED,
-            timestamp: new Date(),
-            message: `Step "${stepName}" (${stepId}) failed: ${error.message}`,
-            context,
-            error,
-        });
-    }
-    /**
-     * Log step retry event
-     */
-    stepRetry(stepId, stepName, attempt, maxAttempts) {
-        this.logEvent({
-            type: EngineLogType.STEP_RETRY,
-            timestamp: new Date(),
-            message: `Step "${stepName}" (${stepId}) retry ${attempt}/${maxAttempts}`,
-            context: { attempt, maxAttempts },
-        });
-    }
-    /**
-     * Log step timeout event
-     */
-    stepTimeout(stepId, stepName, timeout) {
-        this.logEvent({
-            type: EngineLogType.STEP_TIMEOUT,
-            timestamp: new Date(),
-            message: `Step "${stepName}" (${stepId}) timed out after ${timeout}ms`,
-            context: { timeout },
-        });
-    }
-    // ============================================================================
-    // EXPLANATION LOGGING
-    // ============================================================================
-    /**
-     * Log explanation generated event
-     */
-    explanationGenerated(workflowName, stepCount, strategy) {
-        this.logEvent({
-            type: EngineLogType.EXPLANATION_GENERATED,
-            timestamp: new Date(),
-            message: `Explanation generated for "${workflowName}" (${stepCount} steps, ${strategy} strategy)`,
-            context: { workflowName, stepCount, strategy },
-        });
-    }
     /**
-     * Log circular dependencies detected
-     */
-    explanationCycles(workflowName, cycles) {
-        this.logEvent({
-            type: EngineLogType.EXPLANATION_CYCLES,
-            timestamp: new Date(),
-            message: `Circular dependencies detected in "${workflowName}"`,
-            context: { cycles },
-        });
-    }
-    // ============================================================================
-    // ADAPTER & PLUGIN LOGGING
-    // ============================================================================
-    /**
-     * Log adapter loaded event
-     */
-    adapterLoaded(adapterName, version) {
-        this.logEvent({
-            type: EngineLogType.ADAPTER_LOADED,
-            timestamp: new Date(),
-            message: `Adapter "${adapterName}" loaded${version ? ` (v${version})` : ''}`,
-            context: { adapterName, version },
-        });
-    }
-    /**
-     * Log adapter failed event
+     * Log with a custom level
      */
-    adapterFailed(adapterName, error) {
-        this.logEvent({
-            type: EngineLogType.ADAPTER_FAILED,
-            timestamp: new Date(),
-            message: `Adapter "${adapterName}" failed: ${error.message}`,
-            context: { adapterName },
-            error,
-        });
+    logWithLevel(level, message, context) {
+        this.log(level, message, context);
     }
     /**
-     * Log plugin installed event
+     * Log only if severity meets minimum threshold
      */
-    pluginInstalled(pluginName, source) {
-        this.logEvent({
-            type: EngineLogType.PLUGIN_INSTALLED,
-            timestamp: new Date(),
-            message: `Plugin "${pluginName}" installed from ${source}`,
-            context: { pluginName, source },
-        });
+    logIfSeverity(minSeverity, level, message, context) {
+        if (LogLevelSeverity[level] >= minSeverity) {
+            this.log(level, message, context);
+        }
     }
     /**
-     * Log plugin verified event
+     * Measure and log execution time with appropriate log level based on duration.
+     *
+     * Pass `category` to override (`'runtime'` during `run()`, `'analysis'` during `explain()`).
+     * Prefer `logger.runtime.measureExecution(...)` or `logger.analysis.measureExecution(...)`.
      */
-    pluginVerified(pluginName, verified) {
-        this.logEvent({
-            type: EngineLogType.PLUGIN_VERIFIED,
-            timestamp: new Date(),
-            message: `Plugin "${pluginName}" verification: ${verified ? 'PASSED' : 'FAILED'}`,
-            context: { pluginName, verified },
-        });
+    async measureExecution(label, fn, thresholds, category) {
+        const start = Date.now();
+        try {
+            const result = await fn();
+            const duration = Date.now() - start;
+            let level = LogLevel.DEBUG;
+            if (thresholds?.error && duration > thresholds.error) {
+                level = LogLevel.ERROR;
+            }
+            else if (thresholds?.warn && duration > thresholds.warn) {
+                level = LogLevel.WARN;
+            }
+            else {
+                level = LogLevel.INFO;
+            }
+            this._logWithCategory(level, `${label} completed`, { duration: `${duration}ms` }, undefined, category, EngineLogType.EXECUTION_TIME);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - start;
+            this._logWithCategory(LogLevel.ERROR, `${label} failed`, { duration: `${duration}ms` }, error instanceof Error ? error : new Error(String(error)), category, EngineLogType.ERROR_DETECTED);
+            throw error;
+        }
     }
-    // ============================================================================
-    // ERROR & DEBUG LOGGING
-    // ============================================================================
+    // ─── Core log dispatch ────────────────────────────────────────────────────
     /**
-     * Log error detected event
+     * Central log dispatcher — used directly by `CategoryLogger` sub-loggers
+     * and by the private `log()` helper below.
+     *
+     * @param level            - Severity level
+     * @param message          - Human-readable message
+     * @param context          - Optional key-value metadata (merged with workflow ctx)
+     * @param error            - Optional error object
+     * @param categoryOverride - Pin to a specific category (defaults to config category)
+     * @param typeOverride     - Explicit `EngineLogType`; inferred from level when omitted
+     *
+     * @internal  Called via sub-loggers (`runtime`, `analysis`, etc.) or internally.
      */
-    errorDetected(error, context) {
-        this.logEvent({
-            type: EngineLogType.ERROR_DETECTED,
+    _logWithCategory(level, message, context, error, categoryOverride, typeOverride) {
+        if (!this.shouldLogLevel(level))
+            return;
+        // Map severity level → structured event type
+        const typeMap = {
+            [LogLevel.DEBUG]: EngineLogType.DEBUG,
+            [LogLevel.INFO]: EngineLogType.INFO,
+            [LogLevel.WARN]: EngineLogType.WARNING,
+            [LogLevel.ERROR]: EngineLogType.ERROR_DETECTED,
+            [LogLevel.FATAL]: EngineLogType.ERROR,
+        };
+        const eventType = typeOverride ?? typeMap[level] ?? EngineLogType.INFO;
+        const category = categoryOverride ?? this.config.category;
+        // Automatically merge workflow context so every log carries the active workflow
+        const enrichedContext = {};
+        if (this.workflowContext) {
+            enrichedContext['workflow'] = { ...this.workflowContext };
+        }
+        if (context) {
+            Object.assign(enrichedContext, context);
+        }
+        const finalContext = Object.keys(enrichedContext).length > 0 ? enrichedContext : undefined;
+        // Record in history
+        const event = {
+            type: eventType,
             timestamp: new Date(),
-            message: `Error detected: ${error.message}`,
-            context,
+            message,
+            category,
+            source: this.config.source,
+            context: finalContext,
             error,
-        });
-    }
-    /**
-     * Log error debugged event (with debugging info)
-     */
-    errorDebugged(error, debugInfo) {
-        this.logEvent({
-            type: EngineLogType.ERROR_DEBUGGED,
-            timestamp: new Date(),
-            message: `Error debugged: ${error.message}`,
-            context: debugInfo,
+        };
+        this.logHistory.push(event);
+        // Ring-buffer: drop the oldest entry when the limit is reached.
+        // A maxHistorySize of 0 means unbounded (no trimming).
+        if (this.config.maxHistorySize > 0 && this.logHistory.length > this.config.maxHistorySize) {
+            this.logHistory.shift();
+        }
+        // Build + emit formatted entry
+        const entry = createLogEntry(level, message, {
+            source: this.config.source,
+            context: finalContext,
             error,
         });
+        const formatted = formatLog(entry, this.formatOptions);
+        console.log(formatted);
     }
     /**
-     * Log validation error event
-     */
-    validationError(message, errors) {
-        this.logEvent({
-            type: EngineLogType.VALIDATION_ERROR,
-            timestamp: new Date(),
-            message,
-            context: { errors },
-        });
-    }
-    // ============================================================================
-    // PERFORMANCE LOGGING
-    // ============================================================================
-    /**
-     * Log performance metric
+     * Private shorthand — uses the default category from config.
+     * Prefer the categorised sub-loggers (`runtime`, `analysis`, etc.) for new code.
      */
-    performanceMetric(label, metrics) {
-        this.logEvent({
-            type: EngineLogType.PERFORMANCE_METRIC,
-            timestamp: new Date(),
-            message: `Performance: ${label}`,
-            metrics,
-        });
+    log(level, message, context, error) {
+        this._logWithCategory(level, message, context, error);
     }
+    // ─── Log History ────────────────────────────────────────────────────
     /**
-     * Log execution time
+     * Export collected logs as a structured ExportedLogs object.
+     * Includes `byCategory` statistics and the active `workflowContext` snapshot.
      */
-    executionTime(label, duration, context) {
-        this.logEvent({
-            type: EngineLogType.EXECUTION_TIME,
-            timestamp: new Date(),
-            message: `${label}: ${duration}ms`,
-            context,
-            metrics: { duration },
-        });
+    exportLogs() {
+        const grouped = {};
+        let withErrors = 0;
+        let withMetrics = 0;
+        let first;
+        let last;
+        const byType = {};
+        const byCategory = {};
+        for (const event of this.logHistory) {
+            const typeKey = event.type;
+            grouped[typeKey] = grouped[typeKey] ? [...grouped[typeKey], event] : [event];
+            byType[typeKey] = (byType[typeKey] ?? 0) + 1;
+            byCategory[event.category] = (byCategory[event.category] ?? 0) + 1;
+            if (event.error)
+                withErrors++;
+            if (event.metrics)
+                withMetrics++;
+            if (!first || event.timestamp < first)
+                first = event.timestamp;
+            if (!last || event.timestamp > last)
+                last = event.timestamp;
+        }
+        return {
+            raw: [...this.logHistory],
+            grouped,
+            workflowContext: this.workflowContext ?? undefined,
+            stats: {
+                total: this.logHistory.length,
+                byType,
+                byCategory,
+                withErrors,
+                withMetrics,
+                timeRange: { first, last },
+            },
+        };
     }
-    // ============================================================================
-    // FIELD-LEVEL EXECUTION LOGGING (Dynamic Explanation)
-    // ============================================================================
     /**
-     * Log field execution - captures every field that gets executed
-     * This enables dynamic explanation generation from runtime logs
+     * Get all collected logs as a JSON string
      */
-    fieldExecution(type, field, value, context) {
-        // Filter out internal fields (starting with _)
-        if (field.startsWith('_'))
-            return;
-        this.debug(`[Field] ${type}.${field} = ${this.formatValue(value)}`, {
-            fieldType: type,
-            fieldName: field,
-            value: this.sanitizeValue(value),
-            ...context,
-        });
+    getJSONLogs() {
+        return JSON.stringify(this.exportLogs(), null, 2);
     }
     /**
-     * Log input processing
+     * Clear the log history (does NOT clear the workflow context)
      */
-    inputProcessed(inputName, value, source) {
-        this.debug(`[Input] ${inputName} received from ${source}`, {
-            input: inputName,
-            source,
-            value: this.sanitizeValue(value),
-        });
+    clearHistory() {
+        this.logHistory = [];
     }
+    // ─── Workflow Context ─────────────────────────────────────────────────────
     /**
-     * Log output generation
+     * Attach workflow context so every subsequent log entry automatically
+     * includes a `workflow` field.  Call this before `run()`, `explain()`,
+     * or `validate()` with the parsed workflow data.
+     *
+     * ```typescript
+     * logger.setWorkflowContext({
+     *   name:        workflow.name,
+     *   version:     workflow.version,
+     *   kind:        workflow.kind,
+     *   stepCount:   workflow.steps.length,
+     *   filePath:    resolvedPath,
+     * });
+     * ```
      */
-    outputGenerated(outputName, value, step) {
-        this.debug(`[Output] ${outputName} generated${step ? ` by ${step}` : ''}`, {
-            output: outputName,
-            step,
-            value: this.sanitizeValue(value),
-        });
+    setWorkflowContext(ctx) {
+        this.workflowContext = { ...ctx };
     }
     /**
-     * Log context variable access
+     * Detach the workflow context (e.g. after a run completes).
+     * Logs emitted after this call will no longer include the `workflow` field.
      */
-    contextAccessed(variable, value, step) {
-        this.debug(`[Context] ${variable} accessed by ${step}`, {
-            variable,
-            step,
-            value: this.sanitizeValue(value),
-        });
+    clearWorkflowContext() {
+        this.workflowContext = null;
     }
     /**
-     * Log secret access (without exposing values)
+     * Returns a read-only snapshot of the currently active workflow context,
+     * or `null` if none has been set.
      */
-    secretAccessed(secretKey, step) {
-        this.debug(`[Secret] ${secretKey} accessed by ${step}`, {
-            secretKey,
-            step,
-            exposed: false, // Never log secret values
-        });
+    getWorkflowContext() {
+        return this.workflowContext ? { ...this.workflowContext } : null;
     }
     /**
-     * Log variable resolution
+     * Partially update the active workflow context without replacing it.
+     * Only the supplied fields are merged in; the rest are preserved.
+     *
+     * Useful for enriching the context mid-run (e.g. after the execution
+     * strategy is determined):
+     *
+     * ```typescript
+     * logger.patchWorkflowContext({ executionStrategy: 'parallel' });
+     * ```
+     *
+     * If no context has been set yet, the patch is applied as if it were
+     * a fresh `setWorkflowContext` call.
      */
-    variableResolved(variable, resolvedValue, context) {
-        this.debug(`[Variable] ${variable} resolved`, {
-            variable,
-            resolved: this.sanitizeValue(resolvedValue),
-            ...context,
-        });
+    patchWorkflowContext(partial) {
+        this.workflowContext = { ...(this.workflowContext ?? {}), ...partial };
     }
+    // ─── Dynamic Context Helpers ──────────────────────────────────────────────
     /**
-     * Log adapter action execution
-     */
-    adapterActionExecuted(adapter, action, duration, success) {
-        const message = `[Adapter] ${adapter}.${action} ${success ? 'completed' : 'failed'} in ${duration}ms`;
-        const context = { adapter, action, duration, success };
-        if (success) {
-            this.info(message, context);
-        }
-        else {
-            this.error(message, undefined, context);
+     * Build a log-context object for a step event.
+     *
+     * Use this wherever you log step lifecycle events so context is consistent:
+     * ```typescript
+     * logger.runtime.info('Step started', logger.stepCtx({ id: step.id, adapter: step.adapter }));
+     * logger.runtime.error('Step failed', error, logger.stepCtx({ id: step.id, adapter: step.adapter }));
+     * ```
+     */
+    stepCtx(step) {
+        const ctx = { stepId: step.id };
+        if (step.adapter)
+            ctx['adapter'] = step.adapter;
+        if (step.name)
+            ctx['stepName'] = step.name;
+        // Forward any extra fields the caller added
+        for (const [k, v] of Object.entries(step)) {
+            if (k !== 'id' && k !== 'adapter' && k !== 'name')
+                ctx[k] = v;
         }
-    }
-    // ============================================================================
-    // PARSING & VALIDATION LOGGING
-    // ============================================================================
-    /**
-     * Log parsing start
-     */
-    parsingStarted(source, format) {
-        this.debug(`[Parser] Parsing ${format} from ${source}`, {
-            source,
-            format,
-        });
-    }
-    /**
-     * Log parsing success
-     */
-    parsingCompleted(source, duration, stats) {
-        this.info(`[Parser] Parsed successfully in ${duration}ms`, {
-            source,
-            duration,
-            ...stats,
-        });
+        return ctx;
     }
     /**
-     * Log parsing error
+     * Build a log-context object for a workflow-level event.
+     *
+     * Returns a flat object suitable for passing as `context` to any log call.
+     * If no workflow context is set, returns `{}`.
+     *
+     * ```typescript
+     * logger.system.info('Workflow validated', logger.workflowCtx());
+     * ```
      */
-    parsingFailed(source, error, context) {
-        this.error(`[Parser] Parsing failed: ${error.message}`, error, {
-            source,
-            ...context,
-        });
+    workflowCtx() {
+        return this.workflowContext ? { ...this.workflowContext } : {};
     }
+    // ─── Dynamic Lifecycle Helpers ────────────────────────────────────────────
     /**
-     * Log validation start
+     * Log workflow execution started (runtime category).
+     * Called at the top of `WorkflowExecutor.execute()`.
      */
-    validationStarted(target, type) {
-        this.debug(`[Validator] Validating ${type}: ${target}`, {
-            target,
-            type,
-        });
+    workflowStarted(workflowName, context) {
+        this.runtime.info(`Workflow "${workflowName}" started`, { workflowName, ...context });
     }
     /**
-     * Log validation success
+     * Log a workflow input field that was resolved (runtime category).
      */
-    validationPassed(target, type, duration) {
-        this.info(`[Validator] Validation passed: ${target}`, {
-            target,
-            type,
-            duration,
-        });
+    inputProcessed(key, value, source) {
+        this.runtime.debug(`Input resolved: ${key}`, { key, value, source });
     }
     /**
-     * Log validation failure
+     * Log a context field used during execution (runtime category).
      */
-    validationFailed(target, type, errors) {
-        this.error(`[Validator] Validation failed: ${target}`, undefined, {
-            target,
-            type,
-            errors,
-            errorCount: errors.length,
-        });
+    fieldExecution(fieldType, key, value) {
+        this.runtime.debug(`Context field accessed: ${fieldType}.${key}`, { fieldType, key, value });
     }
-    // ============================================================================
-    // ERROR DETECTION & DEBUGGING LOGGING
-    // ============================================================================
     /**
-     * Log error enrichment (when ErrorDetector adds debugging info)
+     * Log step execution started (runtime category).
+     * ```typescript
+     * logger.stepStarted(step.id, step.name, { adapter: step.adapter });
+     * ```
      */
-    errorEnriched(error, debugInfo) {
-        this.debug(`[ErrorDetector] Error enriched with debugging info`, {
-            errorType: error.name,
-            errorMessage: error.message,
-            ...debugInfo,
-        });
+    stepStarted(stepId, stepName, context) {
+        this._logWithCategory(LogLevel.INFO, `Step "${stepName}" (${stepId}) started`, { stepId, stepName, ...context }, undefined, LogCategoryEnum.RUNTIME, EngineLogType.STEP_STARTED);
     }
     /**
-     * Log error debugging output
+     * Log step execution completed (runtime category).
      */
-    errorDebugOutput(error, explanation, fixSteps) {
-        this.info(`[ErrorDebugger] Generated debugging output for ${error.name}`, {
-            errorType: error.name,
-            explanation,
-            fixSteps,
-            stepCount: fixSteps.length,
-        });
+    stepCompleted(stepId, stepName, duration, context) {
+        this._logWithCategory(LogLevel.INFO, `Step "${stepName}" (${stepId}) completed in ${duration}ms`, { stepId, stepName, duration, ...context }, undefined, LogCategoryEnum.RUNTIME, EngineLogType.STEP_COMPLETED);
     }
-    // ============================================================================
-    // EXECUTION PHASE LOGGING
-    // ============================================================================
     /**
-     * Log execution phase start
+     * Log step timeout (runtime category).
      */
-    phaseStarted(phase, stepIds) {
-        this.info(`[Execution] Phase ${phase} started with ${stepIds.length} step(s)`, {
-            phase,
-            stepIds,
-            stepCount: stepIds.length,
-        });
+    stepTimeout(stepId, stepName, timeoutMs) {
+        this._logWithCategory(LogLevel.WARN, `Step "${stepName}" (${stepId}) timed out after ${timeoutMs}ms`, { stepId, stepName, timeoutMs }, undefined, LogCategoryEnum.RUNTIME, EngineLogType.STEP_TIMEOUT);
     }
     /**
-     * Log execution phase completion
+     * Log step retry attempt (runtime category).
      */
-    phaseCompleted(phase, duration, successCount, failureCount) {
-        this.info(`[Execution] Phase ${phase} completed in ${duration}ms`, {
-            phase,
-            duration,
-            successCount,
-            failureCount,
-            totalSteps: successCount + failureCount,
-        });
+    stepRetry(stepId, stepName, attempt, maxAttempts) {
+        this._logWithCategory(LogLevel.WARN, `Step "${stepName}" (${stepId}) retrying — attempt ${attempt}/${maxAttempts}`, { stepId, stepName, attempt, maxAttempts }, undefined, LogCategoryEnum.RUNTIME, EngineLogType.STEP_RETRY);
     }
-    // ============================================================================
-    // UTILITY METHODS
-    // ============================================================================
     /**
-     * Format value for logging (truncate large values)
+     * Log step failure after all attempts (runtime category).
      */
-    formatValue(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (typeof value === 'string') {
-            return value.length > 100 ? `${value.substring(0, 97)}...` : value;
-        }
-        if (typeof value === 'object') {
-            const str = JSON.stringify(value);
-            return str.length > 200 ? `${str.substring(0, 197)}...` : str;
-        }
-        return String(value);
+    stepFailed(stepId, stepName, error, context) {
+        this._logWithCategory(LogLevel.ERROR, `Step "${stepName}" (${stepId}) failed: ${error.message}`, { stepId, stepName, ...context }, error, LogCategoryEnum.RUNTIME, EngineLogType.STEP_FAILED);
     }
     /**
-     * Sanitize value for logging (remove sensitive data)
+     * Log adapter action execution result (runtime category).
      */
-    sanitizeValue(value) {
-        if (value === null || value === undefined)
-            return value;
-        // For objects, recursively sanitize
-        if (typeof value === 'object' && !Array.isArray(value)) {
-            const sanitized = {};
-            for (const [key, val] of Object.entries(value)) {
-                // Skip internal fields
-                if (key.startsWith('_'))
-                    continue;
-                // Mask sensitive fields
-                if (this.isSensitiveField(key)) {
-                    sanitized[key] = '***REDACTED***';
-                }
-                else if (typeof val === 'object') {
-                    sanitized[key] = this.sanitizeValue(val);
-                }
-                else {
-                    sanitized[key] = val;
-                }
-            }
-            return sanitized;
-        }
-        return value;
+    adapterActionExecuted(adapter, action, duration, success) {
+        const level = success ? LogLevel.DEBUG : LogLevel.WARN;
+        this._logWithCategory(level, `Adapter "${adapter}" action "${action}" ${success ? 'succeeded' : 'failed'} in ${duration}ms`, { adapter, action, duration, success }, undefined, LogCategoryEnum.RUNTIME, EngineLogType.EXECUTION_TIME);
     }
     /**
-     * Check if field name suggests sensitive data
+     * Log validation phase started (analysis category).
      */
-    isSensitiveField(fieldName) {
-        const sensitivePatterns = [
-            'password', 'secret', 'token', 'key', 'credential',
-            'apikey', 'api_key', 'auth', 'private',
-        ];
-        const lowerField = fieldName.toLowerCase();
-        return sensitivePatterns.some(pattern => lowerField.includes(pattern));
+    validationStarted(type, schema) {
+        this._logWithCategory(LogLevel.DEBUG, `Validation started: ${type} against ${schema} schema`, { type, schema }, undefined, LogCategoryEnum.ANALYSIS, EngineLogType.WORKFLOW_VALIDATION);
     }
     /**
-     * Log with a custom level
+     * Log validation passed (analysis category).
      */
-    logWithLevel(level, message, context) {
-        this.log(level, message, context);
+    validationPassed(type, schema) {
+        this._logWithCategory(LogLevel.INFO, `Validation passed: ${type} (${schema})`, { type, schema }, undefined, LogCategoryEnum.ANALYSIS, EngineLogType.WORKFLOW_VALIDATION);
     }
     /**
-     * Log only if severity meets minimum threshold
+     * Log validation failure (analysis category).
      */
-    logIfSeverity(minSeverity, level, message, context) {
-        if (LogLevelSeverity[level] >= minSeverity) {
-            this.log(level, message, context);
-        }
+    validationFailed(type, schema, errors) {
+        this._logWithCategory(LogLevel.ERROR, `Validation failed: ${type} (${schema}) — ${errors.length} error(s)`, { type, schema, errors }, undefined, LogCategoryEnum.ANALYSIS, EngineLogType.VALIDATION_ERROR);
     }
     /**
-     * Measure and log execution time with appropriate log level based on duration
+     * Log parsing started (analysis category).
      */
-    async measureExecution(label, fn, thresholds) {
-        const start = Date.now();
-        try {
-            const result = await fn();
-            const duration = Date.now() - start;
-            // Choose log level based on duration thresholds
-            let level = LogLevel.DEBUG;
-            if (thresholds?.error && duration > thresholds.error) {
-                level = LogLevel.ERROR;
-            }
-            else if (thresholds?.warn && duration > thresholds.warn) {
-                level = LogLevel.WARN;
-            }
-            else {
-                level = LogLevel.INFO;
-            }
-            this.log(level, `${label} completed`, { duration: `${duration}ms` });
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - start;
-            this.log(LogLevel.ERROR, `${label} failed`, { duration: `${duration}ms` }, error instanceof Error ? error : new Error(String(error)));
-            throw error;
-        }
+    parsingStarted(format, source) {
+        this._logWithCategory(LogLevel.DEBUG, `Parsing started: ${format} from ${source}`, { format, source }, undefined, LogCategoryEnum.ANALYSIS, EngineLogType.INFO);
     }
     /**
-     * Log a structured engine event
+     * Log parsing completed (analysis category).
      */
-    logEvent(event) {
-        // Add to JSON buffer (always, regardless of log level)
-        this.addToBuffer(event);
-        // Emit event to listeners if structured events enabled
-        if (this.config.structuredEvents) {
-            this.emitEvent(event);
-        }
-        // Determine log level based on event type
-        const level = this.getLogLevelForEventType(event.type);
-        // Check if this level should be logged
-        if (!this.shouldLogLevel(level)) {
-            return;
-        }
-        // Build context with metrics if present
-        const fullContext = {
-            ...event.context,
-            ...(event.metrics && { metrics: event.metrics }),
-        };
-        // Log through standard log method
-        this.log(level, event.message, fullContext, event.error);
+    parsingCompleted(format, duration, context) {
+        this._logWithCategory(LogLevel.INFO, `Parsing completed: ${format} in ${duration}ms`, { format, duration, ...context }, undefined, LogCategoryEnum.ANALYSIS, EngineLogType.INFO);
     }
     /**
-     * Get appropriate log level for event type
+     * Log parsing failure (analysis category).
      */
-    getLogLevelForEventType(type) {
-        // Error events
-        if (type.includes('failed') || type.includes('error') || type.includes('timeout')) {
-            return LogLevel.ERROR;
-        }
-        // Warning events
-        if (type.includes('retry') || type.includes('cycles') || type === EngineLogType.WARNING) {
-            return LogLevel.WARN;
-        }
-        // Debug events
-        if (type === EngineLogType.DEBUG || type.includes('debug')) {
-            return LogLevel.DEBUG;
-        }
-        // Default to INFO
-        return LogLevel.INFO;
+    parsingFailed(format, error, context) {
+        this._logWithCategory(LogLevel.ERROR, `Parsing failed: ${format} — ${error.message}`, { format, ...context }, error, LogCategoryEnum.ANALYSIS, EngineLogType.ERROR_DETECTED);
     }
+    // ─── Typed Event Logger ───────────────────────────────────────────────────
     /**
-     * Emit event to registered listeners
+     * Emit a log with an explicit `EngineLogType`.
+     *
+     * Useful when you want the structured event type to be distinct from the
+     * generic level-based inference — e.g. to mark a `STEP_RETRY` event:
+     *
+     * ```typescript
+     * logger.logEvent(EngineLogType.STEP_RETRY, LogLevel.WARN, 'Retrying step', {
+     *   stepId: 'http-request',
+     *   attempt: 2,
+     * }, 'runtime');
+     * ```
      */
-    emitEvent(event) {
-        const listeners = this.eventListeners.get(event.type) || [];
-        for (const listener of listeners) {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                // Don't let listener errors crash the logger
-                console.error('Error in log event listener:', error);
-            }
-        }
-        // Also emit to wildcard listeners
-        const wildcardListeners = this.eventListeners.get(EngineLogType.INFO) || [];
-        for (const listener of wildcardListeners) {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                console.error('Error in wildcard log event listener:', error);
-            }
-        }
+    logEvent(type, level, message, context, category) {
+        this._logWithCategory(level, message, context, undefined, category, type);
     }
+    // ─── History Queries ──────────────────────────────────────────────────────
     /**
-     * Subscribe to specific log event types
-     */
-    on(type, listener) {
-        if (!this.eventListeners.has(type)) {
-            this.eventListeners.set(type, []);
-        }
-        this.eventListeners.get(type).push(listener);
-        // Return unsubscribe function
-        return () => {
-            const listeners = this.eventListeners.get(type);
-            if (listeners) {
-                const index = listeners.indexOf(listener);
-                if (index > -1) {
-                    listeners.splice(index, 1);
-                }
+     * Return log events that match every supplied filter field.
+     * Omit a field to skip that filter.
+     *
+     * ```typescript
+     * // All runtime errors for the current workflow
+     * logger.filterHistory({ category: 'runtime', withErrors: true });
+     *
+     * // All analysis events since the explain started
+     * const since = new Date();
+     * logger.filterHistory({ category: 'analysis', since });
+     * ```
+     */
+    filterHistory(filter = {}) {
+        return this.logHistory.filter(event => {
+            if (filter.category && event.category !== filter.category)
+                return false;
+            if (filter.type && event.type !== filter.type)
+                return false;
+            if (filter.since && event.timestamp < filter.since)
+                return false;
+            if (filter.until && event.timestamp > filter.until)
+                return false;
+            if (filter.source && event.source !== filter.source)
+                return false;
+            if (filter.withErrors && !event.error)
+                return false;
+            if (filter.workflowName) {
+                const wf = event.context?.['workflow'];
+                if (!wf || wf['name'] !== filter.workflowName)
+                    return false;
             }
-        };
-    }
-    /**
-     * Internal log method
-     */
-    log(level, message, context, error) {
-        // Check if this level should be logged (using severity for better performance)
-        if (!this.shouldLogLevel(level)) {
-            return;
-        }
-        // Create log entry
-        const entry = createLogEntry(level, message, {
-            source: this.config.source,
-            context,
-            error,
+            return true;
         });
-        // Add basic logs to buffer as well (for comprehensive JSON output)
-        this.addToBuffer({
-            type: this.mapLogLevelToEventType(level),
-            timestamp: new Date(),
-            message,
-            context,
-            error,
-        });
-        // Format and output
-        const formatted = formatLog(entry, this.formatOptions);
-        console.log(formatted);
     }
     /**
-     * Map LogLevel to EngineLogType
+     * Return all history entries grouped by category.
+     * Convenience wrapper around `filterHistory`.
      */
-    mapLogLevelToEventType(level) {
-        switch (level) {
-            case LogLevel.DEBUG: return EngineLogType.DEBUG;
-            case LogLevel.INFO: return EngineLogType.INFO;
-            case LogLevel.WARN: return EngineLogType.WARNING;
-            case LogLevel.ERROR:
-            case LogLevel.FATAL: return EngineLogType.ERROR;
-            default: return EngineLogType.INFO;
+    getHistoryByCategory() {
+        const result = {};
+        for (const event of this.logHistory) {
+            result[event.category] = result[event.category] ?? [];
+            result[event.category].push(event);
         }
+        return result;
     }
     /**
      * Check if a level should be logged using severity comparison
@@ -876,270 +716,6 @@ export class EngineLogger {
     isErrorEnabled() {
         return this.willLog(LogLevel.ERROR);
     }
-    // ============================================================================
-    // JSON LOG BUFFER MANAGEMENT
-    // ============================================================================
-    /**
-     * Add event to JSON log buffer
-     */
-    addToBuffer(event) {
-        // Add to buffer
-        this.logBuffer.push(event);
-        // Prevent buffer overflow
-        if (this.logBuffer.length > this.maxBufferSize) {
-            this.logBuffer.shift(); // Remove oldest log
-        }
-    }
-    /**
-     * Get all logs as JSON array
-     * This is what CLI, API, dashboards, and explanation system will consume
-     */
-    getJSONLogs() {
-        return [...this.logBuffer]; // Return copy to prevent external mutations
-    }
-    /**
-     * Get logs filtered by type
-     */
-    getLogsByType(type) {
-        return this.logBuffer.filter(log => log.type === type);
-    }
-    /**
-     * Get logs filtered by time range
-     */
-    getLogsByTimeRange(startTime, endTime) {
-        return this.logBuffer.filter(log => log.timestamp >= startTime && log.timestamp <= endTime);
-    }
-    /**
-     * Get logs filtered by multiple criteria
-     */
-    getLogsFiltered(filter) {
-        let filtered = this.logBuffer;
-        if (filter.types) {
-            filtered = filtered.filter(log => filter.types.includes(log.type));
-        }
-        if (filter.startTime) {
-            filtered = filtered.filter(log => log.timestamp >= filter.startTime);
-        }
-        if (filter.endTime) {
-            filtered = filtered.filter(log => log.timestamp <= filter.endTime);
-        }
-        if (filter.hasError !== undefined) {
-            filtered = filtered.filter(log => filter.hasError ? !!log.error : !log.error);
-        }
-        if (filter.searchText) {
-            const searchLower = filter.searchText.toLowerCase();
-            filtered = filtered.filter(log => log.message.toLowerCase().includes(searchLower));
-        }
-        return filtered;
-    }
-    /**
-     * Get logs by category: Parse events
-     */
-    getParseLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.WORKFLOW_VALIDATION);
-    }
-    /**
-     * Get logs by category: Validation events
-     */
-    getValidationLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.WORKFLOW_VALIDATION ||
-            log.type === EngineLogType.VALIDATION_ERROR);
-    }
-    /**
-     * Get logs by category: Execution events
-     */
-    getExecutionLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.WORKFLOW_STARTED ||
-            log.type === EngineLogType.WORKFLOW_COMPLETED ||
-            log.type === EngineLogType.WORKFLOW_FAILED ||
-            log.type === EngineLogType.STEP_STARTED ||
-            log.type === EngineLogType.STEP_COMPLETED ||
-            log.type === EngineLogType.STEP_FAILED ||
-            log.type === EngineLogType.STEP_RETRY ||
-            log.type === EngineLogType.STEP_TIMEOUT ||
-            log.type === EngineLogType.EXECUTION_TIME ||
-            log.type === EngineLogType.QUEUE_PROCESSING);
-    }
-    /**
-     * Get logs by category: Error events
-     */
-    getErrorLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.ERROR_DETECTED ||
-            log.type === EngineLogType.ERROR_DEBUGGED ||
-            log.type === EngineLogType.VALIDATION_ERROR ||
-            log.type === EngineLogType.WORKFLOW_FAILED ||
-            log.type === EngineLogType.STEP_FAILED ||
-            log.type === EngineLogType.ADAPTER_FAILED ||
-            log.type === EngineLogType.ERROR);
-    }
-    /**
-     * Get logs by category: Lifecycle events
-     */
-    getLifecycleLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.ENGINE_STARTED ||
-            log.type === EngineLogType.ENGINE_STOPPED ||
-            log.type === EngineLogType.ADAPTER_LOADED ||
-            log.type === EngineLogType.PLUGIN_INSTALLED ||
-            log.type === EngineLogType.PLUGIN_VERIFIED);
-    }
-    /**
-     * Get logs by category: Performance events
-     */
-    getPerformanceLogEvents() {
-        return this.logBuffer.filter(log => log.type === EngineLogType.PERFORMANCE_METRIC ||
-            log.type === EngineLogType.EXECUTION_TIME);
-    }
-    /**
-     * Export logs as formatted JSON string
-     */
-    exportLogsAsJSON(pretty = true) {
-        return JSON.stringify(this.logBuffer, null, pretty ? 2 : 0);
-    }
-    /**
-     * Export logs grouped by type
-     */
-    exportLogsGrouped() {
-        const grouped = {};
-        for (const log of this.logBuffer) {
-            const type = log.type;
-            if (!grouped[type]) {
-                grouped[type] = [];
-            }
-            grouped[type].push(log);
-        }
-        return grouped;
-    }
-    /**
-     * Get log statistics
-     */
-    getLogStats() {
-        const stats = {
-            total: this.logBuffer.length,
-            byType: {},
-            withErrors: 0,
-            withMetrics: 0,
-            timeRange: {
-                first: this.logBuffer[0]?.timestamp,
-                last: this.logBuffer[this.logBuffer.length - 1]?.timestamp,
-            },
-        };
-        for (const log of this.logBuffer) {
-            // Count by type
-            stats.byType[log.type] = (stats.byType[log.type] || 0) + 1;
-            // Count errors and metrics
-            if (log.error)
-                stats.withErrors++;
-            if (log.metrics)
-                stats.withMetrics++;
-        }
-        return stats;
-    }
-    /**
-     * Clear log buffer
-     */
-    clearLogs() {
-        this.logBuffer = [];
-    }
-    /**
-     * Set maximum buffer size
-     */
-    setMaxBufferSize(size) {
-        this.maxBufferSize = size;
-        // Trim buffer if needed
-        while (this.logBuffer.length > this.maxBufferSize) {
-            this.logBuffer.shift();
-        }
-    }
-    /**
-     * Get current buffer size
-     */
-    getBufferSize() {
-        return this.logBuffer.length;
-    }
-    /**
-     * Export logs in a comprehensive format for consumers (CLI, API, dashboards)
-     */
-    exportLogs() {
-        const stats = this.getLogStats();
-        const grouped = this.exportLogsGrouped();
-        // Build execution summary from logs
-        const execution = this.buildExecutionSummary();
-        return {
-            raw: this.getJSONLogs(),
-            grouped,
-            stats,
-            execution,
-        };
-    }
-    /**
-     * Build execution summary from collected logs
-     * This powers dynamic explanation generation
-     */
-    buildExecutionSummary() {
-        const workflowLogs = this.logBuffer.filter(log => log.type === EngineLogType.WORKFLOW_STARTED ||
-            log.type === EngineLogType.WORKFLOW_COMPLETED ||
-            log.type === EngineLogType.WORKFLOW_FAILED);
-        const stepLogs = this.logBuffer.filter(log => log.type === EngineLogType.STEP_STARTED ||
-            log.type === EngineLogType.STEP_COMPLETED ||
-            log.type === EngineLogType.STEP_FAILED);
-        const errorLogs = this.logBuffer.filter(log => log.error !== undefined ||
-            log.type === EngineLogType.ERROR_DETECTED ||
-            log.type === EngineLogType.VALIDATION_ERROR);
-        const metricLogs = this.logBuffer.filter(log => log.type === EngineLogType.PERFORMANCE_METRIC ||
-            log.type === EngineLogType.EXECUTION_TIME);
-        // Extract workflow info
-        let workflow;
-        const workflowStarted = workflowLogs.find(log => log.type === EngineLogType.WORKFLOW_STARTED);
-        const workflowEnded = workflowLogs.find(log => log.type === EngineLogType.WORKFLOW_COMPLETED ||
-            log.type === EngineLogType.WORKFLOW_FAILED);
-        if (workflowStarted && workflowEnded) {
-            workflow = {
-                name: workflowStarted.context?.workflowName || 'Unknown',
-                status: workflowEnded.type === EngineLogType.WORKFLOW_COMPLETED ? 'completed' : 'failed',
-                duration: workflowEnded.metrics?.duration,
-            };
-        }
-        // Extract step info
-        const steps = [];
-        const stepMap = new Map();
-        for (const log of stepLogs) {
-            const stepId = log.context?.stepId || '';
-            const stepName = log.context?.stepName || '';
-            if (!stepMap.has(stepId)) {
-                stepMap.set(stepId, { id: stepId, name: stepName });
-            }
-            const step = stepMap.get(stepId);
-            if (log.type === EngineLogType.STEP_COMPLETED) {
-                step.status = 'completed';
-                step.duration = log.metrics?.duration;
-            }
-            else if (log.type === EngineLogType.STEP_FAILED) {
-                step.status = 'failed';
-            }
-            else {
-                step.status = 'started';
-            }
-        }
-        steps.push(...stepMap.values());
-        // Extract error info
-        const errors = errorLogs.map(log => ({
-            step: log.context?.stepId || log.context?.stepName,
-            message: log.message,
-            error: log.error,
-        }));
-        // Extract metrics
-        const metrics = metricLogs.map(log => ({
-            label: log.context?.label || 'Unknown',
-            duration: log.metrics?.duration,
-            memory: log.metrics?.memory,
-        }));
-        return {
-            workflow,
-            steps,
-            errors,
-            metrics,
-        };
-    }
 }
 /**
  * Create a logger instance from engine config
@@ -1160,11 +736,17 @@ export function createEngineLogger(logLevel, verbose = false) {
     const level = levelMap[logLevel] || LogLevel.INFO;
     return new EngineLogger({
         level,
-        format: verbose ? 'pretty' : 'text',
+        format: verbose ? 'pretty' : 'json',
         colors: true,
-        timestamp: true, // Enable human-readable timestamps
+        timestamp: true,
         source: 'Orbyt',
-        structuredEvents: true, // Always collect structured JSON logs
+        category: LogCategoryEnum.SYSTEM,
+        structuredEvents: true,
     });
 }
+/**
+ * Re-export formatTimestamp for external use
+ * Allows other parts of the system to format timestamps consistently
+ */
+export { formatTimestamp };
 //# sourceMappingURL=EngineLogger.js.map