@team-agent/installer 0.3.2 → 0.3.4

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

@@ -37,10 +37,24 @@ use rusqlite::params;
             .cloned()
             .unwrap_or_else(|| json!({}));
         let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
+        let tmux_present = tmux_session_present(workspace, session_name.as_str());
+        let mut readiness_state = state.clone();
+        if let Some(obj) = readiness_state.as_object_mut() {
+            obj.insert("tmux_session_present".to_string(), serde_json::json!(tmux_present));
+        }
+        let readiness = crate::cli::diagnose::wait_readiness(&readiness_state);
         let full = json!({
+            "ok": true,
             "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
             "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
-            "tmux_session_present": tmux_session_present(workspace, session_name.as_str()),
+            "tmux_session_present": tmux_present,
+            "all_spawned": readiness.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
+            "all_attached_receiver": readiness.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),
+            "all_resumable_have_session": readiness.get("all_resumable_have_session").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_complete": readiness.get("session_capture_complete").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_incomplete": readiness.get("session_capture_incomplete").cloned().unwrap_or(Value::Bool(false)),
+            "incomplete_session_capture_agents": readiness.get("incomplete_session_capture_agents").cloned().unwrap_or_else(|| json!([])),
+            "pending_session_agent_ids": readiness.get("pending_session_agent_ids").cloned().unwrap_or_else(|| json!([])),
             "leader_receiver": leader_receiver,
             "teams": state.get("teams").cloned().unwrap_or_else(|| json!({})),
             "agents": agents,
@@ -50,6 +64,7 @@ use rusqlite::params;
             "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
             "results": result_counts(&conn, owner_team_id)?,
             "latest_results": json!([]),
+            "readiness": readiness,
             "coordinator": coordinator_health_value(health),
             "last_events": Value::Array(
                 crate::event_log::EventLog::new(workspace)
@@ -401,6 +416,13 @@ use rusqlite::params;
             "team": full.get("team").cloned().unwrap_or(Value::Null),
             "session_name": full.get("session_name").cloned().unwrap_or(Value::Null),
             "tmux_session_present": full.get("tmux_session_present").cloned().unwrap_or(Value::Bool(false)),
+            "all_spawned": full.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
+            "all_attached_receiver": full.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),
+            "all_resumable_have_session": full.get("all_resumable_have_session").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_complete": full.get("session_capture_complete").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_incomplete": full.get("session_capture_incomplete").cloned().unwrap_or(Value::Bool(false)),
+            "incomplete_session_capture_agents": full.get("incomplete_session_capture_agents").cloned().unwrap_or_else(|| json!([])),
+            "pending_session_agent_ids": full.get("pending_session_agent_ids").cloned().unwrap_or_else(|| json!([])),
             "leader_receiver": compact_object(full.get("leader_receiver"), &[
                 "status", "provider", "mode", "session_name", "window_name", "pane_id", "pane_current_command",
             ]),
@@ -411,6 +433,7 @@ use rusqlite::params;
             "queued_messages": take_array(full.get("queued_messages"), 8),
             "results": full.get("results").cloned().unwrap_or_else(|| json!({})),
             "latest_results": take_array(full.get("latest_results"), 5),
+            "readiness": full.get("readiness").cloned().unwrap_or_else(|| json!({})),
             "coordinator": compact_object(full.get("coordinator"), &["status", "pid", "metadata_ok", "schema_ok"]),
             "last_events": take_array_tail(full.get("last_events"), 10),
         })
@@ -470,7 +493,7 @@ use rusqlite::params;
         };
         Value::Array(
             tasks.iter()
-                .map(|task| compact_object(Some(task), &["id", "title", "status", "assignee", "type"]))
+                .map(|task| compact_object(Some(task), &["id", "title", "status", "assignee", "type", "accepted_result_id"]))
                 .collect(),
         )
     }

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

@@ -456,7 +456,7 @@ Hint: team-agent inbox leader";
     // Rust always does CmdResult::from_json -> CmdOutput::Json (wrong shape).
     #[test]
     fn red_cmd_doctor_comms_human_is_boundary_text_plus_sorted_json() {
-        const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency. Does NOT perform live runtime message round-trip. comms contract suite deferred to 0.2.9 (test files not shipped). (zero token, zero pollution)";
+        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)";
         let args = DoctorArgs {
             spec: None,
             workspace: PathBuf::from("."),
@@ -506,4 +506,3 @@ Hint: team-agent inbox leader";
         assert_eq!(run(&["codex".to_string(), "-h".to_string()], Path::new(".")), ExitCode::Ok);
         assert_eq!(run(&["claude".to_string(), "-h".to_string()], Path::new(".")), ExitCode::Ok);
     }
-

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

@@ -216,27 +216,35 @@ use super::*;
     // the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
     #[test]
     fn comms_selftest_golden_boundary_scope_and_check_shapes() {
-        let boundary = "validates live pane binding consistency. Does NOT perform live runtime message \
-                        round-trip. comms contract suite deferred to 0.2.9 (test files not shipped). \
-                        (zero token, zero pollution)";
+        let boundary = "validates live pane binding consistency and zero-token comms contracts. \
+                        Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
         let ws = tmp_workspace();
         let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
         let obj = v.as_object().expect("comms dict");
         assert_eq!(v["boundary"], json!(boundary), "golden COMMS_BOUNDARY_TEXT prefix (comms.py:11-14)");
         assert_eq!(v["scope"], json!("binding_consistency"), "golden scope");
-        assert_eq!(v["status"], json!("pass"), "empty-state selftest passes (all checks pass/deferred)");
+        assert_eq!(
+            v["status"],
+            json!("fail"),
+            "empty workspace has no runtime receiver binding, so comms gate must not pass"
+        );
         assert!(obj.contains_key("run_id"), "golden carries a run_id (uuid hex[:12])");
         assert!(!obj.contains_key("team"), "golden has NO `team` key");
         assert!(!obj.contains_key("gate"), "golden has NO `gate` key");
-        assert_eq!(
-            v["checks"]["contract_suite"],
-            json!({
-                "status": "deferred",
-                "deferred_to": "0.2.9",
-                "reason": "contract test files not shipped with package",
-                "message": "comms contract verification deferred to 0.2.9; contract test files not shipped with package",
-            }),
-            "golden contract_suite check (comms.py:132-139)"
+        assert_eq!(v["checks"]["contract_suite"]["status"], json!("pass"));
+        assert_eq!(v["checks"]["contract_suite"]["failed"], json!([]));
+        let suite_names: Vec<&str> = v["checks"]["contract_suite"]["checks"]
+            .as_array()
+            .expect("contract suite checks")
+            .iter()
+            .filter_map(|check| check.get("name").and_then(Value::as_str))
+            .collect();
+        assert!(
+            suite_names.contains(&"message_store_schema")
+                && suite_names.contains(&"message_token_shape")
+                && suite_names.contains(&"result_notification_render")
+                && suite_names.contains(&"leader_projection_owner_team"),
+            "contract suite must be executable, not deferred: {suite_names:?}"
         );
         assert_eq!(
             v["checks"]["provider_sdk_calls"]["calls"],
@@ -271,6 +279,8 @@ use super::*;
     // {ok,scanned,orphans,dry_run:true,scanned_at,action_required}. RUST mod.rs:534-535 stub
     // {ok,confirm,cleaned}. scanned/scanned_at are machine/clock-derived; lock the deterministic ones. RED.
     #[test]
+    #[ignore = "real-machine: cleanup_orphans scans machine-wide ta-* tmux/process residue"]
+    #[serial_test::file_serial(tmux)]
     fn cleanup_orphans_dryrun_golden_envelope() {
         let v = diagnose_port::cleanup_orphans(/*confirm=*/ false).expect("cleanup_orphans");
         let obj = v.as_object().expect("cleanup dict");

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

@@ -263,6 +263,8 @@ fn seed_team_spec(ws: &std::path::Path) {
             agent: "w1".to_string(),
             workspace: ws.clone(),
             tail: 20,
+            head: None,
+            search: None,
             allow_raw_screen: true,
             json: true,
         };

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

@@ -4,6 +4,39 @@ struct TeamSocketGuard {
     ws: std::path::PathBuf,
 }
 
+struct EnvGuard {
+    previous: Vec<(&'static str, Option<String>)>,
+}
+
+impl EnvGuard {
+    fn unset(keys: &[&'static str]) -> Self {
+        let previous = keys
+            .iter()
+            .map(|key| (*key, std::env::var(key).ok()))
+            .collect::<Vec<_>>();
+        for key in keys {
+            unsafe {
+                std::env::remove_var(key);
+            }
+        }
+        Self { previous }
+    }
+}
+
+impl Drop for EnvGuard {
+    fn drop(&mut self) {
+        for (key, value) in self.previous.drain(..).rev() {
+            unsafe {
+                if let Some(value) = value {
+                    std::env::set_var(key, value);
+                } else {
+                    std::env::remove_var(key);
+                }
+            }
+        }
+    }
+}
+
 impl Drop for TeamSocketGuard {
     fn drop(&mut self) {
         crate::tmux_backend::TmuxBackend::for_workspace(&self.ws).kill_server();
@@ -122,7 +155,18 @@ fn current_uid() -> Option<String> {
     #[ignore = "real-machine: quick-start --yes spawns a real team (tmux) + coordinator daemon"]
     fn run_dispatches_quick_start_compiles_spec() {
         // The full quick-start path spawns workers + the coordinator; on a real machine we assert it
-        // dispatched to cmd_quick_start (team.spec.yaml compiled under the team dir) + ExitCode::Ok.
+        // dispatched to cmd_quick_start (team.spec.yaml compiled under the team dir). With no positive
+        // caller pane, honest-readiness reports leader_receiver_unbound and exits nonzero.
+        let _env = EnvGuard::unset(&[
+            "TMUX",
+            "TMUX_PANE",
+            "TEAM_AGENT_ID",
+            "TEAM_AGENT_TEAM_ID",
+            "TEAM_AGENT_LEADER_PANE_ID",
+            "TEAM_AGENT_LEADER_SESSION_UUID",
+            "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+            "TEAM_AGENT_LEADER_PROVIDER",
+        ]);
         let dir = std::env::temp_dir().join(format!("ta-cli-qs-{}", std::process::id()));
         std::fs::create_dir_all(dir.join("agents")).unwrap();
         std::fs::write(dir.join("TEAM.md"), "---\nname: t\nobjective: o\nprovider: codex\n---\n\nteam.\n").unwrap();
@@ -134,7 +178,11 @@ fn current_uid() -> Option<String> {
         let argv = vec!["quick-start".to_string(), dir.to_string_lossy().to_string(), "--yes".to_string()];
         let exit = run(&argv, Path::new("."));
         assert!(dir.join("team.spec.yaml").exists(), "quick-start must compile the spec under the team dir");
-        assert_eq!(exit, ExitCode::Ok);
+        assert_eq!(
+            exit,
+            ExitCode::Error,
+            "quick-start must still dispatch and compile, but an unbound leader receiver is an honest-readiness failure, not ExitCode::Ok"
+        );
     }
 
     // =========================================================================
@@ -200,7 +248,13 @@ fn current_uid() -> Option<String> {
     #[test]
     fn cli_restart_missing_spec_surfaces_real_teamselect() {
         let ws = deleg_uniq_dir("restart"); // no team.spec.yaml
-        let args = RestartArgs { workspace: ws, team: None, allow_fresh: false, json: true };
+        let args = RestartArgs {
+            workspace: ws,
+            team: None,
+            allow_fresh: false,
+            session_converge_deadline_ms: None,
+            json: true,
+        };
         let text = outcome_text(cmd_restart(&args));
         assert!(
             text.contains("missing spec for restart"),

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

@@ -2,6 +2,8 @@
 //! 每子命令的 clap-style arg 结构 / 五行 summary 计数桶。
 
 use super::*;
+use crate::provider::Provider;
+use crate::transport::PaneId;
 
 // =============================================================================
 // ERRORS / EXIT(helpers.py `_emit_cli_error` / `_cli_error_payload`)
@@ -363,6 +365,18 @@ pub struct ClaimLeaderArgs {
     pub json: bool,
 }
 
+/// `attach-leader` public CLI args. `cmd_attach_leader` consumes the typed pane/provider
+/// fields and returns/writes a `leader_receiver` binding through the leader lease port.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AttachLeaderArgs {
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub pane: Option<PaneId>,
+    pub provider: Provider,
+    pub confirm: bool,
+    pub json: bool,
+}
+
 /// `identity`(`parser.py:256`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct IdentityArgs {
@@ -386,6 +400,7 @@ pub struct RestartArgs {
     pub workspace: PathBuf,
     pub team: Option<String>,
     pub allow_fresh: bool,
+    pub session_converge_deadline_ms: Option<u64>,
     pub json: bool,
 }
 
@@ -601,6 +616,8 @@ pub struct PeekArgs {
     pub agent: String,
     pub workspace: PathBuf,
     pub tail: usize,
+    pub head: Option<usize>,
+    pub search: Option<String>,
     pub allow_raw_screen: bool,
     pub json: bool,
 }

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":"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"}]}"#;
+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"}]}"#;
 
 #[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":"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"}]}"#;
+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"}]}"#;
 
 #[test]
 fn compile_two_agents_sorted_by_filename_with_routing_and_startup_order() {

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

@@ -158,7 +158,7 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
         let tools = required_tools(&meta, &path)?;
         let prompt_inline = non_empty_trimmed(&body).unwrap_or_else(|| role.clone());
         agent_ids.push(id.clone());
-        agents.push(map(vec![
+        let mut agent_items = vec![
             ("id", Value::Str(id.clone())),
             ("role", Value::Str(role.clone())),
             ("provider", Value::Str(provider)),
@@ -186,7 +186,11 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
                     ),
                 ]),
             ),
-        ]));
+        ];
+        if let Some(profile) = string_field(&meta, "profile") {
+            agent_items.push(("profile", Value::Str(profile)));
+        }
+        agents.push(map(agent_items));
     }
 
     let default_assignee = agent_ids.first().cloned().unwrap_or_default();
@@ -267,7 +271,7 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
                     "display_backend",
                     Value::Str(
                         string_field(&team_meta, "display_backend")
-                            .unwrap_or_else(|| "adaptive".to_string()),
+                            .unwrap_or_else(|| "none".to_string()),
                     ),
                 ),
                 ("session_name", Value::Str(session_name(&team_meta, &team_name))),
@@ -409,10 +413,16 @@ fn resolve_model(role_meta: &Value, team_meta: &Value, provider: &str) -> Value
     if let Some(model) = string_field(role_meta, "model") {
         return Value::Str(model);
     }
-    provider_model(team_meta, provider)
+    if let Some(model) = provider_model(team_meta, provider)
         .or_else(|| string_field(team_meta, "default_model"))
-        .map(Value::Str)
-        .or_else(|| builtin_provider_model(provider).map(|m| Value::Str(m.to_string())))
+    {
+        return Value::Str(model);
+    }
+    if role_meta.get("profile").is_some() {
+        return Value::Null;
+    }
+    builtin_provider_model(provider)
+        .map(|m| Value::Str(m.to_string()))
         .unwrap_or(Value::Null)
 }
 

package/crates/team-agent/src/coordinator/health.rs

@@ -147,15 +147,7 @@ pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopErr
             pid: Some(pid),
         });
     }
-    let Ok(pid_t) = libc::pid_t::try_from(pid.get()) else {
-        return Ok(StopReport {
-            ok: false,
-            status: StopOutcome::KillFailed,
-            pid: Some(pid),
-        });
-    };
-    let rc = unsafe { libc::kill(pid_t, libc::SIGTERM) };
-    if rc != 0 {
+    if !terminate_pid(pid) {
         return Ok(StopReport {
             ok: false,
             status: StopOutcome::KillFailed,
@@ -206,9 +198,11 @@ fn stop_discovered_coordinators(
 }
 
 fn discover_coordinator_pids(workspace: &WorkspacePath) -> Vec<Pid> {
-    let output = match Command::new("ps")
-        .args(["-axo", "pid=,command="])
-        .output()
+    let output = match crate::os_probe::bounded_command_output_with_probe(
+        Command::new("ps").args(["-axo", "pid=,command="]),
+        "ps_table",
+        None,
+    )
     {
         Ok(output) if output.status.success() => output,
         _ => return Vec::new(),
@@ -259,13 +253,86 @@ fn terminate_pid(pid: Pid) -> bool {
     if pid_is_running(pid).ok() == Some(false) {
         return true;
     }
-    if !send_signal(pid, libc::SIGTERM) {
-        return false;
+    let pids = process_tree_pids(pid);
+    for child in pids.iter().rev() {
+        let _ = send_signal(*child, libc::SIGTERM);
     }
-    if wait_until_not_running(pid, Duration::from_millis(750)) {
-        return true;
+    if !wait_until_all_not_running(&pids, Duration::from_secs(5)) {
+        for child in pids.iter().rev() {
+            let _ = send_signal(*child, libc::SIGKILL);
+        }
+    }
+    wait_until_all_not_running(&pids, Duration::from_secs(5))
+}
+
+/// Public wrapper for diagnostic cleanup paths that must reuse coordinator
+/// shutdown's SIGTERM-then-SIGKILL semantics.
+pub fn terminate_pid_tree(pid: Pid) -> bool {
+    terminate_pid(pid)
+}
+
+fn process_tree_pids(root: Pid) -> Vec<Pid> {
+    let root_pid = root.get();
+    let pairs = crate::os_probe::bounded_command_output_with_probe(
+        Command::new("ps").args(["-axo", "pid=,ppid="]),
+        "ps_parent",
+        None,
+    )
+        .ok()
+        .map(|out| String::from_utf8_lossy(&out.stdout).to_string())
+        .unwrap_or_default()
+        .lines()
+        .filter_map(|line| {
+            let mut parts = line.split_whitespace();
+            let pid = parts.next()?.parse::<u32>().ok()?;
+            let ppid = parts.next()?.parse::<u32>().ok()?;
+            Some((pid, ppid))
+        })
+        .collect::<Vec<_>>();
+    let mut out = Vec::new();
+    collect_child_pids(root_pid, &pairs, &mut out);
+    out.push(root_pid);
+    out.sort_unstable();
+    out.dedup();
+    out.into_iter().map(Pid::new).collect()
+}
+
+fn collect_child_pids(parent: u32, pairs: &[(u32, u32)], out: &mut Vec<u32>) {
+    for (pid, ppid) in pairs {
+        if *ppid == parent && !out.contains(pid) {
+            out.push(*pid);
+            collect_child_pids(*pid, pairs, out);
+        }
+    }
+}
+
+fn wait_until_all_not_running(pids: &[Pid], timeout: Duration) -> bool {
+    let start = std::time::Instant::now();
+    loop {
+        for pid in pids {
+            reap_child_if_possible(*pid);
+        }
+        if pids
+            .iter()
+            .all(|pid| pid_is_running(*pid).ok() != Some(true))
+        {
+            return true;
+        }
+        if start.elapsed() >= timeout {
+            return false;
+        }
+        std::thread::sleep(Duration::from_millis(25));
+    }
+}
+
+fn reap_child_if_possible(pid: Pid) {
+    let Ok(pid_t) = libc::pid_t::try_from(pid.get()) else {
+        return;
+    };
+    let mut status = 0;
+    unsafe {
+        libc::waitpid(pid_t, &mut status, libc::WNOHANG);
     }
-    send_signal(pid, libc::SIGKILL) && wait_until_not_running(pid, Duration::from_millis(750))
 }
 
 fn send_signal(pid: Pid, signal: libc::c_int) -> bool {
@@ -306,9 +373,11 @@ pub fn pid_is_running(pid: Pid) -> Result<bool, std::io::Error> {
             _ => Err(err),
         };
     }
-    let out = Command::new("ps")
-        .args(["-p", &pid.to_string(), "-o", "stat="])
-        .output()?;
+    let out = crate::os_probe::bounded_command_output_with_probe(
+        Command::new("ps").args(["-p", &pid.to_string(), "-o", "stat="]),
+        "ps_table",
+        Some(pid.get()),
+    )?;
     if !out.status.success() {
         return Ok(false);
     }

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

@@ -64,6 +64,8 @@ use serde_json::Value;
 pub mod backoff;
 pub mod health;
 pub mod orphan;
+pub mod runtime_detectors;
+pub mod runtime_observation;
 pub mod tick;
 pub mod types;
 
@@ -75,6 +77,8 @@ pub use tick::*;
 pub use backoff::*;
 pub use orphan::*;
 pub use health::*;
+pub use runtime_detectors::*;
+pub use runtime_observation::*;
 
 #[cfg(test)]
 mod tests;