@team-agent/installer 0.5.119 → 0.5.120

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

@@ -32,7 +32,9 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn cursor_role_missing_model_uses_provider_default() {
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-no-model");
     let ws = tmp_dir("cursor-no-model");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let team = write_role_team(&ws, "cursortm", "cursor_writer", None, None);
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(
@@ -54,8 +56,9 @@ fn cursor_role_missing_model_uses_provider_default() {
 #[test]
 #[serial(env)]
 fn cursor_role_explicit_model_reaches_argv() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-with-model");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-with-model");
     let ws = tmp_dir("cursor-with-model");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let team = write_role_team(
         &ws,
         "cursortm",
@@ -116,7 +119,7 @@ fn cursor_role_with_effort_refuses_to_start() {
 #[test]
 #[serial(env)]
 fn cursor_second_seat_in_same_workspace_is_refused() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-two");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-two");
     let ws = tmp_dir("cursor-two");
     let team = ws.join("cursortm");
     std::fs::create_dir_all(team.join("agents")).unwrap();

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

@@ -40,7 +40,7 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn cursor_fresh_spawn_does_not_invent_session_id() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-fresh");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-fresh");
     let (ws, _home, _guard, team) = seed_cursor("pending");
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)
@@ -80,7 +80,7 @@ fn cursor_fresh_spawn_does_not_invent_session_id() {
 #[test]
 #[serial(env)]
 fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-resume");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-resume");
     let (ws, home, _guard, team) = seed_cursor("resume");
     let first = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &first)
@@ -182,7 +182,7 @@ fn cursor_classify_resumes_when_archive_present_and_refuses_when_missing() {
 #[test]
 #[serial(env)]
 fn cursor_fork_agent_refuses_as_unsupported_not_unverified() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-fork");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-fork");
     let (ws, _home, _guard, team) = seed_cursor("fork");
     let transport = OfflineTransport::new();
     quick_start_with_transport_in_workspace(&ws, &team, None, true, Some("cursortm"), &transport)
@@ -280,6 +280,7 @@ fn seed_healthy_coordinator(workspace: &Path) {
 
 fn seed_cursor(tag: &str) -> (PathBuf, PathBuf, HomeGuard, PathBuf) {
     let ws = tmp_dir(tag);
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir(&format!("{tag}-home"));
     let guard = HomeGuard::set(&home);
     let team = write_cursor_role(&ws);

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

@@ -22,10 +22,7 @@ mod hermetic_guard;
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
 fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
-    let env = hermetic_guard::HermeticTestEnv::enter(tag);
-    env.scrub_tmux();
-    env.assert_no_real_tmux();
-    env
+    hermetic_guard::HermeticTestEnv::enter_with_leader(tag)
 }
 
 use std::path::{Path, PathBuf};
@@ -159,6 +156,7 @@ fn seed_healthy_coordinator(workspace: &Path) {
 
 fn seed_grok(tag: &str, effort: Option<&str>) -> (PathBuf, PathBuf, HomeGuard, PathBuf) {
     let ws = tmp_dir(tag);
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir(&format!("{tag}-home"));
     seed_grok_home(&home, Some(&ws));
     let guard = HomeGuard::set(&home);

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

@@ -15,10 +15,7 @@ mod hermetic_guard;
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
 fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
-    let env = hermetic_guard::HermeticTestEnv::enter(tag);
-    env.scrub_tmux();
-    env.assert_no_real_tmux();
-    env
+    hermetic_guard::HermeticTestEnv::enter_with_leader(tag)
 }
 
 use std::path::{Path, PathBuf};
@@ -218,6 +215,7 @@ fn two_grok_seats_coexist_when_toml_has_no_per_seat_keys() {
 fn leftover_per_seat_key_is_cleared_before_start() {
     let _hermetic = enter_hermetic("grok-overlay-leftover-seat");
     let ws = tmp_dir("grok-cwd-per-seat");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir("grok-cwd-per-seat-home");
     seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
@@ -345,6 +343,7 @@ fn grok_missing_login_refuses_to_start() {
 fn grok_spawn_writes_resolved_team_agent_into_project_grok_config() {
     let _hermetic = enter_hermetic("grok-overlay-spawn");
     let ws = tmp_dir("grok-mcp-overlay");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir("grok-mcp-overlay-home");
     seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);

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

@@ -14,10 +14,7 @@ mod hermetic_guard;
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
 fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
-    let env = hermetic_guard::HermeticTestEnv::enter(tag);
-    env.scrub_tmux();
-    env.assert_no_real_tmux();
-    env
+    hermetic_guard::HermeticTestEnv::enter_with_leader(tag)
 }
 
 use std::path::{Path, PathBuf};
@@ -31,7 +28,9 @@ use team_agent::transport::test_support::OfflineTransport;
 #[test]
 #[serial(env)]
 fn grok_role_missing_model_uses_provider_default() {
+    let _hermetic = enter_hermetic("grok-no-model");
     let ws = tmp_dir("grok-no-model");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir("grok-no-model-home");
     seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
@@ -67,6 +66,7 @@ fn grok_role_missing_model_uses_provider_default() {
 fn grok_role_explicit_model_reaches_argv() {
     let _hermetic = enter_hermetic("grok-explicit-model");
     let ws = tmp_dir("grok-with-model");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir("grok-with-model-home");
     seed_grok_home(&home, Some(&ws));
     let _guard = HomeGuard::set(&home);
@@ -103,6 +103,7 @@ fn grok_role_explicit_model_reaches_argv() {
 fn claude_role_missing_model_still_starts() {
     let _hermetic = enter_hermetic("grok-claude-missing-model");
     let ws = tmp_dir("claude-no-model");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let team = write_role_team(
         &ws,
         "claudeteam",

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

@@ -22,10 +22,7 @@ mod hermetic_guard;
 fn _hermetic_boundary_marker(_: &hermetic_guard::HermeticTestEnv) {}
 
 fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
-    let env = hermetic_guard::HermeticTestEnv::enter(tag);
-    env.scrub_tmux();
-    env.assert_no_real_tmux();
-    env
+    hermetic_guard::HermeticTestEnv::enter_with_leader(tag)
 }
 
 use std::path::{Path, PathBuf};
@@ -212,6 +209,7 @@ fn seed_healthy_coordinator(workspace: &Path) {
 
 fn seed_grok(tag: &str) -> (PathBuf, PathBuf, HomeGuard, PathBuf) {
     let ws = tmp_dir(tag);
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let home = tmp_dir(&format!("{tag}-home"));
     seed_grok_home(&home, Some(&ws));
     let guard = HomeGuard::set(&home);

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

@@ -174,8 +174,9 @@ fn unowned_running_ws() -> PathBuf {
 #[test]
 #[serial(env)]
 fn quick_start_compiles_real_spec_to_team_spec_yaml() {
-    let _hermetic = enter_hermetic("launch-spawn-compile-spec");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-compile-spec");
     let team = quick_start_team_dir(QS_VALID_ROLE);
+    seed_healthy_coordinator(&crate::model::paths::team_workspace(&team).unwrap());
     let transport = OfflineTransport::new();
     let result = quick_start_with_transport(&team, None, true, None, &transport);
 
@@ -209,9 +210,10 @@ fn quick_start_compiles_real_spec_to_team_spec_yaml() {
 #[test]
 #[serial(env)]
 fn quick_start_without_team_id_uses_compiled_team_name_as_canonical_key() {
-    let _hermetic = enter_hermetic("launch-spawn-canonical-team");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-canonical-team");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    seed_healthy_coordinator(&workspace);
     let transport = OfflineTransport::new();
 
     let result = quick_start_with_transport(&team, None, true, None, &transport);
@@ -231,8 +233,9 @@ fn quick_start_without_team_id_uses_compiled_team_name_as_canonical_key() {
 #[test]
 #[serial(env)]
 fn existing_runtime_producer_scopes_canonical_team() {
-    let _hermetic = enter_hermetic("launch-spawn-existing-producer");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-existing-producer");
     let team = quick_start_team_dir(QS_VALID_ROLE);
+    seed_healthy_coordinator(&crate::model::paths::team_workspace(&team).unwrap());
     let transport = OfflineTransport::new();
     let first = quick_start_with_transport(&team, Some("from-name"), true, None, &transport)
         .expect("first quick-start");
@@ -342,8 +345,9 @@ fn existing_runtime_empty_top_level_agents_still_emits_bob() {
 #[test]
 #[serial(env)]
 fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_collect() {
-    let _hermetic = enter_hermetic("launch-spawn-dot-team-workspace");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-dot-team-workspace");
     let workspace = temp_ws();
+    seed_healthy_coordinator(&workspace);
     let team = workspace.join(".team").join("current");
     std::fs::create_dir_all(team.join("agents")).unwrap();
     std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
@@ -417,7 +421,7 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
 #[test]
 #[serial(env)]
 fn quick_start_default_workspace_compiled_spec_uses_project_root() {
-    let _hermetic = enter_hermetic("launch-spawn-default-workspace");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-default-workspace");
     let workspace = temp_ws();
     std::fs::create_dir_all(workspace.join("agents")).unwrap();
     std::fs::write(workspace.join("TEAM.md"), QS_TEAM_MD).unwrap();
@@ -724,8 +728,9 @@ fn unowned_running_ws_all_paused() -> PathBuf {
 #[test]
 #[serial(env)]
 fn spine_quick_start_seeds_state_under_team_workspace_not_team_dir() {
-    let _hermetic = enter_hermetic("launch-spawn-spine-workspace");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-spine-workspace");
     let team = quick_start_team_dir(QS_VALID_ROLE); // <base>/teamdir
+    seed_healthy_coordinator(&crate::model::paths::team_workspace(&team).unwrap());
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team.parent().unwrap(); // team_workspace(<base>/teamdir) = <base>
@@ -1302,21 +1307,32 @@ fn start_agent_session_generation_inherits_birth_or_stamps_recreated_session() {
 /// Seed a HEALTHY coordinator at `workspace` (this process's pid + matching metadata + db schema) so
 /// quick_start's internal start_coordinator returns AlreadyRunning — NO real daemon subprocess spawn.
 pub(super) fn seed_healthy_coordinator(workspace: &std::path::Path) {
-    let wp = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
-    std::fs::create_dir_all(crate::model::paths::runtime_dir(workspace)).unwrap();
-    let _ = crate::message_store::MessageStore::open(workspace).unwrap(); // create db schema (schema.ok)
-    let me = crate::coordinator::Pid::new(std::process::id());
-    crate::coordinator::write_coordinator_metadata(
-        &wp,
-        me,
-        crate::coordinator::MetadataSource::Boot,
-    )
-    .unwrap();
-    std::fs::write(
-        crate::coordinator::coordinator_pid_path(&wp),
-        me.to_string(),
-    )
-    .unwrap();
+    hermetic_guard::seed_in_process_coordinator(workspace);
+}
+
+#[test]
+#[cfg(unix)]
+#[serial(env)]
+fn issue337_owned_fixture_caller_admits_fresh_launch_without_guard_bypass() {
+    let env = hermetic_guard::HermeticTestEnv::enter_with_leader("issue337-fixture-caller");
+    let workspace = env.workspace("ws");
+    let team = workspace.join("roles");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    std::fs::write(team.join("agents/implementer.md"), QS_VALID_ROLE).unwrap();
+    seed_healthy_coordinator(&workspace);
+    let transport = OfflineTransport::new();
+    let report = quick_start_with_transport_in_workspace(
+        &workspace, &team, None, true, Some("fixture-team"), &transport,
+    ).unwrap();
+    let QuickStartReport::Ready { launch, .. } = report else { panic!("owned caller must admit launch: {report:?}") };
+    assert!(launch.leader_receiver_attached);
+    assert_eq!(launch.started.len(), 1);
+    assert_eq!(transport.spawn_records().len(), 1);
+    let socket = std::env::var("TMUX").unwrap().split(',').next().unwrap().to_string();
+    assert!(std::path::Path::new(&socket).exists());
+    drop(env);
+    assert!(!std::path::Path::new(&socket).exists());
 }
 
 fn seed_canonical_team_identity(workspace: &std::path::Path, team_key: &str) {
@@ -1333,7 +1349,7 @@ fn seed_canonical_team_identity(workspace: &std::path::Path, team_key: &str) {
 #[test]
 #[serial(env)]
 fn quick_start_with_transport_spawns_workers_not_dry_run() {
-    let _hermetic = enter_hermetic("launch-spawn-spawn-path");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-spawn-path");
     let team = quick_start_team_dir(QS_VALID_ROLE); // one agent: implementer / provider codex
     let workspace = team.parent().expect("team_workspace(team_dir) = parent"); // where start_coordinator runs
     seed_healthy_coordinator(workspace);
@@ -1422,7 +1438,7 @@ fn adaptive_layout_plan_8_workers_is_3_3_2() {
 #[test]
 #[serial(env)]
 fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
-    let _hermetic = enter_hermetic("launch-spawn-adaptive-layout");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-adaptive-layout");
     let roles = (1..=4)
         .map(|i| {
             let id = format!("w{i}");
@@ -1507,7 +1523,7 @@ fn quick_start_tmux_backend_uses_workspace_private_endpoint() {
 #[test]
 #[serial(env)]
 fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
-    let _hermetic = enter_hermetic("launch-spawn-endpoint-attach");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-endpoint-attach");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let workspace = team.parent().expect("team_workspace(team_dir) = parent");
     seed_healthy_coordinator(workspace);
@@ -1568,23 +1584,27 @@ fn annotate_runtime_tmux_endpoint_persists_workspace_socket_as_full_path() {
 #[test]
 #[serial(env)]
 fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command() {
-    let _hermetic = enter_hermetic("launch-spawn-managed-leader");
-    let team = quick_start_team_dir(QS_VALID_ROLE);
-    let workspace = team.parent().expect("team_workspace(team_dir) = parent");
+    let hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-managed-leader");
+    let workspace = hermetic.root();
+    let team = workspace.join("teamdir");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    std::fs::write(team.join("agents/implementer.md"), QS_VALID_ROLE).unwrap();
     seed_healthy_coordinator(workspace);
+    let endpoint = std::env::var("TMUX").unwrap().split(',').next().unwrap().to_string();
     crate::state::persist::save_runtime_state(
         workspace,
         &json!({
             "active_team_key": "teamdir",
-            "session_name": "team-teamdir",
+            "session_name": null,
             "is_external_leader": false,
             "leader_client": {"diagnostic_only": true, "attach_mode": "attach-session"},
-            "leader_receiver": {"mode": "direct_tmux", "status": "attached", "pane_id": "%42"},
-            "team_owner": {"pane_id": "%42", "owner_epoch": 1},
+            "tmux_socket": endpoint,
+            "tmux_endpoint": endpoint,
             "agents": {},
             "teams": {
                 "teamdir": {
-                    "session_name": "team-teamdir",
+                    "session_name": null,
                     "is_external_leader": false,
                     "leader_client": {"diagnostic_only": true, "attach_mode": "attach-session"},
                     "agents": {}
@@ -1593,9 +1613,25 @@ fn quick_start_preserves_managed_leader_topology_and_emits_leader_attach_command
         }),
     )
     .expect("seed managed leader state");
+    let attached = crate::cli::cmd_attach_leader(&crate::cli::AttachLeaderArgs {
+        workspace: workspace.to_path_buf(), team: Some("teamdir".into()), pane: None,
+        provider: crate::model::enums::Provider::Fake, confirm: false, json: true,
+    }).expect("bind the real owned caller through the public lease port");
+    assert_eq!(attached.exit, crate::cli::ExitCode::Ok, "{attached:?}");
+    let mut state = crate::state::persist::load_runtime_state(workspace).unwrap();
+    assert!(state["session_name"].is_null(), "leader-only bootstrap has no worker session");
+    assert!(state["teams"]["teamdir"]["session_name"].is_null());
+    assert!(state["teams"]["teamdir"]["agents"].as_object().unwrap().is_empty());
+    // The owned fake caller models the already-managed launcher topology;
+    // retain the real binding while setting the presentation fixture metadata.
+    state["is_external_leader"] = json!(false);
+    state["leader_client"] = json!({"diagnostic_only": true, "attach_mode": "attach-session"});
+    state["teams"]["teamdir"]["is_external_leader"] = json!(false);
+    state["teams"]["teamdir"]["leader_client"] = state["leader_client"].clone();
+    crate::state::persist::save_runtime_state(workspace, &state).unwrap();
     let transport = OfflineTransport::new();
 
-    let report = quick_start_with_transport(&team, None, true, None, &transport)
+    let report = quick_start_with_transport(&team, None, true, Some("teamdir"), &transport)
         .expect("quick_start_with_transport must reach Ready");
     let attach_commands = match report {
         QuickStartReport::Ready {
@@ -2872,8 +2908,9 @@ fn stop_agent_adaptive_kills_target_pane_not_shared_layout_window() {
 #[test]
 #[serial(env)]
 fn quick_start_seeds_tasks_key_from_compiled_spec() {
-    let _hermetic = enter_hermetic("launch-spawn-tasks-key");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-tasks-key");
     let team = quick_start_team_dir(QS_VALID_ROLE);
+    seed_healthy_coordinator(&crate::model::paths::team_workspace(&team).unwrap());
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team
@@ -2921,7 +2958,7 @@ fn quick_start_seeds_tasks_key_from_compiled_spec() {
 //   suffix (active_team_key, teams).
 #[test]
 #[serial(env)]
-fn quick_start_state_seeds_spec_path_workspace_leader() {
+fn quick_start_unbound_state_producer_seeds_spec_path_workspace_leader() {
     let _hermetic = enter_hermetic("launch-spawn-state-seeds");
     // Bug 2 owner team-scope: top-level owner triple is dropped when the seeded
     // pane is empty; an ambient TMUX_PANE (tests run inside the dev's tmux session)
@@ -2932,10 +2969,14 @@ fn quick_start_state_seeds_spec_path_workspace_leader() {
     let _tmux = EnvVarGuard::unset("TMUX");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
-    let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team
         .parent()
         .expect("team_workspace(<base>/teamdir) = <base>");
+    // Test the real unbound state producer plus recording-only worker stage.
+    // Public start correctly refuses this absent caller (separate regressions).
+    crate::lifecycle::launch::materialize_unbound_state_for_test(
+        workspace, &team, "quickteam", &transport,
+    ).expect("materialize the unbound producer fixture without public start");
     // E5: spec_path in state now points to .team/runtime/<team_key>/, team_dir stays the user role dir.
     let spec_path = quick_start_runtime_spec_path(&team);
     let (raw, state) = raw_runtime_state(workspace);
@@ -3018,10 +3059,11 @@ fn quick_start_state_seeds_spec_path_workspace_leader() {
 #[test]
 #[serial(env)]
 fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
-    let _hermetic = enter_hermetic("launch-spawn-running-state");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("launch-spawn-running-state");
     const FIXED_SPAWNED_AT: &str = "2026-06-04T00:00:00+00:00";
     let _clock_guard = EnvVarGuard::set("TEAM_AGENT_TEST_FIXED_SPAWNED_AT", FIXED_SPAWNED_AT);
     let team = quick_start_team_dir(QS_VALID_ROLE);
+    seed_healthy_coordinator(&crate::model::paths::team_workspace(&team).unwrap());
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, None, &transport);
     let workspace = team

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/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>,