@team-agent/installer 0.5.105 → 0.5.107

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

@@ -4,6 +4,7 @@ mod hermetic_guard;
 use super::*;
 use crate::tmux_backend::TmuxBackend;
 use crate::transport::test_support::OfflineTransport;
+use crate::transport::Transport;
 use serde_json::json;
 use serial_test::serial;
 
@@ -1231,6 +1232,64 @@ fn launch_with_transport_records_one_spawn_per_agent_carrying_build_command() {
         "LaunchReport.started must list the compiled agent; got {:?}",
         report.started
     );
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let state = crate::state::persist::load_runtime_state(&workspace).unwrap();
+    let generation = report.started[0].spawned_at.as_str();
+    assert_eq!(state["generation"], generation);
+    let team_key = crate::state::projection::team_state_key(&state);
+    assert_eq!(state["teams"][&team_key]["generation"], generation);
+    let owner = transport.session_owner(&SessionName::new("team-quickteam")).unwrap().unwrap();
+    assert_eq!(owner.generation, generation);
+}
+
+#[test]
+#[serial(env)]
+fn start_agent_session_generation_inherits_birth_or_stamps_recreated_session() {
+    for canonical_state in [false, true] {
+        for existing_session in [true, false] {
+            for explicit_generation in [true, false] {
+                let ws = restart_ws_one_resumable_worker();
+                let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+                let birth = "2026-07-14T00:00:00+00:00";
+                state["agents"]["alpha"]["status"] = json!("stopped");
+                state["agents"]["alpha"]["spawned_at"] = json!(birth);
+                if explicit_generation {
+                    state["generation"] = json!("explicit-session-birth");
+                }
+                let team_key = crate::state::projection::team_state_key(&state);
+                if canonical_state {
+                    state["team_key"] = json!(team_key);
+                    state["active_team_key"] = json!(team_key);
+                    state["teams"] = json!({});
+                    state["teams"][&team_key] = crate::state::projection::compact_team_state(&state);
+                }
+                let inherited = if explicit_generation { "explicit-session-birth" } else { birth };
+                crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+                let transport = OfflineTransport::new()
+                    .with_session_present(existing_session)
+                    .with_session_owner(&ws, &team_key, inherited);
+                let result = start_agent_with_transport(
+                    &ws, &aid("alpha"), false, false, false, None, &transport,
+                ).unwrap();
+                assert!(matches!(result, StartAgentOutcome::Running { .. }), "{result:?}");
+                let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+                let spawned_at = state["agents"]["alpha"]["spawned_at"].as_str().unwrap();
+                assert_ne!(spawned_at, birth);
+                let expected = if existing_session { inherited } else { spawned_at };
+                assert_eq!(state["generation"], expected);
+                if canonical_state {
+                    assert_eq!(state["teams"][&team_key]["generation"], expected);
+                } else {
+                    // Legacy flat state stays flat; generation persistence does
+                    // not implicitly migrate it to a canonical teams table.
+                    assert!(state.get("teams").is_none());
+                }
+                let owner = transport.session_owner(&SessionName::new("team-restartone")).unwrap().unwrap();
+                assert_eq!(owner.generation, expected);
+                assert_eq!(transport.calls().contains(&"set_session_owner_with_generation"), !existing_session);
+            }
+        }
+    }
 }
 
 // ═════════════════════════════════════════════════════════════════════════
@@ -1704,6 +1763,9 @@ fn restart_ws_one_resumable_worker() -> PathBuf {
 #[test]
 fn restart_with_transport_spawns_resumable_workers_not_stub() {
     let ws = restart_ws_two_resumable_workers();
+    let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    state["generation"] = json!("old-destroyed-session-birth");
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let transport = OfflineTransport::new();
 
     let result = restart_with_transport(&ws, false, None, &transport);
@@ -1731,6 +1793,13 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
         matches!(result, Ok(RestartReport::Restarted { coordinator_started: true, .. })),
         "restart must reach RestartReport::Restarted with coordinator_started=true (AlreadyRunning, seeded); got {result:?}"
     );
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let generation = state["agents"]["alpha"]["spawned_at"].as_str().unwrap();
+    assert_ne!(generation, "old-destroyed-session-birth");
+    assert_eq!(state["generation"], generation);
+    assert!(state.get("teams").is_none(), "legacy flat state must remain flat");
+    let owner = transport.session_owner(&SessionName::new("team-restartteam")).unwrap().unwrap();
+    assert_eq!(owner.generation, generation);
     let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
     let completed = events
         .iter()
@@ -2731,130 +2800,6 @@ fn fork_refuses_source_with_partial_tuple() {
     );
 }
 
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn add_agent_adaptive_splits_last_non_full_layout_window() {
-    let roles = [("w1.md", role_doc("w1")), ("w2.md", role_doc("w2"))];
-    let role_refs = roles
-        .iter()
-        .map(|(file, doc)| (*file, doc.as_str()))
-        .collect::<Vec<_>>();
-    let team = quick_start_team_dir_with_roles(&role_refs);
-    let session = "team-layout-add";
-    crate::state::persist::save_runtime_state(
-        &team,
-        &json!({
-            "session_name": session,
-            "legacy_display_key": "adaptive",
-            "active_team_key": "teamdir",
-            "agents": {
-                "w1": {"status": "running", "provider": "codex", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 0, "pane_id": "%1"},
-                "w2": {"status": "running", "provider": "codex", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 1, "pane_id": "%2"}
-            }
-        }),
-    )
-    .unwrap();
-    seed_healthy_coordinator(&team);
-    let role_file = team.join("w3-role.md");
-    std::fs::write(&role_file, role_doc("w3")).unwrap();
-    let transport = OfflineTransport::new()
-        .with_session_present(true)
-        .with_targets(vec![
-            layout_pane(session, "team-w1", "%1", 0),
-            layout_pane(session, "team-w1", "%2", 1),
-        ])
-        .with_pane_presence("%1", true)
-        .with_pane_presence("%2", true);
-
-    add_agent_with_transport(
-        &team,
-        &AgentId::new("w3"),
-        &role_file,
-        true,
-        None,
-        &transport,
-    )
-    .expect("adaptive add-agent should start");
-
-    assert_eq!(
-        transport.spawn_window_records().last(),
-        Some(&(String::from("spawn_split"), String::from("team-w1"))),
-        "last non-full layout window should be split"
-    );
-    let (_raw, state) = raw_runtime_state(&team);
-    assert_eq!(
-        state.pointer("/agents/w3/layout_window"),
-        Some(&json!("team-w1"))
-    );
-    assert_eq!(state.pointer("/agents/w3/pane_index"), Some(&json!(2)));
-}
-
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn add_agent_adaptive_creates_suffix_window_when_last_layout_full_and_name_collides() {
-    let roles = [
-        ("w1.md", role_doc("w1")),
-        ("w2.md", role_doc("w2")),
-        ("w3.md", role_doc("w3")),
-    ];
-    let role_refs = roles
-        .iter()
-        .map(|(file, doc)| (*file, doc.as_str()))
-        .collect::<Vec<_>>();
-    let team = quick_start_team_dir_with_roles(&role_refs);
-    let session = "team-layout-add-full";
-    crate::state::persist::save_runtime_state(
-        &team,
-        &json!({
-            "session_name": session,
-            "legacy_display_key": "adaptive",
-            "active_team_key": "teamdir",
-            "agents": {
-                "w1": {"status": "running", "provider": "codex", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 0, "pane_id": "%1"},
-                "w2": {"status": "running", "provider": "codex", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 1, "pane_id": "%2"},
-                "w3": {"status": "running", "provider": "codex", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 2, "pane_id": "%3"}
-            }
-        }),
-    )
-    .unwrap();
-    seed_healthy_coordinator(&team);
-    let role_file = team.join("w4-role.md");
-    std::fs::write(&role_file, role_doc("w4")).unwrap();
-    let transport = OfflineTransport::new()
-        .with_session_present(true)
-        .with_targets(vec![
-            layout_pane(session, "team-w1", "%1", 0),
-            layout_pane(session, "team-w1", "%2", 1),
-            layout_pane(session, "team-w1", "%3", 2),
-            layout_pane(session, "team-w2", "%9", 0),
-        ])
-        .with_pane_presence("%1", true)
-        .with_pane_presence("%2", true)
-        .with_pane_presence("%3", true);
-
-    add_agent_with_transport(
-        &team,
-        &AgentId::new("w4"),
-        &role_file,
-        true,
-        None,
-        &transport,
-    )
-    .expect("adaptive add-agent should start");
-
-    assert_eq!(
-        transport.spawn_window_records().last(),
-        Some(&(String::from("spawn_into"), String::from("team-w2-2"))),
-        "full last layout window should create next window with collision suffix"
-    );
-    let (_raw, state) = raw_runtime_state(&team);
-    assert_eq!(
-        state.pointer("/agents/w4/layout_window"),
-        Some(&json!("team-w2-2"))
-    );
-    assert_eq!(state.pointer("/agents/w4/pane_index"), Some(&json!(0)));
-}
-
 #[test]
 fn stop_agent_adaptive_kills_target_pane_not_shared_layout_window() {
     let roles = [("w1.md", role_doc("w1")), ("w2.md", role_doc("w2"))];
@@ -2909,55 +2854,6 @@ fn stop_agent_adaptive_kills_target_pane_not_shared_layout_window() {
     );
 }
 
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn start_agent_adaptive_restarts_missing_pane_in_existing_layout_window() {
-    let ws = temp_ws();
-    crate::state::persist::save_runtime_state(
-        &ws,
-        &json!({
-            "session_name": "team-layout-restart",
-            "legacy_display_key": "adaptive",
-            "agents": {
-                "w1": {"status": "running", "provider": "codex", "role": "w1", "model": "gpt-5.5", "auth_mode": "subscription", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 0, "pane_id": "%1"},
-                "w2": {"status": "running", "provider": "codex", "role": "w2", "model": "gpt-5.5", "auth_mode": "subscription", "window": "team-w1", "layout_window": "team-w1", "layout_index": 0, "pane_index": 1, "pane_id": "%2"}
-            }
-        }),
-    )
-    .unwrap();
-    seed_healthy_coordinator(&ws);
-    let transport = OfflineTransport::new()
-        .with_session_present(true)
-        .with_targets(vec![layout_pane("team-layout-restart", "team-w1", "%2", 1)])
-        .with_pane_presence("%1", false)
-        .with_pane_presence("%2", true);
-
-    let outcome = start_agent_with_transport(
-        &ws,
-        &AgentId::new("w1"),
-        false,
-        true,
-        true,
-        None,
-        &transport,
-    )
-    .expect("adaptive restart should spawn");
-
-    assert!(matches!(outcome, StartAgentOutcome::Running { .. }));
-    assert_eq!(
-        transport.spawn_window_records().last(),
-        Some(&(String::from("spawn_split"), String::from("team-w1"))),
-        "missing worker pane should be rebuilt in its existing layout window"
-    );
-    let (_raw, state) = raw_runtime_state(&ws);
-    assert_eq!(
-        state.pointer("/agents/w1/layout_window"),
-        Some(&json!("team-w1"))
-    );
-    assert_eq!(state.pointer("/agents/w1/window"), Some(&json!("team-w1")));
-    assert_eq!(state.pointer("/agents/w2/pane_id"), Some(&json!("%2")));
-}
-
 // ═════════════════════════════════════════════════════════════════════════
 // WAVE 2 · LANE A — agent-lifecycle byte-parity contracts. stop_agent / reset_agent / remove_agent /
 // fork_agent are stubs (OwnerRefused / RequirementUnmet / "session_id missing"). These RED contracts
@@ -3071,6 +2967,8 @@ fn quick_start_state_seeds_spec_path_workspace_leader() {
             // `ResolvedTransport.source` through the launch call site.
             "transport",
             "active_team_key",
+            // Persist physical session birth independently of worker respawns.
+            "generation",
             "teams",
         ],
         "state.json top-level key order must match golden launch/core.py:62-71 \
@@ -3643,175 +3541,6 @@ fn e43_adaptive_placement_skips_existing_agent_whose_live_pane_window_name_diffe
     }
 }
 
-/// **Regression guard — Fix A**: when an existing agent's live pane DOES
-/// reside under the claimed layout_window, placement keeps the prior
-/// behaviour (groups the new agent into that window). This is the canonical
-/// adaptive 1-window-multiple-panes use case.
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn e43_adaptive_placement_groups_into_layout_window_when_live_pane_matches_claim() {
-    use crate::lifecycle::launch::adaptive_placement_for_agent;
-    use crate::model::ids::AgentId;
-    use crate::transport::{SessionName, WindowName};
-
-    let state = json!({
-        "legacy_display_key": "adaptive",
-        "session_name": "team-iso",
-        "agents": {
-            "alpha": {
-                "status": "running",
-                "provider": "codex",
-                "layout_window": "team-w1",
-                "pane_id": "%1",
-            }
-        }
-    });
-
-    let transport = OfflineTransport::new()
-        .with_targets(vec![layout_pane("team-iso", "team-w1", "%1", 0)])
-        .with_windows(vec![WindowName::new("team-w1")]);
-
-    let placement = adaptive_placement_for_agent(
-        &state,
-        &transport,
-        &SessionName::new("team-iso"),
-        &AgentId::new("beta"),
-    )
-    .expect("placement should succeed");
-
-    assert_eq!(
-        placement.layout_window.as_str(),
-        "team-w1",
-        "E43 Fix A regression guard: when alpha's live pane DOES live under \
-         layout_window 'team-w1', the new agent beta should be grouped into \
-         the same window (canonical adaptive behaviour). Got {placement:?}"
-    );
-    assert!(
-        !placement.starts_window,
-        "E43 Fix A regression guard: grouping into an existing window means \
-         starts_window=false (split into the window). Got {placement:?}"
-    );
-}
-
-/// **RED — Fix B**: `adaptive_existing_placement_for_agent` must NOT return a
-/// `starts_window=true` placement that names a window NOT present in
-/// `live_windows`. When the agent's claimed `layout_window` is stale and the
-/// session is effectively per-agent (live windows are named after agent_ids),
-/// the placement must fall back to a per-agent window named after the
-/// agent_id itself — so the subsequent spawn opens a new window, not a split
-/// of a phantom.
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn e43_adaptive_existing_placement_falls_back_to_agent_id_window_when_claim_missing_from_live() {
-    use crate::lifecycle::launch::adaptive_existing_placement_for_agent;
-    use crate::model::ids::AgentId;
-    use crate::transport::{SessionName, WindowName};
-
-    let state = json!({
-        "legacy_display_key": "adaptive",
-        "session_name": "team-iso",
-        "agents": {
-            "demo-director": {
-                "status": "running",
-                "provider": "codex",
-                // Stale claim — live session has no team-w2 window.
-                "layout_window": "team-w2",
-                "pane_id": "%99",
-            }
-        }
-    });
-
-    let transport = OfflineTransport::new()
-        .with_targets(vec![
-            layout_pane("team-iso", "architect", "%1", 0),
-            layout_pane("team-iso", "test-engineer", "%2", 0),
-        ])
-        .with_windows(vec![
-            WindowName::new("architect"),
-            WindowName::new("test-engineer"),
-        ]);
-
-    let placement = adaptive_existing_placement_for_agent(
-        &state,
-        &transport,
-        &SessionName::new("team-iso"),
-        &AgentId::new("demo-director"),
-    )
-    .expect("placement should resolve");
-
-    assert_ne!(
-        placement.layout_window.as_str(),
-        "team-w2",
-        "E43 Fix B: stale claim 'team-w2' is not in live_windows; placement \
-         must NOT reuse that name (otherwise spawn issues split -t :team-w2 \
-         and tmux says 'can't find window: team-w2'). Got {placement:?}"
-    );
-    assert_eq!(
-        placement.layout_window.as_str(),
-        "demo-director",
-        "E43 Fix B: when the claim is stale and the live layout is \
-         per-agent-named, fall back to a window named after the agent_id \
-         (canonical per-agent pattern). Got {placement:?}"
-    );
-    assert!(
-        placement.starts_window,
-        "E43 Fix B: the fallback opens a NEW window (starts_window=true); \
-         do not try to split an existing window with the wrong name. Got \
-         {placement:?}"
-    );
-}
-
-/// **Regression guard — Fix B**: when the agent's claimed layout_window IS
-/// in live_windows, the existing-placement path keeps its current behaviour
-/// (return a starts_window=false placement that splits into the existing
-/// window).
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn e43_adaptive_existing_placement_keeps_starts_window_false_when_claim_in_live_windows() {
-    use crate::lifecycle::launch::adaptive_existing_placement_for_agent;
-    use crate::model::ids::AgentId;
-    use crate::transport::{SessionName, WindowName};
-
-    let state = json!({
-        "legacy_display_key": "adaptive",
-        "session_name": "team-iso",
-        "agents": {
-            "alpha": {
-                "status": "running",
-                "provider": "codex",
-                "layout_window": "team-w1",
-                "pane_id": "%1",
-                "pane_index": 1u64,
-            }
-        }
-    });
-
-    let transport = OfflineTransport::new()
-        .with_targets(vec![layout_pane("team-iso", "team-w1", "%1", 0)])
-        .with_windows(vec![WindowName::new("team-w1")]);
-
-    let placement = adaptive_existing_placement_for_agent(
-        &state,
-        &transport,
-        &SessionName::new("team-iso"),
-        &AgentId::new("alpha"),
-    )
-    .expect("placement should resolve");
-
-    assert_eq!(
-        placement.layout_window.as_str(),
-        "team-w1",
-        "E43 Fix B regression guard: when claim 'team-w1' IS in live_windows, \
-         existing-placement must keep it. Got {placement:?}"
-    );
-    // pane_index=1 → starts_window=false in the existing behaviour.
-    assert!(
-        !placement.starts_window,
-        "E43 Fix B regression guard: existing window + pane_index>0 → \
-         starts_window=false. Got {placement:?}"
-    );
-}
-
 /// **RED — Fix C end-to-end**: `add_agent` end-to-end must NOT emit a
 /// spawn_split with the stale window name. With state carrying
 /// `legacy_display_key=adaptive` + stale `layout_window=team-w2` residue and
@@ -4107,56 +3836,6 @@ fn e45_add_agent_opens_new_window_does_not_split_into_per_agent_window() {
     );
 }
 
-/// **Regression guard**: when the live session DOES have a real `team-w1`
-/// adaptive window with a live pane that matches state's claim, the
-/// existing E43+adaptive grouping behaviour is preserved (split into team-w1
-/// as before). E45 only changes behaviour for per-agent windows.
-#[test]
-#[ignore = "legacy adaptive display layout contract removed; runtime is silent tmux only"]
-fn e45_real_team_w_adaptive_layout_still_groups_into_layout_window() {
-    use crate::lifecycle::launch::adaptive_placement_for_agent;
-    use crate::model::ids::AgentId;
-    use crate::transport::{SessionName, WindowName};
-
-    let state = json!({
-        "legacy_display_key": "adaptive",
-        "session_name": "team-iso",
-        "agents": {
-            "alpha": {
-                "status": "running",
-                "provider": "codex",
-                "layout_window": "team-w1",
-                "layout_index": 0u64,
-                "pane_id": "%1",
-            }
-        }
-    });
-
-    let transport = OfflineTransport::new()
-        .with_targets(vec![layout_pane("team-iso", "team-w1", "%1", 0)])
-        .with_windows(vec![WindowName::new("team-w1")]);
-
-    let placement = adaptive_placement_for_agent(
-        &state,
-        &transport,
-        &SessionName::new("team-iso"),
-        &AgentId::new("beta"),
-    )
-    .expect("E45 regression guard: real team-w1 adaptive layout must still group new agents in");
-
-    assert_eq!(
-        placement.layout_window.as_str(),
-        "team-w1",
-        "E45 regression guard: real `team-w1` adaptive window must still \
-         host new agents (canonical adaptive behaviour). Got {placement:?}"
-    );
-    assert!(
-        !placement.starts_window,
-        "E45 regression guard: grouping into existing team-w1 → \
-         starts_window=false. Got {placement:?}"
-    );
-}
-
 /// **Regression guard**: helper `is_adaptive_layout_window` golden cases.
 /// `team-w1`, `team-w42`, `team-w7-foo` are adaptive; agent_id names and
 /// other shapes are not.

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

@@ -130,11 +130,6 @@ fn lifecycle_lock_long_held_event_records_holder_and_waiter() {
     );
 }
 
-#[test]
-fn lifecycle_lock_phase_b_golden_source_guard() {
-    r2_lifecycle_lock_exists_precondition();
-}
-
 #[test]
 fn r2_lifecycle_lock_exists_precondition() {
     let src = manifest_src();