@team-agent/installer 0.5.119 → 0.5.121

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

@@ -262,10 +262,7 @@ fn cursor_mcp_enable_child_env_applies_direct_profile_unsets() {
     }
     command.env("NO_PROXY", "fixture");
     command.env("no_proxy", "fixture");
-    crate::lifecycle::launch::apply_cursor_mcp_enable_profile_env(
-        &mut command,
-        Some(&launch),
-    );
+    crate::lifecycle::launch::apply_cursor_mcp_enable_profile_env(&mut command, Some(&launch));
     let output = command.output().expect("env child should run");
     assert!(output.status.success());
     let text = String::from_utf8(output.stdout).unwrap();
@@ -280,7 +277,9 @@ fn cursor_mcp_enable_child_env_applies_direct_profile_unsets() {
         "GLOBAL_AGENT_HTTP_PROXY",
     ] {
         assert!(
-            !text.lines().any(|line| line.starts_with(&format!("{key}="))),
+            !text
+                .lines()
+                .any(|line| line.starts_with(&format!("{key}="))),
             "direct MCP child must omit {key}"
         );
     }
@@ -291,8 +290,9 @@ fn cursor_mcp_enable_child_env_applies_direct_profile_unsets() {
 #[test]
 #[serial(env)]
 fn cursor_spawn_writes_identity_into_project_mcp_json() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-mcp-spawn");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-mcp-spawn");
     let ws = tmp_dir("cursor-mcp-spawn");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let team = write_cursor_team(&ws, "cursortm", "cursor_writer");
     let selected = cursor_mcp_json_path(&ws, "cursor_writer").unwrap();
     assert!(
@@ -325,17 +325,49 @@ fn cursor_spawn_writes_identity_into_project_mcp_json() {
     let enable_cwd = cursor_mcp_enable_working_dir(&ws, Some(&project));
     assert_eq!(enable_cwd, physical_workspace_path(&project));
     let argv_workspace = spawn_argv_workspace_flag(&ws).expect("spawn argv --workspace");
-    assert_eq!(argv_workspace, physical_workspace_path(&project).to_string_lossy());
+    assert_eq!(
+        argv_workspace,
+        physical_workspace_path(&project).to_string_lossy()
+    );
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let row = state.pointer("/agents/cursor_writer").unwrap();
+    assert_eq!(row["spawn_cwd"], project.to_string_lossy().as_ref());
+    assert_eq!(row["session_id"], serde_json::Value::Null);
+
+    // Measured native layout: the store bucket uses --workspace primary, not
+    // --add-dir. A decoy in the real project's bucket must never be selected.
+    let sid = "d298b261-23bb-42bb-bbeb-b2ec08d81ca3";
+    for (cwd, id) in [(&project, sid), (&ws, "foreign-project-session")] {
+        let bucket = format!("{:x}", md5::compute(cwd.to_string_lossy().as_bytes()));
+        let archive = _hermetic.home().join(".cursor/chats").join(bucket).join(id);
+        std::fs::create_dir_all(&archive).unwrap();
+        std::fs::write(archive.join("meta.json"), b"{}").unwrap();
+    }
+    let mut capture = serde_json::json!({"agents": {"cursor_writer": row.clone()}});
+    let report = crate::provider::session::capture::capture_missing_provider_sessions_once(
+        &mut capture,
+        &mut crate::provider::get_adapter,
+        false,
+        0,
+    )
+    .unwrap();
+    assert_eq!(report.assigned, vec!["cursor_writer"]);
+    assert_eq!(capture["agents"]["cursor_writer"]["session_id"], sid);
+    assert_eq!(
+        capture["agents"]["cursor_writer"]["spawn_cwd"],
+        project.to_string_lossy().as_ref()
+    );
 }
 
 #[test]
 #[serial(env)]
 fn cursor_spawn_isolation_off_writes_workspace_mcp_json() {
-    let _hermetic = hermetic_guard::HermeticTestEnv::enter("cursor-mcp-spawn-legacy");
+    let _hermetic = hermetic_guard::HermeticTestEnv::enter_with_leader("cursor-mcp-spawn-legacy");
     let key = "TEAM_AGENT_CURSOR_MCP_ISOLATION";
     let prev = std::env::var(key).ok();
     std::env::set_var(key, "0");
     let ws = tmp_dir("cursor-mcp-spawn-legacy");
+    super::launch_spawn::seed_healthy_coordinator(&ws);
     let team = write_cursor_team(&ws, "cursortm", "cursor_writer");
     let result = quick_start_with_transport_in_workspace(
         &ws,
@@ -359,13 +391,14 @@ fn cursor_spawn_isolation_off_writes_workspace_mcp_json() {
     });
     assert_cursor_identity_overlay(&text, "cursor_writer", &ws);
     assert!(
-        !cursor_mcp_json_path(&ws, "cursor_writer")
-            .unwrap()
-            .exists(),
+        !cursor_mcp_json_path(&ws, "cursor_writer").unwrap().exists(),
         "isolation-off must not materialize the per-seat project overlay"
     );
     let argv_workspace = spawn_argv_workspace_flag(&ws).expect("spawn argv --workspace");
-    assert_eq!(argv_workspace, physical_workspace_path(&ws).to_string_lossy());
+    assert_eq!(
+        argv_workspace,
+        physical_workspace_path(&ws).to_string_lossy()
+    );
 }
 
 fn assert_cursor_identity_overlay(text: &str, agent_id: &str, workspace: &Path) {
@@ -439,7 +472,7 @@ fn sample_mcp_config(agent_id: &str, workspace: &str) -> McpConfig {
     McpConfig {
         raw: serde_json::json!({
             "team_orchestrator": {
-                "command": "/bin/team-agent-test",
+                "command": std::env::current_exe().unwrap(),
                 "args": ["mcp-server", "--workspace", workspace],
                 "env": {
                     "TEAM_AGENT_ID": agent_id,
@@ -456,12 +489,21 @@ fn sample_mcp_config(agent_id: &str, workspace: &str) -> McpConfig {
 #[serial(env)]
 fn isolated_cursor_prepare_materializes_per_seat_project_not_workspace_overlay() {
     let ws = tmp_dir("cursor-iso-clean");
-    let project = prepare_cursor_seat_mcp(&ws, "seat-iso", &sample_mcp_config("seat-iso", &ws.to_string_lossy()))
-        .expect("prepare isolated cursor")
-        .expect("isolation defaults on");
+    let project = prepare_cursor_seat_mcp(
+        &ws,
+        "seat-iso",
+        &sample_mcp_config("seat-iso", &ws.to_string_lossy()),
+    )
+    .expect("prepare isolated cursor")
+    .expect("isolation defaults on");
     assert!(
-        project.ends_with("provider-config/seat-iso/cursor"),
-        "per-seat project must be materialized: {}",
+        !project.starts_with(&ws)
+            && project
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .starts_with("ta-cursor-"),
+        "per-seat native project must be outside workspace Git ancestry: {}",
         project.display()
     );
     assert!(project.join(".cursor").is_dir());
@@ -487,7 +529,10 @@ fn isolated_cursor_prepare_materializes_per_seat_project_not_workspace_overlay()
         .find(|pair| pair[0] == "--workspace")
         .map(|pair| pair[1].as_str())
         .unwrap();
-    assert_eq!(workspace_flag, physical_workspace_path(&project).to_string_lossy());
+    assert_eq!(
+        workspace_flag,
+        physical_workspace_path(&project).to_string_lossy()
+    );
     assert_eq!(
         include_str!("../launch/spawn.rs").contains("prepare_cursor_seat_mcp("),
         true,

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

@@ -26,21 +26,20 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 use crate::lifecycle::restart::classify_restart_plan_with_resume_validation;
 use crate::lifecycle::types::ResumeDecision;
-use crate::provider::session_scan::cursor::{
-    cursor_session_archive_present, cursor_session_dir,
-};
+use crate::model::ids::AgentId;
+use crate::provider::session_scan::cursor::{cursor_session_archive_present, cursor_session_dir};
 use crate::state::persist::{load_runtime_state, save_runtime_state};
 use serial_test::serial;
-use crate::model::ids::AgentId;
 use team_agent::lifecycle::{
-    fork_agent_with_transport, quick_start_with_transport_in_workspace, restart_with_transport,
+    cursor_mcp_project_dir, fork_agent_with_transport, quick_start_with_transport_in_workspace,
+    restart_with_transport,
 };
 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,17 +79,22 @@ 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)
         .expect("initial cursor start");
     let sid = "502896a1-72ba-4c53-9a86-b2da28780806";
+    let primary = cursor_mcp_project_dir(&ws, "cursor_writer").unwrap();
+    let primary_before = std::fs::canonicalize(&primary).unwrap();
     let dir = {
         let path = home
             .join(".cursor")
             .join("chats")
-            .join("00a437742b92089861da7821a62f232a")
+            .join(format!(
+                "{:x}",
+                md5::compute(primary.to_string_lossy().as_bytes())
+            ))
             .join(sid);
         std::fs::create_dir_all(&path).unwrap();
         std::fs::write(path.join("store.db"), b"").unwrap();
@@ -100,7 +104,11 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
     assert_eq!(cursor_session_dir(sid).as_deref(), Some(dir.as_path()));
 
     let mut state = load_runtime_state(&ws).expect("load");
-    patch_cursor_writer(&mut state, sid, &dir, &ws);
+    assert_eq!(
+        state["agents"]["cursor_writer"]["spawn_cwd"],
+        primary.to_string_lossy().as_ref()
+    );
+    patch_cursor_writer(&mut state, sid, &dir, &primary);
     save_runtime_state(&ws, &state).expect("save captured");
 
     seed_healthy_coordinator(&ws);
@@ -121,6 +129,21 @@ fn cursor_restart_uses_resume_when_session_captured_and_archive_present() {
         !argv.iter().any(|a| a == "--continue"),
         "resume argv must not use --continue; argv={argv:?}"
     );
+    let after = load_runtime_state(&ws).unwrap();
+    assert_eq!(
+        after["agents"]["cursor_writer"]["spawn_cwd"],
+        primary.to_string_lossy().as_ref()
+    );
+    assert_eq!(after["agents"]["cursor_writer"]["session_id"], sid);
+    assert_eq!(
+        cursor_mcp_project_dir(&ws, "cursor_writer").unwrap(),
+        primary_before
+    );
+    assert_eq!(argv_flag(&argv, "--workspace").as_deref(), primary.to_str());
+    assert!(argv_contains_adjacent(
+        &argv,
+        &["--add-dir", ws.to_str().unwrap()]
+    ));
 }
 
 #[test]
@@ -182,7 +205,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 +303,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