dashboard: show meta-update progress in the META INPUTS panel

post_meta_update returns 200 immediately and runs the nix flake
update + agent-rebuild ripple in a background task, so the META
INPUTS panel looked idle for the whole multi-minute window (#259).

Track in-flight runs with a Coordinator atomic counter, exposed via
an RAII MetaUpdateGuard held across run_meta_update. Surface it as
the meta_update_running snapshot field plus a MetaUpdateRunning SSE
event (flipped only when the count crosses 0, so concurrent runs
flip the flag once). The panel shows a pulsing in-progress banner
and disables the update button while a run is active.

hive-c0re/src/coordinator.rs

@@ -72,6 +72,14 @@ pub struct Coordinator {
     /// snapshot.
     dashboard_events: broadcast::Sender<DashboardEvent>,
     event_seq: AtomicU64,
+    /// Count of dashboard-triggered `meta-update` runs currently in
+    /// flight. `post_meta_update` returns 200 immediately and does the
+    /// multi-minute `nix flake update` + agent-rebuild ripple in a
+    /// background task, so without this the META INPUTS panel showed no
+    /// sign anything was happening (issue #259). Held via
+    /// `MetaUpdateGuard`; a count > 0 surfaces on `/api/state` as
+    /// `meta_update_running` and via the `MetaUpdateRunning` event.
+    meta_updates_active: AtomicU64,
     /// Last container snapshot seen by `rescan_containers_and_emit`,
     /// keyed by `ContainerView.name`. The rescan diffs a fresh
     /// `container_view::build_all` against this map and emits one
@@ -109,6 +117,33 @@ impl Drop for TransientGuard {
     }
 }
 
+/// RAII guard for the `meta-update` in-progress flag, held for the
+/// duration of a `run_meta_update` background task. Created by
+/// `Coordinator::meta_update_guard`. Drop decrements the active-run
+/// count; the count crossing back to 0 emits
+/// `MetaUpdateRunning { running: false }`, so a concurrent pair of
+/// updates only flips the dashboard flag once.
+pub struct MetaUpdateGuard {
+    coord: Arc<Coordinator>,
+}
+
+impl Drop for MetaUpdateGuard {
+    fn drop(&mut self) {
+        if self
+            .coord
+            .meta_updates_active
+            .fetch_sub(1, Ordering::SeqCst)
+            == 1
+        {
+            self.coord
+                .emit_dashboard_event(DashboardEvent::MetaUpdateRunning {
+                    seq: self.coord.next_seq(),
+                    running: false,
+                });
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum TransientKind {
     /// `lifecycle::spawn` is running (nixos-container create + update + start).
@@ -165,6 +200,7 @@ impl Coordinator {
             transient: Mutex::new(HashMap::new()),
             dashboard_events,
             event_seq: AtomicU64::new(0),
+            meta_updates_active: AtomicU64::new(0),
             last_containers: tokio::sync::Mutex::new(HashMap::new()),
             shutdown_tx,
         })
@@ -218,6 +254,31 @@ impl Coordinator {
         let _ = self.dashboard_events.send(event);
     }
 
+    /// Mark a `meta-update` as in flight and return an RAII guard that
+    /// clears it on drop (including drop-via-panic). The first
+    /// concurrent run emits `MetaUpdateRunning { running: true }`; the
+    /// last one to finish emits `running: false`. The dashboard's META
+    /// INPUTS panel reads the flag to show a disabled "updating…"
+    /// state while the lock bump + rebuild ripple runs (issue #259).
+    pub fn meta_update_guard(self: &Arc<Self>) -> MetaUpdateGuard {
+        if self.meta_updates_active.fetch_add(1, Ordering::SeqCst) == 0 {
+            self.emit_dashboard_event(DashboardEvent::MetaUpdateRunning {
+                seq: self.next_seq(),
+                running: true,
+            });
+        }
+        MetaUpdateGuard {
+            coord: Arc::clone(self),
+        }
+    }
+
+    /// True while at least one dashboard-triggered `meta-update` is
+    /// running. Surfaced on `/api/state` as `meta_update_running` so a
+    /// client that cold-loads mid-update sees the in-progress state.
+    pub fn meta_update_in_progress(&self) -> bool {
+        self.meta_updates_active.load(Ordering::SeqCst) > 0
+    }
+
     /// Emit `ApprovalAdded` immediately after the row is inserted in
     /// sqlite. Caller passes the diff text it already computed (or
     /// `None` for spawn approvals which carry no diff).

hive-c0re/src/dashboard.rs

@@ -206,6 +206,12 @@ struct StateSnapshot {
     /// Inputs in `meta/flake.lock` the operator can selectively
     /// `nix flake update`. Hyperhive first, then `agent-<n>` rows.
     meta_inputs: Vec<MetaInputView>,
+    /// True while a dashboard-triggered `meta-update` (flake lock bump +
+    /// agent rebuild ripple) is running in the background. Lets a
+    /// client that cold-loads mid-update render the META INPUTS panel's
+    /// disabled "updating…" state; live transitions arrive via the
+    /// `MetaUpdateRunning` event (issue #259).
+    meta_update_running: bool,
     /// Whether the hive-forge container is up. When true the dashboard
     /// links each container's config + each approval's commit into the
     /// forge's `agent-configs` repos.
@@ -395,6 +401,7 @@ async fn api_state(headers: HeaderMap, State(state): State<AppState>) -> axum::J
         approvals,
         approval_history,
         meta_inputs: read_meta_inputs(),
+        meta_update_running: state.coord.meta_update_in_progress(),
         questions,
         question_history,
         tombstones,
@@ -1495,6 +1502,10 @@ async fn post_meta_update(
 /// operator and manager get the same feedback they'd see from an
 /// auto-update / manual dashboard rebuild.
 async fn run_meta_update(coord: &Arc<crate::coordinator::Coordinator>, inputs: &[String]) {
+    // Held for the whole run (incl. the early `return` on lock failure):
+    // emits `MetaUpdateRunning { running: true }` now and `false` on
+    // drop so the META INPUTS panel shows progress (issue #259).
+    let _progress = coord.meta_update_guard();
     tracing::info!(?inputs, "meta-update: starting");
     if let Err(e) = crate::meta::lock_update(inputs).await {
         tracing::warn!(error = ?e, "meta-update: lock_update failed");

hive-c0re/src/dashboard_events.rs

@@ -194,4 +194,14 @@ pub enum DashboardEvent {
         seq: u64,
         inputs: Vec<MetaInputView>,
     },
+    /// A dashboard-triggered `meta-update` started (`running: true`) or
+    /// finished (`running: false`). `post_meta_update` returns 200
+    /// immediately and runs the `nix flake update` + agent-rebuild
+    /// ripple in a background task — this event lets the META INPUTS
+    /// panel show a disabled "updating…" state for that whole window
+    /// instead of looking idle (issue #259). Emitted by
+    /// `Coordinator::meta_update_guard` / `MetaUpdateGuard::drop` only
+    /// when the active-run count crosses 0, so concurrent updates flip
+    /// the flag exactly once.
+    MetaUpdateRunning { seq: u64, running: bool },
 }