@team-agent/installer 0.3.1 → 0.3.3

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

@@ -1,11 +1,25 @@
 //! status_port extracted from cli::mod inline placeholder.
 use super::*;
+use crate::state::projection::OwnerTeamResolution;
 use crate::transport::Transport;
+use rusqlite::params;
 
     /// `status.status(workspace, as_json, compact)`(`queries.py:33`,**有副作用**:capture→refresh→save)。
     pub fn status(workspace: &Path, compact: bool, detail: bool) -> Result<Value, CliError> {
-        let _ = detail;
         let state = read_runtime_state(workspace);
+        status_scoped(workspace, &state, None, compact, detail)
+    }
+
+    pub fn status_scoped(
+        workspace: &Path,
+        state: &Value,
+        owner_team_id: Option<&str>,
+        compact: bool,
+        detail: bool,
+    ) -> Result<Value, CliError> {
+        let _ = detail;
+        let resolved_owner_team_id = resolve_status_owner_team(workspace, owner_team_id)?;
+        let owner_team_id = resolved_owner_team_id.as_deref().or(owner_team_id);
         let health = crate::coordinator::coordinator_health(
             &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
         );
@@ -23,19 +37,34 @@ use crate::transport::Transport;
             .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,
-            "agent_health": agent_health(&conn)?,
+            "agent_health": agent_health(&conn, owner_team_id)?,
             "tasks": tasks,
-            "messages": message_counts(&conn)?,
-            "queued_messages": queued_messages(&conn, 8)?,
-            "results": result_counts(&conn)?,
+            "messages": message_counts(&conn, owner_team_id)?,
+            "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)
@@ -51,7 +80,17 @@ use crate::transport::Transport;
     }
     /// `status.format_status(workspace, agent)`(人读)。
     pub fn format_status(workspace: &Path, agent: Option<&str>) -> Result<String, CliError> {
-        let status = status(workspace, true, false)?;
+        let state = read_runtime_state(workspace);
+        format_status_scoped(workspace, &state, None, agent)
+    }
+
+    pub fn format_status_scoped(
+        workspace: &Path,
+        state: &Value,
+        owner_team_id: Option<&str>,
+        agent: Option<&str>,
+    ) -> Result<String, CliError> {
+        let status = status_scoped(workspace, state, owner_team_id, true, false)?;
         Ok(match agent {
             Some(agent) => format!("agent {agent}: {}", status.pointer("/agents").is_some()),
             None => crate::cli::format_status_summary(&status),
@@ -165,6 +204,32 @@ use crate::transport::Transport;
             .unwrap_or_else(|| json!({}))
     }
 
+    fn resolve_status_owner_team(
+        workspace: &Path,
+        owner_team_id: Option<&str>,
+    ) -> Result<Option<String>, CliError> {
+        let Some(requested) = owner_team_id.filter(|team| !team.is_empty()) else {
+            return Ok(None);
+        };
+        let state = read_runtime_state(workspace);
+        match crate::state::projection::resolve_owner_team_id(&state, requested) {
+            OwnerTeamResolution::Canonical(canonical) => Ok(Some(canonical)),
+            OwnerTeamResolution::LegacyAlias { requested, canonical } => {
+                let log = crate::event_log::EventLog::new(workspace);
+                crate::messaging::delivery::normalize_owner_team_id_rows(
+                    workspace,
+                    &requested,
+                    &canonical,
+                    None,
+                    Some(&log),
+                )
+                .map_err(CliError::from)?;
+                Ok(Some(canonical))
+            }
+            OwnerTeamResolution::Unresolved { .. } | OwnerTeamResolution::Ambiguous { .. } => Ok(None),
+        }
+    }
+
     fn agent_window(agent_id: &str, agent_state: &Value) -> String {
         ["window", "window_name"]
             .iter()
@@ -224,15 +289,15 @@ use crate::transport::Transport;
             .unwrap_or(false)
     }
 
-    fn message_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        status_counts(conn, "messages")
+    fn message_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        status_counts(conn, "messages", owner_team_id)
     }
 
-    fn result_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let by_status = result_status_counts(conn)?;
-        let total = count_rows(conn, "results")?;
-        let invalid = count_where_status(conn, "results", "invalid")?;
-        let collected = count_where_status(conn, "results", "collected")?;
+    fn result_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let by_status = result_status_counts(conn, owner_team_id)?;
+        let total = count_rows(conn, "results", owner_team_id)?;
+        let invalid = count_where_status(conn, "results", owner_team_id, "invalid")?;
+        let collected = count_where_status(conn, "results", owner_team_id, "collected")?;
         let uncollected = total.saturating_sub(collected).saturating_sub(invalid);
         Ok(json!({
             "total": total,
@@ -243,10 +308,24 @@ use crate::transport::Transport;
         }))
     }
 
-    fn status_counts(conn: &rusqlite::Connection, table: &str) -> Result<Value, CliError> {
-        let sql = format!("select status, count(*) from {table} group by status order by status");
+    fn status_counts(
+        conn: &rusqlite::Connection,
+        table: &str,
+        owner_team_id: Option<&str>,
+    ) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => format!(
+                "select status, count(*) from {table}
+                 where owner_team_id = ?1
+                 group by status order by status"
+            ),
+            None => format!("select status, count(*) from {table} group by status order by status"),
+        };
         let mut stmt = conn.prepare(&sql).map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -256,16 +335,28 @@ use crate::transport::Transport;
         Ok(Value::Object(out))
     }
 
-    fn result_status_counts(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let mut stmt = conn
-            .prepare(
+    fn result_status_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select status, count(*) from results
+                 where status not in ('collected', 'invalid') and owner_team_id = ?1
+                 group by status
+                 order by status"
+            }
+            None => {
                 "select status, count(*) from results
                  where status not in ('collected', 'invalid')
                  group by status
-                 order by status",
-            )
+                 order by status"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let status: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -275,19 +366,32 @@ use crate::transport::Transport;
         Ok(Value::Object(out))
     }
 
-    fn queued_messages(conn: &rusqlite::Connection, limit: usize) -> Result<Value, CliError> {
+    fn queued_messages(
+        conn: &rusqlite::Connection,
+        owner_team_id: Option<&str>,
+        limit: usize,
+    ) -> Result<Value, CliError> {
         let limit = i64::try_from(limit).unwrap_or(i64::MAX);
-        let mut stmt = conn
-            .prepare(
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select message_id, recipient, status, created_at, delivery_attempts
+                 from messages
+                 where status like 'queued%' and owner_team_id = ?1
+                 order by created_at desc
+                 limit ?2"
+            }
+            None => {
                 "select message_id, recipient, status, created_at, delivery_attempts
                  from messages
                  where status like 'queued%'
                  order by created_at desc
-                 limit ?1",
-            )
+                 limit ?1"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let rows = stmt
-            .query_map([limit], |row| {
+        let map_row = |row: &rusqlite::Row<'_>| {
                 Ok(json!({
                     "message_id": row.get::<_, String>(0)?,
                     "recipient": row.get::<_, Option<String>>(1)?,
@@ -295,8 +399,12 @@ use crate::transport::Transport;
                     "created_at": row.get::<_, Option<String>>(3)?,
                     "delivery_attempts": row.get::<_, i64>(4)?,
                 }))
-            })
-            .map_err(|e| CliError::Runtime(e.to_string()))?;
+            };
+        let rows = match owner_team_id {
+            Some(team) => stmt.query_map(params![team, limit], map_row),
+            None => stmt.query_map(params![limit], map_row),
+        }
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
         let values = rows
             .collect::<Result<Vec<_>, _>>()
             .map_err(|e| CliError::Runtime(e.to_string()))?;
@@ -308,6 +416,13 @@ use crate::transport::Transport;
             "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",
             ]),
@@ -318,6 +433,7 @@ use crate::transport::Transport;
             "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),
         })
@@ -377,7 +493,7 @@ use crate::transport::Transport;
         };
         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(),
         )
     }
@@ -410,30 +526,63 @@ use crate::transport::Transport;
         Value::Array(items.iter().skip(start).cloned().collect())
     }
 
-    fn count_rows(conn: &rusqlite::Connection, table: &str) -> Result<i64, CliError> {
-        let sql = format!("select count(*) from {table}");
-        conn.query_row(&sql, [], |row| row.get::<_, i64>(0))
-            .map_err(|e| CliError::Runtime(e.to_string()))
+    fn count_rows(
+        conn: &rusqlite::Connection,
+        table: &str,
+        owner_team_id: Option<&str>,
+    ) -> Result<i64, CliError> {
+        match owner_team_id {
+            Some(team) => {
+                let sql = format!("select count(*) from {table} where owner_team_id = ?1");
+                conn.query_row(&sql, [team], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+            None => {
+                let sql = format!("select count(*) from {table}");
+                conn.query_row(&sql, [], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+        }
     }
 
     fn count_where_status(
         conn: &rusqlite::Connection,
         table: &str,
+        owner_team_id: Option<&str>,
         status: &str,
     ) -> Result<i64, CliError> {
-        let sql = format!("select count(*) from {table} where status = ?1");
-        conn.query_row(&sql, [status], |row| row.get::<_, i64>(0))
-            .map_err(|e| CliError::Runtime(e.to_string()))
+        match owner_team_id {
+            Some(team) => {
+                let sql = format!("select count(*) from {table} where status = ?1 and owner_team_id = ?2");
+                conn.query_row(&sql, params![status, team], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+            None => {
+                let sql = format!("select count(*) from {table} where status = ?1");
+                conn.query_row(&sql, [status], |row| row.get::<_, i64>(0))
+                    .map_err(|e| CliError::Runtime(e.to_string()))
+            }
+        }
     }
 
-    fn agent_health(conn: &rusqlite::Connection) -> Result<Value, CliError> {
-        let mut stmt = conn
-            .prepare(
+    fn agent_health(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at, owner_team_id
+                 from agent_health where owner_team_id = ?1 order by agent_id"
+            }
+            None => {
                 "select agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at, owner_team_id
-                 from agent_health order by agent_id",
-            )
+                 from agent_health order by agent_id"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let mut rows = stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?;
+        let mut rows = match owner_team_id {
+            Some(team) => stmt.query(params![team]).map_err(|e| CliError::Runtime(e.to_string()))?,
+            None => stmt.query([]).map_err(|e| CliError::Runtime(e.to_string()))?,
+        };
         let mut out = Map::new();
         while let Some(row) = rows.next().map_err(|e| CliError::Runtime(e.to_string()))? {
             let agent_id: String = row.get(0).map_err(|e| CliError::Runtime(e.to_string()))?;

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"
+        );
     }
 
     // =========================================================================
@@ -152,6 +200,7 @@ fn current_uid() -> Option<String> {
         let ws = crate::model::paths::team_workspace(&team).unwrap();
         let _guard = TeamSocketGuard { ws };
         let args = QuickStartArgs {
+            workspace: crate::model::paths::team_workspace(&team).unwrap(),
             agents_dir: team.clone(),
             name: None,
             team_id: None,
@@ -177,6 +226,7 @@ fn current_uid() -> Option<String> {
         std::fs::write(team.join("TEAM.md"), DELEG_TEAM_MD).unwrap();
         std::fs::write(team.join("agents").join("broken.md"), DELEG_INVALID_ROLE).unwrap();
         let args = QuickStartArgs {
+            workspace: crate::model::paths::team_workspace(&team).unwrap(),
             agents_dir: team,
             name: None,
             team_id: None,
@@ -198,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`)
@@ -253,6 +255,7 @@ pub struct InteractionCounts {
 /// `quick-start`(`parser.py:105`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct QuickStartArgs {
+    pub workspace: PathBuf,
     pub agents_dir: PathBuf,
     pub name: Option<String>,
     pub team_id: Option<String>,
@@ -362,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 {
@@ -385,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,
 }
 
@@ -600,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.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();
@@ -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)
 }