@team-agent/installer 0.5.89 → 0.5.92

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.89"
+version = "0.5.92"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.89"
+version = "0.5.92"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -429,83 +429,6 @@ pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
-/// `cmd_collect`(`parser.py:292`)。
-#[cfg(test)]
-pub(crate) fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
-    cmd_collect_for_team(args, args.team.as_deref())
-}
-
-pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<CmdResult, CliError> {
-    let selected = match crate::state::selector::resolve_active_team(
-        &args.workspace,
-        team,
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": args.workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let value = match if team.is_some() {
-        messaging::collect_for_team(
-            &selected.run_workspace,
-            args.result_file.as_deref(),
-            false,
-            Some(&selected.team_key),
-        )
-    } else {
-        messaging::collect(&selected.run_workspace, args.result_file.as_deref(), false)
-    } {
-        Ok(value) => value,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": selected.run_workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let results = value.get("results").cloned().unwrap_or_else(|| json!({}));
-    let ok = value.get("ok").and_then(Value::as_bool).unwrap_or(true);
-    Ok(CmdResult::from_json(
-        json!({
-            "collected": [],
-            "collected_results": value.get("collected_results").cloned().unwrap_or_else(|| json!([])),
-            "coordinator": {
-                "ok": false,
-                "status": "not_required",
-            },
-            "delivered_messages": value.get("delivered_messages").cloned().unwrap_or_else(|| json!([])),
-            "invalid_results": value.get("invalid_results").cloned().unwrap_or_else(|| json!([])),
-            "ok": ok,
-            "results": results,
-            "state_file": value
-                .get("state_file")
-                .cloned()
-                .unwrap_or_else(|| {
-                    json!(selected
-                        .spec_workspace
-                        .as_deref()
-                        .unwrap_or(&selected.run_workspace)
-                        .join("team_state.md")
-                        .to_string_lossy()
-                        .to_string())
-                }),
-        }),
-        args.json,
-    ))
-}
-
 pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
     let selected = match crate::state::selector::resolve_active_team(
         &args.workspace,
@@ -577,7 +500,7 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
             .join(".team")
             .join("logs")
             .join("events.jsonl");
-        return Ok(CmdResult::from_json(
+        return Ok(crate::cli::triage::report(
             json!({
                 "event_log": event_log.to_string_lossy().to_string(),
                 "issues": issues,
@@ -595,9 +518,10 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
                 "suggested_repairs": suggested_repairs,
             }),
             args.json,
+            "diagnose",
         ));
     }
-    let selected = crate::state::selector::resolve_active_team(
+    let selected = crate::state::selector::resolve_active_team_readonly(
         &args.workspace,
         args.team.as_deref(),
         crate::state::selector::SelectorMode::RuntimeOnly,
@@ -632,7 +556,7 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
             Some(selected.team_key.as_str()),
         );
     let ok = issues.as_array().is_some_and(Vec::is_empty);
-    Ok(CmdResult::from_json(
+    Ok(crate::cli::triage::report(
         json!({
             "event_log": event_log.to_string_lossy().to_string(),
             "issues": issues,
@@ -650,6 +574,7 @@ pub fn cmd_diagnose(args: &DiagnoseArgs) -> Result<CmdResult, CliError> {
             "suggested_repairs": suggested_repairs,
         }),
         args.json,
+        "diagnose",
     ))
 }
 
@@ -846,14 +771,14 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 .mark(message_id, "delivered", None)
                 .map_err(crate::messaging::MessagingError::from)?;
         }
-        let _ = messaging::report_result(
+        let report = messaging::report_result(
             workspace,
             &json!({
                 "schema_version": "result_envelope_v1",
                 "task_id": "task_impl",
                 "agent_id": "fake_impl",
                 "status": "success",
-                "summary": "fake result collected",
+                "summary": "fake result finalized",
                 "changes": [],
                 "tests": [],
                 "risks": [],
@@ -861,25 +786,29 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 "next_actions": [],
             }),
         )?;
-    }
-    let mut collect = messaging::collect(workspace, None, false)?;
-    let collected = collect
-        .get("collected_results")
-        .and_then(Value::as_array)
-        .is_some_and(|items| !items.is_empty());
-    if let Some(obj) = collect.as_object_mut() {
-        obj.insert("collected".to_string(), Value::Bool(collected));
+        let auto_finalized = report
+            .get("finalization_status")
+            .and_then(Value::as_str)
+            == Some("auto_finalized");
+        let shutdown = fake_shutdown(workspace)?;
+        let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
+            && send.ok
+            && auto_finalized
+            && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
+        return Ok(json!({
+            "ok": ok,
+            "launch": launch,
+            "send": send_value,
+            "report": report,
+            "shutdown": shutdown,
+        }));
     }
     let shutdown = fake_shutdown(workspace)?;
-    let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
-        && send.ok
-        && collected
-        && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
     Ok(json!({
-        "ok": ok,
+        "ok": false,
         "launch": launch,
         "send": send_value,
-        "collect": collect,
+        "report": null,
         "shutdown": shutdown,
     }))
 }
@@ -1286,89 +1215,82 @@ pub fn cmd_inbox(args: &InboxArgs) -> Result<CmdResult, CliError> {
         &selected.run_workspace,
         &args.agent,
         args.limit,
-        args.since.as_deref(),
-        args.json,
         Some(&selected.team_key),
     )?;
     if args.json {
         Ok(CmdResult::from_json(value, true))
     } else {
-        Ok(CmdResult::human(format_inbox_human(
-            &selected.run_workspace,
-            &args.agent,
-            args.since.as_deref(),
-            &value,
-            Some(&selected.team_key),
-        )?))
+        Ok(CmdResult::human(format_inbox_human(&args.agent, &value)))
     }
 }
 
-fn format_inbox_human(
-    workspace: &Path,
-    agent: &str,
-    since: Option<&str>,
-    value: &Value,
-    owner_team_id: Option<&str>,
-) -> Result<String, CliError> {
+const INBOX_LINE_LIMIT_BYTES: usize = 160;
+
+fn clean_inbox_field(value: &str) -> String {
+    value.chars().filter(|ch| !ch.is_control()).collect()
+}
+
+fn truncate_inbox_line(line: &str) -> String {
+    if line.len() <= INBOX_LINE_LIMIT_BYTES {
+        return line.to_string();
+    }
+    let budget = INBOX_LINE_LIMIT_BYTES.saturating_sub("…".len());
+    let mut end = 0;
+    for (index, ch) in line.char_indices() {
+        let next = index + ch.len_utf8();
+        if next > budget {
+            break;
+        }
+        end = next;
+    }
+    format!("{}…", &line[..end])
+}
+
+fn format_inbox_human(agent: &str, value: &Value) -> String {
     let messages = value
         .get("messages")
         .and_then(Value::as_array)
         .cloned()
         .unwrap_or_default();
-    let mut lines = Vec::new();
     if messages.is_empty() {
-        let mut line = format!("{agent}: no messages");
-        if let Some(since) = since {
-            line.push_str(" since ");
-            line.push_str(since);
-        }
-        lines.push(line);
-    } else {
-        lines.push(format!("{agent}: {} message(s)", messages.len()));
-        for message in messages {
-            let sender = message.get("sender").and_then(Value::as_str).unwrap_or("-");
-            let content = message.get("content").and_then(Value::as_str).unwrap_or("");
-            let status = message.get("status").and_then(Value::as_str).unwrap_or("-");
-            let attempts = message
-                .get("delivery_attempts")
-                .and_then(Value::as_i64)
-                .unwrap_or(0);
-            let error = message.get("error").and_then(Value::as_str).unwrap_or("-");
-            lines.push(format!(
-                "- {sender}: {content} [status={status} attempts={attempts} error={error}]"
-            ));
-        }
-    }
-    let pending = uncollected_result_count(workspace, owner_team_id)?;
-    let mut note = "final results are not in inbox; use team-agent collect".to_string();
-    if pending > 0 {
-        note.push_str(&format!(" ({pending} uncollected result(s) pending)"));
-    }
-    lines.push(note);
-    Ok(lines.join("\n"))
-}
-
-fn uncollected_result_count(
-    workspace: &Path,
-    owner_team_id: Option<&str>,
-) -> Result<i64, CliError> {
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-    match owner_team_id {
-        Some(team) => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid') and owner_team_id = ?1",
-            [team],
-            |row| row.get::<_, i64>(0),
-        ),
-        None => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid')",
-            [],
-            |row| row.get::<_, i64>(0),
-        ),
+        return format!("{agent}: no messages");
     }
-    .map_err(|e| CliError::Runtime(e.to_string()))
+    messages
+        .iter()
+        .map(|message| {
+            let id = clean_inbox_field(
+                message
+                    .get("message_id")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let sender = clean_inbox_field(
+                message.get("sender").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let recipient = clean_inbox_field(
+                message
+                    .get("recipient")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let status = clean_inbox_field(
+                message.get("status").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let time = clean_inbox_field(
+                message
+                    .get("created_at")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let summary = clean_inbox_field(
+                message.get("summary").and_then(Value::as_str).unwrap_or(""),
+            );
+            truncate_inbox_line(&format!(
+                "[{id}] [{sender} -> {recipient}] [{status}] [{time}] [{summary}]"
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
 /// `cmd_takeover`(`commands.py:152`)。
@@ -1593,15 +1515,21 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
             args.team.as_deref(),
             Some("comms"),
         )?;
+        let result = CmdResult::from_json(value, args.json);
         if !args.json {
-            let json_tail = serde_json::to_string_pretty(&sort_json(&value))?;
-            return Ok(CmdResult::human(format!(
-                "{COMMS_BOUNDARY_TEXT}\n{json_tail}"
-            )));
+            let json_tail = match &result.output {
+                CmdOutput::Json(value) => serde_json::to_string_pretty(&sort_json(value))?,
+                _ => String::new(),
+            };
+            return Ok(CmdResult {
+                output: CmdOutput::Human(format!("{COMMS_BOUNDARY_TEXT}\n{json_tail}")),
+                ..result
+            });
         }
-        return Ok(CmdResult::from_json(value, true));
+        return Ok(result);
     }
-    let value = if matches!(args.gate, Some(DoctorGate::Orphans)) {
+    let default_report = args.gate.is_none() && !args.cleanup_orphans && !args.fix_schema;
+    let mut value = if matches!(args.gate, Some(DoctorGate::Orphans)) {
         crate::diagnose::orphans::orphan_gate_json(&args.workspace, args.fix, args.confirm)?
     } else if args.cleanup_orphans {
         crate::diagnose::orphans::cleanup_orphans_json(&args.workspace, args.confirm)?
@@ -1621,7 +1549,32 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
         );
         value
     };
-    Ok(CmdResult::from_json(value, args.json))
+    if default_report {
+        let base_ok = value.get("ok").and_then(Value::as_bool).unwrap_or(false);
+        let has_blocking_issues = value
+            .get("issues")
+            .and_then(Value::as_array)
+            .is_some_and(|issues| {
+                issues.iter().any(|issue| {
+                    let id = issue
+                        .as_str()
+                        .or_else(|| issue.get("id").and_then(Value::as_str));
+                    id != Some("leader_not_attached")
+                })
+            });
+        if let Some(object) = value.as_object_mut() {
+            object.insert(
+                "ok".to_string(),
+                Value::Bool(base_ok && !has_blocking_issues),
+            );
+        }
+    }
+    let result = CmdResult::from_json(value, args.json);
+    Ok(if default_report && !args.json {
+        crate::cli::triage::human_result(result, "doctor")
+    } else {
+        result
+    })
 }
 
 #[cfg(test)]
@@ -1629,11 +1582,31 @@ mod tests {
     #![allow(clippy::unwrap_used)]
 
     use super::{
-        agent_pane_id, append_send_guidance, quickstart_human, send_command, split_shell_argv,
+        agent_pane_id, append_send_guidance, format_inbox_human, quickstart_human, send_command,
+        split_shell_argv,
     };
     use serde_json::{json, Value};
     use std::path::{Path, PathBuf};
 
+    #[test]
+    fn inbox_human_output_sanitizes_controls_and_caps_each_line() {
+        let value = json!({
+            "messages": [{
+                "message_id": "msg-\u{001b}[31m".repeat(20),
+                "sender": "sender\t\u{001b}[2J".repeat(20),
+                "recipient": "worker".repeat(20),
+                "status": "delivered",
+                "created_at": "2026-09-19T00:00:00Z",
+                "summary": "中".repeat(120)
+            }]
+        });
+        let output = format_inbox_human("worker", &value);
+        for line in output.lines() {
+            assert!(line.len() <= 160, "line is {} bytes: {line:?}", line.len());
+            assert!(!line.chars().any(char::is_control), "controls leaked: {line:?}");
+        }
+    }
+
     // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
     #[test]
     fn e13_quickstart_human_includes_attach_commands() {

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

@@ -96,12 +96,6 @@ pub(crate) fn classify_tmux_server_error(error_text: &str) -> &'static str {
 pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value, Value) {
     let mut issues = Vec::new();
     let mut repairs = Vec::new();
-    for issue in crate::topology::diagnose_topology_issues(state, backend) {
-        if let Some(id) = crate::topology::issue_id(&issue) {
-            repairs.push(topology_repair_hint(id));
-        }
-        issues.push(issue);
-    }
 
     if state
         .get("leader_receiver")
@@ -118,41 +112,63 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
         ));
     }
 
-    if let Some(session_name) = state
+    // Probe the session before any topology enumeration. A missing session is
+    // terminal for all window/pane/socket probes; repeating those tmux calls
+    // only pays the dead-socket timeout again on every layer. The persisted
+    // endpoint/socket split is state-only, so preserve that fact before the
+    // short-circuit without probing either dead endpoint.
+    let persisted_socket_conflict = crate::topology::endpoint_socket_conflict(state);
+    let session_unavailable = state
         .get("session_name")
         .and_then(Value::as_str)
         .filter(|s| !s.is_empty())
-    {
-        match backend.has_session(&crate::transport::SessionName::new(
-            session_name.to_string(),
-        )) {
-            Ok(true) => {}
-            Ok(false) => {
-                issues.push(json!("tmux_session_missing"));
-                repairs.push(recovery_hint(
-                    session_name,
-                    "tmux_session_missing",
-                    "team-agent restart",
-                ));
-            }
-            Err(error) => {
-                // 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B):
-                // when the transport error stderr matches "server exited
-                // unexpectedly", the physical layer that disappeared is
-                // the tmux server itself — not just this team's session.
-                // Surface `tmux_server_crashed` so the user's next
-                // action is a coordinator/host-level recovery, not a
-                // per-agent `restart <agent>`.
-                let error_str = error.to_string();
-                let issue_id = classify_tmux_server_error(&error_str);
-                issues.push(json!(issue_id));
-                let mut hint = recovery_hint(session_name, issue_id, "team-agent diagnose");
-                if let Some(obj) = hint.as_object_mut() {
-                    obj.insert("reason".to_string(), Value::String(error_str));
+        .is_some_and(|session_name| {
+            match backend.has_session(&crate::transport::SessionName::new(
+                session_name.to_string(),
+            )) {
+                Ok(true) => false,
+                Ok(false) => {
+                    issues.push(json!("tmux_session_missing"));
+                    repairs.push(recovery_hint(
+                        session_name,
+                        "tmux_session_missing",
+                        "team-agent restart",
+                    ));
+                    true
                 }
-                repairs.push(hint);
+                Err(error) => {
+                    // 0.5.39 Slice 1 (tmux-server-death-locate §11.1 B):
+                    // when the transport error stderr matches "server exited
+                    // unexpectedly", the physical layer that disappeared is
+                    // the tmux server itself — not just this team's session.
+                    let error_str = error.to_string();
+                    let issue_id = classify_tmux_server_error(&error_str);
+                    issues.push(json!(issue_id));
+                    let mut hint = recovery_hint(session_name, issue_id, "team-agent diagnose");
+                    if let Some(obj) = hint.as_object_mut() {
+                        obj.insert("reason".to_string(), Value::String(error_str));
+                    }
+                    repairs.push(hint);
+                    true
+                }
+            }
+        });
+
+    if session_unavailable {
+        if let Some(issue) = persisted_socket_conflict {
+            if let Some(id) = crate::topology::issue_id(&issue) {
+                repairs.push(topology_repair_hint(id));
             }
+            issues.push(issue);
+        }
+        return (Value::Array(issues), Value::Array(repairs));
+    }
+
+    for issue in crate::topology::diagnose_topology_issues(state, backend) {
+        if let Some(id) = crate::topology::issue_id(&issue) {
+            repairs.push(topology_repair_hint(id));
         }
+        issues.push(issue);
     }
 
     if leader_receiver_attached(state) {
@@ -624,6 +640,17 @@ pub(crate) fn append_registry_channel_unbound_to_report(
     repairs.push(recovery_hint(&team_key, issue_id, repair));
     object.insert("issues".to_string(), Value::Array(issues));
     object.insert("suggested_repairs".to_string(), Value::Array(repairs));
+    let is_healthy_unattached_host =
+        class == crate::lifecycle::launch::LeaderBindingClass::Unbound
+            && object.get("ok").and_then(Value::as_bool) == Some(true)
+            && object
+                .get("profile_smoke")
+                .and_then(|profile| profile.get("checks"))
+                .and_then(Value::as_array)
+                .is_some_and(|checks| !checks.is_empty());
+    if !is_healthy_unattached_host {
+        object.insert("ok".to_string(), Value::Bool(false));
+    }
 }
 
 pub(crate) fn append_selected_live_leader_workspace_mismatch(
@@ -652,7 +679,7 @@ fn selected_live_leader_workspace_mismatch(
     workspace: &std::path::Path,
     team: Option<&str>,
 ) -> Option<(Value, Value)> {
-    let selected = crate::state::selector::resolve_active_team(
+    let selected = crate::state::selector::resolve_active_team_readonly(
         workspace,
         team,
         crate::state::selector::SelectorMode::RuntimeOnly,
@@ -766,8 +793,10 @@ fn append_coordinator_health_issue(
     issues: &mut Value,
     repairs: &mut Value,
 ) {
+    // Diagnose must observe coordinator state without initializing or rewriting
+    // `.team/runtime/team.db`, including when the file is missing or empty.
     let workspace = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
-    let health = crate::coordinator::coordinator_health(&workspace);
+    let health = crate::coordinator::coordinator_health_read_only(&workspace);
     let Some(id) = coordinator_issue_id(state, &health) else {
         return;
     };
@@ -1910,14 +1939,24 @@ pub(crate) fn provider_doctor_checks() -> Value {
     ] {
         let adapter = crate::provider::get_adapter(provider);
         let name = provider_wire(provider);
-        let version = adapter.version().unwrap_or_else(|error| error.to_string());
+        let fake = matches!(provider, crate::provider::Provider::Fake);
+        let (auth, version) = if fake {
+            (crate::provider::AuthHintStatus::Present, "fake".to_string())
+        } else {
+            (
+                crate::provider::AuthHintStatus::Unknown,
+                "unknown".to_string(),
+            )
+        };
         providers.insert(
             name.to_string(),
             json!({
-                "auth": adapter.auth_hint(crate::provider::AuthMode::Subscription),
+                "auth": auth,
                 "command": provider_command(provider),
                 "installed": adapter.is_installed(),
                 "version": version,
+                "probe_status": "not_run",
+                "provider_probe_status": "not_run",
             }),
         );
     }