@team-agent/installer 0.5.104 → 0.5.106

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

@@ -505,6 +505,7 @@ session="${TEAM_AGENT_E27_SESSION_NAME}"
 pane="${TEAM_AGENT_E27_PANE_ID}"
 killed_marker="${log}.killed"
 spawned_marker="${log}.spawned"
+anchor_marker="${log}.anchor"
 track=0
 case "$*" in
   *"$expected"*|*"$session"*|*"$pane"*) track=1 ;;
@@ -544,6 +545,23 @@ case "$*" in
     ;;
 esac
 case "$*" in
+  *"list-panes -s -t =$session -F"*)
+    if [ -f "$anchor_marker" ]; then
+      printf '%%9299\t[team-agent keepalive]\n'
+    fi
+    if [ ! -f "$killed_marker" ]; then
+      printf '%s\talpha\n' "$pane"
+    fi
+    if [ -f "$spawned_marker" ]; then
+      printf '%%9288\talpha\n'
+    fi
+    exit 0
+    ;;
+  *"new-window "*"[team-agent keepalive]"*)
+    : > "$anchor_marker"
+    printf '%%9299\n'
+    exit 0
+    ;;
   *"new-window "*|*"new-session "*)
     : > "$spawned_marker"
     printf '%%9288\n'
@@ -651,6 +669,10 @@ fn e27_stop_agent_uses_attached_explicit_state_socket() {
         "attached explicit-socket worker should be stopped"
     );
     assert_only_expected_socket_used(&shim.log, endpoint);
+    let raw = std::fs::read_to_string(&shim.log).unwrap();
+    assert!(raw.contains(&format!("list-panes -s -t ={session_name}")));
+    assert!(raw.contains("set-window-option -t %9299 remain-on-exit on"));
+    assert!(raw.contains("respawn-pane -k -t %9299 exit 0"));
     let state = crate::state::persist::load_runtime_state(&ws).unwrap();
     assert_eq!(
         state

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

@@ -73,6 +73,8 @@ pub(super) struct LaneTransport {
     killed: LaneKills,
     spawns: LaneSpawns,
     spawn_observed_at: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
+    stop_preservation: std::sync::Mutex<Vec<(Vec<crate::transport::Target>, Vec<String>)>>,
+    fail_stop_preservation: bool,
 }
 impl LaneTransport {
     pub(super) fn new(session: &str, windows: &[&str]) -> Self {
@@ -85,6 +87,8 @@ impl LaneTransport {
             killed: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             spawns: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             spawn_observed_at: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+            stop_preservation: std::sync::Mutex::new(Vec::new()),
+            fail_stop_preservation: false,
         }
     }
     pub(super) fn killed(&self) -> Vec<String> {
@@ -297,6 +301,21 @@ impl crate::transport::Transport for LaneTransport {
     ) -> Result<crate::transport::SetEnvOutcome, crate::transport::TransportError> {
         Ok(crate::transport::SetEnvOutcome::Applied)
     }
+    fn preserve_session_before_stop(
+        &self,
+        session: &crate::transport::SessionName,
+        targets: &[crate::transport::Target],
+    ) -> Result<(), crate::transport::TransportError> {
+        self.stop_preservation
+            .lock()
+            .unwrap()
+            .push((targets.to_vec(), self.killed()));
+        if self.fail_stop_preservation {
+            Err(crate::transport::TransportError::TargetNotFound { target: session.as_str().to_string() })
+        } else {
+            Ok(())
+        }
+    }
     fn kill_session(
         &self,
         _s: &crate::transport::SessionName,
@@ -408,6 +427,30 @@ fn lanea_one_agent_ws(alpha_status: &str) -> PathBuf {
     ws
 }
 
+#[test]
+fn stop_session_preservation_runs_before_kill_and_failure_preserves_worker_state() {
+    for fail in [false, true] {
+        let ws = lanea_one_agent_ws("running");
+        let mut tx = LaneTransport::new("team-laneateam", &["alpha"]);
+        tx.fail_stop_preservation = fail;
+        let result = stop_agent_with_transport(&ws, &aid("alpha"), None, &tx);
+        let calls = tx.stop_preservation.lock().unwrap();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].1, Vec::<String>::new(), "preserve must precede all worker kills");
+        assert_eq!(calls[0].0, vec![crate::transport::Target::Pane(crate::transport::PaneId::new("%alpha"))]);
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        if fail {
+            assert!(result.is_err());
+            assert!(tx.killed().is_empty());
+            assert_eq!(state["agents"]["alpha"]["status"], "running");
+        } else {
+            assert!(result.unwrap().stopped);
+            assert_eq!(tx.killed(), vec!["%alpha".to_string()]);
+            assert_eq!(state["agents"]["alpha"]["status"], "stopped");
+        }
+    }
+}
+
 fn selected_spec_path(ws: &std::path::Path) -> std::path::PathBuf {
     crate::state::selector::resolve_active_team(
         ws,

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

@@ -4,6 +4,7 @@ mod hermetic_guard;
 use super::*;
 use crate::tmux_backend::TmuxBackend;
 use crate::transport::test_support::OfflineTransport;
+use crate::transport::Transport;
 use serde_json::json;
 use serial_test::serial;
 
@@ -1231,6 +1232,64 @@ fn launch_with_transport_records_one_spawn_per_agent_carrying_build_command() {
         "LaunchReport.started must list the compiled agent; got {:?}",
         report.started
     );
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+    let generation = report.started[0].spawned_at.as_str();
+    assert_eq!(state["generation"], generation);
+    let team_key = crate::state::projection::team_state_key(&state);
+    assert_eq!(state["teams"][&team_key]["generation"], generation);
+    let owner = transport.session_owner(&SessionName::new("team-quickteam")).unwrap().unwrap();
+    assert_eq!(owner.generation, generation);
+}
+
+#[test]
+#[serial(env)]
+fn start_agent_session_generation_inherits_birth_or_stamps_recreated_session() {
+    for canonical_state in [false, true] {
+        for existing_session in [true, false] {
+            for explicit_generation in [true, false] {
+                let ws = restart_ws_one_resumable_worker();
+                let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+                let birth = "2026-07-14T00:00:00+00:00";
+                state["agents"]["alpha"]["status"] = json!("stopped");
+                state["agents"]["alpha"]["spawned_at"] = json!(birth);
+                if explicit_generation {
+                    state["generation"] = json!("explicit-session-birth");
+                }
+                let team_key = crate::state::projection::team_state_key(&state);
+                if canonical_state {
+                    state["team_key"] = json!(team_key);
+                    state["active_team_key"] = json!(team_key);
+                    state["teams"] = json!({});
+                    state["teams"][&team_key] = crate::state::projection::compact_team_state(&state);
+                }
+                let inherited = if explicit_generation { "explicit-session-birth" } else { birth };
+                crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+                let transport = OfflineTransport::new()
+                    .with_session_present(existing_session)
+                    .with_session_owner(&ws, &team_key, inherited);
+                let result = start_agent_with_transport(
+                    &ws, &aid("alpha"), false, false, false, None, &transport,
+                ).unwrap();
+                assert!(matches!(result, StartAgentOutcome::Running { .. }), "{result:?}");
+                let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+                let spawned_at = state["agents"]["alpha"]["spawned_at"].as_str().unwrap();
+                assert_ne!(spawned_at, birth);
+                let expected = if existing_session { inherited } else { spawned_at };
+                assert_eq!(state["generation"], expected);
+                if canonical_state {
+                    assert_eq!(state["teams"][&team_key]["generation"], expected);
+                } else {
+                    // Legacy flat state stays flat; generation persistence does
+                    // not implicitly migrate it to a canonical teams table.
+                    assert!(state.get("teams").is_none());
+                }
+                let owner = transport.session_owner(&SessionName::new("team-restartone")).unwrap().unwrap();
+                assert_eq!(owner.generation, expected);
+                assert_eq!(transport.calls().contains(&"set_session_owner_with_generation"), !existing_session);
+            }
+        }
+    }
 }
 
 // ═════════════════════════════════════════════════════════════════════════
@@ -1704,6 +1763,9 @@ fn restart_ws_one_resumable_worker() -> PathBuf {
 #[test]
 fn restart_with_transport_spawns_resumable_workers_not_stub() {
     let ws = restart_ws_two_resumable_workers();
+    let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    state["generation"] = json!("old-destroyed-session-birth");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let transport = OfflineTransport::new();
 
     let result = restart_with_transport(&ws, false, None, &transport);
@@ -1731,6 +1793,13 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
         matches!(result, Ok(RestartReport::Restarted { coordinator_started: true, .. })),
         "restart must reach RestartReport::Restarted with coordinator_started=true (AlreadyRunning, seeded); got {result:?}"
     );
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let generation = state["agents"]["alpha"]["spawned_at"].as_str().unwrap();
+    assert_ne!(generation, "old-destroyed-session-birth");
+    assert_eq!(state["generation"], generation);
+    assert!(state.get("teams").is_none(), "legacy flat state must remain flat");
+    let owner = transport.session_owner(&SessionName::new("team-restartteam")).unwrap().unwrap();
+    assert_eq!(owner.generation, generation);
     let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
     let completed = events
         .iter()
@@ -3071,6 +3140,8 @@ fn quick_start_state_seeds_spec_path_workspace_leader() {
             // `ResolvedTransport.source` through the launch call site.
             "transport",
             "active_team_key",
+            // Persist physical session birth independently of worker respawns.
+            "generation",
             "teams",
         ],
         "state.json top-level key order must match golden launch/core.py:62-71 \

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

@@ -180,8 +180,10 @@ fn scoped_shutdown_after_restart_refreshes_owner_and_preserves_sibling() {
     let report = restart_with_transport(&case.workspace, true, Some(TEAM), &transport).unwrap();
     assert!(matches!(report, RestartReport::Restarted { .. }), "{report:?}");
     let state = case.read_state();
-    let expected_generation = state["teams"][TEAM]["agents"]["w1"]["spawned_at"].as_str().unwrap();
-    assert_ne!(expected_generation, "2026-07-14T00:00:00+00:00");
+    let expected_generation = "2026-07-14T00:00:00+00:00";
+    assert_ne!(state["teams"][TEAM]["agents"]["w1"]["spawned_at"], expected_generation);
+    assert_eq!(state["generation"], expected_generation);
+    assert_eq!(state["teams"][TEAM]["generation"], expected_generation);
     let owner = transport.session_owner(&session).unwrap().unwrap();
     assert_eq!(owner.workspace, case.workspace.canonicalize().unwrap().to_string_lossy());
     assert_eq!(owner.team, TEAM);
@@ -213,8 +215,10 @@ fn failed_replacement_preserves_original_session_owner() {
         &session, &case.workspace, TEAM, "2026-07-14T00:00:00+00:00",
     ).unwrap();
     let owner_before = transport.session_owner(&session).unwrap();
+    let generation_before = case.read_state().get("generation").cloned();
     let report = restart_with_transport(&case.workspace, true, Some(TEAM), &transport).unwrap();
     assert_restart_did_not_succeed(&report);
+    assert_eq!(case.read_state().get("generation").cloned(), generation_before);
     assert_eq!(transport.session_owner(&session).unwrap(), owner_before);
     assert_eq!(transport.ops().iter().filter(|op| op.starts_with("set_session_owner:")).count(), 1);
 }

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

@@ -26,6 +26,21 @@ use crate::state::persist::{
 
 pub(crate) const CURRENT_TEAM_ALIAS: &str = "current";
 
+/// Physical tmux session birth identity, independent of later worker spawns.
+/// Legacy launches did not persist it: freeze their fallback BEFORE respawn.
+pub fn session_generation(state: &Value) -> Option<&str> {
+    state.get("generation").and_then(Value::as_str).or_else(|| {
+        state
+            .get("agents")
+            .and_then(Value::as_object)
+            .and_then(|agents| {
+                agents.values().find_map(|agent| {
+                    agent.get("spawned_at").and_then(Value::as_str)
+                })
+            })
+    })
+}
+
 ///
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。

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

@@ -162,7 +162,8 @@ impl<'a> StateRepository<'a> {
         test_support::before_commit();
         let team_key = match intent {
             StateWriteIntent::ResultCollection { owner_team_id } => owner_team_id,
-            StateWriteIntent::ForkAgent { team_key, .. } => Some(team_key),
+            StateWriteIntent::ForkAgent { team_key, .. }
+            | StateWriteIntent::StartAgent { team_key, .. } => Some(team_key),
             _ => {
                 return Err(StateError::SaveFailed(
                     "intent does not accept a bounded Team delta".into(),

package/crates/team-agent/src/tmux_backend/tests.rs

@@ -355,6 +355,21 @@ fn backend_with(default: MockResp, queued: Vec<MockResp>) -> (TmuxBackend, Recor
     (TmuxBackend::with_runner(Box::new(runner)), recorded)
 }
 
+#[test]
+fn pane_dead_observation_requires_native_boolean_receipt() {
+    for (text, expected) in [("1\n", Some(true)), ("0\n", Some(false)), ("", None), ("dead", None), ("2", None)] {
+        let (backend, recorded) = backend_with(MockResp::Out(ok(text)), Vec::new());
+        assert_eq!(backend.pane_is_dead(&PaneId::new("%47")).unwrap(), expected);
+        assert_eq!(recorded.lock().unwrap()[0], svec(&[
+            "tmux", "display-message", "-p", "-t", "%47", "#{pane_dead}",
+        ]));
+    }
+    let (backend, _) = backend_with(MockResp::Out(fail(1, "pane unavailable")), Vec::new());
+    assert_eq!(backend.pane_is_dead(&PaneId::new("%47")).unwrap(), None);
+    let (backend, _) = backend_with(MockResp::Io(std::io::ErrorKind::TimedOut), Vec::new());
+    assert!(backend.pane_is_dead(&PaneId::new("%47")).is_err());
+}
+
 #[test]
 fn provider_exit_receipt_accepts_only_shell_exit_status() {
     for (text, expected) in [
@@ -2202,6 +2217,128 @@ fn kill_session_and_kill_window_argv() {
     );
 }
 
+#[test]
+fn stop_session_preservation_creates_processless_anchor_by_exact_pane_id() {
+    let (be, rec) = backend_with(
+        MockResp::Out(ok("")),
+        vec![MockResp::Out(ok("%7\tworker\n")), MockResp::Out(ok("%8\n"))],
+    );
+    be.preserve_session_before_stop(
+        &SessionName::new("sess"),
+        &[Target::Pane(PaneId::new("%7"))],
+    ).unwrap();
+    let calls = rec.lock().unwrap();
+    assert_eq!(calls.len(), 4);
+    assert_eq!(calls[0], svec(&[
+        "tmux", "list-panes", "-s", "-t", "=sess", "-F", "#{pane_id}\t#{window_name}",
+    ]));
+    assert_eq!(calls[1], tmux_spawn_argv(
+        &SessionName::new("=sess"), &WindowName::new("[team-agent keepalive]"),
+        "exec sleep 86400", false,
+    ));
+    assert_eq!(calls[2], svec(&[
+        "tmux", "set-window-option", "-t", "%8", "remain-on-exit", "on",
+    ]));
+    assert_eq!(calls[3], svec(&["tmux", "respawn-pane", "-k", "-t", "%8", "exit 0"]));
+}
+
+#[test]
+fn stop_session_preservation_skips_surviving_workers_leaders_and_anchors() {
+    for survivor in ["other-worker", "leader", "[team-agent keepalive]", "worker"] {
+        let (be, rec) = backend_with(
+            MockResp::Out(ok(&format!("%7\tworker\n%8\t{survivor}\n"))), vec![],
+        );
+        be.preserve_session_before_stop(
+            &SessionName::new("sess"), &[Target::Pane(PaneId::new("%7"))],
+        ).unwrap();
+        assert_eq!(rec.lock().unwrap().len(), 1, "survivor={survivor}");
+    }
+}
+
+#[test]
+fn stop_session_preservation_covers_duplicate_panes_and_legacy_window_targets() {
+    for targets in [
+        vec![Target::Pane(PaneId::new("%7")), Target::Pane(PaneId::new("%8"))],
+        vec![Target::SessionWindow { session: SessionName::new("sess"), window: WindowName::new("worker") }],
+    ] {
+        let (be, rec) = backend_with(MockResp::Out(ok("")), vec![
+            MockResp::Out(ok("%7\tworker\n%8\tworker\n")), MockResp::Out(ok("%9\n")),
+        ]);
+        be.preserve_session_before_stop(&SessionName::new("sess"), &targets).unwrap();
+        assert_eq!(rec.lock().unwrap().len(), 4);
+    }
+}
+
+#[test]
+fn stop_session_preservation_refuses_unknown_listing_and_rolls_back_failed_anchor() {
+    for response in [fail(1, "listing failed"), ok(""), ok("malformed")] {
+        let (be, rec) = backend_with(MockResp::Out(response), vec![]);
+        assert!(be.preserve_session_before_stop(
+            &SessionName::new("sess"), &[Target::Pane(PaneId::new("%7"))],
+        ).is_err());
+        assert_eq!(rec.lock().unwrap().len(), 1);
+    }
+    for failed_step in ["new-window", "set-window-option", "respawn-pane"] {
+        let mut queued = vec![MockResp::Out(ok("%7\tworker\n"))];
+        if failed_step != "new-window" { queued.push(MockResp::Out(ok("%8\n"))); }
+        if failed_step == "respawn-pane" { queued.push(MockResp::Out(ok(""))); }
+        queued.push(MockResp::Out(fail(1, "anchor failed")));
+        let (be, rec) = backend_with(MockResp::Out(ok("")), queued);
+        assert!(be.preserve_session_before_stop(
+            &SessionName::new("sess"), &[Target::Pane(PaneId::new("%7"))],
+        ).is_err());
+        let calls = rec.lock().unwrap();
+        assert!(!calls.iter().any(|argv| argv.get(1).is_some_and(|op| op == "kill-window")));
+        if failed_step != "new-window" {
+            assert_eq!(calls.last().unwrap(), &svec(&["tmux", "kill-pane", "-t", "%8"]));
+        }
+        assert!(!calls.iter().any(|argv| argv.get(1).is_some_and(|op| op == "kill-pane") && argv.contains(&"%7".to_string())));
+    }
+}
+
+#[test]
+#[ignore = "isolated native tmux: executed explicitly on the remote test host"]
+fn stop_session_preservation_native_tmux_stop_start_and_shutdown() {
+    let tmp = std::env::temp_dir().join(format!(
+        "ta-preserve-{}-{}", std::process::id(), chrono::Utc::now().timestamp_nanos_opt().unwrap(),
+    ));
+    std::fs::create_dir(&tmp).unwrap();
+    let endpoint = tmp.join("tmux.sock");
+    let be = TmuxBackend::with_runner_for_tmux_endpoint(Box::new(RealCommandRunner), endpoint.to_str().unwrap());
+    let session = SessionName::new("preserve-test");
+    struct Cleanup<'a>(&'a TmuxBackend, &'a SessionName, &'a Path);
+    impl Drop for Cleanup<'_> {
+        fn drop(&mut self) {
+            let _ = self.0.kill_session(self.1);
+            let _ = std::fs::remove_dir_all(self.2);
+        }
+    }
+    let _cleanup = Cleanup(&be, &session, &tmp);
+    let argv = svec(&["sleep", "86400"]);
+    let env = BTreeMap::new();
+    let mut worker = be.spawn_first(&session, &WindowName::new("worker"), &argv, &tmp, &env).unwrap();
+    for _ in 0..3 {
+        be.preserve_session_before_stop(&session, &[Target::Pane(worker.pane_id.clone())]).unwrap();
+        be.kill_pane(&worker.pane_id).unwrap();
+        assert!(be.has_session(&session).unwrap());
+        assert_eq!(be.has_pane(&worker.pane_id).unwrap(), Some(false));
+        assert_eq!(be.list_windows(&session).unwrap(), vec![WindowName::new("[team-agent keepalive]")]);
+        let anchor = be.list_targets().unwrap().into_iter().find(|pane| pane.session == session).unwrap();
+        let deadline = Instant::now() + Duration::from_secs(2);
+        loop {
+            let dead = be.runner.run(&be.tmux_argv(&svec(&[
+                "tmux", "display-message", "-p", "-t", anchor.pane_id.as_str(), "#{pane_dead}",
+            ]))).unwrap();
+            if dead.success && dead.stdout.trim() == "1" { break; }
+            assert!(Instant::now() < deadline, "keepalive must have no running process: {dead:?}");
+            std::thread::sleep(Duration::from_millis(20));
+        }
+        worker = be.spawn_into(&session, &WindowName::new("worker"), &argv, &tmp, &env).unwrap();
+    }
+    be.kill_session(&session).unwrap();
+    assert!(!be.has_session(&session).unwrap());
+}
+
 // ── 8. ERROR MAPPING: non-zero tmux exit -> TransportError::Subprocess; runner io::Error -> Err ──
 #[test]
 fn error_paths_map_to_transport_error_not_panic() {

package/crates/team-agent/src/tmux_backend.rs

@@ -74,6 +74,7 @@ use crate::transport::{
 };
 
 pub const PANE_BINDING_NONCE_METADATA_KEY: &str = "TEAM_AGENT_PANE_BINDING_NONCE";
+pub(crate) const KEEPALIVE_WINDOW_NAME: &str = "[team-agent keepalive]";
 const TMUX_PANE_BINDING_NONCE_OPTION: &str = "@team_agent_pane_binding_nonce";
 const TMUX_SESSION_OWNER_WORKSPACE_OPTION: &str = "@team_agent_owner_workspace";
 const TMUX_SESSION_OWNER_TEAM_OPTION: &str = "@team_agent_owner_team";
@@ -3875,6 +3876,26 @@ impl Transport for TmuxBackend {
         Ok(output.stdout.trim().parse::<u8>().ok())
     }
 
+    fn pane_is_dead(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            "#{pane_dead}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if !output.success {
+            return Ok(None);
+        }
+        Ok(match output.stdout.trim() {
+            "1" => Some(true),
+            "0" => Some(false),
+            _ => None,
+        })
+    }
+
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
         let argv = self.tmux_argv(&[
             "tmux".to_string(),
@@ -4087,6 +4108,95 @@ impl Transport for TmuxBackend {
         self.run_ok(&argv)
     }
 
+    fn preserve_session_before_stop(
+        &self,
+        session: &SessionName,
+        targets: &[Target],
+    ) -> Result<(), TransportError> {
+        let list_argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "list-panes".to_string(),
+            "-s".to_string(),
+            "-t".to_string(),
+            format!("={}", session.as_str()),
+            "-F".to_string(),
+            "#{pane_id}\t#{window_name}".to_string(),
+        ]);
+        let output = self.runner.run(&list_argv)?;
+        if !output.success {
+            return Err(subprocess_error(list_argv, output));
+        }
+        for line in output.stdout.lines() {
+            let Some((pane, window)) = line.split_once('\t') else {
+                return Err(TransportError::Subprocess {
+                    argv: list_argv,
+                    code: output.code,
+                    stderr: "tmux returned an invalid session pane listing".to_string(),
+                });
+            };
+            if !targets.iter().any(|target| match target {
+                Target::Pane(id) => id.as_str() == pane,
+                Target::SessionWindow {
+                    session: owner,
+                    window: name,
+                } => owner == session && name.as_str() == window,
+            }) {
+                return Ok(());
+            }
+        }
+        // An empty listing cannot prove that this is the last worker.
+        if output.stdout.trim().is_empty() {
+            return Err(TransportError::TargetNotFound {
+                target: session.as_str().to_string(),
+            });
+        }
+        // Use a separate, non-worker window: remain-on-exit does not protect a
+        // pane explicitly deleted by kill-pane. Configure by the new pane ID,
+        // not a window name that could resolve to another same-named window.
+        let spawn_argv = tmux_spawn_argv(
+            &SessionName::new(format!("={}", session.as_str())),
+            &WindowName::new(KEEPALIVE_WINDOW_NAME),
+            "exec sleep 86400",
+            false,
+        );
+        let spawned = self.run_spawn(&spawn_argv)?;
+        let pane = spawned.stdout.trim();
+        if !pane.starts_with('%')
+            || pane.len() == 1
+            || !pane[1..].chars().all(|ch| ch.is_ascii_digit())
+        {
+            return Err(TransportError::Subprocess {
+                argv: self.tmux_argv(&spawn_argv),
+                code: spawned.code,
+                stderr: "tmux keepalive spawn returned no valid pane id".to_string(),
+            });
+        }
+        let result = self
+            .run_ok(&[
+                "tmux".to_string(),
+                "set-window-option".to_string(),
+                "-t".to_string(),
+                pane.to_string(),
+                "remain-on-exit".to_string(),
+                "on".to_string(),
+            ])
+            .and_then(|()| {
+                self.run_ok(&[
+                    "tmux".to_string(),
+                    "respawn-pane".to_string(),
+                    "-k".to_string(),
+                    "-t".to_string(),
+                    pane.to_string(),
+                    "exit 0".to_string(),
+                ])
+            });
+        if result.is_err() {
+            // The worker has not been killed yet; remove only our new anchor.
+            let _ = self.kill_pane(&PaneId::new(pane));
+        }
+        result
+    }
+
     fn kill_server(&self) -> Result<(), TransportError> {
         TmuxBackend::kill_server(self);
         Ok(())

package/crates/team-agent/src/transport/test_support.rs

@@ -29,6 +29,7 @@ struct OfflineState {
     target_snapshots: VecDeque<Vec<PaneInfo>>,
     windows: Vec<WindowName>,
     pane_presence: BTreeMap<String, bool>,
+    dead_panes: BTreeMap<String, bool>,
     spawn_failures: BTreeMap<String, String>,
     spawned_panes_addressable: bool,
     liveness: BTreeMap<String, PaneLiveness>,
@@ -67,6 +68,7 @@ impl Default for OfflineState {
             target_snapshots: VecDeque::new(),
             windows: Vec::new(),
             pane_presence: BTreeMap::new(),
+            dead_panes: BTreeMap::new(),
             spawn_failures: BTreeMap::new(),
             spawned_panes_addressable: true,
             liveness: BTreeMap::new(),
@@ -144,6 +146,13 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_pane_dead(self, pane: impl Into<String>, dead: bool) -> Self {
+        self.with_state(|state| {
+            state.dead_panes.insert(pane.into(), dead);
+        });
+        self
+    }
+
     pub fn with_spawn_failure(self, window: impl Into<String>, error: impl Into<String>) -> Self {
         self.with_state(|state| {
             state.spawn_failures.insert(window.into(), error.into());
@@ -523,6 +532,13 @@ impl Transport for OfflineTransport {
         Ok(self.with_state(|state| state.pane_current_commands.get(&pane_id).cloned()))
     }
 
+    fn pane_is_dead(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("pane_is_dead");
+            state.dead_panes.get(pane.as_str()).copied()
+        }))
+    }
+
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
         Ok(self.with_state(|state| {
             state.calls.push("liveness");
@@ -582,6 +598,25 @@ impl Transport for OfflineTransport {
         Ok(self.with_state(|state| state.session_owner.clone()))
     }
 
+    fn set_session_owner_with_generation(
+        &self,
+        _session: &SessionName,
+        workspace: &Path,
+        team: &str,
+        generation: &str,
+    ) -> Result<(), TransportError> {
+        self.with_state(|state| {
+            state.calls.push("set_session_owner_with_generation");
+            state.session_owner = Some(super::SessionOwner {
+                workspace: workspace.canonicalize().unwrap_or_else(|_| workspace.to_path_buf())
+                    .to_string_lossy().to_string(),
+                team: team.to_string(),
+                generation: generation.to_string(),
+            });
+        });
+        Ok(())
+    }
+
     fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         Ok(self.with_state(|state| {
             state.calls.push("list_windows");