@team-agent/installer 0.4.11 → 0.5.1

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -118,7 +118,9 @@ pub(super) fn spawn_agent_window(
     // persisted agent JSON (state's agent["effort"] field, set by launch).
     let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider);
     if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
-        agent, provider, agent_id.as_str(),
+        agent,
+        provider,
+        agent_id.as_str(),
     ) {
         let _ = crate::event_log::EventLog::new(workspace)
             .write("provider.effort_unsupported", event_value);
@@ -200,10 +202,8 @@ pub(super) fn spawn_agent_window(
             .and_then(|i| plan.argv.get(i + 1))
             .cloned();
         let env_overlay_keys: Vec<&String> = env.keys().collect();
-        let tmux_start_mode_pre_spawn = predict_tmux_start_mode(
-            layout_placement,
-            into_existing_session,
-        );
+        let tmux_start_mode_pre_spawn =
+            predict_tmux_start_mode(layout_placement, into_existing_session);
         let spawn_epoch = state_spawn_epoch_for_agent(workspace, agent_id);
         let event_log = crate::event_log::EventLog::new(workspace);
         let _ = event_log.write(
@@ -311,12 +311,23 @@ pub(super) fn spawn_agent_window(
             agent_id.as_str(),
         );
     }
-    let _ = adapter.handle_startup_prompts(
+    let startup_prompt = adapter.handle_startup_prompts_outcome(
         transport,
         &crate::transport::Target::Pane(spawn.pane_id.clone()),
         30,
         0.5,
     );
+    if let Some(error) = startup_prompt.capture_error.as_deref() {
+        if is_structural_startup_prompt_error(error) {
+            return Err(LifecycleError::Transport(format!(
+                "startup prompt structural failure for {}:{} pane {}: {}",
+                session_name.as_str(),
+                window.as_str(),
+                spawn.pane_id.as_str(),
+                error
+            )));
+        }
+    }
     Ok(SpawnedAgentWindow {
         spawn,
         plan,
@@ -327,6 +338,86 @@ pub(super) fn spawn_agent_window(
     })
 }
 
+fn is_structural_startup_prompt_error(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    [
+        "can't find window",
+        "can't find pane",
+        "cannot find window",
+        "cannot find pane",
+        "target not found",
+        "no such pane",
+        "window disappeared",
+        "pane not owned",
+        "not owned by requested",
+    ]
+    .iter()
+    .any(|needle| lower.contains(needle))
+}
+
+pub(super) fn rehydrate_agent_command_context_from_spec(
+    spec_workspace: &Path,
+    agent_id: &AgentId,
+    agent: &serde_json::Value,
+) -> serde_json::Value {
+    let Ok(spec) = load_team_spec(spec_workspace) else {
+        return agent.clone();
+    };
+    let Some(spec_agent) = find_spec_agent(&spec, agent_id) else {
+        return agent.clone();
+    };
+    merge_command_context_fields(agent, spec_agent)
+}
+
+fn merge_command_context_fields(
+    agent: &serde_json::Value,
+    spec_agent: &YamlValue,
+) -> serde_json::Value {
+    let mut merged = agent.clone();
+    let Some(obj) = merged.as_object_mut() else {
+        return merged;
+    };
+    for field in [
+        "role",
+        "tools",
+        "system_prompt",
+        "output_contract",
+        "provider",
+        "model",
+        "auth_mode",
+        "effort",
+        "profile",
+        "permission_mode",
+    ] {
+        if let Some(value) = spec_agent.get(field).and_then(yaml_value_to_json) {
+            obj.insert(field.to_string(), value);
+        }
+    }
+    merged
+}
+
+fn yaml_value_to_json(value: &YamlValue) -> Option<serde_json::Value> {
+    match value {
+        YamlValue::Null => Some(serde_json::Value::Null),
+        YamlValue::Bool(value) => Some(serde_json::json!(value)),
+        YamlValue::Int(value) => Some(serde_json::json!(value)),
+        YamlValue::Float(value) => Some(serde_json::json!(value)),
+        YamlValue::Str(value) => Some(serde_json::json!(value)),
+        YamlValue::List(items) => Some(serde_json::Value::Array(
+            items.iter().filter_map(yaml_value_to_json).collect(),
+        )),
+        YamlValue::Map(items) => {
+            let mut map = serde_json::Map::new();
+            for (key, value) in items {
+                if let Some(value) = yaml_value_to_json(value) {
+                    map.insert(key.clone(), value);
+                }
+            }
+            Some(serde_json::Value::Object(map))
+        }
+    }
+}
+
 /// E43 Fix C helper (0.3.24 bug#3): probe live tmux for a window's existence
 /// before issuing `split-window -t :<window>`. Uses `list_windows` first
 /// (cheaper, authoritative when present); falls back to `list_targets` so
@@ -419,16 +510,18 @@ pub(super) fn save_restart_projected_state(
     workspace: &Path,
     state: &mut serde_json::Value,
     team_key: &str,
+    topology_authority_agent_ids: &[&str],
 ) -> Result<(), LifecycleError> {
     sync_restart_team_projections(state, team_key);
-    crate::state::projection::save_team_scoped_state(workspace, state)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+    crate::state::projection::save_team_scoped_state_with_lifecycle_topology_authority(
+        workspace,
+        state,
+        topology_authority_agent_ids,
+    )
+    .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
-pub(super) fn restart_projection_team_key(
-    state: &serde_json::Value,
-    team: Option<&str>,
-) -> String {
+pub(super) fn restart_projection_team_key(state: &serde_json::Value, team: Option<&str>) -> String {
     team.filter(|key| !key.is_empty())
         .map(str::to_string)
         .or_else(|| {
@@ -605,10 +698,7 @@ pub(super) fn resume_backing_probe_for_agent(
                 checked_paths.push(root.clone());
             }
             rollout_ok
-                || codex_session_transcript_exists_with_roots(
-                    session_id.as_str(),
-                    &scan_roots,
-                )
+                || codex_session_transcript_exists_with_roots(session_id.as_str(), &scan_roots)
         }
         Provider::Claude | Provider::ClaudeCode => {
             let rollout_ok = rollout_path_exists(rollout_path);
@@ -705,7 +795,8 @@ fn claude_projects_root_for_agent(agent: &serde_json::Value) -> Option<PathBuf>
         .filter(|value| !value.is_empty())
         .map(PathBuf::from)
         .or_else(|| {
-            std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".claude").join("projects"))
+            std::env::var_os("HOME")
+                .map(|home| PathBuf::from(home).join(".claude").join("projects"))
         })
 }
 

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -1,6 +1,7 @@
 use super::common::*;
 use super::selection::classify_restart_plan_with_resume_validation;
 use super::*;
+use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
 // ── lifecycle::restart —— 整队 Route B resume-or-fresh 重建 ──────────────────
 
@@ -128,6 +129,12 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             expected.display()
         )));
     }
+    let lifecycle_lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &selected.run_workspace,
+        operation: "restart",
+        team: Some(selected.team_key.as_str()),
+        agent_id: None,
+    })?;
     let mut state = selected.state;
     crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, None)?;
     // E5 task#3 / RC-A6a + E4(leader 裁定:每次 restart 都从角色定义重建 runtime spec,覆盖):
@@ -187,8 +194,15 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     if convergence.converged && convergence.changed {
         save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
-    if repair_resume_sessions_from_event_log(&selected.run_workspace, &mut state)? {
-        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
+    let repaired_agent_ids =
+        repair_resume_sessions_from_event_log(&selected.run_workspace, &mut state)?;
+    if !repaired_agent_ids.is_empty() {
+        save_restart_session_repairs(
+            &selected.run_workspace,
+            &mut state,
+            &selected.team_key,
+            &repaired_agent_ids,
+        )?;
         let missing_after_repair = restart_required_missing_session_agent_ids(&state);
         convergence.changed = true;
         convergence.converged = missing_after_repair.is_empty();
@@ -295,7 +309,17 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             .map_err(|e| LifecycleError::Transport(e.to_string()))?;
         mark_leader_receiver_rebind_required(&mut state, &session_name);
         mark_restart_targets_stopped_after_teardown(&mut state, &plan.decisions);
-        save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
+        let topology_authority_agent_ids = plan
+            .decisions
+            .iter()
+            .map(|decision| decision.agent_id.as_str().to_string())
+            .collect::<Vec<_>>();
+        save_restart_state_with_lifecycle_topology_authority(
+            &selected.run_workspace,
+            &mut state,
+            &selected.team_key,
+            &topology_authority_agent_ids,
+        )?;
     }
     let mut successful_agents: Vec<RestartedAgent> = Vec::new();
     let mut failed_agents: Vec<RestartFailedAgent> = Vec::new();
@@ -308,7 +332,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         if fatal_resume_failure {
             continue;
         }
-        let Some(agent) = state
+        let Some(raw_agent) = state
             .get("agents")
             .and_then(|v| v.get(decision.agent_id.as_str()))
             .cloned()
@@ -324,6 +348,11 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             failed_agents.push(restart_failed_agent(decision, "spawn", error));
             continue;
         };
+        let agent = rehydrate_agent_command_context_from_spec(
+            spec_workspace,
+            &decision.agent_id,
+            &raw_agent,
+        );
         let session_id = if matches!(decision.restart_mode, StartMode::Resumed) {
             decision.session_id.as_ref()
         } else {
@@ -429,7 +458,21 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         }
     }
     // END_B5_RESTART_ISOLATION_LOOP
-    save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
+    let mut topology_authority_agent_ids = successful_agents
+        .iter()
+        .map(|agent| agent.agent_id.as_str().to_string())
+        .collect::<Vec<_>>();
+    topology_authority_agent_ids.extend(
+        failed_agents
+            .iter()
+            .map(|agent| agent.agent_id.as_str().to_string()),
+    );
+    save_restart_state_with_lifecycle_topology_authority(
+        &selected.run_workspace,
+        &mut state,
+        &selected.team_key,
+        &topology_authority_agent_ids,
+    )?;
     if fatal_resume_failure {
         let attach_commands = Vec::new();
         let next_actions = restart_failure_next_actions(&failed_agents);
@@ -496,7 +539,10 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         let convergence_deadline = session_convergence_deadline(session_converge_deadline_ms);
         let convergence_poll = session_convergence_poll_interval();
         for decision in successful_agents.drain(..) {
-            if !matches!(decision.restart_mode, crate::lifecycle::types::StartMode::Resumed) {
+            if !matches!(
+                decision.restart_mode,
+                crate::lifecycle::types::StartMode::Resumed
+            ) {
                 survivors.push(decision);
                 continue;
             }
@@ -610,18 +656,23 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             let phase = "resume_postflight";
             let error = "session_backing_store_missing_after_restart".to_string();
             mark_agent_restart_failed(&mut state, &decision, &error);
-            let _ = write_restart_agent_failed_event(
-                &selected.run_workspace,
-                &decision,
-                phase,
-                &error,
-            );
+            let _ =
+                write_restart_agent_failed_event(&selected.run_workspace, &decision, phase, &error);
             postflight_failed.push(restart_failed_agent(&decision, phase, error));
         }
         successful_agents = survivors;
         failed_agents.extend(postflight_failed);
         if !failed_agents.is_empty() {
-            save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
+            let topology_authority_agent_ids = failed_agents
+                .iter()
+                .map(|agent| agent.agent_id.as_str().to_string())
+                .collect::<Vec<_>>();
+            save_restart_state_with_lifecycle_topology_authority(
+                &selected.run_workspace,
+                &mut state,
+                &selected.team_key,
+                &topology_authority_agent_ids,
+            )?;
         }
     }
     if successful_agents.is_empty() && !failed_agents.is_empty() {
@@ -641,6 +692,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             attach_commands,
         });
     }
+    drop(lifecycle_lock);
     let coordinator_started = start_coordinator_for_workspace(&selected.run_workspace)?;
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
@@ -691,11 +743,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     // invoked from a tmux pane should bind that pane as leader_receiver,
     // restoring the worker→leader delivery path. Failure is non-fatal — the
     // user can still run `team-agent attach-leader` manually.
-    try_autobind_leader_after_restart(
-        &selected.run_workspace,
-        Some(&selected.team_key),
-        &state,
-    );
+    try_autobind_leader_after_restart(&selected.run_workspace, Some(&selected.team_key), &state);
     // 0.3.28 Step 1: topology invariant guard (warn-only). Same pattern as
     // `lifecycle::launch::launch_with_transport_in_workspace` — logs to stderr,
     // never panics. Hard error path is deferred to Step 10.
@@ -713,13 +761,13 @@ pub fn restart_with_transport_with_session_convergence_deadline(
 fn repair_resume_sessions_from_event_log(
     workspace: &Path,
     state: &mut serde_json::Value,
-) -> Result<bool, LifecycleError> {
+) -> Result<Vec<String>, LifecycleError> {
     let agent_ids = state
         .get("agents")
         .and_then(serde_json::Value::as_object)
         .map(|agents| agents.keys().cloned().collect::<Vec<_>>())
         .unwrap_or_default();
-    let mut changed = false;
+    let mut repaired_agent_ids = Vec::new();
     for agent_id in agent_ids {
         let previous = state
             .get("agents")
@@ -824,9 +872,9 @@ fn repair_resume_sessions_from_event_log(
                 }),
             )
             .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-        changed = true;
+        repaired_agent_ids.push(agent_id);
     }
-    Ok(changed)
+    Ok(repaired_agent_ids)
 }
 
 fn claimed_session_ids_except(
@@ -1189,9 +1237,7 @@ fn try_autobind_leader_after_restart(
             // the same attach target). Wire-format `parse_provider` keeps
             // them distinct everywhere else.
             crate::provider::wire::parse_provider(s).map(|p| match p {
-                crate::model::enums::Provider::Claude => {
-                    crate::model::enums::Provider::ClaudeCode
-                }
+                crate::model::enums::Provider::Claude => crate::model::enums::Provider::ClaudeCode,
                 other => other,
             })
         })
@@ -1272,7 +1318,92 @@ fn save_restart_state(
     state: &mut serde_json::Value,
     team_key: &str,
 ) -> Result<(), LifecycleError> {
-    save_restart_projected_state(workspace, state, team_key)
+    save_restart_projected_state(workspace, state, team_key, &[])
+}
+
+fn save_restart_state_with_lifecycle_topology_authority(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+    agent_ids: &[String],
+) -> Result<(), LifecycleError> {
+    let agent_ids = agent_ids.iter().map(String::as_str).collect::<Vec<_>>();
+    save_restart_projected_state(workspace, state, team_key, &agent_ids)
+}
+
+fn save_restart_session_repairs(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+    agent_ids: &[String],
+) -> Result<(), LifecycleError> {
+    let repairs = collect_session_repair_fields(state, agent_ids);
+    sync_restart_team_projections(state, team_key);
+    match crate::state::projection::save_team_scoped_state(workspace, state) {
+        Ok(()) => Ok(()),
+        Err(crate::state::StateError::SaveConflict(_)) => {
+            let mut latest =
+                crate::state::projection::select_runtime_state(workspace, Some(team_key))
+                    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+            for (agent_id, repair) in &repairs {
+                apply_session_repair_fields(&mut latest, agent_id, repair);
+            }
+            sync_restart_team_projections(&mut latest, team_key);
+            crate::state::projection::save_team_scoped_state(workspace, &latest)
+                .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+            *state = latest;
+            Ok(())
+        }
+        Err(error) => Err(LifecycleError::StatePersist(error.to_string())),
+    }
+}
+
+fn collect_session_repair_fields(
+    state: &serde_json::Value,
+    agent_ids: &[String],
+) -> Vec<(String, serde_json::Value)> {
+    agent_ids
+        .iter()
+        .filter_map(|agent_id| {
+            state
+                .get("agents")
+                .and_then(|agents| agents.get(agent_id))
+                .cloned()
+                .map(|agent| (agent_id.clone(), agent))
+        })
+        .collect()
+}
+
+fn apply_session_repair_fields(
+    state: &mut serde_json::Value,
+    agent_id: &str,
+    repair: &serde_json::Value,
+) {
+    let Some(target) = state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(agent_id))
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return;
+    };
+    let Some(repair) = repair.as_object() else {
+        return;
+    };
+    for field in [
+        "session_id",
+        "rollout_path",
+        "captured_at",
+        "captured_via",
+        "attribution_confidence",
+    ] {
+        if let Some(value) = repair.get(field) {
+            target.insert(field.to_string(), value.clone());
+        } else {
+            target.remove(field);
+        }
+    }
+    target.remove("attribution_ambiguous");
 }
 
 fn mark_agent_respawned(
@@ -1330,10 +1461,7 @@ fn mark_agent_respawned(
     // active_team_key (priority 3).
     if let Some(ref team_id) = spawn.owner_team_id {
         if !team_id.is_empty() {
-            agent.insert(
-                "owner_team_id".to_string(),
-                serde_json::json!(team_id),
-            );
+            agent.insert("owner_team_id".to_string(), serde_json::json!(team_id));
         }
     }
     // Bug 2 (0.3.32): clear stale `attribution_ambiguous` whenever a new
@@ -1638,8 +1766,13 @@ fn write_restart_resume_decision_events(
     // Layer 2 (leader directive 2026-06-22): every restart.resume_decision
     // event for a Refuse decision must carry the structured refusal_reason
     // wire string so operators can see WHY without crawling state.json.
-    let refusal_index: std::collections::BTreeMap<&str, &crate::lifecycle::types::UnresumableWorker> =
-        unresumable.iter().map(|u| (u.agent_id.as_str(), u)).collect();
+    let refusal_index: std::collections::BTreeMap<
+        &str,
+        &crate::lifecycle::types::UnresumableWorker,
+    > = unresumable
+        .iter()
+        .map(|u| (u.agent_id.as_str(), u))
+        .collect();
     for decision in decisions {
         let agent = state
             .get("agents")

package/crates/team-agent/src/lifecycle/restart/remove.rs

@@ -1,7 +1,8 @@
 use super::*;
-use super::agent::{resolve_team_scoped_state_or_refuse, start_agent_with_transport, stop_agent_at_paths};
+use super::agent::{resolve_team_scoped_state_or_refuse, start_agent_at_paths, stop_agent_at_paths};
 use super::common::*;
 use super::team_state::write_team_state;
+use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 
 /// `remove_agent(workspace, agent_id, from_spec, force, team)`(`lifecycle/agents.py:22`)。
 /// 从 spec/state/team_state/role-file/agent_health 原子摘除;`_RemoveRollback` 字节级快照
@@ -14,6 +15,12 @@ pub fn remove_agent(
     team: Option<&str>,
 ) -> Result<RemoveAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &paths.run_workspace,
+        operation: "remove-agent",
+        team,
+        agent_id: Some(agent_id),
+    })?;
     let transport =
         lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
     remove_agent_at_paths(
@@ -36,6 +43,12 @@ pub fn remove_agent_with_transport(
     transport: &dyn crate::transport::Transport,
 ) -> Result<RemoveAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: &paths.run_workspace,
+        operation: "remove-agent",
+        team,
+        agent_id: Some(agent_id),
+    })?;
     remove_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -787,8 +800,9 @@ impl RemoveRollback {
         }
 
         if self.restore_running && errors.is_empty() {
-            if let Err(e) = start_agent_with_transport(
+            if let Err(e) = start_agent_at_paths(
                 workspace,
+                spec_workspace,
                 &self.agent_id,
                 true,
                 false,

package/crates/team-agent/src/lifecycle/restart/selection.rs

@@ -1,5 +1,6 @@
 use super::common::*;
 use super::*;
+use crate::provider::wire::{parse_canonical_provider, requires_resume_backing};
 
 /// bug-085 四象限 `start_mode` 决策(`start.py:179-188` + `_resume_rollout_missing` `start.py:66-69`),
 /// **从 start_agent 的整条 lock+spawn 路径里分离出的纯函数**(gate gap:porter 需要单元级 RED
@@ -31,7 +32,7 @@ pub fn decide_start_mode(
 }
 
 pub(crate) fn resumable_provider_requires_backing(provider: &str) -> bool {
-    matches!(provider, "codex" | "claude" | "claude_code" | "copilot")
+    parse_canonical_provider(provider).is_some_and(requires_resume_backing)
 }
 
 /// `first_send_at` 严格分类(`_classify_first_send_at`,`orchestration.py:399`)。

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

@@ -323,6 +323,7 @@ expected="${TEAM_AGENT_E27_EXPECTED_ENDPOINT}"
 session="${TEAM_AGENT_E27_SESSION_NAME}"
 pane="${TEAM_AGENT_E27_PANE_ID}"
 killed_marker="${log}.killed"
+spawned_marker="${log}.spawned"
 track=0
 case "$*" in
   *"$expected"*|*"$session"*|*"$pane"*) track=1 ;;
@@ -361,6 +362,7 @@ case "$*" in
     exit 0
     ;;
   *"display-message -p -t $session:alpha #{pane_id}"*)
+    : > "$spawned_marker"
     printf '%%9288\n'
     exit 0
     ;;
@@ -368,6 +370,10 @@ case "$*" in
     exit 0
     ;;
   *"list-panes -a -F"*)
+    if [ -f "$spawned_marker" ]; then
+      printf '%%9288\t%s\t0\talpha\t0\t/dev/ttys099\tnode\t1\t/tmp\t1\t0\t9288\n' "$session"
+      exit 0
+    fi
     # Hard-gate post-stop snapshot: no residual same-role panes after kill.
     if [ -f "$killed_marker" ]; then
       exit 0

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

@@ -27,10 +27,10 @@ impl LaneTransport {
             spawns: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
         }
     }
-    fn killed(&self) -> Vec<String> {
+    pub(super) fn killed(&self) -> Vec<String> {
         self.killed.lock().unwrap().clone()
     }
-    fn spawns(&self) -> Vec<(String, Vec<String>)> {
+    pub(super) fn spawns(&self) -> Vec<(String, Vec<String>)> {
         self.spawns.lock().unwrap().clone()
     }
 }
@@ -164,7 +164,7 @@ fn set_context_state_file(ws: &std::path::Path, name: &str) {
 /// Fork workspace: source `alpha` (role doc = `alpha_role`) + `bravo`, alpha seeded RUNNING with a
 /// source `session_id` (so fork reaches the spec-mutation / native-fork gate). Seeded-healthy coordinator
 /// (fork's start_coordinator -> AlreadyRunning, no real daemon). session_name = "team-laneateam".
-fn fork_ws(alpha_role: &str) -> PathBuf {
+pub(super) fn fork_ws(alpha_role: &str) -> PathBuf {
     let ws = temp_ws().join("forkv2");
     std::fs::create_dir_all(ws.join("agents")).unwrap();
     std::fs::write(ws.join("TEAM.md"), "---\nname: laneateam\nobjective: Fork v2 probe.\nprovider: codex\n---\n\nteam.\n").unwrap();