@team-agent/installer 0.3.13 → 0.3.15

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

@@ -37,6 +37,120 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     Ok(CmdResult::from_json(value, args.json))
 }
 
+pub fn cmd_fallback_send_leader(args: &FallbackSendLeaderArgs) -> Result<CmdResult, CliError> {
+    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
+        return Ok(value);
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    let target = MessageTarget::Single("leader".to_string());
+    let opts = SendOptions {
+        task_id: args.task.as_ref().map(|task| TaskId::new(task.clone())),
+        route_task_id: false,
+        sender: args.sender.clone(),
+        requires_ack: false,
+        wait_visible: false,
+        block_until_delivered: false,
+        team: Some(TeamKey::new(selected.team_key.clone())),
+        message_id: Some(args.message_id.clone()),
+        ..SendOptions::default()
+    };
+    let primary = messaging::send_message(&selected.run_workspace, &target, &args.content, &opts);
+    let message_id = match &primary {
+        Ok(outcome) => outcome
+            .message_id
+            .clone()
+            .unwrap_or_else(|| args.message_id.clone()),
+        Err(_) => args.message_id.clone(),
+    };
+    if let Ok(outcome) = &primary {
+        if is_business_refusal_outcome(outcome) {
+            let value = json!({
+                "ok": false,
+                "status": "refused",
+                "reason": "business_reject",
+                "primary_error": args.primary_error,
+                "message_id": outcome.message_id,
+                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
+            });
+            return Ok(CmdResult::from_json(value, args.json));
+        }
+    }
+
+    let state = selected_state_with_active_key(&selected);
+    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
+    let primary_error = match primary {
+        Ok(outcome) if primary_delivery_succeeded(outcome.status) => {
+            let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
+            if let Some(obj) = value.as_object_mut() {
+                obj.insert("fallback_used".to_string(), json!(false));
+                obj.insert("primary_error".to_string(), json!(args.primary_error));
+            }
+            return Ok(CmdResult::from_json(value, args.json));
+        }
+        Ok(outcome) => format!(
+            "{}; fallback_cli_primary_status={}",
+            args.primary_error,
+            delivery_status_wire(outcome.status)
+        ),
+        Err(error) => format!("{}; fallback_cli_primary_error={error}", args.primary_error),
+    };
+    let outcome = messaging::deliver_to_leader_fallback_pane(
+        &selected.run_workspace,
+        &state,
+        &message_id,
+        None,
+        &args.content,
+        false,
+        Some(&primary_error),
+        &event_log,
+    )?;
+    let mut value = delivery_outcome_json(&outcome, &target, &args.content, &opts);
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("primary_error".to_string(), json!(args.primary_error));
+        obj.insert("delivered_via".to_string(), json!("fallback_pane"));
+        obj.insert(
+            "next_action".to_string(),
+            json!("run team-agent restart-agent to refresh the worker MCP transport"),
+        );
+    }
+    Ok(CmdResult::from_json(value, args.json))
+}
+
+pub fn cmd_fallback_report_result(args: &FallbackReportResultArgs) -> Result<CmdResult, CliError> {
+    if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
+        return Ok(value);
+    }
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    let envelope = fallback_result_envelope(args)?;
+    let value = messaging::report_result_for_owner_team_with_primary_error(
+        &selected.run_workspace,
+        &envelope,
+        Some(&selected.team_key),
+        Some(&args.primary_error),
+    )?;
+    let mut value = value;
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("primary_error".to_string(), json!(args.primary_error));
+        obj.insert(
+            "fallback_protocol".to_string(),
+            json!("fallback-report-result"),
+        );
+        obj.insert(
+            "next_action".to_string(),
+            json!("run team-agent restart-agent to refresh the worker MCP transport"),
+        );
+    }
+    Ok(CmdResult::from_json(value, args.json))
+}
+
 fn routing_ambiguous_value(
     workspace: &Path,
     args: &SendArgs,
@@ -77,6 +191,101 @@ fn routing_ambiguous_value(
     }))
 }
 
+fn selected_state_with_active_key(selected: &crate::state::selector::SelectedTeam) -> Value {
+    let mut state = selected.state.clone();
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert(
+            "active_team_key".to_string(),
+            Value::String(selected.team_key.clone()),
+        );
+    }
+    state
+}
+
+fn fallback_result_envelope(args: &FallbackReportResultArgs) -> Result<Value, CliError> {
+    let mut envelope: Value = serde_json::from_str(&args.result_json)?;
+    let Some(obj) = envelope.as_object_mut() else {
+        return Err(CliError::Usage(
+            "--result-json must be a JSON object".to_string(),
+        ));
+    };
+    obj.entry("schema_version".to_string())
+        .or_insert_with(|| json!("result_envelope_v1"));
+    obj.entry("task_id".to_string())
+        .or_insert_with(|| json!(args.task_id));
+    obj.entry("agent_id".to_string())
+        .or_insert_with(|| json!(args.agent_id));
+    obj.entry("status".to_string())
+        .or_insert_with(|| json!("success"));
+    obj.entry("summary".to_string())
+        .or_insert_with(|| json!("completed"));
+    for key in ["changes", "tests", "risks", "artifacts", "next_actions"] {
+        obj.entry(key.to_string()).or_insert_with(|| json!([]));
+    }
+    Ok(envelope)
+}
+
+fn fallback_business_refusal(primary_error: &str, as_json: bool) -> Option<CmdResult> {
+    is_business_reject_text(primary_error).then(|| {
+        CmdResult::from_json(
+            json!({
+                "ok": false,
+                "status": "refused",
+                "reason": "business_reject",
+                "primary_error": primary_error,
+                "action": "N38 fallback refused: business rule refusals must not use fallback pane delivery",
+            }),
+            as_json,
+        )
+    })
+}
+
+fn is_business_refusal_outcome(outcome: &DeliveryOutcome) -> bool {
+    matches!(
+        outcome.reason,
+        Some(
+            DeliveryRefusal::TargetNotInTeam
+                | DeliveryRefusal::HumanConfirmationRequired
+                | DeliveryRefusal::MissingPermissions
+                | DeliveryRefusal::UnknownRecipient
+                | DeliveryRefusal::TeamOwnerMismatch
+                | DeliveryRefusal::Ambiguous
+                | DeliveryRefusal::RecipientPaneInNonInputMode
+                | DeliveryRefusal::SessionDrift
+                | DeliveryRefusal::RoutingAmbiguous
+                | DeliveryRefusal::EmptyTargetList
+        )
+    )
+}
+
+fn primary_delivery_succeeded(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
+    )
+}
+
+fn is_business_reject_text(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    [
+        "peer_not_in_scope",
+        "target_not_in_team",
+        "permission denied",
+        "missing_permissions",
+        "human_confirmation_required",
+        "unknown_recipient",
+        "routing_ambiguous",
+        "quota",
+        "rate limit",
+        "rate_limit",
+        "blacklist",
+        "blacklisted",
+        "forbidden",
+    ]
+    .iter()
+    .any(|needle| lower.contains(needle))
+}
+
 /// `_send_target`(`commands.py:181-184`):`--to` comma-split fanout / `target` 单值 / None。
 pub fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
     if let Some(targets) = targets.filter(|s| !s.is_empty()) {
@@ -221,3 +430,46 @@ fn delivery_stage_wire(stage: DeliveryStage) -> &'static str {
         DeliveryStage::VisibleCheck => "visible_check",
     }
 }
+
+#[cfg(test)]
+mod e23_tests {
+    use super::*;
+
+    #[test]
+    fn fallback_error_classifier_allows_transport_and_primary_bugs() {
+        for error in [
+            "Transport closed",
+            "Connection refused",
+            "Broken pipe",
+            "EOF on transport",
+            "MCP timeout after 5s",
+            "internal assertion failed: unwrap on Err",
+            "primary_delivery_error: serialize failed",
+        ] {
+            assert!(
+                !is_business_reject_text(error),
+                "failure should be fallback-eligible, not classified as a business refusal: {error}"
+            );
+        }
+    }
+
+    #[test]
+    fn fallback_error_classifier_blocks_business_refusals() {
+        for error in [
+            "peer_not_in_scope",
+            "target_not_in_team",
+            "permission denied",
+            "missing_permissions",
+            "human_confirmation_required",
+            "unknown_recipient",
+            "quota exceeded",
+            "rate_limit",
+            "blacklisted target",
+        ] {
+            assert!(
+                is_business_reject_text(error),
+                "business refusal must not use fallback pane delivery: {error}"
+            );
+        }
+    }
+}

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

@@ -206,6 +206,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: true,
             fresh: false,
+            no_display: false,
             json: true,
         };
         let _ = cmd_quick_start(&args); // real quick_start compiles the spec before any coordinator/launch step
@@ -240,6 +241,7 @@ fn current_uid() -> Option<String> {
             team_id: None,
             yes: false,
             fresh: false,
+            no_display: false,
             json: true,
         };
         let text = outcome_text(cmd_quick_start(&args));
@@ -275,15 +277,25 @@ fn current_uid() -> Option<String> {
         );
     }
 
-    // 4 [P1] — cmd_add_agent with a DUPLICATE agent id surfaces the REAL crate::lifecycle::add_agent
-    // "agent id already exists" error (launch.rs:252). The placeholder returns {ok:true} -> RED.
-    // OS-safe (the dup check fires before compile/spawn).
+    // 4 [P1] — cmd_add_agent with a DUPLICATE runtime agent id surfaces the REAL
+    // crate::lifecycle::add_agent "agent id already exists" error. E25: role docs/spec files are
+    // inputs, not membership; duplicate membership is runtime-state based.
     #[test]
     fn cli_add_agent_duplicate_id_surfaces_real_error() {
         let team = deleg_uniq_dir("addagent");
         std::fs::create_dir_all(team.join("agents")).unwrap();
         std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
         std::fs::write(team.join("agents").join("implementer.md"), DELEG_VALID_ROLE).unwrap(); // 'implementer' already exists
+        crate::state::persist::save_runtime_state(
+            &team,
+            &json!({
+                "session_name": "team-deleg-addagent",
+                "agents": {
+                    "implementer": {"status": "running", "provider": "codex", "window": "implementer"}
+                }
+            }),
+        )
+        .unwrap();
         let dup_role = team.join("dup-role.md");
         std::fs::write(&dup_role, DELEG_VALID_ROLE).unwrap(); // role file must exist
         let args = AddAgentArgs {

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))),