@team-agent/installer 0.5.6 → 0.5.7

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.6"
+version = "0.5.7"
 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.6"
+version = "0.5.7"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -2314,12 +2314,29 @@ pub mod lifecycle_port {
         force: bool,
         team: Option<&str>,
     ) -> Result<Value, CliError> {
+        let agent_id = crate::model::ids::AgentId::new(agent);
+        match crate::lifecycle::remove_agent_flag_requirements(workspace, &agent_id, team) {
+            Ok(requirements) => {
+                if !remove_agent_missing_flags(from_spec, confirm, force, &requirements).is_empty() {
+                    return Ok(remove_agent_flag_refusal(
+                        workspace,
+                        agent,
+                        team,
+                        from_spec,
+                        confirm,
+                        force,
+                        &requirements,
+                    ));
+                }
+            }
+            Err(error) if confirm => return Ok(error_value(error)),
+            Err(_) => {}
+        }
         if !confirm {
             return Ok(
                 json!({"ok": false, "agent_id": agent, "error": "remove-agent requires --confirm"}),
             );
         }
-        let agent_id = crate::model::ids::AgentId::new(agent);
         match crate::lifecycle::remove_agent(workspace, &agent_id, from_spec, force, team) {
             Ok(report @ crate::lifecycle::RemoveAgentOutcome::Removed { .. }) => Ok(json!({
                 "ok": true,
@@ -2343,9 +2360,121 @@ pub mod lifecycle_port {
                 "error": "agent is running; remove-agent requires --force",
                 "action": "rerun with --force to stop and remove the running agent",
             })),
+            Ok(crate::lifecycle::RemoveAgentOutcome::RefusedRequiredFlags { .. }) => Ok(json!({
+                "ok": false,
+                "agent_id": agent,
+                "status": "refused",
+                "reason": "remove_agent_flags_required",
+                "error": "remove-agent required flags changed; rerun the command from the latest refusal",
+            })),
             Err(e) => Ok(error_value(e)),
         }
     }
+
+    fn remove_agent_flag_refusal(
+        workspace: &Path,
+        agent: &str,
+        team: Option<&str>,
+        from_spec: bool,
+        confirm: bool,
+        force: bool,
+        requirements: &crate::lifecycle::RemoveAgentFlagRequirements,
+    ) -> Value {
+        let required_flags = remove_agent_required_flags(requirements);
+        let missing_flags = remove_agent_missing_flags(from_spec, confirm, force, requirements);
+        let reason = if missing_flags.len() == 1 {
+            match missing_flags[0] {
+                "--confirm" => "confirm_required",
+                "--from-spec" => "from_spec_confirm_required",
+                "--force" => "force_required",
+                _ => "remove_agent_flags_required",
+            }
+        } else {
+            "remove_agent_flags_required"
+        };
+        let command = remove_agent_command(workspace, agent, team, &required_flags);
+        let required = required_flags.join(" ");
+        json!({
+            "ok": false,
+            "agent_id": agent,
+            "status": "refused",
+            "reason": reason,
+            "error": format!("remove-agent requires {required} for this agent"),
+            "action": format!("rerun: {command}"),
+            "command": command,
+            "missing_flags": missing_flags,
+            "required_flags": required_flags,
+            "state": {
+                "from_spec_required": requirements.from_spec_required,
+                "running": requirements.force_required,
+                "has_session": requirements.has_session,
+            },
+        })
+    }
+
+    fn remove_agent_missing_flags(
+        from_spec: bool,
+        confirm: bool,
+        force: bool,
+        requirements: &crate::lifecycle::RemoveAgentFlagRequirements,
+    ) -> Vec<&'static str> {
+        remove_agent_required_flags(requirements)
+            .into_iter()
+            .filter(|flag| match *flag {
+                "--from-spec" => !from_spec,
+                "--confirm" => !confirm,
+                "--force" => !force,
+                _ => false,
+            })
+            .collect()
+    }
+
+    fn remove_agent_required_flags(
+        requirements: &crate::lifecycle::RemoveAgentFlagRequirements,
+    ) -> Vec<&'static str> {
+        let mut flags = Vec::new();
+        if requirements.from_spec_required {
+            flags.push("--from-spec");
+        }
+        flags.push("--confirm");
+        if requirements.force_required {
+            flags.push("--force");
+        }
+        flags
+    }
+
+    fn remove_agent_command(
+        workspace: &Path,
+        agent: &str,
+        team: Option<&str>,
+        required_flags: &[&str],
+    ) -> String {
+        let mut parts = vec![
+            "team-agent".to_string(),
+            "remove-agent".to_string(),
+            shell_arg(agent),
+            "--workspace".to_string(),
+            shell_arg(&workspace.to_string_lossy()),
+        ];
+        if let Some(team) = team {
+            parts.push("--team".to_string());
+            parts.push(shell_arg(team));
+        }
+        parts.extend(required_flags.iter().map(|flag| (*flag).to_string()));
+        parts.join(" ")
+    }
+
+    fn shell_arg(raw: &str) -> String {
+        if !raw.is_empty()
+            && raw
+                .bytes()
+                .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'/' | b'.' | b'_' | b'-' | b':'))
+        {
+            raw.to_string()
+        } else {
+            format!("'{}'", raw.replace('\'', "'\\''"))
+        }
+    }
     /// `runtime.acknowledge_idle`(`cmd_acknowledge_idle`)。
     pub fn acknowledge_idle(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
         let mut state = crate::state::persist::load_runtime_state(workspace)

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

@@ -39,7 +39,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             args.json,
         )?;
         add_send_reminder_if_ok(&mut value);
-        return Ok(CmdResult::from_json(value, args.json));
+        return Ok(cmd_send_result(value, args.json));
     }
     // F1 (0.3.26, cross-team send): --pane <pane_id> direct targeting.
     // Mutually exclusive with target / --to (agent-name routing).
@@ -68,7 +68,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
             args.json,
         )?;
         add_send_reminder_if_ok(&mut value);
-        return Ok(CmdResult::from_json(value, args.json));
+        return Ok(cmd_send_result(value, args.json));
     }
     let selected = crate::state::selector::resolve_active_team(
         &args.workspace,
@@ -88,7 +88,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     if let Some(amb) =
         routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts)
     {
-        return Ok(CmdResult::from_json(amb, args.json));
+        return Ok(cmd_send_result(amb, args.json));
     }
     let mut outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
     if opts.watch_result {
@@ -101,7 +101,7 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         }
     }
     add_send_reminder_if_ok(&mut value);
-    Ok(CmdResult::from_json(value, args.json))
+    Ok(cmd_send_result(value, args.json))
 }
 
 /// F1 (0.3.26): direct pane-id send — bypasses agent-name routing + team
@@ -752,8 +752,98 @@ fn add_send_reminder_if_ok(value: &mut Value) {
     if value.get("ok").and_then(Value::as_bool) != Some(true) {
         return;
     }
+    let reminder = send_reminder_for_value(value);
     if let Some(obj) = value.as_object_mut() {
-        obj.insert("reminder".to_string(), json!(crate::cli::SEND_REMINDER));
+        obj.insert("reminder".to_string(), json!(reminder));
+    }
+}
+
+fn cmd_send_result(value: Value, as_json: bool) -> CmdResult {
+    let exit = if value.get("ok").and_then(Value::as_bool) == Some(false) {
+        ExitCode::Error
+    } else {
+        ExitCode::Ok
+    };
+    if as_json {
+        CmdResult::from_json(value, true)
+    } else {
+        CmdResult {
+            output: CmdOutput::Human(send_human_output(&value)),
+            exit,
+            as_json: false,
+        }
+    }
+}
+
+fn send_human_output(value: &Value) -> String {
+    let mut parts = vec![
+        send_human_field(value, "ok"),
+        format!("status: {}", send_human_status(value)),
+        send_human_field(value, "message_id"),
+        format!("target: {}", send_human_target(value)),
+    ];
+    for key in ["verification", "stage", "reason", "channel"] {
+        if !value.get(key).is_none_or(Value::is_null) {
+            parts.push(send_human_field(value, key));
+        }
+    }
+    parts.join(" ")
+}
+
+fn send_human_field(value: &Value, key: &str) -> String {
+    let rendered = value
+        .get(key)
+        .map(send_human_value)
+        .unwrap_or_else(|| "None".to_string());
+    format!("{key}: {rendered}")
+}
+
+fn send_human_target(value: &Value) -> String {
+    ["target", "agent_id", "pane_id", "to_name"]
+        .iter()
+        .find_map(|key| value.get(*key).filter(|v| !v.is_null()))
+        .map(send_human_value)
+        .unwrap_or_else(|| "None".to_string())
+}
+
+fn send_human_status(value: &Value) -> String {
+    value
+        .get("status")
+        .map(send_human_value)
+        .unwrap_or_else(|| {
+            if value.get("ok").and_then(Value::as_bool) == Some(true) {
+                "delivered".to_string()
+            } else {
+                "failed".to_string()
+            }
+        })
+}
+
+fn send_human_value(value: &Value) -> String {
+    let text = match value {
+        Value::Null => "None".to_string(),
+        Value::Bool(true) => "True".to_string(),
+        Value::Bool(false) => "False".to_string(),
+        Value::Number(n) => n.to_string(),
+        Value::String(s) => s.clone(),
+        Value::Array(_) | Value::Object(_) => {
+            serde_json::to_string(value).unwrap_or_else(|_| "None".to_string())
+        }
+    };
+    text.replace(['\r', '\n'], " ")
+}
+
+fn send_reminder_for_value(value: &Value) -> &'static str {
+    let delivered = value.get("delivered").and_then(Value::as_bool);
+    let status = value.get("status").and_then(Value::as_str);
+    let delivery_status = value.get("delivery_status").and_then(Value::as_str);
+    if delivered == Some(false)
+        || matches!(status, Some("queued"))
+        || matches!(delivery_status, Some("pending"))
+    {
+        "Message queued; coordinator will notify when the worker receives it. Do not poll the worker terminal with capture-pane."
+    } else {
+        crate::cli::SEND_REMINDER
     }
 }
 

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

@@ -493,6 +493,60 @@ fn seed_team_spec(ws: &std::path::Path) {
         .unwrap();
     }
     #[test]
+    fn remove_agent_spec_running_refusal_lists_all_required_flags_once() {
+        let ws = tmp_workspace();
+        seed_remove_agent_workspace(&ws, "running");
+        let out = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: false,
+                confirm: false,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(out["ok"], json!(false));
+        assert_eq!(out["status"], json!("refused"));
+        assert_eq!(out["reason"], json!("remove_agent_flags_required"));
+        for flag in ["--from-spec", "--confirm", "--force"] {
+            assert!(
+                out["error"].as_str().is_some_and(|s| s.contains(flag))
+                    && out["action"].as_str().is_some_and(|s| s.contains(flag))
+                    && out["command"].as_str().is_some_and(|s| s.contains(flag)),
+                "refusal must mention {flag} in error/action/copyable command; got {out}"
+            );
+        }
+        let with_confirm = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: false,
+                confirm: true,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(with_confirm["reason"], json!("remove_agent_flags_required"));
+        for flag in ["--from-spec", "--confirm", "--force"] {
+            assert!(
+                with_confirm["error"].as_str().is_some_and(|s| s.contains(flag))
+                    && with_confirm["action"].as_str().is_some_and(|s| s.contains(flag))
+                    && with_confirm["command"].as_str().is_some_and(|s| s.contains(flag)),
+                "refusal with --confirm must still give the full command including {flag}; got {with_confirm}"
+            );
+        }
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(
+            state["agents"].get("fake_impl").is_some(),
+            "refused remove-agent must not delete the spec-defined running agent"
+        );
+    }
+    #[test]
     fn remove_agent_running_refusal_is_not_success_envelope() {
         let ws = tmp_workspace();
         seed_remove_agent_workspace(&ws, "running");

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

@@ -451,6 +451,28 @@ use super::*;
         }
     }
 
+    fn queued_send_args_fixture(json: bool) -> SendArgs {
+        let ws = deleg_uniq_dir("send-human");
+        let _ = crate::message_store::MessageStore::open(&ws).unwrap();
+        crate::state::persist::save_runtime_state(
+            &ws,
+            &json!({
+                "active_team_key": "current",
+                "teams": {"current": {"agents": {"w1": {"provider": "codex"}}}}
+            }),
+        )
+        .unwrap();
+        SendArgs {
+            workspace: ws,
+            target: Some("w1".into()),
+            team: None,
+            task: None,
+            watch_result: false,
+            json,
+            ..send_args_fixture()
+        }
+    }
+
     #[test]
     fn send_options_negates_no_ack_and_no_wait_and_carries_watch() {
         // golden (commands.py:172,174,176): requires_ack=not no_ack; wait_visible=not no_wait;
@@ -494,7 +516,11 @@ use super::*;
     fn cmd_send_joins_message_with_single_space() {
         // golden (commands.py:169): " ".join(["hello","world","foo"]) == "hello world foo".
         // Drive cmd_send; the joined content must reach send_message (RED until ported).
-        let r = cmd_send(&send_args_fixture()).expect("cmd_send returns CmdResult");
+        let args = SendArgs {
+            json: true,
+            ..send_args_fixture()
+        };
+        let r = cmd_send(&args).expect("cmd_send returns CmdResult");
         // The delegate's DeliveryOutcome -> Json must carry an `ok` key feeding exit-code.
         match r.output {
             CmdOutput::Json(ref v) => {
@@ -510,11 +536,92 @@ use super::*;
         }
     }
 
+    #[test]
+    fn cmd_send_default_human_output_is_one_line_without_false_delivered() {
+        let r = cmd_send(&queued_send_args_fixture(false)).expect("cmd_send returns CmdResult");
+        assert!(!r.as_json);
+        let text = emit(&r.output, r.as_json).expect("send should render human text");
+        let lines: Vec<_> = text.lines().collect();
+        assert_eq!(lines.len(), 1, "default send output must be one line: {text}");
+        assert!(
+            lines[0].contains("ok:")
+                && lines[0].contains("status:")
+                && lines[0].contains("message_id:")
+                && lines[0].contains("target:"),
+            "default send output must keep only the core fields; got {text}"
+        );
+        assert!(
+            !text.contains("delivered"),
+            "queued send output must not claim or mention delivered; got {text}"
+        );
+        for hidden in [
+            "agent_id:",
+            "sender:",
+            "message_status:",
+            "verification:",
+            "stage:",
+            "reason:",
+            "channel:",
+            "reminder:",
+        ] {
+            assert!(
+                !text.contains(hidden),
+                "default send output should hide {hidden} unless needed; got {text}"
+            );
+        }
+    }
+
+    #[test]
+    fn cmd_send_json_shape_keeps_056_fields() {
+        let args = queued_send_args_fixture(true);
+        let r = cmd_send(&args).expect("cmd_send returns CmdResult");
+        let v = match r.output {
+            CmdOutput::Json(v) => v,
+            other => panic!("--json send must emit Json, got {other:?}"),
+        };
+        let obj = v.as_object().expect("--json send output must be object");
+        for key in [
+            "ok",
+            "status",
+            "delivery_status",
+            "delivered",
+            "target",
+            "agent_id",
+            "content_length_bytes",
+            "sender",
+            "message_id",
+            "message_status",
+            "verification",
+            "stage",
+            "reason",
+            "channel",
+            "reminder",
+        ] {
+            assert!(obj.contains_key(key), "--json send shape lost {key}: {v}");
+        }
+        assert_eq!(v.get("verification"), Some(&serde_json::Value::Null));
+        assert_eq!(v.get("stage"), Some(&serde_json::Value::Null));
+        assert_eq!(v.get("reason"), Some(&serde_json::Value::Null));
+        assert_eq!(v.get("channel"), Some(&serde_json::Value::Null));
+        assert_eq!(v.get("delivered").and_then(|d| d.as_bool()), Some(false));
+        assert!(
+            !v.get("reminder")
+                .and_then(|reminder| reminder.as_str())
+                .unwrap_or_default()
+                .contains("Message delivered."),
+            "queued JSON reminder must not contradict delivered:false: {v}"
+        );
+    }
+
     #[test]
     fn cmd_send_watch_result_does_not_register_before_delivery() {
         // 0.5.x send contract: --watch-result may only advertise a watcher after
         // initial worker delivery is physically proven.
-        let r = cmd_send(&send_args_fixture()).expect("cmd_send returns CmdResult");
+        let args = SendArgs {
+            json: true,
+            ..send_args_fixture()
+        };
+        let r = cmd_send(&args).expect("cmd_send returns CmdResult");
         let v = match r.output {
             CmdOutput::Json(v) => v,
             other => panic!("expected Json, got {other:?}"),

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

@@ -60,15 +60,37 @@ pub fn remove_agent_with_transport(
     )
 }
 
-fn remove_agent_at_paths(
+pub fn remove_agent_flag_requirements(
+    workspace: &Path,
+    agent_id: &AgentId,
+    team: Option<&str>,
+) -> Result<RemoveAgentFlagRequirements, LifecycleError> {
+    let paths = lifecycle_paths(workspace, team)?;
+    let transport =
+        lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    Ok(remove_agent_preflight(
+        &paths.run_workspace,
+        &paths.spec_workspace,
+        agent_id,
+        team,
+        &transport,
+    )?
+    .requirements)
+}
+
+struct RemoveAgentPreflight {
+    state: serde_json::Value,
+    spec: YamlValue,
+    requirements: RemoveAgentFlagRequirements,
+}
+
+fn remove_agent_preflight(
     workspace: &Path,
     spec_workspace: &Path,
     agent_id: &AgentId,
-    from_spec: bool,
-    force: bool,
     team: Option<&str>,
     transport: &dyn crate::transport::Transport,
-) -> Result<RemoveAgentOutcome, LifecycleError> {
+) -> Result<RemoveAgentPreflight, LifecycleError> {
     // golden agents.py:34-41: resolve_team_scoped_state FIRST (surfaces the team_target_ambiguous /
     // team_target_unresolved refusal before the owner gate), THEN the owner gate, THEN load_spec +
     // _find_worker (unknown-worker raise). Mirror the stop/reset wiring so remove is byte-symmetric:
@@ -80,27 +102,84 @@ fn remove_agent_at_paths(
         return Err(unknown_worker(agent_id));
     };
     let dynamic_agent = is_dynamic_agent(&state, spec_agent, agent_id);
-    if !dynamic_agent && !from_spec {
-        return Ok(RemoveAgentOutcome::RefusedFromSpecConfirm {
-            agent_id: agent_id.clone(),
-        });
-    }
-    if agent_is_running(&state, agent_id, transport) && !force {
-        return Ok(RemoveAgentOutcome::RefusedForceRequired {
+    let force_required = agent_is_running(&state, agent_id, transport);
+    let has_session = state
+        .get("session_name")
+        .and_then(|v| v.as_str())
+        .is_some_and(|s| !s.is_empty())
+        || state
+            .get("agents")
+            .and_then(|v| v.get(agent_id.as_str()))
+            .is_some_and(agent_has_session);
+    Ok(RemoveAgentPreflight {
+        state,
+        spec,
+        requirements: RemoveAgentFlagRequirements {
             agent_id: agent_id.clone(),
+            from_spec_required: !dynamic_agent,
+            force_required,
+            has_session,
+        },
+    })
+}
+
+fn agent_has_session(agent: &serde_json::Value) -> bool {
+    ["session_id", "_pending_session_id", "rollout_path"]
+        .iter()
+        .any(|key| {
+            agent
+                .get(key)
+                .and_then(|v| v.as_str())
+                .is_some_and(|s| !s.is_empty())
+        })
+}
+
+fn remove_agent_at_paths(
+    workspace: &Path,
+    spec_workspace: &Path,
+    agent_id: &AgentId,
+    from_spec: bool,
+    force: bool,
+    team: Option<&str>,
+    transport: &dyn crate::transport::Transport,
+) -> Result<RemoveAgentOutcome, LifecycleError> {
+    let preflight = remove_agent_preflight(workspace, spec_workspace, agent_id, team, transport)?;
+    let missing_from_spec = preflight.requirements.from_spec_required && !from_spec;
+    let missing_force = preflight.requirements.force_required && !force;
+    if missing_from_spec || missing_force {
+        return Ok(if missing_from_spec && missing_force {
+            RemoveAgentOutcome::RefusedRequiredFlags {
+                agent_id: agent_id.clone(),
+                from_spec_required: true,
+                force_required: true,
+            }
+        } else if missing_from_spec {
+            RemoveAgentOutcome::RefusedFromSpecConfirm {
+                agent_id: agent_id.clone(),
+            }
+        } else {
+            RemoveAgentOutcome::RefusedForceRequired {
+                agent_id: agent_id.clone(),
+            }
         });
     }
     let paths = LifecyclePathRefs {
         run_workspace: workspace,
         spec_workspace,
     };
-    let mut rollback = RemoveRollback::capture(paths.run_workspace, paths.spec_workspace, &spec, &state, agent_id)?;
-    rollback.restore_running = force && agent_is_running(&state, agent_id, transport);
+    let mut rollback = RemoveRollback::capture(
+        paths.run_workspace,
+        paths.spec_workspace,
+        &preflight.spec,
+        &preflight.state,
+        agent_id,
+    )?;
+    rollback.restore_running = force && preflight.requirements.force_required;
     let result = remove_agent_inner(
         &paths,
         agent_id,
-        &spec,
-        state,
+        &preflight.spec,
+        preflight.state,
         force,
         team,
         transport,

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

@@ -50,7 +50,7 @@ pub use rebuild::{
     restart, restart_candidates, restart_with_session_convergence_deadline, restart_with_transport,
     restart_with_transport_with_readiness_deadline, select_restart_state,
 };
-pub use remove::{remove_agent, remove_agent_with_transport};
+pub use remove::{remove_agent, remove_agent_flag_requirements, remove_agent_with_transport};
 pub use selection::{
     classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name,
 };

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

@@ -609,6 +609,15 @@ pub struct ForkAgentReport {
     pub session_id: Option<SessionId>,
 }
 
+/// Read-only remove-agent flag requirements for the target's current state.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RemoveAgentFlagRequirements {
+    pub agent_id: AgentId,
+    pub from_spec_required: bool,
+    pub force_required: bool,
+    pub has_session: bool,
+}
+
 /// `remove_agent(...)` 结果(`agents.py:54/56/150`)。`_RemoveRollback` 快照
 /// spec/state/team_state/role_file/agent_health 字节级回滚(Gap 16)。
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -624,6 +633,12 @@ pub enum RemoveAgentOutcome {
     RefusedFromSpecConfirm { agent_id: AgentId },
     /// 运行中未传 force(`agents.py:56`)。
     RefusedForceRequired { agent_id: AgentId },
+    /// Multiple required destructive flags are absent; report them together.
+    RefusedRequiredFlags {
+        agent_id: AgentId,
+        from_spec_required: bool,
+        force_required: bool,
+    },
 }
 
 /// `restart(...)` 结果(`orchestration.py:114/142/387`)。Route B:**先全量验证**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.6",
-    "@team-agent/cli-darwin-x64": "0.5.6",
-    "@team-agent/cli-linux-x64": "0.5.6"
+    "@team-agent/cli-darwin-arm64": "0.5.7",
+    "@team-agent/cli-darwin-x64": "0.5.7",
+    "@team-agent/cli-linux-x64": "0.5.7"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",