@team-agent/installer 0.5.77 → 0.5.80

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

@@ -1,8 +1,18 @@
+#[path = "../../../tests/support/hermetic.rs"]
+mod hermetic_guard;
+
 use super::*;
 use crate::transport::test_support::OfflineTransport;
 use serde_json::json;
 use serial_test::serial;
 
+fn enter_hermetic(tag: &str) -> hermetic_guard::HermeticTestEnv {
+    let env = hermetic_guard::HermeticTestEnv::enter(tag);
+    env.scrub_tmux();
+    env.assert_no_real_tmux();
+    env
+}
+
 fn launch_source() -> String {
     let src = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/lifecycle");
     let mut files = vec![src.join("launch.rs")];
@@ -26,9 +36,6 @@ fn launch_source() -> String {
         .collect()
 }
 
-#[allow(dead_code)]
-struct HermeticTestEnv;
-
 const QS_TEAM_MD: &str =
     "---\nname: quickteam\nobjective: Quick start.\nprovider: codex\n---\n\nQuick-start team.\n";
 pub(super) const QS_VALID_ROLE: &str = "---\nname: implementer\nrole: Implementation Engineer\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n---\n\nImplement bounded tasks.\n";
@@ -163,7 +170,9 @@ fn unowned_running_ws() -> PathBuf {
 // hardcoded "no role docs found" PreflightBlocked. Golden: quick_start.py → _compile_team_dir_spec
 // writes spec_path=team_dir/team.spec.yaml BEFORE launch.
 #[test]
+#[serial(env)]
 fn quick_start_compiles_real_spec_to_team_spec_yaml() {
+    let _hermetic = enter_hermetic("launch-spawn-compile-spec");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
     let result = quick_start_with_transport(&team, None, true, None, &transport);
@@ -196,7 +205,9 @@ 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 team = quick_start_team_dir(QS_VALID_ROLE);
     let workspace = crate::model::paths::team_workspace(&team).unwrap();
     let transport = OfflineTransport::new();
@@ -216,7 +227,120 @@ 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 team = quick_start_team_dir(QS_VALID_ROLE);
+    let transport = OfflineTransport::new();
+    let first = quick_start_with_transport(&team, Some("from-name"), true, None, &transport)
+        .expect("first quick-start");
+    match &first {
+        QuickStartReport::Ready { team: canonical, .. } => {
+            assert_eq!(canonical, "from-name", "Ready producer must emit canonical team");
+        }
+        other => panic!("first quick-start must be Ready; got {other:?}"),
+    }
+    let second = quick_start_with_transport(&team, Some("from-name"), true, None, &transport)
+        .expect("second quick-start");
+    match second {
+        QuickStartReport::ExistingRuntime {
+            team: canonical,
+            agent_ids,
+            ..
+        } => {
+            assert_eq!(canonical.as_deref(), Some("from-name"));
+            assert!(
+                agent_ids.iter().any(|id| id == "implementer"),
+                "ExistingRuntime producer agent_ids={agent_ids:?}"
+            );
+        }
+        other => panic!("duplicate quick-start must be ExistingRuntime; got {other:?}"),
+    }
+}
+
+#[test]
+#[serial(env)]
+fn existing_runtime_requested_bob_does_not_emit_alice_members_or_attach() {
+    let team = quick_start_team_dir(QS_VALID_ROLE);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let state = json!({
+        "active_team_key": "alice",
+        "agents": { "alice": { "window": "alice" } },
+        "session_name": "team-alice",
+        "tmux_endpoint": "/tmp/shared.sock",
+        "teams": {
+            "alice": {
+                "agents": { "alice": { "window": "alice" } },
+                "session_name": "team-alice"
+            },
+            "bob": {
+                "agents": { "bob": { "window": "bob" } },
+                "session_name": "team-bob"
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+    let report = quick_start_with_transport(&team, Some("bob"), true, None, &OfflineTransport::new())
+        .expect("requested bob existing runtime");
+    match report {
+        QuickStartReport::ExistingRuntime {
+            team: canonical,
+            agent_ids,
+            session_name,
+            attach_commands,
+            ..
+        } => {
+            assert_eq!(canonical.as_deref(), Some("bob"));
+            assert_eq!(agent_ids, vec!["bob".to_string()]);
+            assert_eq!(
+                session_name.as_ref().map(|session| session.as_str()),
+                Some("team-bob")
+            );
+            assert!(
+                attach_commands.iter().any(|command| command.contains("team-bob")),
+                "attach must follow bob session; got {attach_commands:?}"
+            );
+            assert!(
+                attach_commands
+                    .iter()
+                    .all(|command| !command.contains("alice") && !command.contains("team-alice")),
+                "attach must not steer to alice; got {attach_commands:?}"
+            );
+        }
+        other => panic!("expected ExistingRuntime for bob; got {other:?}"),
+    }
+}
+
+#[test]
+#[serial(env)]
+fn existing_runtime_empty_top_level_agents_still_emits_bob() {
+    let team = quick_start_team_dir(QS_VALID_ROLE);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let state = json!({
+        "active_team_key": "bob",
+        "agents": {},
+        "teams": {
+            "bob": {
+                "agents": { "bob": { "window": "bob" } },
+                "session_name": "team-bob"
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+    let report = quick_start_with_transport(&team, Some("bob"), true, None, &OfflineTransport::new())
+        .expect("requested bob with empty top-level agents");
+    match report {
+        QuickStartReport::ExistingRuntime { agent_ids, .. } => {
+            assert_eq!(agent_ids, vec!["bob".to_string()]);
+        }
+        other => panic!("expected ExistingRuntime; got {other:?}"),
+    }
+}
+
+#[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 workspace = temp_ws();
     let team = workspace.join(".team").join("current");
     std::fs::create_dir_all(team.join("agents")).unwrap();
@@ -299,7 +423,9 @@ 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 workspace = temp_ws();
     std::fs::create_dir_all(workspace.join("agents")).unwrap();
     std::fs::write(workspace.join("TEAM.md"), QS_TEAM_MD).unwrap();
@@ -375,215 +501,6 @@ fn quick_start_invalid_role_doc_surfaces_real_compile_error() {
     );
 }
 
-#[test]
-fn quick_start_absent_or_empty_roles_preserves_compile_outcome_without_pi_preflight_mutation() {
-    for (label, create_agents, expected) in [
-        ("absent", false, "missing agents directory"),
-        ("empty", true, "no role docs found"),
-    ] {
-        let team = temp_ws().join(format!("teamdir-{label}"));
-        std::fs::create_dir_all(&team).unwrap();
-        std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
-        if create_agents {
-            std::fs::create_dir(team.join("agents")).unwrap();
-        }
-        let workspace = crate::model::paths::team_workspace(&team).unwrap();
-        let team_md_before = std::fs::read(team.join("TEAM.md")).unwrap();
-        let absent_paths = [
-            team.join("team.spec.yaml"),
-            crate::state::persist::runtime_state_path(&workspace),
-            crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
-            workspace.join("team_state.md"),
-            workspace.join(".team/logs/events.jsonl"),
-            workspace.join(".team/runtime/team.db"),
-        ];
-        for path in &absent_paths {
-            assert!(!path.exists(), "precondition: {} must be absent", path.display());
-        }
-
-        let transport = OfflineTransport::new();
-        let mut calls = 0;
-        let mut discover = |_requested: &str| {
-            calls += 1;
-            Ok(Vec::new())
-        };
-        let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
-            &workspace,
-            &team,
-            None,
-            true,
-            None,
-            &transport,
-            true,
-            &mut discover,
-        )
-        .expect_err("an empty role input must preserve the existing compile outcome");
-        drop(discover);
-        assert_eq!(calls, 0, "{label} role input must not invoke Pi discovery");
-        match error {
-            LifecycleError::Compile(message) => {
-                assert!(message.contains(expected), "{label}: {message}");
-            }
-            other => panic!("{label}: expected existing compile outcome, got {other:?}"),
-        }
-        assert_eq!(team_md_before, std::fs::read(team.join("TEAM.md")).unwrap());
-        for path in &absent_paths {
-            assert!(!path.exists(), "{label} role input created {}", path.display());
-        }
-        assert!(transport.calls().is_empty(), "{label}: no transport mutation");
-        assert!(transport.spawn_records().is_empty(), "{label}: no spawn");
-    }
-}
-
-#[test]
-fn quick_start_injected_pi_preflight_is_typed_and_mutation_free() {
-    let role_doc = QS_VALID_ROLE.replace(
-        "provider: codex\nmodel: gpt-5.5",
-        "provider: pi\nmodel: gpt-5.6-sol",
-    );
-    let team = quick_start_team_dir(&role_doc);
-    let workspace = crate::model::paths::team_workspace(&team).unwrap();
-    let role_path = team.join("agents/implementer.md");
-    let team_md_path = team.join("TEAM.md");
-    let local_spec_path = team.join("team.spec.yaml");
-    let runtime_state_path = crate::state::persist::runtime_state_path(&workspace);
-    let runtime_spec_path = crate::model::paths::runtime_spec_path(&workspace, "quickteam");
-    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
-        &workspace,
-        "quickteam",
-        "implementer",
-    );
-    let role_before = std::fs::read(&role_path).unwrap();
-    let team_md_before = std::fs::read(&team_md_path).unwrap();
-    for path in [
-        &local_spec_path,
-        &runtime_state_path,
-        &runtime_spec_path,
-        &pi_paths.wrapper,
-        &pi_paths.sessions,
-    ] {
-        assert!(!path.exists(), "precondition: {} must be absent", path.display());
-    }
-
-    let transport = OfflineTransport::new();
-    let mut calls = 0;
-    let mut discover = |requested: &str| {
-        calls += 1;
-        assert_eq!(requested, "gpt-5.6-sol");
-        Ok(vec!["openai-codex/gpt-5.6-sol".into()])
-    };
-    let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
-        &workspace,
-        &team,
-        None,
-        true,
-        None,
-        &transport,
-        true,
-        &mut discover,
-    )
-    .expect_err("unqualified Pi role must fail before quick-start mutation");
-    drop(discover);
-    assert_eq!(calls, 1);
-    match error {
-        LifecycleError::PiModelPreflight {
-            requested,
-            candidates,
-            action,
-            not_ready,
-        } => {
-            assert_eq!(requested, "gpt-5.6-sol");
-            assert_eq!(candidates, vec!["openai-codex/gpt-5.6-sol"]);
-            assert_eq!(
-                action,
-                "copy a candidate into the role, or run `team-agent models --provider pi --search gpt-5.6-sol`"
-            );
-            assert!(!not_ready);
-        }
-        other => panic!("expected typed Pi preflight error, got {other:?}"),
-    }
-    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
-    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
-    for path in [
-        &local_spec_path,
-        &runtime_state_path,
-        &runtime_spec_path,
-        &pi_paths.wrapper,
-        &pi_paths.sessions,
-    ] {
-        assert!(!path.exists(), "quick-start preflight created {}", path.display());
-    }
-    assert!(transport.calls().is_empty(), "no transport calls before preflight rejection");
-    assert!(transport.spawn_records().is_empty());
-}
-
-#[test]
-fn quick_start_schema_invalid_pi_role_is_mutation_free() {
-    let role_doc = QS_VALID_ROLE
-        .replace(
-            "provider: codex\nmodel: gpt-5.5",
-            "provider: pi\nmodel: openai-codex/gpt-5.6-sol",
-        )
-        .replace("  - mcp_team", "  - fs_read");
-    let team = quick_start_team_dir(&role_doc);
-    let workspace = crate::model::paths::team_workspace(&team).unwrap();
-    let role_path = team.join("agents/implementer.md");
-    let team_md_path = team.join("TEAM.md");
-    let role_before = std::fs::read(&role_path).unwrap();
-    let team_md_before = std::fs::read(&team_md_path).unwrap();
-    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
-        &workspace,
-        "quickteam",
-        "implementer",
-    );
-    let absent_paths = [
-        team.join("team.spec.yaml"),
-        crate::state::persist::runtime_state_path(&workspace),
-        crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
-        workspace.join("team_state.md"),
-        workspace.join(".team/logs/events.jsonl"),
-        workspace.join(".team/runtime/team.db"),
-        pi_paths.wrapper,
-        pi_paths.sessions,
-    ];
-    for path in &absent_paths {
-        assert!(!path.exists(), "precondition: {} must be absent", path.display());
-    }
-
-    let transport = OfflineTransport::new();
-    let mut calls = 0;
-    let mut discover = |_requested: &str| {
-        calls += 1;
-        Ok(Vec::new())
-    };
-    let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
-        &workspace,
-        &team,
-        None,
-        true,
-        None,
-        &transport,
-        true,
-        &mut discover,
-    )
-    .expect_err("invalid Pi schema must fail before quick-start mutation");
-    drop(discover);
-    assert_eq!(calls, 0, "qualified models must not invoke discovery");
-    match error {
-        LifecycleError::Compile(message) => {
-            assert!(message.contains("Pi roles require mcp_team"), "{message}");
-        }
-        other => panic!("expected Pi role schema error, got {other:?}"),
-    }
-    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
-    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
-    for path in &absent_paths {
-        assert!(!path.exists(), "schema preflight created {}", path.display());
-    }
-    assert!(transport.calls().is_empty(), "no transport calls before schema rejection");
-    assert!(transport.spawn_records().is_empty());
-}
-
 // P0 — launch (dry_run) over a real compiled spec must resolve the REAL route/permission plan
 // (no spawn) — NOT the hardcoded RequirementUnmet stub. Golden: launch/core.py dry_run resolves
 // routing + permissions without starting any process.
@@ -813,7 +730,9 @@ fn unowned_running_ws_all_paused() -> PathBuf {
 // #15 — quick_start seeds runtime state under team_workspace(team_dir) (the PARENT), not inside the
 // team dir, so restart/status can locate it. Golden quick_start.py:35 team_workspace(team_dir).
 #[test]
+#[serial(env)]
 fn spine_quick_start_seeds_state_under_team_workspace_not_team_dir() {
+    let _hermetic = enter_hermetic("launch-spawn-spine-workspace");
     let team = quick_start_team_dir(QS_VALID_ROLE); // <base>/teamdir
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, None, &transport);
@@ -1362,7 +1281,9 @@ fn seed_canonical_team_identity(workspace: &std::path::Path, team_key: &str) {
 // RED at assertion (NOT a panic). OS-safe: recording transport (no real tmux) + seeded-healthy
 // coordinator (start_coordinator AlreadyRunning -> no daemon subprocess).
 #[test]
+#[serial(env)]
 fn quick_start_with_transport_spawns_workers_not_dry_run() {
+    let _hermetic = enter_hermetic("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);
@@ -1449,7 +1370,9 @@ 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 roles = (1..=4)
         .map(|i| {
             let id = format!("w{i}");
@@ -1532,7 +1455,9 @@ fn quick_start_tmux_backend_prefers_absolute_tmux_env_endpoint() {
 }
 
 #[test]
+#[serial(env)]
 fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
+    let _hermetic = enter_hermetic("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);
@@ -1591,7 +1516,9 @@ 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");
     seed_healthy_coordinator(workspace);
@@ -1683,7 +1610,9 @@ fn attach_window_names_for_state_agents_include_managed_leader_and_layout_window
 }
 
 #[test]
+#[serial(env)]
 fn quick_start_no_display_keeps_one_window_per_agent() {
+    let _hermetic = enter_hermetic("launch-spawn-no-display");
     let roles = ["w1", "w2"]
         .into_iter()
         .map(|id| (format!("{id}.md"), role_doc(id)))
@@ -3095,7 +3024,9 @@ fn start_agent_adaptive_restarts_missing_pane_in_existing_layout_window() {
 // OS-safe: OfflineTransport (zero real spawn).
 // ═══════════════════════════════════════════════════════════════════════════
 #[test]
+#[serial(env)]
 fn quick_start_seeds_tasks_key_from_compiled_spec() {
+    let _hermetic = enter_hermetic("launch-spawn-tasks-key");
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, None, &transport);
@@ -3146,6 +3077,7 @@ fn quick_start_seeds_tasks_key_from_compiled_spec() {
 #[test]
 #[serial(env)]
 fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
+    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)
     // would otherwise leak into the caller-identity seed, inflate the seeded owner
@@ -3245,6 +3177,7 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
 #[test]
 #[serial(env)]
 fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
+    let _hermetic = enter_hermetic("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);

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

@@ -1,3 +1,6 @@
+#[path = "../../../tests/support/hermetic.rs"]
+mod hermetic_guard;
+
 use super::agent_ops::lanea_team_ws;
 use super::lane_ops::{fork_ws, LaneHomeGuard, LaneTransport};
 use super::launch_spawn::{
@@ -19,11 +22,17 @@ use serde_json::json;
 use std::collections::BTreeSet;
 use std::time::Duration;
 
-#[allow(dead_code)]
-struct 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
+}
 
 #[test]
+#[serial_test::serial(env)]
 fn concurrent_reset_discard_session_serializes() {
+    let _hermetic = enter_hermetic("phase-b-concurrent-reset");
     let ids = (1..=6).map(|n| format!("w{n}")).collect::<Vec<_>>();
     let role_docs = ids
         .iter()
@@ -131,6 +140,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 _home = LaneHomeGuard::enter("phase-b-fork");
     let (add_team, add_workspace, add_role, add_transport) = add_fixture();
     let add_agent = aid("w2");
@@ -313,7 +323,9 @@ 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 (workspace, _team) = breal_workspace();
     let transport = BRealTransport::misowned();
 
@@ -425,7 +437,9 @@ 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 (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

@@ -90,6 +90,9 @@ fn hermetic_caller_envs() -> &'static [&'static str] {
         "TEAM_AGENT_OWNER_TEAM_ID",
         "TEAM_AGENT_ACTIVE_TEAM",
         "TEAM_AGENT_ID",
+        "TEAM_AGENT_CALLER_PROVIDER",
+        "TEAM_AGENT_CALLER_PANE_ID",
+        "TEAM_AGENT_CALLER_TMUX_ENDPOINT",
     ]
 }
 
@@ -176,28 +179,40 @@ fn phase_f_golden_events_state_status_zero_drift() {
 #[test]
 #[serial_test::serial(env)]
 fn phase_golden_unbound_not_ready_requires_claim_leader() {
-    // Unbound recovery guidance belongs to the diagnose/quick-start refusal
-    // surface, not to the seven-field status brief.
     let diagnose = run_diagnose_after_quick_start();
     let issues = diagnose
         .get("issues")
         .and_then(Value::as_array)
         .cloned()
         .unwrap_or_default();
+    let issue_ids: Vec<&str> = issues
+        .iter()
+        .filter_map(|issue| issue.as_str())
+        .collect();
+    assert_eq!(
+        issue_ids
+            .iter()
+            .copied()
+            .filter(|id| *id == "leader_registry_index_missing")
+            .count(),
+        1,
+        "tombstone after seeded owner without registry must be exactly index-missing; diagnose={diagnose}"
+    );
     assert!(
-        issues.iter().any(|issue| {
-            issue.as_str() == Some("leader_not_attached")
-                || issue.get("id").and_then(Value::as_str) == Some("leader_channel_unbound")
-        }),
-        "tombstone fixture must still diagnose leader_receiver_unbound; diagnose={diagnose}"
+        !issue_ids.contains(&"leader_receiver_not_committed"),
+        "parallel not_committed bool must not appear; diagnose={diagnose}"
     );
     let repairs = diagnose
         .get("suggested_repairs")
         .map(Value::to_string)
         .unwrap_or_default();
     assert!(
-        repairs.contains("claim-leader"),
-        "diagnose must retain claim-leader recovery guidance; diagnose={diagnose}"
+        repairs.contains("publish the leader registry index"),
+        "index-missing repair must publish the index; diagnose={diagnose}"
+    );
+    assert!(
+        !repairs.contains("team-agent claim-leader --confirm"),
+        "index-missing must not recommend claim-leader --confirm; diagnose={diagnose}"
     );
 }
 
@@ -490,6 +505,36 @@ fn run_diagnose_after_quick_start() -> Value {
         false,
     )
     .expect("tombstone fixture must quick-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(
+        &mut state,
+        crate::state::owner_gate::CallerIdentity {
+            pane_id: "%1".to_string(),
+            provider: "codex".to_string(),
+            machine_fingerprint: "fp".to_string(),
+            leader_session_uuid: "uuid-tombstone".to_string(),
+            leader_session_uuid_source: "env".to_string(),
+        },
+        |_| None,
+    );
+    crate::state::persist::save_runtime_state(&workspace, &state)
+        .expect("persist seeded owner without registry");
+    if let Some(dir) = crate::leader::registry::registry_dir() {
+        if let Ok(entries) = std::fs::read_dir(&dir) {
+            for entry in entries.flatten() {
+                let _ = std::fs::remove_file(entry.path());
+            }
+        }
+    }
+    assert!(
+        state
+            .pointer("/teams/teamdir/team_owner/pane_id")
+            .or_else(|| state.pointer("/team_owner/pane_id"))
+            .and_then(Value::as_str)
+            .is_some(),
+        "index-missing diagnose requires a persisted seeded owner"
+    );
     let diagnose = cmd_diagnose(&DiagnoseArgs {
         workspace,
         json: true,