@team-agent/installer 0.3.20 → 0.3.21

package/Cargo.lock

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

package/Cargo.toml

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

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()
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.20",
+  "version": "0.3.21",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.3.20",
-    "@team-agent/cli-darwin-x64": "0.3.20",
-    "@team-agent/cli-linux-x64": "0.3.20"
+    "@team-agent/cli-darwin-arm64": "0.3.21",
+    "@team-agent/cli-darwin-x64": "0.3.21",
+    "@team-agent/cli-linux-x64": "0.3.21"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",