fix(cli): report scheduling failure when sandbox create times out

When the sandbox pod cannot be scheduled, the readiness timeout message
only showed Ready=False (ConfigurationPending) although the sandbox status
already carried PodScheduled=False with the scheduler's reason. Prefer a
failing PodScheduled condition when summarizing why the sandbox is not
ready, and fall back to the Ready condition as before.

Signed-off-by: Jane Chen <gojane20@gmail.com>

Author: u0324020

crates/openshell-cli/src/commands/common.rs

@@ -573,13 +573,29 @@ pub fn print_sandbox_header(
 // Sandbox provisioning helpers
 // ---------------------------------------------------------------------------
 
+/// Summarize why a sandbox is not ready yet.
+///
+/// A failing `PodScheduled` condition (for example `Unschedulable` with the
+/// scheduler's "0/N nodes are available" message) is preferred because the
+/// `Ready` condition may be replaced by a less specific reason such as
+/// `ConfigurationPending` while the pod cannot be placed.
 pub fn ready_false_condition_message(
     status: Option<&openshell_core::proto::SandboxStatus>,
 ) -> Option<String> {
-    let condition = status?.conditions.iter().find(|condition| {
-        condition.r#type == "Ready" && condition.status.eq_ignore_ascii_case("false")
-    })?;
+    let conditions = &status?.conditions;
+    let false_condition_message = |condition_type: &str| {
+        conditions
+            .iter()
+            .filter(|condition| {
+                condition.r#type == condition_type && condition.status.eq_ignore_ascii_case("false")
+            })
+            .find_map(condition_summary)
+    };
+
+    false_condition_message("PodScheduled").or_else(|| false_condition_message("Ready"))
+}
 
+fn condition_summary(condition: &openshell_core::proto::SandboxCondition) -> Option<String> {
     if condition.message.is_empty() {
         if condition.reason.is_empty() {
             None

crates/openshell-cli/src/run.rs

@@ -8258,6 +8258,93 @@ mod tests {
         assert!(ready_false_condition_message(Some(&status)).is_none());
     }
 
+    #[test]
+    fn ready_false_condition_message_prefers_unschedulable_pod_scheduled_condition() {
+        let status = SandboxStatus {
+            agent_pod: "pending-pod".to_string(),
+            conditions: vec![
+                SandboxCondition {
+                    r#type: "Ready".to_string(),
+                    status: "False".to_string(),
+                    reason: "ConfigurationPending".to_string(),
+                    message: "Waiting for effective configuration validation".to_string(),
+                    transition_time: None,
+                },
+                SandboxCondition {
+                    r#type: "PodScheduled".to_string(),
+                    status: "False".to_string(),
+                    reason: "Unschedulable".to_string(),
+                    message: "0/11 nodes are available: 11 Insufficient cpu.".to_string(),
+                    transition_time: None,
+                },
+            ],
+            ..Default::default()
+        };
+
+        assert_eq!(
+            ready_false_condition_message(Some(&status)).as_deref(),
+            Some("Unschedulable: 0/11 nodes are available: 11 Insufficient cpu.")
+        );
+    }
+
+    #[test]
+    fn ready_false_condition_message_ignores_scheduled_pod_condition() {
+        let status = SandboxStatus {
+            agent_pod: "scheduled-pod".to_string(),
+            conditions: vec![
+                SandboxCondition {
+                    r#type: "PodScheduled".to_string(),
+                    status: "True".to_string(),
+                    reason: String::new(),
+                    message: String::new(),
+                    transition_time: None,
+                },
+                SandboxCondition {
+                    r#type: "Ready".to_string(),
+                    status: "False".to_string(),
+                    reason: "ConfigurationPending".to_string(),
+                    message: "Waiting for effective configuration validation".to_string(),
+                    transition_time: None,
+                },
+            ],
+            ..Default::default()
+        };
+
+        assert_eq!(
+            ready_false_condition_message(Some(&status)).as_deref(),
+            Some("ConfigurationPending: Waiting for effective configuration validation")
+        );
+    }
+
+    #[test]
+    fn ready_false_condition_message_falls_back_when_pod_scheduled_has_no_detail() {
+        let status = SandboxStatus {
+            agent_pod: "pending-pod".to_string(),
+            conditions: vec![
+                SandboxCondition {
+                    r#type: "PodScheduled".to_string(),
+                    status: "False".to_string(),
+                    reason: String::new(),
+                    message: String::new(),
+                    transition_time: None,
+                },
+                SandboxCondition {
+                    r#type: "Ready".to_string(),
+                    status: "False".to_string(),
+                    reason: "ConfigurationPending".to_string(),
+                    message: String::new(),
+                    transition_time: None,
+                },
+            ],
+            ..Default::default()
+        };
+
+        assert_eq!(
+            ready_false_condition_message(Some(&status)).as_deref(),
+            Some("ConfigurationPending")
+        );
+    }
+
     #[test]
     fn provisioning_timeout_message_includes_condition_and_gpu_hint() {
         let resource_requirements = ResourceRequirements {