@team-agent/installer 0.5.108 → 0.5.109

package/Cargo.lock

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

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

@@ -5,7 +5,7 @@
 //! status brief contract.
 
 use serde_json::{json, Map, Value};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::path::Path;
 use std::process::Command;
 
@@ -548,11 +548,37 @@ fn sample_native_endpoint(
     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 })
+    Some(sample_native_panes(&output, endpoint, registered, process_snapshots))
+}
+
+fn sample_native_panes(
+    output: &str,
+    endpoint: &str,
+    registered: &[RegisteredNode],
+    snapshots: impl FnOnce(&BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot>,
+) -> ProbeResult {
+    let panes = output.lines().filter_map(native_pane_fields).collect::<Vec<_>>();
+    let pids = panes.iter().filter_map(|fields| native_pane_pid(fields[3])).collect::<BTreeSet<_>>();
+    let processes = if pids.is_empty() { BTreeMap::new() } else { snapshots(&pids) };
+    let nodes = panes.into_iter()
+        .filter_map(|fields| parse_native_pane(fields, endpoint, registered, &processes))
+        .collect();
+    ProbeResult { nodes }
+}
+
+fn native_pane_fields(line: &str) -> Option<[&str; 5]> {
+    let mut fields = line.split('\t');
+    let session = fields.next()?;
+    let window = fields.next()?;
+    let pane = fields.next()?;
+    let pid = fields.next().unwrap_or_default();
+    let command = fields.next().unwrap_or_default();
+    if session.is_empty() || window.is_empty() || pane.is_empty() { return None; }
+    Some([session, window, pane, pid, command])
+}
+
+fn native_pane_pid(pid: &str) -> Option<u32> {
+    pid.parse::<u32>().ok().filter(|pid| *pid > 0 && *pid <= i32::MAX as u32)
 }
 
 fn run_native_tmux_list_panes(endpoint: &str) -> Option<String> {
@@ -568,27 +594,23 @@ fn run_native_tmux_list_panes(endpoint: &str) -> Option<String> {
 }
 
 fn parse_native_pane(
-    line: &str,
+    fields: [&str; 5],
     endpoint: &str,
     registered: &[RegisteredNode],
+    processes: &BTreeMap<u32, ProcessSnapshot>,
 ) -> 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 [session, window, pane, pid, command] = fields;
+    let session = session.to_string();
+    let window = window.to_string();
+    let pane = pane.to_string();
     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 !pid.is_empty() {
+        let snapshot = processes.get(&native_pane_pid(pid)?)?;
         if snapshot.zombie {
             return None;
         }
@@ -620,22 +642,35 @@ 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;
+fn process_snapshot_command(pids: &BTreeSet<u32>) -> Command {
+    let pids = pids.iter().map(u32::to_string).collect::<Vec<_>>().join(",");
+    let mut command = Command::new("ps");
+    command.args(["-o", "pid=,ppid=,stat=,comm=", "-p", &pids]);
+    command
+}
+
+fn process_snapshots(pids: &BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot> {
+    if pids.is_empty() { return BTreeMap::new(); }
+    let Ok(output) = process_snapshot_command(pids).output() else { return BTreeMap::new(); };
+    if !output.status.success() { return BTreeMap::new(); }
+    parse_process_snapshots(&output.stdout, pids)
+}
+
+fn parse_process_snapshots(bytes: &[u8], requested: &BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot> {
+    let mut snapshots = BTreeMap::<u32, ProcessSnapshot>::new();
+    let output = String::from_utf8_lossy(bytes);
+    for line in output.lines() {
+        let mut fields = line.split_whitespace();
+        let Some(pid) = fields.next().and_then(native_pane_pid) else { continue; };
+        if !requested.contains(&pid) { continue; }
+        let Some(_ppid) = fields.next() else { continue; };
+        let Some(stat) = fields.next() else { continue; };
+        let zombie = stat.contains('Z');
+        snapshots.entry(pid)
+            .and_modify(|snapshot| snapshot.zombie |= zombie)
+            .or_insert(ProcessSnapshot { zombie });
     }
-    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'),
-    })
+    snapshots
 }
 
 #[cfg(test)]
@@ -1335,6 +1370,162 @@ impl BriefNode {
     }
 }
 
+#[cfg(test)]
+mod native_ps_batch_regressions {
+    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+    use super::*;
+
+    fn registered(endpoint: &str, pane: &str) -> RegisteredNode {
+        RegisteredNode {
+            name: format!("{endpoint}-{pane}"),
+            provider: "pi".into(),
+            model: Some("fixture-model".into()),
+            effort: Some("high".into()),
+            endpoint: Some(endpoint.into()),
+            session: Some("hp".into()),
+            window: Some("w".into()),
+            pane: Some(pane.into()),
+            lifecycle: None,
+        }
+    }
+
+    #[test]
+    fn eight_panes_use_one_endpoint_query() {
+        let registered = (0..8).map(|i| registered("e1", &format!("%{i}"))).collect::<Vec<_>>();
+        let panes = (0..8).map(|i| format!("hp\tw\t%{i}\t{}\tpi\n", 100 + i)).collect::<String>();
+        let rows = (0..8).map(|i| format!("{} 1 S pi\n", 100 + i)).collect::<String>();
+        let mut calls = Vec::new();
+        let result = sample_native_panes(&panes, "e1", &registered, |pids| {
+            calls.push(pids.iter().copied().collect::<Vec<_>>());
+            parse_process_snapshots(rows.as_bytes(), pids)
+        });
+        assert_eq!(calls, vec![(100..108).collect::<Vec<_>>()]);
+        assert_eq!(result.nodes.len(), 8);
+        assert!(result.nodes.iter().all(|node| node.provider == "pi" && node.activity == "working" && node.health == "normal"));
+    }
+
+    #[test]
+    fn pid_deduplication_and_command_preserve_the_privacy_whitelist() {
+        let mut calls = Vec::new();
+        let result = sample_native_panes("hp\tw\t%1\t11\tsh\nhp\tw\t%2\t011\tsh\n", "e1", &[], |pids| {
+            calls.push(pids.iter().copied().collect::<Vec<_>>());
+            parse_process_snapshots(b"11 1 S sh\n", pids)
+        });
+        assert_eq!(calls, vec![vec![11]]);
+        assert_eq!(result.nodes.len(), 2);
+        let pids = BTreeSet::from([22, 11]);
+        let command = process_snapshot_command(&pids);
+        assert_eq!(command.get_program(), "ps");
+        assert_eq!(
+            command.get_args().map(|arg| arg.to_string_lossy().into_owned()).collect::<Vec<_>>(),
+            vec!["-o", "pid=,ppid=,stat=,comm=", "-p", "11,22"]
+        );
+        let command = process_snapshot_command(&BTreeSet::from([11]));
+        assert_eq!(command.get_args().last().unwrap(), "11");
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn native_ps_partial_selection_preserves_a_live_pid() {
+        let pid = std::process::id();
+        let requested = BTreeSet::from([pid, i32::MAX as u32]);
+        let command = process_snapshot_command(&requested);
+        // Absolute ps avoids unrelated PATH-fixture mutation in parallel unit tests.
+        let output = Command::new("/bin/ps").args(command.get_args()).output().unwrap();
+        assert!(output.status.success(), "partial PID selection must not poison the live row");
+        let snapshots = parse_process_snapshots(&output.stdout, &requested);
+        assert!(!snapshots.get(&pid).unwrap().zombie);
+        assert!(!snapshots.contains_key(&(i32::MAX as u32)));
+    }
+
+    #[test]
+    fn single_pane_keeps_its_native_health_and_activity() {
+        let registered = vec![registered("e1", "%1")];
+        let result = sample_native_panes("hp\tw\t%1\t11\tsh\n", "e1", &registered, |pids| {
+            assert_eq!(pids, &BTreeSet::from([11]));
+            parse_process_snapshots(b"11 1 S sh\n", pids)
+        });
+        assert_eq!(result.nodes.len(), 1);
+        assert_eq!(result.nodes[0].provider, "pi");
+        assert_eq!(result.nodes[0].activity, "idle");
+        assert_eq!(result.nodes[0].health, "normal");
+    }
+
+    #[test]
+    fn missing_rows_and_zombies_omit_only_their_panes() {
+        let panes = "hp\tw\t%1\t11\tsh\nhp\tw\t%2\t22\tpi\nhp\tw\t%3\t33\tpi\nhp\tw\t%4\t\tsh\n";
+        let result = sample_native_panes(panes, "e1", &[], |pids| {
+            parse_process_snapshots(b"22 1 Z+ dead\n11 1 S sh\n999 1 S unrelated\n33 1\n", pids)
+        });
+        assert_eq!(result.nodes.iter().map(|node| node.pane.as_str()).collect::<Vec<_>>(), vec!["%1", "%4"]);
+        assert!(result.nodes.iter().all(|node| node.activity == "idle" && node.health == "normal"));
+    }
+
+    #[test]
+    fn empty_or_invalid_pid_sets_do_not_run_ps() {
+        let panes = "hp\tw\t%1\t\tsh\nhp\tw\t%2\t0\tsh\nhp\tw\t%3\t1,2\tsh\nhp\tw\t%4\t4294967295\tsh\n\tw\t%5\t99\tsh\n";
+        let result = sample_native_panes(panes, "e1", &[], |_| panic!("no valid PID means no ps query"));
+        assert_eq!(result.nodes.len(), 1);
+        assert_eq!(result.nodes[0].pane, "%1");
+        assert_eq!(result.nodes[0].health, "normal");
+    }
+
+    #[test]
+    fn snapshot_failure_and_endpoint_results_are_not_shared() {
+        let registered = vec![registered("e1", "%1"), registered("e2", "%1")];
+        let mut calls = Vec::new();
+        let first = sample_native_panes("hp\tw\t%1\t88\tsh\n", "e1", &registered, |pids| {
+            calls.push(("e1", pids.iter().copied().collect::<Vec<_>>()));
+            BTreeMap::new()
+        });
+        let second = sample_native_panes("hp\tw\t%1\t88\tsh\n", "e2", &registered, |pids| {
+            calls.push(("e2", pids.iter().copied().collect::<Vec<_>>()));
+            parse_process_snapshots(b"88 1 S sh\n", pids)
+        });
+        assert_eq!(calls, vec![("e1", vec![88]), ("e2", vec![88])]);
+        assert!(first.nodes.is_empty());
+        assert_eq!(second.nodes.len(), 1);
+        let failed = Some(first);
+        assert_eq!(project_node_with_attach(&registered[0], Some(&failed)).0.health, "unknown");
+        let live = Some(second);
+        assert_eq!(project_node_with_attach(&registered[1], Some(&live)).0.health, "normal");
+    }
+
+    #[test]
+    fn duplicate_process_rows_cannot_hide_a_zombie() {
+        let requested = BTreeSet::from([11]);
+        for rows in [b"11 1 Z dead\n11 1 S sh\n".as_slice(), b"11 1 S sh\n11 1 Z dead\n".as_slice()] {
+            assert!(parse_process_snapshots(rows, &requested).get(&11).unwrap().zombie);
+        }
+        assert!(parse_process_snapshots(b"not a process row\n", &requested).is_empty());
+    }
+
+    #[test]
+    fn json_and_human_keep_nine_fields_without_ps_details() {
+        let registered = vec![registered("e1", "%1"), registered("e1", "%2")];
+        let probe = Some(sample_native_panes(
+            "hp\tw\t%1\t11\tsh\nhp\tw\t%2\t22\tpi\n", "e1", &registered,
+            |pids| parse_process_snapshots(b"22 1 R PRIVATE_COMMAND_DETAIL\n11 1 S PRIVATE_COMMAND_DETAIL\n", pids),
+        ));
+        let projected = registered.iter().map(|node| project_node_with_attach(node, Some(&probe))).collect::<Vec<_>>();
+        let keys = BTreeSet::from(["name", "provider", "model", "effort", "runtime_status", "activity", "health", "session_name", "tmux_command"]);
+        for (node, _) in &projected {
+            let json = node.clone().into_json();
+            assert_eq!(json.as_object().unwrap().keys().map(String::as_str).collect::<BTreeSet<_>>(), keys);
+            assert_eq!(json["model"], "fixture-model");
+            assert_eq!(json["effort"], "high");
+            assert_eq!(json["runtime_status"], "running");
+            assert_eq!(json["health"], "normal");
+            assert!(!json.to_string().contains("PRIVATE_COMMAND_DETAIL"));
+        }
+        let human = format_multi_node_brief(projected);
+        let mut lines = human.lines().skip_while(|line| !line.starts_with("NAME\t"));
+        assert_eq!(lines.next().unwrap().split('\t').count(), 9);
+        assert!(lines.all(|line| line.split('\t').count() == 9));
+        assert!(!human.contains("PRIVATE_COMMAND_DETAIL"));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]

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

@@ -589,15 +589,18 @@ pub(crate) fn run_command(
         Some((writer, rx))
     } else { None };
     let mut output = None;
+    let mut pending_output = None;
+    let mut output_ready_at: Option<Instant> = None;
     let mut too_large_at = None;
     let status = loop {
-        match reader_rx.try_recv() {
+        match pending_output.take().map_or_else(|| reader_rx.try_recv(), Ok) {
             Ok(Ok(bytes)) => {
                 if bytes.len() as u64 > max_bytes {
                     too_large_at.get_or_insert_with(Instant::now);
                 } else {
                     output = Some(bytes);
                 }
+                output_ready_at = Some(Instant::now());
             }
             Ok(Err(_)) => { terminate(&mut child, pid); return Err(CatalogError::OutputReadFailed); }
             Err(mpsc::TryRecvError::Disconnected) if output.is_none() && too_large_at.is_none() => { terminate(&mut child, pid); return Err(CatalogError::OutputReadFailed); }
@@ -614,7 +617,24 @@ pub(crate) fn run_command(
                 terminate(&mut child, pid);
                 return Err(CatalogError::OutputTooLarge);
             }
-            Ok(None) if started.elapsed() < timeout => std::thread::sleep(Duration::from_millis(10)),
+            Ok(None) if started.elapsed() < timeout => {
+                let mut wait = timeout.saturating_sub(started.elapsed()).min(Duration::from_millis(10));
+                if let Some(over_at) = too_large_at {
+                    wait = wait.min(Duration::from_millis(100).saturating_sub(over_at.elapsed()));
+                }
+                if output.is_none() && too_large_at.is_none() {
+                    // Reader completion wakes us instead of trailing a blind 10ms sleep.
+                    if let Ok(result) = reader_rx.recv_timeout(wait) {
+                        pending_output = Some(result);
+                    }
+                } else {
+                    // stdout can close before exit; never busy-poll a disconnected channel.
+                    let interval = output_ready_at.map_or(Duration::from_millis(10), |at| {
+                        catalog_exit_poll_interval(at.elapsed())
+                    });
+                    std::thread::sleep(wait.min(interval));
+                }
+            }
             Ok(None) if too_large_at.is_some() => { terminate(&mut child, pid); return Err(CatalogError::OutputTooLarge); }
             Ok(None) => { terminate(&mut child, pid); return Err(CatalogError::Timeout); }
             Err(_) => { terminate(&mut child, pid); return Err(CatalogError::CommandCouldNotBeObserved); }
@@ -642,6 +662,16 @@ pub(crate) fn run_command(
     output.ok_or(CatalogError::OutputReadFailed)
 }
 
+fn catalog_exit_poll_interval(elapsed: Duration) -> Duration {
+    [1, 3, 6, 10]
+        .into_iter()
+        .map(Duration::from_millis)
+        .find(|checkpoint| *checkpoint > elapsed)
+        .map_or(Duration::from_millis(10), |checkpoint| {
+            checkpoint.saturating_sub(elapsed)
+        })
+}
+
 fn terminate(child: &mut Child, pid: u32) {
     #[cfg(unix)]
     unsafe {
@@ -700,6 +730,151 @@ impl Drop for OwnedTempDir {
     fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); }
 }
 
+#[cfg(all(test, unix))]
+mod command_wait_regressions {
+    use super::*;
+
+    #[derive(Default)]
+    struct Observer {
+        pid: Option<u32>,
+        exits: Vec<Option<i32>>,
+        output_timeouts: usize,
+    }
+
+    impl CatalogObserver for Observer {
+        fn spawned(&mut self, pid: u32) { self.pid = Some(pid); }
+        fn exited(&mut self, status: &ExitStatus) { self.exits.push(status.code()); }
+        fn output_timeout(&mut self) { self.output_timeouts += 1; }
+    }
+
+    fn run(
+        script: &str,
+        input: Option<&[u8]>,
+        timeout: Duration,
+        max_bytes: u64,
+        observer: &mut Observer,
+    ) -> Result<Vec<u8>, CatalogError> {
+        run_command(
+            Path::new("/bin/sh"), &["-c", script], input, None, &[], &[],
+            timeout, max_bytes, observer,
+        )
+    }
+
+    fn assert_owned_child_gone(observer: &Observer) {
+        let pid = observer.pid.unwrap();
+        assert!(pid > 1);
+        let status = Command::new("/bin/kill")
+            .args(["-0", &pid.to_string()])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .unwrap();
+        assert!(!status.success(), "owned child must be reaped");
+    }
+
+    #[test]
+    fn eof_and_success_preserve_input_and_raw_output() {
+        let mut observer = Observer::default();
+        let input = b"catalog\0\xff\n";
+        let output = run(
+            "exec /bin/cat", Some(input), CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap();
+        assert_eq!(output, input.to_vec());
+        assert_eq!(observer.exits, vec![Some(0)]);
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn stdout_eof_does_not_hide_a_later_nonzero_exit() {
+        let mut observer = Observer::default();
+        let error = run(
+            "printf 'partial'; exec 1>&-; /bin/sleep 0.03; exit 17",
+            None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::CommandFailed);
+        assert_eq!(observer.exits, vec![Some(17)]);
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn stdout_eof_does_not_disable_the_ten_second_process_timeout() {
+        let mut observer = Observer::default();
+        let started = Instant::now();
+        let error = run(
+            "exec 1>&-; exec /bin/sleep 30", None, CATALOG_TIMEOUT,
+            MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        let elapsed = started.elapsed();
+        assert_eq!(CATALOG_TIMEOUT, Duration::from_secs(10));
+        assert_eq!(error, CatalogError::Timeout);
+        assert!(elapsed >= CATALOG_TIMEOUT);
+        assert!(elapsed < CATALOG_TIMEOUT + Duration::from_secs(2));
+        assert!(observer.exits.is_empty());
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn exact_one_mib_is_allowed_and_one_more_byte_is_rejected() {
+        assert_eq!(MAX_CATALOG_BYTES, 1024 * 1024);
+        let mut observer = Observer::default();
+        let script = format!("exec /usr/bin/head -c {MAX_CATALOG_BYTES} /dev/zero");
+        let output = run(
+            &script, None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap();
+        assert_eq!(output.len() as u64, MAX_CATALOG_BYTES);
+        assert_owned_child_gone(&observer);
+        let mut observer = Observer::default();
+        let script = format!("exec /usr/bin/head -c {} /dev/zero", MAX_CATALOG_BYTES + 1);
+        assert_eq!(
+            run(&script, None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer),
+            Err(CatalogError::OutputTooLarge)
+        );
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn oversized_output_keeps_one_hundred_millisecond_exit_grace() {
+        let mut observer = Observer::default();
+        let started = Instant::now();
+        let error = run(
+            "printf '%65s' x; exec /bin/sleep 30", None, CATALOG_TIMEOUT, 64, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::OutputTooLarge);
+        assert!(started.elapsed() >= Duration::from_millis(100));
+        assert!(started.elapsed() < Duration::from_secs(2));
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn exited_child_with_inherited_stdout_keeps_output_timeout_observation() {
+        let mut observer = Observer::default();
+        let error = run(
+            "/bin/sleep 30 & exit 0", None, Duration::from_millis(200),
+            MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::Timeout);
+        assert_eq!(observer.exits, vec![Some(0)]);
+        assert_eq!(observer.output_timeouts, 1);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn early_eof_polling_keeps_ten_millisecond_anchor_and_then_old_cadence() {
+        let mut elapsed = Duration::ZERO;
+        for (sleep_ms, check_ms) in [(1, 1), (2, 3), (3, 6), (4, 10), (10, 20)] {
+            let interval = catalog_exit_poll_interval(elapsed);
+            assert_eq!(interval, Duration::from_millis(sleep_ms));
+            elapsed += interval;
+            assert_eq!(elapsed, Duration::from_millis(check_ms));
+        }
+        assert_eq!(catalog_exit_poll_interval(Duration::from_micros(9500)), Duration::from_micros(500));
+        assert_eq!(catalog_exit_poll_interval(Duration::from_millis(50)), Duration::from_millis(10));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -173,11 +173,14 @@ impl RealCommandRunner {
         let stdout_thread = std::thread::spawn(move || read_pipe(stdout));
         let stderr_thread = std::thread::spawn(move || read_pipe(stderr));
         let deadline = Instant::now() + COMMAND_TIMEOUT;
+        // Observe short-lived commands promptly; retain the old cadence for long ones.
+        let mut poll_interval = Duration::from_millis(1);
         let status = loop {
             if let Some(status) = child.try_wait()? {
                 break status;
             }
-            if Instant::now() >= deadline {
+            let now = Instant::now();
+            if now >= deadline {
                 child.kill()?;
                 child.wait()?;
                 let _ = join_pipe_reader(stdout_thread)?;
@@ -187,7 +190,8 @@ impl RealCommandRunner {
                     format!("{program} exceeded 5s timeout"),
                 ));
             }
-            std::thread::sleep(Duration::from_millis(25));
+            std::thread::sleep(poll_interval.min(deadline.saturating_duration_since(now)));
+            poll_interval = (poll_interval * 2).min(Duration::from_millis(25));
         };
         let stdout = join_pipe_reader(stdout_thread)?;
         let stderr = join_pipe_reader(stderr_thread)?;
@@ -4315,3 +4319,96 @@ fn non_empty(raw: &str) -> Option<&str> {
 // tmux is a Unix concept), the test module stays Unix-only.
 #[cfg(all(test, unix))]
 mod tests;
+
+#[cfg(all(test, unix))]
+mod command_runner_regressions {
+    use super::{CommandRunner, RealCommandRunner, COMMAND_TIMEOUT};
+    use std::io::ErrorKind;
+    use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+    fn shell(command: &str) -> Vec<String> {
+        vec!["/bin/sh".into(), "-c".into(), command.into()]
+    }
+
+    #[test]
+    fn nonzero_exit_preserves_both_outputs_and_lossy_utf8() {
+        let output = RealCommandRunner
+            .run(&shell("printf 'stdout\\377'; printf 'stderr\\376' >&2; exit 17"))
+            .unwrap();
+        assert!(!output.success);
+        assert_eq!(output.code, Some(17));
+        assert_eq!(output.stdout, "stdout\u{fffd}");
+        assert_eq!(output.stderr, "stderr\u{fffd}");
+    }
+
+    #[test]
+    fn stdin_is_delivered_and_closed_before_waiting_for_exit() {
+        let input = "first line\nsecond λ line\n".repeat(32);
+        let output = RealCommandRunner
+            .run_with_stdin(&["/bin/cat".into()], &input)
+            .unwrap();
+        assert!(output.success);
+        assert_eq!(output.code, Some(0));
+        assert_eq!(output.stdout, input);
+        assert_eq!(output.stderr, "");
+    }
+
+    #[test]
+    fn signal_exit_retains_absent_exit_code() {
+        let output = RealCommandRunner.run(&shell("kill -TERM $$")).unwrap();
+        assert!(!output.success);
+        assert_eq!(output.code, None);
+    }
+
+    #[test]
+    fn drains_stdout_and_stderr_beyond_pipe_capacity() {
+        let output = RealCommandRunner
+            .run(&shell(
+                "i=0; while [ \"$i\" -lt 20000 ]; do printf 'out\\n'; printf 'err\\n' >&2; i=$((i+1)); done",
+            ))
+            .unwrap();
+        assert!(output.success);
+        assert_eq!(output.code, Some(0));
+        assert_eq!(output.stdout, "out\n".repeat(20000));
+        assert_eq!(output.stderr, "err\n".repeat(20000));
+    }
+
+    #[test]
+    fn timeout_keeps_five_second_budget_and_reaps_the_owned_child() {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let pid_path = std::env::temp_dir().join(format!(
+            "team-agent-runner-timeout-{}-{nonce}.pid",
+            std::process::id()
+        ));
+        let file = std::fs::OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&pid_path)
+            .unwrap();
+        drop(file);
+        // exec keeps one owned PID and closes both pipes when the runner kills it.
+        let mut argv = shell("printf '%s' \"$$\" > \"$1\"; exec /bin/sleep 30");
+        argv.extend([
+            "runner-timeout-test".into(),
+            pid_path.to_string_lossy().into_owned(),
+        ]);
+        let started = Instant::now();
+        let error = RealCommandRunner.run(&argv).unwrap_err();
+        let elapsed = started.elapsed();
+        let pid: i32 = std::fs::read_to_string(&pid_path).unwrap().parse().unwrap();
+        std::fs::remove_file(pid_path).unwrap();
+        assert_eq!(error.kind(), ErrorKind::TimedOut);
+        assert!(elapsed >= COMMAND_TIMEOUT);
+        assert!(elapsed < COMMAND_TIMEOUT + Duration::from_secs(2));
+        assert!(pid > 1);
+        // SAFETY: signal 0 only probes the exact child PID recorded by this fixture.
+        assert_eq!(unsafe { libc::kill(pid, 0) }, -1);
+        assert_eq!(
+            std::io::Error::last_os_error().raw_os_error(),
+            Some(libc::ESRCH)
+        );
+    }
+}

package/package.json

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