feat(wfe-core): add LogSink trait and wire lifecycle publisher into executor

LogSink trait for real-time step output streaming. Added to
StepExecutionContext as optional field (backward compatible).
Threaded through WorkflowExecutor and WorkflowHostBuilder.

Wired LifecyclePublisher.publish() into executor at 5 points:
StepStarted, StepCompleted, Error, Completed, Terminated.
Also added lifecycle events to host start/suspend/resume/terminate.

wfe/src/host.rs

@@ -8,8 +8,8 @@ use tracing::{debug, error, info, warn};
 
 use wfe_core::executor::{StepRegistry, WorkflowExecutor};
 use wfe_core::models::{
-    Event, ExecutionPointer, PointerStatus, QueueType, WorkflowDefinition, WorkflowInstance,
-    WorkflowStatus,
+    Event, ExecutionPointer, LifecycleEvent, LifecycleEventType, PointerStatus, QueueType,
+    WorkflowDefinition, WorkflowInstance, WorkflowStatus,
 };
 use wfe_core::traits::{
     DistributedLockProvider, HostContext, LifecyclePublisher, PersistenceProvider, QueueProvider,
@@ -308,6 +308,18 @@ impl WorkflowHost {
             .queue_work(&id, QueueType::Workflow)
             .await?;
 
+        // Publish lifecycle event.
+        if let Some(ref publisher) = self.lifecycle {
+            let _ = publisher
+                .publish(LifecycleEvent::new(
+                    &id,
+                    definition_id,
+                    version,
+                    LifecycleEventType::Started,
+                ))
+                .await;
+        }
+
         Ok(id)
     }
 
@@ -345,6 +357,16 @@ impl WorkflowHost {
         }
         instance.status = WorkflowStatus::Suspended;
         self.persistence.persist_workflow(&instance).await?;
+        if let Some(ref publisher) = self.lifecycle {
+            let _ = publisher
+                .publish(LifecycleEvent::new(
+                    id,
+                    &instance.workflow_definition_id,
+                    instance.version,
+                    LifecycleEventType::Suspended,
+                ))
+                .await;
+        }
         Ok(true)
     }
 
@@ -362,6 +384,16 @@ impl WorkflowHost {
             .queue_work(id, QueueType::Workflow)
             .await?;
 
+        if let Some(ref publisher) = self.lifecycle {
+            let _ = publisher
+                .publish(LifecycleEvent::new(
+                    id,
+                    &instance.workflow_definition_id,
+                    instance.version,
+                    LifecycleEventType::Resumed,
+                ))
+                .await;
+        }
         Ok(true)
     }
 
@@ -376,6 +408,16 @@ impl WorkflowHost {
         instance.status = WorkflowStatus::Terminated;
         instance.complete_time = Some(chrono::Utc::now());
         self.persistence.persist_workflow(&instance).await?;
+        if let Some(ref publisher) = self.lifecycle {
+            let _ = publisher
+                .publish(LifecycleEvent::new(
+                    id,
+                    &instance.workflow_definition_id,
+                    instance.version,
+                    LifecycleEventType::Terminated,
+                ))
+                .await;
+        }
         Ok(true)
     }
 

wfe/src/host_builder.rs

@@ -21,6 +21,7 @@ pub struct WorkflowHostBuilder {
     queue_provider: Option<Arc<dyn QueueProvider>>,
     lifecycle: Option<Arc<dyn LifecyclePublisher>>,
     search: Option<Arc<dyn SearchIndex>>,
+    log_sink: Option<Arc<dyn wfe_core::traits::LogSink>>,
 }
 
 impl WorkflowHostBuilder {
@@ -31,6 +32,7 @@ impl WorkflowHostBuilder {
             queue_provider: None,
             lifecycle: None,
             search: None,
+            log_sink: None,
         }
     }
 
@@ -64,6 +66,12 @@ impl WorkflowHostBuilder {
         self
     }
 
+    /// Set an optional log sink for real-time step output streaming.
+    pub fn use_log_sink(mut self, sink: Arc<dyn wfe_core::traits::LogSink>) -> Self {
+        self.log_sink = Some(sink);
+        self
+    }
+
     /// Build the `WorkflowHost`.
     ///
     /// Returns an error if persistence, lock_provider, or queue_provider have not been set.
@@ -90,6 +98,9 @@ impl WorkflowHostBuilder {
         if let Some(ref search) = self.search {
             executor = executor.with_search(Arc::clone(search));
         }
+        if let Some(ref log_sink) = self.log_sink {
+            executor = executor.with_log_sink(Arc::clone(log_sink));
+        }
 
         Ok(WorkflowHost {
             persistence,