test(coverage): more local_ai + voice gains

- local_ai/ollama_admin: diagnostics against mock Ollama (unreachable +
  missing models + all models present), list_models happy/error paths.
- voice/dictation_listener: start_if_enabled early-returns for disabled/
  empty-hotkey/unparseable-hotkey; normalize_hotkey_for_rdev coverage
  for Shift+Alt, lowercase, function keys, whitespace trimming.

Author: CodeGhost21

src/openhuman/local_ai/service/ollama_admin.rs

@@ -668,7 +668,7 @@ impl LocalAiService {
     async fn list_models(&self) -> Result<Vec<OllamaModelTag>, String> {
         let response = self
             .http
-            .get(format!("{OLLAMA_BASE_URL}/api/tags"))
+            .get(format!("{}/api/tags", ollama_base_url()))
             .timeout(std::time::Duration::from_secs(5))
             .send()
             .await
@@ -936,4 +936,147 @@ mod tests {
             std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
         }
     }
+
+    #[tokio::test]
+    async fn diagnostics_reports_server_unreachable_when_url_unbound() {
+        let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
+            .lock()
+            .expect("local ai mutex");
+
+        unsafe {
+            std::env::set_var("OPENHUMAN_OLLAMA_BASE_URL", "http://127.0.0.1:1");
+        }
+        let config = Config::default();
+        let service = LocalAiService::new(&config);
+        let diag = service.diagnostics(&config).await.expect("diagnostics");
+        assert_eq!(diag["ollama_running"], false);
+        let issues = diag["issues"].as_array().cloned().unwrap_or_default();
+        assert!(
+            !issues.is_empty(),
+            "unreachable server must surface an issue"
+        );
+        assert!(issues
+            .iter()
+            .any(|v| v.as_str().unwrap_or("").contains("not running")));
+        unsafe {
+            std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
+        }
+    }
+
+    #[tokio::test]
+    async fn diagnostics_with_running_server_but_missing_models_flags_issues() {
+        let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
+            .lock()
+            .expect("local ai mutex");
+
+        let app = Router::new().route("/api/tags", get(|| async { Json(json!({ "models": [] })) }));
+        let base = spawn_mock(app).await;
+        unsafe {
+            std::env::set_var("OPENHUMAN_OLLAMA_BASE_URL", &base);
+        }
+
+        let config = Config::default();
+        let service = LocalAiService::new(&config);
+        let diag = service.diagnostics(&config).await.expect("diagnostics");
+        assert_eq!(diag["ollama_running"], true);
+        // No models are installed → expected chat model issue surfaces.
+        let issues = diag["issues"].as_array().cloned().unwrap_or_default();
+        assert!(!issues.is_empty());
+        unsafe {
+            std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
+        }
+    }
+
+    #[tokio::test]
+    async fn diagnostics_ok_when_expected_models_are_present() {
+        let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
+            .lock()
+            .expect("local ai mutex");
+
+        let config = Config::default();
+        let chat = crate::openhuman::local_ai::model_ids::effective_chat_model_id(&config);
+        let chat_tag = format!("{}:latest", chat);
+        let app = Router::new().route(
+            "/api/tags",
+            get(move || {
+                let chat_tag = chat_tag.clone();
+                async move {
+                    Json(json!({
+                        "models": [
+                            { "name": chat_tag, "modified_at": "", "size": 1u64, "digest": "d" }
+                        ]
+                    }))
+                }
+            }),
+        );
+        let base = spawn_mock(app).await;
+        unsafe {
+            std::env::set_var("OPENHUMAN_OLLAMA_BASE_URL", &base);
+        }
+
+        let service = LocalAiService::new(&config);
+        let diag = service.diagnostics(&config).await.expect("diagnostics");
+        assert_eq!(diag["ollama_running"], true);
+        assert_eq!(diag["expected"]["chat_found"], true);
+        unsafe {
+            std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
+        }
+    }
+
+    #[tokio::test]
+    async fn list_models_returns_parsed_payload() {
+        let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
+            .lock()
+            .expect("local ai mutex");
+
+        let app = Router::new().route(
+            "/api/tags",
+            get(|| async {
+                Json(json!({
+                    "models": [
+                        { "name": "a:latest", "modified_at": "t", "size": 1u64, "digest": "d1" },
+                        { "name": "b:v2", "modified_at": "t", "size": 2u64, "digest": "d2" }
+                    ]
+                }))
+            }),
+        );
+        let base = spawn_mock(app).await;
+        unsafe {
+            std::env::set_var("OPENHUMAN_OLLAMA_BASE_URL", &base);
+        }
+
+        let config = Config::default();
+        let service = LocalAiService::new(&config);
+        let models = service.list_models().await.expect("list_models");
+        assert_eq!(models.len(), 2);
+        assert_eq!(models[0].name, "a:latest");
+        assert_eq!(models[1].name, "b:v2");
+        unsafe {
+            std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
+        }
+    }
+
+    #[tokio::test]
+    async fn list_models_errors_on_non_success() {
+        let _guard = crate::openhuman::local_ai::LOCAL_AI_TEST_MUTEX
+            .lock()
+            .expect("local ai mutex");
+
+        let app = Router::new().route(
+            "/api/tags",
+            get(|| async { (axum::http::StatusCode::SERVICE_UNAVAILABLE, "down") }),
+        );
+        let base = spawn_mock(app).await;
+        unsafe {
+            std::env::set_var("OPENHUMAN_OLLAMA_BASE_URL", &base);
+        }
+
+        let config = Config::default();
+        let service = LocalAiService::new(&config);
+        let err = service.list_models().await.unwrap_err();
+        assert!(err.contains("503") || err.contains("tags failed"));
+        unsafe {
+            std::env::remove_var("OPENHUMAN_OLLAMA_BASE_URL");
+        }
+    }
 }

src/openhuman/voice/dictation_listener.rs

@@ -257,4 +257,52 @@ mod tests {
         assert_eq!(json["hotkey"], "fn");
         assert_eq!(json["activation_mode"], "push");
     }
+
+    #[tokio::test]
+    async fn start_if_enabled_returns_early_when_config_disabled() {
+        // Fast path — `enabled=false` → the fn returns without spawning.
+        let mut config = Config::default();
+        config.dictation.enabled = false;
+        start_if_enabled(&config).await;
+        // No panic = pass. The absence of a spawned hotkey task is what
+        // we're verifying; hard to assert directly without internals.
+    }
+
+    #[tokio::test]
+    async fn start_if_enabled_returns_early_when_hotkey_empty() {
+        let mut config = Config::default();
+        config.dictation.enabled = true;
+        config.dictation.hotkey = String::new();
+        start_if_enabled(&config).await;
+    }
+
+    #[tokio::test]
+    async fn start_if_enabled_returns_early_when_hotkey_unparseable() {
+        let mut config = Config::default();
+        config.dictation.enabled = true;
+        config.dictation.hotkey = "not a real hotkey".into();
+        start_if_enabled(&config).await;
+    }
+
+    #[test]
+    fn normalize_maps_shift_and_alt_verbatim() {
+        let result = normalize_hotkey_for_rdev("Shift+Alt+D");
+        assert_eq!(result, "shift+alt+d");
+    }
+
+    #[test]
+    fn normalize_handles_lowercase_input() {
+        assert_eq!(normalize_hotkey_for_rdev("cmd+d"), "cmd+d");
+    }
+
+    #[test]
+    fn normalize_preserves_function_keys() {
+        assert_eq!(normalize_hotkey_for_rdev("F12"), "f12");
+    }
+
+    #[test]
+    fn normalize_trims_whitespace_between_segments() {
+        let result = normalize_hotkey_for_rdev("  cmd  + shift  +  d  ");
+        assert_eq!(result, "cmd+shift+d");
+    }
 }