@team-agent/installer 0.3.12 → 0.3.14

package/crates/team-agent/src/cli/tests/main_preserved.rs

@@ -472,6 +472,74 @@ fn seed_team_spec(ws: &std::path::Path) {
             other => panic!("expected JSON output, got {other:?}"),
         }
     }
+    fn seed_remove_agent_workspace(ws: &std::path::Path, status: &str) {
+        seed_team_spec(ws);
+        crate::state::persist::save_runtime_state(
+            ws,
+            &json!({
+                "session_name": "team-agent-fake-e2e",
+                "agents": {
+                    "fake_impl": {
+                        "status": status,
+                        "provider": "fake",
+                        "window": "fake_impl"
+                    }
+                },
+                "spec_path": ws.join("team.spec.yaml").to_string_lossy()
+            }),
+        )
+        .unwrap();
+    }
+    #[test]
+    fn remove_agent_running_refusal_is_not_success_envelope() {
+        let ws = tmp_workspace();
+        seed_remove_agent_workspace(&ws, "running");
+        let out = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: true,
+                confirm: true,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(out["ok"], json!(false));
+        assert_eq!(out["status"], json!("refused"));
+        assert_eq!(out["reason"], json!("force_required"));
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(
+            state["agents"].get("fake_impl").is_some(),
+            "refused remove-agent must not delete the running agent"
+        );
+    }
+    #[test]
+    fn remove_agent_from_spec_refusal_is_not_success_envelope() {
+        let ws = tmp_workspace();
+        seed_remove_agent_workspace(&ws, "stopped");
+        let out = json_output(
+            cmd_remove_agent(&RemoveAgentArgs {
+                agent: "fake_impl".to_string(),
+                workspace: ws.clone(),
+                team: None,
+                from_spec: false,
+                confirm: true,
+                force: false,
+                json: true,
+            })
+            .unwrap(),
+        );
+        assert_eq!(out["ok"], json!(false));
+        assert_eq!(out["status"], json!("refused"));
+        assert_eq!(out["reason"], json!("from_spec_confirm_required"));
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert!(
+            state["agents"].get("fake_impl").is_some(),
+            "refused remove-agent must not delete the spec-defined agent"
+        );
+    }
     #[test]
     fn validate_result_file_good_and_inline_garbage_are_distinct() {
         let ws = tmp_workspace();

package/crates/team-agent/src/cli/tests/shutdown_kill_plan.rs

@@ -5,8 +5,15 @@
 //! 集成面由 tests/b5_leader_terminal_kill_red.rs 的真 tmux 契约覆盖,此处锁纯决策 + 4 反向 case。
 
 use crate::cli::lifecycle_port::{sessions_to_kill, KillDecision};
-use crate::transport::SessionName;
-use std::collections::BTreeSet;
+use crate::transport::{
+    AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
+    Key, PaneField, PaneId, PaneInfo, SessionName, SetEnvOutcome, SpawnResult, Target, Transport,
+    TransportError, WindowName,
+};
+use serde_json::json;
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
 
 fn names(raw: &[&str]) -> Vec<SessionName> {
     raw.iter().map(|name| SessionName::new(*name)).collect()
@@ -102,3 +109,154 @@ fn union_prefix_and_anchor_no_double_count() {
         KillDecision::KillIndividually { to_kill: vec![], spared: names(&["team-agent-leader-claude-ws-beef"]) }
     );
 }
+
+#[test]
+fn missing_coordinator_is_ok_when_shutdown_cleaned_session() {
+    let ws = tmp_shutdown_workspace("missing-coordinator-clean");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-lane-l1-clean-shutdown",
+            "agents": {
+                "fake_impl": {
+                    "status": "running",
+                    "provider": "fake",
+                    "window": "fake_impl"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let out = crate::cli::lifecycle_port::shutdown_with_transport(
+        &ws,
+        true,
+        None,
+        &CleanShutdownTransport::new(),
+    )
+    .expect("shutdown should complete");
+    assert_eq!(out["coordinator"]["status"], json!("missing"));
+    assert_eq!(
+        out["ok"], json!(true),
+        "coordinator.status=missing alone must not make a fully cleaned shutdown partial: {out}"
+    );
+    assert_eq!(out["status"], json!("ok"));
+    assert_eq!(out["residuals"]["sessions"], json!([]));
+    assert_eq!(out["residuals"]["processes"], json!([]));
+}
+
+fn tmp_shutdown_workspace(tag: &str) -> PathBuf {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static N: AtomicU64 = AtomicU64::new(0);
+    let dir = std::env::temp_dir().join(format!(
+        "ta-shutdown-{tag}-{}-{}",
+        std::process::id(),
+        N.fetch_add(1, Ordering::Relaxed)
+    ));
+    std::fs::create_dir_all(dir.join(".team").join("runtime")).unwrap();
+    dir
+}
+
+struct CleanShutdownTransport {
+    session_present: Mutex<bool>,
+}
+
+impl CleanShutdownTransport {
+    fn new() -> Self {
+        Self { session_present: Mutex::new(true) }
+    }
+}
+
+impl Transport for CleanShutdownTransport {
+    fn kind(&self) -> BackendKind {
+        BackendKind::Tmux
+    }
+
+    fn spawn_first(
+        &self,
+        _session: &SessionName,
+        _window: &WindowName,
+        _argv: &[String],
+        _cwd: &Path,
+        _env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        unimplemented!("shutdown test does not spawn")
+    }
+
+    fn spawn_into(
+        &self,
+        _session: &SessionName,
+        _window: &WindowName,
+        _argv: &[String],
+        _cwd: &Path,
+        _env: &BTreeMap<String, String>,
+    ) -> Result<SpawnResult, TransportError> {
+        unimplemented!("shutdown test does not spawn")
+    }
+
+    fn inject(
+        &self,
+        _target: &Target,
+        _payload: &InjectPayload,
+        _submit: Key,
+        _bracketed: bool,
+    ) -> Result<InjectReport, TransportError> {
+        unimplemented!("shutdown test does not inject")
+    }
+
+    fn send_keys(&self, _target: &Target, _keys: &[Key]) -> Result<(), TransportError> {
+        Ok(())
+    }
+
+    fn capture(
+        &self,
+        _target: &Target,
+        range: CaptureRange,
+    ) -> Result<CapturedText, TransportError> {
+        Ok(CapturedText { text: String::new(), range })
+    }
+
+    fn query(&self, _target: &Target, _field: PaneField) -> Result<Option<String>, TransportError> {
+        Ok(None)
+    }
+
+    fn liveness(
+        &self,
+        _pane: &PaneId,
+    ) -> Result<crate::model::enums::PaneLiveness, TransportError> {
+        Ok(crate::model::enums::PaneLiveness::Live)
+    }
+
+    fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+        Ok(Vec::new())
+    }
+
+    fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
+        Ok(*self.session_present.lock().unwrap())
+    }
+
+    fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
+        Ok(Vec::new())
+    }
+
+    fn set_session_env(
+        &self,
+        _session: &SessionName,
+        _key: &str,
+        _value: &str,
+    ) -> Result<SetEnvOutcome, TransportError> {
+        Ok(SetEnvOutcome::Applied)
+    }
+
+    fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+        *self.session_present.lock().unwrap() = false;
+        Ok(())
+    }
+
+    fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+        Ok(())
+    }
+
+    fn attach_session(&self, _session: &SessionName) -> Result<AttachOutcome, TransportError> {
+        Ok(AttachOutcome::Attached)
+    }
+}

package/crates/team-agent/src/compiler.rs

@@ -29,6 +29,14 @@ use std::path::Path;
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
 
+pub const IGNORED_OWNER_TEAM_ID_FIELD: &str = "owner_team_id";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IgnoredTeamField {
+    pub field: &'static str,
+    pub value: String,
+}
+
 /// `compiler._read_front_matter` (compiler.py:173-185).
 ///
 /// Reads `path` (UTF-8). If the text does not start with `"---\n"`, returns
@@ -76,6 +84,21 @@ pub fn read_front_matter(path: &Path) -> Result<(Value, String), ModelError> {
     Ok((meta, after_marker.trim_start_matches('\n').to_string()))
 }
 
+pub fn ignored_owner_team_id_from_team_md(team_dir: &Path) -> Result<Option<IgnoredTeamField>, ModelError> {
+    let team_md = team_dir.join("TEAM.md");
+    if !team_md.exists() {
+        return Ok(None);
+    }
+    let (team_meta, _) = read_front_matter(&team_md)?;
+    let Some(value) = team_meta.get(IGNORED_OWNER_TEAM_ID_FIELD) else {
+        return Ok(None);
+    };
+    Ok(Some(IgnoredTeamField {
+        field: IGNORED_OWNER_TEAM_ID_FIELD,
+        value: front_matter_value_label(value),
+    }))
+}
+
 /// `compiler.compile_team` (compiler.py:23-135) — returns the compiled spec dict.
 ///
 /// `TEAM.md` + sorted `agents/*.md` → the canonical spec `Value::Map` with the
@@ -518,5 +541,12 @@ fn max_active_agents(count: usize) -> i64 {
     }
 }
 
+fn front_matter_value_label(value: &Value) -> String {
+    value
+        .as_str()
+        .map(ToString::to_string)
+        .unwrap_or_else(|| yaml::dumps(value).trim().to_string())
+}
+
 #[cfg(test)]
 mod tests;

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"), "");
     }
 }