@team-agent/installer 0.5.106 → 0.5.108

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

@@ -1,13 +1,9 @@
 use super::launch_spawn::seed_healthy_coordinator;
 use super::*;
-use crate::cli::{
-    cmd_doctor, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DoctorArgs,
-    SendArgs, StatusArgs,
-};
+use crate::cli::{cmd_doctor, CmdOutput, CmdResult, DoctorArgs};
 use crate::transport::test_support::OfflineTransport;
-use crate::transport::{PaneId, PaneInfo, SessionName, WindowName};
 use serde_json::{json, Map, Value};
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
@@ -96,91 +92,6 @@ fn hermetic_caller_envs() -> &'static [&'static str] {
     ]
 }
 
-#[test]
-#[ignore = "legacy display-backed phase golden fixture superseded by silent tmux runtime"]
-#[serial_test::serial(env)]
-fn phase_b_golden_events_state_status_zero_drift() {
-    let baseline = phase_fixture_path("phase_b").join("golden.json");
-    let actual = run_phase_golden(PhaseGolden {
-        phase: "phase_b",
-        team_key: "teamdir",
-        lifecycle_op: phase_b_reset_discard_session,
-    });
-    let expected = load_phase_golden(&baseline);
-    assert_eq!(
-        actual, expected,
-        "phase B golden drift; surgical key edits only — do not regenerate the file"
-    );
-}
-
-#[test]
-#[ignore = "legacy display-backed phase golden fixture superseded by silent tmux runtime"]
-#[serial_test::serial(env)]
-fn phase_c_golden_events_state_status_zero_drift() {
-    let baseline = phase_fixture_path("phase_c").join("golden.json");
-    let actual = run_phase_golden(PhaseGolden {
-        phase: "phase_c",
-        team_key: "teamdir",
-        lifecycle_op: phase_b_reset_discard_session,
-    });
-    let expected = load_phase_golden(&baseline);
-    assert_eq!(
-        actual, expected,
-        "phase C golden drift; surgical key edits only — do not regenerate the file"
-    );
-}
-
-#[test]
-#[ignore = "legacy display-backed phase golden fixture superseded by silent tmux runtime"]
-#[serial_test::serial(env)]
-fn phase_d_golden_events_state_status_zero_drift() {
-    let baseline = phase_fixture_path("phase_d").join("golden.json");
-    let actual = run_phase_golden(PhaseGolden {
-        phase: "phase_d",
-        team_key: "teamdir",
-        lifecycle_op: phase_b_reset_discard_session,
-    });
-    let expected = load_phase_golden(&baseline);
-    assert_eq!(
-        actual, expected,
-        "phase D golden drift; surgical key edits only — do not regenerate the file"
-    );
-}
-
-#[test]
-#[ignore = "legacy display-backed phase golden fixture superseded by silent tmux runtime"]
-#[serial_test::serial(env)]
-fn phase_e_golden_events_state_status_zero_drift() {
-    let baseline = phase_fixture_path("phase_e").join("golden.json");
-    let actual = run_phase_golden(PhaseGolden {
-        phase: "phase_e",
-        team_key: "teamdir",
-        lifecycle_op: phase_b_reset_discard_session,
-    });
-    let expected = load_phase_golden(&baseline);
-    assert_eq!(
-        actual, expected,
-        "phase E golden drift; surgical key edits only — do not regenerate the file"
-    );
-}
-
-#[test]
-#[ignore = "legacy display-backed phase golden fixture superseded by silent tmux runtime"]
-#[serial_test::serial(env)]
-fn phase_f_golden_events_state_status_zero_drift() {
-    let baseline = phase_fixture_path("phase_f").join("golden.json");
-    let actual = run_phase_golden(PhaseGolden {
-        phase: "phase_f",
-        team_key: "teamdir",
-        lifecycle_op: phase_b_reset_discard_session,
-    });
-    let expected = load_phase_golden(&baseline);
-    assert_eq!(
-        actual, expected,
-        "phase F golden drift; surgical key edits only — do not regenerate the file"
-    );
-}
-
 #[test]
 #[serial_test::serial(env)]
 fn phase_golden_unbound_not_ready_requires_claim_leader() {
@@ -221,202 +132,6 @@ fn phase_golden_unbound_not_ready_requires_claim_leader() {
     );
 }
 
-#[derive(Clone, Copy)]
-struct PhaseGolden {
-    phase: &'static str,
-    team_key: &'static str,
-    lifecycle_op: fn(&Path, &OfflineTransport, &'static str) -> Value,
-}
-
-fn run_phase_golden(spec: PhaseGolden) -> Value {
-    let hermetic = HermeticTestEnv::enter(spec.phase);
-    let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");
-    let team = two_worker_team_dir(&hermetic);
-    let workspace = team.parent().expect("workspace").to_path_buf();
-    seed_healthy_coordinator(&workspace);
-    let _caller_pane = EnvVarGuard::set("TMUX_PANE", "%caller");
-    let launch_transport = codex_ready_transport().with_targets(vec![PaneInfo {
-        pane_id: PaneId::new("%caller"),
-        session: SessionName::new("caller"),
-        window_index: Some(0),
-        window_name: Some(WindowName::new("caller")),
-        pane_index: Some(0),
-        tty: None,
-        current_command: Some("codex".to_string()),
-        current_path: Some(workspace.clone()),
-        active: true,
-        pane_pid: None,
-        leader_env: BTreeMap::new(),
-    }])
-    .with_pane_current_command("%caller", "codex");
-    let quick_start = quick_start_with_transport_in_workspace(
-        &workspace,
-        &team,
-        None,
-        true,
-        None,
-        &launch_transport,
-    );
-    let status_compact = cmd_status(&StatusArgs {
-        agent: None,
-        workspace: workspace.clone(),
-        detail: false,
-        summary: false,
-        json: true,
-        team: Some(spec.team_key.to_string()),
-    });
-    let status_detail = cmd_status(&StatusArgs {
-        agent: None,
-        workspace: workspace.clone(),
-        detail: true,
-        summary: false,
-        json: true,
-        team: Some(spec.team_key.to_string()),
-    });
-    let send = cmd_send(&SendArgs {
-        target: Some("w1".to_string()),
-        message: vec!["phase".to_string(), "golden".to_string()],
-        targets: None,
-        workspace: workspace.clone(),
-        team: Some(spec.team_key.to_string()),
-        task: None,
-        sender: crate::messaging::TrustedSender::leader(),
-        no_ack: true,
-        no_wait: true,
-        watch_result: false,
-        timeout: 0.1,
-        confirm_human: false,
-        json: true,
-        message_id: Some("phase-golden-message".to_string()),
-        presentation: crate::messaging::presentation::PresentationRequest::default(),
-        pane: None,
-        to_name: None,
-        to_leader: None,
-    });
-    let runtime_state = crate::state::persist::load_runtime_state(&workspace)
-        .expect("quick-start state written before shutdown fixture");
-    let generation = runtime_state
-        .get("generation")
-        .and_then(Value::as_str)
-        .or_else(|| {
-            runtime_state
-                .get("agents")
-                .and_then(Value::as_object)
-                .and_then(|agents| {
-                    agents.values().find_map(|agent| {
-                        agent.get("spawned_at").and_then(Value::as_str)
-                    })
-                })
-        })
-        .or_else(|| {
-            runtime_state
-                .pointer("/teams/teamdir/agents")
-                .and_then(Value::as_object)
-                .and_then(|agents| {
-                    agents.values().find_map(|agent| {
-                        agent.get("spawned_at").and_then(Value::as_str)
-                    })
-                })
-        })
-        .unwrap_or("phase-golden");
-    let lifecycle_transport = codex_ready_transport()
-        .with_session_present(true)
-        .with_windows(vec![WindowName::new("w1"), WindowName::new("w2")])
-        .with_targets(vec![PaneInfo {
-            pane_id: PaneId::new("%w1"),
-            session: SessionName::new("team-phasegolden"),
-            window_index: Some(0),
-            window_name: Some(WindowName::new("w1")),
-            pane_index: Some(0),
-            tty: None,
-            current_command: Some("codex".to_string()),
-            current_path: Some(workspace.clone()),
-            active: true,
-            pane_pid: None,
-            leader_env: BTreeMap::new(),
-        }])
-        .with_session_owner(&workspace, "teamdir", generation);
-    let lifecycle = (spec.lifecycle_op)(&workspace, &lifecycle_transport, spec.team_key);
-    let shutdown = lifecycle_port::shutdown_with_transport(
-        &workspace,
-        true,
-        Some(spec.team_key),
-        &lifecycle_transport,
-    );
-
-    let raw = json!({
-        "phase": spec.phase,
-        "script": [
-            {
-                "step": "quick-start",
-                "exit_code": if quick_start.is_ok() { 0 } else { 1 },
-                "output": quick_start_value(quick_start),
-            },
-            { "step": "status-json", "result": cmd_value(status_compact) },
-            { "step": "status-detail-json", "result": cmd_value(status_detail) },
-            { "step": "send", "result": cmd_value(send) },
-            { "step": "phase-lifecycle-op", "output": lifecycle },
-            {
-                "step": "shutdown-keep-logs",
-                "exit_code": if shutdown.is_ok() { 0 } else { 1 },
-                "output": match shutdown {
-                    Ok(value) => value,
-                    Err(error) => json!({"ok": false, "error": error.to_string()}),
-                },
-            },
-        ],
-        "events_jsonl": read_events(&workspace),
-        "state_json": read_state(&workspace),
-        "transport": {
-            "spawns": lifecycle_transport.spawn_window_records(),
-        },
-    });
-
-    let mut ctx = NormalizeCtx::new(&workspace);
-    normalize_value(raw, &mut ctx, None)
-}
-
-fn phase_b_reset_discard_session(
-    workspace: &Path,
-    transport: &OfflineTransport,
-    team_key: &'static str,
-) -> Value {
-    match crate::lifecycle::reset_agent_with_transport(
-        workspace,
-        &aid("w1"),
-        true,
-        false,
-        Some(team_key),
-        transport,
-    ) {
-        Ok(ResetAgentOutcome::Reset {
-            start_mode,
-            discarded_session_id,
-            session_id,
-            new_session_id,
-            ..
-        }) => json!({
-            "ok": true,
-            "operation": "reset-agent --discard-session",
-            "status": "running",
-            "start_mode": format!("{start_mode:?}"),
-            "discarded_session_id": discarded_session_id.map(|id| id.as_str().to_string()),
-            "session_id": session_id.map(|id| id.as_str().to_string()),
-            "new_session_id": new_session_id.map(|id| id.as_str().to_string()),
-        }),
-        Ok(other) => json!({
-            "ok": true,
-            "operation": "reset-agent --discard-session",
-            "status": format!("{other:?}"),
-        }),
-        Err(error) => json!({
-            "ok": false,
-            "operation": "reset-agent --discard-session",
-            "error": error.to_string(),
-        }),
-    }
-}
-
 fn two_worker_team_dir(hermetic: &HermeticTestEnv) -> PathBuf {
     let team = hermetic.workspace("team").join("teamdir");
     std::fs::create_dir_all(team.join("agents")).unwrap();
@@ -445,40 +160,6 @@ fn role_doc(id: &str) -> String {
     )
 }
 
-fn quick_start_value(result: Result<QuickStartReport, LifecycleError>) -> Value {
-    match result {
-        Ok(QuickStartReport::Ready {
-            session_name,
-            launch,
-            worker_readiness,
-            ..
-        }) => {
-            let agents = launch
-                .started
-                .iter()
-                .map(|started| {
-                    json!({
-                        "agent_id": started.agent_id.as_str(),
-                        "target": started.target,
-                        "start_mode": format!("{:?}", started.start_mode),
-                        "session_id": started.session_id.as_ref().map(|id| id.as_str().to_string()),
-                        "rollout_path": started.rollout_path.as_ref().map(|path| path.as_path().to_string_lossy().to_string()),
-                    })
-                })
-                .collect::<Vec<_>>();
-            json!({
-                "ok": true,
-                "status": "ready",
-                "session_name": session_name.as_str(),
-                "worker_readiness": format!("{worker_readiness:?}"),
-                "started": agents,
-            })
-        }
-        Ok(other) => json!({"ok": false, "status": format!("{other:?}")}),
-        Err(error) => json!({"ok": false, "error": error.to_string()}),
-    }
-}
-
 fn cmd_value(result: Result<CmdResult, crate::cli::CliError>) -> Value {
     match result {
         Ok(cmd) => json!({
@@ -496,46 +177,6 @@ fn cmd_value(result: Result<CmdResult, crate::cli::CliError>) -> Value {
     }
 }
 
-fn read_events(workspace: &Path) -> Vec<Value> {
-    let path = crate::model::paths::logs_dir(workspace).join("events.jsonl");
-    std::fs::read_to_string(path)
-        .unwrap_or_default()
-        .lines()
-        .filter_map(|line| serde_json::from_str(line).ok())
-        .collect()
-}
-
-fn read_state(workspace: &Path) -> Value {
-    crate::state::persist::load_runtime_state(workspace).unwrap_or_else(|_| json!(null))
-}
-
-fn phase_fixture_path(phase: &str) -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("tests")
-        .join("fixtures")
-        .join("0_5_0_phase_golden")
-        .join(phase)
-}
-
-fn load_phase_golden(path: &Path) -> Value {
-    let text = std::fs::read_to_string(path)
-        .unwrap_or_else(|e| panic!("missing golden baseline {}: {e}", path.display()));
-    let stripped = strip_full_line_json_comments(&text);
-    serde_json::from_str(&stripped).unwrap_or_else(|e| {
-        panic!(
-            "parse golden baseline {} after stripping // review comments: {e}",
-            path.display()
-        )
-    })
-}
-
-fn strip_full_line_json_comments(text: &str) -> String {
-    text.lines()
-        .filter(|line| !line.trim_start().starts_with("//"))
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
 fn run_diagnose_after_quick_start() -> Value {
     let hermetic = HermeticTestEnv::enter("tombstone-claim-leader");
     let _permission_mode = EnvVarGuard::set(ANCESTRY_ENV, "[]");

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

@@ -371,16 +371,11 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
 
     let pi_provider_root = hermetic.workspace("pi-add-provider");
     let pi_bin = pi_provider_root.join("bin");
-    let pi_package = pi_provider_root.join("pi-mcp-adapter");
     std::fs::create_dir_all(&pi_bin).expect("create Pi test bin");
-    std::fs::create_dir_all(&pi_package).expect("create Pi test adapter");
     let pi_real = pi_provider_root.join("pi-cli");
     std::fs::write(
         &pi_real,
-        format!(
-            "#!/bin/sh\ncase \"$1\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) printf 'npm:pi-mcp-adapter\\n{}\\n' ;;\n  *) exit 64 ;;\nesac\n",
-            pi_package.display()
-        ),
+        "#!/bin/sh\ncase \"$1\" in\n  --version) printf '0.84.4\\n' ;;\n  --list-models) printf 'provider model\\nteam-agent qwen3.8-27b\\n' ;;\n  list) exit 64 ;;\n  *) exit 64 ;;\nesac\n",
     )
     .expect("write protocol-capable Pi test executable");
     std::fs::set_permissions(
@@ -389,16 +384,6 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     )
     .expect("make Pi test executable");
     std::os::unix::fs::symlink(&pi_real, pi_bin.join("pi")).expect("link Pi test executable");
-    std::fs::write(
-        pi_package.join("package.json"),
-        br#"{"name":"pi-mcp-adapter","version":"2.30.0","pi":{"extensions":["./index.ts"]}}"#,
-    )
-    .expect("write Pi test adapter package");
-    std::fs::write(
-        pi_package.join("index.ts"),
-        b"export const createMcpAdapter = () => {};\n",
-    )
-    .expect("write Pi test adapter entry");
     let _pi_path = EnvVarGuard::set("PATH", pi_bin.as_os_str());
     let pi_success_role = "---\nname: mate\nrole: Pi Dynamic Worker\nprovider: pi\nmodel: team-agent/qwen3.8-27b\nauth_mode: subscription\neffort: max\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\n\ndynamic pi\n";
     let (pi_success_team, pi_success_role_path) =