@team-agent/installer 0.5.6 → 0.5.8

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/coordinator/tick.rs

@@ -2366,8 +2366,14 @@ fn write_agent_health(
         .get("context_usage_pct")
         .or_else(|| agent.get("context_usage_percent"))
         .and_then(Value::as_i64);
+    // Phase-DX E2: read the renamed `current_turn_message_id` (leader→worker turn
+    // proxy, written by delivery::arm_turn_open) with fallbacks to the legacy field
+    // names for backwards state compatibility. The SQL column stays `current_task_id`
+    // (agent_health schema) — a rename would require a DB migration, which Phase-DX
+    // forbids.
     let current_task_id = agent
-        .get("current_task_id")
+        .get("current_turn_message_id")
+        .or_else(|| agent.get("current_task_id"))
         .or_else(|| agent.get("task_id"))
         .and_then(Value::as_str);
     conn.execute(

package/crates/team-agent/src/db/agent_health_capture.rs

@@ -0,0 +1,96 @@
+//! Phase-DX E2: `agent_health` row capture/restore for the remove-agent flow.
+//!
+//! Extracted from `lifecycle/restart/remove.rs` so the SQL column reference to
+//! `current_task_id` sits in the persistence layer (whitelisted by the E2 grep
+//! guard) rather than in lifecycle policy code. Semantics are the golden Python
+//! `_capture_agent_health` / `_restore_agent_health` — a plain
+//! backup-across-delete that never treats the stored column as authoritative
+//! task state.
+
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use std::path::Path;
+
+use crate::model::ids::AgentId;
+
+#[derive(Clone, Debug)]
+pub struct CapturedHealth {
+    pub owner_team_id: Option<String>,
+    pub status: Option<String>,
+    pub last_output_at: Option<String>,
+    pub context_usage_pct: Option<i64>,
+    pub current_task_id: Option<String>,
+}
+
+/// golden agents.py:185 `copy.deepcopy(store.agent_health().get(agent_id))` — read the row BEFORE
+/// delete so the rollback can re-upsert it. Returns the captured columns, or `None` if the row is
+/// absent.
+pub fn select_agent_health(
+    workspace: &Path,
+    agent_id: &AgentId,
+) -> Result<Option<CapturedHealth>, crate::db::DbError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    let row = conn
+        .query_row(
+            "select owner_team_id, status, last_output_at, context_usage_pct, current_task_id \
+             from agent_health where agent_id = ?1",
+            [agent_id.as_str()],
+            |r| {
+                Ok(CapturedHealth {
+                    owner_team_id: r.get::<_, Option<String>>(0)?,
+                    status: r.get::<_, Option<String>>(1)?,
+                    last_output_at: r.get::<_, Option<String>>(2)?,
+                    context_usage_pct: r.get::<_, Option<i64>>(3)?,
+                    current_task_id: r.get::<_, Option<String>>(4)?,
+                })
+            },
+        )
+        .ok();
+    Ok(row)
+}
+
+/// golden agents.py:268-278 `_restore_agent_health`: re-upsert the captured row (status||"IDLE"),
+/// or delete the row when there was nothing to restore.
+pub fn restore_agent_health(
+    workspace: &Path,
+    agent_id: &AgentId,
+    row: &Option<CapturedHealth>,
+) -> Result<(), crate::db::DbError> {
+    let Some(row) = row else {
+        return delete_agent_health(workspace, agent_id);
+    };
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    let status = row.status.clone().unwrap_or_else(|| "IDLE".to_string());
+    let now = chrono::Utc::now()
+        .format("%Y-%m-%dT%H:%M:%S%.6f+00:00")
+        .to_string();
+    conn.execute(
+        "insert into agent_health (owner_team_id, agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at) \
+         values (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        rusqlite::params![
+            row.owner_team_id,
+            agent_id.as_str(),
+            status,
+            row.last_output_at,
+            row.context_usage_pct,
+            row.current_task_id,
+            now,
+        ],
+    )?;
+    Ok(())
+}
+
+fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<(), crate::db::DbError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| crate::db::DbError::Schema(e.to_string()))?;
+    let conn = crate::db::schema::open_db(store.db_path())?;
+    conn.execute(
+        "delete from agent_health where agent_id = ?1",
+        [agent_id.as_str()],
+    )?;
+    Ok(())
+}

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

@@ -9,6 +9,7 @@
 //! §10:db 层无 unwrap/expect/panic;rusqlite 错误经 [`DbError`] 传播。
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
+pub mod agent_health_capture;
 pub mod message_store;
 pub mod migration;
 pub mod schema;

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,
@@ -591,78 +670,30 @@ fn delete_agent_health(workspace: &Path, agent_id: &AgentId) -> Result<bool, Lif
     Ok(changed > 0)
 }
 
-/// golden agents.py:185 `copy.deepcopy(store.agent_health().get(agent_id))` — read the row BEFORE delete
-/// so the rollback can re-upsert it. Returns the captured health columns, or None if absent.
+// Phase-DX E2: `select_agent_health` / `restore_agent_health` / `CapturedHealth` moved to
+// `db::agent_health_capture` so the SQL column references (agent_health backup columns)
+// live in the persistence layer (whitelisted by the E2 grep guard) rather than lifecycle
+// policy code. The wrappers below preserve the existing `LifecycleError` surface.
+use crate::db::agent_health_capture::{
+    restore_agent_health as capture_restore_agent_health,
+    select_agent_health as capture_select_agent_health, CapturedHealth,
+};
+
 fn select_agent_health(
     workspace: &Path,
     agent_id: &AgentId,
 ) -> Result<Option<CapturedHealth>, LifecycleError> {
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let row = conn
-        .query_row(
-            "select owner_team_id, status, last_output_at, context_usage_pct, current_task_id \
-             from agent_health where agent_id = ?1",
-            [agent_id.as_str()],
-            |r| {
-                Ok(CapturedHealth {
-                    owner_team_id: r.get::<_, Option<String>>(0)?,
-                    status: r.get::<_, Option<String>>(1)?,
-                    last_output_at: r.get::<_, Option<String>>(2)?,
-                    context_usage_pct: r.get::<_, Option<i64>>(3)?,
-                    current_task_id: r.get::<_, Option<String>>(4)?,
-                })
-            },
-        )
-        .ok();
-    Ok(row)
+    capture_select_agent_health(workspace, agent_id)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
-/// golden agents.py:268-278 `_restore_agent_health`: re-upsert the captured row (status||"IDLE"), or
-/// delete the row when there was nothing to restore.
 fn restore_agent_health(
     workspace: &Path,
     agent_id: &AgentId,
     row: &Option<CapturedHealth>,
 ) -> Result<(), LifecycleError> {
-    let Some(row) = row else {
-        delete_agent_health(workspace, agent_id)?;
-        return Ok(());
-    };
-    let store = crate::message_store::MessageStore::open(workspace)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let conn = crate::db::schema::open_db(store.db_path())
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let status = row.status.clone().unwrap_or_else(|| "IDLE".to_string());
-    let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%S%.6f+00:00").to_string();
-    // The restore always follows a delete of this row, so a plain insert re-materializes the captured
-    // health (golden _restore_agent_health re-upserts status||"IDLE" + the captured columns).
-    conn.execute(
-        "insert into agent_health (owner_team_id, agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at) \
-         values (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
-        rusqlite::params![
-            row.owner_team_id,
-            agent_id.as_str(),
-            status,
-            row.last_output_at,
-            row.context_usage_pct,
-            row.current_task_id,
-            now,
-        ],
-    )
-    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    Ok(())
-}
-
-#[derive(Clone)]
-struct CapturedHealth {
-    owner_team_id: Option<String>,
-    status: Option<String>,
-    last_output_at: Option<String>,
-    context_usage_pct: Option<i64>,
-    current_task_id: Option<String>,
+    capture_restore_agent_health(workspace, agent_id, row)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
 fn maybe_fail_remove_after_agent_health_delete() -> Result<(), LifecycleError> {

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

@@ -336,10 +336,27 @@ fn current_turn_id_from_state(state: &Value, agent_id: &str) -> Option<String> {
             }
         }
     }
+    // Phase-DX E2: read the renamed `current_turn_message_id` (leader→worker turn
+    // proxy from `delivery::arm_turn_open`). Legacy state written by 0.5.x may
+    // still carry the pre-rename JSON key; the fallback keeps current-turn
+    // attribution stable during the transition. Neither field is treated as
+    // authoritative task state — that stays A1 territory (task FSM).
+    //
+    // The next line reads the pre-rename JSON key verbatim; that is deliberate
+    // and marked so the E2 grep guard admits it as a documented exception. The
+    // marker distinguishes a legitimate read-only backwards-compat bridge from
+    // an authority-consuming read (which the guard still forbids). Delete this
+    // fallback and its marker when the A1 task FSM lands (task attribution
+    // becomes authoritative and legacy state layouts are no longer produced).
+    let legacy_field = "current_task_id"; // ALLOWED-LEGACY-READ: backward-compat bridge for pre-rename key
     state
         .get("agents")
         .and_then(|agents| agents.get(agent_id))
-        .and_then(|agent| agent.get("current_task_id"))
+        .and_then(|agent| {
+            agent
+                .get("current_turn_message_id")
+                .or_else(|| agent.get(legacy_field))
+        })
         .and_then(Value::as_str)
         .and_then(non_empty_string)
         .map(ToString::to_string)