test(coverage): push all 4 remaining modules

- discord/api.rs: list_bot_guilds_at_base/list_guild_channels_at_base test
  seams with mock axum server; parse happy-path, error status, channel
  filter+sort, empty list.
- channels/controllers/ops.rs: parse_allowed_users for string CSV/array/
  newline/@-prefix/case-insensitive dedup/non-string; credential_provider;
  list_channels/describe_channel; connect_channel unknown-channel and
  non-object credentials.
- local_ai/ollama_api.rs: `ollama_base_url()` honours OPENHUMAN_OLLAMA_BASE_URL
  env var so tests can point at mock servers; DEFAULT_OLLAMA_BASE_URL
  preserved.
- local_ai/service/public_infer.rs: mock-backend tests for inference/prompt
  happy path, non-success status, suggest_questions parsing, disabled-
  local-ai short-circuits for summarize/prompt/suggest_questions/
  inline_complete.
- voice/schemas.rs: overlay_notify cancelled→released, unknown state
  errors, missing state errors, server_start handler, TranscribeParams +
  TtsParams deserialize happy/error paths, server_start all-optional
  invariant, description completeness.

Author: CodeGhost21

src/openhuman/channels/controllers/ops.rs

@@ -822,4 +822,127 @@ mod tests {
         .await;
         assert!(err.is_err());
     }
+
+    // ── parse_allowed_users / credential_provider ─────────────────
+
+    #[test]
+    fn parse_allowed_users_handles_string_csv() {
+        let v = serde_json::json!("alice,bob,@carol");
+        let out = parse_allowed_users(Some(&v));
+        assert_eq!(out, vec!["alice", "bob", "carol"]);
+    }
+
+    #[test]
+    fn parse_allowed_users_handles_newline_separated_string() {
+        let v = serde_json::json!("alice\nbob\r\ncarol");
+        let out = parse_allowed_users(Some(&v));
+        assert_eq!(out, vec!["alice", "bob", "carol"]);
+    }
+
+    #[test]
+    fn parse_allowed_users_dedups_case_insensitively() {
+        let v = serde_json::json!("Alice,ALICE,alice,@Alice");
+        let out = parse_allowed_users(Some(&v));
+        assert_eq!(out, vec!["alice"]);
+    }
+
+    #[test]
+    fn parse_allowed_users_normalises_at_prefix_and_whitespace() {
+        let v = serde_json::json!("  @Alice  ");
+        let out = parse_allowed_users(Some(&v));
+        assert_eq!(out, vec!["alice"]);
+    }
+
+    #[test]
+    fn parse_allowed_users_rejects_empty_and_at_only() {
+        let v = serde_json::json!(",  ,@,@ ,@@@, ,");
+        let out = parse_allowed_users(Some(&v));
+        // "@@@" trims to "@" then strips one '@' leaving "@@" which is non-empty
+        // — the canonical value should still survive once. Just ensure
+        // pure whitespace / empty tokens are dropped.
+        assert!(!out.contains(&"".to_string()));
+        assert!(!out.contains(&"@".to_string()));
+    }
+
+    #[test]
+    fn parse_allowed_users_accepts_array_of_strings() {
+        let v = serde_json::json!(["a", "b,c", "@d\ne"]);
+        let out = parse_allowed_users(Some(&v));
+        for expected in ["a", "b", "c", "d", "e"] {
+            assert!(
+                out.contains(&expected.to_string()),
+                "missing `{expected}` in {out:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn parse_allowed_users_returns_empty_for_none_or_non_string_value() {
+        assert!(parse_allowed_users(None).is_empty());
+        assert!(parse_allowed_users(Some(&serde_json::json!(42))).is_empty());
+        assert!(parse_allowed_users(Some(&serde_json::json!({}))).is_empty());
+        assert!(parse_allowed_users(Some(&serde_json::Value::Null)).is_empty());
+    }
+
+    #[test]
+    fn credential_provider_combines_channel_id_and_mode() {
+        let out = credential_provider("telegram", ChannelAuthMode::BotToken);
+        assert!(out.starts_with("channel:telegram:"));
+        let out = credential_provider("discord", ChannelAuthMode::OAuth);
+        assert!(out.starts_with("channel:discord:"));
+    }
+
+    // ── describe_channel / list_channels ───────────────────────────
+
+    #[tokio::test]
+    async fn list_channels_returns_nonempty_catalog() {
+        let out = list_channels().await.unwrap();
+        assert!(!out.value.is_empty());
+        let slugs: Vec<&str> = out.value.iter().map(|d| d.id).collect();
+        assert!(slugs.contains(&"telegram"));
+    }
+
+    #[tokio::test]
+    async fn describe_channel_returns_known_channel() {
+        let out = describe_channel("telegram").await.unwrap();
+        assert_eq!(out.value.id, "telegram");
+    }
+
+    #[tokio::test]
+    async fn describe_channel_errors_for_unknown_channel() {
+        let err = describe_channel("__definitely_unknown__")
+            .await
+            .unwrap_err();
+        assert!(err.contains("unknown channel"));
+    }
+
+    // ── connect_channel validation ─────────────────────────────────
+
+    #[tokio::test]
+    async fn connect_channel_errors_for_unknown_channel() {
+        let config = Config::default();
+        let err = connect_channel(
+            &config,
+            "__unknown__",
+            ChannelAuthMode::BotToken,
+            serde_json::json!({}),
+        )
+        .await
+        .unwrap_err();
+        assert!(err.contains("unknown channel"));
+    }
+
+    #[tokio::test]
+    async fn connect_channel_rejects_non_object_credentials_for_credential_modes() {
+        let config = Config::default();
+        let err = connect_channel(
+            &config,
+            "telegram",
+            ChannelAuthMode::BotToken,
+            serde_json::json!("not an object"),
+        )
+        .await
+        .unwrap_err();
+        assert!(err.contains("credentials must be a JSON object"));
+    }
 }

src/openhuman/channels/providers/discord/api.rs

@@ -50,7 +50,14 @@ fn auth_header(token: &str) -> String {
 
 /// List all guilds (servers) the bot is a member of.
 pub async fn list_bot_guilds(token: &str) -> anyhow::Result<Vec<DiscordGuild>> {
-    let url = format!("{DISCORD_API_BASE}/users/@me/guilds");
+    list_bot_guilds_at_base(DISCORD_API_BASE, token).await
+}
+
+/// Test seam: list guilds against an arbitrary API base. Used by
+/// `list_bot_guilds` in production and by unit tests that drive a
+/// local mock Discord API.
+async fn list_bot_guilds_at_base(base: &str, token: &str) -> anyhow::Result<Vec<DiscordGuild>> {
+    let url = format!("{base}/users/@me/guilds");
     tracing::debug!("[discord-api] listing guilds for bot");
 
     let resp = build_client()
@@ -75,7 +82,16 @@ pub async fn list_guild_channels(
     token: &str,
     guild_id: &str,
 ) -> anyhow::Result<Vec<DiscordTextChannel>> {
-    let url = format!("{DISCORD_API_BASE}/guilds/{guild_id}/channels");
+    list_guild_channels_at_base(DISCORD_API_BASE, token, guild_id).await
+}
+
+/// Test seam: list guild channels against an arbitrary API base.
+async fn list_guild_channels_at_base(
+    base: &str,
+    token: &str,
+    guild_id: &str,
+) -> anyhow::Result<Vec<DiscordTextChannel>> {
+    let url = format!("{base}/guilds/{guild_id}/channels");
     tracing::debug!("[discord-api] listing channels for guild {guild_id}");
 
     let resp = build_client()
@@ -405,4 +421,98 @@ mod tests {
         assert_ne!(VIEW_CHANNEL, SEND_MESSAGES);
         assert_ne!(SEND_MESSAGES, READ_MESSAGE_HISTORY);
     }
+
+    // ── Mock Discord server integration tests ──────────────────────
+
+    use axum::{extract::Path, http::StatusCode, routing::get, Json, Router};
+    use serde_json::json;
+
+    async fn spawn_mock(app: Router) -> String {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
+        format!("http://127.0.0.1:{}", addr.port())
+    }
+
+    #[tokio::test]
+    async fn list_bot_guilds_parses_discord_response() {
+        let app = Router::new().route(
+            "/users/@me/guilds",
+            get(|| async {
+                Json(json!([
+                    {"id": "g1", "name": "Guild One", "icon": "hash1"},
+                    {"id": "g2", "name": "Guild Two", "icon": null}
+                ]))
+            }),
+        );
+        let base = spawn_mock(app).await;
+        let guilds = list_bot_guilds_at_base(&base, "test-token").await.unwrap();
+        assert_eq!(guilds.len(), 2);
+        assert_eq!(guilds[0].id, "g1");
+        assert_eq!(guilds[0].name, "Guild One");
+        assert_eq!(guilds[1].icon, None);
+    }
+
+    #[tokio::test]
+    async fn list_bot_guilds_errors_on_non_success_status() {
+        let app = Router::new().route(
+            "/users/@me/guilds",
+            get(|| async { (StatusCode::UNAUTHORIZED, "bad token") }),
+        );
+        let base = spawn_mock(app).await;
+        let err = list_bot_guilds_at_base(&base, "t")
+            .await
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("list guilds failed"));
+        assert!(err.contains("401"));
+    }
+
+    #[tokio::test]
+    async fn list_guild_channels_filters_text_channels_and_sorts_by_position() {
+        let app = Router::new().route(
+            "/guilds/{guild_id}/channels",
+            get(|Path(guild_id): Path<String>| async move {
+                assert_eq!(guild_id, "g1");
+                Json(json!([
+                    {"id": "c3", "name": "category", "type": 4, "position": 0, "parent_id": null},
+                    {"id": "c1", "name": "general", "type": 0, "position": 2, "parent_id": null},
+                    {"id": "c2", "name": "random", "type": 0, "position": 1, "parent_id": null},
+                    {"id": "c4", "name": "voice", "type": 2, "position": 3, "parent_id": null}
+                ]))
+            }),
+        );
+        let base = spawn_mock(app).await;
+        let channels = list_guild_channels_at_base(&base, "t", "g1").await.unwrap();
+        // Only text channels (type=0) remain, sorted by position ascending.
+        assert_eq!(channels.len(), 2);
+        assert_eq!(channels[0].id, "c2");
+        assert_eq!(channels[1].id, "c1");
+    }
+
+    #[tokio::test]
+    async fn list_guild_channels_errors_on_non_success_status() {
+        let app = Router::new().route(
+            "/guilds/{guild_id}/channels",
+            get(|| async { (StatusCode::FORBIDDEN, "nope") }),
+        );
+        let base = spawn_mock(app).await;
+        let err = list_guild_channels_at_base(&base, "t", "g1")
+            .await
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("list channels failed"));
+        assert!(err.contains("403"));
+    }
+
+    #[tokio::test]
+    async fn list_guild_channels_empty_returns_empty_vec() {
+        let app = Router::new().route(
+            "/guilds/{guild_id}/channels",
+            get(|| async { Json(json!([])) }),
+        );
+        let base = spawn_mock(app).await;
+        let channels = list_guild_channels_at_base(&base, "t", "g").await.unwrap();
+        assert!(channels.is_empty());
+    }
 }

src/openhuman/local_ai/ollama_api.rs

@@ -2,7 +2,23 @@
 
 use serde::{Deserialize, Serialize};
 
-pub(crate) const OLLAMA_BASE_URL: &str = "http://localhost:11434";
+pub(crate) const DEFAULT_OLLAMA_BASE_URL: &str = "http://localhost:11434";
+
+/// Returns the effective Ollama base URL, honouring the
+/// `OPENHUMAN_OLLAMA_BASE_URL` env override so tests can point it at
+/// a local mock server. In production builds this is always
+/// [`DEFAULT_OLLAMA_BASE_URL`] unless an operator has deliberately
+/// pointed the sidecar at a remote Ollama.
+pub(crate) fn ollama_base_url() -> String {
+    match std::env::var("OPENHUMAN_OLLAMA_BASE_URL") {
+        Ok(url) if !url.trim().is_empty() => url.trim().trim_end_matches('/').to_string(),
+        _ => DEFAULT_OLLAMA_BASE_URL.to_string(),
+    }
+}
+
+/// Back-compat constant kept at its original value for callers that
+/// reference it directly. New callers should use [`ollama_base_url`].
+pub(crate) const OLLAMA_BASE_URL: &str = DEFAULT_OLLAMA_BASE_URL;
 
 #[derive(Debug, Serialize)]
 pub(crate) struct OllamaPullRequest {