@team-agent/installer 0.3.14 → 0.3.15

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

@@ -158,11 +158,33 @@ fn tmp_shutdown_workspace(tag: &str) -> PathBuf {
 
 struct CleanShutdownTransport {
     session_present: Mutex<bool>,
+    targets: Vec<PaneInfo>,
+    kill_server_called: Mutex<bool>,
+    probe_timeout_kind: Option<&'static str>,
 }
 
 impl CleanShutdownTransport {
     fn new() -> Self {
-        Self { session_present: Mutex::new(true) }
+        Self {
+            session_present: Mutex::new(true),
+            targets: Vec::new(),
+            kill_server_called: Mutex::new(false),
+            probe_timeout_kind: None,
+        }
+    }
+
+    fn with_targets(mut self, targets: Vec<PaneInfo>) -> Self {
+        self.targets = targets;
+        self
+    }
+
+    fn kill_server_called(&self) -> bool {
+        *self.kill_server_called.lock().unwrap()
+    }
+
+    fn with_probe_timeout(mut self, probe: &'static str) -> Self {
+        self.probe_timeout_kind = Some(probe);
+        self
     }
 }
 
@@ -227,7 +249,11 @@ impl Transport for CleanShutdownTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        if *self.session_present.lock().unwrap() {
+            Ok(self.targets.clone())
+        } else {
+            Ok(Vec::new())
+        }
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -248,10 +274,18 @@ impl Transport for CleanShutdownTransport {
     }
 
     fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+        if let Some(probe) = self.probe_timeout_kind {
+            crate::os_probe::set_probe_timeout_for_test(probe, None, 900);
+        }
         *self.session_present.lock().unwrap() = false;
         Ok(())
     }
 
+    fn kill_server(&self) -> Result<(), TransportError> {
+        *self.kill_server_called.lock().unwrap() = true;
+        Ok(())
+    }
+
     fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
         Ok(())
     }
@@ -260,3 +294,126 @@ impl Transport for CleanShutdownTransport {
         Ok(AttachOutcome::Attached)
     }
 }
+
+#[test]
+fn lsof_cwd_timeout_is_diagnostic_not_shutdown_partial() {
+    let ws = tmp_shutdown_workspace("lsof-cwd-timeout-diagnostic");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-lsof-cwd-timeout",
+            "agents": {
+                "fake_impl": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "fake_impl"
+                }
+            }
+        }),
+    )
+    .unwrap();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(
+        &ws,
+        true,
+        None,
+        &CleanShutdownTransport::new().with_probe_timeout("lsof_cwd"),
+    )
+    .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["status"], json!("ok"));
+    assert_eq!(out["phase"], json!(null));
+    assert_eq!(out["verification_degraded"], json!(true));
+    assert_eq!(out["probe_timeout_kind"], json!("lsof_cwd"));
+    assert_eq!(out["residuals"]["sessions"], json!([]));
+    assert_eq!(out["residuals"]["processes"], json!([]));
+
+    let events = crate::event_log::EventLog::new(&ws).tail(0).expect("events");
+    let shutdown = events
+        .iter()
+        .find(|event| {
+            event.get("event").and_then(serde_json::Value::as_str) == Some("lifecycle.shutdown")
+        })
+        .unwrap_or_else(|| panic!("missing lifecycle.shutdown event: {events:?}"));
+    assert_eq!(shutdown["status"], json!("ok"));
+    assert_eq!(shutdown["phase"], json!(null));
+    assert_eq!(shutdown["verification_degraded"], json!(true));
+    assert_eq!(shutdown["probe_timeout_kind"], json!("lsof_cwd"));
+}
+
+#[test]
+fn ps_table_timeout_still_degrades_shutdown_truth() {
+    let ws = tmp_shutdown_workspace("ps-table-timeout-partial");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-ps-table-timeout",
+            "agents": {
+                "fake_impl": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "fake_impl"
+                }
+            }
+        }),
+    )
+    .unwrap();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(
+        &ws,
+        true,
+        None,
+        &CleanShutdownTransport::new().with_probe_timeout("ps_table"),
+    )
+    .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(false));
+    assert_eq!(out["status"], json!("partial"));
+    assert_eq!(out["phase"], json!("os_probe"));
+    assert_eq!(out["verification_degraded"], json!(true));
+    assert_eq!(out["probe_timeout_kind"], json!("ps_table"));
+}
+
+#[test]
+fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive() {
+    let ws = tmp_shutdown_workspace("leader-env-socket-no-kill-server");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "tmux_socket_source": "leader_env",
+            "agents": {
+                "fake_impl": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "fake_impl"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new().with_targets(vec![PaneInfo {
+        pane_id: PaneId::new("%1"),
+        session: SessionName::new("team-layout"),
+        window_index: Some(0),
+        window_name: Some(WindowName::new("team-w1")),
+        pane_index: Some(0),
+        tty: None,
+        current_command: None,
+        current_path: None,
+        active: true,
+        pane_pid: None,
+        leader_env: BTreeMap::new(),
+    }]);
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["killed_sessions"], json!(["team-layout"]));
+    assert_eq!(out["spared_sessions"], json!([]));
+    assert!(
+        !transport.kill_server_called(),
+        "leader-env/shared socket shutdown must kill sessions individually, never kill-server"
+    );
+}

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

@@ -97,7 +97,8 @@ impl CliError {
                     "tmux session `{session}` already exists. It may be an active team. Do not terminate existing tmux sessions from startup; use a different team name or runtime.session_name and start again."
                 );
                 payload.next_actions = Some(vec![
-                    "Use a different team name or runtime.session_name before starting again.".to_string(),
+                    "Use a different team name or runtime.session_name before starting again."
+                        .to_string(),
                 ]);
             }
         }
@@ -262,6 +263,7 @@ pub struct QuickStartArgs {
     pub team_id: Option<String>,
     pub yes: bool,
     pub fresh: bool,
+    pub no_display: bool,
     pub json: bool,
 }
 
@@ -304,6 +306,33 @@ pub struct SendArgs {
     pub message_id: Option<String>,
 }
 
+/// E23 worker-side emergency fallback for `team_orchestrator.send_message`
+/// transport failures. This is not a general control-plane send path.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FallbackSendLeaderArgs {
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub sender: String,
+    pub task: Option<String>,
+    pub message_id: String,
+    pub content: String,
+    pub primary_error: String,
+    pub json: bool,
+}
+
+/// E23 worker-side emergency fallback for `team_orchestrator.report_result`
+/// transport failures. It must still persist through the results DB.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FallbackReportResultArgs {
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub agent_id: String,
+    pub task_id: String,
+    pub result_json: String,
+    pub primary_error: String,
+    pub json: bool,
+}
+
 /// `allow-peer-talk`(`parser.py`): allow direct peer communication between two agents.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AllowPeerTalkArgs {

package/crates/team-agent/src/compiler/tests.rs

@@ -179,7 +179,7 @@ fn front_matter_non_object_errors() {
 // separators=(",",":"))` with the workspace path templated to __WS__.
 // (team-agent-public v0.2.11, /tmp/probe_compiler.py.)
 
-const BASE_NOPROFILE_JSON: &str = r#"{"version":1,"team":{"name":"doc-team","mode":"supervisor_worker","objective":"Compile role docs.","workspace":"__WS__"},"leader":{"id":"leader","role":"leader","provider":"codex","model":"gpt-5.5","tools":["fs_read","fs_list","mcp_team"],"context_policy":{"keep_user_thread":true,"receive_worker_outputs":"business_messages_and_short_summaries","max_worker_result_tokens":2000}},"agents":[{"id":"implementer","role":"Implementation Engineer","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Implement bounded tasks and report result_envelope_v1.","file":null},"tools":["fs_read","fs_write","execute_bash","mcp_team"],"permission_mode":"restricted","preferred_for":["implementer","Implementation Engineer"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}}],"routing":{"default_assignee":"implementer","rules":[{"id":"route-implementer","match":{"assignee":["implementer"]},"assign_to":"implementer","priority":10}]},"communication":{"protocol":"mcp_inbox","topology":"leader_centered","worker_to_worker":true,"ack_timeout_sec":60,"result_format":"result_envelope_v1","message_store":{"sqlite":".team/runtime/team.db","mirror_files":".team/messages"}},"runtime":{"backend":"tmux","display_backend":"none","session_name":"team-doc-team","auto_launch":true,"require_user_approval_before_launch":true,"max_active_agents":1,"startup_order":["implementer"],"dangerous_auto_approve":false,"fast":false,"tick_interval_sec":2,"push_min_interval_sec":60,"stuck_timeout_sec":300},"context":{"state_file":"team_state.md","artifact_dir":".team/artifacts","log_dir":".team/logs","summarization":{"worker_full_logs":"retain_outside_leader_context","state_update":"after_each_result"}},"tasks":[{"id":"task_initial","title":"Initial document-driven team task","type":"implementation","assignee":"implementer","deps":[],"acceptance":["Worker reports valid result_envelope_v1"],"status":"pending","requires_tools":["mcp_team"],"files":[],"risk":"low"}]}"#;
+const BASE_NOPROFILE_JSON: &str = r#"{"version":1,"team":{"name":"doc-team","mode":"supervisor_worker","objective":"Compile role docs.","workspace":"__WS__"},"leader":{"id":"leader","role":"leader","provider":"codex","model":"gpt-5.5","tools":["fs_read","fs_list","mcp_team"],"context_policy":{"keep_user_thread":true,"receive_worker_outputs":"business_messages_and_short_summaries","max_worker_result_tokens":2000}},"agents":[{"id":"implementer","role":"Implementation Engineer","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Implement bounded tasks and report result_envelope_v1.","file":null},"tools":["fs_read","fs_write","execute_bash","mcp_team"],"permission_mode":"restricted","preferred_for":["implementer","Implementation Engineer"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}}],"routing":{"default_assignee":"implementer","rules":[{"id":"route-implementer","match":{"assignee":["implementer"]},"assign_to":"implementer","priority":10}]},"communication":{"protocol":"mcp_inbox","topology":"leader_centered","worker_to_worker":true,"ack_timeout_sec":60,"result_format":"result_envelope_v1","message_store":{"sqlite":".team/runtime/team.db","mirror_files":".team/messages"}},"runtime":{"backend":"tmux","display_backend":"adaptive","session_name":"team-doc-team","auto_launch":true,"require_user_approval_before_launch":true,"max_active_agents":1,"startup_order":["implementer"],"dangerous_auto_approve":false,"fast":false,"tick_interval_sec":2,"push_min_interval_sec":60,"stuck_timeout_sec":300},"context":{"state_file":"team_state.md","artifact_dir":".team/artifacts","log_dir":".team/logs","summarization":{"worker_full_logs":"retain_outside_leader_context","state_update":"after_each_result"}},"tasks":[{"id":"task_initial","title":"Initial document-driven team task","type":"implementation","assignee":"implementer","deps":[],"acceptance":["Worker reports valid result_envelope_v1"],"status":"pending","requires_tools":["mcp_team"],"files":[],"risk":"low"}]}"#;
 
 #[test]
 fn compile_base_noprofile_matches_python_dict_order_and_values() {
@@ -352,7 +352,7 @@ tools:
 Bravo body.
 ";
 
-const TWO_AGENTS_JSON: &str = r#"{"version":1,"team":{"name":"doc-team","mode":"supervisor_worker","objective":"Compile role docs.","workspace":"__WS__"},"leader":{"id":"leader","role":"leader","provider":"codex","model":"gpt-5.5","tools":["fs_read","fs_list","mcp_team"],"context_policy":{"keep_user_thread":true,"receive_worker_outputs":"business_messages_and_short_summaries","max_worker_result_tokens":2000}},"agents":[{"id":"alpha","role":"Alpha Worker","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Alpha body.","file":null},"tools":["mcp_team"],"permission_mode":"restricted","preferred_for":["alpha","Alpha Worker"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}},{"id":"bravo","role":"Bravo Worker","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Bravo body.","file":null},"tools":["mcp_team"],"permission_mode":"restricted","preferred_for":["bravo","Bravo Worker"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}}],"routing":{"default_assignee":"alpha","rules":[{"id":"route-alpha","match":{"assignee":["alpha"]},"assign_to":"alpha","priority":10},{"id":"route-bravo","match":{"assignee":["bravo"]},"assign_to":"bravo","priority":10}]},"communication":{"protocol":"mcp_inbox","topology":"leader_centered","worker_to_worker":true,"ack_timeout_sec":60,"result_format":"result_envelope_v1","message_store":{"sqlite":".team/runtime/team.db","mirror_files":".team/messages"}},"runtime":{"backend":"tmux","display_backend":"none","session_name":"team-doc-team","auto_launch":true,"require_user_approval_before_launch":true,"max_active_agents":2,"startup_order":["alpha","bravo"],"dangerous_auto_approve":false,"fast":false,"tick_interval_sec":2,"push_min_interval_sec":60,"stuck_timeout_sec":300},"context":{"state_file":"team_state.md","artifact_dir":".team/artifacts","log_dir":".team/logs","summarization":{"worker_full_logs":"retain_outside_leader_context","state_update":"after_each_result"}},"tasks":[{"id":"task_initial","title":"Initial document-driven team task","type":"implementation","assignee":"alpha","deps":[],"acceptance":["Worker reports valid result_envelope_v1"],"status":"pending","requires_tools":["mcp_team"],"files":[],"risk":"low"}]}"#;
+const TWO_AGENTS_JSON: &str = r#"{"version":1,"team":{"name":"doc-team","mode":"supervisor_worker","objective":"Compile role docs.","workspace":"__WS__"},"leader":{"id":"leader","role":"leader","provider":"codex","model":"gpt-5.5","tools":["fs_read","fs_list","mcp_team"],"context_policy":{"keep_user_thread":true,"receive_worker_outputs":"business_messages_and_short_summaries","max_worker_result_tokens":2000}},"agents":[{"id":"alpha","role":"Alpha Worker","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Alpha body.","file":null},"tools":["mcp_team"],"permission_mode":"restricted","preferred_for":["alpha","Alpha Worker"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}},{"id":"bravo","role":"Bravo Worker","provider":"codex","model":"gpt-5.5","auth_mode":"subscription","working_directory":"__WS__","system_prompt":{"inline":"Bravo body.","file":null},"tools":["mcp_team"],"permission_mode":"restricted","preferred_for":["bravo","Bravo Worker"],"avoid_for":[],"output_contract":{"format":"result_envelope_v1","required_fields":["task_id","status","summary","artifacts"]}}],"routing":{"default_assignee":"alpha","rules":[{"id":"route-alpha","match":{"assignee":["alpha"]},"assign_to":"alpha","priority":10},{"id":"route-bravo","match":{"assignee":["bravo"]},"assign_to":"bravo","priority":10}]},"communication":{"protocol":"mcp_inbox","topology":"leader_centered","worker_to_worker":true,"ack_timeout_sec":60,"result_format":"result_envelope_v1","message_store":{"sqlite":".team/runtime/team.db","mirror_files":".team/messages"}},"runtime":{"backend":"tmux","display_backend":"adaptive","session_name":"team-doc-team","auto_launch":true,"require_user_approval_before_launch":true,"max_active_agents":2,"startup_order":["alpha","bravo"],"dangerous_auto_approve":false,"fast":false,"tick_interval_sec":2,"push_min_interval_sec":60,"stuck_timeout_sec":300},"context":{"state_file":"team_state.md","artifact_dir":".team/artifacts","log_dir":".team/logs","summarization":{"worker_full_logs":"retain_outside_leader_context","state_update":"after_each_result"}},"tasks":[{"id":"task_initial","title":"Initial document-driven team task","type":"implementation","assignee":"alpha","deps":[],"acceptance":["Worker reports valid result_envelope_v1"],"status":"pending","requires_tools":["mcp_team"],"files":[],"risk":"low"}]}"#;
 
 #[test]
 fn compile_two_agents_sorted_by_filename_with_routing_and_startup_order() {

package/crates/team-agent/src/compiler.rs

@@ -247,7 +247,7 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
                     "display_backend",
                     Value::Str(
                         string_field(&team_meta, "display_backend")
-                            .unwrap_or_else(|| "none".to_string()),
+                            .unwrap_or_else(|| "adaptive".to_string()),
                     ),
                 ),
                 ("session_name", Value::Str(session_name(&team_meta, &team_name))),

package/crates/team-agent/src/fake_worker.rs

@@ -107,7 +107,10 @@ fn parse_rendered_header(line: &str) -> Option<RenderedBlock> {
         .split_once(" for ")
         .map(|(_, task)| task.trim().to_string())
         .filter(|task| !task.is_empty());
-    Some(RenderedBlock { task_id, lines: Vec::new() })
+    Some(RenderedBlock {
+        task_id,
+        lines: Vec::new(),
+    })
 }
 
 fn parse_token(line: &str) -> Option<String> {
@@ -135,149 +138,13 @@ fn report_fake_result(
         .ok()
         .map(|value| value.trim().to_string())
         .filter(|value| !value.is_empty());
-    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
+    let _ = source_content;
     crate::messaging::report_result_for_owner_team(workspace, &envelope, owner_team.as_deref())
         .map_err(|e| FakeWorkerError::Report(e.to_string()))?;
-    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
     writeln!(output, "{}", serde_json::to_string(&envelope)?)?;
     Ok(())
 }
 
-fn mirror_fake_result_to_leader(
-    workspace: &Path,
-    owner_team: Option<&str>,
-    envelope: &serde_json::Value,
-    source_content: Option<&str>,
-) {
-    let Ok(raw_state) = crate::state::persist::load_runtime_state(workspace) else {
-        return;
-    };
-    let state = owner_team
-        .and_then(|team| crate::state::projection::resolve_owner_team_id(&raw_state, team).canonical_key().map(str::to_string))
-        .map(|team| crate::state::projection::project_top_level_view(&raw_state, &team))
-        .unwrap_or(raw_state);
-    let attached = state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("status"))
-        .and_then(serde_json::Value::as_str)
-        == Some("attached");
-    let pane_id = state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("pane_id"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|pane| !pane.is_empty())
-        .map(str::to_string)
-        .or_else(|| owner_team.and_then(|team| claimed_pane_from_events(workspace, team)));
-    let Some(pane_id) = pane_id.filter(|_| attached || owner_team.is_some()) else {
-        return;
-    };
-    let summary = envelope
-        .get("summary")
-        .and_then(serde_json::Value::as_str)
-        .unwrap_or("Fake worker completed");
-    let result_id = envelope
-        .get("result_id")
-        .and_then(serde_json::Value::as_str)
-        .unwrap_or("");
-    let text = match source_content.filter(|content| !content.trim().is_empty()) {
-        Some(content) => format!(
-            "Fake worker result: {summary}\nMessage content: {}\nResult id: {result_id}",
-            content.trim()
-        ),
-        None => format!("Fake worker result: {summary}\nResult id: {result_id}"),
-    };
-    let target = crate::transport::Target::Pane(crate::transport::PaneId::new(&pane_id));
-    let payload = crate::transport::InjectPayload::Text(text.clone());
-    let key = crate::transport::Key::Enter;
-    if let Some(socket) = leader_receiver_full_socket(&state) {
-        let endpoint_backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
-        if crate::transport::Transport::inject(&endpoint_backend, &target, &payload, key, true).is_ok() {
-            mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
-            return;
-        }
-    }
-    let workspace_backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
-    let _ = crate::transport::Transport::inject(&workspace_backend, &target, &payload, key, true);
-    mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
-}
-
-fn leader_receiver_full_socket(state: &serde_json::Value) -> Option<&str> {
-    state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("tmux_socket"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|socket| !socket.is_empty() && Path::new(socket).is_absolute())
-}
-
-fn claimed_pane_from_events(workspace: &Path, owner_team: &str) -> Option<String> {
-    crate::event_log::EventLog::new(workspace)
-        .tail(50)
-        .ok()?
-        .into_iter()
-        .rev()
-        .find_map(|event| {
-            if event.get("event").and_then(serde_json::Value::as_str)
-                != Some("leader_receiver.rebind_applied")
-            {
-                return None;
-            }
-            if event.get("team_id").and_then(serde_json::Value::as_str) != Some(owner_team) {
-                return None;
-            }
-            event
-                .get("new_pane_id")
-                .and_then(serde_json::Value::as_str)
-                .filter(|pane| !pane.is_empty())
-                .map(str::to_string)
-        })
-}
-
-fn agent_id_from_envelope(envelope: &serde_json::Value) -> Option<&str> {
-    envelope.get("agent_id").and_then(serde_json::Value::as_str)
-}
-
-fn mirror_to_team_session_panes(
-    state: &serde_json::Value,
-    workspace: &Path,
-    agent_id: Option<&str>,
-    text: &str,
-) {
-    let Some(session) = state
-        .get("session_name")
-        .and_then(serde_json::Value::as_str)
-        .filter(|session| !session.is_empty())
-    else {
-        return;
-    };
-    let worker_pane = agent_id.and_then(|agent_id| {
-        state
-            .get("agents")
-            .and_then(|agents| agents.get(agent_id))
-            .and_then(|agent| agent.get("pane_id"))
-            .and_then(serde_json::Value::as_str)
-    });
-    if let Some(socket) = leader_receiver_full_socket(state) {
-        let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
-        for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
-            if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
-                continue;
-            }
-            let target = crate::transport::Target::Pane(pane.pane_id);
-            let payload = crate::transport::InjectPayload::Text(text.to_string());
-            let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
-        }
-    }
-    let backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
-    for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
-        if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
-            continue;
-        }
-        let target = crate::transport::Target::Pane(pane.pane_id);
-        let payload = crate::transport::InjectPayload::Text(text.to_string());
-        let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
-    }
-}
-
 fn fake_envelope(
     workspace: &Path,
     agent_id: &str,
@@ -331,7 +198,9 @@ mod tests {
     fn stored_result(ws: &std::path::Path) -> (String, String, String, serde_json::Value) {
         let store = MessageStore::open(ws).unwrap();
         let conn = open_db(store.db_path()).unwrap();
-        let mut stmt = conn.prepare("select task_id, agent_id, status, envelope from results").unwrap();
+        let mut stmt = conn
+            .prepare("select task_id, agent_id, status, envelope from results")
+            .unwrap();
         let row = stmt
             .query_row([], |r| {
                 Ok((
@@ -354,9 +223,18 @@ mod tests {
             ("t1", "w1", "success"),
             "stored result row must be task_id=t1 agent_id=w1 status=success"
         );
-        assert_eq!(env["schema_version"], serde_json::json!("result_envelope_v1"));
-        assert_eq!(env["summary"], serde_json::json!("Fake worker handled message m1"));
-        assert_eq!(env["tests"], serde_json::json!([{"command": "fake-provider", "status": "passed"}]));
+        assert_eq!(
+            env["schema_version"],
+            serde_json::json!("result_envelope_v1")
+        );
+        assert_eq!(
+            env["summary"],
+            serde_json::json!("Fake worker handled message m1")
+        );
+        assert_eq!(
+            env["tests"],
+            serde_json::json!([{"command": "fake-provider", "status": "passed"}])
+        );
         let artifact_path = env["artifacts"][0]["path"].as_str().unwrap_or_default();
         assert!(
             artifact_path.ends_with(".team/logs/w1.scrollback"),
@@ -375,8 +253,14 @@ mod tests {
 
         assert_golden_envelope(&ws);
         let printed = String::from_utf8(out).unwrap();
-        assert!(printed.contains("TEAM_AGENT_FAKE_READY agent=w1"), "must print the READY idle marker; got {printed}");
-        assert!(printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"), "must print the WORKING marker on a non-empty line; got {printed}");
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_READY agent=w1"),
+            "must print the READY idle marker; got {printed}"
+        );
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"),
+            "must print the WORKING marker on a non-empty line; got {printed}"
+        );
     }
 
     // Rendered-message form: a `Team Agent message from leader for t1:` block ending `[team-agent-token:m1]`
@@ -391,6 +275,9 @@ mod tests {
 
         assert_golden_envelope(&ws);
         let printed = String::from_utf8(out).unwrap();
-        assert!(printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"), "rendered form prints WORKING per line; got {printed}");
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"),
+            "rendered form prints WORKING per line; got {printed}"
+        );
     }
 }

package/crates/team-agent/src/lifecycle/display.rs

@@ -11,15 +11,15 @@ use super::*;
 // ── lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建 ────────────
 
 /// `resolve_display_backend(requested, recorded, source)`(`display/backend.py`)。默认
-/// none;非默认非静默发 `display.backend_resolved`。
+/// adaptive;显式 none 是逃生口。
 pub fn resolve_display_backend(
     requested: Option<DisplayBackend>,
     recorded: Option<DisplayBackend>,
 ) -> ResolvedBackend {
-    let backend = requested.or(recorded).unwrap_or(DisplayBackend::None);
+    let backend = requested.or(recorded).unwrap_or(DisplayBackend::Adaptive);
     ResolvedBackend {
         backend,
-        non_default: backend != DisplayBackend::None,
+        non_default: backend != DisplayBackend::Adaptive,
     }
 }