@team-agent/installer 0.5.104 → 0.5.105

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.104"
+version = "0.5.105"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.104"
+version = "0.5.105"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -1100,6 +1100,7 @@ pub fn cmd_start_agent(args: &StartAgentArgs) -> Result<CmdResult, CliError> {
         args.force,
         args.allow_fresh,
         args.team.as_deref(),
+        &args.role_config,
     )?;
     if value.get("agent_ids").is_none() {
         if let Some(object) = value.as_object_mut() {
@@ -1142,6 +1143,7 @@ pub fn cmd_add_agent(args: &AddAgentArgs) -> Result<CmdResult, CliError> {
         &args.role_file,
         args.team.as_deref(),
         args.force,
+        &args.role_config,
     )?;
     if value.get("agent_ids").is_none() {
         if let Some(object) = value.as_object_mut() {

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

@@ -1430,9 +1430,107 @@ fn restart_args(args: &[String], cwd: &Path) -> Result<RestartArgs, CliError> {
     })
 }
 
+// Keep strict role CLI parsing separate from the legacy shared parser.
+fn role_agent_args(args: &[String], add: bool) -> Result<(ParsedArgs, crate::lifecycle::role_config::RoleConfigPatch), CliError> {
+    let mut role = crate::lifecycle::role_config::RoleConfigPatch::default();
+    let mut forwarded = Vec::new();
+    let mut seen = std::collections::BTreeSet::new();
+    let mut index = 0;
+    while index < args.len() {
+        let argument = &args[index];
+        if !argument.starts_with('-') {
+            forwarded.push(argument.clone());
+            index += 1;
+            continue;
+        }
+        let (flag, inline) = argument.split_once('=').map_or((argument.as_str(), None), |(key, value)| (key, Some(value)));
+        if !seen.insert(flag.to_string()) { return Err(CliError::Usage(format!("duplicate {flag}"))); }
+        if matches!(flag, "--json" | "--allow-fresh" | "--force") {
+            if inline.is_some() || (add && flag == "--allow-fresh") {
+                return Err(CliError::Usage(format!("unsupported option: {argument}")));
+            }
+            forwarded.push(flag.to_string());
+            index += 1;
+            continue;
+        }
+        if !matches!(flag, "--provider" | "--model" | "--effort" | "--bypass" | "--prompt" | "--profile" | "--workspace" | "--team" | "--role-file")
+            || (!add && flag == "--role-file") {
+            return Err(CliError::Usage(format!("unknown option: {flag}")));
+        }
+        let value = if let Some(value) = inline { value.to_string() } else {
+            index += 1;
+            args.get(index).filter(|value| !value.starts_with("--"))
+                .ok_or_else(|| CliError::Usage(format!("missing value for {flag}")))?.clone()
+        };
+        if value.trim().is_empty() { return Err(CliError::Usage(format!("empty value for {flag}"))); }
+        match flag {
+            "--provider" => {
+                let provider = crate::provider::wire::parse_provider(&value)
+                    .ok_or_else(|| CliError::Usage(format!("unknown provider: {value}")))?;
+                role.provider = Some(crate::provider::wire::provider_wire(provider).to_string());
+            }
+            "--bypass" => role.bypass = Some(match value.as_str() {
+                "true" => true, "false" => false,
+                _ => return Err(CliError::Usage("--bypass requires true or false".into())),
+            }),
+            "--model" => role.model = Some(value),
+            "--effort" => {
+                if crate::model::enums::ProviderEffort::parse(&value).is_none() {
+                    return Err(CliError::Usage(format!("unknown effort: {value}")));
+                }
+                role.effort = Some(value);
+            }
+            "--prompt" => role.prompt = Some(value),
+            "--profile" => role.profile = Some(value),
+            _ => { forwarded.push(flag.to_string()); forwarded.push(value); }
+        }
+        index += 1;
+    }
+    let parsed = parse_args(&forwarded);
+    if add && parsed.role_file.is_none() {
+        if role.provider.is_none() { return Err(CliError::Usage("add-agent requires --provider <name>".into())); }
+        if role.bypass.is_none() { return Err(CliError::Usage("add-agent requires --bypass <true|false>".into())); }
+    }
+    if parsed.positionals.len() != 1 { return Err(CliError::Usage("expected exactly one agent id".into())); }
+    Ok((parsed, role))
+}
+
+#[cfg(test)]
+mod role_cli_tests {
+    use super::*;
+    fn strings(values: &[&str]) -> Vec<String> { values.iter().map(|value| (*value).to_string()).collect() }
+
+    #[test]
+    fn add_requires_decisions_without_a_template_but_accepts_file_input() {
+        for args in [vec!["w"], vec!["w", "--provider", "pi"], vec!["w", "--bypass", "false"]] {
+            assert!(role_agent_args(&strings(&args), true).is_err());
+        }
+        assert!(role_agent_args(&strings(&["w", "--role-file", "w.md"]), true).is_ok());
+        let (parsed, _) = role_agent_args(&strings(&["w", "--role-file", "w.md", "--force"]), true).unwrap();
+        assert!(parsed.force);
+        assert!(role_agent_args(&strings(&["w", "--role-file", "w.md", "--force=true"]), true).is_err());
+        assert!(role_agent_args(&strings(&["w", "--role-file", "w.md", "--allow-fresh"]), true).is_err());
+        let (_, patch) = role_agent_args(&strings(&["w", "--provider=pi", "--bypass=false"]), true).unwrap();
+        assert_eq!(patch.provider.as_deref(), Some("pi"));
+        assert_eq!(patch.bypass, Some(false));
+    }
+
+    #[test]
+    fn strict_role_options_reject_ambiguous_values() {
+        for args in [
+            vec!["w", "--bypass"], vec!["w", "--bypass", "yes"],
+            vec!["w", "--no-bypass"], vec!["w", "--bypass", "true", "--bypass=false"],
+            vec!["w", "--unknown", "x"], vec!["w", "extra"],
+        ] { assert!(role_agent_args(&strings(&args), false).is_err()); }
+        let (_, patch) = role_agent_args(&strings(&["w"]), false).unwrap();
+        assert_eq!(patch, crate::lifecycle::role_config::RoleConfigPatch::default());
+    }
+}
+
 fn start_agent_args(args: &[String], cwd: &Path) -> Result<StartAgentArgs, CliError> {
-    let parsed = parse_args(args);
+    let (parsed, role_config) = role_agent_args(args, false)?;
     Ok(StartAgentArgs {
+        role_config,
         agent: required_pos(&parsed, 0, "agent")?,
         workspace: workspace(&parsed, cwd),
         team: parsed.team,
@@ -1466,14 +1564,13 @@ fn reset_agent_args(args: &[String], cwd: &Path) -> Result<ResetAgentArgs, CliEr
 }
 
 fn add_agent_args(args: &[String], cwd: &Path) -> Result<AddAgentArgs, CliError> {
-    let parsed = parse_args(args);
+    let (parsed, role_config) = role_agent_args(args, true)?;
     Ok(AddAgentArgs {
+        role_config,
         agent: required_pos(&parsed, 0, "agent")?,
         workspace: workspace(&parsed, cwd),
         team: parsed.team,
-        role_file: parsed
-            .role_file
-            .ok_or_else(|| CliError::Usage("missing --role-file".to_string()))?,
+        role_file: parsed.role_file.unwrap_or_default(),
         force: parsed.force,
         json: parsed.json,
     })

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

@@ -2750,15 +2750,12 @@ pub mod lifecycle_port {
         force: bool,
         allow_fresh: bool,
         team: Option<&str>,
+        role_config: &crate::lifecycle::role_config::RoleConfigPatch,
     ) -> Result<Value, CliError> {
+        let _ = force; // Never grants authority to stop an already-running seat.
         let agent_id = crate::model::ids::AgentId::new(agent);
-        match crate::lifecycle::start_agent(
-            workspace,
-            &agent_id,
-            force,
-            true,
-            allow_fresh,
-            team,
+        match crate::lifecycle::role_config::start_agent_from_role(
+            workspace, &agent_id, role_config, allow_fresh, team,
         ) {
             Ok(crate::lifecycle::StartAgentOutcome::Running {
                 env,
@@ -2876,15 +2873,12 @@ pub mod lifecycle_port {
         role_file: &str,
         team: Option<&str>,
         force: bool,
+        role_config: &crate::lifecycle::role_config::RoleConfigPatch,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
-        match crate::lifecycle::add_agent_force(
-            workspace,
-            &agent_id,
-            Path::new(role_file),
-            true,
-            team,
-            force,
+        let source = (!role_file.is_empty()).then(|| Path::new(role_file));
+        match crate::lifecycle::role_config::add_agent_from_role(
+            workspace, &agent_id, source, role_config, force, team,
         ) {
             Ok(report) => Ok(agent_action_value(
                 agent,

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

@@ -152,8 +152,8 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "stop the selected team", usage: "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
-    CommandSpec { name: "add-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::AddAgent), summary: "add or force-recreate a worker", usage: "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
-    CommandSpec { name: "start-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::StartAgent), summary: "start an existing worker", usage: "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
+    CommandSpec { name: "add-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::AddAgent), summary: "create and start a new worker", usage: "usage: team-agent add-agent AGENT [--role-file FILE] [--provider NAME] [--bypass true|false] [--model SLUG] [--effort LEVEL] [--prompt TEXT] [--profile NAME] [--force] [--workspace WORKSPACE] [--team TEAM] [--json] (provider/bypass required from CLI or role file; conflicting values rejected; force only recreates a confirmed dead registered pane)", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
+    CommandSpec { name: "start-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::StartAgent), summary: "update and start a stopped worker (stop first if running)", usage: "usage: team-agent start-agent AGENT [--model SLUG] [--effort LEVEL] [--bypass true|false] [--prompt TEXT] [--profile NAME] [--provider NAME] [--workspace WORKSPACE] [--team TEAM] [--allow-fresh] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "stop-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::StopAgent), summary: "stop a worker", usage: "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "reset-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::ResetAgent), summary: "reset a worker session", usage: "usage: team-agent reset-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "claim-leader", tier: CommandTier::Guided, category: CommandCategory::GuidedRecovery, kind: CommandKind::Dispatch(DispatchKind::ClaimLeader), summary: "bind this pane when doctor reports rebind_required", usage: "usage: team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },

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,

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.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:

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,