@team-agent/installer 0.5.119 → 0.5.121

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

@@ -32,7 +32,7 @@ fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
 #[test]
 #[serial_test::serial(env)]
 fn concurrent_reset_discard_session_serializes() {
-    let _hermetic = enter_hermetic("phase-b-concurrent-reset");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-concurrent-reset");
     let ids = (1..=6).map(|n| format!("w{n}")).collect::<Vec<_>>();
     let role_docs = ids
         .iter()
@@ -139,7 +139,7 @@ fn concurrent_reset_discard_session_serializes() {
 #[test]
 #[serial_test::serial(env)]
 fn add_fork_remove_share_lifecycle_lock_behavior() {
-    let _hermetic = enter_hermetic("phase-b-fork");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-fork");
     let _home = LaneHomeGuard::enter("phase-b-fork");
     let (add_team, add_workspace, add_role, add_transport) = add_fixture();
     let add_agent = aid("w2");
@@ -324,7 +324,7 @@ fn add_fork_remove_share_lifecycle_lock_behavior() {
 #[test]
 #[serial_test::serial(env)]
 fn breal_spawn_ownership_mismatch_fails_without_state_pollution() {
-    let _hermetic = enter_hermetic("phase-b-spawn-ownership");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-spawn-ownership");
     let (workspace, _team) = breal_workspace();
     let transport = BRealTransport::misowned();
 
@@ -366,7 +366,9 @@ fn breal_spawn_ownership_mismatch_fails_without_state_pollution() {
 }
 
 #[test]
+#[serial_test::serial(env)]
 fn breal_provider_missing_window_disappeared_fails_closed() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-missing-window");
     let (workspace, _team) = breal_workspace();
     let transport = BRealTransport::dead_after_spawn();
 
@@ -404,7 +406,9 @@ fn breal_provider_missing_window_disappeared_fails_closed() {
 }
 
 #[test]
+#[serial_test::serial(env)]
 fn breal_reset_rehydrates_role_context_from_compiled_spec() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-reset-context");
     let (workspace, _team) = breal_workspace();
     strip_runtime_command_context(&workspace);
     let transport = BRealTransport::owned();
@@ -438,7 +442,7 @@ fn breal_reset_rehydrates_role_context_from_compiled_spec() {
 #[test]
 #[serial_test::serial(env)]
 fn breal_restart_rehydrates_role_context_from_compiled_spec() {
-    let _hermetic = enter_hermetic("phase-b-restart-role-context");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("phase-b-restart-role-context");
     let (workspace, _team) = breal_one_worker_workspace();
     strip_runtime_command_context(&workspace);
     let transport = BRealTransport::owned();

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

@@ -94,8 +94,8 @@ fn hermetic_caller_envs() -> &'static [&'static str] {
 
 #[test]
 #[serial_test::serial(env)]
-fn phase_golden_unbound_not_ready_requires_claim_leader() {
-    let diagnose = run_diagnose_after_quick_start();
+fn phase_golden_missing_registry_requires_index_publication_not_claim() {
+    let diagnose = run_diagnose_after_unbound_state_fixture();
     let issues = diagnose
         .get("issues")
         .and_then(Value::as_array)
@@ -177,22 +177,16 @@ fn cmd_value(result: Result<CmdResult, crate::cli::CliError>) -> Value {
     }
 }
 
-fn run_diagnose_after_quick_start() -> Value {
+fn run_diagnose_after_unbound_state_fixture() -> Value {
     let hermetic = HermeticTestEnv::enter("tombstone-claim-leader");
     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 launch_transport = codex_ready_transport();
-    quick_start_with_transport_in_workspace(
-        &workspace,
-        &team,
-        None,
-        true,
-        None,
-        &launch_transport,
-    )
-    .expect("tombstone fixture must quick-start");
+    crate::lifecycle::launch::materialize_unbound_state_for_test(
+        &workspace, &team, "teamdir", &launch_transport,
+    ).expect("materialize the recording-only tombstone fixture, not a callerless public start");
     let mut state = crate::state::persist::load_runtime_state(&workspace)
         .expect("tombstone fixture must persist runtime state");
     crate::lifecycle::launch::seed_launched_owner_from_caller_with_provider_lookup(

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

@@ -90,6 +90,7 @@ impl Drop for PathEnvGuard {
 struct Fixture {
     #[cfg(unix)]
     _path_guard: PathEnvGuard,
+    _caller: hermetic_guard::HermeticTestEnv,
     root: PathBuf,
     team_dir: PathBuf,
     run_workspace: PathBuf,
@@ -103,6 +104,7 @@ struct Fixture {
 
 impl Fixture {
     fn new() -> Self {
+        let caller = hermetic_guard::HermeticTestEnv::enter_with_leader("pi-fork-owned-caller");
         let root = super::temp_ws();
         #[cfg(unix)]
         let path_guard = PathEnvGuard::with_fake_pi(&root);
@@ -122,6 +124,7 @@ impl Fixture {
         )
         .expect("write referenced profile");
 
+        super::launch_spawn::seed_healthy_coordinator(&root);
         let setup = team_agent::lifecycle::launch::quick_start_with_transport(
             &team_dir,
             None,
@@ -198,6 +201,7 @@ impl Fixture {
         let fixture = Self {
             #[cfg(unix)]
             _path_guard: path_guard,
+            _caller: caller,
             root,
             team_dir,
             run_workspace,

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

@@ -468,9 +468,7 @@ struct LaunchLatencyCase {
 
 impl LaunchLatencyCase {
     fn new(tag: &str, workers: usize) -> Self {
-        let env = hermetic_guard::HermeticTestEnv::enter(tag);
-        env.scrub_tmux();
-        env.assert_no_real_tmux();
+        let env = hermetic_guard::HermeticTestEnv::enter_with_leader(tag);
         let workspace = env.workspace(tag);
         let team_dir = workspace.join("teamdir");
         fs::create_dir_all(&team_dir).expect("create launch team dir");

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

@@ -355,6 +355,13 @@ fn red6_cli_restart_reports_and_top_level_error_logs_are_redacted() {
         combined.push_str(&String::from_utf8_lossy(&output.stdout));
         combined.push_str(&String::from_utf8_lossy(&output.stderr));
     }
+    assert!(read_cli_error_logs(&workspace).is_empty(),
+        "invalid profile syntax must not create a runtime diagnostic log");
+    // Keep the original physical-log redaction assertion on the same actual
+    // runtime-error emitter, separately from the new zero-log Usage boundary.
+    assert_eq!(crate::cli::emit::__test_runtime_error_emitter(
+        "restart", &workspace, &crate::cli::CliError::Runtime(diagnostic.clone())
+    ), crate::cli::ExitCode::Error);
     let logs = read_cli_error_logs(&workspace);
     let output_safe = !combined.contains(&marker) && combined.contains(REDACTED);
     let logs_safe = !logs.contains(&marker) && logs.contains(REDACTED);

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

@@ -720,8 +720,12 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
     let ws = tmp_dir("b-step2-trust-retry");
     let mcp_config = ws.join(".team").join("runtime").join("mcp").join("w1.json");
     std::fs::create_dir_all(mcp_config.parent().unwrap()).unwrap();
-    std::fs::write(&mcp_config, "{}").unwrap();
-    let state = json!({
+    // This worker genuinely depends on MCP. Bind the controlled receipt to the
+    // live test carrier rather than bypassing readiness with an empty config.
+    let owner = "subprep-trust-retry";
+    let mut state = json!({
+        "team_key": owner,
+        "active_team_key": owner,
         "session_name": "team-ta-subroot-SUB-PROBE-2-send-turn-idle",
         "team_dir": ws.join("teamdir").to_string_lossy().to_string(),
         "agents": {
@@ -736,6 +740,21 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
             }
         }
     });
+    #[cfg(unix)]
+    let carrier = {
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        state["agents"]["w1"]["pane_pid"] = json!(carrier);
+        state["agents"]["w1"]["spawned_at"] =
+            json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+        carrier
+    };
+    state["teams"] = json!({owner: state.clone()});
+    std::fs::write(&mcp_config, serde_json::to_vec(&json!({
+        "mcpServers": {"team_orchestrator": {
+            "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+            "env": {"TEAM_AGENT_WORKSPACE": ws.to_path_buf(), "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": owner}
+        }}
+    })).unwrap()).unwrap();
     team_agent::state::persist::save_runtime_state(&ws, &state).unwrap();
 
     let store = MessageStore::open(&ws).unwrap();
@@ -748,7 +767,7 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
             "SUB step2 probe: reply with one sentence and call report_result exactly once.",
             None,
             true,
-            None,
+            Some(owner),
         )
         .unwrap();
     let transport = RecordingTransport::new(vec![
@@ -759,6 +778,10 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
     ])
     .with_session_present(true)
     .with_windows(vec![WindowName::new("w1")]);
+    #[cfg(unix)]
+    {
+        transport.state.lock().unwrap().carrier = Some(carrier);
+    }
     let event_log = EventLog::new(&ws);
 
     let deferred =
@@ -787,6 +810,13 @@ fn contract_b_step2_retry_delivers_queued_message_after_startup_trust_is_handled
         "fixture sanity: delivery defer must be observable as delivery.deferred_startup_prompt"
     );
 
+    // No receipt existed during the actionable trust prompt. Once startup
+    // control can progress, model the successful live helper handshake before
+    // the coordinator retries this SAME queued row.
+    #[cfg(unix)]
+    {
+        crate::mcp_server::readiness::publish(&ws, owner, "w1", chrono::Utc::now()).unwrap();
+    }
     let coord = Coordinator::new(
         WorkspacePath::new(ws.to_path_buf()),
         Box::new(RealAdapterRegistry),
@@ -1045,6 +1075,7 @@ struct TransportState {
     session_present: bool,
     windows: Vec<WindowName>,
     spawn_argv: Vec<Vec<String>>,
+    carrier: Option<u32>,
 }
 
 #[derive(Debug, Clone)]
@@ -1189,7 +1220,19 @@ impl Transport for RecordingTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.state.lock().unwrap().carrier.map(|carrier| PaneInfo {
+            pane_id: PaneId::new("%7"),
+            session: SessionName::new("team-ta-subroot-SUB-PROBE-2-send-turn-idle"),
+            window_index: None,
+            window_name: Some(WindowName::new("w1")),
+            pane_index: None,
+            tty: None,
+            current_command: None,
+            current_path: None,
+            active: true,
+            pane_pid: Some(carrier),
+            leader_env: BTreeMap::new(),
+        }).into_iter().collect())
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {

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

@@ -35,10 +35,8 @@ use team_agent::transport::{
 #[test]
 #[serial(env)]
 fn quick_start_team_id_persists_requested_team_key_for_lifecycle_selection() {
-    let hermetic = hermetic_guard::HermeticTestEnv::enter("team-in-team-requested-key");
-    hermetic.scrub_tmux();
-    hermetic.assert_no_real_tmux();
     let _env = EnvGuard::unset();
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("team-in-team-requested-key");
     let root = tmp_dir("team-id-key");
     seed_healthy_coordinator(&root);
     let team_dir = write_team_dir(&root, "teamdir", "w1");

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

@@ -46,8 +46,9 @@ const CLAUDE_ROLE: &str = "---\nname: clauder\nrole: Claude Worker\nprovider: cl
 #[test]
 #[serial(env)]
 fn worker_mcp_owner_team_scope_must_match_runtime_team_key_not_spec_name() {
-    let hermetic = HermeticTestEnv::enter("rs031-mcp-owner-scope");
+    let hermetic = HermeticTestEnv::enter_with_leader("rs031-mcp-owner-scope");
     let team = mixed_provider_team_dir(&hermetic, "mcp-owner-scope");
+    super::launch_spawn::seed_healthy_coordinator(team.parent().unwrap());
     let transport = RecordingTransport::new()
         .with_windows(vec![WindowName::new("clauder"), WindowName::new("codexer")]);
     let launch = ready_launch(

package/crates/team-agent/src/lifecycle/types.rs

@@ -512,6 +512,16 @@ pub enum QuickStartReport {
         worker_readiness: QuickStartReadiness,
         team: String,
     },
+    /// Workers may exist, but post-spawn admission/coordinator completion failed.
+    /// Preserve confirmed effects; never disguise this as a preflight refusal.
+    Partial {
+        workspace: PathBuf,
+        session_name: SessionName,
+        launch: Box<LaunchReport>,
+        team: String,
+        error: String,
+        coordinator_state: String,
+    },
     /// 已有 runtime state → quick-start 拒绝并引导用 restart。
     ExistingRuntime {
         team: Option<String>,

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

@@ -89,6 +89,8 @@ use crate::messaging::{self, DeliveryOutcome, MessageTarget, SendOptions, Truste
 pub mod helpers;
 pub(crate) mod lifecycle_tools;
 pub mod normalize;
+#[cfg(unix)]
+pub(crate) mod readiness;
 pub mod tools;
 pub mod types;
 pub mod wire;