@team-agent/installer 0.3.21 → 0.3.22

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.21"
+version = "0.3.22"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.21"
+version = "0.3.22"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/emit.rs

@@ -218,7 +218,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("fallback-send-leader") => "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]\n\nEmergency one-shot fallback only after a leader-bound MCP send transport failure; restart-agent after use.".to_string(),
         Some("fallback-report-result") => "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]\n\nEmergency one-shot fallback only after a report_result MCP transport failure; persists the result DB row, then restart-agent after use.".to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
-        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]".to_string(),
+        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n默认输出: worker,空闲|工作|错误；错误细分走 status --summary".to_string(),
         Some("stop") => "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("restart") => "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]".to_string(),
@@ -1663,6 +1663,14 @@ mod tests {
         }
     }
 
+    #[test]
+    fn status_help_mentions_summary_for_error_details() {
+        assert!(
+            command_help(Some("status")).contains("错误细分走 status --summary"),
+            "status help must tell users where detailed error classes live"
+        );
+    }
+
     #[test]
     fn ux_quick_start_workspace_resolves_relative_agents_dir_inside_workspace() {
         let cwd = tmp_workspace();

package/crates/team-agent/src/cli/mod.rs

@@ -269,6 +269,21 @@ pub mod lifecycle_port {
         error: Option<String>,
     }
 
+    #[derive(Debug)]
+    struct OwnedShutdownEndpoint {
+        endpoint: String,
+        socket_file: Option<PathBuf>,
+    }
+
+    #[derive(Debug, Default)]
+    struct OwnedEndpointCleanup {
+        residual_files: Vec<String>,
+        removed_files: Vec<String>,
+        skipped_files: Vec<String>,
+        remaining_sessions: Vec<String>,
+        error: Option<String>,
+    }
+
     fn push_unique_session(
         sessions: &mut Vec<crate::transport::SessionName>,
         session: crate::transport::SessionName,
@@ -419,6 +434,119 @@ pub mod lifecycle_port {
         }
     }
 
+    fn owned_shutdown_endpoint(
+        workspace: &Path,
+        state: &Value,
+        transport: &dyn crate::transport::Transport,
+    ) -> Option<OwnedShutdownEndpoint> {
+        if state_uses_external_leader(state) {
+            return None;
+        }
+        if state.get("tmux_socket_source").and_then(Value::as_str) == Some("leader_env") {
+            return None;
+        }
+        let endpoint = legacy_worker_tmux_endpoint(state)
+            .map(str::to_string)
+            .or_else(|| transport.tmux_endpoint())
+            .unwrap_or_else(|| crate::tmux_backend::socket_name_for_workspace(workspace));
+        if endpoint.is_empty() || endpoint == "default" {
+            return None;
+        }
+        let workspace_socket = crate::tmux_backend::socket_name_for_workspace(workspace);
+        let source = state.get("tmux_socket_source").and_then(Value::as_str);
+        let owned = source == Some("workspace")
+            || source.is_none()
+                && endpoint_matches_workspace_socket(&endpoint, workspace, &workspace_socket);
+        if !owned {
+            return None;
+        }
+        let socket_file = socket_file_for_endpoint(&endpoint);
+        Some(OwnedShutdownEndpoint {
+            endpoint,
+            socket_file,
+        })
+    }
+
+    fn endpoint_matches_workspace_socket(
+        endpoint: &str,
+        workspace: &Path,
+        workspace_socket: &str,
+    ) -> bool {
+        if endpoint == workspace_socket {
+            return true;
+        }
+        let Some(workspace_path) = crate::tmux_backend::socket_path_for_workspace(workspace) else {
+            return false;
+        };
+        Path::new(endpoint) == workspace_path
+    }
+
+    fn socket_file_for_endpoint(endpoint: &str) -> Option<PathBuf> {
+        if Path::new(endpoint).is_absolute() {
+            Some(PathBuf::from(endpoint))
+        } else {
+            crate::tmux_backend::socket_path_for_name(endpoint)
+        }
+    }
+
+    fn cleanup_owned_empty_endpoint(
+        transport: &dyn crate::transport::Transport,
+        endpoint: &OwnedShutdownEndpoint,
+        event_log: &crate::event_log::EventLog,
+    ) -> OwnedEndpointCleanup {
+        let mut cleanup = OwnedEndpointCleanup::default();
+        cleanup.remaining_sessions = transport
+            .list_targets()
+            .unwrap_or_default()
+            .into_iter()
+            .map(|pane| pane.session.as_str().to_string())
+            .collect::<std::collections::BTreeSet<_>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        if !cleanup.remaining_sessions.is_empty() {
+            if let Some(path) = endpoint.socket_file.as_ref() {
+                cleanup.skipped_files.push(path.display().to_string());
+            }
+            let _ = event_log.write(
+                "shutdown.owned_endpoint_cleanup_skipped",
+                json!({
+                    "endpoint": endpoint.endpoint,
+                    "reason": "sessions_remain",
+                    "remaining_sessions": cleanup.remaining_sessions.clone(),
+                    "skipped_files": cleanup.skipped_files.clone(),
+                }),
+            );
+            return cleanup;
+        }
+        if let Err(error) = transport.kill_server() {
+            cleanup.error = Some(error.to_string());
+        }
+        if let Some(path) = endpoint.socket_file.as_ref() {
+            if path.exists() {
+                match std::fs::remove_file(path) {
+                    Ok(()) => cleanup.removed_files.push(path.display().to_string()),
+                    Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                    Err(error) => {
+                        cleanup.error.get_or_insert_with(|| error.to_string());
+                    }
+                }
+            }
+            if path.exists() {
+                cleanup.residual_files.push(path.display().to_string());
+            }
+        }
+        let _ = event_log.write(
+            "shutdown.owned_endpoint_cleanup",
+            json!({
+                "endpoint": endpoint.endpoint,
+                "removed_files": cleanup.removed_files.clone(),
+                "residual_files": cleanup.residual_files.clone(),
+                "error": cleanup.error.clone(),
+            }),
+        );
+        cleanup
+    }
+
     pub fn shutdown_with_transport(
         workspace: &Path,
         keep_logs: bool,
@@ -506,6 +634,7 @@ pub mod lifecycle_port {
                     kill_error = Some(error.to_string());
                 }
             }
+            let _ = crate::lifecycle::display::close_team_display_backends(&run_workspace, session);
         }
         deadline.check("reap_workspace_residuals")?;
         reap_workspace_process_residuals(
@@ -539,6 +668,20 @@ pub mod lifecycle_port {
         if let Some(error) = session_residual_error {
             kill_error.get_or_insert(error);
         }
+        let event_log = crate::event_log::EventLog::new(&run_workspace);
+        let owned_endpoint = owned_shutdown_endpoint(&run_workspace, &state, transport);
+        let owned_cleanup = owned_endpoint
+            .as_ref()
+            .map(|endpoint| cleanup_owned_empty_endpoint(transport, endpoint, &event_log))
+            .unwrap_or_default();
+        if let Some(error) = owned_cleanup.error.as_ref() {
+            kill_error.get_or_insert_with(|| error.clone());
+        }
+        let owned_file_residuals = owned_cleanup
+            .residual_files
+            .iter()
+            .map(|path| json!({ "path": path }))
+            .collect::<Vec<_>>();
         deadline.check("process_residuals")?;
         // C-①: the post-verify gets ONE fresh verification snapshot (reaps changed
         // the world; #248 post-verify facts must be current, not the entry view).
@@ -597,7 +740,8 @@ pub mod lifecycle_port {
         let session_killed = !killed_sessions.is_empty()
             && kill_error.is_none()
             && session_residuals.is_empty()
-            && process_residuals.is_empty();
+            && process_residuals.is_empty()
+            && owned_file_residuals.is_empty();
         mark_agents_stopped(&mut state);
         deadline.check("save_state")?;
         if team.is_some() {
@@ -624,6 +768,7 @@ pub mod lifecycle_port {
             kill_error: kill_error.is_some(),
             session_residuals: !session_residuals.is_empty(),
             process_residuals: !process_residuals.is_empty(),
+            owned_file_residuals: !owned_file_residuals.is_empty(),
             cleanup_truth_degraded,
             coordinator_timeout,
             coordinator_stop_ok: stopped.as_ref().map(|stopped| stopped.ok),
@@ -655,6 +800,10 @@ pub mod lifecycle_port {
                     "verification_degraded": verification_degraded,
                     "probe_timeout_kind": probe_timeout_kind,
                     "probe_timeout": probe_timeout_value,
+                    "owned_endpoint": owned_endpoint.as_ref().map(|endpoint| endpoint.endpoint.clone()),
+                    "owned_files_removed": owned_cleanup.removed_files.clone(),
+                    "owned_files_skipped": owned_cleanup.skipped_files.clone(),
+                    "owned_file_residuals": owned_file_residuals.clone(),
                 }),
             )
             .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -675,6 +824,7 @@ pub mod lifecycle_port {
             "residuals": {
                 "sessions": session_residuals,
                 "processes": process_residuals,
+                "owned_files": owned_file_residuals,
             },
             "error": kill_error,
             "coordinator": {
@@ -706,6 +856,7 @@ pub mod lifecycle_port {
         pub(crate) kill_error: bool,
         pub(crate) session_residuals: bool,
         pub(crate) process_residuals: bool,
+        pub(crate) owned_file_residuals: bool,
         pub(crate) cleanup_truth_degraded: bool,
         pub(crate) coordinator_timeout: bool,
         pub(crate) coordinator_stop_ok: Option<bool>,
@@ -724,6 +875,7 @@ pub mod lifecycle_port {
             && !input.kill_error
             && !input.session_residuals
             && !input.process_residuals
+            && !input.owned_file_residuals
             && !input.cleanup_truth_degraded;
         if ok {
             return ShutdownOutcome {
@@ -736,7 +888,11 @@ pub mod lifecycle_port {
             ("timeout", Some("stop_coordinator"))
         } else if input.cleanup_truth_degraded {
             ("partial", Some("os_probe"))
-        } else if input.kill_error {
+        } else if input.kill_error
+            || input.session_residuals
+            || input.process_residuals
+            || input.owned_file_residuals
+        {
             ("failed", None)
         } else {
             ("partial", None)

package/crates/team-agent/src/cli/status.rs

@@ -145,6 +145,67 @@ pub fn format_status_summary(data: &Value) -> String {
     )
 }
 
+pub fn format_status_csv(data: &Value) -> String {
+    let Some(agents) = data.get("agents").and_then(Value::as_object) else {
+        return String::new();
+    };
+    let health = data.get("agent_health").and_then(Value::as_object);
+    agents
+        .iter()
+        .map(|(agent_id, agent)| {
+            let status = csv_agent_status(agent_id, agent, health);
+            format!("{agent_id},{status}")
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn csv_agent_status(
+    agent_id: &str,
+    agent: &Value,
+    health: Option<&serde_json::Map<String, Value>>,
+) -> &'static str {
+    let raw = agent
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("")
+        .to_ascii_lowercase();
+    let hstatus = health
+        .and_then(|map| map.get(agent_id))
+        .and_then(|v| v.get("status"))
+        .and_then(Value::as_str)
+        .unwrap_or("")
+        .to_ascii_lowercase();
+    if matches!(raw.as_str(), "failed" | "error" | "spawn_failed")
+        || matches!(hstatus.as_str(), "failed" | "error" | "spawn_failed")
+        || matches!(raw.as_str(), "stopped" | "done")
+    {
+        return "错误";
+    }
+    let pane_present = agent
+        .get("pane_id")
+        .and_then(Value::as_str)
+        .filter(|pane| !pane.is_empty())
+        .is_some()
+        || agent
+            .pointer("/display/pane_id")
+            .and_then(Value::as_str)
+            .filter(|pane| !pane.is_empty())
+            .is_some();
+    if matches!(raw.as_str(), "running" | "busy" | "working") && !pane_present {
+        return "错误";
+    }
+    if raw == "idle" || hstatus == "idle" {
+        return "空闲";
+    }
+    if matches!(raw.as_str(), "running" | "busy" | "working")
+        || matches!(hstatus.as_str(), "running" | "working" | "busy")
+    {
+        return "工作";
+    }
+    "错误"
+}
+
 /// `_latest_result_line`(`commands.py:333-337`):agent_id/summary/created_at 渲染单行。
 /// summary `\n`→` ` 后 [:80] 截断、空 → `-`;agent_id 空 → `-`;created_at 经 age_text。
 pub(crate) fn format_latest_result(value: &Value) -> String {

package/crates/team-agent/src/cli/status_port.rs

@@ -127,8 +127,8 @@ use rusqlite::params;
                 format_agent_status(workspace, &status, agent)
             }
             None => {
-                let status = status_scoped(workspace, state, owner_team_id, true, false)?;
-                Ok(crate::cli::format_status_summary(&status))
+                let status = status_scoped(workspace, state, owner_team_id, false, false)?;
+                Ok(crate::cli::format_status_csv(&status))
             }
         }
     }

package/crates/team-agent/src/cli/tests/base.rs

@@ -363,6 +363,32 @@ latest result: none";
         assert!(!line2.contains("interacted"), "no marker when interacted==0");
     }
 
+    #[test]
+    fn format_status_csv_preserves_agent_order_and_collapses_errors() {
+        let data = json!({
+            "agents": {
+                "zeta": {"status": "idle", "pane_id": "%1"},
+                "alpha": {"status": "running", "pane_id": "%2"},
+                "err_failed": {"status": "failed", "pane_id": "%3"},
+                "err_missing_pane": {"status": "running"},
+                "err_unknown": {"status": "mystery", "pane_id": "%4"},
+                "err_stopped": {"status": "stopped", "pane_id": "%5"}
+            },
+            "agent_health": {
+                "alpha": {"status": "working"}
+            }
+        });
+        assert_eq!(
+            format_status_csv(&data),
+            "zeta,空闲\nalpha,工作\nerr_failed,错误\nerr_missing_pane,错误\nerr_unknown,错误\nerr_stopped,错误"
+        );
+    }
+
+    #[test]
+    fn format_status_csv_zero_workers_is_empty() {
+        assert_eq!(format_status_csv(&json!({"agents": {}, "agent_health": {}})), "");
+    }
+
     // =========================================================================
     // emit(helpers.py:12-23):--json sort_keys+indent=2 | dict 逐键 | 非 dict
     // =========================================================================