@team-agent/installer 0.3.20 → 0.3.22

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

@@ -23,8 +23,7 @@ pub fn restart_with_session_convergence_deadline(
     session_converge_deadline_ms: Option<u64>,
 ) -> Result<RestartReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
-    let transport =
-        lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
     restart_with_transport_with_session_convergence_deadline(
         workspace,
         allow_fresh,
@@ -148,12 +147,10 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         allow_fresh,
     )?;
     if convergence.converged && convergence.changed {
-        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
-            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
     if repair_resume_sessions_from_event_log(&selected.run_workspace, &mut state)? {
-        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
-            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
         let missing_after_repair = restart_required_missing_session_agent_ids(&state);
         convergence.changed = true;
         convergence.converged = missing_after_repair.is_empty();
@@ -173,8 +170,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         });
     }
     if !convergence.converged && convergence.changed {
-        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
-            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
     let mut forced_fresh_missing = if convergence.converged {
         std::collections::BTreeSet::new()
@@ -222,8 +218,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             .map_err(|e| LifecycleError::Transport(e.to_string()))?;
         mark_leader_receiver_rebind_required(&mut state, &session_name);
         mark_restart_targets_stopped_after_teardown(&mut state, &plan.decisions);
-        crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
-            .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
     let mut successful_agents: Vec<RestartedAgent> = Vec::new();
     let mut failed_agents: Vec<RestartFailedAgent> = Vec::new();
@@ -353,8 +348,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         }
     }
     // END_B5_RESTART_ISOLATION_LOOP
-    crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     if fatal_resume_failure {
         let attach_commands = Vec::new();
         let next_actions = restart_failure_next_actions(&failed_agents);
@@ -868,6 +862,14 @@ fn mark_restart_targets_stopped_after_teardown(
     }
 }
 
+fn save_restart_state(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+) -> Result<(), LifecycleError> {
+    save_restart_projected_state(workspace, state, team_key)
+}
+
 fn mark_agent_respawned(
     state: &mut serde_json::Value,
     agent_id: &AgentId,
@@ -906,7 +908,13 @@ fn mark_agent_respawned(
     });
     if let Some(pane_pid) = pane_pid {
         agent.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
+    } else {
+        agent.remove("pane_pid");
     }
+    agent.insert(
+        "spawned_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
     if matches!(
         restart_mode,
         StartMode::Fresh | StartMode::FreshAfterMissingRollout
@@ -929,7 +937,10 @@ fn mark_agent_respawned(
             "layout_index".to_string(),
             serde_json::json!(placement.layout_index),
         );
-        agent.insert("pane_index".to_string(), serde_json::json!(placement.pane_index));
+        agent.insert(
+            "pane_index".to_string(),
+            serde_json::json!(placement.pane_index),
+        );
         agent.insert(
             "display".to_string(),
             serde_json::json!({
@@ -963,6 +974,8 @@ fn mark_agent_respawned(
     }
     agent.remove("startup_prompts");
     agent.remove("startup_prompt_status");
+    agent.remove("startup_prompt_probe_epoch");
+    agent.remove("startup_prompt_probe_disabled_at");
     Ok(())
 }
 
@@ -1403,3 +1416,272 @@ fn restart_candidate_has_context(state: &serde_json::Value) -> bool {
             })
         })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeMap;
+    use std::path::Path;
+
+    use crate::transport::{
+        AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport, Key,
+        PaneField, PaneInfo, PaneLiveness, SetEnvOutcome, SpawnResult, Target, Transport,
+        TransportError,
+    };
+
+    struct RespawnEpochTransport;
+
+    impl Transport for RespawnEpochTransport {
+        fn kind(&self) -> BackendKind {
+            BackendKind::Tmux
+        }
+
+        fn spawn_first(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            unimplemented!("not used by respawn epoch test")
+        }
+
+        fn spawn_into(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            unimplemented!("not used by respawn epoch test")
+        }
+
+        fn inject(
+            &self,
+            _target: &Target,
+            _payload: &InjectPayload,
+            _submit: Key,
+            _bracketed: bool,
+        ) -> Result<InjectReport, TransportError> {
+            unimplemented!("not used by respawn epoch test")
+        }
+
+        fn send_keys(&self, _target: &Target, _keys: &[Key]) -> Result<(), TransportError> {
+            unimplemented!("not used by respawn epoch test")
+        }
+
+        fn capture(
+            &self,
+            _target: &Target,
+            range: CaptureRange,
+        ) -> Result<CapturedText, TransportError> {
+            Ok(CapturedText {
+                text: String::new(),
+                range,
+            })
+        }
+
+        fn query(
+            &self,
+            _target: &Target,
+            _field: PaneField,
+        ) -> Result<Option<String>, TransportError> {
+            Ok(None)
+        }
+
+        fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+            Ok(PaneLiveness::Live)
+        }
+
+        fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
+            Ok(true)
+        }
+
+        fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn set_session_env(
+            &self,
+            _session: &SessionName,
+            _key: &str,
+            _value: &str,
+        ) -> Result<SetEnvOutcome, TransportError> {
+            Ok(SetEnvOutcome::Applied)
+        }
+
+        fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn attach_session(&self, _session: &SessionName) -> Result<AttachOutcome, TransportError> {
+            Ok(AttachOutcome::Attached)
+        }
+    }
+
+    fn disabled_safety() -> DangerousApproval {
+        DangerousApproval {
+            enabled: false,
+            source: DangerousApprovalSource::Disabled,
+            inherited: false,
+            provider: None,
+            flag: None,
+            worker_capability_above_leader: false,
+            ancestry_binary_name: None,
+            unexpected_binary: false,
+        }
+    }
+
+    #[test]
+    fn respawn_refreshes_startup_probe_epoch_inputs() {
+        let mut state = serde_json::json!({
+            "agents": {
+                "w1": {
+                    "status": "running",
+                    "window": "w1-old",
+                    "pane_id": "%old",
+                    "pane_pid": 1010,
+                    "spawned_at": "2026-06-01T00:00:00+00:00",
+                    "startup_prompts": "disabled_for_epoch",
+                    "startup_prompt_status": "disabled_for_epoch",
+                    "startup_prompt_probe_epoch": "pane_pid:1010",
+                    "startup_prompt_probe_disabled_at": "2026-06-01T00:02:30+00:00"
+                }
+            }
+        });
+        let spawn = SpawnedAgentWindow {
+            spawn: SpawnResult {
+                pane_id: PaneId::new("%new"),
+                session: SessionName::new("team-epoch"),
+                window: WindowName::new("w1"),
+                child_pid: Some(2020),
+            },
+            plan: crate::provider::CommandPlan::argv_only(vec!["codex".to_string()]),
+            profile_launch: crate::provider::ProviderProfileLaunch::default(),
+            layout_placement: None,
+        };
+        let before = chrono::Utc::now();
+
+        mark_agent_respawned(
+            &mut state,
+            &AgentId::new("w1"),
+            StartMode::Resumed,
+            &spawn,
+            &RespawnEpochTransport,
+            &disabled_safety(),
+        )
+        .expect("mark respawned");
+
+        let agent = state.pointer("/agents/w1").expect("agent");
+        assert_eq!(
+            agent.get("pane_id").and_then(serde_json::Value::as_str),
+            Some("%new")
+        );
+        assert_eq!(
+            agent.get("pane_pid").and_then(serde_json::Value::as_u64),
+            Some(2020)
+        );
+        let spawned_at = agent
+            .get("spawned_at")
+            .and_then(serde_json::Value::as_str)
+            .expect("spawned_at refreshed");
+        let spawned_at = chrono::DateTime::parse_from_rfc3339(spawned_at)
+            .expect("spawned_at rfc3339")
+            .with_timezone(&chrono::Utc);
+        assert!(
+            spawned_at >= before - chrono::Duration::seconds(1),
+            "respawn must start a fresh startup-probe grace window; spawned_at={spawned_at}, before={before}"
+        );
+        for key in [
+            "startup_prompts",
+            "startup_prompt_status",
+            "startup_prompt_probe_epoch",
+            "startup_prompt_probe_disabled_at",
+        ] {
+            assert!(
+                agent.get(key).is_none(),
+                "respawned pane must not inherit old startup prompt epoch field {key}"
+            );
+        }
+    }
+
+    #[test]
+    fn restart_projection_sync_updates_active_team_and_current_alias() {
+        let mut state = serde_json::json!({
+            "active_team_key": "team-alpha",
+            "team_dir": "/tmp/team-alpha",
+            "session_name": "team-alpha",
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "pane_id": "%new",
+                    "pane_pid": 47650,
+                    "spawned_at": "2026-06-13T04:00:00+00:00"
+                }
+            },
+            "teams": {
+                "current": {
+                    "team_dir": "/tmp/team-alpha",
+                    "session_name": "team-alpha",
+                    "agents": {
+                        "alpha": {
+                            "status": "running",
+                            "pane_id": "%new",
+                            "pane_pid": 47650,
+                            "spawned_at": "2026-06-13T04:00:00+00:00"
+                        }
+                    }
+                },
+                "team-alpha": {
+                    "team_dir": "/tmp/team-alpha",
+                    "session_name": "team-alpha",
+                    "agents": {
+                        "alpha": {
+                            "status": "running",
+                            "pane_id": "%old",
+                            "pane_pid": 46784,
+                            "spawned_at": "2026-06-13T03:00:00+00:00",
+                            "startup_prompt_probe_epoch": "pane_pid:46784"
+                        }
+                    }
+                }
+            }
+        });
+
+        sync_restart_team_projections(&mut state, "team-alpha");
+
+        for pointer in [
+            "/agents/alpha",
+            "/teams/current/agents/alpha",
+            "/teams/team-alpha/agents/alpha",
+        ] {
+            let agent = state.pointer(pointer).expect(pointer);
+            assert_eq!(
+                agent.get("pane_id").and_then(serde_json::Value::as_str),
+                Some("%new")
+            );
+            assert_eq!(
+                agent.get("pane_pid").and_then(serde_json::Value::as_u64),
+                Some(47650)
+            );
+            assert_eq!(
+                agent.get("spawned_at").and_then(serde_json::Value::as_str),
+                Some("2026-06-13T04:00:00+00:00")
+            );
+            assert!(
+                agent.get("startup_prompt_probe_epoch").is_none(),
+                "{pointer} must not retain the old startup probe epoch"
+            );
+        }
+    }
+}

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

@@ -1118,6 +1118,20 @@ fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
         vec!["spawn_first", "spawn_split", "spawn_split", "spawn_into"],
         "4 default-adaptive workers should create team-w1 with 3 panes, then team-w2"
     );
+    assert_eq!(
+        transport
+            .pane_title_records()
+            .iter()
+            .map(|(_, window, pane, title)| (window.as_str(), pane.as_str(), title.as_str()))
+            .collect::<Vec<_>>(),
+        vec![
+            ("team-w1", "%0", "w1"),
+            ("team-w1", "%1", "w2"),
+            ("team-w1", "%2", "w3"),
+            ("team-w2", "%3", "w4"),
+        ],
+        "adaptive workers must set tmux pane titles to the agent id"
+    );
     assert_eq!(
         launch
             .started
@@ -1147,6 +1161,14 @@ fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
     );
 
     let (_raw, state) = raw_runtime_state(workspace);
+    assert!(
+        transport
+            .pane_title_records()
+            .iter()
+            .all(|(session, _, _, _)| Some(session.as_str())
+                == state.get("session_name").and_then(serde_json::Value::as_str)),
+        "pane titles must be configured inside the team session"
+    );
     assert_eq!(state["display_backend"], json!("adaptive"));
     assert_eq!(state.pointer("/agents/w1/window"), Some(&json!("team-w1")));
     assert_eq!(state.pointer("/agents/w1/layout_window"), Some(&json!("team-w1")));
@@ -1155,6 +1177,14 @@ fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
         state.pointer("/agents/w1/display/backend"),
         Some(&json!("adaptive"))
     );
+    assert_eq!(
+        state.pointer("/agents/w1/display/pane_title"),
+        Some(&json!("w1"))
+    );
+    assert_eq!(
+        state.pointer("/agents/w1/display/linked_session"),
+        Some(&json!(null))
+    );
     assert_eq!(
         state.pointer("/agents/w4/layout_window"),
         Some(&json!("team-w2"))

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

@@ -41,11 +41,11 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
     }
     fn spawn_first(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_first".to_string(), argv.to_vec()));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new("%0"), session: session.clone(), window: window.clone(), child_pid: None })
+        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new("%0"), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn spawn_into(&self, session: &crate::transport::SessionName, window: &crate::transport::WindowName, argv: &[String], _cwd: &std::path::Path, _env: &std::collections::BTreeMap<String, String>) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
         self.spawns.lock().unwrap().push(("spawn_into".to_string(), argv.to_vec()));
-        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(format!("%{}", window.as_str())), session: session.clone(), window: window.clone(), child_pid: None })
+        Ok(crate::transport::SpawnResult { pane_id: crate::transport::PaneId::new(format!("%{}", window.as_str())), session: session.clone(), window: window.clone(), child_pid: Some(6856) })
     }
     fn inject(&self, _t: &crate::transport::Target, _p: &crate::transport::InjectPayload, _s: crate::transport::Key, _b: bool) -> Result<crate::transport::InjectReport, crate::transport::TransportError> {
         unimplemented!("not reached by start_agent respawn")
@@ -54,16 +54,19 @@ impl crate::transport::Transport for SessionProbeRecordingTransport {
         unimplemented!("not reached")
     }
     fn capture(&self, _t: &crate::transport::Target, _r: crate::transport::CaptureRange) -> Result<crate::transport::CapturedText, crate::transport::TransportError> {
-        unimplemented!("not reached")
+        Ok(crate::transport::CapturedText {
+            text: String::new(),
+            range: crate::transport::CaptureRange::Full,
+        })
     }
     fn query(&self, _t: &crate::transport::Target, _f: crate::transport::PaneField) -> Result<Option<String>, crate::transport::TransportError> {
         unimplemented!("not reached")
     }
     fn liveness(&self, _p: &crate::transport::PaneId) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
-        unimplemented!("not reached")
+        Ok(crate::model::enums::PaneLiveness::Live)
     }
     fn list_targets(&self) -> Result<Vec<crate::transport::PaneInfo>, crate::transport::TransportError> {
-        unimplemented!("not reached")
+        Ok(Vec::new())
     }
     fn has_session(&self, _s: &crate::transport::SessionName) -> Result<bool, crate::transport::TransportError> {
         Ok(self.session_exists)
@@ -163,6 +166,87 @@ fn reset_agent_discard_session_rebuilds_window_via_start_respawn() {
         "into a LIVE session (has_session=true) the window rebuild is a new-window (spawn_into); got {recorded:?}"
     );
 }
+
+#[test]
+fn reset_agent_discard_session_syncs_projection_epoch_inputs_for_restart_agent_command() {
+    let ws = restart_ws_two_resumable_workers();
+    let mut state = crate::state::persist::load_runtime_state(&ws).expect("load state");
+    state["team_dir"] = json!(ws.to_string_lossy());
+    state["active_team_key"] = json!("restartteam");
+    state["agents"]["alpha"]["window"] = json!("alpha");
+    state["agents"]["alpha"]["pane_id"] = json!("%old");
+    state["agents"]["alpha"]["pane_pid"] = json!(6304);
+    state["agents"]["alpha"]["spawned_at"] = json!("2026-06-13T01:00:00+00:00");
+    state["agents"]["alpha"]["startup_prompts"] = json!("disabled_for_epoch");
+    state["agents"]["alpha"]["startup_prompt_status"] = json!("disabled_for_epoch");
+    state["agents"]["alpha"]["startup_prompt_probe_epoch"] = json!("pane_pid:6304");
+    state["agents"]["alpha"]["startup_prompt_probe_disabled_at"] =
+        json!("2026-06-13T01:01:00+00:00");
+    let compact = crate::state::projection::compact_team_state(&state);
+    state["teams"] = json!({
+        "current": compact.clone(),
+        "restartteam": compact,
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).expect("save stale projections");
+
+    let before = chrono::Utc::now();
+    let spawns = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+    let transport = SessionProbeRecordingTransport {
+        spawns: std::sync::Arc::clone(&spawns),
+        session_exists: true,
+    };
+    let outcome = reset_agent_with_transport(&ws, &AgentId::new("alpha"), true, false, None, &transport)
+        .expect("reset-agent alpha --discard-session --no-display");
+    assert!(
+        matches!(outcome, ResetAgentOutcome::Reset { .. }),
+        "restart-agent alpha --discard-session --no-display must complete reset; got {outcome:?}"
+    );
+
+    let state = crate::state::persist::load_runtime_state(&ws).expect("reload state");
+    for pointer in [
+        "/agents/alpha",
+        "/teams/current/agents/alpha",
+        "/teams/restartteam/agents/alpha",
+    ] {
+        let agent = state.pointer(pointer).expect(pointer);
+        assert_eq!(
+            agent.get("pane_id").and_then(serde_json::Value::as_str),
+            Some("%alpha"),
+            "{pointer} must project the reset-spawned pane, not the stale pre-reset pane"
+        );
+        assert_eq!(
+            agent.get("pane_pid").and_then(serde_json::Value::as_u64),
+            Some(6856),
+            "{pointer} must project the reset-spawned pane pid, not stale pid 6304"
+        );
+        let spawned_at = agent
+            .get("spawned_at")
+            .and_then(serde_json::Value::as_str)
+            .expect("spawned_at refreshed");
+        assert_ne!(
+            spawned_at, "2026-06-13T01:00:00+00:00",
+            "{pointer} must not retain stale spawned_at"
+        );
+        let spawned_at = chrono::DateTime::parse_from_rfc3339(spawned_at)
+            .expect("spawned_at rfc3339")
+            .with_timezone(&chrono::Utc);
+        assert!(
+            spawned_at >= before - chrono::Duration::seconds(1),
+            "{pointer} must get a fresh startup-probe grace epoch; spawned_at={spawned_at}, before={before}"
+        );
+        for key in [
+            "startup_prompts",
+            "startup_prompt_status",
+            "startup_prompt_probe_epoch",
+            "startup_prompt_probe_disabled_at",
+        ] {
+            assert!(
+                agent.get(key).is_none(),
+                "{pointer} must not retain old startup probe epoch field {key}"
+            );
+        }
+    }
+}
 // item ② — remove invoked with a NON-canonical input (the workspace's own `.team` subpath) must resolve
 // the CANONICAL live run-workspace and apply the removal to the LIVE roster — not the subpath's detached
 // runtime. canonical_run_workspace($ws/.team) == $ws. The regression made remove "succeed" against a