@team-agent/installer 0.3.11 → 0.3.13

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

@@ -264,55 +264,6 @@ impl Coordinator {
                     BTreeMap::new()
                 }
             };
-        // C-3-4 cr verdict — copilot 一期 classify→None(Unknown);为防 silent,
-        // tick 每次发现 copilot agent(从 state.agents 直接扫,不依赖 captures —
-        // 离线/未起 tmux 场景仍能写)就发 `provider.classify.unsupported` 事件
-        // (字面 reason=`phase1_unknown_pending_sample`,含 provider="copilot" + "classify"
-        // 串)。二期接 sqlite turns 表后这条删/降级,届时改 reason 区分。
-        //
-        // B-4 P4 / 036b 防 dedup-flood:同 (provider, agent_id, reason) 状态跨 tick
-        // 只发一次(check_key 范式,同 abnormal_check_key tick.rs:603 同精神);状态
-        // 变了才再发。check_key 落 state.agents.<id>.classify_unsupported.last_key,
-        // tick-only metadata,不进 #235 owner / receiver 等持久态。
-        let agents_snapshot: Vec<(String, Option<String>)> =
-            if let Some(agents) = state.get("agents").and_then(Value::as_object) {
-                agents
-                    .iter()
-                    .filter_map(|(agent_id, agent)| {
-                        let is_copilot = agent
-                            .get("provider")
-                            .and_then(Value::as_str)
-                            .and_then(parse_provider)
-                            .is_some_and(|p| matches!(p, crate::model::enums::Provider::Copilot));
-                        if !is_copilot {
-                            return None;
-                        }
-                        let last_key = agent
-                            .get("classify_unsupported")
-                            .and_then(|v| v.get("last_key"))
-                            .and_then(Value::as_str)
-                            .map(str::to_string);
-                        Some((agent_id.clone(), last_key))
-                    })
-                    .collect()
-            } else {
-                Vec::new()
-            };
-        for (agent_id, last_key) in agents_snapshot {
-            let check_key = format!("copilot|{agent_id}|phase1_unknown_pending_sample");
-            if last_key.as_deref() == Some(check_key.as_str()) {
-                continue;
-            }
-            let _ = event_log.write(
-                "provider.classify.unsupported",
-                serde_json::json!({
-                    "provider": "copilot",
-                    "agent_id": agent_id,
-                    "reason": "phase1_unknown_pending_sample",
-                }),
-            );
-            mark_classify_unsupported(&mut state, &agent_id, &check_key);
-        }
         if let Err(error) = self.detect_abnormal_exits(&mut state, &event_log, &pane_snapshot) {
             let _ = event_log.write(
                 "coordinator.tick.detect_abnormal_failed",
@@ -1644,7 +1595,7 @@ fn agent_process_liveness(
     }
     if let Some(target) = matching_agent_target(agent, session_name, targets) {
         if let Some(command) = target.current_command.as_deref() {
-            return command_process_check(agent.provider, command);
+            return pane_command_process_check(agent.provider, target, command);
         }
         if let Some(pid) = target.pane_pid.map(Pid::new) {
             return pid_process_check("pane_pid", pid);
@@ -1731,7 +1682,7 @@ fn pid_process_check(label: &str, pid: Pid) -> ProcessCheck {
 }
 
 fn command_process_check(provider: crate::model::enums::Provider, command: &str) -> ProcessCheck {
-    if provider_command_matches(provider, command) {
+    if crate::leader::command_matches_provider(provider, command) {
         process_check(ProcessLiveness::Alive, format!("current_command:{command}"))
     } else {
         process_check(
@@ -1741,16 +1692,20 @@ fn command_process_check(provider: crate::model::enums::Provider, command: &str)
     }
 }
 
-fn provider_command_matches(provider: crate::model::enums::Provider, command: &str) -> bool {
-    let lower = command.to_ascii_lowercase();
-    match provider {
-        crate::model::enums::Provider::Claude | crate::model::enums::Provider::ClaudeCode => {
-            lower.contains("claude")
-        }
-        crate::model::enums::Provider::Codex => lower.contains("codex"),
-        crate::model::enums::Provider::Copilot => lower.contains("copilot"),
-        crate::model::enums::Provider::GeminiCli => lower.contains("gemini"),
-        crate::model::enums::Provider::Fake => lower.contains("fake"),
+fn pane_command_process_check(
+    provider: crate::model::enums::Provider,
+    pane: &crate::transport::PaneInfo,
+    command: &str,
+) -> ProcessCheck {
+    if crate::leader::attribute_pane_provider(pane)
+        .is_some_and(|candidate| crate::leader::provider_matches(candidate, provider))
+    {
+        process_check(ProcessLiveness::Alive, format!("current_command:{command}"))
+    } else {
+        process_check(
+            ProcessLiveness::Dead,
+            format!("provider_not_foreground:{command}"),
+        )
     }
 }
 
@@ -1962,28 +1917,6 @@ fn mark_abnormal_suppressed(state: &mut Value, agent_id: &str, key: &str) {
     }
 }
 
-/// B-4 P4 dedup marker — 把 classify.unsupported check_key 写到
-/// state.agents.<id>.classify_unsupported.last_key,只在状态变了才再发事件。
-/// 同 abnormal_check_key (line 603) 同精神,但落 agents 子 obj(per-agent locality,
-/// 不污染 abnormal_exit_watch 命名空间)。
-fn mark_classify_unsupported(state: &mut Value, agent_id: &str, key: &str) {
-    let Some(agents) = state.get_mut("agents").and_then(Value::as_object_mut) else {
-        return;
-    };
-    let Some(agent) = agents.get_mut(agent_id).and_then(Value::as_object_mut) else {
-        return;
-    };
-    let entry = agent
-        .entry("classify_unsupported".to_string())
-        .or_insert_with(|| serde_json::json!({}));
-    if !entry.is_object() {
-        *entry = serde_json::json!({});
-    }
-    if let Some(obj) = entry.as_object_mut() {
-        obj.insert("last_key".to_string(), serde_json::json!(key));
-    }
-}
-
 fn mark_abnormal_checked(state: &mut Value, agent_id: &str, key: &str) {
     if let Some(watch) = coordinator_child_object(state, "abnormal_exit_watch") {
         let entry = watch

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

@@ -634,8 +634,7 @@ fn claim_target_from_pane_info(workspace: &Path, target: &PaneInfo) -> Option<Le
     if !target.active {
         return None;
     }
-    let command = target.current_command.as_deref().unwrap_or_default();
-    let provider = leader_command_provider(command)?;
+    let provider = super::attribute_pane_provider(target)?;
     let current_path = target.current_path.as_deref()?;
     if !crate::state::owner_gate::workspace_paths_match(current_path, workspace) {
         return None;
@@ -648,21 +647,6 @@ fn claim_target_from_pane_info(workspace: &Path, target: &PaneInfo) -> Option<Le
     })
 }
 
-fn leader_command_provider(command: &str) -> Option<Provider> {
-    let lower = command.to_ascii_lowercase();
-    if lower.contains("claude") {
-        Some(Provider::ClaudeCode)
-    } else if lower.contains("codex") {
-        Some(Provider::Codex)
-    } else if lower.contains("copilot") {
-        Some(Provider::Copilot)
-    } else if lower.contains("fake") {
-        Some(Provider::Fake)
-    } else {
-        None
-    }
-}
-
 fn target_leader_session_uuid(target: &PaneInfo) -> Option<crate::model::ids::LeaderSessionUuid> {
     target
         .leader_env
@@ -1090,13 +1074,13 @@ mod tests {
     use super::*;
 
     #[test]
-    fn leader_command_provider_recognizes_copilot() {
+    fn attribute_command_provider_recognizes_copilot() {
         assert_eq!(
-            leader_command_provider("copilot --allow-all-tools"),
+            super::super::attribute_command_provider("copilot --allow-all-tools"),
             Some(Provider::Copilot)
         );
         assert_eq!(
-            leader_command_provider("/usr/local/bin/copilot"),
+            super::super::attribute_command_provider("/usr/local/bin/copilot"),
             Some(Provider::Copilot)
         );
     }

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

@@ -13,7 +13,7 @@
 //!     (`build_idle_nodes` / `push_idle_reminder`) / `wake.py`
 //!     (`should_reread` / `on_file_changed` / `take_pending`).
 //!   - `messaging/leader_panes.py` (`_leader_command_looks_usable` /
-//!     `_leader_command_provider` / `_target_leader_session_uuid`).
+//!     provider attribution / `_target_leader_session_uuid`).
 //!
 //! 职责(card §职责):拥有「谁是 leader、消息投到哪个 pane」这一身份事实,当成租约(lease)
 //! 管理。pane id 即权威路由/授权身份,`owner_epoch` 做 CAS/去重,确定派生的
@@ -79,6 +79,7 @@ mod helpers;
 pub mod inject;
 pub mod lease;
 pub mod owner_bind;
+pub mod provider_attribution;
 pub mod rediscover;
 pub mod start;
 pub mod takeover;
@@ -88,6 +89,7 @@ pub mod types;
 pub use inject::*;
 pub use lease::*;
 pub use owner_bind::*;
+pub(crate) use provider_attribution::*;
 pub use rediscover::*;
 pub use start::*;
 pub use takeover::*;

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

@@ -8,7 +8,7 @@ use serde_json::{json, Value};
 use crate::model::ids::{LeaderSessionUuid, OwnerEpoch, TeamKey};
 use crate::provider::Provider;
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{PaneField, PaneId, Target, Transport};
+use crate::transport::{PaneField, PaneId, PaneInfo, SessionName, Target, Transport};
 
 use super::helpers::{get_path_str, now_ts, prefix, resolve_workspace_for_hash};
 use super::{
@@ -134,8 +134,12 @@ pub fn bind_owner_from_caller_pane(
             hint: Some(hint.to_string()),
         });
     };
-    let caller_current_command = tmux_pane_current_command(workspace, &pane).unwrap_or_default();
-    let provider = bind_provider_from_env_or_command(&caller_current_command);
+    let caller_info = tmux_pane_info(workspace, &pane);
+    let caller_current_command = caller_info
+        .as_ref()
+        .and_then(|info| info.current_command.clone())
+        .unwrap_or_else(|| tmux_pane_current_command(workspace, &pane).unwrap_or_default());
+    let provider = bind_provider_from_env_or_pane(&caller_current_command, caller_info);
     let machine_fingerprint = std::env::var("TEAM_AGENT_MACHINE_FINGERPRINT").unwrap_or_default();
     let os_user = std::env::var("USER")
         .or_else(|_| std::env::var("USERNAME"))
@@ -185,47 +189,19 @@ pub fn emit_owner_bound_event(
     Ok(())
 }
 
-fn bind_provider_from_env_or_command(command: &str) -> Provider {
-    std::env::var("TEAM_AGENT_LEADER_PROVIDER")
+fn bind_provider_from_env_or_pane(command: &str, pane: Option<PaneInfo>) -> Provider {
+    let env_provider = std::env::var("TEAM_AGENT_LEADER_PROVIDER")
         .ok()
-        .and_then(|raw| super::helpers::parse_provider(&raw))
-        .or_else(|| provider_from_command(command))
+        .and_then(|raw| super::helpers::parse_provider(&raw));
+    env_provider
+        .or_else(|| pane.as_ref().and_then(super::attribute_pane_provider))
+        .or_else(|| super::attribute_command_provider(command))
         // E11 层2:未知命令不再静默默认 codex(会误绑任意 provider + 喂错分类器)。
-        // 无法识别时回落 Codex 仅作最末兜底,且该路径已被 provider_from_command 的显式 None 收窄
+        // 无法识别时回落 Codex 仅作最末兜底,且该路径已被统一归因入口的显式 None 收窄
         // (调用方理应只在已知 leader 命令上 bind);保留以不改 fn 签名/上游 panic 面。
         .unwrap_or(Provider::Codex)
 }
 
-/// E11 层2 + N39:command 名 → wire 串 → `parse_provider`(**单一映射源**,与
-/// `owner_bind_provider_wire` 共用 [`command_provider_wire`])。未知命令 → `None`
-/// (危险的 `_ => Codex` 默认已删:不静默把任意 provider 误绑成 codex)。
-fn provider_from_command(command: &str) -> Option<Provider> {
-    command_provider_wire(command).and_then(super::helpers::parse_provider)
-}
-
-/// command 名 → provider wire 串(单一真相;copilot/claude/codex/fake)。未知 → `None`。
-/// `claude.exe` 归一为 `claude`。
-fn command_provider_wire(command: &str) -> Option<&'static str> {
-    match exact_command_name(command).as_deref() {
-        Some("claude") | Some("claude.exe") => Some("claude"),
-        Some("codex") => Some("codex"),
-        Some("copilot") => Some("copilot"),
-        Some("fake") => Some("fake"),
-        _ => None,
-    }
-}
-
-fn exact_command_name(command: &str) -> Option<String> {
-    let last = command
-        .split_whitespace()
-        .next()
-        .unwrap_or(command)
-        .rsplit(['/', '\\'])
-        .next()?;
-    let lower = last.to_ascii_lowercase();
-    if lower.is_empty() { None } else { Some(lower) }
-}
-
 pub fn owner_bind_provider_wire(command: &str) -> &'static str {
     if let Ok(raw) = std::env::var("TEAM_AGENT_LEADER_PROVIDER") {
         // env 显式 provider:经 parse_provider(单一表,知 copilot)校验后透传其 wire 串;
@@ -234,9 +210,9 @@ pub fn owner_bind_provider_wire(command: &str) -> &'static str {
             .map(super::helpers::provider_wire)
             .unwrap_or("");
     }
-    // E11 层2 + N39:与 provider_from_command 共用 command_provider_wire 单一映射(含 copilot);
+    // E11 层2 + N39:与统一 provider attribution 共用单一映射(含 copilot);
     // 未知命令 → ""(不绑),不再静默当 codex。
-    command_provider_wire(command).unwrap_or("")
+    super::provider_wire_from_command(command).unwrap_or("")
 }
 
 fn family_a_identity(
@@ -295,6 +271,28 @@ fn tmux_pane_current_command(workspace: &Path, pane: &str) -> Result<String, Lea
         .map_err(|e| LeaderError::Tmux(e.to_string()))
 }
 
+fn tmux_pane_info(workspace: &Path, pane: &str) -> Option<PaneInfo> {
+    let target = PaneId::new(pane);
+    TmuxBackend::for_workspace(workspace)
+        .list_targets()
+        .ok()?
+        .into_iter()
+        .find(|info| info.pane_id == target)
+        .or_else(|| tmux_pane_current_command(workspace, pane).ok().map(|command| PaneInfo {
+            pane_id: target,
+            session: SessionName::new(""),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: (!command.is_empty()).then_some(command),
+            current_path: None,
+            active: true,
+            pane_pid: None,
+            leader_env: Default::default(),
+        }))
+}
+
 // NOTE: `derive_leader_session_uuid`(`leader_binding.py:146`)已由
 // `model::ids::LeaderSessionUuid::derive` 字节对齐实现(含 NUL 拒绝 + golden 测试)——
 // 此 lane REUSE 之,不重声明。
@@ -307,25 +305,25 @@ mod e11_provider_bind_tests {
     // E11 层2:copilot leader 命令必须绑成 Provider::Copilot(此前缺臂 → _ => Codex 误绑)。
     #[test]
     fn copilot_command_binds_copilot_not_codex() {
-        assert_eq!(provider_from_command("copilot --banner -C /ws"), Some(Provider::Copilot));
-        assert_eq!(provider_from_command("/opt/homebrew/bin/copilot"), Some(Provider::Copilot));
+        assert_eq!(super::super::attribute_command_provider("copilot --banner -C /ws"), Some(Provider::Copilot));
+        assert_eq!(super::super::attribute_command_provider("/opt/homebrew/bin/copilot"), Some(Provider::Copilot));
         assert_eq!(owner_bind_provider_wire("copilot --banner"), "copilot");
     }
 
     #[test]
     fn known_commands_map_via_single_source() {
-        assert_eq!(provider_from_command("claude"), Some(Provider::Claude));
-        assert_eq!(provider_from_command("codex"), Some(Provider::Codex));
-        assert_eq!(provider_from_command("fake"), Some(Provider::Fake));
+        assert_eq!(super::super::attribute_command_provider("claude"), Some(Provider::ClaudeCode));
+        assert_eq!(super::super::attribute_command_provider("codex"), Some(Provider::Codex));
+        assert_eq!(super::super::attribute_command_provider("fake"), Some(Provider::Fake));
         assert_eq!(owner_bind_provider_wire("claude"), "claude");
         assert_eq!(owner_bind_provider_wire("codex"), "codex");
     }
 
-    // E11 层2:未知命令不再静默默认 codex —— provider_from_command → None,wire → ""。
+    // E11 层2:未知命令不再静默默认 codex —— attribution → None,wire → ""。
     #[test]
     fn unknown_command_is_none_not_silent_codex() {
-        assert_eq!(provider_from_command("node /some/thing.js"), None);
-        assert_eq!(provider_from_command("totally-unknown"), None);
+        assert_eq!(super::super::attribute_command_provider("node /some/thing.js"), None);
+        assert_eq!(super::super::attribute_command_provider("totally-unknown"), None);
         assert_eq!(owner_bind_provider_wire("totally-unknown"), "");
     }
 }

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

@@ -0,0 +1,214 @@
+//! Positive provider attribution for leader panes.
+
+use std::collections::BTreeMap;
+use std::process::Command;
+
+use crate::provider::Provider;
+use crate::transport::PaneInfo;
+
+use super::helpers::{parse_provider, provider_wire};
+
+const PROVIDER_COMMANDS: &[(&str, Provider)] = &[
+    ("claude", Provider::ClaudeCode),
+    ("claude.exe", Provider::ClaudeCode),
+    ("codex", Provider::Codex),
+    ("copilot", Provider::Copilot),
+    ("gemini", Provider::GeminiCli),
+    ("fake", Provider::Fake),
+];
+
+pub(crate) fn attribute_pane_provider(pane: &PaneInfo) -> Option<Provider> {
+    attribute_pane_provider_with_process(pane, provider_from_pid_env, provider_from_pid_argv)
+}
+
+fn attribute_pane_provider_with_process(
+    pane: &PaneInfo,
+    provider_from_env_pid: impl Fn(u32) -> Option<Provider>,
+    provider_from_argv_pid: impl Fn(u32) -> Option<Provider>,
+) -> Option<Provider> {
+    provider_from_env(&pane.leader_env)
+        .or_else(|| pane.pane_pid.and_then(provider_from_env_pid))
+        .or_else(|| {
+            pane.current_command
+                .as_deref()
+                .and_then(attribute_command_provider)
+        })
+        .or_else(|| pane.pane_pid.and_then(provider_from_argv_pid))
+}
+
+pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
+    provider_from_text(command)
+}
+
+pub(crate) fn command_matches_provider(provider: Provider, command: &str) -> bool {
+    attribute_command_provider(command)
+        .is_some_and(|candidate| provider_matches(candidate, provider))
+}
+
+pub(crate) fn provider_wire_from_command(command: &str) -> Option<&'static str> {
+    attribute_command_provider(command).map(provider_wire_for_command_attribution)
+}
+
+fn provider_from_env(env: &BTreeMap<String, String>) -> Option<Provider> {
+    env.get("TEAM_AGENT_LEADER_PROVIDER")
+        .filter(|raw| !raw.is_empty())
+        .and_then(|raw| parse_provider(raw))
+}
+
+fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
+    process_command_line(pid)
+        .as_deref()
+        .and_then(provider_from_text)
+}
+
+fn provider_from_pid_env(pid: u32) -> Option<Provider> {
+    process_environment(pid)
+        .as_deref()
+        .and_then(provider_from_env_text)
+}
+
+fn provider_from_text(text: &str) -> Option<Provider> {
+    let lower = text.to_ascii_lowercase();
+    PROVIDER_COMMANDS
+        .iter()
+        .find_map(|(needle, provider)| lower.contains(needle).then_some(*provider))
+}
+
+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="))
+        .filter(|raw| !raw.is_empty())
+        .and_then(parse_provider)
+}
+
+pub(crate) fn provider_matches(candidate: Provider, expected: Provider) -> bool {
+    candidate == expected
+        || matches!(
+            (candidate, expected),
+            (Provider::Claude, Provider::ClaudeCode) | (Provider::ClaudeCode, Provider::Claude)
+        )
+}
+
+fn provider_wire_for_command_attribution(provider: Provider) -> &'static str {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => "claude",
+        other => provider_wire(other),
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn process_command_line(pid: u32) -> Option<String> {
+    let bytes = std::fs::read(format!("/proc/{pid}/cmdline")).ok()?;
+    let parts = bytes
+        .split(|byte| *byte == 0)
+        .filter(|part| !part.is_empty())
+        .map(|part| String::from_utf8_lossy(part).to_string())
+        .collect::<Vec<_>>();
+    (!parts.is_empty()).then(|| parts.join(" "))
+}
+
+#[cfg(target_os = "linux")]
+fn process_environment(pid: u32) -> Option<String> {
+    String::from_utf8(std::fs::read(format!("/proc/{pid}/environ")).ok()?).ok()
+}
+
+#[cfg(not(target_os = "linux"))]
+fn process_command_line(pid: u32) -> Option<String> {
+    let output = crate::os_probe::bounded_command_output_with_probe(
+        Command::new("ps")
+            .arg("-p")
+            .arg(pid.to_string())
+            .args(["-o", "command="]),
+        "provider_argv",
+        Some(pid),
+    )
+    .ok()?;
+    output
+        .status
+        .success()
+        .then(|| String::from_utf8_lossy(&output.stdout).trim().to_string())
+        .filter(|text| !text.is_empty())
+}
+
+#[cfg(not(target_os = "linux"))]
+fn process_environment(pid: u32) -> Option<String> {
+    let _ = pid;
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::transport::{PaneId, SessionName};
+    fn pane(command: &str, pid: Option<u32>) -> PaneInfo {
+        PaneInfo {
+            pane_id: PaneId::new("%1"),
+            session: SessionName::new("team-test"),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: Some(command.to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: pid,
+            leader_env: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn direct_command_form_recognizes_copilot() {
+        assert_eq!(
+            attribute_pane_provider(&pane("copilot --allow-all-tools", None)),
+            Some(Provider::Copilot)
+        );
+    }
+
+    #[test]
+    fn node_running_non_provider_stays_none() {
+        assert_eq!(attribute_pane_provider(&pane("node", None)), None);
+        assert_eq!(
+            attribute_command_provider("node /tmp/not-a-provider.js"),
+            None
+        );
+    }
+
+    #[test]
+    fn pane_env_provider_wins_over_command() {
+        let mut pane = pane("codex", None);
+        pane.leader_env.insert(
+            "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+            "copilot".to_string(),
+        );
+
+        assert_eq!(attribute_pane_provider(&pane), Some(Provider::Copilot));
+    }
+
+    #[test]
+    fn node_form_copilot_is_attributed_from_process_argv() {
+        let pane = pane("node", Some(4242));
+
+        assert_eq!(
+            attribute_pane_provider_with_process(
+                &pane,
+                |_| None,
+                |pid| (pid == 4242).then_some(Provider::Copilot),
+            ),
+            Some(Provider::Copilot)
+        );
+    }
+
+    #[test]
+    fn process_env_provider_wins_for_node_form() {
+        let pane = pane("node /opt/homebrew/bin/copilot", Some(4242));
+
+        assert_eq!(
+            attribute_pane_provider_with_process(
+                &pane,
+                |pid| (pid == 4242).then_some(Provider::Copilot),
+                |_| Some(Provider::Codex),
+            ),
+            Some(Provider::Copilot)
+        );
+    }
+}

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

@@ -81,13 +81,13 @@ fn event_named(events: &[Value], name: &str) -> Value {
 }
 
 #[test]
-fn leader_command_provider_recognizes_copilot() {
+fn attribute_command_provider_recognizes_copilot() {
     assert_eq!(
-        leader_command_provider("copilot --allow-all-tools"),
+        super::super::attribute_command_provider("copilot --allow-all-tools"),
         Some(Provider::Copilot)
     );
     assert_eq!(
-        leader_command_provider("/usr/local/bin/copilot"),
+        super::super::attribute_command_provider("/usr/local/bin/copilot"),
         Some(Provider::Copilot)
     );
 }