@team-agent/installer 0.5.33 → 0.5.35

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.33"
+version = "0.5.35"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.33"
+version = "0.5.35"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/status.rs

@@ -52,6 +52,14 @@ pub fn agent_summary_counts(agents: &Value, health: &Value) -> SummaryCounts {
             .and_then(|v| v.get("status"))
             .and_then(Value::as_str)
             .unwrap_or("");
+        // 0.5.35 R4 (`.team/artifacts/managed-leader-provider-reentry-locate.md`):
+        // canonical `worker_state=UNKNOWN` / `activity.status=uncertain`
+        // beats legacy `agent_health.status=WORKING` so the five-line
+        // summary stops counting a runtime-honestly-UNKNOWN agent as busy.
+        if canonical_worker_state_is_unknown(agent) {
+            counts.unknown += 1;
+            continue;
+        }
         match classify_agent_bucket(raw, hstatus) {
             SummaryBucket::Running => counts.running += 1,
             SummaryBucket::Busy => counts.busy += 1,
@@ -64,6 +72,22 @@ pub fn agent_summary_counts(agents: &Value, health: &Value) -> SummaryCounts {
     counts
 }
 
+/// 0.5.35 R4: return true when the runtime classifier has written a
+/// canonical non-decisive observation onto the agent row. Used by
+/// `agent_summary_counts` and `csv_agent_status` so the "UNKNOWN-first"
+/// signal beats legacy `agent_health.status`.
+fn canonical_worker_state_is_unknown(agent: &Value) -> bool {
+    let worker_state_unknown = agent
+        .get("worker_state")
+        .and_then(Value::as_str)
+        .is_some_and(|value| value.eq_ignore_ascii_case("UNKNOWN"));
+    let activity_uncertain = agent
+        .pointer("/activity/status")
+        .and_then(Value::as_str)
+        .is_some_and(|value| value.eq_ignore_ascii_case("uncertain"));
+    worker_state_unknown || activity_uncertain
+}
+
 fn stale_agent_bucket(agent: &Value) -> Option<SummaryBucket> {
     if agent.get("stale").and_then(Value::as_bool) != Some(true) {
         return None;
@@ -224,6 +248,10 @@ fn csv_agent_status(
     if matches!(raw.as_str(), "running" | "busy" | "working") && !pane_present {
         return "错误";
     }
+    // 0.5.35 R4: canonical UNKNOWN beats legacy WORKING in human CSV too.
+    if canonical_worker_state_is_unknown(agent) {
+        return "未知";
+    }
     if raw == "idle" || hstatus == "idle" {
         return "空闲";
     }

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

@@ -223,7 +223,22 @@ pub fn execute_leader_plan(
         && !std::io::stdin().is_terminal()
         && insert_detach_flag(&mut argv);
     if plan.mode == LeaderStartMode::ExecProvider && !plan.is_external_leader {
-        persist_exec_provider_leader_binding(plan, workspace)?;
+        // 0.5.35 (`.team/artifacts/managed-leader-provider-reentry-locate.md`
+        // §5/§6): three-way classify BEFORE persist. Same physical pane =
+        // provider process replacement (refresh only). Different pane with
+        // an existing canonical binding = no canonical rewrite (claim /
+        // takeover is the recovery path, §7). Unbound = first-time write.
+        match classify_exec_provider_binding(workspace, plan)? {
+            ExecProviderBinding::ManagedReentry => {
+                refresh_managed_leader_provider_binding(plan, workspace)?;
+            }
+            ExecProviderBinding::DifferentPaneAlreadyBound => {
+                // No canonical state write. Provider still runs below.
+            }
+            ExecProviderBinding::Unbound => {
+                persist_exec_provider_leader_binding(plan, workspace)?;
+            }
+        }
     } else if plan.is_external_leader {
         persist_external_leader_topology_marker(plan, workspace)?;
     }
@@ -904,6 +919,184 @@ fn persist_exec_provider_leader_binding(
     Ok(())
 }
 
+/// 0.5.35 (`.team/artifacts/managed-leader-provider-reentry-locate.md` §5/§6):
+/// three-way classification of an in-tmux ExecProvider invocation. Physical-
+/// channel-first — never consults `pane_current_command` or gates on
+/// `leader_session_uuid` equality (§6 forbids uuid-mismatch hard refusal).
+enum ExecProviderBinding {
+    ManagedReentry,
+    DifferentPaneAlreadyBound,
+    Unbound,
+}
+
+fn classify_exec_provider_binding(
+    workspace: &Path,
+    plan: &LeaderStartPlan,
+) -> Result<ExecProviderBinding, LeaderError> {
+    let Some(pane) = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+    else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let state = match crate::state::persist::load_runtime_state(workspace) {
+        Ok(state) => state,
+        Err(_) => return Ok(ExecProviderBinding::Unbound),
+    };
+    let team_key = plan
+        .identity
+        .as_ref()
+        .map(|identity| identity.team_id.as_str().to_string())
+        .or_else(|| {
+            state
+                .get("active_team_key")
+                .and_then(serde_json::Value::as_str)
+                .filter(|s| !s.is_empty())
+                .map(str::to_string)
+        });
+    let Some(team_key) = team_key else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let Some(receiver) = state
+        .pointer(&format!("/teams/{team_key}/leader_receiver"))
+        .and_then(serde_json::Value::as_object)
+    else {
+        return Ok(ExecProviderBinding::Unbound);
+    };
+    let receiver_pane = receiver
+        .get("pane_id")
+        .or_else(|| receiver.get("pane"))
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or("");
+    if receiver_pane.is_empty() {
+        return Ok(ExecProviderBinding::Unbound);
+    }
+    if receiver_pane != pane {
+        return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+    }
+    let pane_id = PaneId::new(pane.clone());
+    let target = current_tmux_pane_info(&pane_id);
+    let leader_prefixed_session = target
+        .as_ref()
+        .map(|t| t.session.as_str().starts_with(LEADER_SESSION_PREFIX))
+        .unwrap_or(false);
+    if !leader_prefixed_session {
+        return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+    }
+    let recorded_socket = receiver
+        .get("tmux_socket")
+        .and_then(serde_json::Value::as_str)
+        .filter(|s| !s.is_empty());
+    if let Some(recorded_socket) = recorded_socket {
+        let caller_socket = crate::tmux_backend::socket_name_from_tmux_env();
+        if caller_socket.as_deref() != Some(recorded_socket) {
+            return Ok(ExecProviderBinding::DifferentPaneAlreadyBound);
+        }
+    }
+    Ok(ExecProviderBinding::ManagedReentry)
+}
+
+/// 0.5.35: same-pane provider re-entry refresh path. Preserves canonical
+/// team runtime identity (`session_name`/`team_dir`/`spec_path`/`agents`/
+/// `tasks`) and epoch non-regressively; updates only diagnostic receiver
+/// fields. Stage 3 strip preserved (root `team_owner`/`leader_receiver`/
+/// `owner_epoch` are NOT reintroduced — writes go through
+/// `state::ownership::write_owner` into the canonical teams.<key> slot).
+fn refresh_managed_leader_provider_binding(
+    plan: &LeaderStartPlan,
+    workspace: &Path,
+) -> Result<(), LeaderError> {
+    let identity = plan
+        .identity
+        .as_ref()
+        .ok_or_else(|| LeaderError::Start("managed leader re-entry identity missing".to_string()))?;
+    let pane = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .ok_or_else(|| LeaderError::Start("managed leader re-entry pane missing".to_string()))?;
+    let pane_id = PaneId::new(pane.clone());
+    let target = current_tmux_pane_info(&pane_id);
+    let mut state = crate::state::persist::load_runtime_state(workspace)
+        .unwrap_or_else(|_| serde_json::json!({}));
+    let team_key = identity.team_id.as_str();
+    let existing_receiver = state
+        .pointer(&format!("/teams/{team_key}/leader_receiver"))
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    let existing_owner = crate::state::ownership::read_owner_value(&state, team_key)
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}));
+    let existing_epoch = state
+        .pointer(&format!("/teams/{team_key}/owner_epoch"))
+        .and_then(serde_json::Value::as_u64)
+        .or_else(|| existing_owner.get("owner_epoch").and_then(serde_json::Value::as_u64))
+        .or_else(|| existing_receiver.get("owner_epoch").and_then(serde_json::Value::as_u64))
+        .unwrap_or(0);
+    let now = chrono::Utc::now().to_rfc3339();
+    let provider = serde_json::to_value(plan.provider)?;
+    let mut receiver = match existing_receiver.as_object() {
+        Some(map) => serde_json::Value::Object(map.clone()),
+        None => serde_json::json!({}),
+    };
+    if let Some(obj) = receiver.as_object_mut() {
+        obj.insert("mode".to_string(), serde_json::json!("direct_tmux"));
+        obj.insert("status".to_string(), serde_json::json!("attached"));
+        obj.insert("provider".to_string(), provider.clone());
+        obj.insert("pane_id".to_string(), serde_json::json!(pane));
+        obj.insert("pane".to_string(), serde_json::json!(pane));
+        obj.insert("attached_at".to_string(), serde_json::json!(now.clone()));
+        obj.insert("discovery".to_string(), serde_json::json!("managed_leader"));
+        obj.insert("owner_epoch".to_string(), serde_json::json!(existing_epoch));
+        obj.entry("leader_session_uuid".to_string())
+            .or_insert_with(|| serde_json::json!(identity.leader_session_uuid.as_str()));
+        if let Some(target) = target.as_ref() {
+            obj.insert("session_name".to_string(), serde_json::json!(target.session.as_str()));
+            if let Some(window_name) = target.window_name.as_ref() {
+                obj.insert("window_name".to_string(), serde_json::json!(window_name.as_str()));
+            }
+            if let Some(pane_pid) = target.pane_pid {
+                obj.insert("pane_pid".to_string(), serde_json::json!(pane_pid));
+            }
+        }
+    }
+    let mut owner = match existing_owner.as_object() {
+        Some(map) => serde_json::Value::Object(map.clone()),
+        None => serde_json::json!({}),
+    };
+    if let Some(obj) = owner.as_object_mut() {
+        obj.insert("pane_id".to_string(), serde_json::json!(pane));
+        obj.insert("provider".to_string(), provider);
+        obj.insert("owner_epoch".to_string(), serde_json::json!(existing_epoch));
+        obj.entry("machine_fingerprint".to_string())
+            .or_insert_with(|| serde_json::json!(identity.machine_fingerprint.as_str()));
+        obj.entry("leader_session_uuid".to_string())
+            .or_insert_with(|| serde_json::json!(identity.leader_session_uuid.as_str()));
+        obj.entry("claimed_via".to_string())
+            .or_insert_with(|| serde_json::json!("claim-leader"));
+        obj.entry("os_user".to_string())
+            .or_insert_with(|| serde_json::json!(identity.os_user.as_str()));
+    }
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert("active_team_key".to_string(), serde_json::json!(team_key));
+        obj.insert(
+            "leader_client".to_string(),
+            serde_json::json!({
+                "diagnostic_only": true,
+                "attach_mode": "exec-provider",
+                "tmux": std::env::var("TMUX").ok(),
+                "reentry": true,
+            }),
+        );
+    }
+    let record = crate::state::ownership::OwnershipWrite::new()
+        .with_leader_receiver(receiver)
+        .with_team_owner(owner)
+        .with_owner_epoch(existing_epoch);
+    crate::state::ownership::write_owner(&mut state, team_key, record);
+    crate::state::persist::save_runtime_state(workspace, &state)?;
+    Ok(())
+}
+
 fn current_tmux_pane_info(pane_id: &PaneId) -> Option<crate::transport::PaneInfo> {
     tmux_transport_for_current_pane()
         .list_targets()

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

@@ -163,20 +163,27 @@ pub(crate) fn latest_prompt_signal(scrollback: &str) -> Option<AgentActivity> {
     }
     let mut has_idle_prompt = false;
     let mut has_live_working_indicator = false;
+    let mut has_fake_ready_structural = false;
     for line in &active_region {
         let lower = line.to_ascii_lowercase();
         if line.contains('❯') || line.contains('›') {
             has_idle_prompt = true;
         }
-        // 0.5.32 follow-up (`0532-r1-real-fail-triage.md` §6/§7):
+        // 0.5.34 (`0532-r1-real-fail-triage.md` §6/§7 + te msg_94957b9c55b0):
         // fake provider owns explicit READY/WORKING markers (fake_worker.rs:47/59).
-        // Recognize them here as STRUCTURAL bottom-region signals so restart's
-        // first-capture READY does not fall through to `recent_provider_output`
-        // false busy. Scope: literal `TEAM_AGENT_FAKE_READY`/`TEAM_AGENT_FAKE_WORKING`
-        // tokens only — do NOT infer that arbitrary "ready" prose from real
-        // providers means idle.
+        // - READY is a STRUCTURAL non-busy signal that suppresses the
+        //   `recent_provider_output` false-busy on first post-restart capture,
+        //   but must NOT resolve to Idle (unknown-never-idle discipline —
+        //   post-restart READY is the fake worker's boot heartbeat, not proof
+        //   of an idle prompt). Route it through Uncertain with a distinct
+        //   rationale so callers can trace the source.
+        // - WORKING is a structural busy signal (parity with the codex
+        //   `• Working (` composer indicator).
+        // Scope: literal `TEAM_AGENT_FAKE_*` tokens only — do NOT infer that
+        // arbitrary "ready" prose from real providers means either idle or
+        // non-busy.
         if line.contains("TEAM_AGENT_FAKE_READY") {
-            has_idle_prompt = true;
+            has_fake_ready_structural = true;
         }
         if line.contains("TEAM_AGENT_FAKE_WORKING") {
             has_live_working_indicator = true;
@@ -208,6 +215,17 @@ pub(crate) fn latest_prompt_signal(scrollback: &str) -> Option<AgentActivity> {
     if has_idle_prompt {
         return Some(idle_activity());
     }
+    // 0.5.34: fake READY is structural but not decisive. Return Uncertain
+    // so the classifier short-circuits (avoiding recent_provider_output
+    // false-busy) without asserting idle. `latest_pane_signal_is_structural`
+    // in coordinator/tick.rs treats `Some(_)` as structural.
+    if has_fake_ready_structural {
+        return Some(AgentActivity {
+            status: ActivityStatus::Uncertain,
+            confidence: 0.6,
+            rationale: "fake_ready_structural".to_string(),
+        });
+    }
     // No structural signal in the bottom region → caller (activity.rs:184)
     // gets None and treats as no-decisive-signal → Uncertain (IRON LAW).
     None

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.33",
+  "version": "0.5.35",
   "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.5.33",
-    "@team-agent/cli-darwin-x64": "0.5.33",
-    "@team-agent/cli-linux-x64": "0.5.33"
+    "@team-agent/cli-darwin-arm64": "0.5.35",
+    "@team-agent/cli-darwin-x64": "0.5.35",
+    "@team-agent/cli-linux-x64": "0.5.35"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",