@team-agent/installer 0.5.100 → 0.5.102

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

@@ -1,9 +1,8 @@
 use crate::cli::spec::{CommandKind, COMMAND_SPECS};
 use crate::compiler::compile_role_agent;
 use crate::lifecycle::launch::pi_mcp::parse_pi_leader_args;
-use crate::mcp_server::TeamOrchestratorTools;
 use crate::model::enums::{AuthMode, Provider, ProviderEffort};
-use crate::model::ids::{AgentId, TeamKey};
+use crate::model::ids::AgentId;
 use crate::model::yaml::Value;
 use crate::provider::{get_adapter, ProviderCommandContext};
 use crate::transport::test_support::OfflineTransport;
@@ -44,71 +43,6 @@ fn run_process_isolated(marker: &str, test_name: &str, body: impl FnOnce()) {
     );
 }
 
-#[cfg(unix)]
-const FILE_H_NATIVE_COMPILE_DEADLINE: std::time::Duration = std::time::Duration::from_secs(15);
-#[cfg(unix)]
-const FILE_H_NATIVE_READINESS_DEADLINE: std::time::Duration = std::time::Duration::from_secs(3);
-
-#[cfg(unix)]
-#[derive(Debug)]
-struct FileHCommandTimeout {
-    stage: &'static str,
-    pid: u32,
-    deadline: std::time::Duration,
-    elapsed: std::time::Duration,
-    reaped_status: std::process::ExitStatus,
-}
-
-#[cfg(unix)]
-fn run_file_h_command_with_deadline(
-    command: &mut std::process::Command,
-    stage: &'static str,
-    deadline: std::time::Duration,
-    stdout_path: &Path,
-    stderr_path: &Path,
-) -> Result<std::process::Output, FileHCommandTimeout> {
-    let stdout_file = std::fs::File::create(stdout_path)
-        .unwrap_or_else(|error| panic!("{stage}: create stdout receipt failed: {error}"));
-    let stderr_file = std::fs::File::create(stderr_path)
-        .unwrap_or_else(|error| panic!("{stage}: create stderr receipt failed: {error}"));
-    let mut child = command
-        .stdout(std::process::Stdio::from(stdout_file))
-        .stderr(std::process::Stdio::from(stderr_file))
-        .spawn()
-        .unwrap_or_else(|error| panic!("{stage}: spawn failed: {error}"));
-    let pid = child.id();
-    let started = std::time::Instant::now();
-    loop {
-        if let Some(status) = child
-            .try_wait()
-            .unwrap_or_else(|error| panic!("{stage}: poll pid {pid} failed: {error}"))
-        {
-            return Ok(std::process::Output {
-                status,
-                stdout: std::fs::read(stdout_path).unwrap_or_default(),
-                stderr: std::fs::read(stderr_path).unwrap_or_default(),
-            });
-        }
-        let elapsed = started.elapsed();
-        if elapsed >= deadline {
-            child
-                .kill()
-                .unwrap_or_else(|error| panic!("{stage}: kill exact pid {pid} failed: {error}"));
-            let reaped_status = child
-                .wait()
-                .unwrap_or_else(|error| panic!("{stage}: reap exact pid {pid} failed: {error}"));
-            return Err(FileHCommandTimeout {
-                stage,
-                pid,
-                deadline,
-                elapsed,
-                reaped_status,
-            });
-        }
-        std::thread::park_timeout(std::time::Duration::from_millis(10));
-    }
-}
-
 fn dynamic_add_fixture(root: &Path, label: &str, role_doc: &str) -> (PathBuf, PathBuf) {
     let team = root.join(label);
     std::fs::create_dir_all(team.join("agents")).expect("create dynamic team fixture");
@@ -287,10 +221,13 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     .expect("write provider-default teammate role");
     let defaults = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace")
         .expect("provider: pi teammate may use Pi model and effort defaults");
-    assert_eq!(defaults.agent.get("model"), Some(&Value::Null));
-    assert!(
-        defaults.agent.get("effort").is_none(),
-        "omitted Pi model and effort must remain absent"
+    assert_eq!(
+        defaults.agent.get("model"),
+        Some(&Value::Str("openai-codex/gpt-6-luna".to_string()))
+    );
+    assert_eq!(
+        defaults.agent.get("effort"),
+        Some(&Value::Str("max".to_string()))
     );
     std::fs::remove_dir_all(root).expect("remove role fixture");
 
@@ -572,336 +509,6 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
         crate::state::persist::load_runtime_state(&dead_team).expect("load dead rollback state");
     assert!(dead_state.pointer("/agents/mate").is_none());
 
-    #[cfg(unix)]
-    {
-        let live = dynamic_root.join("live-public-add");
-        std::fs::create_dir_all(live.join("agents")).expect("create live agents dir");
-        std::fs::create_dir_all(live.join("roles")).expect("create live roles dir");
-        std::fs::write(
-            live.join("TEAM.md"),
-            "---\nname: current\nobjective: Public no-spec add fixture.\nprovider: fake\n---\n\nfixture\n",
-        )
-        .expect("write live TEAM.md");
-        std::fs::write(
-            live.join("agents/implementer.md"),
-            "---\nname: implementer\nrole: Existing Worker\nprovider: fake\nmodel: fake\nauth_mode: subscription\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n---\n\nexisting\n",
-        )
-        .expect("write live existing role");
-        std::fs::write(live.join("roles/mate.md"), fake_role).expect("write live add role");
-        let live_socket = "/private/tmp/tmux-501/ta-live-owning";
-        let live_session = "team-agent-leader-pi-live-owning";
-        crate::state::persist::save_runtime_state(
-            &live,
-            &json!({
-                "active_team_key": "current",
-                "tmux_endpoint": worker_socket,
-                "tmux_socket": worker_socket,
-                "agents": {
-                    "implementer": {
-                        "status": "running",
-                        "provider": "fake",
-                        "model": "fake",
-                        "auth_mode": "subscription",
-                        "window": "implementer"
-                    }
-                },
-                "teams": {
-                    "current": {
-                        "status": "alive",
-                        "team_dir": live,
-                        "session_name": null,
-                        "tmux_endpoint": worker_socket,
-                        "tmux_socket": worker_socket,
-                        "agents": {
-                            "implementer": {
-                                "status": "running",
-                                "provider": "fake",
-                                "model": "fake",
-                                "auth_mode": "subscription",
-                                "window": "implementer"
-                            }
-                        },
-                        "leader_receiver": {
-                            "status": "attached",
-                            "session_name": live_session,
-                            "tmux_socket": live_socket
-                        }
-                    },
-                    "sibling": {
-                        "status": "alive",
-                        "team_dir": live.join("sibling"),
-                        "session_name": null,
-                        "agents": {},
-                        "leader_receiver": {
-                            "status": "attached",
-                            "session_name": "team-agent-leader-pi-sibling",
-                            "tmux_socket": "/private/tmp/tmux-501/ta-live-sibling"
-                        }
-                    }
-                }
-            }),
-        )
-        .expect("seed live nested receiver");
-        super::launch_spawn::seed_healthy_coordinator(&live);
-        let runtime_spec = crate::model::paths::runtime_spec_path(&live, "current");
-        assert!(
-            !runtime_spec.exists(),
-            "fixture must enter the TEAM.md fallback before runtime spec exists"
-        );
-
-        let shim_root = live.join("tmux-shim");
-        std::fs::create_dir_all(&shim_root).expect("create tmux shim dir");
-        let shim_log = shim_root.join("argv.log");
-        let shim_source = shim_root.join("tmux.c");
-        let shim = shim_root.join("tmux");
-        std::fs::write(
-            &shim_source,
-            r#"#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-static int has_arg(int argc, char **argv, const char *needle) {
-    for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], needle) == 0) return 1;
-    }
-    return 0;
-}
-
-int main(int argc, char **argv) {
-    if (getenv("TEAM_AGENT_PI_TEST_HANG") != NULL) for (;;) pause();
-    const char *log_path = getenv("TEAM_AGENT_PI_TMUX_LOG");
-    const char *socket = getenv("TEAM_AGENT_PI_OWNING_SOCKET");
-    const char *session = getenv("TEAM_AGENT_PI_OWNING_SESSION");
-    const char *workspace = getenv("TEAM_AGENT_PI_RUN_WORKSPACE");
-    FILE *log = log_path == NULL ? NULL : fopen(log_path, "a");
-    if (log == NULL || socket == NULL || session == NULL || workspace == NULL) return 92;
-    for (int i = 1; i < argc; i++) fprintf(log, "%s%s", i == 1 ? "" : " ", argv[i]);
-    fputc('\n', log);
-    fclose(log);
-
-    int owns_socket = 0;
-    for (int i = 1; i + 1 < argc; i++) {
-        if (strcmp(argv[i], "-S") == 0 && strcmp(argv[i + 1], socket) == 0) owns_socket = 1;
-    }
-    if (!owns_socket) return 91;
-    if (has_arg(argc, argv, "new-window") || has_arg(argc, argv, "display-message")) {
-        puts("%9101");
-    } else if (has_arg(argc, argv, "list-panes")) {
-        printf("%%9101__TA_FIELD__%s__TA_FIELD__0__TA_FIELD__mate__TA_FIELD__0__TA_FIELD__/dev/ttys099__TA_FIELD__sh__TA_FIELD__1__TA_FIELD__%s__TA_FIELD__1__TA_FIELD__0__TA_FIELD__9101__TA_FIELD__\n", session, workspace);
-    }
-    return 0;
-}
-"#,
-        )
-        .expect("write native tmux shim source");
-        let compile = run_file_h_command_with_deadline(
-            std::process::Command::new("cc")
-                .args(["-O0", "-o"])
-                .arg(&shim)
-                .arg(&shim_source),
-            "File-H native fake compile",
-            FILE_H_NATIVE_COMPILE_DEADLINE,
-            &shim_root.join("compile.stdout"),
-            &shim_root.join("compile.stderr"),
-        )
-        .unwrap_or_else(|timeout| panic!("{timeout:?}"));
-        assert!(
-            compile.status.success(),
-            "native tmux shim compile failed: {}",
-            String::from_utf8_lossy(&compile.stderr)
-        );
-        let tooth_started = std::time::Instant::now();
-        let tooth = run_file_h_command_with_deadline(
-            std::process::Command::new(&shim).env("TEAM_AGENT_PI_TEST_HANG", "1"),
-            "File-H native fake readiness timeout tooth",
-            FILE_H_NATIVE_READINESS_DEADLINE,
-            &shim_root.join("readiness-tooth.stdout"),
-            &shim_root.join("readiness-tooth.stderr"),
-        )
-        .expect_err("non-exiting native fake must hit the readiness deadline");
-        assert_eq!(tooth.stage, "File-H native fake readiness timeout tooth");
-        assert_eq!(tooth.deadline, FILE_H_NATIVE_READINESS_DEADLINE);
-        assert!(!tooth.reaped_status.success(), "{tooth:?}");
-        assert!(
-            !crate::platform::process::pid_is_alive(tooth.pid),
-            "readiness timeout must leave its exact child dead and reaped: {tooth:?}"
-        );
-        assert!(
-            tooth_started.elapsed()
-                <= FILE_H_NATIVE_READINESS_DEADLINE + std::time::Duration::from_secs(1),
-            "readiness timeout tooth exceeded its deadline plus reap allowance: {tooth:?}"
-        );
-
-        let preflight = run_file_h_command_with_deadline(
-            std::process::Command::new(&shim)
-                .args(["-S", worker_socket, "has-session"])
-                .env("TEAM_AGENT_PI_TMUX_LOG", shim_root.join("preflight.log"))
-                .env("TEAM_AGENT_PI_OWNING_SOCKET", worker_socket)
-                .env("TEAM_AGENT_PI_OWNING_SESSION", live_session)
-                .env("TEAM_AGENT_PI_RUN_WORKSPACE", &live),
-            "File-H native fake has-session preflight",
-            FILE_H_NATIVE_READINESS_DEADLINE,
-            &shim_root.join("preflight.stdout"),
-            &shim_root.join("preflight.stderr"),
-        )
-        .unwrap_or_else(|timeout| panic!("{timeout:?}"));
-        assert!(
-            preflight.status.success(),
-            "native tmux shim preflight failed: {}",
-            String::from_utf8_lossy(&preflight.stderr)
-        );
-        let previous_path = std::env::var_os("PATH").unwrap_or_default();
-        let joined_path = std::env::join_paths(
-            std::iter::once(shim_root.clone()).chain(std::env::split_paths(&previous_path)),
-        )
-        .expect("join native shim PATH");
-        let _path = EnvVarGuard::set("PATH", joined_path);
-        let _log = EnvVarGuard::set("TEAM_AGENT_PI_TMUX_LOG", &shim_log);
-        let _socket = EnvVarGuard::set("TEAM_AGENT_PI_OWNING_SOCKET", worker_socket);
-        let _session = EnvVarGuard::set("TEAM_AGENT_PI_OWNING_SESSION", live_session);
-        let _workspace = EnvVarGuard::set("TEAM_AGENT_PI_RUN_WORKSPACE", &live);
-
-        let tools = TeamOrchestratorTools::with_identity(
-            &live,
-            Some(AgentId::new("leader")),
-            Some(TeamKey::new("current")),
-        );
-        let result = tools
-            .add_agent("mate", "roles/mate.md")
-            .expect("public MCP add must use the persisted worker endpoint");
-        assert_eq!(
-            result.fields.get("ok").and_then(serde_json::Value::as_bool),
-            Some(true)
-        );
-        let tmux_argv = std::fs::read_to_string(&shim_log).expect("read tmux shim log");
-        assert!(
-            tmux_argv.contains(&format!("-S {worker_socket}")),
-            "public add must address the persisted worker socket: {tmux_argv}"
-        );
-        assert!(
-            tmux_argv.contains(&format!(
-                "new-window -d -P -F #{{pane_id}} -t {live_session} -n mate"
-            )),
-            "public add must reuse the owner session with new-window: {tmux_argv}"
-        );
-        assert!(
-            tmux_argv.contains(&live.to_string_lossy().to_string()),
-            "spawn command must retain the MCP scratch as cwd: {tmux_argv}"
-        );
-        assert!(
-            !tmux_argv.contains("new-session"),
-            "public add must not start a same-named session on another server: {tmux_argv}"
-        );
-        let parent_socket = crate::tmux_backend::socket_name_for_workspace(
-            live.parent().expect("live scratch parent"),
-        );
-        assert!(
-            !tmux_argv.contains(&parent_socket),
-            "public add must not derive transport from the scratch parent: {tmux_argv}"
-        );
-
-        let added_state = crate::state::persist::load_runtime_state(&live)
-            .expect("load public add state for send/status");
-        assert_eq!(
-            added_state
-                .pointer("/teams/current/session_name")
-                .and_then(serde_json::Value::as_str),
-            Some(live_session),
-            "dynamic add must persist the selected receiver session for shared send/status routing"
-        );
-        assert!(
-            added_state
-                .pointer("/teams/sibling/session_name")
-                .is_some_and(serde_json::Value::is_null),
-            "selected-team routing must not borrow or rewrite a sibling session: {added_state}"
-        );
-        assert_eq!(
-            added_state
-                .pointer("/teams/sibling/leader_receiver/session_name")
-                .and_then(serde_json::Value::as_str),
-            Some("team-agent-leader-pi-sibling")
-        );
-
-        let mut old_state = added_state.clone();
-        old_state["teams"]["current"]["session_name"] = serde_json::Value::Null;
-        crate::state::persist::save_runtime_state(&live, &old_state)
-            .expect("seed controlled old null-session view");
-        let blocked = tools
-            .send_message(
-                &crate::messaging::MessageTarget::Single("mate".to_string()),
-                "controlled old session routing probe",
-                None,
-                None,
-                None,
-            )
-            .expect("old public send must return a structured refusal")
-            .to_value();
-        assert_eq!(blocked.get("ok"), Some(&json!(false)), "{blocked}");
-        assert_eq!(
-            blocked.get("reason"),
-            Some(&json!("tmux_target_missing")),
-            "the old null-session view must fail at real send target resolution: {blocked}"
-        );
-        let old_status = tools
-            .get_team_status()
-            .expect("old public status must return an honest dead view");
-        assert_eq!(
-            old_status
-                .fields
-                .get("agents")
-                .and_then(|agents| agents.get("mate"))
-                .and_then(|mate| mate.get("stale_reason"))
-                .and_then(serde_json::Value::as_str),
-            Some("pane_dead"),
-            "the old null-session view must fail at real status liveness resolution: {:?}",
-            old_status.fields
-        );
-        crate::state::persist::save_runtime_state(&live, &added_state)
-            .expect("restore corrected selected-team session");
-
-        let sent = tools
-            .send_message(
-                &crate::messaging::MessageTarget::Single("mate".to_string()),
-                "session routing probe",
-                None,
-                None,
-                None,
-            )
-            .expect("public send must resolve the added mate")
-            .to_value();
-        assert_eq!(sent.get("status"), Some(&json!("accepted")), "{sent}");
-        assert!(
-            sent.get("message_id")
-                .and_then(serde_json::Value::as_str)
-                .is_some_and(|message_id| message_id.starts_with("msg_")),
-            "blocked target resolution must not be reported as a successful send: {sent}"
-        );
-
-        let status = tools
-            .get_team_status()
-            .expect("public status must resolve the selected owner session");
-        assert_eq!(
-            status
-                .fields
-                .get("session_name")
-                .and_then(serde_json::Value::as_str),
-            Some(live_session),
-            "status must report the selected receiver session"
-        );
-        assert_ne!(
-            status
-                .fields
-                .get("agents")
-                .and_then(|agents| agents.get("mate"))
-                .and_then(|mate| mate.get("stale_reason"))
-                .and_then(serde_json::Value::as_str),
-            Some("pane_dead"),
-            "the live owner-session mate must not be reported pane_dead: {:?}",
-            status.fields
-        );
-    }
-
     let shared_source = include_str!("../launch/pi_mcp.rs");
     let leader_source = include_str!("../../leader/start.rs");
     let teammate_source = include_str!("../launch/spawn.rs");

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

@@ -372,7 +372,7 @@ fn pi_leader_wrapper_materializes_from_empty_unicode_wsl_workspace() {
         team_id: "current",
         agent_id: "leader",
         workspace: &workspace,
-        include_tools: &["assign_task", "send_message"],
+        include_tools: &["send_message", "report_result", "get_team_status"],
     })
     .expect("materialize Pi leader wrapper from an empty Unicode workspace");
 
@@ -437,7 +437,7 @@ fn pi_wrapper_publish_needs_no_final_path_metadata_lookup() {
             team_id: "current",
             agent_id: "leader",
             workspace: &workspace,
-            include_tools: &["assign_task", "send_message"],
+            include_tools: &["send_message", "report_result", "get_team_status"],
         },
         |temp, destination| {
             std::fs::rename(temp, destination)?;