@team-agent/installer 0.3.21 → 0.3.23

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

@@ -187,6 +187,16 @@ pub(super) fn spawn_agent_window(
         )
     };
     let spawn = result.map_err(|e| LifecycleError::Transport(e.to_string()))?;
+    if layout_placement.is_some() {
+        crate::lifecycle::launch::configure_adaptive_pane_title(
+            workspace,
+            transport,
+            session_name,
+            &window,
+            &spawn.pane_id,
+            agent_id.as_str(),
+        );
+    }
     let _ = adapter.handle_startup_prompts(
         transport,
         &crate::transport::Target::Pane(spawn.pane_id.clone()),
@@ -247,6 +257,72 @@ pub(super) fn persist_effective_approval_policy_for_restart(
     crate::lifecycle::launch::persist_effective_approval_policy(agent, safety);
 }
 
+pub(super) fn save_restart_projected_state(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+) -> Result<(), LifecycleError> {
+    sync_restart_team_projections(state, team_key);
+    crate::state::projection::save_team_scoped_state(workspace, state)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
+pub(super) fn restart_projection_team_key(
+    state: &serde_json::Value,
+    team: Option<&str>,
+) -> String {
+    team.filter(|key| !key.is_empty())
+        .map(str::to_string)
+        .or_else(|| {
+            state
+                .get("active_team_key")
+                .and_then(serde_json::Value::as_str)
+                .filter(|key| !key.is_empty())
+                .map(str::to_string)
+        })
+        .unwrap_or_else(|| crate::state::projection::team_state_key(state))
+}
+
+pub(super) fn sync_restart_team_projections(state: &mut serde_json::Value, team_key: &str) {
+    let Some(teams) = state.get("teams").and_then(serde_json::Value::as_object) else {
+        return;
+    };
+    if teams.is_empty() {
+        return;
+    }
+    let compact = crate::state::projection::compact_team_state(state);
+    let active_key = state
+        .get("active_team_key")
+        .and_then(serde_json::Value::as_str)
+        .filter(|key| !key.is_empty())
+        .map(str::to_string);
+    let derived_key = crate::state::projection::team_state_key(state);
+    let Some(teams) = state
+        .get_mut("teams")
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return;
+    };
+    let mut keys = Vec::new();
+    if !team_key.is_empty() {
+        keys.push(team_key.to_string());
+    }
+    if let Some(active_key) = active_key {
+        keys.push(active_key);
+    }
+    if !derived_key.is_empty() {
+        keys.push(derived_key);
+    }
+    if teams.contains_key("current") {
+        keys.push("current".to_string());
+    }
+    keys.sort();
+    keys.dedup();
+    for key in keys {
+        teams.insert(key, compact.clone());
+    }
+}
+
 pub(super) fn state_session_name(state: &serde_json::Value) -> SessionName {
     state
         .get("session_name")
@@ -327,6 +403,7 @@ pub(super) fn resume_backing_exists_for_agent(
         Provider::Claude | Provider::ClaudeCode => {
             rollout_path_exists(rollout_path)
                 || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
+                || claude_project_transcript_exists(agent, session_id.as_str())
         }
         Provider::Copilot => copilot_session_store_has_session(session_id.as_str()),
         Provider::GeminiCli | Provider::Fake => false,
@@ -372,6 +449,42 @@ fn event_transcript_path(event: &serde_json::Value) -> Option<PathBuf> {
         .map(PathBuf::from)
 }
 
+/// E36 fix-B: a real Claude worker writes its session transcript to
+/// `<claude_projects_root>/<workspace-slug>/<session_id>.jsonl` even when neither
+/// `rollout_path` was persisted to state nor a `session.captured` event was logged.
+/// That landed transcript is itself a valid resume backing — restart was wrongly
+/// refusing resumable workers because it only checked the two paths above. Scan the
+/// projects root recursively for `<session_id>.jsonl` (session_id is a unique UUID,
+/// so we avoid recomputing the project-dir slug, which is brittle for non-ASCII
+/// workspace paths).
+fn claude_project_transcript_exists(agent: &serde_json::Value, session_id: &str) -> bool {
+    if session_id.is_empty() {
+        return false;
+    }
+    let projects_root = agent
+        .get("claude_projects_root")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(PathBuf::from)
+        .or_else(|| {
+            std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude").join("projects"))
+        });
+    let Some(projects_root) = projects_root else {
+        return false;
+    };
+    if !projects_root.is_dir() {
+        return false;
+    }
+    let transcript_name = format!("{session_id}.jsonl");
+    let Ok(project_dirs) = std::fs::read_dir(&projects_root) else {
+        return false;
+    };
+    project_dirs
+        .flatten()
+        .filter(|entry| entry.path().is_dir())
+        .any(|entry| entry.path().join(&transcript_name).is_file())
+}
+
 fn copilot_session_store_has_session(session_id: &str) -> bool {
     let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
         return false;
@@ -832,3 +945,69 @@ pub(super) fn is_dynamic_agent(
             .and_then(YamlValue::as_str)
             .is_some_and(|s| !s.is_empty())
 }
+
+#[cfg(test)]
+mod e36_transcript_backing_tests {
+    use super::*;
+
+    struct ScratchDir(PathBuf);
+    impl ScratchDir {
+        fn new(tag: &str) -> Self {
+            let pid = std::process::id();
+            let base = std::env::temp_dir().join(format!("ta-e36-{tag}-{pid}"));
+            std::fs::create_dir_all(&base).expect("scratch dir");
+            ScratchDir(base)
+        }
+        fn path(&self) -> &Path {
+            &self.0
+        }
+    }
+    impl Drop for ScratchDir {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(&self.0);
+        }
+    }
+
+    // E36 fix-B RED→GREEN: a real Claude worker that sent a message has its session
+    // transcript landed at <projects_root>/<slug>/<session_id>.jsonl, but neither
+    // rollout_path was persisted to state nor a session.captured event was logged.
+    // Before the fix, claude_project_transcript_exists did not exist and restart
+    // refused such a worker. This asserts the landed transcript is recognized.
+    #[test]
+    fn claude_project_transcript_is_recognized_without_rollout_or_capture_event() {
+        let scratch = ScratchDir::new("recognized");
+        let projects_root = scratch.path().join("projects");
+        let slug_dir = projects_root.join("-Users-alauda-Documents-code---rust---9");
+        std::fs::create_dir_all(&slug_dir).expect("mkdir slug");
+        let session_id = "87742d3f-0b4e-4fc1-ad35-447ac2340b65";
+        std::fs::write(slug_dir.join(format!("{session_id}.jsonl")), b"{}\n").expect("transcript");
+
+        let agent = serde_json::json!({
+            "claude_projects_root": projects_root.to_string_lossy(),
+        });
+        assert!(
+            claude_project_transcript_exists(&agent, session_id),
+            "landed claude transcript must count as resume backing (E36 fix-B)"
+        );
+    }
+
+    #[test]
+    fn missing_claude_transcript_is_not_backing() {
+        let scratch = ScratchDir::new("missing");
+        let projects_root = scratch.path().join("projects");
+        std::fs::create_dir_all(&projects_root).expect("mkdir");
+        let agent = serde_json::json!({
+            "claude_projects_root": projects_root.to_string_lossy(),
+        });
+        assert!(
+            !claude_project_transcript_exists(&agent, "deadbeef-0000-0000-0000-000000000000"),
+            "no transcript file => no backing"
+        );
+    }
+
+    #[test]
+    fn empty_session_id_is_not_backing() {
+        let agent = serde_json::json!({});
+        assert!(!claude_project_transcript_exists(&agent, ""));
+    }
+}

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"))