@team-agent/installer 0.3.14 → 0.3.16

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

@@ -158,11 +158,40 @@ 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>,
+    targets_persist_after_kill: bool,
 }
 
 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,
+            targets_persist_after_kill: false,
+        }
+    }
+
+    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
+    }
+
+    fn with_targets_persist_after_kill(mut self) -> Self {
+        self.targets_persist_after_kill = true;
+        self
     }
 }
 
@@ -227,7 +256,11 @@ impl Transport for CleanShutdownTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        if *self.session_present.lock().unwrap() || self.targets_persist_after_kill {
+            Ok(self.targets.clone())
+        } else {
+            Ok(Vec::new())
+        }
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -248,10 +281,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 +301,245 @@ 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 bounded_coordinator_stop_returns_grace_window_late_success() {
+    let ws = tmp_shutdown_workspace("late-coordinator-stop-success");
+    let report = crate::cli::lifecycle_port::stop_coordinator_bounded_with(
+        crate::coordinator::WorkspacePath::new(ws),
+        std::time::Duration::from_millis(5),
+        |_workspace| {
+            std::thread::sleep(std::time::Duration::from_millis(25));
+            Ok(crate::coordinator::StopReport {
+                ok: true,
+                status: crate::coordinator::StopOutcome::Stopped,
+                pid: Some(crate::coordinator::Pid::new(12345)),
+            })
+        },
+    )
+    .expect("late result inside grace window must be returned")
+    .expect("stop result should be ok");
+
+    assert!(report.ok, "late success must not be discarded as timeout");
+    assert_eq!(report.status, crate::coordinator::StopOutcome::Stopped);
+}
+
+#[test]
+fn shutdown_outcome_late_or_postcheck_gone_is_ok_with_lsof_diagnostic() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: false,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Gone,
+        },
+    );
+
+    assert!(out.ok);
+    assert_eq!(out.status, "ok");
+    assert_eq!(out.phase, None);
+}
+
+#[test]
+fn shutdown_outcome_coordinator_timeout_still_running_is_timeout() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: false,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Running,
+        },
+    );
+
+    assert!(!out.ok);
+    assert_eq!(out.status, "timeout");
+    assert_eq!(out.phase, Some("stop_coordinator"));
+}
+
+#[test]
+fn shutdown_outcome_ps_table_degraded_still_partial_after_coordinator_gone() {
+    let out = crate::cli::lifecycle_port::classify_shutdown_outcome(
+        crate::cli::lifecycle_port::ShutdownOutcomeInput {
+            kill_error: false,
+            session_residuals: false,
+            process_residuals: false,
+            cleanup_truth_degraded: true,
+            coordinator_timeout: true,
+            coordinator_stop_ok: None,
+            coordinator_post_stop: crate::cli::lifecycle_port::CoordinatorStopObservation::Gone,
+        },
+    );
+
+    assert!(!out.ok);
+    assert_eq!(out.status, "partial");
+    assert_eq!(out.phase, Some("os_probe"));
+}
+
+#[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"
+    );
+}
+
+#[test]
+fn managed_leader_shutdown_never_kills_server_even_when_socket_looks_exclusive() {
+    let ws = tmp_shutdown_workspace("managed-leader-no-kill-server");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-current",
+            "is_external_leader": false,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new("%1"),
+            session: SessionName::new("team-current"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("leader")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: None,
+            leader_env: BTreeMap::new(),
+        }])
+        .with_targets_persist_after_kill();
+
+    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-current"]));
+    assert_eq!(out["spared_sessions"], json!([]));
+    assert!(
+        !transport.kill_server_called(),
+        "managed topology must clear the team session/window without kill-server"
+    );
+}

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

@@ -36,6 +36,10 @@ use super::*;
         for key in [
             "team",
             "session_name",
+            "leader_topology",
+            "is_external_leader",
+            "leader_attach_command",
+            "leader_client",
             "tmux_session_present",
             "leader_receiver",
             "agents",
@@ -61,6 +65,27 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_status_reports_managed_leader_topology_and_attach_command() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.insert("is_external_leader".to_string(), json!(false));
+            obj.insert("session_name".to_string(), json!("team-current"));
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        assert_eq!(v["leader_topology"], json!("managed"));
+        assert_eq!(v["is_external_leader"], json!(false));
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("managed status includes attach command");
+        assert!(attach.contains("attach -t team-current:leader"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_status_detail_full_keeps_uncompacted_events() {
         // cmd_status --json --detail -> status_port::status(compact=false): the FULL dict

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(),
                 ]);
             }
         }
@@ -201,6 +202,8 @@ pub struct LeaderLauncherArgs {
     pub confirm_attach: bool,
     /// `--attach-session <name>` / `--attach-session=<name>`。
     pub attach_session: Option<String>,
+    /// 0.3.16 topology opt-out: keep the old external/current-pane leader launcher path.
+    pub external_leader: bool,
 }
 
 // =============================================================================
@@ -262,6 +265,7 @@ pub struct QuickStartArgs {
     pub team_id: Option<String>,
     pub yes: bool,
     pub fresh: bool,
+    pub no_display: bool,
     pub json: bool,
 }
 
@@ -304,6 +308,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))),