@team-agent/installer 0.5.5 → 0.5.7

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.5"
+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.5"
+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/crates/team-agent/src/mcp_server/helpers.rs

@@ -3,6 +3,7 @@
 use std::io::Write as _;
 use std::path::Path;
 
+use rusqlite::{params, OptionalExtension};
 use serde::Serialize;
 use serde_json::Value;
 
@@ -274,12 +275,7 @@ fn find_latest_nonterminal_task_for(tasks: &[Value], agent_id: &str) -> Option<S
     None
 }
 
-/// Find the most recent delivered direct message to `agent_id` whose `task_id`
-/// is empty/null AND for which no result row exists yet. Used by
-/// `report_result` as a message-scoped fallback before defaulting to
-/// `"manual"`, so `collect` can correlate via the existing message-scope path
-/// (`messaging::results::is_message_scoped_result`).
-pub(crate) fn latest_uncorrelated_delivered_message_for(
+pub(crate) fn latest_reportable_message_for(
     workspace: &Path,
     agent_id: &str,
     owner_team_id: Option<&str>,
@@ -287,33 +283,147 @@ pub(crate) fn latest_uncorrelated_delivered_message_for(
     use crate::db::message_store::MessageStore;
     let store = MessageStore::open(workspace).ok()?;
     let conn = crate::db::schema::open_db(store.db_path()).ok()?;
-    let sql = match owner_team_id {
-        Some(_) => "select m.message_id from messages m \
-                     where m.recipient = ?1 and m.status = 'delivered' \
-                       and (m.task_id is null or m.task_id = '') \
-                       and m.owner_team_id = ?2 \
-                       and not exists ( \
-                         select 1 from results r \
-                         where r.task_id = m.message_id and r.agent_id = m.recipient \
-                       ) \
-                     order by m.created_at desc limit 1",
-        None => "select m.message_id from messages m \
-                     where m.recipient = ?1 and m.status = 'delivered' \
-                       and (m.task_id is null or m.task_id = '') \
-                       and not exists ( \
-                         select 1 from results r \
-                         where r.task_id = m.message_id and r.agent_id = m.recipient \
-                       ) \
-                     order by m.created_at desc limit 1",
-    };
-    let mut stmt = conn.prepare(sql).ok()?;
-    let id: Option<String> = match owner_team_id {
-        Some(team) => stmt
-            .query_row(rusqlite::params![agent_id, team], |row| row.get::<_, String>(0))
-            .ok(),
-        None => stmt
-            .query_row(rusqlite::params![agent_id], |row| row.get::<_, String>(0))
-            .ok(),
+    current_turn_message_for(workspace, &conn, agent_id, owner_team_id)
+        .or_else(|| latest_reportable_message_from_db(&conn, agent_id, owner_team_id))
+}
+
+fn current_turn_message_for(
+    workspace: &Path,
+    conn: &rusqlite::Connection,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    let state = report_scope_state(workspace, owner_team_id)?;
+    current_turn_id_from_state(&state, agent_id)
+        .filter(|message_id| message_is_reportable(conn, message_id, agent_id, owner_team_id))
+}
+
+fn report_scope_state(workspace: &Path, owner_team_id: Option<&str>) -> Option<Value> {
+    let state = load_runtime_state(workspace).ok()?;
+    let Some(team) = owner_team_id.filter(|team| !team.is_empty()) else {
+        return Some(state);
     };
-    id
+    let canonical = crate::state::projection::resolve_owner_team_id(&state, team)
+        .canonical_key()
+        .map(str::to_string)
+        .unwrap_or_else(|| team.to_string());
+    if let Some(projected) = state
+        .get("teams")
+        .and_then(Value::as_object)
+        .and_then(|teams| teams.get(&canonical))
+        .cloned()
+    {
+        Some(projected)
+    } else {
+        Some(state)
+    }
+}
+
+fn current_turn_id_from_state(state: &Value, agent_id: &str) -> Option<String> {
+    if let Some(turn) = state.get("coordinator").and_then(|v| v.get("turn_open")) {
+        let armed = turn.get("armed").and_then(Value::as_bool).unwrap_or(false);
+        let node_matches = turn
+            .get("node_id")
+            .and_then(Value::as_str)
+            .is_some_and(|node| node == agent_id);
+        if armed && node_matches {
+            if let Some(turn_id) = turn
+                .get("turn_id")
+                .and_then(Value::as_str)
+                .and_then(non_empty_string)
+            {
+                return Some(turn_id.to_string());
+            }
+        }
+    }
+    state
+        .get("agents")
+        .and_then(|agents| agents.get(agent_id))
+        .and_then(|agent| agent.get("current_task_id"))
+        .and_then(Value::as_str)
+        .and_then(non_empty_string)
+        .map(ToString::to_string)
+}
+
+fn message_is_reportable(
+    conn: &rusqlite::Connection,
+    message_id: &str,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> bool {
+    conn.query_row(
+        "select 1 from messages m
+         where m.message_id = ?1
+           and m.recipient = ?2
+           and (?3 is null or m.owner_team_id = ?3)
+           and (m.task_id is null or m.task_id = '')
+           and m.status in ('delivered', 'target_resolved', 'submitted', 'injected', 'visible')
+           and (m.status = 'delivered' or m.error is null)
+           and m.created_at >= coalesce((
+             select max(r.created_at) from results r
+             where r.agent_id = m.recipient
+               and (?3 is null or r.owner_team_id = m.owner_team_id)
+           ), '0000')
+           and not exists (
+             select 1 from results r
+             where r.task_id = m.message_id and r.agent_id = m.recipient
+           )
+         limit 1",
+        params![message_id, agent_id, owner_team_id],
+        |_| Ok(()),
+    )
+    .optional()
+    .ok()
+    .flatten()
+    .is_some()
+}
+
+fn latest_reportable_message_from_db(
+    conn: &rusqlite::Connection,
+    agent_id: &str,
+    owner_team_id: Option<&str>,
+) -> Option<String> {
+    let row = conn
+        .query_row(
+            "select m.message_id, m.status, m.error from messages m
+             where m.recipient = ?1
+               and (?2 is null or m.owner_team_id = ?2)
+               and (m.task_id is null or m.task_id = '')
+               and m.created_at >= coalesce((
+                 select max(r.created_at) from results r
+                 where r.agent_id = m.recipient
+                   and (?2 is null or r.owner_team_id = m.owner_team_id)
+               ), '0000')
+               and not exists (
+                 select 1 from results r
+                 where r.task_id = m.message_id and r.agent_id = m.recipient
+               )
+             order by m.created_at desc,
+               case when m.status = 'delivered' then 0 else 1 end
+             limit 1",
+            params![agent_id, owner_team_id],
+            |row| {
+                Ok((
+                    row.get::<_, String>(0)?,
+                    row.get::<_, String>(1)?,
+                    row.get::<_, Option<String>>(2)?,
+                ))
+            },
+        )
+        .optional()
+        .ok()
+        .flatten()?;
+    let (message_id, status, error) = row;
+    if reportable_message_status(&status, error.as_deref()) {
+        Some(message_id)
+    } else {
+        None
+    }
+}
+
+fn reportable_message_status(status: &str, error: Option<&str>) -> bool {
+    matches!(
+        status,
+        "delivered" | "target_resolved" | "submitted" | "injected" | "visible"
+    ) && (status == "delivered" || error.is_none())
 }

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

@@ -99,9 +99,9 @@ pub use wire::*;
 // pub(crate) 子项 (normalize 的 list helpers、wire 的 dispatch_tool 等) 经此再导出,
 // 使 `#[cfg(test)] mod tests` 的 `use super::*` 与跨子模块引用解析不变。
 pub(crate) use helpers::{
-    delivery_outcome_value, ensure_object, enum_value, insert_array, latest_task_for_assignee,
-    non_empty_string, normalize_token, normalized_envelope_value, object_fields, text_field,
-    text_of_value, tool_error_reason_wire, tool_runtime_error,
+    delivery_outcome_value, ensure_object, enum_value, insert_array, latest_reportable_message_for,
+    latest_task_for_assignee, non_empty_string, normalize_token, normalized_envelope_value,
+    object_fields, text_field, text_of_value, tool_error_reason_wire, tool_runtime_error,
 };
 pub(crate) use normalize::{
     normalize_artifacts, normalize_changes, normalize_next_actions, normalize_risks, normalize_tests,

package/crates/team-agent/src/mcp_server/tests/tools.rs

@@ -61,6 +61,134 @@
         assert_eq!(env.task_id, TaskId::new("manual"));
     }
 
+    fn seed_report_message(
+        ws: &std::path::Path,
+        message_id: &str,
+        owner_team_id: &str,
+        status: &str,
+        created_at: &str,
+    ) {
+        let store = MessageStore::open(ws).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        conn.execute(
+            "insert into messages(
+                message_id, owner_team_id, task_id, sender, recipient, reply_to, requires_ack,
+                status, content, artifact_refs, created_at, updated_at, delivered_at,
+                acknowledged_at, error, delivery_attempts
+            ) values (?1, ?2, null, 'leader', 'probe-worker', null, 0,
+                ?3, 'task', '[]', ?4, ?4, case when ?3 = 'delivered' then ?4 else null end,
+                null, null, 0)",
+            rusqlite::params![message_id, owner_team_id, status, created_at],
+        )
+        .unwrap();
+    }
+
+    fn seed_report_result(
+        ws: &std::path::Path,
+        result_id: &str,
+        owner_team_id: &str,
+        task_id: &str,
+        created_at: &str,
+    ) {
+        let store = MessageStore::open(ws).unwrap();
+        let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+        let envelope = json!({
+            "schema_version": "result_envelope_v1",
+            "result_id": result_id,
+            "task_id": task_id,
+            "agent_id": "probe-worker",
+            "status": "success",
+            "summary": "seed",
+            "changes": [], "tests": [], "risks": [], "artifacts": [], "next_actions": []
+        });
+        conn.execute(
+            "insert into results(
+                result_id, owner_team_id, task_id, agent_id, envelope, status, created_at
+            ) values (?1, ?2, ?3, 'probe-worker', ?4, 'success', ?5)",
+            rusqlite::params![result_id, owner_team_id, task_id, envelope.to_string(), created_at],
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn report_result_prefers_current_inflight_message_over_old_delivered_fallback() {
+        let ws = unique_ws("report-current-message");
+        seed_report_message(
+            &ws,
+            "msg_old",
+            "gate055",
+            "delivered",
+            "2026-07-06T13:24:25.000000+00:00",
+        );
+        seed_report_result(
+            &ws,
+            "res_seed",
+            "gate055",
+            "task_initial",
+            "2026-07-06T13:25:00.000000+00:00",
+        );
+        seed_report_message(
+            &ws,
+            "msg_new",
+            "gate055",
+            "target_resolved",
+            "2026-07-06T13:27:35.000000+00:00",
+        );
+
+        let tools = TeamOrchestratorTools::with_identity(
+            &ws,
+            Some(AgentId::new("probe-worker")),
+            Some(TeamKey::new("gate055")),
+        );
+        let ok = tools.report_result(
+            None, Some("S3_RESTART_TOKEN"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None,
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("msg_new")),
+            "current in-flight message must beat stale delivered fallback"
+        );
+    }
+
+    #[test]
+    fn report_result_does_not_backfill_old_delivered_message_after_latest_result() {
+        let ws = unique_ws("report-no-old-backfill");
+        seed_report_message(
+            &ws,
+            "msg_old",
+            "gate055",
+            "delivered",
+            "2026-07-06T13:24:25.000000+00:00",
+        );
+        seed_report_result(
+            &ws,
+            "res_latest",
+            "gate055",
+            "task_initial",
+            "2026-07-06T13:25:00.000000+00:00",
+        );
+
+        let tools = TeamOrchestratorTools::with_identity(
+            &ws,
+            Some(AgentId::new("probe-worker")),
+            Some(TeamKey::new("gate055")),
+        );
+        let ok = tools.report_result(
+            None, Some("manual follow-up"), ResultStatus::Success,
+            None, None, None, None, None,
+            None, None,
+        ).expect("report ok");
+        let v = serde_json::to_value(&ok).unwrap();
+        assert_eq!(
+            v.get("task_id"),
+            Some(&json!("manual")),
+            "old delivered messages older than latest result must not be reused"
+        );
+    }
+
     // ════════════════════════════════════════════════════════════════════════
     // CONTROL-PLANE: request_human creates a requires_ack leader message → needs_human
     // (tools.py:342-346). sender = explicit > env > "unknown" (never leader).

package/crates/team-agent/src/mcp_server/tools.rs

@@ -21,9 +21,8 @@ use crate::messaging::{self, MessageTarget, SendOptions};
 
 use super::helpers::{
     delivery_outcome_value, ensure_object, enum_value, insert_array, is_worker_recipient,
-    json_dumps_default, latest_task_for_assignee, latest_uncorrelated_delivered_message_for,
-    non_empty_string, normalized_envelope_value, object_fields, requires_ack_for_target,
-    tool_runtime_error,
+    json_dumps_default, latest_reportable_message_for, latest_task_for_assignee, non_empty_string,
+    normalized_envelope_value, object_fields, requires_ack_for_target, tool_runtime_error,
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
@@ -326,9 +325,9 @@ impl TeamOrchestratorTools {
                 //   1. explicit arg
                 //   2. latest nonterminal task assigned to this agent in
                 //      teams.<owner>.tasks (scoped) → top-level tasks
-                //   3. latest delivered direct message to this agent with no
-                //      task id and no result yet (message-scope correlation —
-                //      collect path: is_message_scoped_result)
+                //   3. current/in-flight reportable direct message to this agent
+                //      with no task id and no result yet (message-scope
+                //      correlation — collect path: is_message_scoped_result)
                 //   4. "manual" — truly uncorrelated; collect still rejects
                 let owner_team_id_str = self.owner_team_id.as_ref().map(|t| t.as_str().to_string());
                 let resolved = task_id
@@ -344,7 +343,7 @@ impl TeamOrchestratorTools {
                     })
                     .or_else(|| {
                         self.agent_id.as_ref().and_then(|agent| {
-                            latest_uncorrelated_delivered_message_for(
+                            latest_reportable_message_for(
                                 &self.workspace,
                                 agent.as_str(),
                                 owner_team_id_str.as_deref(),

package/crates/team-agent/src/messaging/delivery.rs

@@ -460,6 +460,14 @@ pub fn deliver_pending_message(
             });
         }
     };
+    record_current_turn_after_inject_if_leader_to_worker_scoped(
+        workspace,
+        &message.sender,
+        &message.recipient,
+        message_id,
+        event_log,
+        canonical_owner_team_id.as_deref(),
+    )?;
     let submit_verified = inject_submit_verified(&inject_report);
     let readback_verified = pane_readback_verified(&inject_report);
     // Leader pane: inject success is delivery proof. Worker pane: post-submit
@@ -1892,7 +1900,7 @@ pub fn execute_trust_retry(
 }
 
 /// `_record_turn_open_if_leader_to_worker` (`delivery.py:430`):**take-over arm 来自真实投递**
-/// (card §121) —— 仅 leader→worker 注入**成功后**才调 `record_turn_open_after_delivery`,绝不凭空 arm。
+/// (card §121) —— 仅 leader→worker 注入/投递成功后才 arm,绝不凭空 arm。
 pub fn record_turn_open_if_leader_to_worker(
     workspace: &Path,
     state: &serde_json::Value,
@@ -1907,6 +1915,30 @@ pub fn record_turn_open_if_leader_to_worker(
     )
 }
 
+fn record_current_turn_after_inject_if_leader_to_worker_scoped(
+    workspace: &Path,
+    sender: &str,
+    recipient: &str,
+    message_id: &str,
+    event_log: &EventLog,
+    owner_team_id: Option<&str>,
+) -> Result<(), MessagingError> {
+    if !matches!(sender, "leader" | "Leader") || recipient == "leader" {
+        return Ok(());
+    }
+    let message_id = Some(message_id.to_string());
+    let mut state = scoped_state_for_write(workspace, owner_team_id)?;
+    arm_turn_open(&mut state, recipient, &message_id);
+    save_scoped_state_reapplying_after_conflict(workspace, &state, owner_team_id, |latest| {
+        arm_turn_open(latest, recipient, &message_id);
+    })?;
+    event_log.write(
+        "turn_open.armed_after_inject",
+        serde_json::json!({"agent_id": recipient, "message_id": message_id}),
+    )?;
+    Ok(())
+}
+
 fn record_turn_open_if_leader_to_worker_scoped(
     workspace: &Path,
     sender: &str,
@@ -1943,6 +1975,19 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
             serde_json::json!({"armed": true, "node_id": recipient, "turn_id": message_id}),
         );
     }
+    if let Some(agent) = root
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(recipient))
+        .and_then(serde_json::Value::as_object_mut)
+    {
+        agent.insert(
+            "current_task_id".to_string(),
+            message_id.as_ref().map_or(serde_json::Value::Null, |id| {
+                serde_json::Value::String(id.clone())
+            }),
+        );
+    }
 }
 
 /// `_stamp_first_send_at_if_leader_to_worker` (`delivery.py:380`):首次 leader→worker 投递戳

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1575,6 +1575,17 @@ fn deliver_pending_submit_unverified_is_not_saved_by_readback() {
         "0.3.30: positive readback alone must not mark delivered when submit is unverified"
     );
     assert_ne!(out.message_status.0, "delivered");
+    let updated = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        updated.pointer("/coordinator/turn_open/turn_id"),
+        Some(&serde_json::json!(message_id)),
+        "current-turn fact is armed immediately after physical inject succeeds"
+    );
+    assert_eq!(
+        updated.pointer("/agents/w1/current_task_id"),
+        Some(&serde_json::json!(message_id)),
+        "agent current_task_id is armed without marking the message delivered"
+    );
 }
 
 #[test]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.5",
+  "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.5",
-    "@team-agent/cli-darwin-x64": "0.5.5",
-    "@team-agent/cli-linux-x64": "0.5.5"
+    "@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",