fix(driver-store): hide native agent JRE badge

crates/dbx-core/src/agent_manager.rs

@@ -347,6 +347,7 @@ pub struct AgentDriverInfo {
     pub installed: bool,
     pub installed_version: Option<String>,
     pub update_available: bool,
+    pub requires_java_runtime: bool,
     pub jre: String,
     pub jre_installed: bool,
 }

crates/dbx-core/src/agent_service.rs

@@ -184,9 +184,13 @@ pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) ->
     agent_catalog::driver_store_entries()
         .map(|(key, label)| {
             let installed = am.is_driver_installed(key);
-            let requires_java_runtime = am.driver_requires_java_runtime(key);
             let local = local_state.installed_drivers.get(key);
             let remote = registry.and_then(|r| agent_registry_driver(r, key));
+            let requires_java_runtime = if installed {
+                am.driver_requires_java_runtime(key)
+            } else {
+                remote.is_some_and(|driver| driver.native.get(AgentManager::current_platform()).is_none())
+            };
             let jre_key = remote
                 .map(|r| r.jre.clone())
                 .or_else(|| local.map(|l| l.jre.clone()))
@@ -209,6 +213,7 @@ pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) ->
                     (Some(l), Some(r)) => l.version != r.version || jre_update_available,
                     _ => false,
                 },
+                requires_java_runtime,
                 jre: jre_key.clone(),
                 jre_installed: !installed || !requires_java_runtime || am.is_jre_installed(&jre_key),
             }

crates/dbx-core/tests/agent_service.rs

@@ -37,6 +37,30 @@ fn registry_with_jre_driver(db_type: &str, driver_version: &str, jre: &str, jre_
     registry
 }
 
+fn registry_with_native_driver(db_type: &str, version: &str, jre: &str) -> AgentRegistry {
+    let mut drivers = std::collections::HashMap::new();
+    drivers.insert(
+        db_type.to_string(),
+        DriverInfo {
+            version: version.to_string(),
+            label: db_type.to_string(),
+            min_app_version: "0.1.0".to_string(),
+            jre: jre.to_string(),
+            jar: Some(ArtifactInfo {
+                url: format!("https://example.com/dbx-agent-{db_type}-legacy-placeholder.jar"),
+                size: 0,
+            }),
+            native: [(
+                AgentManager::current_platform().to_string(),
+                ArtifactInfo { url: format!("https://example.com/dbx-agent-{db_type}"), size: 42 },
+            )]
+            .into_iter()
+            .collect(),
+        },
+    );
+    AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
+}
+
 #[test]
 fn built_in_agent_list_includes_expected_driver_labels() {
     let manager = test_manager("labels");
@@ -80,6 +104,7 @@ fn agent_list_marks_installed_driver_update_when_registry_version_differs() {
     assert_eq!(h2.version, "0.2.0");
     assert_eq!(h2.size, 42);
     assert_eq!(h2.jre, "21");
+    assert!(h2.requires_java_runtime);
     assert!(h2.update_available);
 }
 
@@ -174,9 +199,55 @@ fn agent_list_does_not_require_jre_for_native_agent() {
     let dameng = agents.iter().find(|agent| agent.db_type == "dameng").unwrap();
 
     assert!(dameng.installed);
+    assert!(!dameng.requires_java_runtime);
     assert!(dameng.jre_installed);
 }
 
+#[test]
+fn agent_list_does_not_require_jre_for_registry_native_agent() {
+    let manager = test_manager("registry-native-no-jre");
+    let registry = registry_with_native_driver("xugu", "0.2.0", DEFAULT_JRE_KEY);
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let xugu = agents.iter().find(|agent| agent.db_type == "xugu").unwrap();
+
+    assert!(!xugu.installed);
+    assert_eq!(xugu.jre, DEFAULT_JRE_KEY);
+    assert!(!xugu.requires_java_runtime);
+    assert!(xugu.jre_installed);
+}
+
+#[test]
+fn agent_list_keeps_jre_requirement_for_installed_jar_when_registry_has_native() {
+    let manager = test_manager("installed-jar-registry-native");
+    let jar_path = manager.driver_jar_path("xugu");
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    std::fs::write(&jar_path, b"jar").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            installed_drivers: [(
+                "xugu".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_native_driver("xugu", "0.2.0", DEFAULT_JRE_KEY);
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let xugu = agents.iter().find(|agent| agent.db_type == "xugu").unwrap();
+
+    assert!(xugu.installed);
+    assert!(xugu.requires_java_runtime);
+    assert!(!xugu.jre_installed);
+}
+
 #[test]
 fn agent_list_uses_legacy_default_jre_version_when_checking_updates() {
     let manager = test_manager("legacy-jre-version");