@team-agent/installer 0.5.66 → 0.5.68

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

@@ -1,3 +1,24 @@
+//! ---
+//! purpose: coordinator 的共享数据面——协议常量、Pid/WorkspacePath newtype、健康与启停的穷尽状态 enum、metadata/schema/report 结构、以及跨子系统注入用的 trait 占位
+//! contract:
+//!   provides:
+//!     - name: as_str
+//!       what: 把 binary-identity relation 与 metadata mismatch reason 映射成稳定 wire 字符串
+//!     - name: as_path
+//!       what: 从 WorkspacePath newtype 取回底层路径
+//!   depends:
+//!     - crate::model::enums
+//!     - crate::model::ids
+//!     - crate::provider
+//!     - crate::message_store
+//!     - crate::event_log
+//! boundary:
+//!   - 只定义形状，不含任何判定、I/O 或事件写入
+//!   - as_str 的返回值是对外稳定契约：已发布的字符串只可新增不可改写
+//!   - ProviderRegistry / MarkerStore 只是注入点，实现体不在本模块
+//! maturity: wired
+//! ---
+//!
 //! coordinator 共享数据面:常量 / newtype / 穷尽 enum / metadata / schema health /
 //! report 结构 / abnormal-track 数据型 / WatchCursor / cross-dep 占位。
 
@@ -42,9 +63,19 @@ pub const ROTATION_MARKER: &str =
 pub struct Pid(pub u32);
 
 impl Pid {
+    /// ---
+    /// purpose: 把裸 OS pid 包成 newtype，杜绝与其他 int id 混传
+    /// params:
+    ///   pid: OS 进程号，不做存活或有效性校验
+    /// returns: 承载该 pid 的 newtype
+    /// ---
     pub fn new(pid: u32) -> Self {
         Self(pid)
     }
+    /// ---
+    /// purpose: 取回底层裸 pid，供需要 OS 接口的调用方使用
+    /// returns: 构造时传入的 pid 原值
+    /// ---
     pub fn get(self) -> u32 {
         self.0
     }
@@ -62,9 +93,19 @@ impl std::fmt::Display for Pid {
 pub struct WorkspacePath(pub PathBuf);
 
 impl WorkspacePath {
+    /// ---
+    /// purpose: 把一个路径包成 workspace newtype，作为 tick/health/start/stop 的统一 key
+    /// params:
+    ///   p: workspace 根路径。调用方负责先 resolve；本构造不做规范化也不校验存在性
+    /// returns: 承载该路径的 newtype
+    /// ---
     pub fn new(p: impl Into<PathBuf>) -> Self {
         Self(p.into())
     }
+    /// ---
+    /// purpose: 借出底层路径，供文件系统与子进程参数使用
+    /// returns: 构造时传入的路径原值的借用
+    /// ---
     pub fn as_path(&self) -> &Path {
         &self.0
     }
@@ -200,6 +241,10 @@ pub enum CoordinatorBinaryIdentityRelation {
 }
 
 impl CoordinatorBinaryIdentityRelation {
+    /// ---
+    /// purpose: 把「调用方二进制相对 daemon 二进制」的关系映射成稳定 wire 字符串
+    /// returns: 五个稳定串之一（same / caller_newer_than_daemon / daemon_newer_than_caller / same_version_path_mismatch / unknown）；这些值进事件与 status 输出，已发布的不可改写
+    /// ---
     pub fn as_str(self) -> &'static str {
         match self {
             Self::Same => "same",
@@ -225,6 +270,10 @@ pub enum CoordinatorMetadataMismatchReason {
 }
 
 impl CoordinatorMetadataMismatchReason {
+    /// ---
+    /// purpose: 把 coordinator metadata 被拒的原因映射成稳定 wire 字符串
+    /// returns: 七个稳定串之一（metadata_missing / pid_mismatch / protocol_version_mismatch / message_store_schema_version_mismatch / binary_identity_missing / binary_version_mismatch / binary_path_mismatch）；进 HealthReport 与事件，已发布的不可改写
+    /// ---
     pub fn as_str(self) -> &'static str {
         match self {
             Self::MetadataMissing => "metadata_missing",

package/crates/team-agent/src/db/message_store.rs

@@ -548,19 +548,26 @@ impl MessageStore {
 
     /// `claim_for_delivery` (`core.py:190-205`): atomic single-winner claim. Flips an
     /// eligible row (status ∈ pending/accepted/queued_until_idle/queued_until_start/
-    /// queued_stopped/queued_pane_missing) to `target_resolved`, `delivery_attempts +=
-    /// 1`. Returns `true` iff THIS update matched exactly one row.
+    /// queued_stopped/queued_pane_missing, **or** `target_resolved` with a non-null
+    /// error — the retry/error-bypass path) to `target_resolved`, clears `error`,
+    /// `delivery_attempts += 1`. Returns `true` iff THIS update matched exactly one
+    /// row. Clearing `error` is the CAS: a concurrent retry cannot also match
+    /// `error is not null`.
     pub fn claim_for_delivery(&self, message_id: &str) -> Result<bool, MessageStoreError> {
         let conn = crate::db::schema::open_db(&self.path)?;
         let rows = conn.execute(
             "update messages
              set status = 'target_resolved',
                  delivery_attempts = delivery_attempts + 1,
+                 error = null,
                  updated_at = ?2
              where message_id = ?1
-               and status in (
-                   'pending', 'accepted', 'queued_until_idle', 'queued_until_start',
-                   'queued_stopped', 'queued_pane_missing', ?3
+               and (
+                   status in (
+                       'pending', 'accepted', 'queued_until_idle', 'queued_until_start',
+                       'queued_stopped', 'queued_pane_missing', ?3
+                   )
+                   or (status = 'target_resolved' and error is not null)
                )",
             params![
                 message_id,
@@ -1138,6 +1145,33 @@ mod tests {
         assert_eq!(status_of(&read(&s), &mid), "failed");
     }
 
+    #[test]
+    fn claim_for_delivery_error_retry_is_atomic_single_winner() {
+        let s = store();
+        let mid = s
+            .create_message(Some("t"), "s", "r", "c", None, true, None)
+            .unwrap();
+        s.mark(&mid, "target_resolved", Some("probe_failed"))
+            .unwrap();
+        assert_eq!(
+            col_str(&read(&s), &mid, "error").as_deref(),
+            Some("probe_failed")
+        );
+        assert!(
+            s.claim_for_delivery(&mid).unwrap(),
+            "target_resolved+error must enter the claim gate, not a non-CAS bypass"
+        );
+        let c = read(&s);
+        assert_eq!(status_of(&c, &mid), "target_resolved");
+        assert_eq!(col_str(&c, &mid, "error"), None);
+        assert_eq!(col_i64(&c, &mid, "delivery_attempts"), 1);
+        assert!(
+            !s.claim_for_delivery(&mid).unwrap(),
+            "cleared error must lose the second claim"
+        );
+        assert_eq!(col_i64(&read(&s), &mid, "delivery_attempts"), 1);
+    }
+
     #[test]
     fn claim_for_delivery_never_claims_stored_only_presentation() {
         let s = store();

package/crates/team-agent/src/layout/worker_env.rs

@@ -72,7 +72,8 @@ const WORKER_IDENTITY_PREFIXES: &[&str] = &["CLAUDE_CODE_"];
 ///   * All POSIX-valid shell identifier keys from `parent_env` EXCEPT
 ///     those matching `STRIP_PREFIXES` / `STRIP_EXACT`.
 ///   * Overlay: `TEAM_AGENT_WORKSPACE`, `TEAM_AGENT_ID`,
-///     `TEAM_AGENT_AGENT_ID`, `TEAM_AGENT_OWNER_TEAM_ID` (when present).
+///     `TEAM_AGENT_AGENT_ID`, `TEAM_AGENT_OWNER_TEAM_ID` (when present),
+///     `TEAM_AGENT_AUTH_MODE` (when present).
 ///
 /// POSIX-validity filter: shell variable names must match
 /// `[A-Za-z_][A-Za-z0-9_]*`. Cargo's integration-test runner exports keys
@@ -83,6 +84,7 @@ pub fn worker_spawn_env<I>(
     workspace: &Path,
     agent_id: &str,
     team_id: Option<&str>,
+    auth_mode: Option<&str>,
 ) -> BTreeMap<String, String>
 where
     I: IntoIterator<Item = (String, String)>,
@@ -106,6 +108,9 @@ where
     if let Some(tid) = team_id.filter(|s| !s.is_empty()) {
         env.insert("TEAM_AGENT_OWNER_TEAM_ID".to_string(), tid.to_string());
     }
+    if let Some(auth) = auth_mode.filter(|s| !s.is_empty()) {
+        env.insert("TEAM_AGENT_AUTH_MODE".to_string(), auth.to_string());
+    }
     env
 }
 
@@ -223,6 +228,7 @@ mod tests {
             Path::new("/ws"),
             "developer",
             Some("alpha"),
+            None,
         );
         for stripped in [
             "TEAM_AGENT_LEADER_PROVIDER",
@@ -248,6 +254,7 @@ mod tests {
             Path::new("/ws"),
             "developer",
             Some("alpha"),
+            Some("subscription"),
         );
         assert_eq!(
             env.get("TEAM_AGENT_ID").map(String::as_str),
@@ -265,11 +272,21 @@ mod tests {
             env.get("TEAM_AGENT_OWNER_TEAM_ID").map(String::as_str),
             Some("alpha")
         );
+        assert_eq!(
+            env.get("TEAM_AGENT_AUTH_MODE").map(String::as_str),
+            Some("subscription")
+        );
     }
 
     #[test]
     fn worker_spawn_env_inherits_parent_env_minus_strip_list() {
-        let env = worker_spawn_env(make_parent_env(&[]), Path::new("/ws"), "developer", None);
+        let env = worker_spawn_env(
+            make_parent_env(&[]),
+            Path::new("/ws"),
+            "developer",
+            None,
+            None,
+        );
         // Inherit-then-strip: every parent key passes through EXCEPT the
         // strip list. PATH-like + provider creds + random user vars all
         // present.
@@ -292,7 +309,7 @@ mod tests {
     #[test]
     fn worker_spawn_env_drops_posix_invalid_keys() {
         let parent = make_parent_env(&[("CARGO_BIN_EXE_team-agent", "/bin/x")]);
-        let env = worker_spawn_env(parent, Path::new("/ws"), "developer", None);
+        let env = worker_spawn_env(parent, Path::new("/ws"), "developer", None, None);
         assert!(!env.contains_key("CARGO_BIN_EXE_team-agent"));
     }
 

package/crates/team-agent/src/layout/worker_window_helpers.rs

@@ -17,6 +17,8 @@ pub fn provider_window_name(provider: Provider) -> &'static str {
         Provider::Codex => "codex",
         Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini",
+        Provider::Grok => "grok",
+        Provider::CursorAgent => "agent",
         Provider::Fake => "fake",
     }
 }

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

@@ -17,6 +17,11 @@ const COMMAND_GRAMMAR_PROVIDER_COMMANDS: &[(&str, Provider)] = &[
     ("codex", Provider::Codex),
     ("copilot", Provider::Copilot),
     ("gemini", Provider::GeminiCli),
+    ("grok", Provider::Grok),
+    // NOTE: Cursor `agent` binary is NOT added here — command-text attribution
+    // is a substring contains() match in table order; `"agent"` would also
+    // match the framework's own `team-agent` binary and mis-attribute leader
+    // panes. CursorAgent panes need env/argv-based attribution (TODO 0.5.67).
     ("fake", Provider::Fake),
 ];
 
@@ -91,11 +96,37 @@ fn provider_from_pid_env(pid: u32) -> Option<Provider> {
 
 fn provider_from_command_text(text: &str) -> Option<Provider> {
     let lower = text.to_ascii_lowercase();
+    if cursor_agent_command_text(&lower) {
+        return Some(Provider::CursorAgent);
+    }
     COMMAND_GRAMMAR_PROVIDER_COMMANDS
         .iter()
         .find_map(|(needle, provider)| lower.contains(needle).then_some(*provider))
 }
 
+/// Cursor 二进制名为 `agent`，不能做 substring contains（会误伤 `team-agent`）。
+/// 认精确 token `cursor-agent` / `…/agent`，且必须带 `--sandbox` 或 `--trust`。
+fn cursor_agent_command_text(lower: &str) -> bool {
+    let tokens: Vec<&str> = lower.split_whitespace().collect();
+    if tokens.iter().any(|tok| {
+        *tok == "team-agent"
+            || tok.ends_with("/team-agent")
+            || tok.ends_with("\\team-agent")
+    }) {
+        return false;
+    }
+    let is_cursor_bin = tokens.iter().any(|tok| {
+        *tok == "cursor-agent"
+            || *tok == "agent"
+            || tok.ends_with("/cursor-agent")
+            || tok.ends_with("/agent")
+            || tok.ends_with("\\cursor-agent")
+            || tok.ends_with("\\agent")
+    });
+    let has_cursor_flag = tokens.iter().any(|tok| *tok == "--sandbox" || *tok == "--trust");
+    is_cursor_bin && has_cursor_flag
+}
+
 fn provider_from_env_text(text: &str) -> Option<Provider> {
     text.split(|ch: char| ch == '\0' || ch.is_ascii_whitespace())
         .find_map(|part| part.strip_prefix("TEAM_AGENT_LEADER_PROVIDER="))
@@ -180,6 +211,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn cursor_agent_basename_with_trust_is_attributed() {
+        assert_eq!(
+            attribute_command_provider("cursor-agent --trust --sandbox disabled --workspace /ws"),
+            Some(Provider::CursorAgent)
+        );
+        assert_eq!(
+            attribute_command_provider("agent --trust --sandbox disabled --workspace /ws"),
+            Some(Provider::CursorAgent)
+        );
+    }
+
+    #[test]
+    fn team_agent_binary_is_not_cursor() {
+        assert_ne!(
+            attribute_command_provider("team-agent --trust claude"),
+            Some(Provider::CursorAgent)
+        );
+        assert_eq!(attribute_command_provider("team-agent status"), None);
+        assert_eq!(attribute_command_provider("agent"), None);
+    }
+
     #[test]
     fn pane_env_provider_wins_over_command() {
         let mut pane = pane("codex", None);

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

@@ -243,6 +243,9 @@ pub fn register_binding_from_state_best_effort(
     );
     let event_log = crate::event_log::EventLog::new(workspace);
     let write_result = write_entry_best_effort(&entry);
+    if write_result.is_some() {
+        let _ = mark_displaced_same_pane_entries_unbound(&entry);
+    }
     let status = if let Some(path) = &write_result {
         let _ = event_log.write(
             EVENT_REGISTERED,
@@ -275,6 +278,68 @@ pub fn register_binding_from_state_best_effort(
     })
 }
 
+/// Stored registry status after another workspace claimed the same pane.
+pub const REGISTRY_STATUS_UNBOUND: &str = "unbound";
+
+/// When workspace B claims a pane, every other attached registry row that
+/// still names that pane is no longer deliverable. Mark those rows unbound.
+/// Does not change pane-side authorization storage.
+pub fn mark_displaced_same_pane_entries_unbound(winner: &LeaderRegistryEntry) -> Vec<PathBuf> {
+    let Some(winner_pane) = winner
+        .channel
+        .get("pane_id")
+        .and_then(Value::as_str)
+        .filter(|pane| !pane.is_empty())
+    else {
+        return Vec::new();
+    };
+    let winner_socket = winner
+        .channel
+        .get("tmux_socket")
+        .and_then(Value::as_str)
+        .filter(|socket| !socket.is_empty());
+    let mut displaced = Vec::new();
+    for (path, mut entry) in read_all_entries() {
+        if entry.workspace_hash == winner.workspace_hash && entry.team_key == winner.team_key {
+            continue;
+        }
+        if entry.status != "attached" {
+            continue;
+        }
+        let Some(pane) = entry
+            .channel
+            .get("pane_id")
+            .and_then(Value::as_str)
+            .filter(|pane| !pane.is_empty())
+        else {
+            continue;
+        };
+        if pane != winner_pane {
+            continue;
+        }
+        let Some(socket) = entry
+            .channel
+            .get("tmux_socket")
+            .and_then(Value::as_str)
+            .filter(|socket| !socket.is_empty())
+        else {
+            continue;
+        };
+        let Some(winner_socket) = winner_socket else {
+            continue;
+        };
+        if socket != winner_socket {
+            continue;
+        }
+        entry.status = REGISTRY_STATUS_UNBOUND.to_string();
+        entry.updated_at = chrono::Utc::now().to_rfc3339();
+        if write_entry_best_effort(&entry).is_some() {
+            displaced.push(path);
+        }
+    }
+    displaced
+}
+
 fn entry_filename(entry: &LeaderRegistryEntry) -> String {
     format!("{}__{}.json", entry.workspace_hash, entry.team_key)
 }