@team-agent/installer 0.5.86 → 0.5.89

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.86"
+version = "0.5.89"
 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.86"
+version = "0.5.89"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -314,7 +314,7 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
 }
 
 /// `cmd_status`(`commands.py:90`)。CLI status 统一为只读七字段 brief；
-/// `--json` 与人读路径共享 nodeprobe-backed projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
+/// `--json` 与人读路径共享 native tmux/process projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
 #[cfg(test)]
 pub(crate) fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
     cmd_status_for_team(args, args.team.as_deref())
@@ -357,7 +357,7 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
         }
     }
     // Status brief is deliberately independent of the legacy RuntimeSnapshot:
-    // it performs one bounded nodeprobe sample and exposes exactly seven
+    // it performs one native tmux/process sample and exposes exactly seven
     // fields. `--summary` and `--detail` remain parser-compatible but do not
     // re-enable history, runtime diagnostics, or reminder text.
     if args.json {

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

@@ -417,7 +417,7 @@ fn command_help(command: Option<&str>) -> String {
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
-        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或 nodeprobe 证据时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
+        Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
         Some("models") => "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, and display name. Cursor uses the local `agent --list-models` catalog.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
         Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
@@ -1069,17 +1069,37 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         ));
     }
     let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    let agents_dir = parsed
-        .positionals
-        .first()
-        .map(PathBuf::from)
-        .unwrap_or_else(|| workspace.clone());
-    let agents_dir = if agents_dir.is_absolute() {
-        agents_dir
-    } else {
-        workspace.join(agents_dir)
-    };
+    let explicit_workspace = parsed
+        .workspace
+        .as_deref()
+        .map(|path| resolve_cli_path(cwd, path));
+    let positional_agents_dir = parsed.positionals.first().map(PathBuf::from).map(|path| {
+        if path.is_absolute() {
+            path
+        } else if let Some(workspace) = explicit_workspace.as_ref() {
+            workspace.join(path)
+        } else {
+            cwd.join(path)
+        }
+    });
+    let workspace = explicit_workspace
+        .or_else(|| {
+            let path = positional_agents_dir.as_ref()?;
+            if let Some(run_workspace) = path
+                .ancestors()
+                .find(|ancestor| ancestor.file_name().and_then(|name| name.to_str()) == Some(".team"))
+                .and_then(Path::parent)
+            {
+                return Some(run_workspace.to_path_buf());
+            }
+            path.join("TEAM.md").is_file().then(|| path.to_path_buf())
+        })
+        .unwrap_or_else(|| cwd.to_path_buf());
+    // A positional team directory containing TEAM.md is a complete standalone
+    // workspace. Use it as the runtime workspace unless --workspace explicitly
+    // selects another root; this prevents host owner context/state leaking into
+    // an independent quick-start target.
+    let agents_dir = positional_agents_dir.unwrap_or_else(|| workspace.clone());
     // 0.5.x Phase 1d Batch 2: validate the `--backend` literal up-front
     // so users get a fast, actionable error instead of a downstream
     // factory refusal. Accept the same literals as the factory
@@ -2565,6 +2585,30 @@ mod tests {
         let _ = std::fs::remove_dir_all(&ws);
     }
 
+    #[test]
+    fn ux_quick_start_positional_team_dir_is_standalone_workspace() {
+        let cwd = tmp_workspace();
+        let ws = tmp_workspace();
+        std::fs::write(ws.join("TEAM.md"), "# team\n").unwrap();
+        let args = quick_start_args(&cli_argv(&[&ws.to_string_lossy()]), &cwd).unwrap();
+        assert_eq!(args.workspace, ws);
+        assert_eq!(args.agents_dir, ws);
+        let _ = std::fs::remove_dir_all(&cwd);
+        let _ = std::fs::remove_dir_all(&ws);
+    }
+
+    #[test]
+    fn ux_quick_start_team_dir_under_dot_team_uses_project_workspace() {
+        let cwd = tmp_workspace();
+        let team_dir = cwd.join(".team/current");
+        std::fs::create_dir_all(&team_dir).unwrap();
+        std::fs::write(team_dir.join("TEAM.md"), "# team\n").unwrap();
+        let args = quick_start_args(&cli_argv(&[".team/current"]), &cwd).unwrap();
+        assert_eq!(args.workspace, cwd);
+        assert_eq!(args.agents_dir, team_dir);
+        let _ = std::fs::remove_dir_all(&cwd);
+    }
+
     // ── E8 (N38): 未知子命令 → 最近似建议(additive,不破坏 golden invalid-choice 行) ──
     #[test]
     fn e8_unknown_subcommand_suggests_nearest_known_command() {

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -1,38 +1,66 @@
-//! Seven-field, read-only status projection backed by one bounded nodeprobe sample.
+//! Seven-field, read-only status projection backed by native tmux and process samples.
 //!
 //! This intentionally does not reuse RuntimeSnapshot: the legacy snapshot reads
 //! coordinator/db/history and carries diagnostic fields that are outside the
 //! status brief contract.
 
-use serde::Deserialize;
 use serde_json::{json, Map, Value};
-use sha2::{Digest, Sha256};
 use std::collections::BTreeMap;
+use std::path::Path;
+use std::process::Command;
+
+#[cfg(test)]
+use serde::Deserialize;
+#[cfg(test)]
+use sha2::{Digest, Sha256};
+#[cfg(test)]
 use std::fs::{File, OpenOptions};
+#[cfg(test)]
 use std::io::Read;
-use std::path::{Path, PathBuf};
-use std::process::{Child, Command, ExitStatus, Stdio};
+#[cfg(test)]
+use std::path::PathBuf;
+#[cfg(test)]
+use std::process::{Child, ExitStatus, Stdio};
+#[cfg(test)]
 use std::sync::atomic::{AtomicBool, Ordering};
+#[cfg(test)]
 use std::sync::mpsc;
 #[cfg(test)]
 use std::sync::Arc;
+#[cfg(test)]
 use std::thread;
+#[cfg(test)]
 use std::time::{Duration, Instant};
 
+#[cfg(test)]
 const NODEPROBE_TIMEOUT: Duration = Duration::from_secs(2);
+#[cfg(test)]
 const NODEPROBE_OUTPUT_LIMIT: u64 = 1024 * 1024;
+#[cfg(test)]
 const NODEPROBE_KILL_GRACE: Duration = Duration::from_millis(100);
+#[cfg(test)]
 const NODEPROBE_RECEIPT_LIMIT: u64 = 64 * 1024;
+#[cfg(test)]
 const NODEPROBE_BINARY_LIMIT: u64 = 64 * 1024 * 1024;
+#[cfg(test)]
 const NODEPROBE_READ_CHUNK: usize = 64 * 1024;
+#[cfg(test)]
 const NODEPROBE_NAME: &str = "nodeprobe";
+#[cfg(test)]
 const NODEPROBE_RECEIPT_SUFFIX: &str = ".capability.json";
+#[cfg(test)]
 const NODEPROBE_RECEIPT_SCHEMA: &str = "nodeprobe-capability-v1";
+#[cfg(test)]
 const NODEPROBE_SOURCE_REPO: &str = "Florious95/team-agent-scratch/nodeprobe";
+#[cfg(test)]
 const NODEPROBE_SOURCE_COMMIT: &str = "ff316dc0afe8ab280e61d30934e7624579be6224";
+#[cfg(test)]
 const NODEPROBE_SOURCE_TREE: &str = "5217a41aa914ddcb72c27f39f1b4af9ead68b1b6";
+#[cfg(test)]
 const NODEPROBE_REPORT_SCHEMA: u64 = 1;
+#[cfg(test)]
 const NODEPROBE_CAPABILITIES: &[&str] = &["tmux.list-panes", "ps.pid_ppid_stat_comm"];
+#[cfg(test)]
 const NODEPROBE_FORBIDDEN: &[&str] = &[
     "tmux.capture-pane",
     "tmux.attach",
@@ -47,6 +75,7 @@ thread_local! {
     static TEST_RESOLVER_DELAY: std::cell::RefCell<Option<TestResolverDelay>> = const { std::cell::RefCell::new(None) };
 }
 
+#[cfg(test)]
 static NODEPROBE_RESOLVER_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -90,6 +119,7 @@ struct ProbeResult {
 }
 
 #[derive(Debug, Deserialize)]
+#[cfg(test)]
 struct NodeprobeCapabilityReceipt {
     schema: String,
     binary: String,
@@ -383,6 +413,126 @@ fn first_string(value: &Value, keys: &[&str]) -> Option<String> {
 }
 
 fn probe_registered_endpoints(nodes: &[RegisteredNode]) -> BTreeMap<String, Option<ProbeResult>> {
+    #[cfg(test)]
+    {
+        // Keep the legacy fixture seam for existing hermetic tests; production
+        // status never searches for or executes nodeprobe.
+        if TEST_NODEPROBE.with(|slot| slot.borrow().is_some()) {
+            return probe_registered_endpoints_with_test_nodeprobe(nodes);
+        }
+    }
+    let mut endpoints = BTreeMap::new();
+    for endpoint in nodes.iter().filter_map(|node| node.endpoint.as_deref()) {
+        if endpoints.contains_key(endpoint) {
+            continue;
+        }
+        endpoints.insert(
+            endpoint.to_string(),
+            sample_native_endpoint(endpoint, nodes),
+        );
+    }
+    endpoints
+}
+
+fn sample_native_endpoint(
+    endpoint: &str,
+    registered: &[RegisteredNode],
+) -> Option<ProbeResult> {
+    let output = run_native_tmux_list_panes(endpoint)?;
+    let nodes = output
+        .lines()
+        .filter_map(|line| parse_native_pane(line, endpoint, registered))
+        .collect::<Vec<_>>();
+    Some(ProbeResult { nodes })
+}
+
+fn run_native_tmux_list_panes(endpoint: &str) -> Option<String> {
+    const FORMAT: &str = "#{session_name}\t#{window_name}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}";
+    let flag = if Path::new(endpoint).is_absolute() { "-S" } else { "-L" };
+    let output = Command::new("tmux")
+        .arg(flag)
+        .arg(endpoint)
+        .args(["list-panes", "-a", "-F", FORMAT])
+        .output()
+        .ok()?;
+    output.status.success().then(|| String::from_utf8(output.stdout).ok())?
+}
+
+fn parse_native_pane(
+    line: &str,
+    endpoint: &str,
+    registered: &[RegisteredNode],
+) -> Option<ProbeNode> {
+    let mut fields = line.split('\t');
+    let session = fields.next()?.to_string();
+    let window = fields.next()?.to_string();
+    let pane = fields.next()?.to_string();
+    let pid = fields.next().filter(|value| !value.is_empty());
+    let command = fields.next().unwrap_or_default();
+    if session.is_empty() || window.is_empty() || pane.is_empty() {
+        return None;
+    }
+    let matched = registered.iter().find(|node| {
+        node.endpoint.as_deref() == Some(endpoint)
+            && node.session.as_deref() == Some(session.as_str())
+            && node.window.as_deref().is_none_or(|value| value == window)
+            && node.pane.as_deref() == Some(pane.as_str())
+    });
+    if let Some(pid) = pid {
+        let snapshot = process_snapshot(pid)?;
+        if snapshot.zombie {
+            return None;
+        }
+    }
+    let provider = matched
+        .map(|node| node.provider.clone())
+        .unwrap_or_else(|| "unknown".to_string());
+    let activity = if command.is_empty() {
+        "unknown"
+    } else if matches!(command, "bash" | "fish" | "sh" | "zsh" | "-bash" | "-zsh") {
+        "idle"
+    } else {
+        "working"
+    };
+    Some(ProbeNode {
+        socket: endpoint.to_string(),
+        session: session.clone(),
+        window: window.clone(),
+        pane,
+        provider,
+        activity: activity.to_string(),
+        health: "normal".to_string(),
+        session_name: Some(session),
+        evidence_method: Some("native_tmux".to_string()),
+    })
+}
+
+struct ProcessSnapshot {
+    zombie: bool,
+}
+
+fn process_snapshot(pid: &str) -> Option<ProcessSnapshot> {
+    let output = Command::new("ps")
+        .args(["-o", "pid=,ppid=,stat=,comm=", "-p", pid])
+        .output()
+        .ok()?;
+    if !output.status.success() || String::from_utf8_lossy(&output.stdout).trim().is_empty() {
+        return None;
+    }
+    let output_text = String::from_utf8_lossy(&output.stdout);
+    let stat = output_text
+        .split_whitespace()
+        .nth(2)
+        .unwrap_or_default();
+    Some(ProcessSnapshot {
+        zombie: stat.contains('Z'),
+    })
+}
+
+#[cfg(test)]
+fn probe_registered_endpoints_with_test_nodeprobe(
+    nodes: &[RegisteredNode],
+) -> BTreeMap<String, Option<ProbeResult>> {
     let deadline = Instant::now() + NODEPROBE_TIMEOUT;
     let candidates = nodeprobe_candidates();
     let resolver_options = resolver_options();
@@ -410,6 +560,7 @@ fn probe_registered_endpoints(nodes: &[RegisteredNode]) -> BTreeMap<String, Opti
     endpoints
 }
 
+#[cfg(test)]
 fn run_nodeprobe(binary: &Path, endpoint: &str, deadline: Instant) -> Option<Vec<u8>> {
     if Instant::now() >= deadline {
         return None;
@@ -476,6 +627,7 @@ fn run_nodeprobe(binary: &Path, endpoint: &str, deadline: Instant) -> Option<Vec
     }
 }
 
+#[cfg(test)]
 fn wait_child_bounded(child: &mut Child, deadline: Instant) -> Option<ExitStatus> {
     loop {
         match child.try_wait() {
@@ -493,6 +645,7 @@ fn wait_child_bounded(child: &mut Child, deadline: Instant) -> Option<ExitStatus
     }
 }
 
+#[cfg(test)]
 fn terminate_nodeprobe(child: &mut Child) {
     #[cfg(unix)]
     {
@@ -509,6 +662,7 @@ fn terminate_nodeprobe(child: &mut Child) {
     }
 }
 
+#[cfg(test)]
 fn spawn_nodeprobe(binary: &Path, endpoint: &str) -> Option<Child> {
     let flag = if Path::new(endpoint).is_absolute() {
         "-S"
@@ -522,11 +676,13 @@ fn spawn_nodeprobe(binary: &Path, endpoint: &str) -> Option<Child> {
 }
 
 #[derive(Clone, Default)]
+#[cfg(test)]
 struct ResolverOptions {
     #[cfg(test)]
     delay_after_selection: Option<TestResolverDelay>,
 }
 
+#[cfg(test)]
 fn resolver_options() -> ResolverOptions {
     #[cfg(test)]
     {
@@ -543,11 +699,13 @@ fn resolver_options() -> ResolverOptions {
 // A resolver that is stuck in an uninterruptible filesystem syscall may outlive
 // the caller deadline. It owns only its candidate work; the active gate prevents
 // repeated status calls from accumulating more detached resolver threads.
+#[cfg(test)]
 struct ResolverActiveGuard {
     #[cfg(test)]
     finished_signal: Option<ResolverDelaySignal>,
 }
 
+#[cfg(test)]
 impl Drop for ResolverActiveGuard {
     fn drop(&mut self) {
         NODEPROBE_RESOLVER_ACTIVE.store(false, Ordering::Release);
@@ -558,6 +716,7 @@ impl Drop for ResolverActiveGuard {
     }
 }
 
+#[cfg(test)]
 fn resolve_nodeprobe_binary(
     candidates: Vec<PathBuf>,
     deadline: Instant,
@@ -606,6 +765,7 @@ fn resolve_nodeprobe_binary(
     }
 }
 
+#[cfg(test)]
 fn select_nodeprobe_binary(
     candidates: Vec<PathBuf>,
     deadline: Instant,
@@ -621,6 +781,7 @@ fn select_nodeprobe_binary(
     None
 }
 
+#[cfg(test)]
 fn nodeprobe_candidates() -> Vec<PathBuf> {
     #[cfg(test)]
     {
@@ -642,6 +803,7 @@ fn nodeprobe_candidates() -> Vec<PathBuf> {
     candidates
 }
 
+#[cfg(test)]
 fn validate_nodeprobe_candidate(path: &Path, deadline: Instant) -> Option<PathBuf> {
     if Instant::now() >= deadline {
         return None;
@@ -669,6 +831,7 @@ fn validate_nodeprobe_candidate(path: &Path, deadline: Instant) -> Option<PathBu
     (digest == receipt.binary_sha256).then_some(path.to_path_buf())
 }
 
+#[cfg(test)]
 fn valid_nodeprobe_receipt(receipt: &NodeprobeCapabilityReceipt, binary: &Path) -> bool {
     receipt.schema == NODEPROBE_RECEIPT_SCHEMA
         && binary.file_name().and_then(|name| name.to_str()) == Some(NODEPROBE_NAME)
@@ -683,10 +846,12 @@ fn valid_nodeprobe_receipt(receipt: &NodeprobeCapabilityReceipt, binary: &Path)
         && same_string_set(&receipt.forbidden, NODEPROBE_FORBIDDEN)
 }
 
+#[cfg(test)]
 fn valid_sha256(value: &str) -> bool {
     value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit())
 }
 
+#[cfg(test)]
 fn same_string_set(actual: &[String], expected: &[&str]) -> bool {
     let mut actual = actual.to_vec();
     actual.sort_unstable();
@@ -698,6 +863,7 @@ fn same_string_set(actual: &[String], expected: &[&str]) -> bool {
     actual == expected
 }
 
+#[cfg(test)]
 fn nodeprobe_receipt_path(binary: &Path) -> PathBuf {
     let name = binary
         .file_name()
@@ -706,6 +872,7 @@ fn nodeprobe_receipt_path(binary: &Path) -> PathBuf {
     binary.with_file_name(format!("{name}{NODEPROBE_RECEIPT_SUFFIX}"))
 }
 
+#[cfg(test)]
 fn read_bounded_file(path: &Path, limit: u64, deadline: Instant) -> Option<Vec<u8>> {
     let metadata = std::fs::metadata(path).ok()?;
     if !metadata.is_file() || metadata.len() > limit {
@@ -729,6 +896,7 @@ fn read_bounded_file(path: &Path, limit: u64, deadline: Instant) -> Option<Vec<u
     }
 }
 
+#[cfg(test)]
 fn sha256_file(path: &Path, deadline: Instant) -> Option<String> {
     let metadata = std::fs::metadata(path).ok()?;
     if !metadata.is_file() || metadata.len() > NODEPROBE_BINARY_LIMIT {
@@ -754,6 +922,7 @@ fn sha256_file(path: &Path, deadline: Instant) -> Option<String> {
     }
 }
 
+#[cfg(test)]
 fn open_readonly_nonblocking(path: &Path) -> Option<File> {
     let mut options = OpenOptions::new();
     options.read(true);
@@ -765,6 +934,7 @@ fn open_readonly_nonblocking(path: &Path) -> Option<File> {
     options.open(path).ok()
 }
 
+#[cfg(test)]
 fn is_executable(metadata: &std::fs::Metadata) -> bool {
     #[cfg(unix)]
     {
@@ -778,6 +948,7 @@ fn is_executable(metadata: &std::fs::Metadata) -> bool {
     }
 }
 
+#[cfg(test)]
 fn current_nodeprobe_target() -> Option<&'static str> {
     match (std::env::consts::OS, std::env::consts::ARCH) {
         ("macos", "aarch64") => Some("aarch64-apple-darwin"),
@@ -789,6 +960,7 @@ fn current_nodeprobe_target() -> Option<&'static str> {
     }
 }
 
+#[cfg(test)]
 fn configure_nodeprobe_command(command: &mut Command) {
     command
         .stdin(Stdio::null())
@@ -801,6 +973,7 @@ fn configure_nodeprobe_command(command: &mut Command) {
     }
 }
 
+#[cfg(test)]
 fn parse_probe(bytes: &[u8], requested_endpoint: &str) -> Result<ProbeResult, ()> {
     let value: Value = serde_json::from_slice(bytes).map_err(|_| ())?;
     if value.get("schema_version").and_then(Value::as_u64) != Some(1) {
@@ -823,6 +996,7 @@ fn parse_probe(bytes: &[u8], requested_endpoint: &str) -> Result<ProbeResult, ()
     Ok(ProbeResult { nodes })
 }
 
+#[cfg(test)]
 fn probe_has_error(value: &Value) -> bool {
     match value.get("error") {
         None | Some(Value::Null) => false,
@@ -833,6 +1007,7 @@ fn probe_has_error(value: &Value) -> bool {
     }
 }
 
+#[cfg(test)]
 fn parse_probe_node(value: &Value, report_socket: &str) -> Option<ProbeNode> {
     Some(ProbeNode {
         // The accepted producer binds the socket once at the report envelope
@@ -857,6 +1032,7 @@ fn parse_probe_node(value: &Value, report_socket: &str) -> Option<ProbeNode> {
     })
 }
 
+#[cfg(test)]
 fn non_empty(value: &Value, key: &str) -> Option<String> {
     value
         .get(key)
@@ -895,12 +1071,16 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
     }
     let pi_channel = observed.provider.eq_ignore_ascii_case("pi")
         && observed.evidence_method.as_deref() == Some("pi_activity_channel");
-    let activity = if observed.provider.eq_ignore_ascii_case("pi") && !pi_channel {
+    let native_tmux = observed.evidence_method.as_deref() == Some("native_tmux");
+    let activity = if observed.provider.eq_ignore_ascii_case("pi")
+        && !pi_channel
+        && !native_tmux
+    {
         "unknown"
     } else {
         valid_activity(&observed.activity)
     };
-    let health = if observed.provider.eq_ignore_ascii_case("pi") && !pi_channel {
+    let health = if observed.provider.eq_ignore_ascii_case("pi") && !pi_channel && !native_tmux {
         "unknown"
     } else {
         valid_health(&observed.health)

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

@@ -32,8 +32,8 @@ use crate::model::enums::{Provider, ProviderEffort};
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
 use crate::provider::wire::{
-    builtin_provider_model as wire_builtin_provider_model, is_claude_family,
-    parse_canonical_provider, provider_model_keys,
+    builtin_provider_model as wire_builtin_provider_model, parse_canonical_provider,
+    provider_model_keys,
 };
 
 pub const IGNORED_OWNER_TEAM_ID_FIELD: &str = "owner_team_id";
@@ -602,12 +602,9 @@ fn compile_role_agent_with_mode(
             })
             .unwrap_or("");
         let provider_enum = parse_canonical_provider(provider_str).unwrap_or(Provider::Codex);
-        if effort.is_claude_only()
-            && !is_claude_family(provider_enum)
-            && provider_enum != Provider::Pi
-        {
+        if let Err(reason) = effort.resolve_for_provider(provider_enum) {
             return Err(ModelError::Validation(format!(
-                "{}: effort '{}' is only supported by claude/claude_code (provider: {provider_str})",
+                "{}: {reason} (effort: {}; provider: {provider_str})",
                 role_path.display(),
                 effort.as_str()
             )));

package/crates/team-agent/src/lifecycle/launch/identity.rs

@@ -9,7 +9,7 @@
 //!     - name: transport_has_session
 //!       what: 探测 tmux session 是否存在，探测本身出错一律当不存在
 //!     - name: provider_effort_from_raw
-//!       what: 解析 effort 并要求该 provider 支持，否则 None
+//!       what: 解析 effort，保留兼容忽略项并拒绝非法 provider 组合
 //!     - name: quick_start_depth_guard
 //!       what: 定出本次 quick-start 的父团队与层级，推不出父团队时拒绝
 //!     - name: annotate_persisted_team_depth
@@ -135,24 +135,24 @@ pub(super) fn parse_auth_mode(raw: &str) -> Option<AuthMode> {
 /// purpose: 从原始字符串解析 effort，并要求当前 provider 支持它
 /// params:
 ///   raw: effort 原文，None 或空白返回 None
-/// returns: 解析成功且该 provider 支持时返回该档位，否则 None
+/// returns: 支持的档位或兼容忽略的 None；已知非法 provider/effort 组合返回错误
 /// ---
 /// 0.4.x provider effort MVP step 4: low-level from a raw string. Returns
-/// `Some(effort)` when the level parses AND the provider supports it.
+/// `Some(effort)` for supported levels, None for legacy ignored values,
+/// and an error for provider/effort combinations rejected by configuration.
 pub(crate) fn provider_effort_from_raw(
     raw: Option<&str>,
     provider: Provider,
-) -> Option<ProviderEffort> {
-    let raw = raw?.trim();
-    if raw.is_empty() {
-        return None;
-    }
-    let effort = ProviderEffort::parse(raw)?;
-    if effort.is_supported_by(provider) {
-        Some(effort)
-    } else {
-        None
-    }
+) -> Result<Option<ProviderEffort>, LifecycleError> {
+    let Some(effort) = raw.and_then(ProviderEffort::parse) else {
+        return Ok(None);
+    };
+    effort.resolve_for_provider(provider).map_err(|reason| {
+        LifecycleError::RequirementUnmet(format!(
+            "{reason} (effort: {}; provider: {provider:?})",
+            effort.as_str()
+        ))
+    })
 }
 
 /// ---
@@ -171,7 +171,7 @@ pub(crate) fn provider_effort_event_payload(
         return None;
     }
     let effort = ProviderEffort::parse(raw)?;
-    if effort.is_supported_by(provider) {
+    if !matches!(effort.resolve_for_provider(provider), Ok(None)) {
         return None;
     }
     Some(serde_json::json!({
@@ -221,7 +221,7 @@ pub(crate) fn extend_worker_env_unset_for_effort(
 pub(crate) fn provider_effort_for_spawn(
     agent: &crate::model::yaml::Value,
     provider: Provider,
-) -> Option<ProviderEffort> {
+) -> Result<Option<ProviderEffort>, LifecycleError> {
     provider_effort_from_raw(agent.get("effort").and_then(|v| v.as_str()), provider)
 }
 
@@ -252,7 +252,7 @@ pub(crate) fn provider_effort_event_if_dropped(
 pub(crate) fn provider_effort_for_spawn_json(
     agent: &serde_json::Value,
     provider: Provider,
-) -> Option<ProviderEffort> {
+) -> Result<Option<ProviderEffort>, LifecycleError> {
     provider_effort_from_raw(
         agent.get("effort").and_then(serde_json::Value::as_str),
         provider,
@@ -307,10 +307,16 @@ pub(super) fn quick_start_depth_guard(
     requested_team: Option<&str>,
     _strict_real_runtime: bool,
 ) -> Result<QuickStartDepth, LifecycleError> {
-    let env_parent = std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
-        .ok()
-        .map(|value| value.trim().to_string())
-        .filter(|value| !value.is_empty());
+    // OWNER_TEAM_ID is injected into every worker process. It is parent
+    // context only when the target quick-start workspace is the same workspace
+    // that produced the environment; otherwise a worker launching a fresh
+    // external workspace would inherit a false nesting parent.
+    let env_parent = owner_context_matches_workspace(workspace).then(|| {
+        std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
+            .ok()
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty())
+    }).flatten();
     let parent = env_parent;
     let Some(parent) = parent else {
         let state = crate::state::persist::load_runtime_state(workspace)
@@ -365,6 +371,18 @@ pub(super) fn quick_start_depth_guard(
 /// purpose: 从 runtime state 推断父团队键
 /// returns: 活跃团队键，且该团队确有 running 席位时返回它，否则 None
 /// ---
+fn owner_context_matches_workspace(workspace: &Path) -> bool {
+    let Some(env_workspace) = std::env::var_os("TEAM_AGENT_WORKSPACE") else {
+        return false;
+    };
+    let env_workspace = PathBuf::from(env_workspace);
+    env_workspace == workspace
+        || std::fs::canonicalize(&env_workspace)
+            .ok()
+            .zip(std::fs::canonicalize(workspace).ok())
+            .is_some_and(|(env_path, target_path)| env_path == target_path)
+}
+
 pub(super) fn infer_parent_team_from_active_state(state: &serde_json::Value) -> Option<String> {
     let active = explicit_active_team_key(state)?;
     let team = state

package/crates/team-agent/src/lifecycle/launch/spawn.rs

@@ -152,7 +152,7 @@ pub(super) fn spawn_agents(
         // 0.4.x provider effort MVP step 4 + 7: resolve effort and emit
         // unsupported warning event when the spec asked for an effort the
         // provider can't satisfy.
-        let agent_effort = provider_effort_for_spawn(agent, provider);
+        let agent_effort = provider_effort_for_spawn(agent, provider)?;
         if let Some(event_value) = provider_effort_event_if_dropped(agent, provider, agent_id_raw) {
             let _ = crate::event_log::EventLog::new(workspace)
                 .write("provider.effort_unsupported", event_value);

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -355,7 +355,7 @@ pub(super) fn spawn_agent_window(
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
     // 0.4.x provider effort MVP: restart/resume preserves effort from the
     // persisted agent JSON (state's agent["effort"] field, set by launch).
-    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider);
+    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider)?;
     if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
         agent,
         provider,

package/crates/team-agent/src/lifecycle/tests/b0_reader_hideone_audit_contract.rs

@@ -99,17 +99,17 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
     let case = B0HideOneCase::new("status-diagnose-hide-one");
     let root = case.current_state();
     save_runtime_state(&case.workspace, &root).expect("seed current root state");
-    let probe = brief_probe::install_trusted_nodeprobe(
+    let tmux = brief_probe::install_native_tmux(
         &case.workspace.join("probe"),
         NEW_ENDPOINT,
         SESSION,
         WORKER,
         "%new",
-        "fake",
+        "bash",
     );
     let _path = case.env.with_env(
         "PATH",
-        &brief_probe::path_with_probe(&probe, std::env::var_os("PATH").as_deref()),
+        &brief_probe::path_with_probe(&tmux, std::env::var_os("PATH").as_deref()),
     );
 
     let status_before = case.run_json(&[

package/crates/team-agent/src/model/enums.rs

@@ -86,9 +86,8 @@ impl ProviderEffort {
         matches!(self, Self::Max)
     }
 
-    /// True when the given provider supports this effort level. `max` is
-    /// Claude-only; other levels are supported by Claude, Codex, and Grok.
-    /// Copilot/Gemini/CursorAgent/Fake ignore the field (warning at runtime).
+    /// Native command support. Claude/Pi accept max; Codex/Grok accept
+    /// the other levels. Use resolve_for_provider for admission/ignore policy.
     pub fn is_supported_by(self, provider: Provider) -> bool {
         match provider {
             Provider::Claude | Provider::ClaudeCode | Provider::Pi => true,
@@ -98,6 +97,21 @@ impl ProviderEffort {
             }
         }
     }
+
+    /// One admission policy for compiler, direct specs and runtime commands.
+    /// Ok(None) preserves the legacy warning-and-ignore providers.
+    pub fn resolve_for_provider(self, provider: Provider) -> Result<Option<Self>, &'static str> {
+        if provider == Provider::CursorAgent {
+            return Err("cursor_agent does not support effort; the Cursor CLI has no --effort flag");
+        }
+        if self.is_supported_by(provider) {
+            Ok(Some(self))
+        } else if self.is_claude_only() {
+            Err("effort 'max' is only supported by claude/claude_code/pi")
+        } else {
+            Ok(None)
+        }
+    }
 }
 
 /// auth 模式(`AUTH_MODES` `profiles/constants.py:6`)。

package/crates/team-agent/src/model/spec.rs

@@ -18,7 +18,7 @@ use crate::model::ids::TaskId;
 use crate::model::task_graph::{find_dependency_cycle, TaskNode};
 use crate::model::yaml::Value as Yaml;
 use crate::model::yaml;
-use crate::provider::wire::{is_claude_family, parse_canonical_provider};
+use crate::provider::wire::parse_canonical_provider;
 
 /// result_envelope_v1 顶层 required(= allowed)。
 const RESULT_REQUIRED: &[&str] = &[
@@ -463,15 +463,16 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
                     "{path}/effort: unknown effort '{raw}' (allowed: low|medium|high|xhigh|max)"
                 ));
             }
-            Some(effort) if effort.is_claude_only() => {
+            Some(effort) => {
                 let provider = agent.get("provider").and_then(Yaml::as_str).unwrap_or("");
-                if !parse_canonical_provider(provider).is_some_and(is_claude_family) {
-                    errors.push(format!(
-                        "{path}/effort: effort '{raw}' is only supported by claude/claude_code (provider: {provider})"
-                    ));
+                if let Some(provider_enum) = parse_canonical_provider(provider) {
+                    if let Err(reason) = effort.resolve_for_provider(provider_enum) {
+                        errors.push(format!(
+                            "{path}/effort: {reason} (effort: {raw}; provider: {provider})"
+                        ));
+                    }
                 }
             }
-            Some(_) => {}
         }
     }
     check_keys_y(

package/crates/team-agent/src/provider/wire.rs

@@ -231,7 +231,7 @@ mod tests {
         );
         assert!(
             model_spec_rs.contains("parse_canonical_provider")
-                && model_spec_rs.contains("is_claude_family"),
+                && model_spec_rs.contains("resolve_for_provider"),
             "model spec must validate providers through typed helpers"
         );
         assert!(

package/package.json

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