@team-agent/installer 0.5.106 → 0.5.107

package/crates/team-agent/src/lifecycle/tests/fixtures/pi_native_mcp_host.mjs

@@ -0,0 +1,71 @@
+import { writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const [wrapperPath, receiptPath, cwd] = process.argv.slice(2);
+if (!wrapperPath || !receiptPath || !cwd) throw new Error("expected wrapper, receipt, and cwd");
+
+const registrations = [];
+const unregistrations = [];
+const handlers = new Map();
+const extensionCommands = [{
+  name: "mcp",
+  source: "extension",
+  sourceInfo: { path: "builtin:mcp", source: "builtin", scope: "user", origin: "top-level" },
+}];
+const pi = {
+  on(event, handler) {
+    const list = handlers.get(event) ?? [];
+    list.push(handler);
+    handlers.set(event, list);
+  },
+  getCommands() {
+    return extensionCommands;
+  },
+  getMcpServers() {
+    return registrations.map(({ name, config }) => ({ name, config, extensionPath: "<native-n1-fixture>" }));
+  },
+  getAllTools() {
+    return registrations.flatMap(({ name, config }) => Object.entries(config.toolExposure ?? {})
+      .map(([tool, exposure]) => ({ name: `mcp__${name}__${tool}`, namespace: { name: `mcp__${name}` }, exposure })));
+  },
+  getActiveTools() {
+    return this.getAllTools().filter((tool) => tool.exposure !== "hidden").map((tool) => tool.name);
+  },
+  registerMcpServer(name, config) {
+    registrations.push({ name, config });
+  },
+  unregisterMcpServer(name) {
+    unregistrations.push(name);
+  },
+};
+
+const extension = await import(pathToFileURL(wrapperPath).href);
+if (typeof extension.default !== "function") throw new Error("generated wrapper has no default extension factory");
+await extension.default(pi);
+const context = {
+  cwd,
+  sessionManager: {
+    getSessionFile: () => undefined,
+    getLeafId: () => undefined,
+    getEntries: () => [],
+  },
+};
+for (const handler of handlers.get("session_start") ?? []) {
+  await handler({ type: "session_start" }, context);
+}
+if (registrations.length !== 1) throw new Error(`expected one native MCP registration, saw ${registrations.length}`);
+const expectedTools = Object.keys(registrations[0].config.toolExposure ?? {})
+  .map((tool) => `mcp__${registrations[0].name}__${tool}`);
+const deadline = Date.now() + 3_000;
+while (!expectedTools.every((name) => pi.getActiveTools().includes(name))) {
+  if (Date.now() >= deadline) throw new Error(`native MCP tools never became active: ${pi.getActiveTools()}`);
+  await new Promise((resolve) => setTimeout(resolve, 10));
+}
+const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+if (typeof beforeAgentStart !== "function") throw new Error("generated wrapper omitted before_agent_start wire binding");
+const binding = await beforeAgentStart({ systemPrompt: "N1 fixture" }, context);
+const wirePrompt = binding?.systemPrompt;
+if (typeof wirePrompt !== "string" || !expectedTools.every((name) => wirePrompt.includes(name))) {
+  throw new Error(`native Team tool wire binding is incomplete: ${wirePrompt}`);
+}
+await writeFile(receiptPath, `${JSON.stringify({ registrations, unregistrations, activeTools: pi.getActiveTools(), expectedTools, wirePrompt }, null, 2)}\n`, "utf8");

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

@@ -1321,33 +1321,6 @@ fn lanea_stop_window_present_kills_and_stopped_true() {
     );
 }
 
-// ── STOP #2 (stop-display-noop-2) [RED] — close ghostty_workspace slot: persist display.status/pane_title
-// Golden operations.py:88-92 -> display/close.py:84-85 relabels the slot: display["status"]="stopped",
-// display["pane_title"]=f"stopped: {agent_id}", written back into the persisted agent entry. Rust never
-// touches the display (mark_agent_stopped leaves it as-is) and hardcodes display_closed:false. RED: the
-// persisted display.status/pane_title are the in-process observable.
-#[test]
-#[ignore = "legacy external display contract removed; runtime is silent tmux only"]
-fn lanea_stop_ghostty_workspace_relabels_slot_to_stopped() {
-    let ws = lanea_ws_agents(json!({
-        "alpha": { "status": "running", "provider": "codex", "window": "alpha",
-                   "display": { "backend": "ghostty_workspace", "pane_id": "%5", "linked_session": "disp-alpha", "status": "running", "pane_title": "alpha" } }
-    }));
-    let tx = LaneTransport::new("team-laneateam", &["alpha"]);
-    let _ = stop_agent_with_transport(&ws, &aid("alpha"), None, &tx).expect("stop ok");
-    let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
-    assert_eq!(
-        state.pointer("/agents/alpha/display/status").and_then(serde_json::Value::as_str),
-        Some("stopped"),
-        "stop must relabel a ghostty_workspace slot: display.status='stopped' (close.py:84); Rust leaves it 'running'"
-    );
-    assert_eq!(
-        state.pointer("/agents/alpha/display/pane_title").and_then(serde_json::Value::as_str),
-        Some("stopped: alpha"),
-        "stop must set display.pane_title='stopped: <id>' (close.py:85); Rust never touches the display"
-    );
-}
-
 // ── RESET #3 (reset-paused-restart-2) [RED] — reset of a PAUSED agent returns ok=true (NOT an Err) ───
 // Golden operations.py:126-140: after discard, reset re-spawns via start_agent(force,allow_fresh).
 // discard does NOT clear `paused`, so start_agent returns the refusal-shaped {ok:False,status:paused,
@@ -1851,42 +1824,3 @@ fn fresh_start_persists_boundary_from_before_transport_spawn() {
          spawned_at={spawned_at}, transport_observed_at={transport_observed_at}"
     );
 }
-
-// ── REMOVE #6/#12 (remove-rollback-no-agent-health-3 / remove-rollback-health-1) [SEAM #[ignore]] ────
-// Golden _RemoveRollback captures `self.health = copy.deepcopy(store.agent_health().get(agent_id))`
-// (agents.py:185) and restore() re-upserts it via _restore_agent_health (agents.py:215-218,268-278). The
-// Rust RemoveRollback has NO health field and never restores it (restart.rs:972-1067). This is only
-// observable when a step AFTER the agent_health delete fails — but Rust's only post-delete step is the
-// snapshot, which golden runs OUTSIDE the rollback-protected region (agents.py:135). Exercising it
-// golden-faithfully needs a production failure-injection seam at an in-try step after the delete (mirror
-// the coordinator SaveHook). PORTER: add `health: Option<Value>` to RemoveRollback (capture the row
-// before delete; restore re-upserts status||"IDLE"/last_output_at/context_usage_pct/current_task_id, or
-// deletes if None) AND move save_team_runtime_snapshot OUTSIDE the rollback region (golden agents.py:135).
-#[test]
-#[ignore = "seam: agent_health rollback restore needs a failure-injection hook (post-delete, in-try) to \
-            exercise in-process; golden agents.py:185/215-218/268-278. Porter adds RemoveRollback.health + \
-            moves save_team_runtime_snapshot outside the rollback region."]
-fn lanea_remove_rollback_restores_agent_health() {
-    // Golden contract (verified by reading agents.py): on a mid-remove failure after the agent_health
-    // row is deleted, rollback re-upserts the captured row so the health history is not lost.
-}
-
-// ── FORK (fork-incomplete-rollback) [SEAM #[ignore]] — post-spawn rollback arms ─────────────────────
-// Golden operations.py:384-394 wraps spec-mutation..start_coordinator in try/except; on ANY failure it
-// (1) kills the spawned tmux window if present, (2) adapter.cleanup_mcp, (3) restores old spec text, and
-// (4) restores prior state. Rust only restores the spec on the spawn_into arm (launch.rs:481); the
-// save_runtime_state (486-487) and start_coordinator (488-493) failure arms leave the spec mutated, the
-// already-spawned window un-killed, and the state un-rolled-back; install_mcp/cleanup_mcp are absent.
-// The adapter.fork_plan arm IS covered HARD above (lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm).
-// The post-SPAWN arms need a failure-injection seam after spawn_into (codex+subscription forks past
-// adapter.fork_plan, so the spawn succeeds and there is no in-process way to fail save/coordinator cleanly).
-// PORTER: a Drop guard armed after the spec write, disarmed on success — kills the window, restores spec
-// + state, runs cleanup_mcp on every post-write error arm.
-#[test]
-#[ignore = "seam: fork post-spawn rollback arms (save_runtime_state / start_coordinator failure) need a \
-            failure-injection hook after spawn_into; golden operations.py:384-394. Porter wires a Drop \
-            guard (kill window + restore spec/state + cleanup_mcp) armed after the spec write."]
-fn lanea_fork_rollback_complete_on_post_spawn_failure() {
-    // Golden contract (operations.py:384-394): a post-spawn failure kills the spawned window, restores
-    // the old spec text + prior state, and runs cleanup_mcp before re-raising.
-}

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

@@ -2800,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"))];
@@ -2978,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
@@ -3714,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
@@ -4178,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();