@team-agent/installer 0.5.85 → 0.5.89

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.85"
+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.85"
+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/mod.rs

@@ -3646,7 +3646,6 @@ pub mod lifecycle_port {
                     dry_run: false,
                     tmux_endpoint: None,
                     routes: Vec::new(),
-                    permissions: Vec::new(),
                     leader_receiver_attached: true,
                     leader_bind_stage: None,
                     leader_bind_reason: None,

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)