@team-agent/installer 0.5.51 → 0.5.53

package/crates/team-agent/src/lifecycle/launch/fork_finalize.rs

@@ -0,0 +1,238 @@
+use super::*;
+
+pub(super) struct ForkPostSpawnInput<'a> {
+    pub workspace: &'a Path,
+    pub transport: &'a dyn Transport,
+    pub session_name: &'a SessionName,
+    pub window: &'a WindowName,
+    pub mcp_config_path: &'a Path,
+    pub agent_id: &'a AgentId,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub team_key: &'a str,
+    pub spawn: &'a crate::transport::SpawnResult,
+}
+
+pub(super) fn ensure_fork_spawn_live(input: ForkPostSpawnInput<'_>) -> Result<(), LifecycleError> {
+    let rollback = || {
+        rollback_fork_after_spawn(
+            input.workspace,
+            input.transport,
+            input.session_name,
+            input.window,
+            input.mcp_config_path,
+            input.agent_id,
+            input.profile_launch,
+            input.team_key,
+        );
+    };
+    if !matches!(
+        input.transport.liveness(&input.spawn.pane_id),
+        Ok(PaneLiveness::Live)
+    ) {
+        rollback();
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "fork process is not live after spawn: agent={} pane={}",
+            input.agent_id,
+            input.spawn.pane_id.as_str()
+        )));
+    }
+    Ok(())
+}
+
+pub(super) fn prepare_claude_fork_backing(
+    provider: Provider,
+    plan: &crate::provider::CommandPlan,
+    source_backing: &Path,
+    source_session_id: &crate::provider::SessionId,
+) -> Result<Option<crate::provider::adapters::claude_fork::ClaudeForkMaterialization>, LifecycleError>
+{
+    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        return Ok(None);
+    }
+    let target_session_id = plan.expected_session_id.as_ref().ok_or_else(|| {
+        LifecycleError::Provider("claude fork plan has no snapshot session id".to_string())
+    })?;
+    crate::provider::adapters::claude_fork::materialize_claude_fork(
+        source_backing,
+        source_session_id,
+        target_session_id,
+    )
+    .map(Some)
+    .map_err(|error| {
+        LifecycleError::Provider(format!(
+            "context_fork_unavailable: claude snapshot copy failed before spawn: {error}"
+        ))
+    })
+}
+
+pub(super) struct ForkCoordinatorInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub agent_id: &'a AgentId,
+    pub transport: &'a dyn Transport,
+    pub session_name: &'a SessionName,
+    pub window: &'a WindowName,
+    pub mcp_config_path: &'a Path,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+}
+
+pub(super) fn start_fork_coordinator(
+    input: ForkCoordinatorInput<'_>,
+) -> Result<bool, LifecycleError> {
+    let rollback = || {
+        rollback_fork_after_spawn(
+            input.workspace,
+            input.transport,
+            input.session_name,
+            input.window,
+            input.mcp_config_path,
+            input.agent_id,
+            input.profile_launch,
+            input.team_key,
+        );
+    };
+    if let Err(error) = maybe_fail_fork_after_spawn("start_coordinator") {
+        rollback();
+        return Err(error);
+    }
+    crate::coordinator::start_coordinator(&crate::coordinator::WorkspacePath::new(
+        input.workspace.to_path_buf(),
+    ))
+    .map(|report| report.ok)
+    .map_err(|error| {
+        rollback();
+        LifecycleError::StatePersist(error.to_string())
+    })
+}
+
+pub(super) struct ForkFinalizeInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub source_agent_id: &'a AgentId,
+    pub agent_id: &'a AgentId,
+    pub spec_agent: &'a Value,
+    pub safety: &'a DangerousApproval,
+    pub plan: &'a crate::provider::CommandPlan,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub spawn: &'a crate::transport::SpawnResult,
+    pub profile_dir: &'a Path,
+    pub dynamic_role_file: &'a Path,
+    pub context_proof: &'a crate::provider::session::ContextForkProof,
+    pub spawned_at: &'a str,
+    pub spawn_epoch: u64,
+}
+
+pub(super) fn finalize_fork_state(input: ForkFinalizeInput<'_>) -> Result<(), LifecycleError> {
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: input.workspace,
+        operation: "fork-agent-finalize",
+        team: Some(input.team_key),
+        agent_id: Some(input.agent_id),
+    })?;
+    let mut next_state = crate::state::selector::resolve_active_team(
+        input.workspace,
+        Some(input.team_key),
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|error| LifecycleError::TeamSelect(error.to_string()))?
+    .state;
+    upsert_forked_agent_state(
+        &mut next_state,
+        input.source_agent_id,
+        input.agent_id,
+        input.spec_agent,
+        input.safety,
+        input.plan,
+        input.profile_launch,
+        input.spawn,
+        input.workspace,
+        Some(input.profile_dir),
+        input.dynamic_role_file,
+        input.context_proof,
+        input.spawned_at,
+        input.spawn_epoch,
+    )?;
+    if let Some(agent) = next_state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(input.agent_id.as_str()))
+        .and_then(serde_json::Value::as_object_mut)
+    {
+        persist_effective_approval_policy(agent, input.safety);
+    }
+    maybe_fail_fork_after_spawn("save_runtime_state")?;
+    crate::state::repository::StateRepository::new(input.workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::ForkAgent {
+                team_key: input.team_key,
+                agent_id: input.agent_id.as_str(),
+            },
+            &next_state,
+        )
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))
+}
+
+pub(super) fn verify_fork_registration(
+    workspace: &Path,
+    team_key: &str,
+    agent_id: &AgentId,
+    spawn: &crate::transport::SpawnResult,
+    window: &WindowName,
+) -> Result<(), LifecycleError> {
+    let saved = crate::state::projection::select_runtime_state(workspace, Some(team_key))
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
+    let agent = saved
+        .get("agents")
+        .and_then(|agents| agents.get(agent_id.as_str()))
+        .ok_or_else(|| LifecycleError::StatePersist("canonical team row is missing".to_string()))?;
+    if agent.get("pane_id").and_then(serde_json::Value::as_str) != Some(spawn.pane_id.as_str()) {
+        return Err(LifecycleError::StatePersist(
+            "canonical team pane_id does not match spawned pane".to_string(),
+        ));
+    }
+    if agent.get("window").and_then(serde_json::Value::as_str) != Some(window.as_str()) {
+        return Err(LifecycleError::StatePersist(
+            "canonical team window does not match spawned window".to_string(),
+        ));
+    }
+    if let Some(pid) = spawn.child_pid {
+        if agent.get("pane_pid").and_then(serde_json::Value::as_u64) != Some(u64::from(pid)) {
+            return Err(LifecycleError::StatePersist(
+                "canonical team pane_pid does not match spawned process".to_string(),
+            ));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn rollback_fork_after_spawn(
+    workspace: &Path,
+    transport: &dyn Transport,
+    session_name: &SessionName,
+    window: &WindowName,
+    mcp_config_path: &Path,
+    agent_id: &AgentId,
+    profile_launch: &crate::provider::ProviderProfileLaunch,
+    team_key: &str,
+) {
+    let _ = transport.kill_window(&Target::SessionWindow {
+        session: session_name.clone(),
+        window: window.clone(),
+    });
+    if let Ok(_lock) = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace,
+        operation: "fork-agent-rollback",
+        team: Some(team_key),
+        agent_id: Some(agent_id),
+    }) {
+        let _ = crate::lifecycle::restart::remove::remove_agent_with_transport_locked(
+            workspace,
+            agent_id,
+            true,
+            true,
+            Some(team_key),
+            transport,
+        );
+    }
+    cleanup_fork_mcp_artifacts(workspace, agent_id, mcp_config_path, profile_launch);
+}

package/crates/team-agent/src/lifecycle/launch/fork_state.rs

@@ -14,6 +14,61 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 
 use super::*;
 
+pub(super) fn reserve_forked_agent_state(
+    state: &mut serde_json::Value,
+    source_agent_id: &AgentId,
+    as_agent_id: &AgentId,
+    spec_agent: &Value,
+    dynamic_role_file: &Path,
+) -> Result<(), LifecycleError> {
+    let agents = state
+        .as_object_mut()
+        .ok_or_else(|| {
+            LifecycleError::StatePersist("runtime state root is not an object".to_string())
+        })?
+        .entry("agents".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    let agent_map = agents.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state agents is not an object".to_string())
+    })?;
+    if agent_map.contains_key(as_agent_id.as_str()) {
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "agent id already exists: {as_agent_id}"
+        )));
+    }
+    crate::lifecycle::restart::remove::clear_agent_retirement_in_state(state, as_agent_id);
+    let agents = state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .ok_or_else(|| {
+            LifecycleError::StatePersist("runtime state agents is not an object".to_string())
+        })?;
+    let mut entry = serde_json::json!({
+        "status": "forking",
+        "agent_id": as_agent_id.as_str(),
+        "window": as_agent_id.as_str(),
+        "forked_from": source_agent_id.as_str(),
+        "dynamic_role_file": dynamic_role_file.to_string_lossy().to_string(),
+        "role_source_ownership": "managed",
+    });
+    if let Some(object) = entry.as_object_mut() {
+        for key in [
+            "provider",
+            "auth_mode",
+            "model",
+            "profile",
+            "role",
+            "effort",
+        ] {
+            if let Some(value) = spec_agent.get(key) {
+                object.insert(key.to_string(), yaml_value_to_json(value));
+            }
+        }
+    }
+    agents.insert(as_agent_id.as_str().to_string(), entry);
+    Ok(())
+}
+
 pub(super) fn maybe_fail_fork_after_spawn(step: &str) -> Result<(), LifecycleError> {
     let Ok(reason) = std::env::var("TEAM_AGENT_TEST_FAIL_FORK_AFTER_SPAWN") else {
         return Ok(());
@@ -42,6 +97,11 @@ pub(super) fn cleanup_fork_mcp_artifacts(
             .join(".team/runtime/provider-env")
             .join(format!("{}.env", agent_id.as_str())),
     );
+    let _ = std::fs::remove_dir_all(
+        workspace
+            .join(".team/runtime/copilot-instructions")
+            .join(agent_id.as_str()),
+    );
     if let Some(config_dir) = profile_launch.claude_config_dir.as_ref() {
         let _ = std::fs::remove_dir_all(config_dir.parent().unwrap_or(config_dir));
     }
@@ -202,6 +262,10 @@ pub(super) fn upsert_forked_agent_state(
     spawn: &crate::transport::SpawnResult,
     spawn_cwd: &Path,
     profile_dir: Option<&Path>,
+    dynamic_role_file: &Path,
+    context_proof: &crate::provider::session::ContextForkProof,
+    spawned_at: &str,
+    spawn_epoch: u64,
 ) -> Result<(), LifecycleError> {
     if !state.is_object() {
         *state = serde_json::json!({});
@@ -241,6 +305,14 @@ pub(super) fn upsert_forked_agent_state(
         "forked_from".to_string(),
         serde_json::json!(source_agent_id.as_str()),
     );
+    entry.insert(
+        "dynamic_role_file".to_string(),
+        serde_json::json!(dynamic_role_file.to_string_lossy().to_string()),
+    );
+    entry.insert(
+        "role_source_ownership".to_string(),
+        serde_json::json!("managed"),
+    );
     entry.insert(
         "spawn_cwd".to_string(),
         serde_json::json!(spawn_cwd.to_string_lossy().to_string()),
@@ -249,6 +321,8 @@ pub(super) fn upsert_forked_agent_state(
         "pane_id".to_string(),
         serde_json::json!(spawn.pane_id.as_str()),
     );
+    entry.insert("spawned_at".to_string(), serde_json::json!(spawned_at));
+    entry.insert("spawn_epoch".to_string(), serde_json::json!(spawn_epoch));
     if let Some(pid) = spawn.child_pid {
         entry.insert("pane_pid".to_string(), serde_json::json!(pid));
     }
@@ -274,14 +348,36 @@ pub(super) fn upsert_forked_agent_state(
             );
         }
     }
-    entry.insert("session_id".to_string(), serde_json::Value::Null);
-    entry.insert("rollout_path".to_string(), serde_json::Value::Null);
-    entry.insert("captured_at".to_string(), serde_json::Value::Null);
-    entry.insert("captured_via".to_string(), serde_json::Value::Null);
+    entry.insert(
+        "session_id".to_string(),
+        serde_json::json!(context_proof.new_session_id.as_str()),
+    );
+    entry.insert(
+        "rollout_path".to_string(),
+        serde_json::json!(context_proof.backing_path.to_string_lossy().to_string()),
+    );
+    entry.insert(
+        "captured_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
+    entry.insert(
+        "captured_via".to_string(),
+        serde_json::json!(context_proof.captured_via),
+    );
     entry.insert(
         "attribution_confidence".to_string(),
-        serde_json::Value::Null,
+        serde_json::json!(context_proof.attribution_confidence),
     );
+    if let Some(root) = context_proof.managed_backing_root.as_ref() {
+        entry.insert(
+            "session_backing_root".to_string(),
+            serde_json::json!(root.to_string_lossy().to_string()),
+        );
+        entry.insert(
+            "session_backing_ownership".to_string(),
+            serde_json::json!("managed"),
+        );
+    }
     persist_command_plan_state(&mut entry, plan, profile_launch);
     agent_map.insert(
         as_agent_id.as_str().to_string(),

package/crates/team-agent/src/lifecycle/launch/quick_start.rs

@@ -379,7 +379,7 @@ pub fn quick_start_with_transport_in_workspace_with_display(
     // to "unknown" in the payload) — Phase 2 refactor will thread
     // ResolvedTransport.source through the launch signature.
     annotate_runtime_transport(&mut state, transport, &workspace, None);
-    save_launched_team_state_for_key(&workspace, &state, Some(&state_team_key))?;
+    save_launched_team_state_for_key(&workspace, &state, Some(&state_team_key), None)?;
     annotate_persisted_team_depth(
         &workspace,
         &state_team_key,

package/crates/team-agent/src/lifecycle/launch/role_source.rs

@@ -0,0 +1,170 @@
+use std::path::{Path, PathBuf};
+
+use crate::lifecycle::LifecycleError;
+use crate::model::ids::AgentId;
+use crate::model::yaml::{self, Value};
+
+use super::set_yaml_map_value;
+
+pub(super) struct MaterializedRole {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl MaterializedRole {
+    pub(super) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    pub(super) fn keep(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl Drop for MaterializedRole {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(super) fn materialize_latest_role(
+    run_workspace: &Path,
+    team_dir: &Path,
+    state: &serde_json::Value,
+    source_agent_id: &AgentId,
+    as_agent_id: &AgentId,
+    label: Option<&str>,
+) -> Result<MaterializedRole, LifecycleError> {
+    let source_path = resolve_role_source(run_workspace, team_dir, state, source_agent_id)?;
+    let (mut meta, body) = crate::compiler::read_front_matter(&source_path)
+        .map_err(|error| LifecycleError::Compile(error.to_string()))?;
+    let declared = meta
+        .get("name")
+        .and_then(Value::as_str)
+        .filter(|name| !name.is_empty())
+        .ok_or_else(|| {
+            LifecycleError::Compile(format!(
+                "source role file does not declare name: {}",
+                source_path.display()
+            ))
+        })?;
+    if declared != source_agent_id.as_str() {
+        return Err(LifecycleError::Compile(format!(
+            "source role file declares name '{}' but source agent is '{}'",
+            declared, source_agent_id
+        )));
+    }
+    set_yaml_map_value(
+        &mut meta,
+        "name",
+        Value::Str(as_agent_id.as_str().to_string()),
+    )?;
+    if let Some(label) = label.filter(|value| !value.is_empty()) {
+        set_yaml_map_value(&mut meta, "role", Value::Str(label.to_string()))?;
+    }
+
+    let managed_dir = run_workspace.join(".team").join("dynamic-role-files");
+    std::fs::create_dir_all(&managed_dir)
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
+    let path = managed_dir.join(format!("{}.md", as_agent_id.as_str()));
+    if path.exists() {
+        return Err(LifecycleError::RequirementUnmet(format!(
+            "managed role file already exists: {}",
+            path.display()
+        )));
+    }
+    let rendered = format!("---\n{}---\n\n{}", yaml::dumps(&meta), body);
+    let temp = path.with_extension(format!("md.tmp-{}", std::process::id()));
+    std::fs::write(&temp, rendered.as_bytes())
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
+    if let Err(error) = std::fs::rename(&temp, &path) {
+        let _ = std::fs::remove_file(&temp);
+        return Err(LifecycleError::StatePersist(error.to_string()));
+    }
+    Ok(MaterializedRole { path, keep: false })
+}
+
+pub(super) fn clamp_materialized_role_to_leader(
+    materialized: &Path,
+    spec: &Value,
+) -> Result<(), LifecycleError> {
+    let leader_tools = spec
+        .get("leader")
+        .and_then(|leader| leader.get("tools"))
+        .and_then(Value::as_list)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(Value::as_str)
+                .map(str::to_string)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    let (mut meta, body) = crate::compiler::read_front_matter(materialized)
+        .map_err(|error| LifecycleError::Compile(error.to_string()))?;
+    let requested = meta
+        .get("tools")
+        .and_then(Value::as_list)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(Value::as_str)
+                .map(str::to_string)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    let ceiling = crate::model::permissions::expand_tool_strings(&leader_tools)
+        .into_iter()
+        .collect::<std::collections::BTreeSet<_>>();
+    let effective = crate::model::permissions::expand_tool_strings(&requested)
+        .into_iter()
+        .filter(|tool| ceiling.contains(tool))
+        .map(Value::Str)
+        .collect::<Vec<_>>();
+    set_yaml_map_value(&mut meta, "tools", Value::List(effective))?;
+    let rendered = format!("---\n{}---\n\n{}", yaml::dumps(&meta), body);
+    std::fs::write(materialized, rendered.as_bytes())
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))
+}
+
+fn resolve_role_source(
+    run_workspace: &Path,
+    team_dir: &Path,
+    state: &serde_json::Value,
+    source_agent_id: &AgentId,
+) -> Result<PathBuf, LifecycleError> {
+    if let Some(raw) = state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .and_then(|agent| agent.get("dynamic_role_file"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+    {
+        let path = PathBuf::from(raw);
+        let resolved = if path.is_absolute() {
+            path
+        } else {
+            run_workspace.join(path)
+        };
+        if resolved.is_file() {
+            return Ok(resolved);
+        }
+        return Err(LifecycleError::Compile(format!(
+            "source dynamic role file not found: {}",
+            resolved.display()
+        )));
+    }
+    let path = team_dir
+        .join("agents")
+        .join(format!("{}.md", source_agent_id.as_str()));
+    if path.is_file() {
+        Ok(path)
+    } else {
+        Err(LifecycleError::Compile(format!(
+            "source role file not found: {}",
+            path.display()
+        )))
+    }
+}

package/crates/team-agent/src/lifecycle/launch/state_projection.rs

@@ -146,7 +146,7 @@ pub(super) fn persist_spawn_agent_state(
         obj.insert("agents".to_string(), serde_json::Value::Object(agents));
         state = serde_json::Value::Object(obj);
     }
-    save_launched_team_state_for_key(workspace, &state, Some(&team_id))
+    save_launched_team_state_for_key(workspace, &state, Some(&team_id), None)
 }
 
 pub(super) fn pane_pids_by_started_agent(
@@ -178,13 +178,14 @@ pub(super) fn save_launched_team_state(
     workspace: &Path,
     launched: &serde_json::Value,
 ) -> Result<(), LifecycleError> {
-    save_launched_team_state_for_key(workspace, launched, None)
+    save_launched_team_state_for_key(workspace, launched, None, None)
 }
 
 pub(super) fn save_launched_team_state_for_key(
     workspace: &Path,
     launched: &serde_json::Value,
     team_key: Option<&str>,
+    added_agent_id: Option<&str>,
 ) -> Result<(), LifecycleError> {
     let existing = load_runtime_state(workspace).unwrap_or_else(|_| serde_json::json!({}));
     let launched_key = team_key
@@ -231,13 +232,12 @@ pub(super) fn save_launched_team_state_for_key(
     };
     let mut projected = crate::state::projection::project_top_level_view(&merged, &launched_key);
     drop_unbound_top_level_owner(&mut projected);
+    let intent = crate::state::repository::StateWriteIntent::launch_team_or_add_agent(
+        &launched_key,
+        added_agent_id,
+    );
     crate::state::repository::StateRepository::new(workspace)
-        .save(
-            crate::state::repository::StateWriteIntent::LaunchTeam {
-                team_key: &launched_key,
-            },
-            &projected,
-        )
+        .save(intent, &projected)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 

package/crates/team-agent/src/lifecycle/launch/worker_env.rs

@@ -18,7 +18,7 @@ pub(super) fn agent_is_paused(agent: &Value) -> bool {
     matches!(agent.get("paused"), Some(Value::Bool(true)))
 }
 
-pub(super) fn spawn_timestamp() -> String {
+pub(crate) fn spawn_timestamp() -> String {
     match std::env::var("TEAM_AGENT_TEST_FIXED_SPAWNED_AT") {
         Ok(value) => value,
         Err(_) => chrono::Utc::now()

package/crates/team-agent/src/lifecycle/launch.rs

@@ -234,7 +234,7 @@ pub(super) use worker_env::*;
 pub(crate) use worker_env::{
     apply_copilot_instructions_overlay, apply_mcp_auto_approval_env, apply_profile_launch_env,
     fill_spawn_placeholders, fill_spawn_placeholders_full, inherited_env_with_team_overrides,
-    persist_command_plan_state,
+    persist_command_plan_state, spawn_timestamp,
 };
 
 mod identity;
@@ -285,12 +285,24 @@ pub(crate) use add_agent_state::inject_agent_into_spec;
 pub(super) use add_agent_state::*;
 
 mod fork_agent;
+pub use fork_agent::fork_agent_with_transport;
 pub(super) use fork_agent::*;
-pub use fork_agent::{fork_agent, fork_agent_with_transport};
+
+mod fork_entry;
+pub use fork_entry::fork_agent;
 
 mod fork_state;
 pub(super) use fork_state::*;
 
+mod fork_finalize;
+pub(super) use fork_finalize::*;
+
+mod role_source;
+pub(super) use role_source::*;
+
+mod clone_agent;
+pub use clone_agent::clone_agent;
+
 mod ownership;
 pub(super) use ownership::*;
 pub(crate) use ownership::{ensure_owner_allowed, ensure_owner_allowed_for_state, state_path};