@team-agent/installer 0.3.17 → 0.3.18

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.17"
+version = "0.3.18"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.17"
+version = "0.3.18"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -363,10 +363,7 @@ pub mod lifecycle_port {
     }
 
     fn state_uses_external_leader(state: &Value) -> bool {
-        state
-            .get("is_external_leader")
-            .and_then(Value::as_bool)
-            .unwrap_or(true)
+        crate::state::projection::state_is_external_leader(state)
     }
 
     fn managed_leader_socket_cleanup(
@@ -1722,9 +1719,31 @@ pub mod lifecycle_port {
             open_display,
             team,
         ) {
-            Ok(report) => {
-                Ok(json!({"ok": true, "agent_id": agent, "report": format!("{report:?}")}))
-            }
+            Ok(crate::lifecycle::ResetAgentOutcome::Reset {
+                env,
+                start_mode,
+                discarded_session_id,
+                session_id,
+                new_session_id,
+            }) => Ok(json!({
+                "ok": true,
+                "agent_id": env.agent_id.as_str(),
+                "status": "reset",
+                "state_file": env.state_file.to_string_lossy().to_string(),
+                "coordinator_started": env.coordinator_started,
+                "start_mode": start_mode,
+                "discarded_session_id": discarded_session_id.as_ref().map(|id| id.as_str()),
+                "session_id": session_id.as_ref().map(|id| id.as_str()),
+                "new_session_id": new_session_id.as_ref().map(|id| id.as_str()),
+            })),
+            Ok(crate::lifecycle::ResetAgentOutcome::Refused { reason }) => Ok(json!({
+                "ok": false,
+                "agent_id": agent,
+                "status": "refused",
+                "reason": match reason {
+                    crate::lifecycle::ResetRefusal::DiscardSessionRequired => "discard_session_required",
+                },
+            })),
             Err(e) => Ok(error_value(e)),
         }
     }

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

@@ -48,10 +48,7 @@ use rusqlite::params;
             .cloned()
             .unwrap_or_else(|| json!({}));
         let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
-        let is_external_leader = state
-            .get("is_external_leader")
-            .and_then(Value::as_bool)
-            .unwrap_or(true);
+        let is_external_leader = crate::state::projection::state_is_external_leader(state);
         let leader_topology = if is_external_leader { "external" } else { "managed" };
         let leader_attach_command = if is_external_leader {
             None
@@ -573,8 +570,8 @@ use rusqlite::params;
         json!({
             "team": full.get("team").cloned().unwrap_or(Value::Null),
             "session_name": full.get("session_name").cloned().unwrap_or(Value::Null),
-            "leader_topology": full.get("leader_topology").cloned().unwrap_or_else(|| json!("external")),
-            "is_external_leader": full.get("is_external_leader").cloned().unwrap_or(Value::Bool(true)),
+            "leader_topology": full.get("leader_topology").cloned().unwrap_or_else(|| json!("managed")),
+            "is_external_leader": full.get("is_external_leader").cloned().unwrap_or(Value::Bool(false)),
             "leader_attach_command": full.get("leader_attach_command").cloned().unwrap_or(Value::Null),
             "leader_client": full.get("leader_client").cloned().unwrap_or(Value::Null),
             "tmux_session_present": full.get("tmux_session_present").cloned().unwrap_or(Value::Bool(false)),

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

@@ -309,6 +309,7 @@ fn lsof_cwd_timeout_is_diagnostic_not_shutdown_partial() {
         &ws,
         &json!({
             "session_name": "team-lsof-cwd-timeout",
+            "is_external_leader": true,
             "agents": {
                 "fake_impl": {
                     "status": "running",
@@ -467,6 +468,7 @@ fn leader_env_tmux_socket_never_kills_server_even_when_sessions_look_exclusive()
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
+            "is_external_leader": true,
             "tmux_socket_source": "leader_env",
             "agents": {
                 "fake_impl": {
@@ -543,3 +545,42 @@ fn managed_leader_shutdown_never_kills_server_even_when_socket_looks_exclusive()
         "managed topology must clear the team session/window without kill-server"
     );
 }
+
+#[test]
+fn shutdown_missing_topology_marker_defaults_to_managed_cleanup() {
+    let ws = tmp_shutdown_workspace("missing-topology-marker-managed-cleanup");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-current",
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new("%1"),
+            session: SessionName::new("team-current"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("leader")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("codex".to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: None,
+            leader_env: BTreeMap::new(),
+        }])
+        .with_targets_persist_after_kill();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["killed_sessions"], json!(["team-current"]));
+    assert_eq!(out["spared_sessions"], json!([]));
+    assert!(
+        !transport.kill_server_called(),
+        "missing topology marker must default to managed cleanup, not external kill-server"
+    );
+}

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

@@ -86,6 +86,27 @@ use super::*;
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn status_port_missing_topology_marker_defaults_to_managed() {
+        let ws = seed_status_workspace();
+        let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if let Some(obj) = state.as_object_mut() {
+            obj.remove("is_external_leader");
+            obj.insert("session_name".to_string(), json!("team-current"));
+        }
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+
+        let v = status_port::status(&ws, /*compact=*/ true, /*detail=*/ false).expect("status");
+
+        assert_eq!(v["leader_topology"], json!("managed"));
+        assert_eq!(v["is_external_leader"], json!(false));
+        let attach = v["leader_attach_command"]
+            .as_str()
+            .expect("missing marker defaults to managed attach command");
+        assert!(attach.contains("attach -t team-current:leader"), "{attach}");
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
     #[test]
     fn status_port_status_detail_full_keeps_uncompacted_events() {
         // cmd_status --json --detail -> status_port::status(compact=false): the FULL dict

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

@@ -856,6 +856,8 @@ fn save_launched_team_state_for_key(
             "active_team_key".to_string(),
             serde_json::Value::String(launched_key.clone()),
         );
+        obj.entry("is_external_leader".to_string())
+            .or_insert(serde_json::Value::Bool(false));
     }
     promote_launched_binding_from_team_entry(&mut launched, &launched_key);
     preserve_existing_leader_topology(&existing, &launched_key, &mut launched);
@@ -3021,10 +3023,7 @@ fn attach_window_names_with_managed_leader(
 }
 
 fn state_uses_managed_leader(state: &serde_json::Value) -> bool {
-    state
-        .get("is_external_leader")
-        .and_then(serde_json::Value::as_bool)
-        .is_some_and(|external| !external)
+    crate::state::projection::state_is_managed_leader(state)
 }
 
 /// BUG-7 helper: derive a [`QuickStartReadiness`] verdict from the just-written
@@ -3087,7 +3086,7 @@ fn quick_start_session_capture_incomplete_agents(workspace: &Path, team_key: &st
     crate::session_capture::incomplete_interacted_resumable_agent_ids(team_state)
 }
 
-fn launched_team_receiver_is_attached(workspace: &Path, team_key: &str) -> bool {
+pub(crate) fn launched_team_receiver_is_attached(workspace: &Path, team_key: &str) -> bool {
     let Ok(state) = load_runtime_state(workspace) else {
         return true;
     };
@@ -3097,7 +3096,7 @@ fn launched_team_receiver_is_attached(workspace: &Path, team_key: &str) -> bool
         .and_then(|teams| teams.get(team_key))
         .unwrap_or(&state);
     if team_state.get("leader_receiver").is_none() {
-        return true;
+        return crate::state::projection::state_is_external_leader(team_state);
     }
     if team_uses_fake_model_harness(team_state) {
         return true;
@@ -4366,6 +4365,7 @@ fn initial_runtime_state(
         "display_backend".to_string(),
         serde_json::json!(display_backend),
     );
+    state.insert("is_external_leader".to_string(), serde_json::json!(false));
     let mut state = serde_json::Value::Object(state);
     if !seed_launched_owner_from_env(&mut state) {
         let team_id = crate::state::projection::team_state_key(&state);

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

@@ -206,6 +206,7 @@ pub(crate) fn start_agent_at_paths(
         start_mode,
         target: spawn.spawn.pane_id.as_str().to_string(),
         session_id,
+        new_session_id: spawn.plan.expected_session_id.clone(),
         rollout_path,
     })
 }
@@ -528,8 +529,8 @@ fn reset_agent_at_paths(
         .and_then(|v| v.get(agent_id.as_str()))
         .and_then(|v| v.get("session_id"))
         .and_then(|v| v.as_str())
-        .unwrap_or("")
-        .to_string();
+        .filter(|session| !session.is_empty())
+        .map(SessionId::new);
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state_before_stop, Some(agent_id))?;
     let stop = stop_agent_at_paths(workspace, spec_workspace, agent_id, team, transport)?;
     let mut state = resolve_team_scoped_state_or_refuse(workspace, team)?;
@@ -537,11 +538,22 @@ fn reset_agent_at_paths(
     discard_agent_session_fields(&mut state, agent_id)?;
     // golden operations.py (reset): save_team_scoped_state on the team projection — same multi-team
     // preservation as stop, not a raw save_runtime_state.
-    crate::state::projection::save_team_scoped_state(workspace, &state)
+    crate::state::projection::save_team_scoped_state_with_tombstoned_agents(
+        workspace,
+        &state,
+        &[agent_id.as_str()],
+    )
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     // golden operations.py:125: write_team_state after the discard-save (the intermediate stopped snapshot).
     write_team_state(spec_workspace, &spec, &state)?;
-    write_reset_tombstone_event(workspace, agent_id, &discarded_session_id)?;
+    write_reset_tombstone_event(
+        workspace,
+        agent_id,
+        discarded_session_id
+            .as_ref()
+            .map(SessionId::as_str)
+            .unwrap_or(""),
+    )?;
     let start = start_agent_at_paths(
         workspace,
         spec_workspace,
@@ -556,11 +568,34 @@ fn reset_agent_at_paths(
     write_reset_complete_event(workspace, agent_id, stop.stopped, started)?;
     match start {
         StartAgentOutcome::Running {
-            env, start_mode, ..
-        } => Ok(ResetAgentOutcome::Reset { env, start_mode }),
+            env,
+            start_mode,
+            session_id,
+            new_session_id,
+            ..
+        } => {
+            let output_session_id = if matches!(
+                start_mode,
+                StartMode::Fresh | StartMode::FreshAfterMissingRollout
+            ) {
+                new_session_id.clone().or(session_id)
+            } else {
+                session_id
+            };
+            Ok(ResetAgentOutcome::Reset {
+                env,
+                start_mode,
+                discarded_session_id,
+                session_id: output_session_id,
+                new_session_id,
+            })
+        }
         StartAgentOutcome::Noop { env, .. } => Ok(ResetAgentOutcome::Reset {
             env,
             start_mode: StartMode::Noop,
+            discarded_session_id,
+            session_id: None,
+            new_session_id: None,
         }),
         StartAgentOutcome::Paused { .. } => Ok(ResetAgentOutcome::Reset {
             env: AgentActionEnvelope {
@@ -569,6 +604,9 @@ fn reset_agent_at_paths(
                 coordinator_started: false,
             },
             start_mode: StartMode::Noop,
+            discarded_session_id,
+            session_id: None,
+            new_session_id: None,
         }),
     }
 }

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -1200,9 +1200,15 @@ fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
             .any(|cmd| cmd.contains(&format!("tmux -S {endpoint} attach -t "))),
         "attach commands must use the selected socket endpoint: {attach_commands:?}"
     );
+    assert!(
+        attach_commands.iter().any(|cmd| cmd.contains(":leader")),
+        "fresh managed quick-start must include the leader window attach command: {attach_commands:?}"
+    );
     let (_raw, state) = raw_runtime_state(workspace);
     assert_eq!(state["tmux_endpoint"], json!(endpoint));
     assert_eq!(state["tmux_socket"], json!(endpoint));
+    assert_eq!(state["is_external_leader"], json!(false));
+    assert_eq!(state["teams"]["teamdir"]["is_external_leader"], json!(false));
 }
 
 #[test]
@@ -1249,6 +1255,33 @@ fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command
     assert_eq!(state["leader_client"]["diagnostic_only"], json!(true));
 }
 
+#[test]
+fn fresh_managed_state_without_receiver_is_not_attached() {
+    let workspace = temp_ws();
+    crate::state::persist::save_runtime_state(
+        &workspace,
+        &json!({
+            "active_team_key": "teamdir",
+            "session_name": "team-teamdir",
+            "is_external_leader": false,
+            "agents": {"implementer": {"status": "running"}},
+            "teams": {
+                "teamdir": {
+                    "session_name": "team-teamdir",
+                    "is_external_leader": false,
+                    "agents": {"implementer": {"status": "running"}}
+                }
+            }
+        }),
+    )
+    .unwrap();
+
+    assert!(
+        !crate::lifecycle::launch::launched_team_receiver_is_attached(&workspace, "teamdir"),
+        "managed topology with missing leader_receiver must not be reported attached"
+    );
+}
+
 #[test]
 fn attach_window_names_for_state_agents_include_managed_leader_and_layout_windows() {
     let state = json!({
@@ -2225,9 +2258,11 @@ fn quick_start_seeds_tasks_key_from_compiled_spec() {
 //   cross-team reads cannot accidentally pick up another team's binding from the root.
 //   The post-launch hook drops the top-level owner triple when the launched pane is
 //   unbound (empty pane_id), and only the per-team entry retains the binding.
-//   Order remains the golden prefix (spec_path … display_backend) + new suffix
-//   (active_team_key, teams). display_backend stays the resolved backend from
-//   display/backend.py:12-29 (default adaptive), not the raw optional spec field.
+//   R1: topology is explicit; fresh managed teams carry `is_external_leader=false`
+//   before the team-in-team suffix. Order remains the golden prefix
+//   (spec_path … display_backend) + topology marker + new suffix (active_team_key,
+//   teams). display_backend stays the resolved backend from display/backend.py:12-29
+//   (default adaptive), not the raw optional spec field.
 #[test]
 #[serial(env)]
 fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
@@ -2264,11 +2299,13 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
             "agents",
             "tasks",
             "display_backend",
+            "is_external_leader",
             "active_team_key",
             "teams",
         ],
         "state.json top-level key order must match golden launch/core.py:62-71 \
-         plus Bug 1/2 team-in-team suffix (active_team_key, teams). \
+         plus R1 topology marker and Bug 1/2 team-in-team suffix \
+         (is_external_leader, active_team_key, teams). \
          Bug 2 owner team-scope (N1/N12/N18/N29) deliberately keeps owner / \
          leader_receiver / owner_epoch OFF the top level — they live ONLY under \
          teams[<active_team_key>] so per-team isolation has a single source of \
@@ -2308,6 +2345,7 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
         json!("adaptive"),
         "adaptive layout directive: resolve_display_backend(None, source='launch') defaults to adaptive"
     );
+    assert_eq!(state["is_external_leader"], json!(false));
 }
 
 // Stage B1 — golden launch/core.py:238-255 writes the running agent state only after

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

@@ -535,6 +535,7 @@ pub enum StartAgentOutcome {
         start_mode: StartMode,
         target: String,
         session_id: Option<SessionId>,
+        new_session_id: Option<SessionId>,
         rollout_path: Option<RolloutPath>,
     },
     /// 窗口已存在且非 force → noop(`start.py:134`)。
@@ -565,6 +566,9 @@ pub enum ResetAgentOutcome {
     Reset {
         env: AgentActionEnvelope,
         start_mode: StartMode,
+        discarded_session_id: Option<SessionId>,
+        session_id: Option<SessionId>,
+        new_session_id: Option<SessionId>,
     },
     /// 未传 discard_session → 拒绝(不丢上下文的误用保护)。
     Refused { reason: ResetRefusal },

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -60,7 +60,13 @@ pub(crate) fn reset_agent(
     )
     .map_err(tool_runtime_error)?
     {
-        ResetAgentOutcome::Reset { env, start_mode } => Ok(ToolOk {
+        ResetAgentOutcome::Reset {
+            env,
+            start_mode,
+            discarded_session_id,
+            session_id,
+            new_session_id,
+        } => Ok(ToolOk {
             fields: object_fields(serde_json::json!({
                 "ok": true,
                 "agent_id": env.agent_id.as_str(),
@@ -68,6 +74,9 @@ pub(crate) fn reset_agent(
                 "state_file": env.state_file.to_string_lossy().to_string(),
                 "coordinator_started": env.coordinator_started,
                 "start_mode": enum_value(start_mode),
+                "discarded_session_id": discarded_session_id.as_ref().map(|id| id.as_str()),
+                "session_id": session_id.as_ref().map(|id| id.as_str()),
+                "new_session_id": new_session_id.as_ref().map(|id| id.as_str()),
             })),
         }),
         ResetAgentOutcome::Refused { reason } => Ok(ToolOk {

package/crates/team-agent/src/state/persist.rs

@@ -170,13 +170,38 @@ impl Drop for RuntimeLock {
 /// `save_runtime_state`(bug-084)。`state` 是 state.json 的内存 Value(插入序保留)。
 /// 注:Python 在此还调 `_migrate_state_identity`(identity slice 落地后接入;本 slice 不改 state 内容)。
 pub fn save_runtime_state(workspace: &Path, state: &Value) -> Result<(), StateError> {
-    save_runtime_state_with_deleted_agents(workspace, state, &[])
+    save_runtime_state_with_merge_exceptions(workspace, state, &[], None, &[])
 }
 
 pub(crate) fn save_runtime_state_with_deleted_agents(
     workspace: &Path,
     state: &Value,
     deleted_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_runtime_state_with_merge_exceptions(workspace, state, deleted_agent_ids, None, &[])
+}
+
+pub(crate) fn save_runtime_state_with_team_tombstoned_agents(
+    workspace: &Path,
+    state: &Value,
+    tombstoned_team_key: &str,
+    tombstoned_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_runtime_state_with_merge_exceptions(
+        workspace,
+        state,
+        &[],
+        Some(tombstoned_team_key),
+        tombstoned_agent_ids,
+    )
+}
+
+fn save_runtime_state_with_merge_exceptions(
+    workspace: &Path,
+    state: &Value,
+    deleted_agent_ids: &[&str],
+    skip_capture_backfill_team_key: Option<&str>,
+    skip_capture_backfill_agent_ids: &[&str],
 ) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
     if cache_equals(&path, state) {
@@ -218,7 +243,19 @@ pub(crate) fn save_runtime_state_with_deleted_agents(
             .filter(|id| !id.is_empty())
             .map(str::to_string)
             .collect::<BTreeSet<_>>();
-        preserve_latest_roster_entries(&mut migrated, &latest, &deleted);
+        let skip_capture_backfill = skip_capture_backfill_agent_ids
+            .iter()
+            .copied()
+            .filter(|id| !id.is_empty())
+            .map(str::to_string)
+            .collect::<BTreeSet<_>>();
+        preserve_latest_roster_entries(
+            &mut migrated,
+            &latest,
+            &deleted,
+            skip_capture_backfill_team_key,
+            &skip_capture_backfill,
+        );
     }
     // 字节对拍 Python json.dumps(indent=2, ensure_ascii=False)(无尾换行)。
     let payload = serde_json::to_string_pretty(&migrated)?;
@@ -269,19 +306,34 @@ fn read_latest_state_under_lock(workspace: &Path, path: &Path) -> Option<Value>
     Some(latest)
 }
 
-fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_agent_ids: &BTreeSet<String>) {
+fn preserve_latest_roster_entries(
+    incoming: &mut Value,
+    latest: &Value,
+    deleted_agent_ids: &BTreeSet<String>,
+    skip_capture_backfill_team_key: Option<&str>,
+    skip_capture_backfill_agent_ids: &BTreeSet<String>,
+) {
     // A0/R1: the projection gate only guards the TOP-LEVEL passes (top-level agents and
     // the top-level<->active-team cross projections depend on which team is active); the
     // per-team `teams.<k>.agents` merge below is team-key self-identifying and must run
     // even when another process flipped session_name/active_team_key between this
     // writer's load and save.
     let projection_matches = same_runtime_projection(incoming, latest);
+    let active_team = active_team_key(incoming).or_else(|| active_team_key(latest));
+    let top_level_team = Some(team_state_key(incoming)).or_else(|| Some(team_state_key(latest)));
+    let skip_top_level_capture_backfill =
+        should_skip_capture_backfill(top_level_team.as_deref(), skip_capture_backfill_team_key);
     if projection_matches {
-        preserve_missing_agents(incoming.get_mut("agents"), latest.get("agents"), deleted_agent_ids);
+        preserve_missing_agents(
+            incoming.get_mut("agents"),
+            latest.get("agents"),
+            deleted_agent_ids,
+            skip_top_level_capture_backfill,
+            skip_capture_backfill_agent_ids,
+        );
         preserve_latest_ownership_fields(incoming, latest);
     }
 
-    let active_team = active_team_key(incoming).or_else(|| active_team_key(latest));
     if projection_matches {
         if let Some(active_team) = active_team.as_deref() {
             let latest_active_agents = latest
@@ -289,7 +341,13 @@ fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_
                 .and_then(Value::as_object)
                 .and_then(|teams| teams.get(active_team))
                 .and_then(|entry| entry.get("agents"));
-            preserve_missing_agents(incoming.get_mut("agents"), latest_active_agents, deleted_agent_ids);
+            preserve_missing_agents(
+                incoming.get_mut("agents"),
+                latest_active_agents,
+                deleted_agent_ids,
+                skip_top_level_capture_backfill,
+                skip_capture_backfill_agent_ids,
+            );
         }
     }
 
@@ -306,6 +364,8 @@ fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_
                 incoming_entry.get_mut("agents"),
                 latest_entry.get("agents"),
                 deleted_agent_ids,
+                should_skip_capture_backfill(Some(team), skip_capture_backfill_team_key),
+                skip_capture_backfill_agent_ids,
             );
             preserve_latest_ownership_fields(incoming_entry, latest_entry);
         }
@@ -314,13 +374,26 @@ fn preserve_latest_roster_entries(incoming: &mut Value, latest: &Value, deleted_
         if let Some(active_team) = active_team.as_deref() {
             let latest_top_agents = latest.get("agents");
             if let Some(incoming_entry) = incoming_teams.get_mut(active_team) {
-                preserve_missing_agents(incoming_entry.get_mut("agents"), latest_top_agents, deleted_agent_ids);
+                preserve_missing_agents(
+                    incoming_entry.get_mut("agents"),
+                    latest_top_agents,
+                    deleted_agent_ids,
+                    should_skip_capture_backfill(Some(active_team), skip_capture_backfill_team_key),
+                    skip_capture_backfill_agent_ids,
+                );
                 preserve_latest_ownership_fields(incoming_entry, latest);
             }
         }
     }
 }
 
+fn should_skip_capture_backfill(current_team_key: Option<&str>, skip_team_key: Option<&str>) -> bool {
+    match skip_team_key {
+        Some(skip_team_key) => current_team_key == Some(skip_team_key),
+        None => true,
+    }
+}
+
 fn preserve_latest_ownership_fields(incoming: &mut Value, latest: &Value) {
     if !latest_has_preferable_ownership(incoming, latest) {
         return;
@@ -379,6 +452,8 @@ fn preserve_missing_agents(
     incoming_agents: Option<&mut Value>,
     latest_agents: Option<&Value>,
     deleted_agent_ids: &BTreeSet<String>,
+    skip_capture_backfill: bool,
+    skip_capture_backfill_agent_ids: &BTreeSet<String>,
 ) {
     let Some(incoming_agents) = incoming_agents else {
         return;
@@ -398,7 +473,9 @@ fn preserve_missing_agents(
                 slot.insert(latest_agent.clone());
             }
             serde_json::map::Entry::Occupied(mut existing) => {
-                backfill_capture_fields(existing.get_mut(), latest_agent);
+                if !skip_capture_backfill || !skip_capture_backfill_agent_ids.contains(agent_id) {
+                    backfill_capture_fields(existing.get_mut(), latest_agent);
+                }
             }
         }
     }

package/crates/team-agent/src/state/projection.rs

@@ -14,7 +14,7 @@ use std::path::Path;
 use serde_json::{json, Map, Value};
 
 use super::StateError;
-use crate::state::persist::{load_runtime_state, save_runtime_state_with_deleted_agents};
+use crate::state::persist::{load_runtime_state, save_runtime_state_with_deleted_agents, save_runtime_state_with_team_tombstoned_agents};
 
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。
@@ -162,6 +162,17 @@ pub fn compact_team_state(state: &Value) -> Value {
     }
 }
 
+pub fn state_is_external_leader(state: &Value) -> bool {
+    state
+        .get("is_external_leader")
+        .and_then(Value::as_bool)
+        .unwrap_or(false)
+}
+
+pub fn state_is_managed_leader(state: &Value) -> bool {
+    !state_is_external_leader(state)
+}
+
 /// `merge_workspace_team_state`(`state.py:111`):把新启动的 team 并入既有 workspace state。
 pub fn merge_workspace_team_state(existing: &Value, launched: &Value) -> Value {
     let launched_key = team_state_key(launched);
@@ -471,6 +482,23 @@ pub(crate) fn save_team_scoped_state_with_deleted_agents(
     workspace: &Path,
     team_state: &Value,
     deleted_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_team_scoped_state_with_merge_exceptions(workspace, team_state, deleted_agent_ids, &[])
+}
+
+pub(crate) fn save_team_scoped_state_with_tombstoned_agents(
+    workspace: &Path,
+    team_state: &Value,
+    tombstoned_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_team_scoped_state_with_merge_exceptions(workspace, team_state, &[], tombstoned_agent_ids)
+}
+
+fn save_team_scoped_state_with_merge_exceptions(
+    workspace: &Path,
+    team_state: &Value,
+    deleted_agent_ids: &[&str],
+    tombstoned_agent_ids: &[&str],
 ) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
     let existing = load_runtime_state(workspace)?;
@@ -500,7 +528,15 @@ pub(crate) fn save_team_scoped_state_with_deleted_agents(
     // not existing_teams and existing_primary_key == target_key → 纯 save(剔 teams)。
     if existing_teams.is_empty() && existing_primary_key.as_deref() == Some(target_key.as_str()) {
         let merged = compact_team_state(team_state);
-        return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
+        if tombstoned_agent_ids.is_empty() {
+            return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
+        }
+        return save_runtime_state_with_team_tombstoned_agents(
+            workspace,
+            &merged,
+            &target_key,
+            tombstoned_agent_ids,
+        );
     }
     // teams = deepcopy(incoming_teams or existing_teams)
     let mut teams = match incoming_teams {
@@ -520,7 +556,16 @@ pub(crate) fn save_team_scoped_state_with_deleted_agents(
     if merged.get("teams").and_then(Value::as_object).is_some_and(Map::is_empty) {
         merged.remove("teams");
     }
-    save_runtime_state_with_deleted_agents(workspace, &Value::Object(merged), deleted_agent_ids)
+    if tombstoned_agent_ids.is_empty() {
+        save_runtime_state_with_deleted_agents(workspace, &Value::Object(merged), deleted_agent_ids)
+    } else {
+        save_runtime_state_with_team_tombstoned_agents(
+            workspace,
+            &Value::Object(merged),
+            &target_key,
+            tombstoned_agent_ids,
+        )
+    }
 }
 
 // ---- helpers ----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "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.3.17",
-    "@team-agent/cli-darwin-x64": "0.3.17",
-    "@team-agent/cli-linux-x64": "0.3.17"
+    "@team-agent/cli-darwin-arm64": "0.3.18",
+    "@team-agent/cli-darwin-x64": "0.3.18",
+    "@team-agent/cli-linux-x64": "0.3.18"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",