@team-agent/installer 0.5.98 → 0.5.100

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

@@ -45,11 +45,11 @@ use serde_json::{json, Map, Value};
 use thiserror::Error;
 
 // REUSE in-tree(只 import,不 redefine):
-use crate::messaging::{self, AlertType, MessageTarget, SendOptions, TrustedSender};
+use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
-pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker terminal output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
+pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker pane output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
 pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
 pub(crate) const STATUS_REMINDER: &str = "Results are finalized automatically; use --watch-result or team-agent inbox AGENT -n 3 for transport fallback. Do not capture-pane worker terminals.";
 
@@ -119,7 +119,7 @@ mod hermetic_test_support;
 pub mod status_port;
 
 /// PLACEHOLDER → step13 lifecycle(`runtime.{quick_start,start_agent,add_agent,fork_agent,
-/// remove_agent,start_agent,stop_agent,reset_agent,restart,shutdown,start_leader,acknowledge_idle}`)。
+/// remove_agent,start_agent,stop_agent,reset_agent,restart,shutdown,start_leader}`)。
 /// `quick_start.py` 物理在本子系统但实现属 step 13(card)。本层只声明委派面。
 pub mod lifecycle_port {
     use super::*;
@@ -133,16 +133,14 @@ pub mod lifecycle_port {
         name: Option<&str>,
         team_id: Option<&str>,
         yes: bool,
-        open_display: bool,
         backend: Option<&str>,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace_with_display_and_backend(
+        match crate::lifecycle::quick_start_in_workspace_with_backend(
             workspace,
             agents_dir,
             name,
             yes,
             team_id,
-            open_display,
             backend,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
@@ -1155,10 +1153,7 @@ pub mod lifecycle_port {
                             }
                         }
                     }
-                    let _ = crate::lifecycle::display::close_team_display_backends(
-                        &run_workspace,
-                        session,
-                    );
+                    cleanup_owned_team_windows(&run_workspace, transport, &state, session);
                 } else {
                     let targets = vec![session.as_str().to_string()];
                     let event_log = crate::event_log::EventLog::new(&run_workspace);
@@ -1185,10 +1180,7 @@ pub mod lifecycle_port {
                     } else {
                         push_unique_session(&mut killed_sessions, session.clone());
                     }
-                    let _ = crate::lifecycle::display::close_team_display_backends(
-                        &run_workspace,
-                        session,
-                    );
+                    cleanup_owned_team_windows(&run_workspace, transport, &state, session);
                 }
             }
         }
@@ -1473,6 +1465,127 @@ pub mod lifecycle_port {
         Ok(response)
     }
 
+    /// Remove legacy adaptive display windows without reopening a display backend.
+    /// Every target is scoped to the selected transport and passes the same
+    /// ownership/protection audit as the rest of shutdown. Unknown or protected
+    /// targets are intentionally left in place.
+    fn cleanup_owned_team_windows(
+        workspace: &Path,
+        transport: &dyn crate::transport::Transport,
+        state: &Value,
+        session: &crate::transport::SessionName,
+    ) {
+        let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+            return;
+        };
+        let leader_session = state
+            .get("leader_receiver")
+            .and_then(|receiver| receiver.get("session_name"))
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| session.as_str());
+        let leader_panes = collect_state_leader_anchor_pane_ids(
+            state,
+            transport.tmux_endpoint().as_deref(),
+        );
+        let event_log = crate::event_log::EventLog::new(workspace);
+        let team_key = state.get("team_key").and_then(Value::as_str);
+        let generation = state_generation(state);
+        let overview_prefix = format!("team-agent:{}:overview", session.as_str());
+        let mut windows = std::collections::BTreeSet::new();
+        let mut panes = std::collections::BTreeSet::new();
+        for (_agent_id, agent) in agents {
+            let Some(display) = agent.get("display").and_then(Value::as_object) else {
+                continue;
+            };
+            if display.get("backend").and_then(Value::as_str) != Some("adaptive") {
+                continue;
+            }
+            if display.get("status").and_then(Value::as_str) == Some("stopped") {
+                continue;
+            }
+            if let Some(window) = display
+                .get("workspace_window")
+                .or_else(|| display.get("window"))
+                .or_else(|| agent.get("window"))
+                .and_then(Value::as_str)
+                .filter(|value| !value.is_empty())
+            {
+                if window == overview_prefix || window.starts_with(&format!("{overview_prefix}-")) {
+                    windows.insert(format!("{leader_session}:{window}"));
+                }
+            }
+            if let Some(pane) = display.get("pane_id").and_then(Value::as_str) {
+                if pane.starts_with('%') && !leader_panes.contains(pane) {
+                    panes.insert(pane.to_string());
+                }
+            }
+        }
+        if let Ok(live_windows) = transport.list_windows(&crate::transport::SessionName::new(
+            leader_session.to_string(),
+        )) {
+            for window in live_windows {
+                let name = window.as_str();
+                if name == overview_prefix || name.starts_with(&format!("{overview_prefix}-")) {
+                    windows.insert(format!("{leader_session}:{name}"));
+                }
+            }
+        }
+        let live_targets = transport.list_targets().unwrap_or_default();
+        for target in &live_targets {
+            if leader_panes.contains(target.pane_id.as_str()) {
+                continue;
+            }
+            if let Some(window) = target.window_name.as_ref() {
+                if windows.contains(&format!("{}:{}", target.session.as_str(), window.as_str())) {
+                    panes.remove(target.pane_id.as_str());
+                }
+            }
+        }
+        for target in windows {
+            let Some((target_session, target_window)) = target.split_once(':') else {
+                continue;
+            };
+            let target = crate::transport::Target::SessionWindow {
+                session: crate::transport::SessionName::new(target_session.to_string()),
+                window: crate::transport::WindowName::new(target_window.to_string()),
+            };
+            let target_text = format!("{target_session}:{target_window}");
+            let audit = crate::kill_audit::pre_kill_audit_scoped(
+                &event_log,
+                transport,
+                "shutdown.legacy_display_window",
+                "kill-window",
+                std::slice::from_ref(&target_text),
+                workspace,
+                team_key,
+                generation,
+                "session_marker+state_display_window+team_tag",
+                "positive workspace/team ownership",
+            );
+            if audit.is_ok() {
+                let _ = transport.kill_window(&target);
+            }
+        }
+        for pane in panes {
+            let audit = crate::kill_audit::pre_kill_audit_scoped(
+                &event_log,
+                transport,
+                "shutdown.legacy_display_pane",
+                "kill-pane",
+                std::slice::from_ref(&pane),
+                workspace,
+                team_key,
+                generation,
+                "state_display_pane+team_session",
+                "positive workspace/team ownership",
+            );
+            if audit.is_ok() {
+                let _ = transport.kill_pane(&crate::transport::PaneId::new(pane));
+            }
+        }
+    }
+
     /// 0.5.x Windows portability Batch 6 Option A: locate and
     /// terminate the ConPTY shim if `state.transport.shim.pid` is
     /// recorded. Returns a JSON blob for the shutdown response so
@@ -2635,7 +2748,6 @@ pub mod lifecycle_port {
         workspace: &Path,
         agent: &str,
         force: bool,
-        open_display: bool,
         allow_fresh: bool,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
@@ -2644,7 +2756,7 @@ pub mod lifecycle_port {
             workspace,
             &agent_id,
             force,
-            open_display,
+            true,
             allow_fresh,
             team,
         ) {
@@ -2712,7 +2824,6 @@ pub mod lifecycle_port {
         workspace: &Path,
         agent: &str,
         discard_session: bool,
-        open_display: bool,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
@@ -2720,7 +2831,7 @@ pub mod lifecycle_port {
             workspace,
             &agent_id,
             discard_session,
-            open_display,
+            true,
             team,
         ) {
             Ok(crate::lifecycle::ResetAgentOutcome::Reset {
@@ -2763,7 +2874,6 @@ pub mod lifecycle_port {
         workspace: &Path,
         agent: &str,
         role_file: &str,
-        open_display: bool,
         team: Option<&str>,
         force: bool,
     ) -> Result<Value, CliError> {
@@ -2772,7 +2882,7 @@ pub mod lifecycle_port {
             workspace,
             &agent_id,
             Path::new(role_file),
-            open_display,
+            true,
             team,
             force,
         ) {
@@ -2811,12 +2921,11 @@ pub mod lifecycle_port {
         source_agent: &str,
         as_agent_id: &str,
         label: Option<&str>,
-        open_display: bool,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
-        match crate::lifecycle::fork_agent(workspace, &source, &dest, label, open_display, team) {
+        match crate::lifecycle::fork_agent(workspace, &source, &dest, label, true, team) {
             Ok(report) => Ok(json!({
                 "ok": true,
                 "source_agent_id": report.source_agent_id.as_str(),
@@ -2833,12 +2942,11 @@ pub mod lifecycle_port {
         source_agent: &str,
         as_agent_id: &str,
         label: Option<&str>,
-        open_display: bool,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
-        match crate::lifecycle::clone_agent(workspace, &source, &dest, label, open_display, team) {
+        match crate::lifecycle::clone_agent(workspace, &source, &dest, label, true, team) {
             Ok(report) => Ok(json!({
                 "ok": true,
                 "status": "cloned",
@@ -3024,60 +3132,6 @@ pub mod lifecycle_port {
             format!("'{}'", raw.replace('\'', "'\\''"))
         }
     }
-    ///
-    /// `runtime.acknowledge_idle`(`cmd_acknowledge_idle`)。
-    pub fn acknowledge_idle(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
-        let mut state = crate::state::persist::load_runtime_state(workspace)
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let team = team
-            .map(ToString::to_string)
-            .or_else(|| {
-                state
-                    .get("active_team_key")
-                    .and_then(Value::as_str)
-                    .map(ToString::to_string)
-            })
-            .filter(|s| !s.is_empty())
-            .or_else(|| {
-                workspace
-                    .file_name()
-                    .map(|name| name.to_string_lossy().to_string())
-            })
-            .unwrap_or_else(|| "current".to_string());
-        let now = chrono::Utc::now().to_rfc3339();
-        let ttl_seconds = 1800;
-        let expires_at = (chrono::Utc::now() + chrono::Duration::seconds(ttl_seconds)).to_rfc3339();
-        record_idle_acknowledged(&mut state, &team, &now, &expires_at, ttl_seconds);
-        suppress_team_idle_fallbacks(&mut state, &team, &now, &expires_at, ttl_seconds);
-        let agent_id = state
-            .get("agents")
-            .and_then(Value::as_object)
-            .and_then(|agents| agents.keys().next().cloned())
-            .map(Value::String)
-            .unwrap_or(Value::Null);
-        crate::state::repository::StateRepository::new(workspace)
-            .save(
-                crate::state::repository::StateWriteIntent::IdleAck {
-                    team_key: Some(&team),
-                },
-                &state,
-            )
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
-        crate::event_log::EventLog::new(workspace)
-            .write(
-                "coordinator.idle_acknowledged",
-                json!({"team": team, "ttl_seconds": ttl_seconds}),
-            )
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
-        Ok(json!({
-            "ok": true,
-            "team": team,
-            "agent_id": agent_id,
-            "acknowledged_at": now,
-            "expires_at": expires_at,
-            "ttl_seconds": ttl_seconds,
-        }))
-    }
 
     fn error_value(error: crate::lifecycle::LifecycleError) -> Value {
         let message = error.to_string();
@@ -3132,118 +3186,6 @@ pub mod lifecycle_port {
         None
     }
 
-    fn record_idle_acknowledged(
-        state: &mut Value,
-        team: &str,
-        acknowledged_at: &str,
-        expires_at: &str,
-        ttl_seconds: i64,
-    ) {
-        let Some(root) = state.as_object_mut() else {
-            return;
-        };
-        let coordinator = root
-            .entry("coordinator")
-            .or_insert_with(|| json!({}))
-            .as_object_mut();
-        let Some(coordinator) = coordinator else {
-            return;
-        };
-        let idle = coordinator
-            .entry("idle_acknowledged")
-            .or_insert_with(|| json!({}))
-            .as_object_mut();
-        let Some(idle) = idle else {
-            return;
-        };
-        idle.insert(
-            team.to_string(),
-            json!({"acknowledged_at": acknowledged_at, "expires_at": expires_at, "ttl_seconds": ttl_seconds}),
-        );
-    }
-
-    fn suppress_team_idle_fallbacks(
-        state: &mut Value,
-        team: &str,
-        suppressed_at: &str,
-        expires_at: &str,
-        ttl_seconds: i64,
-    ) {
-        let agents = state
-            .get("agents")
-            .and_then(Value::as_object)
-            .map(|obj| obj.keys().cloned().collect::<Vec<_>>())
-            .unwrap_or_default();
-        for agent in agents {
-            upsert_suppression(
-                state,
-                SuppressionRecord {
-                    team,
-                    agent_id: &agent,
-                    alert_type: "idle_fallback",
-                    suppressed_by: "manual_acknowledge",
-                    suppressed_at,
-                    expires_at,
-                    ttl_seconds,
-                },
-            );
-        }
-    }
-
-    struct SuppressionRecord<'a> {
-        team: &'a str,
-        agent_id: &'a str,
-        alert_type: &'a str,
-        suppressed_by: &'a str,
-        suppressed_at: &'a str,
-        expires_at: &'a str,
-        ttl_seconds: i64,
-    }
-
-    fn upsert_suppression(state: &mut Value, record: SuppressionRecord<'_>) {
-        let Some(root) = state.as_object_mut() else {
-            return;
-        };
-        let Some(coordinator) = root
-            .entry("coordinator")
-            .or_insert_with(|| json!({}))
-            .as_object_mut()
-        else {
-            return;
-        };
-        let Some(all) = coordinator
-            .entry("suppressed_idle_alerts")
-            .or_insert_with(|| json!({}))
-            .as_object_mut()
-        else {
-            return;
-        };
-        let Some(team_map) = all
-            .entry(record.team.to_string())
-            .or_insert_with(|| json!({}))
-            .as_object_mut()
-        else {
-            return;
-        };
-        let Some(agent_map) = team_map
-            .entry(record.agent_id.to_string())
-            .or_insert_with(|| json!({}))
-            .as_object_mut()
-        else {
-            return;
-        };
-        agent_map.insert(
-            record.alert_type.to_string(),
-            json!({
-                "suppressed_at": record.suppressed_at,
-                "suppressed_by": record.suppressed_by,
-                "manual_acknowledge": true,
-                "expires_at": record.expires_at,
-                "ttl_seconds": record.ttl_seconds,
-            }),
-        );
-    }
-
     const COMPACT_READINESS_KEYS: [&str; 6] = [
         "all_workers_spawned",
         "state",
@@ -3340,10 +3282,10 @@ pub mod lifecycle_port {
         {
             return vec![
                 "repair state.session_name to the worker session; it currently names the leader launcher session".to_string(),
-                format!("team-agent diagnose --team {team} --json"),
+                format!("team-agent doctor --team {team} --json"),
             ];
         }
-        let mut actions = vec![format!("team-agent diagnose --team {team} --json")];
+        let mut actions = vec![format!("team-agent doctor --team {team} --json")];
         if issue_ids
             .iter()
             .any(|id| id.contains("socket") || id.contains("endpoint"))
@@ -3362,7 +3304,6 @@ pub mod lifecycle_port {
                 launch,
                 next_actions,
                 attach_commands,
-                display_backend,
                 worker_readiness,
                 team,
             } => {
@@ -3502,7 +3443,6 @@ pub mod lifecycle_port {
                     "team": team,
                     "agent_ids": launch.started.iter().map(|agent| agent.agent_id.as_str()).collect::<Vec<_>>(),
                     "dry_run": launch.dry_run,
-                    "display_backend": display_backend,
                     "next_actions": next_actions,
                     "attach_commands": attach_commands,
                     "reminder": crate::cli::QUICK_START_REMINDER,
@@ -3638,12 +3578,6 @@ pub mod lifecycle_port {
                         claude_config_dir: None,
                         provider_projects_root: None,
                         managed_mcp_config: false,
-                        layout_window: None,
-                        layout_index: None,
-                        pane_index: None,
-                        display: crate::lifecycle::WorkerDisplay::Blocked {
-                            reason: crate::lifecycle::AdaptiveBlockReason::AggregatorRebuildFailed,
-                        },
                     }],
                     dry_run: false,
                     tmux_endpoint: None,
@@ -3655,7 +3589,6 @@ pub mod lifecycle_port {
                 }),
                 next_actions: Vec::new(),
                 attach_commands: Vec::new(),
-                display_backend: "none".to_string(),
                 worker_readiness: crate::lifecycle::QuickStartReadiness::PendingToolLoad,
                 team: "team-demo".to_string(),
             });
@@ -3773,7 +3706,7 @@ pub mod lifecycle_port {
                 "status": "partial",
                 "reason": "restart_agent_failed",
                 "failed_agents": [{"agent_id": "worker", "error": "spawn failed"}],
-                "next_actions": ["restart-agent worker"],
+                "next_actions": ["reset-agent worker --discard-session"],
                 "attach_commands": [],
                 "coordinator": {"status": "running", "transport": "default"}
             });
@@ -3781,7 +3714,7 @@ pub mod lifecycle_port {
             compact_restart_value(&mut default);
             assert_eq!(default["status"], json!("partial"));
             assert_eq!(default["reason"], json!("restart_agent_failed"));
-            assert_eq!(default["next_actions"], json!(["restart-agent worker"]));
+            assert_eq!(default["next_actions"], json!(["reset-agent worker --discard-session"]));
             assert!(default.get("coordinator").is_none());
             assert!(detail.get("coordinator").is_some());
         }
@@ -4063,7 +3996,7 @@ pub mod lifecycle_port {
                         "phase": failure.phase,
                         "error": failure.error,
                         "action": format!(
-                            "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                            "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                             failure.agent_id,
                             failure.agent_id
                         ),
@@ -4109,7 +4042,7 @@ pub mod lifecycle_port {
                     "phase": failure.phase,
                     "error": failure.error,
                     "action": format!(
-                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                        "inspect worker {} output, then reset that worker with `team-agent reset-agent {} --discard-session` or rerun `team-agent restart --allow-fresh`",
                         failure.agent_id,
                         failure.agent_id
                     ),

package/crates/team-agent/src/cli/send/coordinator.rs

@@ -27,13 +27,13 @@ pub(super) fn dirty_topology_refusal_value(
         "status": "refused_dirty_topology",
         "reason": reason,
         "session_name": session_name,
-        "error": "send refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before sending",
+        "error": "send refused: tmux endpoint/socket topology is inconsistent; run doctor from the intended leader socket before sending",
         "issues": issue_ids
             .iter()
             .map(|id| json!({"id": id}))
             .collect::<Vec<_>>(),
         "next_actions": [
-            "team-agent diagnose --json",
+            "team-agent doctor --json",
             format!("team-agent claim-leader --team {repair_team} --confirm --json"),
             format!("team-agent takeover --team {repair_team} --confirm --json")
         ],