@team-agent/installer 0.3.13 → 0.3.15

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

@@ -1,6 +1,7 @@
 use super::*;
 use crate::transport::test_support::OfflineTransport;
 use serial_test::serial;
+use serde_json::json;
 
 const QS_TEAM_MD: &str =
     "---\nname: quickteam\nobjective: Quick start.\nprovider: codex\n---\n\nQuick-start team.\n";
@@ -18,6 +19,38 @@ pub(super) fn quick_start_team_dir(role_doc: &str) -> PathBuf {
     team
 }
 
+fn quick_start_team_dir_with_roles(role_docs: &[(&str, &str)]) -> PathBuf {
+    let team = temp_ws().join("teamdir");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+    for (file, role_doc) in role_docs {
+        std::fs::write(team.join("agents").join(file), role_doc).unwrap();
+    }
+    team
+}
+
+fn role_doc(id: &str) -> String {
+    format!(
+        "---\nname: {id}\nrole: {id} Worker\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\n{id} worker.\n"
+    )
+}
+
+fn layout_pane(session: &str, window: &str, pane: &str, pane_index: u32) -> crate::transport::PaneInfo {
+    crate::transport::PaneInfo {
+        pane_id: crate::transport::PaneId::new(pane),
+        session: crate::transport::SessionName::new(session),
+        window_index: None,
+        window_name: Some(crate::transport::WindowName::new(window)),
+        pane_index: Some(pane_index),
+        tty: None,
+        current_command: Some("codex".to_string()),
+        current_path: None,
+        active: pane_index == 0,
+        pane_pid: None,
+        leader_env: std::collections::BTreeMap::new(),
+    }
+}
+
 /// E5 spec 迁移:spec 不再落 team_dir,而在 <team_workspace>/.team/runtime/<team_key>/。
 /// team_key = team_dir.name(quick_start_team_dir → "teamdir");workspace = team_workspace(team)。
 pub(super) fn quick_start_runtime_spec_path(team: &std::path::Path) -> PathBuf {
@@ -121,12 +154,23 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
 
     let transport = OfflineTransport::new();
     let result = quick_start_with_transport(&team, None, true, true, None, &transport);
-    assert!(matches!(result, Ok(QuickStartReport::Ready { .. })), "quick-start failed: {result:?}");
+    assert!(
+        matches!(result, Ok(QuickStartReport::Ready { .. })),
+        "quick-start failed: {result:?}"
+    );
 
     let state_path = crate::state::persist::runtime_state_path(&workspace);
-    assert!(state_path.exists(), "quick-start .team/current must persist runtime state under project root");
     assert!(
-        !workspace.join(".team").join(".team").join("runtime").join("state.json").exists(),
+        state_path.exists(),
+        "quick-start .team/current must persist runtime state under project root"
+    );
+    assert!(
+        !workspace
+            .join(".team")
+            .join(".team")
+            .join("runtime")
+            .join("state.json")
+            .exists(),
         "quick-start .team/current must not create nested .team/.team runtime state"
     );
 
@@ -137,11 +181,21 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
             crate::state::selector::SelectorMode::RuntimeOnly,
         )
         .expect("status/collect selector should resolve project root");
-        assert_eq!(selected.run_workspace, workspace, "input={}", input.display());
+        assert_eq!(
+            selected.run_workspace,
+            workspace,
+            "input={}",
+            input.display()
+        );
         // E5: selector resolves spec_path to .team/runtime/<team_key>/ (team_key="current").
         let expected_spec = crate::model::paths::runtime_spec_path(&workspace, "current");
         assert_eq!(
-            selected.spec_path.as_deref().map(std::fs::canonicalize).transpose().unwrap(),
+            selected
+                .spec_path
+                .as_deref()
+                .map(std::fs::canonicalize)
+                .transpose()
+                .unwrap(),
             Some(std::fs::canonicalize(&expected_spec).unwrap()),
             "input={}",
             input.display()
@@ -155,14 +209,20 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
         summary: false,
         json: true,
     });
-    assert!(status.is_ok(), "status should normalize teamdir to project-root runtime state: {status:?}");
+    assert!(
+        status.is_ok(),
+        "status should normalize teamdir to project-root runtime state: {status:?}"
+    );
 
     let collect = crate::cli::cmd_collect(&crate::cli::CollectArgs {
         result_file: None,
         workspace: team.clone(),
         json: true,
     });
-    assert!(collect.is_ok(), "collect should normalize teamdir to the same project-root state/spec: {collect:?}");
+    assert!(
+        collect.is_ok(),
+        "collect should normalize teamdir to the same project-root state/spec: {collect:?}"
+    );
 }
 
 // P0 — quick_start over an INVALID role doc (missing `provider`) must surface the REAL compile
@@ -222,7 +282,15 @@ fn launch_dry_run_resolves_real_plan_not_stub_error() {
 fn start_agent_proceeds_past_owner_gate_for_unowned_workspace() {
     let ws = unowned_running_ws();
     let transport = OfflineTransport::new();
-    let result = start_agent_with_transport(&ws, &AgentId::new("w1"), false, false, true, None, &transport);
+    let result = start_agent_with_transport(
+        &ws,
+        &AgentId::new("w1"),
+        false,
+        false,
+        true,
+        None,
+        &transport,
+    );
     assert!(
         !matches!(result, Err(LifecycleError::OwnerRefused(_))),
         "start_agent must reach the real chain for a no-owner workspace, not hard-refuse owner; got {result:?}"
@@ -292,7 +360,10 @@ fn fork_agent_proceeds_past_owner_gate_for_unowned_workspace() {
 fn quick_start_full_ready_real_spawn() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let report = quick_start(&team, None, true, true, None).expect("quick_start launches the team");
-    assert!(matches!(report, QuickStartReport::Ready { .. }), "got {report:?}");
+    assert!(
+        matches!(report, QuickStartReport::Ready { .. }),
+        "got {report:?}"
+    );
 }
 
 // ═════════════════════════════════════════════════════════════════════════
@@ -375,7 +446,9 @@ fn compiled_spec_path_with_paused_agent(team: &std::path::Path) -> PathBuf {
             _ => None,
         })
         .expect("compiled spec must contain agents");
-    let first = agents.first_mut().expect("compiled spec must contain an agent");
+    let first = agents
+        .first_mut()
+        .expect("compiled spec must contain an agent");
     let crate::model::yaml::Value::Map(agent) = first else {
         panic!("compiled agent must be a map");
     };
@@ -422,7 +495,10 @@ fn spine_launch_dry_run_safety_reflects_spec_dangerous() {
     let team = quick_start_team_dir_custom(QS_TEAM_MD_DANGEROUS, QS_VALID_ROLE);
     let spec_path = compiled_spec_path(&team);
     let report = launch(&spec_path, true, false, true).expect("dry_run launch");
-    assert!(report.safety.enabled, "safety must reflect spec.runtime.dangerous_auto_approve=true");
+    assert!(
+        report.safety.enabled,
+        "safety must reflect spec.runtime.dangerous_auto_approve=true"
+    );
     assert_eq!(
         report.safety.source,
         DangerousApprovalSource::RuntimeConfig,
@@ -463,19 +539,35 @@ fn spine_restart_empty_team_is_not_atomic_refusal() {
     );
 }
 
-// #14 — add_agent rejects a duplicate agent id (golden operations.py:301 'agent id already exists'),
-// BEFORE any full recompile. Current does a full compile_team with no duplicate-id guard.
+// E25 — add_agent duplicate membership is runtime-state based, not role-doc/spec-file based.
 #[test]
 fn spine_add_agent_rejects_duplicate_agent_id() {
     let team = quick_start_team_dir(QS_VALID_ROLE); // team already has agent 'implementer'
+    crate::state::persist::save_runtime_state(
+        &team,
+        &json!({
+            "session_name": "team-quickteam",
+            "agents": {
+                "implementer": {"status": "running", "provider": "codex", "window": "implementer"}
+            }
+        }),
+    )
+    .unwrap();
     let role = team.join("dup-role.md");
     std::fs::write(&role, QS_VALID_ROLE).unwrap(); // a role doc named 'implementer' = duplicate
     let transport = OfflineTransport::new();
-    let result = add_agent_with_transport(&team, &AgentId::new("implementer"), &role, false, None, &transport);
+    let result = add_agent_with_transport(
+        &team,
+        &AgentId::new("implementer"),
+        &role,
+        false,
+        None,
+        &transport,
+    );
     let text = format!("{result:?}");
     assert!(
         text.contains("already exists"),
-        "add_agent must reject a duplicate agent id (golden 'agent id already exists'); got {text}"
+        "add_agent must reject an id already present in runtime state; got {text}"
     );
 }
 
@@ -524,7 +616,7 @@ fn e5_add_agent_does_not_copy_role_into_platform_dir_and_injects_into_spec() {
 #[test]
 fn e5_restart_rebuilds_runtime_spec_from_role_docs() {
     let ws = restart_ws_two_resumable_workers(); // has TEAM.md + agents/{alpha,bravo}.md + state
-    // Edit a role doc AFTER initial compile: change alpha's role text.
+                                                 // Edit a role doc AFTER initial compile: change alpha's role text.
     std::fs::write(
         ws.join("agents").join("alpha.md"),
         "---\nname: alpha\nrole: RENAMED Alpha Role\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nAlpha edited.\n",
@@ -551,10 +643,13 @@ fn e5_restart_rebuilds_runtime_spec_from_role_docs() {
 #[test]
 fn red2_restart_finds_runtime_spec_not_missing_when_user_dir_has_no_spec() {
     let ws = restart_ws_two_resumable_workers(); // has TEAM.md + agents + state
-    // Simulate spec-demote: remove any user-dir spec the fixture wrote; restart must still find
-    // the runtime spec (rebuilt from role docs / read-order B), NOT report "missing spec".
+                                                 // Simulate spec-demote: remove any user-dir spec the fixture wrote; restart must still find
+                                                 // the runtime spec (rebuilt from role docs / read-order B), NOT report "missing spec".
     let _ = std::fs::remove_file(ws.join("team.spec.yaml"));
-    assert!(!ws.join("team.spec.yaml").exists(), "user-dir spec removed (spec-demote condition)");
+    assert!(
+        !ws.join("team.spec.yaml").exists(),
+        "user-dir spec removed (spec-demote condition)"
+    );
     let transport = OfflineTransport::new();
     let result = restart_with_transport(&ws, false, None, &transport);
     // The gate must NOT short-circuit with "missing spec for restart" — restart must proceed
@@ -575,7 +670,11 @@ fn red2_restart_empty_workspace_still_reports_missing() {
     let result = restart_with_transport(&ws, false, None, &transport);
     let text = format!("{result:?}");
     assert!(
-        text.contains("missing spec") || text.to_lowercase().contains("not found") || text.contains("no_local_team_context") || text.to_lowercase().contains("invalid workspace"),
+        text.contains("missing spec")
+            || text.to_lowercase().contains("not found")
+            || text.contains("no_local_team_context")
+            || text.to_lowercase().contains("invalid workspace")
+            || text.contains("role definitions missing"),
         "RED-2 negative: empty workspace restart must still error (missing/not-found); got {text}"
     );
     let _ = std::fs::remove_dir_all(&ws);
@@ -595,7 +694,11 @@ fn red2still_entry_gate_resolves_parent_dot_team_form_a() {
     let base = temp_ws();
     let team_dir = base.join("teamdir");
     std::fs::create_dir_all(team_dir.join("agents")).unwrap();
-    std::fs::write(team_dir.join("TEAM.md"), "---\nname: teamdir\nobjective: o\nprovider: codex\n---\nt.\n").unwrap();
+    std::fs::write(
+        team_dir.join("TEAM.md"),
+        "---\nname: teamdir\nobjective: o\nprovider: codex\n---\nt.\n",
+    )
+    .unwrap();
     std::fs::write(team_dir.join("agents").join("w1.md"), QS_VALID_ROLE).unwrap();
     // .team lives in the PARENT (base), with a runtime spec — mirrors quick-start <dir> from base cwd.
     let spec = crate::compiler::compile_team(&team_dir).unwrap();
@@ -622,7 +725,10 @@ fn red2still_entry_gate_resolves_parent_dot_team_form_a() {
     );
     // Full restart on team_dir must NOT early-exit with missing spec.
     let transport = OfflineTransport::new();
-    let text = format!("{:?}", restart_with_transport(&team_dir, false, None, &transport));
+    let text = format!(
+        "{:?}",
+        restart_with_transport(&team_dir, false, None, &transport)
+    );
     assert!(
         !text.contains("missing spec for restart") && !text.contains("active team spec not found"),
         "RED-2-STILL Form A: restart <team_dir> (.team in parent) must not report missing; got {text}"
@@ -635,7 +741,11 @@ fn red2still_entry_gate_same_dir_dot_team_form_b() {
     // Form B: .team in team_dir itself (cwd == team_dir at quick-start time).
     let team_dir = temp_ws();
     std::fs::create_dir_all(team_dir.join("agents")).unwrap();
-    std::fs::write(team_dir.join("TEAM.md"), "---\nname: tb\nobjective: o\nprovider: codex\n---\nt.\n").unwrap();
+    std::fs::write(
+        team_dir.join("TEAM.md"),
+        "---\nname: tb\nobjective: o\nprovider: codex\n---\nt.\n",
+    )
+    .unwrap();
     std::fs::write(team_dir.join("agents").join("w1.md"), QS_VALID_ROLE).unwrap();
     let spec = crate::compiler::compile_team(&team_dir).unwrap();
     let runtime_spec = crate::model::paths::runtime_spec_path(&team_dir, "tb");
@@ -649,7 +759,10 @@ fn red2still_entry_gate_same_dir_dot_team_form_b() {
     )
     .unwrap();
     let transport = OfflineTransport::new();
-    let text = format!("{:?}", restart_with_transport(&team_dir, false, None, &transport));
+    let text = format!(
+        "{:?}",
+        restart_with_transport(&team_dir, false, None, &transport)
+    );
     assert!(
         !text.contains("missing spec for restart") && !text.contains("active team spec not found"),
         "RED-2-STILL Form B: restart <team_dir> (.team in team_dir) must not report missing; got {text}"
@@ -703,7 +816,8 @@ fn e5_add_agent_resolves_team_dir_to_role_dir_when_runtime_spec_exists() {
     )
     .unwrap();
     let transport = OfflineTransport::new();
-    let result = add_agent_with_transport(&team, &AgentId::new("w2"), &role, false, None, &transport);
+    let result =
+        add_agent_with_transport(&team, &AgentId::new("w2"), &role, false, None, &transport);
     // Core decoupling signature: must NOT fail because compile_team looked for TEAM.md/agents under
     // the runtime spec dir. Before the fix, team_dir=spec_workspace(runtime) → "missing TEAM.md".
     let text = format!("{result:?}");
@@ -825,15 +939,29 @@ fn launch_with_transport_records_one_spawn_per_agent_carrying_build_command() {
         "exactly one spawn per started agent; recorded={recorded:?} started={:?}",
         report.started
     );
-    assert!(!report.started.is_empty(), "a real (non-dry-run) launch must spawn >=1 worker");
-    assert!(!report.dry_run, "launch_with_transport(dry_run=false) must report dry_run=false");
-    assert_eq!(recorded[0].0, "spawn_first", "the first worker uses new-session (spawn_first)");
     assert!(
-        recorded.iter().any(|(_, argv)| argv.iter().any(|a| a == "codex")),
+        !report.started.is_empty(),
+        "a real (non-dry-run) launch must spawn >=1 worker"
+    );
+    assert!(
+        !report.dry_run,
+        "launch_with_transport(dry_run=false) must report dry_run=false"
+    );
+    assert_eq!(
+        recorded[0].0, "spawn_first",
+        "the first worker uses new-session (spawn_first)"
+    );
+    assert!(
+        recorded
+            .iter()
+            .any(|(_, argv)| argv.iter().any(|a| a == "codex")),
         "each spawn argv must carry the agent's provider build_command (codex); got {recorded:?}"
     );
     assert!(
-        report.started.iter().any(|s| s.agent_id.as_str() == "implementer"),
+        report
+            .started
+            .iter()
+            .any(|s| s.agent_id.as_str() == "implementer"),
         "LaunchReport.started must list the compiled agent; got {:?}",
         report.started
     );
@@ -853,8 +981,17 @@ pub(super) fn seed_healthy_coordinator(workspace: &std::path::Path) {
     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();
+    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();
 }
 
 // RED — quick_start_with_transport must drive the REAL spawn path: launch.dry_run==false, started
@@ -889,7 +1026,10 @@ fn quick_start_with_transport_spawns_workers_not_dry_run() {
         launch.started
     );
     assert!(
-        launch.started.iter().any(|s| s.agent_id.as_str() == "implementer"),
+        launch
+            .started
+            .iter()
+            .any(|s| s.agent_id.as_str() == "implementer"),
         "launch.started must list the compiled agent 'implementer'; got {:?}",
         launch.started
     );
@@ -899,13 +1039,212 @@ fn quick_start_with_transport_spawns_workers_not_dry_run() {
         !recorded.is_empty(),
         "quick_start must drive the transport spawn path (>=1 spawn recorded); the dry-run bug records ZERO spawns"
     );
-    assert_eq!(recorded[0].0, "spawn_first", "the first worker uses new-session (spawn_first); got {recorded:?}");
+    assert_eq!(
+        recorded[0].0, "spawn_first",
+        "the first worker uses new-session (spawn_first); got {recorded:?}"
+    );
     assert!(
-        recorded.iter().any(|(_, argv)| argv.iter().any(|a| a == "codex")),
+        recorded
+            .iter()
+            .any(|(_, argv)| argv.iter().any(|a| a == "codex")),
         "the spawn argv must carry the agent's provider build_command (codex); got {recorded:?}"
     );
 }
 
+#[test]
+fn adaptive_layout_plan_8_workers_is_3_3_2() {
+    let agents = (1..=8)
+        .map(|i| AgentId::new(format!("w{i}")))
+        .collect::<Vec<_>>();
+    let plan = adaptive_layout_plan(&agents, 3);
+    let windows = plan
+        .iter()
+        .map(|placement| placement.layout_window.as_str().to_string())
+        .collect::<Vec<_>>();
+    assert_eq!(
+        windows,
+        vec![
+            "team-w1", "team-w1", "team-w1", "team-w2", "team-w2", "team-w2", "team-w3",
+            "team-w3",
+        ]
+    );
+    let pane_counts = ["team-w1", "team-w2", "team-w3"]
+        .into_iter()
+        .map(|window| windows.iter().filter(|actual| actual.as_str() == window).count())
+        .collect::<Vec<_>>();
+    assert_eq!(pane_counts, vec![3, 3, 2]);
+    assert_eq!(
+        plan.iter()
+            .filter(|placement| placement.starts_window)
+            .map(|placement| placement.agent_id.as_str().to_string())
+            .collect::<Vec<_>>(),
+        vec!["w1", "w4", "w7"]
+    );
+}
+
+#[test]
+fn quick_start_default_adaptive_groups_workers_into_layout_panes() {
+    let roles = (1..=4)
+        .map(|i| {
+            let id = format!("w{i}");
+            (format!("{id}.md"), role_doc(&id))
+        })
+        .collect::<Vec<_>>();
+    let role_refs = roles
+        .iter()
+        .map(|(file, doc)| (file.as_str(), doc.as_str()))
+        .collect::<Vec<_>>();
+    let team = quick_start_team_dir_with_roles(&role_refs);
+    let workspace = team.parent().expect("team_workspace(team_dir) = parent");
+    seed_healthy_coordinator(workspace);
+    let transport = OfflineTransport::new();
+
+    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+        .expect("quick_start_with_transport must reach Ready");
+
+    let (launch, attach_commands, display_backend) = match report {
+        QuickStartReport::Ready { launch, attach_commands, display_backend, .. } => {
+            (*launch, attach_commands, display_backend)
+        }
+        other => panic!("quick_start must reach Ready; got {other:?}"),
+    };
+    assert_eq!(display_backend, "adaptive");
+    assert_eq!(
+        transport
+            .spawn_records()
+            .iter()
+            .map(|(kind, _)| kind.as_str())
+            .collect::<Vec<_>>(),
+        vec!["spawn_first", "spawn_split", "spawn_split", "spawn_into"],
+        "4 default-adaptive workers should create team-w1 with 3 panes, then team-w2"
+    );
+    assert_eq!(
+        launch
+            .started
+            .iter()
+            .map(|started| {
+                (
+                    started.agent_id.as_str().to_string(),
+                    started.layout_window.as_ref().map(|w| w.as_str().to_string()),
+                    started.pane_index,
+                )
+            })
+            .collect::<Vec<_>>(),
+        vec![
+            ("w1".to_string(), Some("team-w1".to_string()), Some(0)),
+            ("w2".to_string(), Some("team-w1".to_string()), Some(1)),
+            ("w3".to_string(), Some("team-w1".to_string()), Some(2)),
+            ("w4".to_string(), Some("team-w2".to_string()), Some(0)),
+        ]
+    );
+    assert!(
+        attach_commands.iter().any(|cmd| cmd.contains(":team-w1")),
+        "attach commands must include the first layout window: {attach_commands:?}"
+    );
+    assert!(
+        attach_commands.iter().any(|cmd| cmd.contains(":team-w2")),
+        "attach commands must include the second layout window: {attach_commands:?}"
+    );
+
+    let (_raw, state) = raw_runtime_state(workspace);
+    assert_eq!(state["display_backend"], json!("adaptive"));
+    assert_eq!(state.pointer("/agents/w1/window"), Some(&json!("team-w1")));
+    assert_eq!(state.pointer("/agents/w1/layout_window"), Some(&json!("team-w1")));
+    assert_eq!(state.pointer("/agents/w1/pane_index"), Some(&json!(0)));
+    assert_eq!(
+        state.pointer("/agents/w1/display/backend"),
+        Some(&json!("adaptive"))
+    );
+    assert_eq!(
+        state.pointer("/agents/w4/layout_window"),
+        Some(&json!("team-w2"))
+    );
+}
+
+#[test]
+#[serial(env)]
+fn quick_start_tmux_backend_prefers_absolute_tmux_env_endpoint() {
+    let leader_socket = "/tmp/team-agent-layout-leader-socket";
+    let _tmux = EnvVarGuard::set("TMUX", &format!("{leader_socket},123,0"));
+    let backend = quick_start_tmux_backend(std::path::Path::new("/tmp/layout-workspace"));
+
+    assert_eq!(
+        crate::transport::Transport::tmux_endpoint(&backend).as_deref(),
+        Some(leader_socket),
+        "quick-start from inside tmux must use the caller's full $TMUX socket endpoint"
+    );
+    assert_eq!(
+        selected_tmux_socket_source(&backend, std::path::Path::new("/tmp/layout-workspace")),
+        Some("leader_env")
+    );
+}
+
+#[test]
+fn quick_start_persists_selected_tmux_endpoint_and_attach_commands() {
+    let team = quick_start_team_dir(QS_VALID_ROLE);
+    let workspace = team.parent().expect("team_workspace(team_dir) = parent");
+    seed_healthy_coordinator(workspace);
+    let endpoint = "/tmp/team-agent-layout-selected-socket";
+    let transport = OfflineTransport::new().with_tmux_endpoint(endpoint);
+
+    let report = quick_start_with_transport(&team, None, true, true, None, &transport)
+        .expect("quick_start_with_transport must reach Ready");
+    let attach_commands = match report {
+        QuickStartReport::Ready { attach_commands, .. } => attach_commands,
+        other => panic!("quick_start must reach Ready; got {other:?}"),
+    };
+
+    assert!(
+        attach_commands
+            .iter()
+            .any(|cmd| cmd.contains(&format!("tmux -S {endpoint} attach -t "))),
+        "attach commands must use the selected socket endpoint: {attach_commands:?}"
+    );
+    let (_raw, state) = raw_runtime_state(workspace);
+    assert_eq!(state["tmux_endpoint"], json!(endpoint));
+    assert_eq!(state["tmux_socket"], json!(endpoint));
+}
+
+#[test]
+fn quick_start_no_display_keeps_one_window_per_agent() {
+    let roles = ["w1", "w2"]
+        .into_iter()
+        .map(|id| (format!("{id}.md"), role_doc(id)))
+        .collect::<Vec<_>>();
+    let role_refs = roles
+        .iter()
+        .map(|(file, doc)| (file.as_str(), doc.as_str()))
+        .collect::<Vec<_>>();
+    let team = quick_start_team_dir_with_roles(&role_refs);
+    let workspace = team.parent().expect("team_workspace(team_dir) = parent");
+    seed_healthy_coordinator(workspace);
+    let transport = OfflineTransport::new();
+
+    let report = quick_start_with_transport_in_workspace_with_display(
+        workspace, &team, None, true, true, None, &transport, false,
+    )
+    .expect("quick_start_with_transport must reach Ready");
+
+    let display_backend = match report {
+        QuickStartReport::Ready { display_backend, .. } => display_backend,
+        other => panic!("quick_start must reach Ready; got {other:?}"),
+    };
+    assert_eq!(display_backend, "none");
+    assert_eq!(
+        transport
+            .spawn_records()
+            .iter()
+            .map(|(kind, _)| kind.as_str())
+            .collect::<Vec<_>>(),
+        vec!["spawn_first", "spawn_into"],
+        "--no-display must use the legacy one-worker-window spawn path"
+    );
+    let (_raw, state) = raw_runtime_state(workspace);
+    assert_eq!(state["display_backend"], json!("none"));
+    assert_eq!(state.pointer("/agents/w1/window"), Some(&json!("w1")));
+    assert_eq!(state.pointer("/agents/w1/layout_window"), None);
+}
+
 // REAL-MACHINE residency boundary (acceptance framework): the PUBLIC quick_start (real TmuxBackend +
 // real start_coordinator) on a fresh ws must leave a LIVE tmux session AND a ps-verifiable resident
 // coordinator daemon (start_coordinator -> live pid). The framework verifies residency via ps; here we
@@ -917,7 +1256,10 @@ fn quick_start_fresh_ws_spawns_resident_tmux_and_coordinator() {
     let report = quick_start(&team, None, true, true, None).expect("quick_start");
     match report {
         QuickStartReport::Ready { launch, .. } => {
-            assert!(!launch.dry_run, "a real quick_start must spawn (not dry-run)");
+            assert!(
+                !launch.dry_run,
+                "a real quick_start must spawn (not dry-run)"
+            );
             assert!(
                 !launch.started.is_empty(),
                 "a real quick_start must spawn >=1 worker into a live tmux session; got {:?}",
@@ -949,7 +1291,11 @@ pub(super) fn restart_ws_two_resumable_workers() -> PathBuf {
     let bravo_rollout = ws.join("bravo-rollout.jsonl");
     std::fs::write(&alpha_rollout, "{}\n").unwrap();
     std::fs::write(&bravo_rollout, "{}\n").unwrap();
-    std::fs::write(ws.join("TEAM.md"), "---\nname: restartteam\nobjective: Restart probe.\nprovider: codex\n---\n\nteam.\n").unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartteam\nobjective: Restart probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
     std::fs::write(ws.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
     std::fs::write(ws.join("agents").join("bravo.md"), DELEG_ROLE_BRAVO).unwrap();
     let spec = crate::compiler::compile_team(&ws).expect("compile 2-agent team");
@@ -1039,18 +1385,31 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
 
     let ws = restart_ws_two_resumable_workers();
     let dead_after_first = OfflineTransport::new().with_session_absent_after_spawn_first();
-    let result =
-        restart_with_transport_with_readiness_deadline(&ws, false, None, &dead_after_first, Some(0));
+    let result = restart_with_transport_with_readiness_deadline(
+        &ws,
+        false,
+        None,
+        &dead_after_first,
+        Some(0),
+    );
     let recorded = dead_after_first.spawn_records();
     assert_eq!(
         recorded.len(),
-        2,
-        "if the session disappears after alpha, restart must isolate alpha and still try bravo; got result={result:?} recorded={recorded:?}"
+        1,
+        "if a resumed session disappears after alpha, restart must fail fast before bravo; got result={result:?} recorded={recorded:?}"
     );
     assert!(
         recorded.iter().all(|(kind, _)| kind == "spawn_first"),
         "restart must not call spawn_into/new-window against a dead server; result={result:?} recorded={recorded:?}"
     );
+    let result_debug = format!("{result:?}");
+    let report = result.expect("resume integrity failure should return a typed failed report");
+    let RestartReport::Failed { failed_agents, .. } = report else {
+        panic!("resume integrity failure must not be Partial/Restarted; got {report:?}");
+    };
+    assert_eq!(failed_agents.len(), 1);
+    assert_eq!(failed_agents[0].agent_id.as_str(), "alpha");
+    assert_eq!(failed_agents[0].phase, "resume");
     assert!(
         dead_after_first.calls().iter().all(|call| *call != "kill_session"),
         "a single worker/session disappearance must not trigger another shared-session kill; calls={:?}",
@@ -1061,13 +1420,16 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
         .iter()
         .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.agent_failed"))
         .expect("restart.agent_failed event for isolated alpha");
-    assert_eq!(failed.get("agent_id").and_then(|v| v.as_str()), Some("alpha"));
+    assert_eq!(
+        failed.get("agent_id").and_then(|v| v.as_str()),
+        Some("alpha")
+    );
     assert!(
         failed
             .get("error")
             .and_then(|v| v.as_str())
             .is_some_and(|error| error.contains("session_disappeared_after_spawn")),
-        "restart must report the first resumed agent/session disappearance explicitly; event={failed} result={result:?}"
+        "restart must report the first resumed agent/session disappearance explicitly; event={failed} result={result_debug}"
     );
 }
 
@@ -1088,9 +1450,15 @@ fn restart_spawn_failure_isolated_to_partial_report() {
     else {
         panic!("single worker failure must return RestartReport::Partial; got {report:?}");
     };
-    assert!(coordinator_started, "partial restart still starts coordinator for successful agents");
+    assert!(
+        coordinator_started,
+        "partial restart still starts coordinator for successful agents"
+    );
     assert_eq!(
-        agents.iter().map(|agent| agent.agent_id.as_str()).collect::<Vec<_>>(),
+        agents
+            .iter()
+            .map(|agent| agent.agent_id.as_str())
+            .collect::<Vec<_>>(),
         vec!["alpha"]
     );
     assert_eq!(failed_agents.len(), 1);
@@ -1098,8 +1466,18 @@ fn restart_spawn_failure_isolated_to_partial_report() {
     assert_eq!(failed_agents[0].phase, "spawn");
 
     let state = crate::state::persist::load_runtime_state(&ws).unwrap();
-    assert_eq!(state.pointer("/agents/alpha/status").and_then(|v| v.as_str()), Some("running"));
-    assert_eq!(state.pointer("/agents/bravo/status").and_then(|v| v.as_str()), Some("failed"));
+    assert_eq!(
+        state
+            .pointer("/agents/alpha/status")
+            .and_then(|v| v.as_str()),
+        Some("running")
+    );
+    assert_eq!(
+        state
+            .pointer("/agents/bravo/status")
+            .and_then(|v| v.as_str()),
+        Some("failed")
+    );
     assert!(
         state
             .pointer("/agents/bravo/restart_error")
@@ -1113,7 +1491,10 @@ fn restart_spawn_failure_isolated_to_partial_report() {
         .iter()
         .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.completed"))
         .expect("restart.completed event for partial restart");
-    assert_eq!(completed.get("rc").and_then(|v| v.as_str()), Some("partial"));
+    assert_eq!(
+        completed.get("rc").and_then(|v| v.as_str()),
+        Some("partial")
+    );
     assert!(
         completed
             .get("successful_agents")
@@ -1201,10 +1582,14 @@ fn restart_times_out_when_spawned_worker_pane_is_not_addressable() {
     let events = crate::event_log::EventLog::new(&ws).tail(20).unwrap();
     let timeout = events
         .iter()
-        .find(|event| event.get("event").and_then(|v| v.as_str()) == Some("restart.readiness_timeout"))
+        .find(|event| {
+            event.get("event").and_then(|v| v.as_str()) == Some("restart.readiness_timeout")
+        })
         .expect("restart.readiness_timeout event");
     assert_eq!(
-        timeout.get("worker_pane_addressable").and_then(|v| v.as_bool()),
+        timeout
+            .get("worker_pane_addressable")
+            .and_then(|v| v.as_bool()),
         Some(false),
         "timeout event must carry the failed readiness condition: {timeout}"
     );
@@ -1230,7 +1615,15 @@ fn start_agent_with_transport_spawns_resume_not_stub() {
     seed_healthy_coordinator(&ws);
     let transport = OfflineTransport::new();
 
-    let _result = start_agent_with_transport(&ws, &AgentId::new("alpha"), false, false, false, None, &transport);
+    let _result = start_agent_with_transport(
+        &ws,
+        &AgentId::new("alpha"),
+        false,
+        false,
+        false,
+        None,
+        &transport,
+    );
 
     let recorded = transport.spawn_records();
     assert_eq!(
@@ -1253,14 +1646,25 @@ fn start_agent_with_transport_spawns_resume_not_stub() {
 fn add_agent_with_transport_spawns_new_worker_not_stub() {
     let team = temp_ws().join("addteam");
     std::fs::create_dir_all(team.join("agents")).unwrap();
-    std::fs::write(team.join("TEAM.md"), "---\nname: addteam\nobjective: Add probe.\nprovider: codex\n---\n\nteam.\n").unwrap();
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: addteam\nobjective: Add probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
     std::fs::write(team.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap(); // existing agent
     let role_file = team.join("worker2-role.md"); // OUTSIDE agents/ -> not a duplicate of an existing agent
     std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
     seed_healthy_coordinator(&team);
     let transport = OfflineTransport::new();
 
-    let _result = add_agent_with_transport(&team, &AgentId::new("worker2"), &role_file, false, None, &transport);
+    let _result = add_agent_with_transport(
+        &team,
+        &AgentId::new("worker2"),
+        &role_file,
+        false,
+        None,
+        &transport,
+    );
 
     // (a) the recompiled spec was written (real subsystem step). E5: under .team/runtime/<team_key>/,
     // NOT the user team dir.
@@ -1286,6 +1690,419 @@ fn add_agent_with_transport_spawns_new_worker_not_stub() {
     );
 }
 
+#[test]
+fn add_agent_role_doc_exists_runtime_missing_succeeds() {
+    let team = temp_ws().join("add_role_doc_team");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: addroledoc\nobjective: Add role-doc probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(team.join("agents").join("implementer.md"), QS_VALID_ROLE).unwrap();
+    let role_file = team.join("agents").join("worker2.md");
+    std::fs::write(&role_file, DELEG_ROLE_WORKER2).unwrap();
+    crate::state::persist::save_runtime_state(
+        &team,
+        &json!({
+            "session_name": "team-addroledoc",
+            "agents": {
+                "implementer": {"status": "running", "provider": "codex", "window": "implementer"}
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&team);
+    let transport = OfflineTransport::new();
+
+    let result = add_agent_with_transport(
+        &team,
+        &AgentId::new("worker2"),
+        &role_file,
+        false,
+        None,
+        &transport,
+    );
+
+    assert!(
+        result.is_ok(),
+        "a prepared agents/<id>.md role doc is not membership; runtime state is authoritative: {result:?}"
+    );
+    let state = crate::state::persist::load_runtime_state(&team).expect("load state");
+    assert!(
+        state.pointer("/agents/worker2").is_some(),
+        "add-agent must add worker2 to runtime state; state={state}"
+    );
+    assert_eq!(
+        transport.spawn_records().len(),
+        1,
+        "add-agent must spawn exactly the new worker"
+    );
+}
+
+#[test]
+fn start_agent_runtime_missing_role_doc_exists_no_side_effect() {
+    let team = temp_ws().join("start_missing_team");
+    std::fs::create_dir_all(team.join("agents")).unwrap();
+    std::fs::write(
+        team.join("TEAM.md"),
+        "---\nname: startmissing\nobjective: Start missing probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(team.join("agents").join("reviewer.md"), DELEG_ROLE_WORKER2).unwrap();
+    crate::state::persist::save_runtime_state(
+        &team,
+        &json!({
+            "session_name": "team-startmissing",
+            "agents": {
+                "implementer": {"status": "running", "provider": "codex", "window": "implementer"}
+            }
+        }),
+    )
+    .unwrap();
+    let transport = OfflineTransport::new();
+
+    let result = start_agent_with_transport(
+        &team,
+        &AgentId::new("reviewer"),
+        false,
+        false,
+        true,
+        None,
+        &transport,
+    );
+
+    let text = format!("{result:?}");
+    assert!(
+        text.contains("not found"),
+        "start-agent must refuse runtime-missing agents before side effects; got {text}"
+    );
+    assert!(
+        transport.spawn_records().is_empty(),
+        "runtime-missing start-agent must not spawn a pane"
+    );
+    assert!(
+        !team
+            .join(".team")
+            .join("runtime")
+            .join("mcp")
+            .join("reviewer.json")
+            .exists(),
+        "runtime-missing start-agent must not write worker MCP config"
+    );
+    let events = crate::event_log::EventLog::new(&team)
+        .tail(20)
+        .unwrap_or_default();
+    assert!(
+        !events.iter().any(|event| {
+            event.get("event").and_then(|v| v.as_str()) == Some("start_agent.agent_start")
+        }),
+        "runtime-missing start-agent must not emit start_agent.agent_start; events={events:?}"
+    );
+}
+
+#[test]
+fn restart_allow_fresh_copilot_persists_expected_session_id() {
+    let ws = temp_ws().join("restartcopilot");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartcopilot\nobjective: Restart copilot probe.\nprovider: copilot\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(
+        ws.join("agents").join("alpha.md"),
+        "---\nname: alpha\nrole: Alpha Worker\nprovider: copilot\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nAlpha.\n",
+    )
+    .unwrap();
+    let spec = crate::compiler::compile_team(&ws).expect("compile copilot team");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-restartcopilot",
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "provider": "copilot",
+                    "window": "alpha",
+                    "first_send_at": "2026-05-27T10:00:00+00:00",
+                    "session_id": null,
+                    "rollout_path": "/tmp/stale-copilot-rollout.jsonl",
+                    "captured_at": "2026-05-27T10:00:00+00:00",
+                    "captured_via": "stale",
+                    "attribution_confidence": "stale"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&ws);
+    let transport = OfflineTransport::new();
+
+    let result = restart_with_transport(&ws, true, None, &transport);
+
+    assert!(
+        matches!(result, Ok(RestartReport::Restarted { .. })),
+        "allow-fresh restart should fresh-spawn the copilot worker; got {result:?}"
+    );
+    let recorded = transport.spawn_records();
+    assert_eq!(
+        recorded.len(),
+        1,
+        "expected one copilot spawn; got {recorded:?}"
+    );
+    let session_arg = recorded[0]
+        .1
+        .windows(2)
+        .find_map(|pair| (pair[0] == "--session-id").then(|| pair[1].clone()))
+        .expect("copilot fresh spawn argv must include --session-id");
+    let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
+    let agent = state.pointer("/agents/alpha").expect("alpha state");
+    assert_eq!(
+        agent.get("session_id").and_then(serde_json::Value::as_str),
+        Some(session_arg.as_str()),
+        "fresh restart must promote expected_session_id to persisted session_id"
+    );
+    assert_eq!(
+        agent
+            .get("_pending_session_id")
+            .and_then(serde_json::Value::as_str),
+        Some(session_arg.as_str()),
+        "fresh restart must retain pending session audit state"
+    );
+    for stale in [
+        "rollout_path",
+        "captured_at",
+        "captured_via",
+        "attribution_confidence",
+    ] {
+        assert_eq!(
+            agent.get(stale),
+            Some(&serde_json::Value::Null),
+            "fresh restart must clear stale capture field {stale}: {agent}"
+        );
+    }
+    let plan = crate::lifecycle::restart::classify_restart_plan(&state, false)
+        .expect("classify second restart");
+    assert!(
+        plan.unresumable
+            .iter()
+            .all(|worker| worker.reason != "no_persisted_session_id"),
+        "second restart must not loop as no_persisted_session_id; unresumable={:?}",
+        plan.unresumable
+    );
+}
+
+#[test]
+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,
+            "display_backend": "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]
+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,
+            "display_backend": "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"))];
+    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 spec = crate::compiler::compile_team(&team).unwrap();
+    std::fs::write(team.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    let session = "team-layout-stop";
+    crate::state::persist::save_runtime_state(
+        &team,
+        &json!({
+            "session_name": session,
+            "display_backend": "adaptive",
+            "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();
+    let transport = OfflineTransport::new()
+        .with_targets(vec![
+            layout_pane(session, "team-w1", "%1", 0),
+            layout_pane(session, "team-w1", "%2", 1),
+        ])
+        .with_pane_presence("%2", true);
+
+    let report =
+        stop_agent_with_transport(&team, &AgentId::new("w2"), None, &transport).unwrap();
+
+    assert!(report.stopped);
+    assert_eq!(report.target, "%2");
+    assert!(
+        transport.calls().iter().any(|call| *call == "kill_pane"),
+        "adaptive stop must kill only the target pane"
+    );
+    assert!(
+        !transport.calls().iter().any(|call| *call == "kill_window"),
+        "adaptive stop must not kill the shared layout window"
+    );
+    let (_raw, state) = raw_runtime_state(&team);
+    assert_eq!(state.pointer("/agents/w1/pane_id"), Some(&json!("%1")));
+    assert_eq!(state.pointer("/agents/w1/layout_window"), Some(&json!("team-w1")));
+}
+
+#[test]
+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",
+            "display_backend": "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
@@ -1306,7 +2123,9 @@ fn quick_start_seeds_tasks_key_from_compiled_spec() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
-    let workspace = team.parent().expect("team_workspace(<base>/teamdir) = <base>");
+    let workspace = team
+        .parent()
+        .expect("team_workspace(<base>/teamdir) = <base>");
     let state = crate::state::persist::load_runtime_state(workspace)
         .expect("runtime state.json must exist after quick_start");
     // (b) the tasks KEY must always be present and a JSON array (golden launch/core.py:69 default []).
@@ -1318,10 +2137,14 @@ fn quick_start_seeds_tasks_key_from_compiled_spec() {
             state.as_object().map(|o| o.keys().cloned().collect::<Vec<_>>())
         ),
     };
-    let tasks = tasks.as_array().expect("`tasks` must be a JSON array (golden default [])");
+    let tasks = tasks
+        .as_array()
+        .expect("`tasks` must be a JSON array (golden default [])");
     // (a) spec.tasks must be carried into runtime state — the doc compiler's default task id.
     assert!(
-        tasks.iter().any(|t| t.get("id").and_then(|v| v.as_str()) == Some("task_initial")),
+        tasks
+            .iter()
+            .any(|t| t.get("id").and_then(|v| v.as_str()) == Some("task_initial")),
         "state.tasks must carry the compiled spec's task (id=task_initial); got {tasks:?}"
     );
 }
@@ -1355,11 +2178,18 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
-    let workspace = team.parent().expect("team_workspace(<base>/teamdir) = <base>");
+    let workspace = team
+        .parent()
+        .expect("team_workspace(<base>/teamdir) = <base>");
     // 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);
-    let keys = state.as_object().expect("state root object").keys().cloned().collect::<Vec<_>>();
+    let keys = state
+        .as_object()
+        .expect("state root object")
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>();
     assert_eq!(
         keys,
         vec![
@@ -1382,7 +2212,10 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
          truth (no shadow copy on the root that callers could read across teams); \
          raw={raw}"
     );
-    assert_eq!(state["spec_path"], json!(spec_path.canonicalize().unwrap().to_string_lossy()));
+    assert_eq!(
+        state["spec_path"],
+        json!(spec_path.canonicalize().unwrap().to_string_lossy())
+    );
     assert_eq!(state["workspace"], json!(workspace.to_string_lossy()));
     assert_eq!(state["team_dir"], json!(team.to_string_lossy()));
     assert_eq!(state["session_name"], json!("team-quickteam"));
@@ -1392,21 +2225,25 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
         "leader must be copied from compiled spec.leader"
     );
     assert!(
-        state["agents"].as_object().is_some_and(|agents| agents.contains_key("implementer")),
+        state["agents"]
+            .as_object()
+            .is_some_and(|agents| agents.contains_key("implementer")),
         "existing agents value must remain seeded from compiled spec; got {:?}",
         state["agents"]
     );
     assert!(
         state["tasks"].as_array().is_some_and(|tasks| {
-            tasks.iter().any(|task| task.get("id").and_then(|id| id.as_str()) == Some("task_initial"))
+            tasks
+                .iter()
+                .any(|task| task.get("id").and_then(|id| id.as_str()) == Some("task_initial"))
         }),
         "existing tasks value must remain seeded from compiled spec; got {:?}",
         state["tasks"]
     );
     assert_eq!(
         state["display_backend"],
-        json!("none"),
-        "golden resolve_display_backend(None, source='launch') defaults to none"
+        json!("adaptive"),
+        "adaptive layout directive: resolve_display_backend(None, source='launch') defaults to adaptive"
     );
 }
 
@@ -1418,17 +2255,23 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
 #[serial(env)]
 fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     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 _clock_guard = EnvVarGuard::set("TEAM_AGENT_TEST_FIXED_SPAWNED_AT", FIXED_SPAWNED_AT);
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let transport = OfflineTransport::new();
     let _ = quick_start_with_transport(&team, None, true, true, None, &transport);
-    let workspace = team.parent().expect("team_workspace(<base>/teamdir) = <base>");
+    let workspace = team
+        .parent()
+        .expect("team_workspace(<base>/teamdir) = <base>");
     let (raw, state) = raw_runtime_state(workspace);
     let agent = state
         .pointer("/agents/implementer")
         .unwrap_or_else(|| panic!("implementer agent state missing; raw={raw}"));
-    let keys = agent.as_object().expect("agent state object").keys().cloned().collect::<Vec<_>>();
+    let keys = agent
+        .as_object()
+        .expect("agent state object")
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>();
     assert_eq!(
         keys,
         vec![
@@ -1447,11 +2290,15 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
             "captured_at",
             "captured_via",
             "attribution_confidence",
+            "layout_window",
+            "layout_index",
+            "pane_index",
+            "display",
             "spawn_cwd",
             "spawned_at",
             "pane_id",
         ],
-        "running agent state key order must match golden launch/core.py:238-255; raw={raw}"
+        "running agent state key order must include adaptive layout fields; raw={raw}"
     );
     assert_eq!(agent["status"], json!("running"));
     assert_eq!(agent["provider"], json!("codex"));
@@ -1459,10 +2306,12 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     assert_eq!(agent["model"], json!("gpt-5.5"));
     assert_eq!(agent["auth_mode"], json!("subscription"));
     assert!(agent["profile"].is_null());
-    assert_eq!(agent["window"], json!("implementer"));
+    assert_eq!(agent["window"], json!("team-w1"));
     assert_eq!(
         agent["mcp_config"],
-        json!(workspace.join(".team/runtime/mcp/implementer.json").to_string_lossy())
+        json!(workspace
+            .join(".team/runtime/mcp/implementer.json")
+            .to_string_lossy())
     );
     assert_eq!(
         agent["permissions"],
@@ -1479,6 +2328,12 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
     assert!(agent["captured_at"].is_null());
     assert!(agent["captured_via"].is_null());
     assert!(agent["attribution_confidence"].is_null());
+    assert_eq!(agent["layout_window"], json!("team-w1"));
+    assert_eq!(agent["layout_index"], json!(0));
+    assert_eq!(agent["pane_index"], json!(0));
+    assert_eq!(agent.pointer("/display/backend"), Some(&json!("adaptive")));
+    assert_eq!(agent.pointer("/display/window"), Some(&json!("team-w1")));
+    assert_eq!(agent.pointer("/display/pane_id"), Some(&json!("%0")));
     // D5 (#264) / Python launch/core.py:253 — fresh launch persists spawn_cwd=workspace.
     assert_eq!(agent["spawn_cwd"], json!(workspace.to_string_lossy()));
     assert_eq!(agent["spawned_at"], json!(FIXED_SPAWNED_AT));
@@ -1495,7 +2350,9 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
 fn quick_start_paused_agent_state_is_paused_provider_only_and_not_spawned() {
     let team = quick_start_team_dir(QS_VALID_ROLE);
     let spec_path = compiled_spec_path_with_paused_agent(&team);
-    let workspace = team.parent().expect("team_workspace(<base>/teamdir) = <base>");
+    let workspace = team
+        .parent()
+        .expect("team_workspace(<base>/teamdir) = <base>");
     crate::state::persist::save_runtime_state(
         workspace,
         &json!({
@@ -1519,7 +2376,12 @@ fn quick_start_paused_agent_state_is_paused_provider_only_and_not_spawned() {
     let agent = state
         .pointer("/agents/implementer")
         .unwrap_or_else(|| panic!("implementer agent state missing; raw={raw}"));
-    let keys = agent.as_object().expect("agent state object").keys().cloned().collect::<Vec<_>>();
+    let keys = agent
+        .as_object()
+        .expect("agent state object")
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>();
     assert_eq!(
         keys,
         vec!["status", "provider"],