@team-agent/installer 0.5.104 → 0.5.106

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

@@ -1,4 +1,4 @@
-//! Seven-field, read-only status projection backed by native tmux and process samples.
+//! Read-only status: native runtime samples plus accepted launch model/effort.
 //!
 //! This intentionally does not reuse RuntimeSnapshot: the legacy snapshot reads
 //! coordinator/db/history and carries diagnostic fields that are outside the
@@ -82,6 +82,8 @@ static NODEPROBE_RESOLVER_ACTIVE: AtomicBool = AtomicBool::new(false);
 struct RegisteredNode {
     name: String,
     provider: String,
+    model: Option<String>,
+    effort: Option<String>,
     endpoint: Option<String>,
     session: Option<String>,
     window: Option<String>,
@@ -106,6 +108,8 @@ struct ProbeNode {
 struct BriefNode {
     name: String,
     provider: String,
+    model: Option<String>,
+    effort: Option<String>,
     runtime_status: String,
     activity: String,
     health: String,
@@ -157,7 +161,7 @@ pub(crate) fn status_brief_scoped(
     })
 }
 
-/// Human output is the exact same seven-field projection as JSON, rendered in
+/// Human output is the exact same nine-field projection as JSON, rendered in
 /// stable field order. Null values remain explicit rather than becoming a
 /// diagnostic or an inferred value.
 pub(crate) fn format_status_brief(
@@ -305,9 +309,11 @@ fn write_test_capability_receipt(path: &Path) {
 
 fn format_brief_node(value: &Value) -> Option<String> {
     Some(format!(
-        "name: {} provider: {} runtime_status: {} activity: {} health: {} session_name: {} tmux_command: {}",
+        "name: {} provider: {} model: {} effort: {} runtime_status: {} activity: {} health: {} session_name: {} tmux_command: {}",
         value.get("name")?.as_str()?,
         value.get("provider")?.as_str()?,
+        display_optional(value.get("model")?),
+        display_optional(value.get("effort")?),
         value.get("runtime_status")?.as_str()?,
         value.get("activity")?.as_str()?,
         value.get("health")?.as_str()?,
@@ -369,6 +375,10 @@ fn registered_node(name: &str, value: &Value, state: &Value) -> RegisteredNode {
     RegisteredNode {
         name: name.to_string(),
         provider,
+        // Accepted launch settings, not pending role-file edits or guessed
+        // provider defaults. Runtime liveness remains a separate signal.
+        model: string_at(value, &["model"]),
+        effort: string_at(value, &["effort"]),
         endpoint: endpoint(value).or_else(|| endpoint(state)),
         session: first_string(value, &["session_name", "session"])
             .or_else(|| {
@@ -1052,6 +1062,8 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
             MatchResult::Missing => BriefNode {
                 name: node.name.clone(),
                 provider: node.provider.clone(),
+                model: node.model.clone(),
+                effort: node.effort.clone(),
                 runtime_status: "stopped".to_string(),
                 activity: "unknown".to_string(),
                 health: "unknown".to_string(),
@@ -1092,6 +1104,8 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
         } else {
             node.provider.clone()
         },
+        model: node.model.clone(),
+        effort: node.effort.clone(),
         runtime_status: "running".to_string(),
         activity: activity.to_string(),
         health: health.to_string(),
@@ -1172,6 +1186,8 @@ impl BriefNode {
         Self {
             name: node.name.clone(),
             provider: node.provider.clone(),
+            model: node.model.clone(),
+            effort: node.effort.clone(),
             runtime_status: "unknown".to_string(),
             activity: "unknown".to_string(),
             health: "unknown".to_string(),
@@ -1184,6 +1200,8 @@ impl BriefNode {
         let mut object = Map::new();
         object.insert("name".to_string(), json!(self.name));
         object.insert("provider".to_string(), json!(self.provider));
+        object.insert("model".to_string(), json!(self.model));
+        object.insert("effort".to_string(), json!(self.effort));
         object.insert("runtime_status".to_string(), json!(self.runtime_status));
         object.insert("activity".to_string(), json!(self.activity));
         object.insert("health".to_string(), json!(self.health));
@@ -1208,6 +1226,8 @@ mod tests {
         RegisteredNode {
             name: "worker".to_string(),
             provider: "pi".to_string(),
+            model: None,
+            effort: None,
             endpoint: Some("/tmp/tmux socket/o'k".to_string()),
             session: Some("sess".to_string()),
             window: Some("win".to_string()),
@@ -1234,6 +1254,45 @@ mod tests {
         br#"{"schema_version":1,"socket":"/tmp/sock","sampled_at":"2026-01-01T00:00:00Z","nodes":[],"error":{"kind":"tmux_inventory","message":"missing"}}"#
     }
 
+    #[test]
+    fn status_model_effort_project_accepted_launch_settings_in_all_runtime_states() {
+        for settings in [(None, None), (Some("openai-codex/gpt-6-luna"), Some("max"))] {
+            let mut node = registered();
+            node.model = settings.0.map(str::to_string);
+            node.effort = settings.1.map(str::to_string);
+            for lifecycle in [None, Some("stopped")] {
+                node.lifecycle = lifecycle.map(str::to_string);
+                for sample in [None, Some(ProbeResult { nodes: vec![probe("pi_activity_channel")] })] {
+                    let value = project_node(&node, Some(&sample)).into_json();
+                    assert_eq!(value["model"], json!(settings.0));
+                    assert_eq!(value["effort"], json!(settings.1));
+                    let human = format_brief_node(&value).unwrap();
+                    assert!(human.contains(&format!("model: {} effort: {}", settings.0.unwrap_or("null"), settings.1.unwrap_or("null"))));
+                    assert_eq!(value.as_object().unwrap().len(), 9);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn status_model_effort_use_canonical_runtime_roster_not_stale_projection() {
+        let state = json!({
+            "active_team_key": "selected",
+            "agents": {"worker": {"model": "stale-model", "effort": "low"}},
+            "teams": {"selected": {"agents": {
+                "worker": {"model": "accepted-model", "effort": "max"},
+                "plain": {}
+            }}}
+        });
+        let selected = registered_nodes(&state, Some("worker"));
+        assert_eq!(selected.len(), 1);
+        assert_eq!(selected[0].model.as_deref(), Some("accepted-model"));
+        assert_eq!(selected[0].effort.as_deref(), Some("max"));
+        let plain = registered_nodes(&state, Some("plain"));
+        assert!(plain[0].model.is_none());
+        assert!(plain[0].effort.is_none());
+    }
+
     #[test]
     fn pi_pane_title_is_unknown_not_idle() {
         let node = registered();

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

@@ -317,6 +317,7 @@ fn cli_add_agent_duplicate_id_surfaces_real_error() {
     let dup_role = team.join("dup-role.md");
     std::fs::write(&dup_role, DELEG_VALID_ROLE).unwrap(); // role file must exist
     let args = AddAgentArgs {
+        role_config: Default::default(),
         agent: "implementer".to_string(),
         workspace: team,
         team: None,
@@ -332,12 +333,12 @@ fn cli_add_agent_duplicate_id_surfaces_real_error() {
         );
 }
 
-// 5 [P1] — cmd_status --json emits the concise seven-field node projection.
+// 5 [P1] — cmd_status --json emits the concise nine-field node projection.
 // Status must not leak coordinator/db/history diagnostics; missing exact nodeprobe evidence remains
 // an explicit unknown projection. The fixture still seeds a real store to ensure the status path
 // does not accidentally depend on coordinator or mailbox reads.
 #[test]
-fn cli_status_emits_seven_field_brief_without_diagnostics() {
+fn cli_status_emits_nine_field_brief_without_diagnostics() {
     let ws = seed_status_workspace(); // writes .team/runtime/state.json
     let store = crate::message_store::MessageStore::open(&ws).unwrap();
     let _ = store
@@ -398,6 +399,8 @@ fn cli_status_emits_seven_field_brief_without_diagnostics() {
         [
             "name",
             "provider",
+            "model",
+            "effort",
             "runtime_status",
             "activity",
             "health",

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

@@ -345,7 +345,7 @@ fn status_compact_reports_identity_slot_health_on_grok_identity_slot_ok() {
 }
 
 #[test]
-fn cmd_status_human_is_seven_field_brief_without_diagnostics() {
+fn cmd_status_human_is_nine_field_brief_without_diagnostics() {
     let ws = seed_status_workspace();
     let args = StatusArgs {
         agent: None,
@@ -364,7 +364,7 @@ fn cmd_status_human_is_seven_field_brief_without_diagnostics() {
 
     assert!(
         text.contains(
-            "name: a1 provider: unknown runtime_status: unknown activity: unknown health: unknown session_name: null tmux_command: null"
+            "name: a1 provider: unknown model: null effort: null runtime_status: unknown activity: unknown health: unknown session_name: null tmux_command: null"
         ),
         "{text}"
     );

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

@@ -475,6 +475,7 @@ pub struct RestartArgs {
 /// `start-agent`(`parser.py:369`)。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StartAgentArgs {
+    pub role_config: crate::lifecycle::role_config::RoleConfigPatch,
     pub agent: String,
     pub workspace: PathBuf,
     pub team: Option<String>,
@@ -502,9 +503,10 @@ pub struct ResetAgentArgs {
     pub json: bool,
 }
 
-/// `add-agent`(`parser.py:395`)。`--role-file` 必需。
+/// `add-agent`: provider and bypass are explicit CLI or role-file decisions.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AddAgentArgs {
+    pub role_config: crate::lifecycle::role_config::RoleConfigPatch,
     pub agent: String,
     pub workspace: PathBuf,
     pub team: Option<String>,

package/crates/team-agent/src/lifecycle/launch/add_agent.rs

@@ -418,7 +418,7 @@ pub(crate) fn add_agent_with_transport_force(
 /// returns: 新席报告；成功后还要过快照的一致性校验
 /// errors: 角色文件不存在先行返回 Compile；摘除、加回或一致性校验失败时按快照恢复并返回错误
 /// ---
-pub(super) fn force_recreate_with_transport_locked(
+pub(crate) fn force_recreate_with_transport_locked(
     run_workspace: &Path,
     team_dir: &Path,
     agent_id: &AgentId,
@@ -546,7 +546,7 @@ pub(super) fn add_agent_with_transport_at_paths(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn add_agent_with_transport_at_paths_locked(
+pub(crate) fn add_agent_with_transport_at_paths_locked(
     run_workspace: &Path,
     team_dir: &Path,
     agent_id: &AgentId,
@@ -683,6 +683,7 @@ fn add_agent_with_transport_at_paths_reserved(
             &spec_path,
             pre_spec_text.as_deref(),
             None,
+            Some(&canonical_team_key),
             agent_id,
             "state_upsert_failed",
         );
@@ -705,6 +706,7 @@ fn add_agent_with_transport_at_paths_reserved(
                 &spec_path,
                 pre_spec_text.as_deref(),
                 None,
+                Some(&canonical_team_key),
                 agent_id,
                 "start_agent_failed",
             );
@@ -721,6 +723,7 @@ fn add_agent_with_transport_at_paths_reserved(
                 &spec_path,
                 pre_spec_text.as_deref(),
                 None,
+                Some(&canonical_team_key),
                 agent_id,
                 "start_agent_noop",
             );
@@ -734,6 +737,7 @@ fn add_agent_with_transport_at_paths_reserved(
                 &spec_path,
                 pre_spec_text.as_deref(),
                 None,
+                Some(&canonical_team_key),
                 agent_id,
                 "added_agent_paused",
             );

package/crates/team-agent/src/lifecycle/launch/add_agent_state.rs

@@ -55,6 +55,7 @@ pub(super) fn rollback_add_agent_atomic(
     spec_path: &Path,
     pre_spec_text: Option<&str>,
     pre_runtime_state: Option<&serde_json::Value>,
+    team_key: Option<&str>,
     agent_id: &AgentId,
     reason: &str,
 ) {
@@ -86,7 +87,7 @@ pub(super) fn rollback_add_agent_atomic(
         crate::state::repository::StateRepository::new(run_workspace)
             .save(
                 crate::state::repository::StateWriteIntent::AgentRollback {
-                    team_key: None,
+                    team_key,
                     agent_id: agent_id.as_str(),
                 },
                 state,
@@ -94,7 +95,7 @@ pub(super) fn rollback_add_agent_atomic(
             .is_ok()
     } else {
         // No prior runtime state — drop just the agent we added (load → strip → save).
-        if let Ok(mut state) = crate::state::persist::load_runtime_state(run_workspace) {
+        if let Ok(mut state) = crate::state::projection::select_runtime_state(run_workspace, team_key) {
             if let Some(agents) = state
                 .get_mut("agents")
                 .and_then(serde_json::Value::as_object_mut)
@@ -105,7 +106,8 @@ pub(super) fn rollback_add_agent_atomic(
                 .get_mut("teams")
                 .and_then(serde_json::Value::as_object_mut)
             {
-                for team in teams.values_mut() {
+                for (key, team) in teams.iter_mut() {
+                    if team_key.is_some_and(|selected| selected != key) { continue; }
                     if let Some(agents) = team
                         .get_mut("agents")
                         .and_then(serde_json::Value::as_object_mut)
@@ -117,7 +119,7 @@ pub(super) fn rollback_add_agent_atomic(
             crate::state::repository::StateRepository::new(run_workspace)
                 .save(
                     crate::state::repository::StateWriteIntent::AgentRollback {
-                        team_key: None,
+                        team_key,
                         agent_id: agent_id.as_str(),
                     },
                     &state,

package/crates/team-agent/src/lifecycle/launch/role_source.rs

@@ -39,7 +39,7 @@ fn set_yaml_map_value(value: &mut Value, key: &str, next: Value) -> Result<(), L
     Ok(())
 }
 
-fn dump_role_frontmatter(meta: &Value) -> String {
+pub(crate) fn dump_role_frontmatter(meta: &Value) -> String {
     let Value::Map(pairs) = meta else {
         return yaml::dumps(meta);
     };

package/crates/team-agent/src/lifecycle/launch/spec_state.rs

@@ -327,8 +327,13 @@ pub(crate) fn write_spec_atomic(spec_path: &Path, spec: &Value) -> Result<(), Li
             .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", parent.display())))?;
     }
     let tmp = spec_path.with_extension(format!("tmp-{}", std::process::id()));
-    std::fs::write(&tmp, yaml::dumps(spec))
-        .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", tmp.display())))?;
+    if let Err(e) = std::fs::write(&tmp, yaml::dumps(spec)) {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(LifecycleError::StatePersist(format!(
+            "{}: {e}",
+            tmp.display()
+        )));
+    }
     if let Err(e) = std::fs::rename(&tmp, spec_path) {
         let _ = std::fs::remove_file(&tmp);
         return Err(LifecycleError::StatePersist(format!(

package/crates/team-agent/src/lifecycle/launch/state_projection.rs

@@ -170,12 +170,17 @@ pub(super) fn persist_spawn_agent_state(
             )?,
         );
     }
+    let generation = started
+        .first()
+        .map(|agent| agent.spawned_at.as_str())
+        .unwrap_or(session_name.as_str());
+    // Use the same birth identity as the native session owner marker. Worker
+    // spawned_at may change on start-agent; this session generation must not.
     if let Some(obj) = state.as_object_mut() {
         obj.insert("agents".to_string(), serde_json::Value::Object(agents));
+        obj.insert("generation".to_string(), serde_json::json!(generation));
     } else {
-        let mut obj = serde_json::Map::new();
-        obj.insert("agents".to_string(), serde_json::Value::Object(agents));
-        state = serde_json::Value::Object(obj);
+        state = serde_json::json!({"agents": agents, "generation": generation});
     }
     save_launched_team_state_for_key(workspace, &state, Some(&team_id), None)
 }

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

@@ -402,7 +402,10 @@ pub(super) use readiness::*;
 mod add_agent;
 pub(super) use add_agent::*;
 pub use add_agent::{add_agent, add_agent_force};
-pub(crate) use add_agent::{add_agent_with_transport, add_agent_with_transport_force};
+pub(crate) use add_agent::{
+    add_agent_with_transport, add_agent_with_transport_force,
+    add_agent_with_transport_at_paths_locked, force_recreate_with_transport_locked,
+};
 
 pub(crate) mod add_agent_state;
 pub(super) use add_agent_state::*;

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

@@ -57,6 +57,7 @@ pub(crate) mod pane_input_lock;
 pub(crate) mod profile_launch;
 pub(crate) mod profile_smoke;
 pub mod restart;
+pub mod role_config;
 pub mod types;
 pub(crate) mod worker_command_context;
 

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

@@ -37,6 +37,37 @@ use super::team_state::write_team_state;
 use super::*;
 use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
+/// CLI start is orthogonal to stop: refuse any live target before editing its role.
+/// Transport uncertainty is a refusal, not permission to spawn a duplicate.
+pub(crate) fn ensure_agent_not_running(
+    state: &serde_json::Value,
+    agent_id: &AgentId,
+    transport: &dyn crate::transport::Transport,
+) -> Result<(), LifecycleError> {
+    let agent = state.get("agents").and_then(|agents| agents.get(agent_id.as_str()))
+        .ok_or_else(|| LifecycleError::RequirementUnmet(format!("agent {agent_id} not found")))?;
+    let session = state_session_name(state);
+    let window = agent_window(agent, agent_id);
+    let pane = agent.get("pane_id").and_then(serde_json::Value::as_str);
+    let targets = transport.list_targets()
+        .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+    let live = targets.iter().find(|target| {
+        target.session == session
+            && target.window_name.as_ref().is_some_and(|name| name.as_str() == window)
+            && (pane == Some(target.pane_id.as_str())
+                || !crate::lifecycle::launch::state_uses_adaptive_layout(state))
+            && agent_pane_live_by_id(transport, &target.pane_id)
+    });
+    if let Some(target) = live {
+        Err(LifecycleError::RequirementUnmet(format!(
+            "agent {agent_id} is already running (duplicate / active cohort); use stop-agent first; cohort proof: session={} window={window} pane={}",
+            session.as_str(), target.pane_id.as_str(),
+        )))
+    } else {
+        Ok(())
+    }
+}
+
 /// ---
 /// purpose: 起或复活一席的对外入口
 /// params:
@@ -342,6 +373,8 @@ pub(crate) fn start_agent_at_paths(
     };
     let into_existing_session =
         session_live_or_default(transport, &session_name, session_name_present(&state));
+    let inherited_generation =
+        crate::state::projection::session_generation(&state).map(str::to_string);
     let safety = crate::lifecycle::launch::effective_runtime_config_for_worker_spawn_json(
         &agent,
         provider,
@@ -410,6 +443,24 @@ pub(crate) fn start_agent_at_paths(
         &safety,
         start_mode,
     )?;
+    let generation = if into_existing_session {
+        inherited_generation.as_deref()
+    } else {
+        Some(spawn.spawned_at.as_str())
+    };
+    if let Some(generation) = generation {
+        state["generation"] = serde_json::json!(generation);
+        if !into_existing_session {
+            transport
+                .set_session_owner_with_generation(
+                    &session_name,
+                    workspace,
+                    &resolved_team_key,
+                    generation,
+                )
+                .map_err(|error| LifecycleError::Transport(error.to_string()))?;
+        }
+    }
     // 0.5.66 bypass 单源 §2.7:启动即带 bypass → 审计留痕。
     if safety.enabled {
         let state_agent = state
@@ -1125,6 +1176,30 @@ pub(super) fn stop_agent_at_paths(
         || !same_role_panes.is_empty()
         || (pane_id.is_none() && window_exists(transport, &session_name, &window));
     if stopped {
+        let stop_targets =
+            if let Some(pane) = pane_id.as_ref().filter(|_| stored_pane_live) {
+                vec![Target::Pane(pane.clone())]
+            } else if !same_role_panes.is_empty() {
+                same_role_panes
+                    .iter()
+                    .map(|pane| Target::Pane(pane.pane_id.clone()))
+                    .collect()
+            } else {
+                vec![Target::SessionWindow {
+                    session: session_name.clone(),
+                    window: WindowName::new(&window),
+                }]
+            };
+        // Explicit kill-pane/kill-window ignores remain-on-exit on the worker.
+        // Preserve the last window BEFORE killing it, or the coordinator sees
+        // a missing session and stops while the seat is merely being stopped.
+        transport
+            .preserve_session_before_stop(&session_name, &stop_targets)
+            .map_err(|error| {
+                LifecycleError::Transport(format!(
+                    "failed to preserve session before stopping agent {agent_id}: {error}"
+                ))
+            })?;
         // golden operations.py:84-86: a non-zero kill-window raises
         // RuntimeError(f"failed to stop agent {agent_id}: {proc.stderr.strip()}").
         //

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -509,6 +509,8 @@ fn restart_with_selected_team_and_transport(
     let live_worker_session_deferred_teardown =
         session_live_or_default(transport, &session_name, false)
             && !collect_live_agents_from_state(&state).is_empty();
+    let inherited_generation =
+        crate::state::projection::session_generation(&state).map(str::to_string);
     let same_role_cohort_targets =
         same_role_cohort_targets_from_decisions(&state, spec_workspace, &plan.decisions);
     let pre_spawn_pane_ids = if live_worker_session_deferred_teardown {
@@ -998,6 +1000,25 @@ fn restart_with_selected_team_and_transport(
             }
         }
     }
+    if !fatal_resume_failure && !successful_agents.is_empty() {
+        let generation = if live_worker_session_deferred_teardown {
+            inherited_generation
+        } else {
+            // A recreated session gets the first successful NEW worker's birth,
+            // not an arbitrary old stopped worker still present in the roster.
+            successful_agents.first().and_then(|agent| {
+                state
+                    .get("agents")?
+                    .get(agent.agent_id.as_str())?
+                    .get("spawned_at")?
+                    .as_str()
+                    .map(str::to_string)
+            })
+        };
+        if let Some(generation) = generation {
+            state["generation"] = serde_json::json!(generation);
+        }
+    }
     save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
         &selected.run_workspace,
         &mut state,
@@ -1040,23 +1061,9 @@ fn restart_with_selected_team_and_transport(
             attach_commands,
         });
     }
-    // Respawn changes the generation used by shutdown's ownership check, even
-    // when build-before-destroy keeps the tmux session itself alive. Stamp only
-    // the selected session, after its replacement state is durable.
-    if let Some(generation) = state
-        .get("generation")
-        .and_then(serde_json::Value::as_str)
-        .or_else(|| {
-            state
-                .get("agents")
-                .and_then(serde_json::Value::as_object)
-                .and_then(|agents| {
-                    agents.values().find_map(|agent| {
-                        agent.get("spawned_at").and_then(serde_json::Value::as_str)
-                    })
-                })
-        })
-    {
+    // Stamp the physical session birth after durable state. Replacing workers
+    // in a retained session does not create a new session generation.
+    if let Some(generation) = crate::state::projection::session_generation(&state) {
         transport
             .set_session_owner_with_generation(
                 &session_name,

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

@@ -77,7 +77,7 @@ pub(crate) mod remove;
 mod selection;
 mod team_state;
 
-pub(crate) use agent::start_agent_at_paths;
+pub(crate) use agent::{start_agent_at_paths, ensure_agent_not_running};
 pub use agent::{reset_agent, start_agent, stop_agent};
 pub(crate) use agent::{
     reset_agent_with_transport, start_agent_with_transport, stop_agent_with_transport,