@team-agent/installer 0.3.20 → 0.3.22

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

@@ -6,8 +6,8 @@
 
 use crate::cli::lifecycle_port::{sessions_to_kill, KillDecision};
 use crate::transport::{
-    AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
-    Key, PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target, Transport,
+    AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport, Key,
+    PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target, Transport,
     TransportError, WindowName,
 };
 use serde_json::json;
@@ -33,7 +33,10 @@ fn rc4_exclusive_socket_kills_server() {
     // 空 session 集 → 逐 kill(no-op),不整 server 拆(没东西可拆)。
     assert_eq!(
         sessions_to_kill(&[], &BTreeSet::new()),
-        KillDecision::KillIndividually { to_kill: vec![], spared: vec![] }
+        KillDecision::KillIndividually {
+            to_kill: vec![],
+            spared: vec![]
+        }
     );
 }
 
@@ -45,8 +48,16 @@ fn rc1_in_tmux_no_prefix_anchor_spares_user_session() {
     let decision = sessions_to_kill(&sessions, &anchor);
     match decision {
         KillDecision::KillIndividually { to_kill, spared } => {
-            assert_eq!(to_kill, names(&["team-x"]), "only non-anchor session killed");
-            assert_eq!(spared, names(&["team-coder-team"]), "user/leader session spared by anchor");
+            assert_eq!(
+                to_kill,
+                names(&["team-x"]),
+                "only non-anchor session killed"
+            );
+            assert_eq!(
+                spared,
+                names(&["team-coder-team"]),
+                "user/leader session spared by anchor"
+            );
         }
         other => panic!("anchor session must force per-session kill, not {other:?}"),
     }
@@ -106,7 +117,10 @@ fn union_prefix_and_anchor_no_double_count() {
     let decision = sessions_to_kill(&sessions, &anchor);
     assert_eq!(
         decision,
-        KillDecision::KillIndividually { to_kill: vec![], spared: names(&["team-agent-leader-claude-ws-beef"]) }
+        KillDecision::KillIndividually {
+            to_kill: vec![],
+            spared: names(&["team-agent-leader-claude-ws-beef"])
+        }
     );
 }
 
@@ -136,12 +150,214 @@ fn missing_coordinator_is_ok_when_shutdown_cleaned_session() {
     .expect("shutdown should complete");
     assert_eq!(out["coordinator"]["status"], json!("missing"));
     assert_eq!(
-        out["ok"], json!(true),
+        out["ok"],
+        json!(true),
         "coordinator.status=missing alone must not make a fully cleaned shutdown partial: {out}"
     );
     assert_eq!(out["status"], json!("ok"));
     assert_eq!(out["residuals"]["sessions"], json!([]));
     assert_eq!(out["residuals"]["processes"], json!([]));
+    assert_eq!(out["residuals"]["owned_files"], json!([]));
+}
+
+#[test]
+fn owned_empty_endpoint_cleanup_removes_socket_file_before_reporting_ok() {
+    let ws = tmp_shutdown_workspace("owned-empty-endpoint-clean");
+    let socket = ws.join("owned.sock");
+    std::fs::write(&socket, b"socket").unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-owned-clean",
+            "tmux_endpoint": socket.to_string_lossy(),
+            "tmux_socket": socket.to_string_lossy(),
+            "tmux_socket_source": "workspace",
+            "is_external_leader": false,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new();
+
+    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["status"], json!("ok"));
+    assert_eq!(out["residuals"]["owned_files"], json!([]));
+    assert!(
+        !socket.exists(),
+        "owned empty endpoint socket file must be removed"
+    );
+    assert!(
+        transport.kill_server_called(),
+        "owned empty endpoint should be torn down after session cleanup"
+    );
+}
+
+#[test]
+fn leader_env_endpoint_is_not_owned_or_removed() {
+    let ws = tmp_shutdown_workspace("leader-env-endpoint-spared");
+    let socket = ws.join("leader-env.sock");
+    std::fs::write(&socket, b"socket").unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-external",
+            "tmux_endpoint": socket.to_string_lossy(),
+            "tmux_socket": socket.to_string_lossy(),
+            "tmux_socket_source": "leader_env",
+            "is_external_leader": true,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new();
+
+    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["residuals"]["owned_files"], json!([]));
+    assert!(socket.exists(), "leader_env socket is not team-owned");
+    assert!(
+        !transport.kill_server_called(),
+        "leader_env/shared socket must never be torn down by owned cleanup"
+    );
+}
+
+#[test]
+fn owned_file_residual_makes_shutdown_failed_not_partial() {
+    let ws = tmp_shutdown_workspace("owned-file-residual-failed");
+    let socket_dir = ws.join("owned-dir.sock");
+    std::fs::create_dir_all(&socket_dir).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-owned-residual",
+            "tmux_endpoint": socket_dir.to_string_lossy(),
+            "tmux_socket": socket_dir.to_string_lossy(),
+            "tmux_socket_source": "workspace",
+            "is_external_leader": false,
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new();
+
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(&ws, true, None, &transport)
+        .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(false));
+    assert_eq!(out["status"], json!("failed"));
+    assert_eq!(out["phase"], json!(null));
+    assert_eq!(
+        out["residuals"]["owned_files"],
+        json!([{ "path": socket_dir.display().to_string() }])
+    );
+}
+
+#[test]
+fn scoped_shutdown_keeps_owned_endpoint_when_sibling_session_remains() {
+    let ws = tmp_shutdown_workspace("scoped-owned-endpoint-sibling");
+    let socket = ws.join("owned-shared.sock");
+    std::fs::write(&socket, b"socket").unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "active_team_key": "team-a",
+            "teams": {
+                "team-a": {
+                    "team_key": "team-a",
+                    "status": "alive",
+                    "session_name": "team-a",
+                    "tmux_endpoint": socket.to_string_lossy(),
+                    "tmux_socket": socket.to_string_lossy(),
+                    "tmux_socket_source": "workspace",
+                    "is_external_leader": false,
+                    "agents": {}
+                },
+                "team-b": {
+                    "team_key": "team-b",
+                    "status": "alive",
+                    "session_name": "team-b",
+                    "tmux_endpoint": socket.to_string_lossy(),
+                    "tmux_socket": socket.to_string_lossy(),
+                    "tmux_socket_source": "workspace",
+                    "is_external_leader": false,
+                    "agents": {}
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let transport = CleanShutdownTransport::new()
+        .with_targets(vec![PaneInfo {
+            pane_id: PaneId::new("%2"),
+            session: SessionName::new("team-b"),
+            window_index: Some(0),
+            window_name: Some(WindowName::new("worker")),
+            pane_index: Some(0),
+            tty: None,
+            current_command: Some("fake".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, Some("team-a"), &transport)
+            .expect("shutdown should complete");
+
+    assert_eq!(out["ok"], json!(true));
+    assert_eq!(out["residuals"]["owned_files"], json!([]));
+    assert!(
+        socket.exists(),
+        "owned endpoint stays while sibling team session remains"
+    );
+    assert!(
+        !transport.kill_server_called(),
+        "scoped shutdown must not tear down a non-empty shared owned endpoint"
+    );
+}
+
+#[test]
+fn repeated_owned_endpoint_shutdowns_leave_no_socket_file_growth() {
+    let ws = tmp_shutdown_workspace("owned-loop-no-growth");
+    let sockets = (0..20)
+        .map(|idx| ws.join(format!("owned-loop-{idx}.sock")))
+        .collect::<Vec<_>>();
+    let starting = sockets.iter().filter(|path| path.exists()).count();
+    for socket in &sockets {
+        std::fs::write(socket, b"socket").unwrap();
+        crate::state::persist::save_runtime_state(
+            &ws,
+            &json!({
+                "session_name": "team-owned-loop",
+                "tmux_endpoint": socket.to_string_lossy(),
+                "tmux_socket": socket.to_string_lossy(),
+                "tmux_socket_source": "workspace",
+                "is_external_leader": false,
+                "agents": {}
+            }),
+        )
+        .unwrap();
+        let out = crate::cli::lifecycle_port::shutdown_with_transport(
+            &ws,
+            true,
+            None,
+            &CleanShutdownTransport::new(),
+        )
+        .expect("shutdown should complete");
+        assert_eq!(out["ok"], json!(true), "shutdown report: {out}");
+    }
+    let ending = sockets.iter().filter(|path| path.exists()).count();
+    assert_eq!(
+        ending, starting,
+        "owned socket files must not grow across loops"
+    );
 }
 
 fn tmp_shutdown_workspace(tag: &str) -> PathBuf {
@@ -241,7 +457,10 @@ impl Transport for CleanShutdownTransport {
         _target: &Target,
         range: CaptureRange,
     ) -> Result<CapturedText, TransportError> {
-        Ok(CapturedText { text: String::new(), range })
+        Ok(CapturedText {
+            text: String::new(),
+            range,
+        })
     }
 
     fn query(&self, _target: &Target, _field: PaneField) -> Result<Option<String>, TransportError> {
@@ -337,7 +556,9 @@ fn lsof_cwd_timeout_is_diagnostic_not_shutdown_partial() {
     assert_eq!(out["residuals"]["sessions"], json!([]));
     assert_eq!(out["residuals"]["processes"], json!([]));
 
-    let events = crate::event_log::EventLog::new(&ws).tail(0).expect("events");
+    let events = crate::event_log::EventLog::new(&ws)
+        .tail(0)
+        .expect("events");
     let shutdown = events
         .iter()
         .find(|event| {
@@ -412,6 +633,7 @@ fn shutdown_outcome_late_or_postcheck_gone_is_ok_with_lsof_diagnostic() {
             kill_error: false,
             session_residuals: false,
             process_residuals: false,
+            owned_file_residuals: false,
             cleanup_truth_degraded: false,
             coordinator_timeout: true,
             coordinator_stop_ok: None,
@@ -431,6 +653,7 @@ fn shutdown_outcome_coordinator_timeout_still_running_is_timeout() {
             kill_error: false,
             session_residuals: false,
             process_residuals: false,
+            owned_file_residuals: false,
             cleanup_truth_degraded: false,
             coordinator_timeout: true,
             coordinator_stop_ok: None,
@@ -450,6 +673,7 @@ fn shutdown_outcome_ps_table_degraded_still_partial_after_coordinator_gone() {
             kill_error: false,
             session_residuals: false,
             process_residuals: false,
+            owned_file_residuals: false,
             cleanup_truth_degraded: true,
             coordinator_timeout: true,
             coordinator_stop_ok: None,

package/crates/team-agent/src/coordinator/runtime_detectors.rs

@@ -116,6 +116,25 @@ fn detect_session_drift(
         .filter(|s| !s.trim().is_empty())?;
     let actual = extract_thread_id_from_scrollback(&fact.scrollback_tail)?;
     if actual.eq_ignore_ascii_case(stored) {
+        if agent_has_session_drift(state, &fact.agent_id)
+            || fact
+                .agent_state_snapshot
+                .get("status")
+                .and_then(Value::as_str)
+                == Some("session_drift")
+        {
+            clear_agent_session_drift(state, &fact.agent_id);
+            let _ = event_log.write(
+                "coordinator.session_drift_cleared",
+                json!({
+                    "agent_id": fact.agent_id.as_str(),
+                    "stored_session_id": stored,
+                    "actual_thread_id": actual,
+                    "status": "running",
+                    "provider": "codex",
+                }),
+            );
+        }
         return None;
     }
     if fact
@@ -278,7 +297,9 @@ fn extract_thread_id_from_scrollback(scrollback: &str) -> Option<String> {
         while let Some(pos) = lower.get(offset..).and_then(|tail| tail.find(needle)) {
             let start = offset + pos + needle.len();
             if let Some(token) = first_token(scrollback.get(start..).unwrap_or_default()) {
-                found = Some(token.to_ascii_lowercase());
+                if is_uuid_token(&token) {
+                    found = Some(token.to_ascii_lowercase());
+                }
             }
             offset = start;
         }
@@ -297,11 +318,33 @@ fn first_token(text: &str) -> Option<String> {
         .unwrap_or(trimmed);
     let token: String = trimmed
         .chars()
-        .take_while(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | ':' | '.'))
+        .take_while(|c| c.is_ascii_alphanumeric() || *c == '-')
         .collect();
     (!token.is_empty()).then_some(token)
 }
 
+fn is_uuid_token(token: &str) -> bool {
+    let bytes = token.as_bytes();
+    if bytes.len() != 36 {
+        return false;
+    }
+    for (idx, byte) in bytes.iter().enumerate() {
+        match idx {
+            8 | 13 | 18 | 23 => {
+                if *byte != b'-' {
+                    return false;
+                }
+            }
+            _ => {
+                if !byte.is_ascii_hexdigit() {
+                    return false;
+                }
+            }
+        }
+    }
+    true
+}
+
 fn mark_agent_session_drift(
     state: &mut Value,
     agent_id: &AgentId,
@@ -341,6 +384,49 @@ fn mark_agent_session_drift(
     }
 }
 
+fn clear_agent_session_drift(state: &mut Value, agent_id: &AgentId) {
+    if let Some(agent) = agent_object_mut(state, agent_id) {
+        agent.insert("status".to_string(), Value::String("running".to_string()));
+        agent.remove("session_drift");
+    }
+    if let Some(teams) = state.get_mut("teams").and_then(Value::as_object_mut) {
+        for team in teams.values_mut() {
+            if let Some(agent) = team
+                .get_mut("agents")
+                .and_then(Value::as_object_mut)
+                .and_then(|agents| agents.get_mut(agent_id.as_str()))
+                .and_then(Value::as_object_mut)
+            {
+                agent.insert("status".to_string(), Value::String("running".to_string()));
+                agent.remove("session_drift");
+            }
+        }
+    }
+}
+
+fn agent_has_session_drift(state: &Value, agent_id: &AgentId) -> bool {
+    state
+        .get("agents")
+        .and_then(Value::as_object)
+        .and_then(|agents| agents.get(agent_id.as_str()))
+        .and_then(|agent| agent.get("status"))
+        .and_then(Value::as_str)
+        == Some("session_drift")
+        || state
+            .get("teams")
+            .and_then(Value::as_object)
+            .is_some_and(|teams| {
+                teams.values().any(|team| {
+                    team.get("agents")
+                        .and_then(Value::as_object)
+                        .and_then(|agents| agents.get(agent_id.as_str()))
+                        .and_then(|agent| agent.get("status"))
+                        .and_then(Value::as_str)
+                        == Some("session_drift")
+                })
+            })
+}
+
 fn match_api_error(scrollback: &str) -> Option<(String, String)> {
     let lines: Vec<String> = scrollback
         .lines()
@@ -510,3 +596,166 @@ fn tail_chars(text: &str, max_chars: usize) -> String {
     let start = chars.len().saturating_sub(max_chars);
     chars[start..].iter().collect()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeMap;
+    use std::path::PathBuf;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    use crate::model::ids::{AgentId, TeamKey};
+
+    const STORED: &str = "11111111-1111-4111-8111-111111111111";
+    const OTHER: &str = "22222222-2222-4222-8222-222222222222";
+
+    #[test]
+    fn session_drift_ignores_plain_text_after_marker_words() {
+        let workspace = temp_workspace("plain-text");
+        let mut state = state_with_agent("running", None);
+        let captures = captures("w1", STORED, "Need resume confirmation before changing anything.\nSeveral threads mention evidence.\n");
+
+        let observed = observe_runtime(&workspace, &mut state, captures, None);
+
+        assert!(
+            observed.session_drift.is_empty(),
+            "plain prose must not be treated as a runtime id observation: {observed:?}"
+        );
+        assert_eq!(
+            state.pointer("/agents/w1/status").and_then(Value::as_str),
+            Some("running")
+        );
+        assert!(state.pointer("/agents/w1/session_drift").is_none());
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+
+    #[test]
+    fn session_drift_marks_real_uuid_mismatch() {
+        let workspace = temp_workspace("uuid-mismatch");
+        let mut state = state_with_agent("running", None);
+        let captures = captures(
+            "w1",
+            STORED,
+            &format!("Codex resumed. Switched to thread {OTHER}\n"),
+        );
+
+        let observed = observe_runtime(&workspace, &mut state, captures, None);
+
+        assert_eq!(observed.session_drift.len(), 1, "{observed:?}");
+        assert_eq!(
+            state.pointer("/agents/w1/status").and_then(Value::as_str),
+            Some("session_drift")
+        );
+        assert_eq!(
+            state
+                .pointer("/agents/w1/session_drift/actual_thread_id")
+                .and_then(Value::as_str),
+            Some(OTHER)
+        );
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+
+    #[test]
+    fn session_drift_clears_existing_marker_when_uuid_matches() {
+        let workspace = temp_workspace("uuid-match-clear");
+        let mut state = state_with_agent(
+            "session_drift",
+            Some(json!({
+                "stored_session_id": STORED,
+                "actual_thread_id": OTHER,
+                "detected_at": "2026-06-13T00:00:00Z",
+                "remediation": "old"
+            })),
+        );
+        let captures = captures("w1", STORED, &format!("resume {STORED}\n"));
+
+        let observed = observe_runtime(&workspace, &mut state, captures, None);
+
+        assert!(
+            observed.session_drift.is_empty(),
+            "matching observation clears state instead of reporting a new drift: {observed:?}"
+        );
+        assert_eq!(
+            state.pointer("/agents/w1/status").and_then(Value::as_str),
+            Some("running")
+        );
+        assert!(state.pointer("/agents/w1/session_drift").is_none());
+        assert_eq!(
+            state
+                .pointer("/teams/current/agents/w1/status")
+                .and_then(Value::as_str),
+            Some("running")
+        );
+        assert!(state
+            .pointer("/teams/current/agents/w1/session_drift")
+            .is_none());
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+
+    fn captures(
+        agent_id: &str,
+        stored_session_id: &str,
+        scrollback_tail: &str,
+    ) -> BTreeMap<AgentId, CapturedRuntimeFact> {
+        let agent_id = AgentId::new(agent_id);
+        let snapshot = json!({
+            "provider": "codex",
+            "status": "running",
+            "session_id": stored_session_id,
+        });
+        BTreeMap::from([(
+            agent_id.clone(),
+            CapturedRuntimeFact {
+                team_key: Some(TeamKey::new("current")),
+                agent_id,
+                provider: Some(Provider::Codex),
+                session_name: None,
+                window: None,
+                pane_id: None,
+                scrollback_tail: scrollback_tail.to_string(),
+                pane_info: None,
+                agent_state_snapshot: snapshot,
+                stored_session_id: Some(stored_session_id.to_string()),
+                last_output_at: None,
+                rollout_path: None,
+                process_liveness: None,
+            },
+        )])
+    }
+
+    fn state_with_agent(status: &str, session_drift: Option<Value>) -> Value {
+        let mut agent = json!({
+            "provider": "codex",
+            "status": status,
+            "session_id": STORED,
+        });
+        if let Some(drift) = session_drift {
+            agent["session_drift"] = drift;
+        }
+        json!({
+            "active_team_key": "current",
+            "agents": {
+                "w1": agent.clone()
+            },
+            "teams": {
+                "current": {
+                    "agents": {
+                        "w1": agent
+                    }
+                }
+            }
+        })
+    }
+
+    fn temp_workspace(tag: &str) -> PathBuf {
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-rs-e28-{tag}-{}-{}",
+            std::process::id(),
+            COUNTER.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::canonicalize(dir).unwrap()
+    }
+}