test(coverage): channels partial push (68.12% → 68.91%)

- channels/controllers/schemas.rs: every registered key resolves, required
  input coverage for describe/send_message/telegram_login_check.
- channels/providers/web.rs: catalog parity, chat/cancel schema required
  inputs, unknown fallback, key_for, event_session_id_for stability,
  normalize_model_override trimming/empty, broadcast channel subscribe,
  field-builder helpers.
- channels/providers/discord/api.rs: auth_header prefix, BotPermissionCheck
  serde with empty/full missing_permissions lists, permission bit flags
  are single-bit and distinct.

Channels remains below the 80% issue target — the bulk of remaining
uncovered code lives in telegram/channel.rs (574 lines), ops.rs (462),
lark.rs (433) and runtime/startup.rs (350), which depend on live HTTP /
socket / runtime bootstrap state that would require extensive mock
infrastructure to exercise from unit tests.

Author: CodeGhost21

src/openhuman/channels/controllers/schemas.rs

@@ -655,4 +655,76 @@ mod tests {
         fns.dedup();
         assert_eq!(fns.len(), len, "duplicate function names found");
     }
+
+    #[test]
+    fn every_known_key_resolves_to_non_unknown_schema() {
+        let keys = [
+            "list",
+            "describe",
+            "connect",
+            "disconnect",
+            "status",
+            "test",
+            "telegram_login_start",
+            "telegram_login_check",
+            "discord_list_guilds",
+            "discord_list_channels",
+            "discord_check_permissions",
+            "send_message",
+            "send_reaction",
+            "create_thread",
+            "update_thread",
+            "list_threads",
+        ];
+        for k in keys {
+            let s = schemas(k);
+            assert_eq!(s.namespace, "channels");
+            assert_ne!(s.function, "unknown", "key `{k}` fell through");
+            assert!(!s.description.is_empty(), "key `{k}` missing description");
+            assert!(!s.outputs.is_empty(), "key `{k}` has no outputs");
+        }
+    }
+
+    #[test]
+    fn unknown_function_returns_unknown_fallback() {
+        let s = schemas("no_such_fn_123");
+        assert_eq!(s.function, "unknown");
+        assert_eq!(s.namespace, "channels");
+    }
+
+    #[test]
+    fn describe_schema_requires_channel() {
+        let s = schemas("describe");
+        let chan = s.inputs.iter().find(|f| f.name == "channel");
+        assert!(chan.is_some_and(|f| f.required));
+    }
+
+    #[test]
+    fn send_message_requires_channel_and_message() {
+        let s = schemas("send_message");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"channel"));
+        // The rich-message body is carried in `message` (JSON).
+        assert!(required.contains(&"message"));
+    }
+
+    #[test]
+    fn telegram_login_check_requires_session_id_or_token() {
+        let s = schemas("telegram_login_check");
+        // Should have at least one required input
+        assert!(s.inputs.iter().any(|f| f.required));
+    }
+
+    #[test]
+    fn discord_list_guilds_schema_may_have_no_required_inputs() {
+        let s = schemas("discord_list_guilds");
+        // Either no inputs or all-optional inputs are acceptable — but the
+        // schema must still exist with outputs.
+        assert!(!s.outputs.is_empty());
+    }
 }

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

@@ -340,4 +340,69 @@ mod tests {
         assert_eq!(SEND_MESSAGES, 2048);
         assert_eq!(READ_MESSAGE_HISTORY, 65536);
     }
+
+    #[test]
+    fn auth_header_has_bot_prefix() {
+        assert_eq!(auth_header("abc"), "Bot abc");
+        assert_eq!(auth_header(""), "Bot ");
+    }
+
+    #[test]
+    fn permission_check_lists_all_missing_permissions_when_bot_lacks_any() {
+        let check = BotPermissionCheck {
+            can_view_channel: false,
+            can_send_messages: false,
+            can_read_message_history: false,
+            missing_permissions: vec![
+                "VIEW_CHANNEL".into(),
+                "SEND_MESSAGES".into(),
+                "READ_MESSAGE_HISTORY".into(),
+            ],
+        };
+        let json = serde_json::to_string(&check).unwrap();
+        assert!(json.contains("VIEW_CHANNEL"));
+        assert!(json.contains("SEND_MESSAGES"));
+        assert!(json.contains("READ_MESSAGE_HISTORY"));
+    }
+
+    #[test]
+    fn permission_check_with_all_granted_has_empty_missing_list() {
+        let check = BotPermissionCheck {
+            can_view_channel: true,
+            can_send_messages: true,
+            can_read_message_history: true,
+            missing_permissions: vec![],
+        };
+        let json = serde_json::to_string(&check).unwrap();
+        assert!(json.contains("\"missing_permissions\":[]"));
+    }
+
+    #[test]
+    fn text_channel_type_zero_is_standard_text() {
+        let json = r#"{"id":"1","name":"general","type":0,"position":0,"parent_id":null}"#;
+        let ch: DiscordTextChannel = serde_json::from_str(json).unwrap();
+        assert_eq!(ch.channel_type, 0);
+    }
+
+    #[test]
+    fn guild_deserializes_with_full_payload() {
+        let json = r#"{
+            "id": "999",
+            "name": "Full Guild",
+            "icon": "hash"
+        }"#;
+        let g: DiscordGuild = serde_json::from_str(json).unwrap();
+        assert_eq!(g.id, "999");
+        assert_eq!(g.name, "Full Guild");
+    }
+
+    #[test]
+    fn permission_bit_flags_are_disjoint() {
+        // Sanity: each permission is a single bit and distinct.
+        assert_eq!(VIEW_CHANNEL.count_ones(), 1);
+        assert_eq!(SEND_MESSAGES.count_ones(), 1);
+        assert_eq!(READ_MESSAGE_HISTORY.count_ones(), 1);
+        assert_ne!(VIEW_CHANNEL, SEND_MESSAGES);
+        assert_ne!(SEND_MESSAGES, READ_MESSAGE_HISTORY);
+    }
 }

src/openhuman/channels/providers/web.rs

@@ -696,7 +696,12 @@ fn to_json<T: serde::Serialize>(outcome: RpcOutcome<T>) -> Result<Value, String>
 
 #[cfg(test)]
 mod tests {
-    use super::{cancel_chat, start_chat};
+    use super::{
+        all_web_channel_controller_schemas, all_web_channel_registered_controllers, cancel_chat,
+        event_session_id_for, json_output, key_for, normalize_model_override, optional_f64,
+        optional_string, required_string, schemas, start_chat, subscribe_web_channel_events,
+    };
+    use crate::core::TypeSchema;
 
     #[tokio::test]
     async fn start_chat_validates_required_fields() {
@@ -728,4 +733,131 @@ mod tests {
             .expect_err("thread id should be required");
         assert!(err.contains("thread_id is required"));
     }
+
+    // ── Schema catalog ────────────────────────────────────────────
+
+    #[test]
+    fn web_channel_catalog_has_chat_and_cancel() {
+        let s = all_web_channel_controller_schemas();
+        let c = all_web_channel_registered_controllers();
+        assert_eq!(s.len(), c.len());
+        assert_eq!(s.len(), 2);
+        let fns: Vec<&str> = s.iter().map(|x| x.function).collect();
+        assert!(fns.contains(&"web_chat"));
+        assert!(fns.contains(&"web_cancel"));
+    }
+
+    #[test]
+    fn chat_schema_requires_client_thread_message() {
+        let s = schemas("chat");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert!(required.contains(&"client_id"));
+        assert!(required.contains(&"thread_id"));
+        assert!(required.contains(&"message"));
+        // model_override and temperature must be optional.
+        assert!(s
+            .inputs
+            .iter()
+            .any(|f| f.name == "model_override" && !f.required));
+        assert!(s
+            .inputs
+            .iter()
+            .any(|f| f.name == "temperature" && !f.required));
+    }
+
+    #[test]
+    fn cancel_schema_requires_client_and_thread() {
+        let s = schemas("cancel");
+        let required: Vec<&str> = s
+            .inputs
+            .iter()
+            .filter(|f| f.required)
+            .map(|f| f.name)
+            .collect();
+        assert_eq!(required, vec!["client_id", "thread_id"]);
+    }
+
+    #[test]
+    fn unknown_schema_returns_unknown_fallback() {
+        let s = schemas("no_such_fn");
+        assert_eq!(s.function, "unknown");
+        assert_eq!(s.namespace, "channel");
+        assert_eq!(s.outputs.len(), 1);
+        assert_eq!(s.outputs[0].name, "error");
+    }
+
+    // ── Helpers ───────────────────────────────────────────────────
+
+    #[test]
+    fn key_for_combines_client_id_and_thread_id() {
+        assert_eq!(key_for("c1", "t1"), "c1::t1");
+        assert_eq!(key_for("", ""), "::");
+    }
+
+    #[test]
+    fn event_session_id_for_is_stable() {
+        // Two calls with the same args must produce the same id.
+        let a = event_session_id_for("c1", "t1");
+        let b = event_session_id_for("c1", "t1");
+        assert_eq!(a, b);
+        // Different args → different id.
+        let c = event_session_id_for("c2", "t1");
+        assert_ne!(a, c);
+    }
+
+    #[test]
+    fn normalize_model_override_returns_none_for_empty_or_whitespace() {
+        assert!(normalize_model_override(None).is_none());
+        assert!(normalize_model_override(Some("".into())).is_none());
+        assert!(normalize_model_override(Some("   ".into())).is_none());
+    }
+
+    #[test]
+    fn normalize_model_override_trims_value() {
+        assert_eq!(
+            normalize_model_override(Some("  gpt-4  ".into())),
+            Some("gpt-4".to_string())
+        );
+    }
+
+    // ── Broadcast events ──────────────────────────────────────────
+
+    #[test]
+    fn subscribe_web_channel_events_returns_receiver() {
+        // Just confirm we can subscribe without panic.
+        let _rx = subscribe_web_channel_events();
+    }
+
+    // ── Field builder helpers ─────────────────────────────────────
+
+    #[test]
+    fn required_string_marks_field_required() {
+        let f = required_string("client_id", "c");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::String));
+    }
+
+    #[test]
+    fn optional_string_marks_field_optional() {
+        let f = optional_string("model", "c");
+        assert!(!f.required);
+    }
+
+    #[test]
+    fn optional_f64_marks_field_optional() {
+        let f = optional_f64("temperature", "c");
+        assert!(!f.required);
+    }
+
+    #[test]
+    fn json_output_is_required_json_field() {
+        let f = json_output("ack", "c");
+        assert!(f.required);
+        assert!(matches!(f.ty, TypeSchema::Json));
+    }
 }