@team-agent/installer 0.3.23 → 0.3.25

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -544,13 +544,27 @@ impl Coordinator {
                 .get("last_output_at")
                 .and_then(Value::as_str)
                 .map(str::to_string);
-            let activity = crate::messaging::classify_agent_activity(
-                &snapshot,
-                &captured.text,
-                pane_in_mode,
-                current_command.as_deref(),
-                last_output_at_now.as_deref(),
-            );
+            // E47 (0.3.24 P0, idle/busy 假阳): consult the AUTHORITATIVE
+            // provider JSONL classifier BEFORE the TUI keyword scan. The
+            // scrollback Tail(40) keeps historical `• Working (...· esc to
+            // interrupt)` + spinners within the 40-line window long after a
+            // turn completed, so `classify_agent_activity`'s rfind-recency
+            // grep flips a truly-idle worker to Working/Stuck. The provider
+            // JSONL (codex task_complete / claude end_turn) is the single
+            // source of truth for "turn closed". Only fall back to TUI
+            // scanning when the JSONL is unreadable or no lifecycle fact has
+            // been written yet (TurnState::Unknown) — never silently fall
+            // through into the leaky grep on a CONFIRMED IDLE.
+            let activity_from_jsonl = jsonl_activity_for_agent(agent);
+            let activity = activity_from_jsonl.unwrap_or_else(|| {
+                crate::messaging::classify_agent_activity(
+                    &snapshot,
+                    &captured.text,
+                    pane_in_mode,
+                    current_command.as_deref(),
+                    last_output_at_now.as_deref(),
+                )
+            });
             remember_idle_capture_schedule(agent, &activity);
             write_activity(agent, &activity, false);
             let last_output_at = last_output_at_now;
@@ -2519,6 +2533,40 @@ fn agent_rollout_path(agent: &Value) -> Option<PathBuf> {
         .map(PathBuf::from)
 }
 
+/// E47 (0.3.24 P0, idle/busy 假阳): consult the authoritative provider JSONL
+/// classifier and map to neutral `AgentActivity`. Returns `None` when the
+/// classifier reports `TurnState::Unknown` (unreadable JSONL / no lifecycle
+/// fact yet) so the caller falls back to the TUI scan — this honours the
+/// IRON LAW (activity.rs:3 / bug-071/077/085): no-signal = Uncertain (not
+/// silently coerced to Idle); but here Unknown means "JSONL gave no signal",
+/// so we hand off to the TUI scanner which has its OWN no-signal → Uncertain
+/// path. Copilot/Gemini/Fake providers (which don't have JSONL — classify.rs
+/// returns Unknown for them) thus keep using TUI scanning unchanged.
+fn jsonl_activity_for_agent(agent: &Value) -> Option<crate::messaging::AgentActivity> {
+    let rollout_path = agent_rollout_path(agent)?;
+    let provider = agent
+        .get("provider")
+        .and_then(Value::as_str)
+        .and_then(parse_provider)?;
+    let log_text = std::fs::read_to_string(&rollout_path).ok()?;
+    let process = explicit_process_liveness(agent).unwrap_or(ProcessLiveness::Unverifiable);
+    let result = crate::provider::classify(provider, &log_text, process, 0.0).ok()?;
+    use crate::messaging::{ActivityStatus, AgentActivity};
+    use crate::provider::types::TurnState;
+    let status = match result.state {
+        TurnState::Idle => ActivityStatus::Idle,
+        TurnState::IdleInterrupted => ActivityStatus::Idle,
+        TurnState::Working => ActivityStatus::Working,
+        TurnState::BlockedOnHuman | TurnState::Abnormal => ActivityStatus::Uncertain,
+        TurnState::Unknown => return None,
+    };
+    Some(AgentActivity {
+        status,
+        confidence: 0.95,
+        rationale: format!("provider_jsonl:{}", result.reason),
+    })
+}
+
 fn runtime_approval_target(
     agent: &Value,
     session_name: Option<&str>,

package/crates/team-agent/src/leader/lease.rs

@@ -2,7 +2,7 @@
 //! + 双写 / 分叉检测。
 
 use std::collections::BTreeSet;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use serde_json::{json, Value};
 
@@ -1024,14 +1024,27 @@ fn state_owner(state: &Value) -> Option<TeamOwner> {
 pub fn write_lease_dual_state(workspace: &Path, state: &Value) -> Result<(), LeaderError> {
     crate::state::persist::save_runtime_state(workspace, state)?;
     if let Some(session_name) = state.get("session_name").and_then(Value::as_str) {
-        let snap_path = crate::model::paths::runtime_dir(workspace)
-            .join("teams")
-            .join(session_name)
-            .join("state.json");
-        if let Some(parent) = snap_path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        std::fs::write(snap_path, serde_json::to_string_pretty(state)?)?;
+        write_team_snapshot_atomic(workspace, session_name, state)?;
+    }
+    Ok(())
+}
+
+fn write_team_snapshot_atomic(
+    workspace: &Path,
+    session_name: &str,
+    state: &Value,
+) -> Result<(), LeaderError> {
+    let snap_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name);
+    let parent = snap_path
+        .parent()
+        .ok_or_else(|| LeaderError::Validation("team snapshot path has no parent".to_string()))?;
+    std::fs::create_dir_all(parent)?;
+    let tmp = parent.join(format!("state.json.tmp-{}", std::process::id()));
+    let data = serde_json::to_vec_pretty(state)?;
+    std::fs::write(&tmp, data)?;
+    if let Err(error) = std::fs::rename(&tmp, &snap_path) {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(error.into());
     }
     Ok(())
 }
@@ -1113,10 +1126,7 @@ pub fn detect_dual_state_divergence(
     let Some(session_name) = state.get("session_name").and_then(Value::as_str) else {
         return Ok(None);
     };
-    let snap_path = crate::model::paths::runtime_dir(workspace)
-        .join("teams")
-        .join(session_name)
-        .join("state.json");
+    let snap_path = readable_team_snapshot_path(workspace, session_name);
     if !snap_path.exists() {
         return Ok(None);
     }
@@ -1150,6 +1160,17 @@ pub fn detect_dual_state_divergence(
     })))
 }
 
+fn readable_team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf {
+    let safe_path = crate::lifecycle::helpers::team_snapshot_path(workspace, session_name);
+    if safe_path.exists() {
+        return safe_path;
+    }
+    crate::model::paths::runtime_dir(workspace)
+        .join("teams")
+        .join(session_name)
+        .join("state.json")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/crates/team-agent/src/leader/tests/lease_api.rs

@@ -145,6 +145,85 @@ use super::*;
         );
     }
 
+    #[test]
+    fn lease_divergence_reads_restart_snapshot_for_special_session_names() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_dual_special_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let state = serde_json::json!({
+            "session_name": "team:proj-中文",
+            "team_owner": {"pane_id": "%1", "owner_epoch": 2, "leader_session_uuid": "uuuu"},
+            "leader_receiver": {"pane_id": "%1", "owner_epoch": 2},
+        });
+        write_lease_dual_state(&ws, &state).unwrap();
+        let safe_path = crate::lifecycle::helpers::team_snapshot_path(&ws, "team:proj-中文");
+        let raw_path = crate::model::paths::runtime_dir(&ws)
+            .join("teams")
+            .join("team:proj-中文")
+            .join("state.json");
+        assert!(
+            safe_path.exists(),
+            "lease snapshot must use the restart-safe path: {}",
+            safe_path.display()
+        );
+        assert!(
+            !raw_path.exists(),
+            "new lease writes must not create the legacy raw session path: {}",
+            raw_path.display()
+        );
+
+        let restart_state = serde_json::json!({
+            "session_name": "team:proj-中文",
+            "team_owner": {"pane_id": "%9", "owner_epoch": 2, "leader_session_uuid": "uuuu"},
+            "leader_receiver": {"pane_id": "%9", "owner_epoch": 2},
+        });
+        let restart_path = crate::lifecycle::save_team_runtime_snapshot(&ws, &restart_state).unwrap();
+        assert_eq!(restart_path, safe_path);
+        assert!(
+            restart_path.exists(),
+            "restart snapshot must be written to a real file: {}",
+            restart_path.display()
+        );
+
+        let d = detect_dual_state_divergence(&ws, &state)
+            .unwrap()
+            .expect("divergence detector must read the restart-written snapshot");
+        assert_eq!(d["workspace_owner_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_owner_pane"], serde_json::json!("%9"));
+        assert_eq!(d["workspace_receiver_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_receiver_pane"], serde_json::json!("%9"));
+    }
+
+    #[test]
+    fn detect_dual_state_divergence_reads_legacy_raw_snapshot_when_safe_absent() {
+        let ws = std::env::temp_dir().join(format!("ta_rs_dual_legacy_{}", std::process::id()));
+        std::fs::create_dir_all(&ws).unwrap();
+        let state = serde_json::json!({
+            "session_name": "team:legacy-中文",
+            "team_owner": {"pane_id": "%1", "leader_session_uuid": "uuuu", "owner_epoch": 2},
+            "leader_receiver": {"pane_id": "%1", "owner_epoch": 2},
+        });
+        let safe_path = crate::lifecycle::helpers::team_snapshot_path(&ws, "team:legacy-中文");
+        assert!(!safe_path.exists(), "test setup requires safe path absent");
+        let raw_dir = crate::model::paths::runtime_dir(&ws)
+            .join("teams")
+            .join("team:legacy-中文");
+        std::fs::create_dir_all(&raw_dir).unwrap();
+        let snap = serde_json::json!({
+            "session_name": "team:legacy-中文",
+            "team_owner": {"pane_id": "%8", "leader_session_uuid": "uuuu", "owner_epoch": 2},
+            "leader_receiver": {"pane_id": "%8", "owner_epoch": 2},
+        });
+        std::fs::write(raw_dir.join("state.json"), serde_json::to_string(&snap).unwrap()).unwrap();
+
+        let d = detect_dual_state_divergence(&ws, &state)
+            .unwrap()
+            .expect("legacy raw snapshot fallback must preserve old teams");
+        assert_eq!(d["workspace_owner_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_owner_pane"], serde_json::json!("%8"));
+        assert_eq!(d["workspace_receiver_pane"], serde_json::json!("%1"));
+        assert_eq!(d["team_receiver_pane"], serde_json::json!("%8"));
+    }
+
     // detect_dual_state_divergence:无 session_name → None(__init__.py:560-561);unimplemented → RED。
     #[test]
     fn detect_dual_state_divergence_none_without_session_name() {

package/crates/team-agent/src/lifecycle/helpers.rs

@@ -16,14 +16,15 @@ pub fn save_team_runtime_snapshot(
         .get("session_name")
         .and_then(|v| v.as_str())
         .ok_or_else(|| LifecycleError::StatePersist("session_name is required".to_string()))?;
-    let safe = safe_snapshot_name(session_name);
     // golden restart/snapshot.py:46-47 — team_runtime_snapshot_dir = runtime_dir(workspace)/teams/<safe>,
     // and paths.py:25-26 runtime_dir = workspace/.team/runtime. Use the crate path helper so the snapshot
     // lands at <ws>/.team/runtime/teams/<safe>, matching golden AND the rest of the crate (not the
     // ".team"-less <ws>/runtime/teams that the original port wrote).
-    let dir = crate::model::paths::runtime_dir(workspace).join("teams").join(safe);
+    let path = team_snapshot_path(workspace, session_name);
+    let dir = path
+        .parent()
+        .ok_or_else(|| LifecycleError::StatePersist("snapshot path has no parent".to_string()))?;
     fs::create_dir_all(&dir).map_err(|e| persist_err("create snapshot dir", &e))?;
-    let path = dir.join("state.json");
     let tmp = dir.join("state.json.tmp");
     let data = serde_json::to_vec_pretty(state)
         .map_err(|e| LifecycleError::StatePersist(format!("serialize snapshot: {e}")))?;
@@ -32,6 +33,13 @@ pub fn save_team_runtime_snapshot(
     Ok(path)
 }
 
+pub fn team_snapshot_path(workspace: &Path, session_name: &str) -> PathBuf {
+    crate::model::paths::runtime_dir(workspace)
+        .join("teams")
+        .join(safe_snapshot_name(session_name))
+        .join("state.json")
+}
+
 fn persist_err(action: &str, err: &io::Error) -> LifecycleError {
     LifecycleError::StatePersist(format!("{action}: {err}"))
 }