fix: use live worker observation snapshots

crates/worker/src/controller.rs

@@ -5,8 +5,8 @@ use std::sync::atomic::Ordering;
 use llm_engine::EngineError;
 use llm_engine::llm_client::client::LlmClient;
 use manifest::TicketFeatureAccessConfig;
-use session_store::Store;
 use session_store::WorkerMetadataStore;
+use session_store::{LogEntry, Store};
 use ticket::LocalTicketBackend;
 use ticket::config::TicketConfig;
 use tokio::sync::{broadcast, mpsc, oneshot};
@@ -16,7 +16,7 @@ use crate::discovery::{
     WorkerDiscovery, list_workers_tool, restore_worker_tool, send_to_peer_worker_tool,
 };
 use crate::feature::FeatureRegistryBuilder;
-use crate::in_flight::InFlightEvents;
+use crate::in_flight::{InFlightEvents, snapshot_from_guard};
 use crate::ipc::alerter::Alerter;
 use crate::ipc::notify_buffer::NotifyBuffer;
 use crate::ipc::server::SocketServer;
@@ -66,6 +66,31 @@ impl WorkerHandle {
         self.event_tx.subscribe()
     }
 
+    pub fn snapshot_event(&self) -> Event {
+        self.snapshot_event_with_entry_subscription().0
+    }
+
+    pub(crate) fn snapshot_event_with_entry_subscription(
+        &self,
+    ) -> (Event, broadcast::Receiver<LogEntry>) {
+        let (entries, entry_rx, in_flight) = {
+            let in_flight_guard = self.in_flight.snapshot_guard();
+            let (entries, entry_rx) = self.sink.subscribe_with_snapshot();
+            let in_flight = snapshot_from_guard(&in_flight_guard);
+            (entries, entry_rx, in_flight)
+        };
+        let event = Event::Snapshot {
+            entries: entries
+                .into_iter()
+                .map(|entry| serde_json::to_value(entry).expect("log entry serializes"))
+                .collect(),
+            greeting: self.shared_state.greeting.clone(),
+            status: self.shared_state.get_status(),
+            in_flight,
+        };
+        (event, entry_rx)
+    }
+
     /// Broadcast an event to all listeners (including socket clients).
     pub fn send_event(&self, event: Event) -> Result<usize, broadcast::error::SendError<Event>> {
         self.event_tx.send(event)

crates/worker/src/ipc/server.rs

@@ -7,7 +7,6 @@ use tokio::net::UnixListener;
 use tokio::task::JoinHandle;
 
 use crate::controller::WorkerHandle;
-use crate::in_flight::snapshot_from_guard;
 use protocol::{Event, Method};
 
 /// Unix socket server for Worker Protocol.
@@ -111,16 +110,10 @@ async fn handle_connection(stream: tokio::net::UnixStream, handle: WorkerHandle)
     // committed entry or as the still-present in-flight block. This lock
     // order matches `append_entry` (in-flight clear before sink publish) and
     // keeps the snapshot/live boundary gap-free.
-    let (entries_snapshot, mut entry_rx, alert_snapshot, mut rx, in_flight) = {
-        let in_flight_guard = handle.in_flight.snapshot_guard();
-        let (entries_snapshot, entry_rx) = handle.sink.subscribe_with_snapshot();
-
-        // Atomically subscribe and snapshot buffered alerts so that warnings
-        // emitted before this client connected are replayed exactly once.
-        let (alert_snapshot, rx) = handle.alerter.subscribe_with_snapshot();
-        let in_flight = snapshot_from_guard(&in_flight_guard);
-        (entries_snapshot, entry_rx, alert_snapshot, rx, in_flight)
-    };
+    let (snapshot_event, mut entry_rx) = handle.snapshot_event_with_entry_subscription();
+    // Atomically subscribe and snapshot buffered alerts so that warnings
+    // emitted before this client connected are replayed exactly once.
+    let (alert_snapshot, mut rx) = handle.alerter.subscribe_with_snapshot();
     for alert in alert_snapshot {
         if writer.write(&Event::Alert(alert)).await.is_err() {
             return;
@@ -129,15 +122,6 @@ async fn handle_connection(stream: tokio::net::UnixStream, handle: WorkerHandle)
 
     // Send the typed snapshot up front so late attachers can
     // reconstruct view state without an extra round trip.
-    let snapshot_event = Event::Snapshot {
-        entries: entries_snapshot
-            .into_iter()
-            .map(|e| serde_json::to_value(&e).expect("LogEntry is Serialize"))
-            .collect(),
-        greeting: handle.shared_state.greeting.clone(),
-        status: handle.shared_state.get_status(),
-        in_flight,
-    };
     if writer.write(&snapshot_event).await.is_err() {
         return;
     }