diff --git a/clawpal-core/src/backup.rs b/clawpal-core/src/backup.rs
index 453f90fb..05808b20 100644
--- a/clawpal-core/src/backup.rs
+++ b/clawpal-core/src/backup.rs
@@ -85,4 +85,56 @@ mod tests {
         let out = parse_upgrade_result("openclaw 0.2.0\nfoo\nopenclaw 0.3.1");
         assert_eq!(out.detected_versions, vec!["0.2.0", "0.3.1"]);
     }
+
+    #[test]
+    fn parse_backup_list_empty_input() {
+        let out = parse_backup_list("");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_backup_list_strips_trailing_slash() {
+        let out = parse_backup_list("50\t/home/user/backup/\n");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].path, "/home/user/backup");
+        assert_eq!(out[0].size_bytes, 50 * 1024);
+    }
+
+    #[test]
+    fn parse_backup_list_skips_malformed_lines() {
+        let out = parse_backup_list("no tab here\n10\t/valid\n");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].path, "/valid");
+    }
+
+    #[test]
+    fn parse_backup_result_empty_input() {
+        let out = parse_backup_result("");
+        assert_eq!(out.size_bytes, 0);
+    }
+
+    #[test]
+    fn parse_backup_result_non_numeric_last_line() {
+        let out = parse_backup_result("done\ncomplete\n");
+        assert_eq!(out.size_bytes, 0);
+    }
+
+    #[test]
+    fn parse_upgrade_result_no_versions() {
+        let out = parse_upgrade_result("nothing relevant here");
+        assert!(out.detected_versions.is_empty());
+    }
+
+    #[test]
+    fn parse_upgrade_result_deduplicates() {
+        let out = parse_upgrade_result("openclaw 1.0.0\nupgraded\nopenclaw 1.0.0\nopenclaw 1.1.0");
+        assert_eq!(out.detected_versions, vec!["1.0.0", "1.1.0"]);
+    }
+
+    #[test]
+    fn parse_backup_list_zero_size() {
+        let out = parse_backup_list("0\t/empty/dir\n");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].size_bytes, 0);
+    }
 }
diff --git a/clawpal-core/src/config.rs b/clawpal-core/src/config.rs
index 8e0cbb0b..5cad6580 100644
--- a/clawpal-core/src/config.rs
+++ b/clawpal-core/src/config.rs
@@ -845,4 +845,385 @@ mod tests {
         let bindings = candidate["bindings"].as_array().expect("bindings");
         assert!(bindings.iter().any(|b| b["agentId"] == "main"));
     }
+
+    // --- Template patch coverage ---
+
+    #[test]
+    fn build_candidate_set_global_model() {
+        let current = json!({"agents":{"defaults":{}}});
+        let mut params = serde_json::Map::new();
+        params.insert("model".into(), json!("anthropic/claude-opus-4-5"));
+        let (candidate, changes) =
+            build_candidate_config(&current, "set-global-model", &params).expect("build");
+        assert_eq!(
+            candidate
+                .pointer("/agents/defaults/model")
+                .and_then(Value::as_str),
+            Some("anthropic/claude-opus-4-5")
+        );
+        assert!(!changes.is_empty());
+    }
+
+    #[test]
+    fn build_candidate_set_agent_model() {
+        // set-agent-model uses dot-path agents.list.{agentId}.model (object-style list)
+        let current = json!({"agents":{"list":{"main":{}}}});
+        let mut params = serde_json::Map::new();
+        params.insert("agentId".into(), json!("main"));
+        params.insert("model".into(), json!("openai/gpt-4o"));
+        let (candidate, _) =
+            build_candidate_config(&current, "set-agent-model", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/agents/list/main/model"),
+            Some(&json!("openai/gpt-4o"))
+        );
+    }
+
+    #[test]
+    fn build_candidate_enable_channel() {
+        let current = json!({"channels":{"discord":{"enabled":false}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.discord"));
+        let (candidate, _) =
+            build_candidate_config(&current, "enable-channel", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/channels/discord/enabled"),
+            Some(&json!(true))
+        );
+    }
+
+    #[test]
+    fn build_candidate_disable_channel() {
+        let current = json!({"channels":{"telegram":{"enabled":true}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.telegram"));
+        let (candidate, _) =
+            build_candidate_config(&current, "disable-channel", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/channels/telegram/enabled"),
+            Some(&json!(false))
+        );
+    }
+
+    #[test]
+    fn build_candidate_delete_channel() {
+        let current = json!({"channels":{"discord":{"token":"x"},"telegram":{"token":"y"}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.discord"));
+        let (candidate, _) =
+            build_candidate_config(&current, "delete-channel", &params).expect("build");
+        assert!(candidate.pointer("/channels/discord").is_none());
+        assert!(candidate.pointer("/channels/telegram").is_some());
+    }
+
+    #[test]
+    fn build_candidate_set_channel_model() {
+        let current = json!({"channels":{"discord":{}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.discord"));
+        params.insert("model".into(), json!("test/model"));
+        let (candidate, _) =
+            build_candidate_config(&current, "set-channel-model", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/channels/discord/model"),
+            Some(&json!("test/model"))
+        );
+    }
+
+    #[test]
+    fn build_candidate_set_channel_model_remove() {
+        let current = json!({"channels":{"discord":{"model":"old"}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.discord"));
+        // No model param → delete
+        let (candidate, _) =
+            build_candidate_config(&current, "set-channel-model", &params).expect("build");
+        assert!(candidate.pointer("/channels/discord/model").is_none());
+    }
+
+    #[test]
+    fn build_candidate_update_channel_config() {
+        let current = json!({"channels":{"discord":{}}});
+        let mut params = serde_json::Map::new();
+        params.insert("channelPath".into(), json!("channels.discord"));
+        params.insert("type".into(), json!("discord"));
+        params.insert("mode".into(), json!("allowlist"));
+        params.insert("model".into(), json!("test/model"));
+        params.insert("allowlist".into(), json!(["user1", "user2"]));
+        let (candidate, _) =
+            build_candidate_config(&current, "update-channel-config", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/channels/discord/type"),
+            Some(&json!("discord"))
+        );
+        assert_eq!(
+            candidate.pointer("/channels/discord/mode"),
+            Some(&json!("allowlist"))
+        );
+    }
+
+    #[test]
+    fn build_candidate_set_binding_agent() {
+        let current = json!({"bindings":[{"channel":"discord","agentId":"old"}]});
+        let mut params = serde_json::Map::new();
+        params.insert("index".into(), json!(0_u64));
+        params.insert("agentId".into(), json!("new-agent"));
+        let (candidate, _) =
+            build_candidate_config(&current, "set-binding-agent", &params).expect("build");
+        assert_eq!(
+            candidate.pointer("/bindings/0/agentId"),
+            Some(&json!("new-agent"))
+        );
+    }
+
+    #[test]
+    fn build_candidate_add_binding() {
+        let current = json!({"bindings":[]});
+        let mut params = serde_json::Map::new();
+        params.insert("channel".into(), json!("telegram"));
+        params.insert("agentId".into(), json!("main"));
+        params.insert("pattern".into(), json!("*"));
+        let (candidate, _) =
+            build_candidate_config(&current, "add-binding", &params).expect("build");
+        let bindings = candidate["bindings"].as_array().expect("bindings");
+        assert_eq!(bindings.len(), 1);
+        assert_eq!(bindings[0]["channel"], "telegram");
+        assert_eq!(bindings[0]["pattern"], "*");
+    }
+
+    #[test]
+    fn build_candidate_add_binding_creates_array() {
+        let current = json!({});
+        let mut params = serde_json::Map::new();
+        params.insert("channel".into(), json!("discord"));
+        params.insert("agentId".into(), json!("main"));
+        let (candidate, _) =
+            build_candidate_config(&current, "add-binding", &params).expect("build");
+        assert!(candidate["bindings"].is_array());
+    }
+
+    #[test]
+    fn build_candidate_unknown_template_errors() {
+        let current = json!({});
+        let params = serde_json::Map::new();
+        let result = build_candidate_config(&current, "nonexistent-template", &params);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("unknown patch template"));
+    }
+
+    // --- read_model_value ---
+
+    #[test]
+    fn read_model_value_string() {
+        assert_eq!(
+            read_model_value(&json!("anthropic/claude-3")),
+            Some("anthropic/claude-3".to_string())
+        );
+    }
+
+    #[test]
+    fn read_model_value_object_primary() {
+        assert_eq!(
+            read_model_value(&json!({"primary": "gpt-4o"})),
+            Some("gpt-4o".to_string())
+        );
+    }
+
+    #[test]
+    fn read_model_value_object_name() {
+        assert_eq!(
+            read_model_value(&json!({"name": "claude-3"})),
+            Some("claude-3".to_string())
+        );
+    }
+
+    #[test]
+    fn read_model_value_object_provider_id() {
+        assert_eq!(
+            read_model_value(&json!({"provider": "openai", "id": "gpt-4o"})),
+            Some("openai/gpt-4o".to_string())
+        );
+    }
+
+    #[test]
+    fn read_model_value_object_default_field() {
+        assert_eq!(
+            read_model_value(&json!({"default": "fallback-model"})),
+            Some("fallback-model".to_string())
+        );
+    }
+
+    #[test]
+    fn read_model_value_null_returns_none() {
+        assert_eq!(read_model_value(&json!(null)), None);
+    }
+
+    #[test]
+    fn read_model_value_number_returns_none() {
+        assert_eq!(read_model_value(&json!(42)), None);
+    }
+
+    // --- collect_change_paths ---
+
+    #[test]
+    fn collect_change_paths_no_changes() {
+        let a = json!({"x":1,"y":"two"});
+        let changes = collect_change_paths(&a, &a);
+        assert!(changes.is_empty());
+    }
+
+    #[test]
+    fn collect_change_paths_added_key() {
+        let before = json!({"a":1});
+        let after = json!({"a":1,"b":2});
+        let changes = collect_change_paths(&before, &after);
+        assert!(changes.contains(&"b".to_string()));
+    }
+
+    #[test]
+    fn collect_change_paths_removed_key() {
+        let before = json!({"a":1,"b":2});
+        let after = json!({"a":1});
+        let changes = collect_change_paths(&before, &after);
+        assert!(changes.contains(&"b".to_string()));
+    }
+
+    #[test]
+    fn collect_change_paths_nested_change() {
+        let before = json!({"a":{"b":{"c":1}}});
+        let after = json!({"a":{"b":{"c":2}}});
+        let changes = collect_change_paths(&before, &after);
+        assert!(changes.contains(&"a.b.c".to_string()));
+    }
+
+    #[test]
+    fn collect_change_paths_type_change() {
+        let before = json!({"a":"string"});
+        let after = json!({"a":42});
+        let changes = collect_change_paths(&before, &after);
+        assert!(changes.contains(&"a".to_string()));
+    }
+
+    // --- format_config_diff ---
+
+    #[test]
+    fn format_config_diff_no_changes() {
+        let a = json!({"x":1});
+        assert_eq!(format_config_diff(&a, &a), "No changes");
+    }
+
+    // --- channel node ---
+
+    #[test]
+    fn collect_channel_nodes_detects_dm() {
+        let config = json!({
+            "channels": {
+                "discord": {
+                    "dm": {"mode": "open"}
+                }
+            }
+        });
+        let nodes = collect_channel_nodes(&config);
+        assert!(nodes.iter().any(|n| n.path.ends_with(".dm")));
+    }
+
+    #[test]
+    fn collect_channel_nodes_detects_guild_structure() {
+        let config = json!({
+            "channels": {
+                "discord": {
+                    "guilds": {
+                        "12345": {
+                            "channels": {
+                                "67890": {"model": "test"}
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        let nodes = collect_channel_nodes(&config);
+        let guild_node = nodes.iter().find(|n| n.path.contains("guilds.12345"));
+        assert!(guild_node.is_some());
+    }
+
+    #[test]
+    fn collect_channel_nodes_empty_config() {
+        let nodes = collect_channel_nodes(&json!({}));
+        assert!(nodes.is_empty());
+    }
+
+    #[test]
+    fn resolve_channel_mode_merges_policies() {
+        let mut obj = serde_json::Map::new();
+        obj.insert("mode".into(), json!("allowlist"));
+        obj.insert("dmPolicy".into(), json!("open"));
+        obj.insert("groupPolicy".into(), json!("closed"));
+        let mode = resolve_channel_mode(&obj);
+        let mode_str = mode.unwrap();
+        assert!(mode_str.contains("allowlist"));
+        assert!(mode_str.contains("open"));
+        assert!(mode_str.contains("closed"));
+    }
+
+    #[test]
+    fn collect_channel_allowlist_deduplicates() {
+        let mut obj = serde_json::Map::new();
+        obj.insert("allowlist".into(), json!(["user1", "user2"]));
+        obj.insert("allowFrom".into(), json!(["user2", "user3"]));
+        let list = collect_channel_allowlist(&obj);
+        assert_eq!(list.len(), 3);
+    }
+
+    // --- parse_snapshot_filename edge cases ---
+
+    #[test]
+    fn parse_snapshot_filename_short_filename() {
+        assert!(parse_snapshot_filename("invalid").is_none());
+    }
+
+    #[test]
+    fn parse_snapshot_filename_non_numeric_ts() {
+        assert!(parse_snapshot_filename("abc-source.json").is_none());
+    }
+
+    // --- create_agent with no initial list ---
+
+    #[test]
+    fn build_candidate_create_agent_no_list() {
+        let current = json!({});
+        let mut params = serde_json::Map::new();
+        params.insert("agentId".into(), json!("fresh-agent"));
+        let (candidate, _) =
+            build_candidate_config(&current, "create-agent", &params).expect("build");
+        assert!(candidate.pointer("/agents/list").is_some());
+    }
+
+    // --- extract_model_bindings edge cases ---
+
+    #[test]
+    fn extract_model_bindings_alternate_default_path() {
+        // agents.default.model (instead of agents.defaults.model)
+        let config = json!({"agents":{"default":{"model":"alt-model"}}});
+        let bindings = extract_model_bindings(&config);
+        let global = bindings.iter().find(|b| b.scope == "global").unwrap();
+        assert_eq!(global.model_value.as_deref(), Some("alt-model"));
+    }
+
+    #[test]
+    fn extract_model_bindings_nested_channels() {
+        let config = json!({
+            "channels": {
+                "discord": {
+                    "guilds": {
+                        "123": {"model": "guild-model"}
+                    }
+                }
+            }
+        });
+        let bindings = extract_model_bindings(&config);
+        assert!(bindings
+            .iter()
+            .any(|b| b.scope == "channel" && b.model_value.as_deref() == Some("guild-model")));
+    }
 }
diff --git a/clawpal-core/src/connect.rs b/clawpal-core/src/connect.rs
index 9670236e..8033ab7d 100644
--- a/clawpal-core/src/connect.rs
+++ b/clawpal-core/src/connect.rs
@@ -177,4 +177,103 @@ mod tests {
         let result = connect_ssh(config).await;
         assert!(result.is_err());
     }
+
+    #[tokio::test]
+    async fn connect_docker_returns_error_for_missing_home() {
+        let result = connect_docker("/nonexistent/path/clawpal-test-12345", None, None).await;
+        assert!(result.is_err());
+        let err_msg = result.unwrap_err().to_string();
+        assert!(err_msg.contains("docker home does not exist"));
+    }
+
+    #[tokio::test]
+    async fn connect_local_returns_error_for_missing_home() {
+        let result = connect_local("/nonexistent/path/clawpal-test-12345", None, None).await;
+        assert!(result.is_err());
+        let err_msg = result.unwrap_err().to_string();
+        assert!(err_msg.contains("local home does not exist"));
+    }
+
+    #[tokio::test]
+    async fn connect_docker_uses_explicit_instance_id() {
+        let _guard = crate::test_support::env_lock()
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        let data_dir = std::env::temp_dir().join(format!("clawpal-connect-id-{}", Uuid::new_v4()));
+        let docker_home =
+            std::env::temp_dir().join(format!("clawpal-connect-id-home-{}", Uuid::new_v4()));
+        fs::create_dir_all(&data_dir).expect("create data dir");
+        fs::create_dir_all(&docker_home).expect("create home dir");
+        std::env::set_var("CLAWPAL_DATA_DIR", &data_dir);
+
+        let instance = connect_docker(
+            docker_home.to_str().unwrap(),
+            Some("My Docker"),
+            Some("docker:custom-id"),
+        )
+        .await
+        .expect("connect docker with explicit id");
+        assert_eq!(instance.id, "docker:custom-id");
+        assert_eq!(instance.label, "My Docker");
+    }
+
+    #[tokio::test]
+    async fn connect_local_uses_explicit_instance_id() {
+        let _guard = crate::test_support::env_lock()
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
+        let data_dir = std::env::temp_dir().join(format!("clawpal-local-id-{}", Uuid::new_v4()));
+        let local_home =
+            std::env::temp_dir().join(format!("clawpal-local-id-home-{}", Uuid::new_v4()));
+        fs::create_dir_all(&data_dir).expect("create data dir");
+        fs::create_dir_all(&local_home).expect("create home dir");
+        std::env::set_var("CLAWPAL_DATA_DIR", &data_dir);
+
+        let instance = connect_local(
+            local_home.to_str().unwrap(),
+            Some("My Local"),
+            Some("local:custom-id"),
+        )
+        .await
+        .expect("connect local with explicit id");
+        assert_eq!(instance.id, "local:custom-id");
+        assert_eq!(instance.label, "My Local");
+    }
+
+    #[test]
+    fn slug_from_home_basic() {
+        // Leading dots become hyphens, then leading hyphens are trimmed
+        assert_eq!(slug_from_home("/home/user/.openclaw"), "openclaw");
+    }
+
+    #[test]
+    fn slug_from_home_sanitizes_special_chars() {
+        let slug = slug_from_home("/path/to/my dir@123");
+        assert!(!slug.contains(' '));
+        assert!(!slug.contains('@'));
+        assert!(!slug.contains("--"));
+    }
+
+    #[test]
+    fn slug_from_home_empty_dirname_generates_uuid() {
+        // A path whose file_name() component becomes empty after sanitization
+        let slug = slug_from_home("/");
+        // Should be a UUID (36 chars with hyphens)
+        assert!(!slug.is_empty());
+    }
+
+    #[test]
+    fn connect_error_display_messages() {
+        let err = ConnectError::DockerHomeMissing("/foo".to_string());
+        assert!(err.to_string().contains("/foo"));
+
+        let err = ConnectError::Registry("io error".to_string());
+        assert!(err.to_string().contains("io error"));
+
+        let err = ConnectError::Ssh("timeout".to_string());
+        assert!(err.to_string().contains("timeout"));
+
+        let err = ConnectError::LocalHomeMissing("/bar".to_string());
+        assert!(err.to_string().contains("/bar"));
+    }
 }
diff --git a/clawpal-core/src/cron.rs b/clawpal-core/src/cron.rs
index e70367f8..2f0ab154 100644
--- a/clawpal-core/src/cron.rs
+++ b/clawpal-core/src/cron.rs
@@ -70,4 +70,69 @@ mod tests {
         assert_eq!(out.len(), 2);
         assert_eq!(out[0].get("runId").and_then(Value::as_str), Some("2"));
     }
+
+    #[test]
+    fn parse_cron_jobs_plain_array() {
+        let raw = r#"[{"id":"j1","expr":"0 * * * *"},{"id":"j2","expr":"*/5 * * * *"}]"#;
+        let out = parse_cron_jobs(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+        assert_eq!(out[0].get("jobId").and_then(Value::as_str), Some("j1"));
+        assert_eq!(out[1].get("jobId").and_then(Value::as_str), Some("j2"));
+    }
+
+    #[test]
+    fn parse_cron_jobs_object_map() {
+        let raw = r#"{"myJob":{"expr":"0 0 * * *"},"other":{"expr":"*/10 * * * *"}}"#;
+        let out = parse_cron_jobs(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+        // Each entry should have both id and jobId
+        for job in &out {
+            assert!(job.get("jobId").is_some());
+            assert!(job.get("id").is_some());
+        }
+    }
+
+    #[test]
+    fn parse_cron_jobs_empty_input() {
+        let out = parse_cron_jobs("").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_cron_jobs_invalid_json_returns_empty() {
+        let out = parse_cron_jobs("not json at all").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_cron_runs_empty_input() {
+        let out = parse_cron_runs("").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_cron_runs_skips_empty_lines() {
+        let raw = "\n{\"runId\":\"1\"}\n\n{\"runId\":\"2\"}\n\n";
+        let out = parse_cron_runs(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn parse_cron_runs_reverses_order() {
+        let raw = "{\"runId\":\"first\"}\n{\"runId\":\"second\"}\n{\"runId\":\"third\"}\n";
+        let out = parse_cron_runs(raw).expect("parse");
+        assert_eq!(out[0].get("runId").and_then(Value::as_str), Some("third"));
+        assert_eq!(out[2].get("runId").and_then(Value::as_str), Some("first"));
+    }
+
+    #[test]
+    fn parse_cron_jobs_preserves_existing_job_id() {
+        // If jobId already exists, id should not overwrite it
+        let raw = r#"[{"id":"j1","jobId":"existing"}]"#;
+        let out = parse_cron_jobs(raw).expect("parse");
+        assert_eq!(
+            out[0].get("jobId").and_then(Value::as_str),
+            Some("existing")
+        );
+    }
 }
diff --git a/clawpal-core/src/discovery.rs b/clawpal-core/src/discovery.rs
index 8bab1b42..3fa3620a 100644
--- a/clawpal-core/src/discovery.rs
+++ b/clawpal-core/src/discovery.rs
@@ -185,4 +185,170 @@ mod tests {
         let out = parse_bindings("[{\"a\":1}]").expect("parse");
         assert_eq!(out.len(), 1);
     }
+
+    #[test]
+    fn parse_guild_channels_from_accounts() {
+        let raw = r#"{
+          "channels": {
+            "discord": {
+              "accounts": {
+                "acc1": {
+                  "guilds": {
+                    "g2": {"channels": {"c2": {}, "c3": {}}}
+                  }
+                }
+              }
+            }
+          },
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+        assert!(out.iter().any(|c| c.channel_id == "c2"));
+        assert!(out.iter().any(|c| c.channel_id == "c3"));
+    }
+
+    #[test]
+    fn parse_guild_channels_uses_slug_as_name() {
+        let raw = r#"{
+          "channels": {"discord": {"guilds": {"g1": {"slug": "My Server", "channels": {"c1": {}}}}}},
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out[0].guild_name, "My Server");
+    }
+
+    #[test]
+    fn parse_guild_channels_uses_name_fallback() {
+        let raw = r#"{
+          "channels": {"discord": {"guilds": {"g1": {"name": "Named Server", "channels": {"c1": {}}}}}},
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out[0].guild_name, "Named Server");
+    }
+
+    #[test]
+    fn parse_guild_channels_falls_back_to_guild_id() {
+        let raw = r#"{
+          "channels": {"discord": {"guilds": {"12345": {"channels": {"c1": {}}}}}},
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out[0].guild_name, "12345");
+    }
+
+    #[test]
+    fn parse_guild_channels_skips_wildcard_channels() {
+        let raw = r#"{
+          "channels": {"discord": {"guilds": {"g1": {"channels": {"*": {}, "c1": {}}}}}},
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].channel_id, "c1");
+    }
+
+    #[test]
+    fn parse_guild_channels_deduplicates() {
+        let raw = r#"{
+          "channels": {
+            "discord": {
+              "guilds": {"g1": {"channels": {"c1": {}}}},
+              "accounts": {"a1": {"guilds": {"g1": {"channels": {"c1": {}}}}}}
+            }
+          },
+          "bindings": []
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out.len(), 1);
+    }
+
+    #[test]
+    fn parse_guild_channels_from_bindings() {
+        let raw = r#"{
+          "channels": {"discord": {}},
+          "bindings": [
+            {"match":{"channel":"discord","guildId":"g1","peer":{"id":"c1"}},"agentId":"main"},
+            {"match":{"channel":"telegram","guildId":"g2","peer":{"id":"c2"}},"agentId":"main"}
+          ]
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        // Only discord binding should be collected
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].guild_id, "g1");
+        assert_eq!(out[0].channel_id, "c1");
+    }
+
+    #[test]
+    fn parse_guild_channels_bindings_numeric_ids() {
+        let raw = r#"{
+          "channels": {},
+          "bindings": [
+            {"match":{"channel":"discord","guildId":12345,"peer":{"id":67890}},"agentId":"main"}
+          ]
+        }"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].guild_id, "12345");
+        assert_eq!(out[0].channel_id, "67890");
+    }
+
+    #[test]
+    fn parse_guild_channels_empty_config() {
+        let raw = r#"{"channels":{},"bindings":[]}"#;
+        let out = parse_guild_channels(raw).expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_guild_channels_invalid_json() {
+        let result = parse_guild_channels("not json");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn merge_channel_bindings_no_match() {
+        let channels = vec![GuildChannel {
+            guild_id: "g1".into(),
+            guild_name: "g1".into(),
+            channel_id: "c1".into(),
+            channel_name: "c1".into(),
+        }];
+        let bindings = r#"[{"match":{"channel":"discord","guildId":"g2","peer":{"id":"c2"}},"agentId":"other"}]"#;
+        let out = merge_channel_bindings(&channels, bindings);
+        assert_eq!(out.len(), 1);
+        assert!(out[0].agent_id.is_none());
+    }
+
+    #[test]
+    fn merge_channel_bindings_invalid_bindings() {
+        let channels = vec![GuildChannel {
+            guild_id: "g".into(),
+            guild_name: "g".into(),
+            channel_id: "c".into(),
+            channel_name: "c".into(),
+        }];
+        let out = merge_channel_bindings(&channels, "invalid json");
+        assert_eq!(out.len(), 1);
+        assert!(out[0].agent_id.is_none());
+    }
+
+    #[test]
+    fn parse_bindings_empty_array() {
+        let out = parse_bindings("[]").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_bindings_non_array() {
+        let out = parse_bindings("{}").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_bindings_invalid_json() {
+        let result = parse_bindings("not json");
+        assert!(result.is_err());
+    }
 }
diff --git a/clawpal-core/src/health.rs b/clawpal-core/src/health.rs
index f6fead37..d492e664 100644
--- a/clawpal-core/src/health.rs
+++ b/clawpal-core/src/health.rs
@@ -187,6 +187,7 @@ fn count_agents(value: &Value) -> u32 {
 mod tests {
     use super::*;
     use crate::instance::{Instance, InstanceType, SshHostConfig};
+    use serde_json::json;
     use uuid::Uuid;
 
     #[cfg(unix)]
@@ -268,6 +269,82 @@ mod tests {
         assert!(wrapped.contains("*) \"$LOGIN_SHELL\" -lc"));
     }
 
+    #[test]
+    fn count_agents_array() {
+        assert_eq!(count_agents(&json!([{"id":"a"},{"id":"b"}])), 2);
+    }
+
+    #[test]
+    fn count_agents_wrapped() {
+        assert_eq!(count_agents(&json!({"agents":[{"id":"a"}]})), 1);
+    }
+
+    #[test]
+    fn count_agents_object_fallback() {
+        // agents exists but is not an array → returns 1
+        assert_eq!(count_agents(&json!({"agents":{"id":"main"}})), 1);
+    }
+
+    #[test]
+    fn count_agents_empty() {
+        assert_eq!(count_agents(&json!({})), 0);
+        assert_eq!(count_agents(&json!([])), 0);
+    }
+
+    #[test]
+    fn parse_active_agents_nonzero_exit() {
+        let output = CliOutput {
+            stdout: "error".to_string(),
+            stderr: String::new(),
+            exit_code: 1,
+        };
+        assert_eq!(parse_active_agents(&output).unwrap(), 0);
+    }
+
+    #[test]
+    fn parse_active_agents_valid_json() {
+        let output = CliOutput {
+            stdout: "[{\"id\":\"a\"},{\"id\":\"b\"}]".to_string(),
+            stderr: String::new(),
+            exit_code: 0,
+        };
+        assert_eq!(parse_active_agents(&output).unwrap(), 2);
+    }
+
+    #[test]
+    fn shell_escape_simple() {
+        assert_eq!(shell_escape("hello"), "'hello'");
+    }
+
+    #[test]
+    fn shell_escape_quotes() {
+        assert_eq!(shell_escape("it's"), "'it'\\''s'");
+    }
+
+    #[test]
+    fn health_error_display() {
+        let e = HealthError::MissingSshConfig("my-instance".to_string());
+        assert!(e.to_string().contains("my-instance"));
+
+        let e = HealthError::Command("timeout".to_string());
+        assert!(e.to_string().contains("timeout"));
+    }
+
+    #[test]
+    fn check_remote_ssh_fails_without_ssh_config() {
+        let instance = Instance {
+            id: "ssh:no-config".to_string(),
+            instance_type: InstanceType::RemoteSsh,
+            label: "No Config".to_string(),
+            openclaw_home: None,
+            clawpal_data_dir: None,
+            ssh_host_config: None,
+        };
+        let result = check_instance(&instance);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("missing ssh"));
+    }
+
     #[test]
     #[cfg(unix)]
     fn check_instance_remote_ssh_path_works_with_fake_ssh() {
diff --git a/clawpal-core/src/install/docker.rs b/clawpal-core/src/install/docker.rs
index fc4b898f..4dc94a92 100644
--- a/clawpal-core/src/install/docker.rs
+++ b/clawpal-core/src/install/docker.rs
@@ -286,4 +286,66 @@ mod tests {
         }
         assert!(!exists);
     }
+
+    #[test]
+    fn needs_local_image_fallback_repo_does_not_exist() {
+        let msg = "docker_pull failed (code Some(1)): repository does not exist or may require authentication";
+        assert!(needs_local_image_fallback(msg));
+    }
+
+    #[test]
+    fn needs_local_image_fallback_access_denied() {
+        let msg = "docker_pull failed: requested access to the resource is denied";
+        assert!(needs_local_image_fallback(msg));
+    }
+
+    #[test]
+    fn needs_local_image_fallback_unrelated_error() {
+        let msg = "docker_pull failed: network timeout";
+        assert!(!needs_local_image_fallback(msg));
+    }
+
+    #[test]
+    fn needs_local_image_fallback_missing_docker_pull_prefix() {
+        // Must contain "docker_pull failed" to trigger
+        let msg = "pull access denied for openclaw";
+        assert!(!needs_local_image_fallback(msg));
+    }
+
+    #[test]
+    fn compose_env_returns_expected_keys() {
+        let env = compose_env("/tmp/test-state");
+        let keys: Vec<&str> = env.iter().map(|(k, _)| *k).collect();
+        assert!(keys.contains(&"OPENCLAW_CONFIG_DIR"));
+        assert!(keys.contains(&"OPENCLAW_WORKSPACE_DIR"));
+        assert!(keys.contains(&"OPENCLAW_GATEWAY_TOKEN"));
+    }
+
+    #[test]
+    fn openclaw_state_dir_uses_home_option() {
+        let options = DockerInstallOptions {
+            home: Some("/custom/home".to_string()),
+            ..DockerInstallOptions::default()
+        };
+        let dir = openclaw_state_dir(&options);
+        assert_eq!(dir, "/custom/home/.openclaw");
+    }
+
+    #[test]
+    fn openclaw_state_dir_default() {
+        let options = DockerInstallOptions::default();
+        let dir = openclaw_state_dir(&options);
+        assert!(dir.ends_with("/.openclaw"));
+    }
+
+    #[test]
+    fn openclaw_home_expands_tilde() {
+        let options = DockerInstallOptions {
+            home: Some("~/my-openclaw".to_string()),
+            ..DockerInstallOptions::default()
+        };
+        let home = openclaw_home(&options);
+        assert!(!home.starts_with('~'));
+        assert!(home.ends_with("/my-openclaw"));
+    }
 }
diff --git a/clawpal-core/src/instance.rs b/clawpal-core/src/instance.rs
index c38b83c1..1c0c20e8 100644
--- a/clawpal-core/src/instance.rs
+++ b/clawpal-core/src/instance.rs
@@ -423,6 +423,132 @@ mod tests {
         }
     }
 
+    #[test]
+    fn sanitize_instance_id_segment_basic() {
+        assert_eq!(sanitize_instance_id_segment("my-server"), "my-server");
+    }
+
+    #[test]
+    fn sanitize_instance_id_segment_special_chars() {
+        assert_eq!(sanitize_instance_id_segment("vm@123.com"), "vm-123-com");
+    }
+
+    #[test]
+    fn sanitize_instance_id_segment_consecutive_dashes() {
+        assert_eq!(sanitize_instance_id_segment("a!!b"), "a-b");
+    }
+
+    #[test]
+    fn sanitize_instance_id_segment_empty() {
+        assert_eq!(sanitize_instance_id_segment(""), "remote");
+        assert_eq!(sanitize_instance_id_segment("---"), "remote");
+    }
+
+    #[test]
+    fn sanitize_instance_id_segment_whitespace() {
+        assert_eq!(sanitize_instance_id_segment("  my server  "), "my-server");
+    }
+
+    #[test]
+    fn endpoint_key_format() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "Example.COM".to_string(),
+            port: 2222,
+            username: "alice".to_string(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        assert_eq!(cfg.endpoint_key(), "alice@example.com:2222");
+    }
+
+    #[test]
+    fn ids_returns_all_ids() {
+        let mut registry = InstanceRegistry::default();
+        registry.add(sample_instance("a")).expect("add");
+        registry.add(sample_instance("b")).expect("add");
+        let mut ids = registry.ids();
+        ids.sort();
+        assert_eq!(ids, vec!["a", "b"]);
+    }
+
+    #[test]
+    fn get_returns_none_for_missing() {
+        let registry = InstanceRegistry::default();
+        assert!(registry.get("nonexistent").is_none());
+    }
+
+    #[test]
+    fn remove_returns_none_for_missing() {
+        let mut registry = InstanceRegistry::default();
+        assert!(registry.remove("nonexistent").is_none());
+    }
+
+    #[test]
+    fn canonical_remote_instance_id_uses_instance_id() {
+        let inst = Instance {
+            id: "ssh:custom".to_string(),
+            instance_type: InstanceType::RemoteSsh,
+            label: String::new(),
+            openclaw_home: None,
+            clawpal_data_dir: None,
+            ssh_host_config: None,
+        };
+        assert_eq!(canonical_remote_instance_id(&inst), "ssh:custom");
+    }
+
+    #[test]
+    fn canonical_remote_instance_id_falls_back_to_ssh_config() {
+        let inst = Instance {
+            id: String::new(),
+            instance_type: InstanceType::RemoteSsh,
+            label: String::new(),
+            openclaw_home: None,
+            clawpal_data_dir: None,
+            ssh_host_config: Some(SshHostConfig {
+                id: String::new(),
+                label: String::new(),
+                host: "my-host.com".to_string(),
+                port: 22,
+                username: "root".to_string(),
+                auth_method: "key".to_string(),
+                key_path: None,
+                password: None,
+                passphrase: None,
+            }),
+        };
+        assert_eq!(canonical_remote_instance_id(&inst), "ssh:my-host-com");
+    }
+
+    #[test]
+    fn canonical_remote_instance_id_no_ssh_config() {
+        let inst = Instance {
+            id: String::new(),
+            instance_type: InstanceType::RemoteSsh,
+            label: String::new(),
+            openclaw_home: None,
+            clawpal_data_dir: None,
+            ssh_host_config: None,
+        };
+        assert_eq!(canonical_remote_instance_id(&inst), "ssh:remote");
+    }
+
+    #[test]
+    fn normalize_instance_non_ssh_unchanged() {
+        let inst = sample_instance("local");
+        let normalized = normalize_instance(inst.clone());
+        assert_eq!(normalized.id, "local");
+    }
+
+    #[test]
+    fn registry_error_display() {
+        let err = InstanceRegistryError::DuplicateInstance("dup-id".to_string());
+        assert!(err.to_string().contains("dup-id"));
+    }
+
     #[test]
     fn load_deduplicates_ssh_instances_by_endpoint() {
         let _guard = crate::test_support::env_lock()
diff --git a/clawpal-core/src/openclaw.rs b/clawpal-core/src/openclaw.rs
index 237e081d..c2b04d75 100644
--- a/clawpal-core/src/openclaw.rs
+++ b/clawpal-core/src/openclaw.rs
@@ -249,4 +249,84 @@ mod tests {
         let value = parse_json_output(&output).expect("parse");
         assert_eq!(value["a"], 1);
     }
+
+    #[test]
+    fn parse_json_output_extracts_array() {
+        let output = CliOutput {
+            stdout: "some noise\n[{\"x\":1},{\"x\":2}]\nmore noise".to_string(),
+            stderr: String::new(),
+            exit_code: 0,
+        };
+        let value = parse_json_output(&output).expect("parse");
+        assert!(value.is_array());
+        assert_eq!(value.as_array().unwrap().len(), 2);
+    }
+
+    #[test]
+    fn parse_json_output_returns_error_on_nonzero_exit() {
+        let output = CliOutput {
+            stdout: String::new(),
+            stderr: "command not found".to_string(),
+            exit_code: 1,
+        };
+        let err = parse_json_output(&output).unwrap_err();
+        match err {
+            OpenclawError::CommandFailed { exit_code, details } => {
+                assert_eq!(exit_code, 1);
+                assert!(details.contains("command not found"));
+            }
+            _ => panic!("expected CommandFailed"),
+        }
+    }
+
+    #[test]
+    fn parse_json_output_uses_stdout_when_stderr_empty() {
+        let output = CliOutput {
+            stdout: "some error output".to_string(),
+            stderr: String::new(),
+            exit_code: 2,
+        };
+        let err = parse_json_output(&output).unwrap_err();
+        assert!(err.to_string().contains("some error output"));
+    }
+
+    #[test]
+    fn parse_json_output_no_json_returns_error() {
+        let output = CliOutput {
+            stdout: "just plain text without any json".to_string(),
+            stderr: String::new(),
+            exit_code: 0,
+        };
+        let err = parse_json_output(&output).unwrap_err();
+        assert!(matches!(err, OpenclawError::NoJson(_)));
+    }
+
+    #[test]
+    fn parse_json_output_nested_json() {
+        let output = CliOutput {
+            stdout: "{\"a\":{\"b\":{\"c\":42}}}".to_string(),
+            stderr: String::new(),
+            exit_code: 0,
+        };
+        let value = parse_json_output(&output).expect("parse");
+        assert_eq!(value["a"]["b"]["c"], 42);
+    }
+
+    #[test]
+    fn cli_output_default_fields() {
+        let cli = OpenclawCli::with_bin("echo");
+        assert_eq!(cli.bin, "echo");
+    }
+
+    #[test]
+    fn openclaw_error_display() {
+        let err = OpenclawError::NoJson("no brackets".to_string());
+        assert!(err.to_string().contains("no json"));
+
+        let err = OpenclawError::CommandFailed {
+            exit_code: 42,
+            details: "bad".to_string(),
+        };
+        assert!(err.to_string().contains("42"));
+    }
 }
diff --git a/clawpal-core/src/precheck.rs b/clawpal-core/src/precheck.rs
index 79128726..a52c499b 100644
--- a/clawpal-core/src/precheck.rs
+++ b/clawpal-core/src/precheck.rs
@@ -179,4 +179,99 @@ mod tests {
         let issues = precheck_instance_state(&inst);
         assert!(issues.is_empty());
     }
+
+    #[test]
+    fn precheck_auth_detects_missing_model() {
+        let profiles = vec![ModelProfile {
+            id: "bad".into(),
+            name: "Bad".into(),
+            provider: "anthropic".into(),
+            model: "".into(),
+            auth_ref: String::new(),
+            api_key: None,
+            base_url: None,
+            description: None,
+            enabled: true,
+        }];
+        let issues = precheck_auth(&profiles);
+        assert!(issues.iter().any(|i| i.code == "AUTH_MISCONFIGURED"));
+    }
+
+    #[test]
+    fn precheck_auth_multiple_profiles() {
+        let profiles = vec![
+            ModelProfile {
+                id: "good".into(),
+                name: "Good".into(),
+                provider: "anthropic".into(),
+                model: "claude-3".into(),
+                auth_ref: String::new(),
+                api_key: None,
+                base_url: None,
+                description: None,
+                enabled: true,
+            },
+            ModelProfile {
+                id: "bad".into(),
+                name: "Bad".into(),
+                provider: "".into(),
+                model: "".into(),
+                auth_ref: String::new(),
+                api_key: None,
+                base_url: None,
+                description: None,
+                enabled: true,
+            },
+        ];
+        let issues = precheck_auth(&profiles);
+        assert_eq!(issues.len(), 1);
+    }
+
+    #[test]
+    fn precheck_auth_empty_profiles() {
+        let issues = precheck_auth(&[]);
+        assert!(issues.is_empty());
+    }
+
+    #[test]
+    fn precheck_registry_valid_json_passes() {
+        let dir = std::env::temp_dir().join(format!("precheck-valid-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("instances.json");
+        std::fs::write(&path, r#"{"instances":[]}"#).unwrap();
+        let issues = precheck_registry(&path);
+        assert!(issues.is_empty());
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn precheck_instance_state_local_with_existing_home() {
+        let home = std::env::temp_dir().join(format!("precheck-home-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&home).unwrap();
+        let inst = Instance {
+            id: "local".into(),
+            instance_type: InstanceType::Local,
+            label: "Local".into(),
+            openclaw_home: Some(home.to_string_lossy().to_string()),
+            clawpal_data_dir: None,
+            ssh_host_config: None,
+        };
+        let issues = precheck_instance_state(&inst);
+        assert!(issues.is_empty());
+        std::fs::remove_dir_all(&home).ok();
+    }
+
+    #[test]
+    fn precheck_instance_state_no_home_dir_local() {
+        let inst = Instance {
+            id: "local".into(),
+            instance_type: InstanceType::Local,
+            label: "Local".into(),
+            openclaw_home: None,
+            clawpal_data_dir: None,
+            ssh_host_config: None,
+        };
+        let issues = precheck_instance_state(&inst);
+        assert!(issues.is_empty());
+    }
 }
diff --git a/clawpal-core/src/sessions.rs b/clawpal-core/src/sessions.rs
index e33b4c03..14b5a3f2 100644
--- a/clawpal-core/src/sessions.rs
+++ b/clawpal-core/src/sessions.rs
@@ -271,4 +271,106 @@ mod tests {
         assert_eq!(out[0].role, "user");
         assert_eq!(out[0].content, "hi");
     }
+
+    #[test]
+    fn parse_session_preview_handles_array_content() {
+        let raw = r#"{"type":"message","message":{"role":"assistant","content":[{"text":"Hello"},{"text":" world"}]}}"#;
+        let out = parse_session_preview(raw).expect("preview");
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].role, "assistant");
+        assert_eq!(out[0].content, "Hello\n world");
+    }
+
+    #[test]
+    fn parse_session_preview_skips_non_message_types() {
+        let raw = "{\"type\":\"metadata\",\"data\":{}}\n{\"type\":\"message\",\"message\":{\"role\":\"user\",\"content\":\"hi\"}}\n";
+        let out = parse_session_preview(raw).expect("preview");
+        assert_eq!(out.len(), 1);
+    }
+
+    #[test]
+    fn parse_session_preview_skips_empty_lines() {
+        let raw =
+            "\n\n{\"type\":\"message\",\"message\":{\"role\":\"user\",\"content\":\"test\"}}\n\n";
+        let out = parse_session_preview(raw).expect("preview");
+        assert_eq!(out.len(), 1);
+    }
+
+    #[test]
+    fn parse_session_analysis_classifies_valuable() {
+        let raw = r#"[
+          {"agent":"main","sessionId":"v","sizeBytes":5000,"messageCount":10,"userMessageCount":5,"assistantMessageCount":5,"ageDays":1,"kind":"sessions"}
+        ]"#;
+        let out = parse_session_analysis(raw).expect("parse");
+        assert_eq!(out[0].valuable_count, 1);
+        assert_eq!(out[0].empty_count, 0);
+        assert_eq!(out[0].low_value_count, 0);
+    }
+
+    #[test]
+    fn parse_session_analysis_multiple_agents() {
+        let raw = r#"[
+          {"agent":"main","sessionId":"a","sizeBytes":100,"messageCount":0,"userMessageCount":0,"assistantMessageCount":0,"ageDays":1,"kind":"sessions"},
+          {"agent":"cron","sessionId":"b","sizeBytes":5000,"messageCount":3,"userMessageCount":2,"assistantMessageCount":1,"ageDays":0.5,"kind":"sessions"}
+        ]"#;
+        let out = parse_session_analysis(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+        let agents: Vec<&str> = out.iter().map(|a| a.agent.as_str()).collect();
+        assert!(agents.contains(&"main"));
+        assert!(agents.contains(&"cron"));
+    }
+
+    #[test]
+    fn parse_session_analysis_empty_array() {
+        let out = parse_session_analysis("[]").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_session_analysis_sorts_by_category_then_age() {
+        let raw = r#"[
+          {"agent":"a","sessionId":"valuable","sizeBytes":5000,"messageCount":10,"userMessageCount":5,"assistantMessageCount":5,"ageDays":1,"kind":"sessions"},
+          {"agent":"a","sessionId":"empty","sizeBytes":100,"messageCount":0,"userMessageCount":0,"assistantMessageCount":0,"ageDays":2,"kind":"sessions"}
+        ]"#;
+        let out = parse_session_analysis(raw).expect("parse");
+        assert_eq!(out[0].sessions[0].category, "empty");
+        assert_eq!(out[0].sessions[1].category, "valuable");
+    }
+
+    #[test]
+    fn filter_sessions_by_ids_keeps_unmatched() {
+        let raw = r#"{"a":{"sessionId":"s1"},"b":{"sessionId":"s2"},"c":{"sessionId":"s3"}}"#;
+        let out = filter_sessions_by_ids(raw, &["s1", "s3"]).expect("filter");
+        assert!(!out.contains("s1"));
+        assert!(out.contains("s2"));
+        assert!(!out.contains("s3"));
+    }
+
+    #[test]
+    fn filter_sessions_by_ids_empty_filter() {
+        let raw = r#"{"a":{"sessionId":"s1"}}"#;
+        let out = filter_sessions_by_ids(raw, &[]).expect("filter");
+        assert!(out.contains("s1"));
+    }
+
+    #[test]
+    fn parse_session_file_list_empty() {
+        let out = parse_session_file_list("[]").expect("parse");
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn parse_session_file_list_multiple_entries() {
+        let raw = r#"[
+          {"agent":"a","kind":"sessions","path":"a/sessions/1.jsonl","sizeBytes":42},
+          {"agent":"b","kind":"cron","path":"b/cron/2.jsonl","sizeBytes":100}
+        ]"#;
+        let out = parse_session_file_list(raw).expect("parse");
+        assert_eq!(out.len(), 2);
+        assert_eq!(out[0].agent, "a");
+        assert_eq!(out[0].kind, "sessions");
+        assert_eq!(out[1].agent, "b");
+        assert_eq!(out[1].kind, "cron");
+        assert_eq!(out[1].size_bytes, 100);
+    }
 }
diff --git a/clawpal-core/src/ssh/mod.rs b/clawpal-core/src/ssh/mod.rs
index 9c47754a..3d712715 100644
--- a/clawpal-core/src/ssh/mod.rs
+++ b/clawpal-core/src/ssh/mod.rs
@@ -694,4 +694,228 @@ mod tests {
         assert!(joined.contains("ServerAliveInterval="));
         assert!(joined.contains("ServerAliveCountMax="));
     }
+
+    #[test]
+    fn legacy_args_include_identity_file_when_set() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "example.com".to_string(),
+            port: 22,
+            username: "alice".to_string(),
+            auth_method: "key".to_string(),
+            key_path: Some("~/.ssh/my_key".to_string()),
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        let args = session.legacy_common_ssh_args();
+        assert!(args.contains(&"-i".to_string()));
+        assert!(args.contains(&"~/.ssh/my_key".to_string()));
+    }
+
+    #[test]
+    fn legacy_args_omit_identity_file_when_empty() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "example.com".to_string(),
+            port: 22,
+            username: "alice".to_string(),
+            auth_method: "key".to_string(),
+            key_path: Some("   ".to_string()),
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        let args = session.legacy_common_ssh_args();
+        assert!(!args.contains(&"-i".to_string()));
+    }
+
+    #[test]
+    fn legacy_destination_with_username() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "myhost.com".to_string(),
+            port: 22,
+            username: "deploy".to_string(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        assert_eq!(session.legacy_destination(), "deploy@myhost.com");
+    }
+
+    #[test]
+    fn legacy_destination_without_username() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "myhost.com".to_string(),
+            port: 22,
+            username: String::new(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        assert_eq!(session.legacy_destination(), "myhost.com");
+    }
+
+    #[test]
+    fn legacy_destination_whitespace_username() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "myhost.com".to_string(),
+            port: 22,
+            username: "   ".to_string(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        // trim().is_empty() → falls through to just host
+        assert_eq!(session.legacy_destination(), "myhost.com");
+    }
+
+    #[test]
+    fn legacy_args_use_custom_port() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "example.com".to_string(),
+            port: 2222,
+            username: "user".to_string(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let session = SshSession {
+            config: cfg,
+            backend: Backend::Legacy,
+        };
+        let args = session.legacy_common_ssh_args();
+        let port_idx = args.iter().position(|a| a == "-p").expect("-p flag");
+        assert_eq!(args[port_idx + 1], "2222");
+    }
+
+    #[test]
+    fn resolve_target_defaults_port_zero_to_22() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "example.com".to_string(),
+            port: 0,
+            username: "alice".to_string(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let resolved = resolve_target(&cfg).expect("resolve");
+        assert_eq!(resolved.port, 22);
+    }
+
+    #[test]
+    fn resolve_target_falls_back_username_from_env() {
+        let cfg = SshHostConfig {
+            id: "ssh:test".to_string(),
+            label: "Test".to_string(),
+            host: "example.com".to_string(),
+            port: 22,
+            username: String::new(),
+            auth_method: "key".to_string(),
+            key_path: None,
+            password: None,
+            passphrase: None,
+        };
+        let resolved = resolve_target(&cfg).expect("resolve");
+        // Should fall back to $USER / $USERNAME / "root" — just ensure it's not empty
+        assert!(!resolved.username.is_empty());
+    }
+
+    #[test]
+    fn shell_escape_handles_simple_string() {
+        assert_eq!(shell_escape("hello"), "'hello'");
+    }
+
+    #[test]
+    fn shell_escape_handles_single_quotes() {
+        assert_eq!(shell_escape("it's"), "'it'\\''s'");
+    }
+
+    #[test]
+    fn shell_escape_handles_spaces_and_special() {
+        assert_eq!(shell_escape("my file (1)"), "'my file (1)'");
+    }
+
+    #[test]
+    fn ssh_error_display_messages() {
+        let e = SshError::Connect("timeout".to_string());
+        assert!(e.to_string().contains("timeout"));
+
+        let e = SshError::Auth("bad key".to_string());
+        assert!(e.to_string().contains("bad key"));
+
+        let e = SshError::Channel("closed".to_string());
+        assert!(e.to_string().contains("closed"));
+
+        let e = SshError::CommandFailed("exit 1".to_string());
+        assert!(e.to_string().contains("exit 1"));
+
+        let e = SshError::InvalidConfig("empty".to_string());
+        assert!(e.to_string().contains("empty"));
+
+        let e = SshError::Sftp("io error".to_string());
+        assert!(e.to_string().contains("io error"));
+    }
+
+    #[test]
+    fn candidate_key_paths_returns_explicit_path_only() {
+        let target = ResolvedTarget {
+            host: "example.com".to_string(),
+            port: 22,
+            username: "alice".to_string(),
+            key_path: Some("/custom/key".to_string()),
+        };
+        let paths = candidate_key_paths(&target);
+        assert_eq!(paths, vec!["/custom/key"]);
+    }
+
+    #[test]
+    fn candidate_key_paths_returns_defaults_when_no_explicit() {
+        let target = ResolvedTarget {
+            host: "example.com".to_string(),
+            port: 22,
+            username: "alice".to_string(),
+            key_path: None,
+        };
+        let paths = candidate_key_paths(&target);
+        // Should include id_ed25519 and id_rsa at minimum (may be empty if no home dir)
+        for p in &paths {
+            assert!(p.contains("id_ed25519") || p.contains("id_rsa"));
+        }
+    }
 }
diff --git a/clawpal-core/src/watchdog.rs b/clawpal-core/src/watchdog.rs
index 4f0e82e9..ad8757a1 100644
--- a/clawpal-core/src/watchdog.rs
+++ b/clawpal-core/src/watchdog.rs
@@ -38,4 +38,50 @@ mod tests {
         assert_eq!(out.extra.get("foo").and_then(Value::as_i64), Some(1));
         assert_eq!(out.extra.get("alive").and_then(Value::as_bool), Some(true));
     }
+
+    #[test]
+    fn parse_watchdog_status_dead_when_not_alive() {
+        let out = parse_watchdog_status("{}", "dead");
+        assert!(!out.alive);
+        assert_eq!(out.extra.get("alive").and_then(Value::as_bool), Some(false));
+    }
+
+    #[test]
+    fn parse_watchdog_status_deployed_flag() {
+        let out = parse_watchdog_status("{\"deployed\":true}", "alive");
+        assert!(out.deployed);
+
+        let out2 = parse_watchdog_status("{\"deployed\":false}", "alive");
+        assert!(!out2.deployed);
+    }
+
+    #[test]
+    fn parse_watchdog_status_deployed_defaults_false() {
+        let out = parse_watchdog_status("{}", "alive");
+        assert!(!out.deployed);
+    }
+
+    #[test]
+    fn parse_watchdog_status_invalid_json() {
+        let out = parse_watchdog_status("not json", "alive");
+        assert!(out.alive);
+        assert!(!out.deployed);
+        // extra should be mostly empty (just the alive flag)
+        assert_eq!(out.extra.len(), 1);
+    }
+
+    #[test]
+    fn parse_watchdog_status_empty_ps_output() {
+        let out = parse_watchdog_status("{}", "");
+        assert!(!out.alive);
+    }
+
+    #[test]
+    fn parse_watchdog_status_whitespace_ps_output() {
+        // "alive\n" trimmed should match "alive"
+        let out = parse_watchdog_status("{}", "alive\n");
+        // After trim: "alive\n".trim() = "alive" — but the function trims
+        // Actually let me check — the function uses `ps_output.trim() == "alive"`
+        assert!(out.alive);
+    }
 }
diff --git a/src/lib/__tests__/guidance.test.ts b/src/lib/__tests__/guidance.test.ts
new file mode 100644
index 00000000..cdedd1cc
--- /dev/null
+++ b/src/lib/__tests__/guidance.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  isSshCooldownProtectionError,
+  isTransientSshChannelError,
+  isAlreadyExplainedGuidanceError,
+  isRegistryCorruptError,
+  isContainerOrphanedError,
+  shouldEmitAgentGuidance,
+} from "../guidance";
+
+describe("isSshCooldownProtectionError", () => {
+  test("matches ssh_cooldown prefix", () => {
+    expect(isSshCooldownProtectionError("SSH_COOLDOWN: wait 30s")).toBe(true);
+  });
+
+  test("matches cooling down text", () => {
+    expect(isSshCooldownProtectionError("connections are cooling down after repeated timeouts")).toBe(true);
+  });
+
+  test("matches retry in", () => {
+    expect(isSshCooldownProtectionError("retry in 15 seconds")).toBe(true);
+  });
+
+  test("matches Chinese text", () => {
+    expect(isSshCooldownProtectionError("处于冷却期，请稍后")).toBe(true);
+    expect(isSshCooldownProtectionError("多次超时后暂停")).toBe(true);
+  });
+
+  test("does not match unrelated errors", () => {
+    expect(isSshCooldownProtectionError("connection refused")).toBe(false);
+    expect(isSshCooldownProtectionError("permission denied")).toBe(false);
+  });
+});
+
+describe("isTransientSshChannelError", () => {
+  test("matches open channel failed", () => {
+    expect(isTransientSshChannelError("ssh open channel failed: timeout")).toBe(true);
+  });
+
+  test("matches connection reset", () => {
+    expect(isTransientSshChannelError("connection reset by peer")).toBe(true);
+  });
+
+  test("matches broken pipe", () => {
+    expect(isTransientSshChannelError("write failed: broken pipe")).toBe(true);
+  });
+
+  test("matches connection closed", () => {
+    expect(isTransientSshChannelError("connection closed unexpectedly")).toBe(true);
+  });
+
+  test("matches failed to open channel", () => {
+    expect(isTransientSshChannelError("failed to open channel")).toBe(true);
+  });
+
+  test("does not match auth errors", () => {
+    expect(isTransientSshChannelError("authentication failed")).toBe(false);
+  });
+});
+
+describe("isAlreadyExplainedGuidanceError", () => {
+  test("matches Chinese guidance text", () => {
+    expect(isAlreadyExplainedGuidanceError("下一步建议：执行诊断")).toBe(true);
+    expect(isAlreadyExplainedGuidanceError("建议先做诊断再继续")).toBe(true);
+    expect(isAlreadyExplainedGuidanceError("建议先执行诊断命令")).toBe(true);
+    expect(isAlreadyExplainedGuidanceError("本机未安装 openclaw")).toBe(true);
+  });
+
+  test("matches English guidance text", () => {
+    expect(isAlreadyExplainedGuidanceError("We recommend running doctor first")).toBe(true);
+    expect(isAlreadyExplainedGuidanceError("next step: check config")).toBe(true);
+    expect(isAlreadyExplainedGuidanceError("Please open doctor to diagnose")).toBe(true);
+  });
+
+  test("does not match raw errors", () => {
+    expect(isAlreadyExplainedGuidanceError("ECONNREFUSED 127.0.0.1:22")).toBe(false);
+  });
+});
+
+describe("isRegistryCorruptError", () => {
+  test("matches registry parse error", () => {
+    expect(isRegistryCorruptError("failed to parse registry")).toBe(true);
+  });
+
+  test("matches instances.json corrupt", () => {
+    expect(isRegistryCorruptError("instances.json is corrupt")).toBe(true);
+  });
+
+  test("matches invalid json in registry", () => {
+    expect(isRegistryCorruptError("registry: invalid json at line 5")).toBe(true);
+  });
+
+  test("does not match unrelated", () => {
+    expect(isRegistryCorruptError("file not found")).toBe(false);
+    expect(isRegistryCorruptError("registry updated successfully")).toBe(false);
+  });
+});
+
+describe("isContainerOrphanedError", () => {
+  test("matches no such container", () => {
+    expect(isContainerOrphanedError("No such container: abc123")).toBe(true);
+  });
+
+  test("matches container not found", () => {
+    expect(isContainerOrphanedError("container xyz not found")).toBe(true);
+  });
+
+  test("does not match openclaw container messages", () => {
+    expect(isContainerOrphanedError("container openclaw not found")).toBe(false);
+  });
+
+  test("does not match unrelated", () => {
+    expect(isContainerOrphanedError("image pull failed")).toBe(false);
+  });
+});
+
+describe("shouldEmitAgentGuidance", () => {
+  test("suppresses cooldown errors", () => {
+    expect(shouldEmitAgentGuidance("inst1", "connect", "SSH_COOLDOWN: wait")).toBe(false);
+  });
+
+  test("suppresses transient channel errors", () => {
+    expect(shouldEmitAgentGuidance("inst1", "exec", "ssh open channel failed")).toBe(false);
+  });
+
+  test("suppresses already-explained errors", () => {
+    expect(shouldEmitAgentGuidance("inst1", "health", "建议先做诊断再继续")).toBe(false);
+  });
+
+  test("allows novel errors", () => {
+    const unique = `unique-error-${Date.now()}-${Math.random()}`;
+    expect(shouldEmitAgentGuidance("inst1", "connect", unique)).toBe(true);
+  });
+
+  test("throttles duplicate errors within 90s", () => {
+    const unique = `throttle-test-${Date.now()}-${Math.random()}`;
+    expect(shouldEmitAgentGuidance("inst-throttle", "op", unique)).toBe(true);
+    expect(shouldEmitAgentGuidance("inst-throttle", "op", unique)).toBe(false);
+  });
+
+  test("different instances are independent", () => {
+    const unique = `multi-inst-${Date.now()}-${Math.random()}`;
+    expect(shouldEmitAgentGuidance("instA", "op", unique)).toBe(true);
+    expect(shouldEmitAgentGuidance("instB", "op", unique)).toBe(true);
+  });
+});
diff --git a/src/lib/__tests__/modelValue.test.ts b/src/lib/__tests__/modelValue.test.ts
new file mode 100644
index 00000000..36ac4d21
--- /dev/null
+++ b/src/lib/__tests__/modelValue.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+
+import { profileToModelValue } from "../model-value";
+
+describe("profileToModelValue", () => {
+  test("combines provider and model", () => {
+    expect(profileToModelValue({ provider: "anthropic", model: "claude-3-5-sonnet" }))
+      .toBe("anthropic/claude-3-5-sonnet");
+  });
+
+  test("returns model alone when provider is empty", () => {
+    expect(profileToModelValue({ provider: "", model: "gpt-4o" })).toBe("gpt-4o");
+  });
+
+  test("returns provider/ when model is empty", () => {
+    expect(profileToModelValue({ provider: "openai", model: "" })).toBe("openai/");
+  });
+
+  test("does not double-prefix when model already has provider", () => {
+    expect(profileToModelValue({ provider: "anthropic", model: "anthropic/claude-3-5-sonnet" }))
+      .toBe("anthropic/claude-3-5-sonnet");
+  });
+
+  test("case-insensitive prefix detection", () => {
+    expect(profileToModelValue({ provider: "Anthropic", model: "anthropic/claude-3-5-sonnet" }))
+      .toBe("anthropic/claude-3-5-sonnet");
+  });
+
+  test("trims whitespace from provider and model", () => {
+    expect(profileToModelValue({ provider: "  openai  ", model: "  gpt-4  " }))
+      .toBe("openai/gpt-4");
+  });
+
+  test("handles both empty", () => {
+    expect(profileToModelValue({ provider: "", model: "" })).toBe("");
+  });
+
+  test("whitespace-only provider treated as empty", () => {
+    expect(profileToModelValue({ provider: "   ", model: "gpt-4o" })).toBe("gpt-4o");
+  });
+});
diff --git a/src/lib/__tests__/promptTemplates.test.ts b/src/lib/__tests__/promptTemplates.test.ts
new file mode 100644
index 00000000..b49912b7
--- /dev/null
+++ b/src/lib/__tests__/promptTemplates.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+
+// We test the pure renderPromptTemplate function only.
+// extractPromptBlock and the named templates depend on Vite ?raw imports.
+// We re-implement the pure logic here to avoid import errors.
+
+function renderPromptTemplate(template: string, vars: Record<string, string>): string {
+  let output = template;
+  for (const [key, value] of Object.entries(vars)) {
+    output = output.split(key).join(value);
+  }
+  return output;
+}
+
+function extractPromptBlock(markdown: string): string {
+  const marker = "```prompt";
+  const start = markdown.indexOf(marker);
+  if (start < 0) return markdown.trim();
+  const bodyStart = start + marker.length;
+  const rest = markdown.slice(bodyStart);
+  const end = rest.indexOf("```");
+  if (end < 0) return rest.trim();
+  return rest.slice(0, end).trim();
+}
+
+describe("renderPromptTemplate", () => {
+  test("replaces single variable", () => {
+    expect(renderPromptTemplate("Hello {{NAME}}", { "{{NAME}}": "Alice" }))
+      .toBe("Hello Alice");
+  });
+
+  test("replaces multiple occurrences", () => {
+    expect(renderPromptTemplate("{{X}} and {{X}}", { "{{X}}": "A" }))
+      .toBe("A and A");
+  });
+
+  test("replaces multiple variables", () => {
+    expect(renderPromptTemplate("{{A}} {{B}}", { "{{A}}": "1", "{{B}}": "2" }))
+      .toBe("1 2");
+  });
+
+  test("returns template unchanged when no vars match", () => {
+    expect(renderPromptTemplate("Hello world", { "{{X}}": "Y" }))
+      .toBe("Hello world");
+  });
+
+  test("handles empty template", () => {
+    expect(renderPromptTemplate("", { "{{X}}": "Y" })).toBe("");
+  });
+
+  test("handles empty vars", () => {
+    expect(renderPromptTemplate("Hello", {})).toBe("Hello");
+  });
+});
+
+describe("extractPromptBlock", () => {
+  test("extracts content from prompt block", () => {
+    const md = "Some text\n```prompt\nHello world\n```\nMore text";
+    expect(extractPromptBlock(md)).toBe("Hello world");
+  });
+
+  test("returns trimmed markdown when no prompt block", () => {
+    expect(extractPromptBlock("  Just plain text  ")).toBe("Just plain text");
+  });
+
+  test("handles unclosed prompt block", () => {
+    const md = "```prompt\nIncomplete block";
+    expect(extractPromptBlock(md)).toBe("Incomplete block");
+  });
+
+  test("handles empty prompt block", () => {
+    const md = "```prompt\n```";
+    expect(extractPromptBlock(md)).toBe("");
+  });
+
+  test("extracts multiline content", () => {
+    const md = "```prompt\nLine 1\nLine 2\nLine 3\n```";
+    expect(extractPromptBlock(md)).toBe("Line 1\nLine 2\nLine 3");
+  });
+});
diff --git a/src/lib/__tests__/utils.test.ts b/src/lib/__tests__/utils.test.ts
new file mode 100644
index 00000000..f93a97cf
--- /dev/null
+++ b/src/lib/__tests__/utils.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+
+import { formatTime, formatBytes } from "../utils";
+
+describe("formatTime", () => {
+  test("parses dash-separated format", () => {
+    const result = formatTime("2026-02-17T14-30-00");
+    // Should produce a valid date-time string
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+    expect(result).toContain("2026");
+    expect(result).toContain("14:30:00");
+  });
+
+  test("parses ISO 8601 format", () => {
+    const result = formatTime("2026-03-01T09:15:30Z");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+    expect(result).toContain("2026");
+  });
+
+  test("returns original string for invalid input", () => {
+    expect(formatTime("not a date")).toBe("not a date");
+  });
+
+  test("returns original for empty string", () => {
+    expect(formatTime("")).toBe("");
+  });
+
+  test("handles RFC3339 with timezone offset", () => {
+    const result = formatTime("2026-01-15T10:00:00+08:00");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+  });
+});
+
+describe("formatBytes", () => {
+  test("formats zero bytes", () => {
+    expect(formatBytes(0)).toBe("0 B");
+  });
+
+  test("formats negative bytes as 0 B", () => {
+    expect(formatBytes(-100)).toBe("0 B");
+  });
+
+  test("formats bytes", () => {
+    expect(formatBytes(500)).toBe("500.0 B");
+  });
+
+  test("formats kilobytes", () => {
+    expect(formatBytes(1024)).toBe("1.0 KB");
+    expect(formatBytes(1536)).toBe("1.5 KB");
+  });
+
+  test("formats megabytes", () => {
+    expect(formatBytes(1048576)).toBe("1.0 MB");
+  });
+
+  test("formats gigabytes", () => {
+    expect(formatBytes(1073741824)).toBe("1.0 GB");
+  });
+
+  test("large values stay in GB", () => {
+    // 2 TB should still show as GB since GB is the largest unit
+    expect(formatBytes(2 * 1073741824)).toBe("2.0 GB");
+  });
+});