@team-agent/installer 0.5.74 → 0.5.77

package/Cargo.lock

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

package/README.md

@@ -82,6 +82,15 @@ Subagents are one-shot, fire-and-forget, and can't talk to each other. Team Agen
 
 ## Status
 
+`team-agent status` prints one concise row per registered node with seven fields:
+`name`, `provider`, `runtime_status`, `activity`, `health`, `session_name`, and `tmux_command`.
+`--json` exposes the same projection as structured JSON. Missing or conflicting evidence is
+reported as `unknown`; a non-null `tmux_command` is safe to copy for the observed socket,
+session, window, and pane. `--summary` and `--detail` remain accepted for compatibility and
+do not add diagnostic or history fields. The accepted nodeprobe pairing and
+operator-trusted capability receipt are documented in
+[`docs/status-nodeprobe.md`](docs/status-nodeprobe.md).
+
 **Beta.** Used daily in real projects. Rough edges possible in uncommon configurations. Issues and PRs welcome.
 
 ## License

package/README.zh.md

@@ -82,6 +82,14 @@ subagent 是一次性的、干完即焚、彼此不通信。Team Agent 的队友
 
 ## 状态
 
+`team-agent status` 为每个已登记节点输出七个简要字段：
+`name`、`provider`、`runtime_status`、`activity`、`health`、`session_name`、`tmux_command`。
+`--json` 与人读输出使用同一信息投影。证据缺失或冲突时显示 `unknown`；非空
+`tmux_command` 可复制到已观测的 socket、session、window 和 pane。`--summary` 与
+`--detail` 保留兼容性，但不会增加诊断或历史字段。已验收 nodeprobe 的配对方式、
+operator-trusted 能力 receipt 与 fail-closed 边界见
+[`docs/status-nodeprobe.md`](docs/status-nodeprobe.md)。
+
 **Beta。** 已在真实项目里日常使用,小众配置下可能有毛边。欢迎 issue 和 PR。
 
 ## License

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

@@ -280,8 +280,8 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
     }
 }
 
-/// `cmd_status`(`commands.py:90`)。三态:`--summary`(xor json,xor agent)→五行文本;
-/// `--json`→`status_port::status(compact=!detail)`;else→`status_port::format_status(agent)`。
+/// `cmd_status`(`commands.py:90`)。CLI status 统一为只读七字段 brief；
+/// `--json` 与人读路径共享 nodeprobe-backed projection；`--summary`/`--detail` 保留参数兼容性但不暴露诊断。
 #[cfg(test)]
 pub(crate) fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
     cmd_status_for_team(args, args.team.as_deref())
@@ -300,123 +300,50 @@ pub fn cmd_status_for_team(args: &StatusArgs, team: Option<&str>) -> Result<CmdR
     }
     // S4QR-001 (0.4.8): selected-team ambiguity gate. status is a selected-team
     // command: when the workspace has 2+ alive teams and no --team was passed,
-    // refuse instead of silently defaulting to the active team. Uses the same
-    // CommandScope::resolve helper as refuse_if_multi_alive_team_missing_scope
-    // (cli/emit.rs:964-979) so the destructive-command ambiguity gate and the
-    // selected-team-read ambiguity gate share a single source of truth.
+    // refuse instead of silently defaulting to the active team. Uses the
+    // read-only CommandScope helper so the gate cannot migrate/write state.
     if team.is_none() {
-        let scope = crate::state::paths::CommandScope::resolve(&args.workspace, None);
+        let scope = crate::state::paths::CommandScope::resolve_readonly(&args.workspace, None);
         if scope.is_ambiguous() {
             let candidates: Vec<String> = scope.candidates().to_vec();
             let message = format!(
                 "status: workspace has multiple alive teams ({}); pass `--team <key>` to choose one",
                 candidates.join(", ")
             );
-            if args.json {
-                let payload = serde_json::json!({
-                    "ok": false,
-                    "status": "refused",
-                    "reason": "team_target_ambiguous",
-                    "candidates": candidates,
-                    "message": message,
-                });
-                return Ok(CmdResult::from_json(payload, args.json));
-            }
             return Err(CliError::Usage(message));
         }
     }
-    let selected = match crate::state::selector::resolve_active_team(
+    let selected = crate::state::selector::resolve_active_team_readonly(
         &args.workspace,
         team,
         crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                status_selector_error_payload(&error.to_string(), &args.workspace),
-                args.json,
-            ));
+    )?;
+    if let Some(agent) = args.agent.as_deref() {
+        if !status_port::registered_agent_exists(&selected.state, agent) {
+            return Err(CliError::Runtime(format!("unknown agent id: {agent}")));
         }
-    };
-    if args.summary {
-        // 0.4.x compact slimming: `--summary` renders the five-line triage
-        // text via `format_status_summary`, which needs the full payload
-        // fields (coordinator, leader_receiver, agent_health, queued_messages,
-        // latest_results). The slim compact projection drops those, so the
-        // summary path must request the full payload (compact=false).
-        let value = status_port::status_scoped(
-            &selected.run_workspace,
-            &selected.state,
-            Some(&selected.team_key),
-            false,
-            false,
-        )?;
-        return Ok(CmdResult::human(append_reminder(
-            format_status_summary(&value),
-            crate::cli::STATUS_REMINDER,
-        )));
     }
+    // Status brief is deliberately independent of the legacy RuntimeSnapshot:
+    // it performs one bounded nodeprobe 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 {
-        let value = status_port::status_scoped(
-            &selected.run_workspace,
-            &selected.state,
-            Some(&selected.team_key),
-            status_compact_flag(args.detail),
-            args.detail,
-        )?;
-        return Ok(CmdResult::from_json(value, true));
+        return Ok(CmdResult::from_json(
+            status_port::status_brief_scoped(
+                &selected.run_workspace,
+                &selected.state,
+                args.agent.as_deref(),
+            ),
+            true,
+        ));
     }
-    let mut text = status_port::format_status_scoped(
+    Ok(CmdResult::human(status_port::format_status_brief(
         &selected.run_workspace,
         &selected.state,
-        Some(&selected.team_key),
         args.agent.as_deref(),
-    )?;
-    if args.detail {
-        let value = status_port::status_scoped(
-            &selected.run_workspace,
-            &selected.state,
-            Some(&selected.team_key),
-            false,
-            true,
-        )?;
-        if let Some(hint) = value
-            .pointer("/runtime/hint")
-            .and_then(serde_json::Value::as_str)
-            .filter(|hint| !hint.is_empty())
-        {
-            if !text.is_empty() {
-                text.push('\n');
-            }
-            text.push_str(hint);
-        }
-    }
-    Ok(CmdResult::human(append_reminder(
-        text,
-        crate::cli::STATUS_REMINDER,
     )))
 }
 
-fn status_selector_error_payload(error: &str, workspace: &Path) -> Value {
-    let stamp = chrono::Utc::now().format("%Y%m%d-%H%M%S%.6f");
-    let log_path = std::env::temp_dir()
-        .join("team-agent")
-        .join("cli-errors")
-        .join(format!("status-{stamp}.log"));
-    if let Some(parent) = log_path.parent() {
-        let _ = std::fs::create_dir_all(parent);
-    }
-    let _ = std::fs::write(&log_path, format!("{error}\n"));
-    json!({
-        "ok": false,
-        "error": error,
-        "action": "run `team-agent doctor` or inspect the log path shown here",
-        "log": log_path.to_string_lossy().to_string(),
-        "workspace": workspace.to_string_lossy().to_string(),
-        "reminder": crate::cli::STATUS_REMINDER,
-    })
-}
-
 /// `cmd_watch`(`commands.py:103`)。委派 `coordinator::run_watch`;KeyboardInterrupt/正常 → `SystemExit(0)`。
 /// 返回 [`CmdResult::none`](不经 emit)。
 pub fn cmd_watch(args: &WatchArgs) -> Result<CmdResult, CliError> {

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

@@ -85,10 +85,31 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
     }
     match dispatch(command, &argv[1..], cwd) {
         Ok(exit) => exit,
-        Err(error) => emit_cli_error(command, &argv[1..], cwd, &error),
+        Err(error) => emit_cli_error_for_command(command, &argv[1..], cwd, &error),
     }
 }
 
+fn emit_cli_error_for_command(
+    command: &str,
+    args: &[String],
+    cwd: &Path,
+    error: &CliError,
+) -> ExitCode {
+    if command == "status" {
+        emit_status_cli_error(error)
+    } else {
+        emit_cli_error(command, args, cwd, error)
+    }
+}
+
+fn emit_status_cli_error(error: &CliError) -> ExitCode {
+    let normalized = normalize_cli_error(error);
+    let payload_error = normalized.as_ref().unwrap_or(error);
+    let safe_error = crate::redaction::redact_external_text(&payload_error.to_string());
+    eprintln!("error: {safe_error}");
+    ExitCode::Error
+}
+
 /// Print a handler's CmdResult to stdout (emit formats json/human), then surface its exit code.
 /// (parser.py: `print(emit(result, as_json))` then the ok→exit mapping.)
 fn emit_result(r: CmdResult) -> ExitCode {
@@ -387,7 +408,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默认输出: worker,空闲|工作|错误；错误细分走 status --summary".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("models") => "usage: team-agent models --provider pi [--search TEXT] [--json]\n\nPrints models.v1 exact role_model entries; each entry includes current=true|false. Catalog readiness is reported as auth=ok|not_ready with auth_basis=catalog_visibility.".to_string(),
         Some("stop") => compat_hidden_help("stop", "usage: team-agent stop [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]"),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
@@ -2184,11 +2205,18 @@ mod tests {
     }
 
     #[test]
-    fn status_help_mentions_summary_for_error_details() {
-        assert!(
-            command_help(Some("status")).contains("错误细分走 status --summary"),
-            "status help must tell users where detailed error classes live"
-        );
+    fn status_help_describes_brief_projection_and_unknown_boundary() {
+        let help = command_help(Some("status"));
+        for marker in [
+            "name/provider/runtime_status/activity/health/session_name/tmux_command",
+            "人读与 --json 使用同一投影",
+            "显示 unknown",
+            "tmux_command",
+            "不增加诊断字段",
+        ] {
+            assert!(help.contains(marker), "status help missing {marker}: {help}");
+        }
+        assert!(!help.contains("错误细分走 status --summary"));
     }
 
     #[test]

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

@@ -3633,17 +3633,24 @@ pub mod lifecycle_port {
                 coordinator,
                 next_actions,
                 attach_commands,
-            } => json!({
-                "ok": true,
-                "status": "restarted",
-                "session_name": session_name.as_str(),
-                "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
-                "coordinator_started": coordinator_started,
-                "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
-                "next_actions": next_actions,
-                "attach_commands": attach_commands,
-                "reminder": crate::cli::QUICK_START_REMINDER,
-            }),
+                attach_window_failures,
+            } => {
+                let mut value = json!({
+                    "ok": true,
+                    "status": "restarted",
+                    "session_name": session_name.as_str(),
+                    "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
+                    "coordinator_started": coordinator_started,
+                    "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
+                    "next_actions": next_actions,
+                    "attach_commands": attach_commands,
+                    "reminder": crate::cli::QUICK_START_REMINDER,
+                });
+                if let Some(debt) = attach_window_failures {
+                    value["attach_window_failures"] = debt;
+                }
+                value
+            },
             crate::lifecycle::RestartReport::Partial {
                 session_name,
                 agents,
@@ -3652,35 +3659,42 @@ pub mod lifecycle_port {
                 coordinator,
                 next_actions,
                 attach_commands,
-            } => json!({
-                "ok": false,
-                "status": "partial",
-                "reason": "restart_agent_failed",
-                "session_name": session_name.as_str(),
-                "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
-                "failed_agents": failed_agents.iter().map(|failure| json!({
-                    "agent_id": failure.agent_id.as_str(),
-                    "restart_mode": failure.restart_mode,
-                    "decision": failure.decision,
-                    "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
-                    "phase": failure.phase,
-                    "error": failure.error,
-                    "action": crate::lifecycle::restart_failure_action(
-                        &failure.agent_id,
-                        &failure.phase,
-                        failure.session_id.as_ref(),
-                    ),
-                    "log": format!(
-                        ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
-                        failure.agent_id
-                    ),
-                })).collect::<Vec<_>>(),
-                "coordinator_started": coordinator_started,
-                "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
-                "next_actions": next_actions,
-                "attach_commands": attach_commands,
-                "reminder": crate::cli::QUICK_START_REMINDER,
-            }),
+                attach_window_failures,
+            } => {
+                let mut value = json!({
+                    "ok": false,
+                    "status": "partial",
+                    "reason": "restart_agent_failed",
+                    "session_name": session_name.as_str(),
+                    "agents": agents.iter().map(|a| a.agent_id.as_str()).collect::<Vec<_>>(),
+                    "failed_agents": failed_agents.iter().map(|failure| json!({
+                        "agent_id": failure.agent_id.as_str(),
+                        "restart_mode": failure.restart_mode,
+                        "decision": failure.decision,
+                        "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
+                        "phase": failure.phase,
+                        "error": failure.error,
+                        "action": crate::lifecycle::restart_failure_action(
+                            &failure.agent_id,
+                            &failure.phase,
+                            failure.session_id.as_ref(),
+                        ),
+                        "log": format!(
+                            ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
+                            failure.agent_id
+                        ),
+                    })).collect::<Vec<_>>(),
+                    "coordinator_started": coordinator_started,
+                    "coordinator": crate::lifecycle::coordinator_start_summary_value(&coordinator),
+                    "next_actions": next_actions,
+                    "attach_commands": attach_commands,
+                    "reminder": crate::cli::QUICK_START_REMINDER,
+                });
+                if let Some(debt) = attach_window_failures {
+                    value["attach_window_failures"] = debt;
+                }
+                value
+            },
             crate::lifecycle::RestartReport::Failed {
                 session_name,
                 failed_agents,
@@ -5260,11 +5274,14 @@ pub mod leader_port {
         if let Some(topology_convergence) = result.topology_convergence {
             out.insert("topology_convergence".to_string(), topology_convergence);
         }
+        if let Some(attach_window_failures) = result.attach_window_failures {
+            out.insert("attach_window_failures".to_string(), attach_window_failures);
+        }
         Value::Object(out)
     }
 
     fn attach_lease_value(result: crate::leader::LeaseResult, requeued: Value) -> Value {
-        json!({
+        let mut value = json!({
             "ok": result.ok,
             "leader_receiver": result
                 .receiver
@@ -5277,7 +5294,11 @@ pub mod leader_port {
                 "action": result.action,
             },
             "requeued_exhausted_watchers": requeued,
-        })
+        });
+        if let Some(attach_window_failures) = result.attach_window_failures {
+            value["attach_window_failures"] = attach_window_failures;
+        }
+        value
     }
 
     fn attach_requeued_exhausted_watchers(

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

@@ -1,6 +1,8 @@
 //! Read-only Pi model catalog discovery for `team-agent models`.
 use super::{CliError, CmdOutput, CmdResult, ExitCode, ModelsArgs};
 use serde_json::{json, Value};
+#[cfg(test)]
+use std::collections::BTreeMap;
 use std::path::Path;
 use std::process::Command;
 use std::time::Duration;
@@ -272,6 +274,66 @@ mod tests {
         let _ = std::fs::remove_dir_all(path.parent().unwrap());
     }
 
+    #[cfg(unix)]
+    fn native_timeout_fixture() -> std::path::PathBuf {
+        let path = std::path::PathBuf::from(env!("TEAM_AGENT_MODELS_TIMEOUT_FIXTURE"));
+        assert!(path.is_file(), "prebuilt models timeout fixture is missing");
+        path
+    }
+
+    #[cfg(unix)]
+    fn native_timeout_receipt() -> std::path::PathBuf {
+        let stamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        std::path::PathBuf::from("/tmp").join(format!(
+            "team-agent-models-timeout-{}-{stamp}.receipt",
+            std::process::id()
+        ))
+    }
+
+    #[cfg(unix)]
+    fn read_native_timeout_receipt(path: &Path) -> BTreeMap<String, String> {
+        let mut fields = BTreeMap::new();
+        for line in std::fs::read_to_string(path).unwrap().lines() {
+            let (key, value) = line.split_once('=').expect("receipt key/value");
+            assert!(fields.insert(key.to_string(), value.to_string()).is_none());
+        }
+        assert_eq!(
+            fields.keys().map(String::as_str).collect::<Vec<_>>(),
+            vec![
+                "child_argv_exact",
+                "child_pid",
+                "child_spawn_attempts",
+                "descendant_pid",
+                "descendant_started",
+                "descendant_stdout_inherited",
+                "parent_argv_exact",
+                "parent_pid",
+                "parent_started_once",
+            ]
+        );
+        fields
+    }
+
+    #[cfg(unix)]
+    fn with_native_mode<T>(
+        mode: &str,
+        action: impl FnOnce() -> T,
+    ) -> (T, crate::lifecycle::launch::pi_mcp::PiCatalogTestObservation) {
+        let receipt = native_timeout_receipt();
+        assert!(!receipt.exists());
+        let result = crate::lifecycle::launch::pi_mcp::with_pi_catalog_test_observation(
+            &receipt,
+            Some(mode),
+            action,
+        );
+        assert!(!receipt.exists());
+        let _ = std::fs::remove_file(format!("{}.sock", receipt.display()));
+        result
+    }
+
     #[cfg(unix)]
     #[test]
     fn runner_invokes_exact_argv_once_and_drains() {
@@ -291,12 +353,38 @@ mod tests {
     #[cfg(unix)]
     #[test]
     fn runner_timeout_is_bounded_when_descendant_keeps_stdout() {
-        let path = fixture("sleep 2 & exit 0");
+        let path = native_timeout_fixture();
+        let receipt = native_timeout_receipt();
+        assert!(!receipt.exists());
         let started = Instant::now();
-        let result = run_catalog(&path, Duration::from_millis(40), 1024);
+        let (result, observation) =
+            crate::lifecycle::launch::pi_mcp::with_pi_catalog_test_observation(
+                &receipt,
+                Some("descendant"),
+                || run_catalog(&path, Duration::from_millis(40), 1024),
+            );
         assert!(started.elapsed() < Duration::from_millis(500));
         assert!(result.unwrap_err().contains("timed out"));
-        cleanup_fixture(&path);
+        assert_eq!(observation.spawn_count, 1);
+        assert_eq!(observation.argv, vec!["--list-models"]);
+        assert_eq!(observation.parent_exit_success, Some(true));
+        assert_eq!(observation.parent_exit_code, Some(0));
+        assert!(observation.reader_timeout);
+
+        let fields = read_native_timeout_receipt(&receipt);
+        assert_eq!(fields["parent_started_once"], "1");
+        assert_eq!(fields["parent_argv_exact"], "1");
+        assert_eq!(fields["child_spawn_attempts"], "1");
+        assert_eq!(fields["child_argv_exact"], "1");
+        assert_eq!(fields["descendant_started"], "1");
+        assert_eq!(fields["descendant_stdout_inherited"], "1");
+        assert_eq!(
+            fields["parent_pid"],
+            observation.parent_pid.unwrap().to_string()
+        );
+        assert_eq!(fields["child_pid"], fields["descendant_pid"]);
+        let _ = std::fs::remove_file(&receipt);
+        let _ = std::fs::remove_file(format!("{}.sock", receipt.display()));
     }
 
     #[cfg(unix)]
@@ -352,35 +440,61 @@ mod tests {
     #[cfg(unix)]
     #[test]
     fn runner_fails_closed_for_nonzero_oversize_timeout_and_unavailable() {
-        let fail = fixture("echo sensitive-token >&2; exit 7");
+        let fail = native_timeout_fixture();
+        let (failed_result, fail_observation) = with_native_mode("exit7", || {
+            run_catalog(&fail, Duration::from_secs(1), 1024)
+        });
         assert_eq!(
-            run_catalog(&fail, Duration::from_secs(1), 1024).unwrap_err(),
+            failed_result.unwrap_err(),
             "Pi model catalog command failed"
         );
-        let failed = cmd_models_with(
-            &ModelsArgs {
-                provider: "pi".into(),
-                search: None,
-                json: false,
-            },
-            &fail,
-            Duration::from_secs(1),
-            1024,
-        )
-        .unwrap();
+        assert_eq!(fail_observation.spawn_count, 1);
+        assert_eq!(fail_observation.argv, vec!["--list-models"]);
+        assert_eq!(fail_observation.parent_exit_success, Some(false));
+        assert_eq!(fail_observation.parent_exit_code, Some(7));
+        assert!(!fail_observation.reader_timeout);
+        let (failed, failed_observation) = with_native_mode("exit7", || {
+            cmd_models_with(
+                &ModelsArgs {
+                    provider: "pi".into(),
+                    search: None,
+                    json: false,
+                },
+                &fail,
+                Duration::from_secs(1),
+                1024,
+            )
+        });
+        let failed = failed.unwrap();
+        assert_eq!(failed_observation.spawn_count, 1);
+        assert_eq!(failed_observation.argv, vec!["--list-models"]);
+        assert_eq!(failed_observation.parent_exit_success, Some(false));
+        assert_eq!(failed_observation.parent_exit_code, Some(7));
+        assert!(!failed_observation.reader_timeout);
         let CmdOutput::Human(text) = failed.output else {
             panic!("expected failure projection")
         };
         assert_eq!(failed.exit, ExitCode::Error);
         assert!(!text.contains("sensitive-token"));
-        let big = fixture("head -c 64 /dev/zero");
-        assert!(run_catalog(&big, Duration::from_secs(1), 8)
-            .unwrap_err()
-            .contains("bounded output"));
-        let slow = fixture("sleep 2");
-        assert!(run_catalog(&slow, Duration::from_millis(20), 1024)
-            .unwrap_err()
-            .contains("timed out"));
+        let big = native_timeout_fixture();
+        let (big_result, big_observation) = with_native_mode("oversize", || {
+            run_catalog(&big, Duration::from_secs(1), 8)
+        });
+        assert!(big_result.unwrap_err().contains("bounded output"));
+        assert_eq!(big_observation.spawn_count, 1);
+        assert_eq!(big_observation.argv, vec!["--list-models"]);
+        assert_eq!(big_observation.parent_exit_success, Some(true));
+        assert_eq!(big_observation.parent_exit_code, Some(0));
+        assert!(!big_observation.reader_timeout);
+        let slow = native_timeout_fixture();
+        let (slow_result, slow_observation) = with_native_mode("sleep", || {
+            run_catalog(&slow, Duration::from_millis(20), 1024)
+        });
+        assert!(slow_result.unwrap_err().contains("timed out"));
+        assert_eq!(slow_observation.spawn_count, 1);
+        assert_eq!(slow_observation.argv, vec!["--list-models"]);
+        assert_eq!(slow_observation.parent_exit_success, None);
+        assert!(!slow_observation.reader_timeout);
         assert!(run_catalog(
             std::path::Path::new("/does/not/exist"),
             Duration::from_secs(1),
@@ -388,9 +502,6 @@ mod tests {
         )
         .unwrap_err()
         .contains("unavailable"));
-        for path in [fail, big, slow] {
-            cleanup_fixture(&path);
-        }
     }
 
     #[test]