Source the packages-list pause reason from fetched data, not a frontend cache

The Installed Packages List cached each package's autosync pause reason in
a page-scoped frontend map reconciled from Tauri events plus a
get_autosync_snapshot seed. That reconciliation caused three P1 races
(snapshot-vs-events, async listener-registration window, manual-clear
staleness) because not every backend pause-clear path emits a UI event.

Make it data-driven instead: the list-data command reads the autosync
watcher's paused map (the single source of truth, the same source
get_autosync_snapshot uses) and stamps each row's new pausedReason field
with the Other-reason message. The UI derives the red state and hint purely
from that fetched data and refetches on autosync events, so the durable red
state always reflects authoritative backend data.

Removes the frontend paused_map, resolved_since_mount, the snapshot-seeding
spawn_local, and the now-unused listen_with_ready helper (folded back into
listen). Adds byte-identical pausedReason wire-form tests on both sides.

Author: fiskus

quilt-sync/src-tauri/src/commands/package_list.rs

@@ -1,9 +1,12 @@
 //! Installed-packages list (light phase) and per-package status refresh
 //! (heavy phase) for the Leptos UI.
 
+use std::collections::HashMap;
+
 use serde::Serialize;
 
 use crate::Error;
+use crate::autopull::Watcher;
 use crate::model;
 use crate::quilt;
 
@@ -26,16 +29,25 @@ pub struct InstalledPackageListItem {
     /// the UI can still surface a misconfigured remote when origin
     /// resolution fails (status: "error" branch).
     pub remote_display: Option<String>,
+    /// The autosync watcher's `Other` pause message for this namespace,
+    /// if it is currently paused for a reason the status string cannot
+    /// carry (workflow refusal, hash mismatch, etc.); `None` otherwise.
+    ///
+    /// Read straight from the watcher's paused map (the single source of
+    /// truth) at fetch time, so the UI derives the red/hint state from
+    /// authoritative data instead of a reconciled frontend cache.
+    pub paused_reason: Option<String>,
 }
 
 async fn get_installed_packages_list_data_from_model(
     m: &impl model::QuiltModel,
     tracing: &crate::telemetry::Telemetry,
+    paused_reasons: &HashMap<String, String>,
 ) -> Result<InstalledPackagesListData, Error> {
     let list = m.get_installed_packages_list().await?;
     let mut packages = Vec::new();
     for installed_package in list {
-        match load_package_item(m, tracing, &installed_package).await {
+        match load_package_item(m, tracing, &installed_package, paused_reasons).await {
             Ok(item) => packages.push(item),
             Err(err) => {
                 tracing::warn!(
@@ -52,28 +64,33 @@ async fn load_package_item(
     m: &impl model::QuiltModel,
     tracing: &crate::telemetry::Telemetry,
     installed_package: &quilt::InstalledPackage,
+    paused_reasons: &HashMap<String, String>,
 ) -> Result<InstalledPackageListItem, Error> {
+    let namespace = installed_package.namespace.to_string();
+    let paused_reason = paused_reasons.get(&namespace).cloned();
     let lineage = m.get_installed_package_lineage(installed_package).await?;
 
     let Some(remote_uri) = lineage.remote_uri.as_ref() else {
         return Ok(InstalledPackageListItem {
-            namespace: installed_package.namespace.to_string(),
+            namespace,
             status: "local".to_string(),
             has_changes: false,
             uri: None,
             remote_display: None,
+            paused_reason,
         });
     };
 
     let typed_uri = quilt_uri::S3PackageUri::from(remote_uri);
 
     if remote_uri.origin.is_none() {
         return Ok(InstalledPackageListItem {
-            namespace: installed_package.namespace.to_string(),
+            namespace,
             status: "error".to_string(),
             has_changes: false,
             uri: Some(typed_uri),
             remote_display: Some(remote_uri.to_string()),
+            paused_reason,
         });
     }
 
@@ -85,20 +102,34 @@ async fn load_package_item(
     let has_changes = false; // Refined by refresh_package_status
 
     Ok(InstalledPackageListItem {
-        namespace: installed_package.namespace.to_string(),
+        namespace,
         status: upstream_state.to_string(),
         has_changes,
         uri: Some(typed_uri),
         remote_display: Some(remote_display),
+        paused_reason,
     })
 }
 
 #[tauri::command]
 pub async fn get_installed_packages_list_data(
     m: tauri::State<'_, model::Model>,
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
+    watcher: tauri::State<'_, Watcher>,
 ) -> Result<InstalledPackagesListData, String> {
-    get_installed_packages_list_data_from_model(&*m, &tracing)
+    // Read the watcher's paused map — the single source of truth — the
+    // same way `get_autosync_snapshot` does. Only `Other`-reason pauses
+    // carry a `message`; those are the reasons the status string cannot
+    // convey, so they are the only ones surfaced on each row.
+    let paused_reasons: HashMap<String, String> = watcher
+        .snapshot()
+        .await
+        .paused
+        .into_iter()
+        .filter_map(|entry| entry.message.map(|message| (entry.namespace, message)))
+        .collect();
+
+    get_installed_packages_list_data_from_model(&*m, &tracing, &paused_reasons)
         .await
         .map_err(|e| e.to_frontend_string())
 }
@@ -203,7 +234,7 @@ mod tests {
         mocks::mock_installed_packages_list(&mut model);
         let tracing = crate::telemetry::Telemetry::default();
 
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -266,7 +297,7 @@ mod tests {
             });
 
         let tracing = crate::telemetry::Telemetry::default();
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -316,7 +347,7 @@ mod tests {
             });
 
         let tracing = crate::telemetry::Telemetry::default();
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -352,7 +383,7 @@ mod tests {
             });
 
         let tracing = crate::telemetry::Telemetry::default();
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -386,7 +417,7 @@ mod tests {
             .returning(|_| Ok(quilt::lineage::PackageLineage::default()));
 
         let tracing = crate::telemetry::Telemetry::default();
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -426,7 +457,7 @@ mod tests {
             });
 
         let tracing = crate::telemetry::Telemetry::default();
-        let data = get_installed_packages_list_data_from_model(&model, &tracing)
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &HashMap::new())
             .await
             .map_err(|e| e.to_string())?;
 
@@ -643,4 +674,70 @@ mod tests {
         assert!(!result.has_changes);
         Ok(())
     }
+
+    // ── paused_reason population (data-driven red state) ──
+
+    #[tokio::test]
+    async fn test_installed_packages_list_data_populates_paused_reason() -> Result<(), String> {
+        let mut model = mocks::create();
+
+        let pkgs = vec![
+            make_installed_package(("test", "paused")),
+            make_installed_package(("test", "clean")),
+        ];
+        model
+            .expect_get_installed_packages_list()
+            .return_once(move || Ok(pkgs));
+        model
+            .expect_get_installed_package_lineage()
+            .returning(|pkg| {
+                let uri = make_manifest_uri(&pkg.namespace.to_string());
+                Ok(quilt::lineage::PackageLineage::from_remote(
+                    uri,
+                    "abcdef".to_string(),
+                ))
+            });
+
+        // Stand in for the watcher's paused map: only the paused namespace
+        // has an `Other` message.
+        let mut paused_reasons = HashMap::new();
+        paused_reasons.insert(
+            "test/paused".to_string(),
+            "workflow rejected metadata".to_string(),
+        );
+
+        let tracing = crate::telemetry::Telemetry::default();
+        let data = get_installed_packages_list_data_from_model(&model, &tracing, &paused_reasons)
+            .await
+            .map_err(|e| e.to_string())?;
+
+        let find = |ns: &str| data.packages.iter().find(|p| p.namespace == ns).unwrap();
+        assert_eq!(
+            find("test/paused").paused_reason.as_deref(),
+            Some("workflow rejected metadata"),
+        );
+        assert!(find("test/clean").paused_reason.is_none());
+        Ok(())
+    }
+
+    /// The serialized row must be byte-identical to what the UI mirror
+    /// (`quilt_sync_ui::commands::PackageItemData`) deserializes in its
+    /// `package_item_data_wire_form_is_verbatim`. If the two drift, the
+    /// list silently drops the pause reason (or a whole field) at the
+    /// Tauri boundary.
+    #[test]
+    fn package_item_data_wire_form_is_verbatim() {
+        let item = InstalledPackageListItem {
+            namespace: "acme/data".to_string(),
+            status: "paused".to_string(),
+            has_changes: false,
+            uri: None,
+            remote_display: None,
+            paused_reason: Some("workflow rejected metadata".to_string()),
+        };
+        assert_eq!(
+            serde_json::to_string(&item).unwrap(),
+            r#"{"namespace":"acme/data","status":"paused","hasChanges":false,"uri":null,"remoteDisplay":null,"pausedReason":"workflow rejected metadata"}"#
+        );
+    }
 }

quilt-sync/ui/src/commands.rs

@@ -261,6 +261,13 @@ pub struct PackageItemData {
     pub has_changes: bool,
     pub uri: Option<S3PackageUri>,
     pub remote_display: Option<String>,
+    /// The autosync watcher's `Other` pause message for this namespace,
+    /// fetched with the list data. `Some` means the row is autosync-paused
+    /// for a reason the status string cannot carry, so it renders red with
+    /// this reason as its third line; `None` means no such pause. Sourced
+    /// directly from the backend's authoritative paused map — there is no
+    /// frontend cache to go stale.
+    pub paused_reason: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -878,7 +885,34 @@ pub async fn send_crash_report(zip_path: String) -> Result<String, String> {
 
 #[cfg(test)]
 mod tests {
-    use super::{CommitViolation, CommitWorkflows, ViolationField, WorkflowInfo, WorkflowIntent};
+    use super::{
+        CommitViolation, CommitWorkflows, PackageItemData, ViolationField, WorkflowInfo,
+        WorkflowIntent,
+    };
+
+    /// The mirror struct must deserialize the exact JSON the backend
+    /// (`quilt_sync::commands::package_list::InstalledPackageListItem`)
+    /// serializes. This literal is anchored identically in the backend's
+    /// `package_item_data_wire_form_is_verbatim`; if the two drift, the
+    /// list silently drops the pause reason (or a whole field) at the
+    /// Tauri boundary — the exact class of bug this data-driven design
+    /// exists to prevent.
+    #[test]
+    fn package_item_data_wire_form_is_verbatim() {
+        let item = serde_json::from_str::<PackageItemData>(
+            r#"{"namespace":"acme/data","status":"paused","hasChanges":false,"uri":null,"remoteDisplay":null,"pausedReason":"workflow rejected metadata"}"#,
+        )
+        .unwrap();
+        assert_eq!(item.namespace, "acme/data");
+        assert_eq!(item.status, "paused");
+        assert!(!item.has_changes);
+        assert!(item.uri.is_none());
+        assert!(item.remote_display.is_none());
+        assert_eq!(
+            item.paused_reason.as_deref(),
+            Some("workflow rejected metadata")
+        );
+    }
 
     /// The mirror types must deserialize the exact tagged JSON the backend
     /// (`quilt_sync::commands::commit_data::CommitViolation`) serializes. These