fix: connect embedded runtime input lifecycle

crates/worker-runtime/src/runtime.rs

@@ -11,7 +11,8 @@ use crate::error::RuntimeError;
 use crate::execution::{
     WorkerExecutionBackend, WorkerExecutionBackendKind, WorkerExecutionBackendRef,
     WorkerExecutionHandle, WorkerExecutionOperation, WorkerExecutionResult,
-    WorkerExecutionSpawnRequest, WorkerExecutionSpawnResult, WorkerExecutionStatus,
+    WorkerExecutionRunState, WorkerExecutionSpawnRequest, WorkerExecutionSpawnResult,
+    WorkerExecutionStatus,
 };
 #[cfg(feature = "fs-store")]
 use crate::fs_store::{
@@ -723,9 +724,13 @@ impl Runtime {
         let mut state = self.lock()?;
         state.ensure_worker_ref(worker_ref)?;
         let transcript_sequence = state.project_protocol_event_to_transcript(worker_ref, &payload);
+        let execution_state_changed =
+            state.project_protocol_event_to_execution(worker_ref, &payload);
         let event = state.push_worker_observation_event(worker_ref.clone(), payload);
-        if let Some(sequence) = transcript_sequence {
+        if transcript_sequence.is_some() || execution_state_changed {
             state.persist_worker(&worker_ref.worker_id)?;
+        }
+        if let Some(sequence) = transcript_sequence {
             state.persist_transcript_entry(&worker_ref.worker_id, sequence)?;
         }
         Ok(event)
@@ -1324,6 +1329,51 @@ impl RuntimeState {
         }
     }
 
+    #[cfg(feature = "ws-server")]
+    fn project_protocol_event_to_execution(
+        &mut self,
+        worker_ref: &WorkerRef,
+        event: &protocol::Event,
+    ) -> bool {
+        let Some(worker) = self.workers.get_mut(&worker_ref.worker_id) else {
+            return false;
+        };
+        let status = &mut worker.execution;
+        let next_run_state = match event {
+            protocol::Event::Status {
+                status: protocol::WorkerStatus::Running,
+            } => Some(WorkerExecutionRunState::Busy),
+            protocol::Event::Status {
+                status: protocol::WorkerStatus::Idle,
+            } => Some(WorkerExecutionRunState::Idle),
+            protocol::Event::Status {
+                status: protocol::WorkerStatus::Paused,
+            } => Some(WorkerExecutionRunState::Busy),
+            protocol::Event::Snapshot { status, .. } => match status {
+                protocol::WorkerStatus::Running => Some(WorkerExecutionRunState::Busy),
+                protocol::WorkerStatus::Idle => Some(WorkerExecutionRunState::Idle),
+                protocol::WorkerStatus::Paused => Some(WorkerExecutionRunState::Busy),
+            },
+            protocol::Event::RunEnd { result } => match result {
+                protocol::RunResult::Finished | protocol::RunResult::RolledBack => {
+                    Some(WorkerExecutionRunState::Idle)
+                }
+                protocol::RunResult::Paused => Some(WorkerExecutionRunState::Busy),
+                protocol::RunResult::LimitReached => Some(WorkerExecutionRunState::Errored),
+            },
+            protocol::Event::Error { .. } => Some(WorkerExecutionRunState::Errored),
+            _ => None,
+        };
+        let Some(next_run_state) = next_run_state else {
+            return false;
+        };
+        if status.run_state == next_run_state {
+            return false;
+        }
+        status.run_state = next_run_state;
+        true
+    }
+
     fn push_diagnostic(
         &mut self,
         severity: DiagnosticSeverity,