rebuild_queue: wire worker into coordinator + dashboard event

hive-c0re/src/coordinator.rs

@@ -88,6 +88,12 @@ pub struct Coordinator {
     /// tokio mutex so the rescan can `await` `lifecycle::list` /
     /// `is_running` without blocking other coordinator paths.
     last_containers: tokio::sync::Mutex<HashMap<String, ContainerView>>,
+    /// Global rebuild queue. Every long-running container/meta op
+    /// (rebuild, meta-update, first-spawn) goes through this queue so
+    /// hive-c0re runs at most one at a time and the dashboard can
+    /// render a single ordered view of pending + running work. See
+    /// `rebuild_queue.rs` for the dedup rules + history retention.
+    pub rebuild_queue: Arc<crate::rebuild_queue::RebuildQueue>,
     /// Shutdown signal broadcast to all background tasks. Sending
     /// `true` asks every loop to exit after its current work item.
     /// Use `shutdown_rx()` to subscribe; `request_shutdown()` to fire.
@@ -202,10 +208,23 @@ impl Coordinator {
             event_seq: AtomicU64::new(0),
             meta_updates_active: AtomicU64::new(0),
             last_containers: tokio::sync::Mutex::new(HashMap::new()),
+            rebuild_queue: Arc::new(crate::rebuild_queue::RebuildQueue::new()),
             shutdown_tx,
         })
     }
 
+    /// Emit a `RebuildQueueChanged` snapshot event. Called from the
+    /// queue mutation helpers (`enqueue` / `finish` / `cancel`-adjacent
+    /// wrappers below) and the worker so every state transition
+    /// surfaces on the dashboard without extra plumbing.
+    pub fn emit_rebuild_queue_snapshot(self: &Arc<Self>) {
+        let queue = self.rebuild_queue.snapshot();
+        self.emit_dashboard_event(DashboardEvent::RebuildQueueChanged {
+            seq: self.next_seq(),
+            queue,
+        });
+    }
+
     /// Subscribe to the shutdown watch channel. Background tasks call
     /// this at spawn time and break their loop when the receiver
     /// transitions to `true` (via `Coordinator::request_shutdown`).