feat(agent): detect availability via session/new probe and assistant-first identity

crates/aionui-ai-agent/src/capability/cli_process/mod.rs

@@ -92,38 +92,44 @@ impl CliAgentProcess {
         }
     }
 
-    /// Gracefully terminate the subprocess.
+    /// Gracefully terminate the subprocess **and any descendants in its
+    /// process group**.
     ///
     /// 1. Close stdin
-    /// 2. Wait up to `grace_period` for the process to exit on its own
-    /// 3. If still running after grace period, send SIGKILL
+    /// 2. Wait up to `grace_period` for the leader to exit on its own
+    /// 3. SIGKILL the whole process group regardless of whether the leader
+    ///    has already exited — wrapper CLIs (`npm exec ...`) routinely fork
+    ///    a grandchild (`openclaw-acp`) that survives leader exit, and only
+    ///    a group-wide kill reaps it
     pub async fn kill(&self, grace_period: Duration) -> Result<(), AgentError> {
         // Close stdin first to signal the child
         self.close_stdin().await;
 
-        // Wait for graceful exit within the grace period
+        // Wait up to the grace period for the leader to exit on its own.
+        // Even if it does, we still issue a group-wide SIGKILL below — the
+        // leader exiting tells us nothing about its grandchildren.
         let mut rx = self.exit_rx.clone();
-        let exited = tokio::time::timeout(grace_period, async {
-            // If already exited, return immediately
+        let _ = tokio::time::timeout(grace_period, async {
             if rx.borrow().is_some() {
                 return;
             }
-            // Wait for state change
             let _ = rx.changed().await;
         })
         .await;
 
-        if exited.is_ok() && self.exit_rx.borrow().is_some() {
-            debug!(pid = self.pid, "CLI process exited gracefully");
-            return Ok(());
+        // Always sweep the process group. `force_kill` treats ESRCH as
+        // success, so this is idempotent when the leader (and group) are
+        // already gone.
+        if self.exit_rx.borrow().is_some() {
+            debug!(pid = self.pid, "CLI leader already exited; sweeping process group");
+        } else {
+            warn!(pid = self.pid, "Grace period expired, sending SIGKILL");
         }
-
-        // Force kill
-        warn!(pid = self.pid, "Grace period expired, sending SIGKILL");
         force_kill(self.pid, self.process_group_id)?;
 
         // Wait for the exit monitor to observe process termination so callers
-        // do not race a still-live child after force-kill returns.
+        // do not race a still-live leader after force-kill returns. Skip the
+        // wait if the leader had already exited before our sweep.
         let mut rx = self.exit_rx.clone();
         tokio::time::timeout(Duration::from_secs(5), async {
             if rx.borrow().is_some() {
@@ -137,6 +143,24 @@ impl CliAgentProcess {
         Ok(())
     }
 
+    /// Unconditionally force-kill this process and its entire process group.
+    ///
+    /// Unlike [`kill`](Self::kill), this neither closes stdin first nor waits
+    /// for a graceful exit, and it does **not** short-circuit when the direct
+    /// child has already exited. It always signals the process *group*, so a
+    /// descendant reparented to init after the launcher exited (e.g. an
+    /// npx-spawned ACP grandchild) is still reaped.
+    ///
+    /// Used by throwaway probe connections: the node/npx launcher exits on its
+    /// own once the ACP transport closes, but `kill_on_drop` reaps only the
+    /// direct child, leaving the grandchild (`codex-acp`, `codebuddy --acp`, …)
+    /// to leak as an orphan.
+    pub fn force_kill_tree(&self) {
+        if let Err(e) = force_kill(self.pid, self.process_group_id) {
+            warn!(pid = self.pid, error = %e, "force_kill_tree failed");
+        }
+    }
+
     /// Check whether the subprocess is still running.
     #[allow(dead_code)] // Complete CliProcess lifecycle API
     pub fn is_running(&self) -> bool {
@@ -449,6 +473,64 @@ pub(super) mod tests {
         assert!(result.is_err());
     }
 
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn force_kill_tree_reaps_grandchild_after_leader_exits() {
+        // Reproduces the probe leak: the spawned launcher backgrounds a
+        // long-lived grandchild then exits 0 on its own (mirrors node/npx
+        // forking the real ACP binary then returning once the transport
+        // closes). `kill_on_drop` would only reap the direct child; the
+        // grandchild reparents to init and leaks. `force_kill_tree` must
+        // signal the whole process group and take the grandchild with it.
+        let marker = tempfile::NamedTempFile::new().unwrap();
+        let marker_path = marker.path().to_string_lossy().into_owned();
+
+        let config = CommandSpec {
+            command: "sh".into(),
+            args: vec![
+                "-c".into(),
+                "sleep 60 & child=$!; printf '%s' \"$child\" > \"$1\"; exit 0".into(),
+                "probe-grandchild-cleanup".into(),
+                marker_path.clone(),
+            ],
+            env: vec![],
+            cwd: None,
+        };
+        let proc = spawn_sdk_test_process(config).await;
+
+        // Leader exits on its own; wait for the exit monitor to observe it.
+        timeout(Duration::from_secs(5), proc.wait_for_exit())
+            .await
+            .expect("leader should exit promptly");
+
+        let child_pid: u32 = std::fs::read_to_string(marker.path())
+            .expect("grandchild pid marker should exist")
+            .trim()
+            .parse()
+            .expect("grandchild pid should be numeric");
+
+        fn is_pid_alive(pid: u32) -> bool {
+            let result = unsafe { libc::kill(pid as i32, 0) };
+            if result == 0 {
+                return true;
+            }
+            !matches!(std::io::Error::last_os_error().raw_os_error(), Some(libc::ESRCH))
+        }
+
+        assert!(is_pid_alive(child_pid), "grandchild pid={child_pid} should be alive");
+
+        proc.force_kill_tree();
+
+        let deadline = std::time::Instant::now() + Duration::from_secs(5);
+        while is_pid_alive(child_pid) && std::time::Instant::now() < deadline {
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
+        assert!(
+            !is_pid_alive(child_pid),
+            "grandchild pid={child_pid} should be reaped by force_kill_tree",
+        );
+    }
+
     #[tokio::test]
     async fn pid_is_nonzero_for_valid_process() {
         let config = simple_script_config("sleep 10");

crates/aionui-ai-agent/src/factory/acp.rs

@@ -677,7 +677,19 @@ mod tests {
             yolo_id: None,
             sort_order: 0,
             team_capable: false,
+            last_check_status: None,
+            last_check_kind: None,
+            last_check_error_code: None,
+            last_check_error_message: None,
+            last_check_error_details: None,
+            last_check_guidance: None,
+            last_check_latency_ms: None,
+            last_check_at: None,
+            last_success_at: None,
+            last_failure_at: None,
             handshake: aionui_api_types::AgentHandshake::default(),
+            has_command_override: false,
+            env_override_key_count: 0,
         };
 
         let spec = resolve_agent_command_spec(

crates/aionui-ai-agent/src/factory/acp_assembler.rs

@@ -197,11 +197,11 @@ mod tests {
         let prompt = result.unwrap();
         assert!(prompt.contains("aion_create_team"));
         assert!(prompt.contains("aion_list_models"));
-        assert!(prompt.contains("hand off to the created Team conversation"));
-        assert!(!prompt.contains("Immediately"));
-        assert!(!prompt.contains(
+        assert!(prompt.contains("only use returned assistant_id values with `team_spawn_agent`"));
+        assert!(prompt.contains(
             "use team tools (`team_spawn_agent`, `team_send_message`, `team_members`, `team_task_create`, etc.) to manage your team"
         ));
+        assert!(!prompt.contains("hand off to the created Team conversation"));
     }
 
     #[test]
@@ -247,7 +247,19 @@ mod tests {
             yolo_id: None,
             sort_order: 0,
             team_capable: true,
+            last_check_status: None,
+            last_check_kind: None,
+            last_check_error_code: None,
+            last_check_error_message: None,
+            last_check_error_details: None,
+            last_check_guidance: None,
+            last_check_latency_ms: None,
+            last_check_at: None,
+            last_success_at: None,
+            last_failure_at: None,
             handshake: aionui_api_types::AgentHandshake::default(),
+            has_command_override: false,
+            env_override_key_count: 0,
         }
     }
 

crates/aionui-ai-agent/src/factory/aionrs.rs

@@ -1040,11 +1040,11 @@ mod tests {
         let prompt = overrides.system_prompt.as_deref().unwrap();
         assert!(prompt.contains("aion_create_team"));
         assert!(prompt.contains("aion_list_models"));
-        assert!(prompt.contains("hand off to the created Team conversation"));
-        assert!(!prompt.contains("Immediately"));
-        assert!(!prompt.contains(
+        assert!(prompt.contains("only use returned assistant_id values with `team_spawn_agent`"));
+        assert!(prompt.contains(
             "use team tools (`team_spawn_agent`, `team_send_message`, `team_members`, `team_task_create`, etc.) to manage your team"
         ));
+        assert!(!prompt.contains("hand off to the created Team conversation"));
     }
 
     #[test]

crates/aionui-ai-agent/src/lib.rs

@@ -39,6 +39,7 @@ pub use protocol::events::AgentStreamEvent;
 pub use protocol::send_error::AgentSendError;
 pub use registry::{AgentRegistry, UnavailableReason};
 pub use routes::{AgentRouterState, RemoteAgentRouterState, agent_routes, remote_agent_routes};
+pub use services::AgentAvailabilityFeedbackPort;
 pub use services::AgentService;
 pub use services::RemoteAgentService;
 pub use session_context::{

crates/aionui-ai-agent/src/manager/acp/codex_sandbox.rs

@@ -236,7 +236,19 @@ mod tests {
             yolo_id: Some("full-access".into()),
             sort_order: 3110,
             team_capable: true,
+            last_check_status: None,
+            last_check_kind: None,
+            last_check_error_code: None,
+            last_check_error_message: None,
+            last_check_error_details: None,
+            last_check_guidance: None,
+            last_check_latency_ms: None,
+            last_check_at: None,
+            last_success_at: None,
+            last_failure_at: None,
             handshake: aionui_api_types::AgentHandshake::default(),
+            has_command_override: false,
+            env_override_key_count: 0,
         }
     }
 

crates/aionui-ai-agent/src/manager/acp/mode_normalize.rs

@@ -71,7 +71,19 @@ mod tests {
             yolo_id: yolo_id.map(ToOwned::to_owned),
             sort_order: 3130,
             team_capable: false,
+            last_check_status: None,
+            last_check_kind: None,
+            last_check_error_code: None,
+            last_check_error_message: None,
+            last_check_error_details: None,
+            last_check_guidance: None,
+            last_check_latency_ms: None,
+            last_check_at: None,
+            last_success_at: None,
+            last_failure_at: None,
             handshake: AgentHandshake::default(),
+            has_command_override: false,
+            env_override_key_count: 0,
         }
     }
 

crates/aionui-ai-agent/src/persistence/acp_session_sync.rs

@@ -277,7 +277,6 @@ mod tests {
         let repo: Arc<dyn IAcpSessionRepository> = Arc::new(SqliteAcpSessionRepository::new(db.pool().clone()));
         repo.create(&CreateAcpSessionParams {
             conversation_id: "conv-1",
-            agent_backend: "claude",
             agent_source: "builtin",
             agent_id: "2d23ff1c",
         })

crates/aionui-ai-agent/src/protocol/cli_detect.rs

@@ -2,30 +2,33 @@ use std::sync::Arc;
 use std::time::Instant;
 
 use crate::registry::AgentRegistry;
-use aionui_api_types::{AcpHealthCheckResponse, AgentMetadata};
+use aionui_api_types::AgentMetadata;
 use aionui_runtime::resolve_command_path;
 
+pub(crate) struct CliHealthCheckResult {
+    pub available: bool,
+    pub error: Option<String>,
+}
+
 /// Perform a health check for an ACP backend.
 ///
-/// Checks CLI availability and measures detection latency.
-pub(crate) async fn health_check(registry: &Arc<AgentRegistry>, backend: &str) -> AcpHealthCheckResponse {
+/// Checks CLI availability and returns an availability/error pair.
+pub(crate) async fn health_check(registry: &Arc<AgentRegistry>, backend: &str) -> CliHealthCheckResult {
     let start = Instant::now();
 
     let Some(meta) = registry.find_builtin_by_backend(backend).await else {
-        return AcpHealthCheckResponse {
+        return CliHealthCheckResult {
             available: false,
-            latency: None,
             error: Some(format!("No agent_metadata row for backend '{backend}'")),
         };
     };
 
     let path = probe_command(&meta);
-    let latency_ms = start.elapsed().as_millis() as u64;
+    let _latency_ms = start.elapsed().as_millis() as u64;
     let available = path.is_some();
 
-    AcpHealthCheckResponse {
+    CliHealthCheckResult {
         available,
-        latency: Some(latency_ms),
         error: if available {
             None
         } else {
@@ -35,6 +38,67 @@ pub(crate) async fn health_check(registry: &Arc<AgentRegistry>, backend: &str) -
 }
 
 fn probe_command(meta: &AgentMetadata) -> Option<String> {
+    if let Some(path) = meta.resolved_command.as_ref() {
+        return Some(path.to_string_lossy().into_owned());
+    }
     let cmd = meta.command.as_deref()?;
     resolve_command_path(cmd).map(|p| p.to_string_lossy().into_owned())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use aionui_api_types::{
+        AgentHandshake, AgentSnapshotCheckKind, AgentSnapshotCheckStatus, AgentSource, AgentSourceInfo, BehaviorPolicy,
+    };
+    use aionui_common::AgentType;
+    use std::path::PathBuf;
+
+    fn metadata_with_resolved_command() -> AgentMetadata {
+        AgentMetadata {
+            id: "agent-codex".into(),
+            icon: None,
+            name: "Codex CLI".into(),
+            name_i18n: None,
+            description: None,
+            description_i18n: None,
+            backend: Some("codex".into()),
+            agent_type: AgentType::Acp,
+            agent_source: AgentSource::Builtin,
+            agent_source_info: AgentSourceInfo {
+                binary_name: Some("codex".into()),
+                ..Default::default()
+            },
+            enabled: true,
+            available: true,
+            command: None,
+            resolved_command: Some(PathBuf::from("codex-acp")),
+            args: vec![],
+            env: vec![],
+            native_skills_dirs: None,
+            behavior_policy: BehaviorPolicy::default(),
+            yolo_id: None,
+            sort_order: 0,
+            team_capable: false,
+            last_check_status: Some(AgentSnapshotCheckStatus::Online),
+            last_check_kind: Some(AgentSnapshotCheckKind::Startup),
+            last_check_error_code: None,
+            last_check_error_message: None,
+            last_check_error_details: None,
+            last_check_guidance: None,
+            last_check_latency_ms: None,
+            last_check_at: None,
+            last_success_at: None,
+            last_failure_at: None,
+            handshake: AgentHandshake::default(),
+            has_command_override: false,
+            env_override_key_count: 0,
+        }
+    }
+
+    #[test]
+    fn probe_command_uses_hydrated_resolved_command_when_spawn_command_is_empty() {
+        let meta = metadata_with_resolved_command();
+        assert_eq!(probe_command(&meta), Some("codex-acp".into()));
+    }
+}