@team-agent/installer 0.5.57 → 0.5.59

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

@@ -0,0 +1,109 @@
+use super::*;
+
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn upsert_pending_forked_agent_state(
+    state: &mut serde_json::Value,
+    source_agent_id: &AgentId,
+    as_agent_id: &AgentId,
+    spec_agent: &Value,
+    safety: &DangerousApproval,
+    plan: &crate::provider::CommandPlan,
+    profile_launch: &crate::provider::ProviderProfileLaunch,
+    spawn: &crate::transport::SpawnResult,
+    profile_dir: Option<&Path>,
+    dynamic_role_file: &Path,
+    pending: &crate::provider::session::PendingContextFork,
+    spawn_epoch: u64,
+) -> Result<(), LifecycleError> {
+    let root = state.as_object_mut().ok_or_else(|| {
+        LifecycleError::StatePersist("runtime state root is not an object".to_string())
+    })?;
+    let agents = root
+        .entry("agents".to_string())
+        .or_insert_with(|| serde_json::json!({}))
+        .as_object_mut()
+        .ok_or_else(|| {
+            LifecycleError::StatePersist("runtime state agents is not an object".to_string())
+        })?;
+    let mut entry = serde_json::Map::new();
+    entry.insert("status".to_string(), serde_json::json!("running"));
+    entry.insert(
+        "capture_state".to_string(),
+        serde_json::json!("pending_context_fork"),
+    );
+    entry.insert(
+        "agent_id".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "window".to_string(),
+        serde_json::json!(as_agent_id.as_str()),
+    );
+    entry.insert(
+        "forked_from".to_string(),
+        serde_json::json!(source_agent_id.as_str()),
+    );
+    entry.insert(
+        "fork_source_session_id".to_string(),
+        serde_json::json!(pending.source_session_id.as_str()),
+    );
+    entry.insert(
+        "pending_target_agent".to_string(),
+        serde_json::json!(pending.target_agent),
+    );
+    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!(pending
+            .scanner_context
+            .spawn_cwd
+            .to_string_lossy()
+            .to_string()),
+    );
+    entry.insert(
+        "pane_id".to_string(),
+        serde_json::json!(spawn.pane_id.as_str()),
+    );
+    entry.insert(
+        "spawned_at".to_string(),
+        serde_json::json!(pending.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));
+    }
+    for key in [
+        "provider",
+        "auth_mode",
+        "model",
+        "profile",
+        "role",
+        "effort",
+    ] {
+        if let Some(value) = spec_agent.get(key) {
+            entry.insert(key.to_string(), yaml_value_to_json(value));
+        }
+    }
+    if spec_agent.get("profile").is_some() {
+        if let Some(profile_dir) = profile_dir {
+            entry.insert(
+                "_profile_dir".to_string(),
+                serde_json::json!(profile_dir.to_string_lossy().to_string()),
+            );
+        }
+    }
+    persist_command_plan_state(&mut entry, plan, profile_launch);
+    persist_effective_approval_policy(&mut entry, safety);
+    agents.insert(
+        as_agent_id.as_str().to_string(),
+        serde_json::Value::Object(entry),
+    );
+    Ok(())
+}

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

@@ -14,6 +14,10 @@ use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest}
 
 use super::*;
 
+#[path = "fork_pending.rs"]
+mod fork_pending;
+pub(super) use fork_pending::upsert_pending_forked_agent_state;
+
 pub(super) fn reserve_forked_agent_state(
     state: &mut serde_json::Value,
     source_agent_id: &AgentId,
@@ -134,6 +138,51 @@ pub(super) fn find_spec_agent<'a>(spec: &'a Value, agent_id: &AgentId) -> Option
     })
 }
 
+pub(super) fn fork_spec_agent<'a>(spec: &'a Value, agent_id: &AgentId) -> Option<&'a Value> {
+    find_spec_agent(spec, agent_id)
+}
+
+pub(super) fn fork_source_tuple(
+    state: &serde_json::Value,
+    source_agent_id: &AgentId,
+) -> Result<(crate::provider::SessionId, PathBuf), LifecycleError> {
+    let source = state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .ok_or_else(|| {
+            LifecycleError::Provider(format!("unknown worker agent id: {source_agent_id}"))
+        })?;
+    let field = |name: &str| {
+        source
+            .get(name)
+            .and_then(serde_json::Value::as_str)
+            .filter(|value| !value.is_empty())
+    };
+    let (Some(session_id), Some(backing)) = (field("session_id"), field("rollout_path")) else {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is missing or incomplete \
+             (session_id+rollout_path+captured_at+captured_via required)"
+        )));
+    };
+    if field("captured_at").is_none() || field("captured_via").is_none() {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is missing or incomplete \
+             (session_id+rollout_path+captured_at+captured_via required)"
+        )));
+    }
+    let backing = PathBuf::from(backing);
+    if !backing.is_file() {
+        return Err(LifecycleError::Provider(format!(
+            "cannot fork {source_agent_id}: source session backing is not readable: {}",
+            backing.display()
+        )));
+    }
+    Ok((
+        crate::provider::SessionId::new(session_id.to_string()),
+        backing,
+    ))
+}
+
 pub(super) fn append_forked_agent(
     spec: &Value,
     source_agent: &Value,

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

@@ -295,6 +295,7 @@ mod fork_state;
 pub(super) use fork_state::*;
 
 mod fork_finalize;
+pub(crate) use fork_finalize::finalize_pending_fork_capture;
 pub(super) use fork_finalize::*;
 
 mod role_source;

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

@@ -664,6 +664,14 @@ pub struct ForkAgentReport {
     pub new_agent_id: AgentId,
     pub env: AgentActionEnvelope,
     pub session_id: Option<SessionId>,
+    pub backing_state: ForkBackingState,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ForkBackingState {
+    Verified,
+    PendingContextFork,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -130,6 +130,7 @@ pub(crate) fn fork_agent(
             "state_file": report.env.state_file.to_string_lossy().to_string(),
             "coordinator_started": report.env.coordinator_started,
             "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "backing_state": report.backing_state,
         })),
     })
 }

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -336,9 +336,20 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
                     .or_else(|| obj.get("name"))
                     .or_else(|| obj.get("test"))
                     .and_then(text_of_value)?;
+                let status =
+                    match normalize_token(obj.get("status").and_then(Value::as_str)).as_str() {
+                        "executed" => {
+                            if obj.get("exit_code").and_then(Value::as_i64) == Some(0) {
+                                TestStatus::Passed
+                            } else {
+                                TestStatus::Failed
+                            }
+                        }
+                        _ => normalize_test_status(obj.get("status").and_then(Value::as_str)),
+                    };
                 Some(NormalizedTest {
                     command,
-                    status: normalize_test_status(obj.get("status").and_then(Value::as_str)),
+                    status,
                     detail: obj
                         .get("detail")
                         .or_else(|| obj.get("output"))
@@ -346,6 +357,7 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
                         .or_else(|| obj.get("stderr"))
                         .or_else(|| obj.get("summary"))
                         .or_else(|| obj.get("message"))
+                        .or_else(|| obj.get("log_path"))
                         .and_then(text_of_value),
                 })
             }
@@ -358,6 +370,46 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
         .collect()
 }
 
+pub(crate) fn validate_test_evidence_schema(value: Option<&Value>) -> Result<(), String> {
+    const ALLOWED: &str = r#"allowed schema: {"status":"executed","command":string,"exit_code":integer,"log_path":string}"#;
+    for (index, item) in items_from_value(value).iter().enumerate() {
+        let Value::Object(obj) = item else {
+            continue;
+        };
+        let status = normalize_token(obj.get("status").and_then(Value::as_str));
+        if status == "executed" {
+            let valid = obj.get("command").and_then(Value::as_str).is_some()
+                && obj.get("exit_code").and_then(Value::as_i64).is_some()
+                && obj.get("log_path").and_then(Value::as_str).is_some();
+            if !valid {
+                return Err(format!(
+                    "unsupported_test_evidence_schema at tests[{index}]; {ALLOWED}"
+                ));
+            }
+        } else if !status.is_empty()
+            && !matches!(
+                status.as_str(),
+                "passed"
+                    | "pass"
+                    | "ok"
+                    | "success"
+                    | "failed"
+                    | "fail"
+                    | "error"
+                    | "skipped"
+                    | "skip"
+                    | "not_run"
+                    | "notrun"
+            )
+        {
+            return Err(format!(
+                "unsupported_test_evidence_schema at tests[{index}]; {ALLOWED}"
+            ));
+        }
+    }
+    Ok(())
+}
+
 pub(crate) fn normalize_risks(value: Option<&Value>) -> Vec<NormalizedRisk> {
     items_from_value(value)
         .iter()

package/crates/team-agent/src/mcp_server/tools.rs

@@ -27,7 +27,7 @@ use super::helpers::{
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
-    report_result_integrity_warnings,
+    report_result_integrity_warnings, validate_test_evidence_schema,
 };
 use super::types::{
     Scope, SendOutcome, ToolError, ToolErrorReason, ToolOk, ToolResult, VisiblePeers,
@@ -522,6 +522,13 @@ impl TeamOrchestratorTools {
         {
             self.note_unknown_result_status(&raw);
         }
+        if let Err(error) = validate_test_evidence_schema(base.get("tests")) {
+            return Err(ToolError::new(
+                ToolErrorReason::InvalidToolArguments,
+                error,
+                "UnsupportedTestEvidenceSchema",
+            ));
+        }
         let normalized = normalize_report_envelope(&base);
         if let Some(error) = normalized.presentation_error.as_deref() {
             return Err(ToolError::new(

package/crates/team-agent/src/provider/session/capture.rs

@@ -469,13 +469,25 @@ fn classify_pending_capture_state(
     const TRIGGER_GRACE_SECS: i64 = 15;
     let past_spawn_grace = elapsed_since_spawn >= SPAWN_GRACE_SECS;
     let past_trigger_grace = has_trigger && elapsed_since_trigger >= TRIGGER_GRACE_SECS;
+    let fork_pending_expired = agent_obj.get("capture_state").and_then(Value::as_str)
+        == Some("pending_context_fork")
+        && crate::provider::session::transition_pending_context_fork(
+            has_trigger,
+            past_spawn_grace && past_trigger_grace,
+        )
+        .is_some();
     // transcript_missing requires BOTH: a trigger occurred AND we've
     // waited past the spawn grace (so we're not blamed for slow startup).
     // candidate_count == 0 is the "no backing" signal; non-zero
     // candidates that didn't satisfy assignment go through the ambiguous
     // path above and don't reach here.
-    if has_trigger && past_spawn_grace && past_trigger_grace && candidate_count == 0 {
+    if (fork_pending_expired || has_trigger && past_spawn_grace && past_trigger_grace)
+        && candidate_count == 0
+    {
         "transcript_missing"
+    } else if agent_obj.get("capture_state").and_then(Value::as_str) == Some("pending_context_fork")
+    {
+        "pending_context_fork"
     } else {
         "pending_first_turn"
     }
@@ -1143,6 +1155,9 @@ fn apply_captured_session(
     agent_obj: &mut serde_json::Map<String, Value>,
     captured: &CapturedSession,
 ) -> bool {
+    if agent_obj.get("capture_state").and_then(Value::as_str) == Some("pending_context_fork") {
+        return crate::lifecycle::finalize_pending_fork_capture(agent_obj, captured);
+    }
     let Some(session_id) = captured.session_id.as_ref() else {
         return false;
     };
@@ -1984,6 +1999,27 @@ mod u1_tests {
         );
     }
 
+    #[test]
+    fn pending_context_fork_keeps_typed_state_until_trigger_grace_expires() {
+        let old = (chrono::Utc::now() - chrono::Duration::seconds(60)).to_rfc3339();
+        let mut agent = serde_json::Map::new();
+        agent.insert("spawned_at".to_string(), serde_json::json!(old));
+        agent.insert(
+            "capture_state".to_string(),
+            serde_json::json!("pending_context_fork"),
+        );
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "pending_context_fork"
+        );
+        let trigger = (chrono::Utc::now() - chrono::Duration::seconds(20)).to_rfc3339();
+        agent.insert("first_send_at".to_string(), serde_json::json!(trigger));
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "transcript_missing"
+        );
+    }
+
     #[test]
     fn canonical_pending_capture_preserves_legacy_missing_boundary() {
         let agent = serde_json::json!({

package/crates/team-agent/src/provider/session/context_fork/claude.rs

@@ -0,0 +1,85 @@
+use super::*;
+
+pub(super) fn verify_claude_fork(
+    provider: Provider,
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
+    spawn_cwd: &Path,
+    deadline: Duration,
+) -> Result<ContextForkProof, ContextForkTermination> {
+    let expected = plan.expected_session_id.as_ref().ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: Claude plan has no expected session id".to_string(),
+        )
+    })?;
+    let path = expected_backing_path.ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: Claude plan has no exact snapshot backing".to_string(),
+        )
+    })?;
+    let expected_name = format!("{}.jsonl", expected.as_str());
+    if path.file_name().and_then(|name| name.to_str()) != Some(expected_name.as_str()) {
+        return Err(ProviderError::CaptureFailed(format!(
+            "context_fork_unverified: Claude snapshot backing does not match expected session {}",
+            expected.as_str()
+        ))
+        .into());
+    }
+    let started = std::time::Instant::now();
+    loop {
+        if let Some(stamp) = file_stamp(path) {
+            let changed = before.files.get(path).is_none_or(|old| *old != stamp);
+            let observed_matches =
+                session_id_from_jsonl(path).is_none_or(|observed| observed == expected.as_str());
+            if changed && readable_jsonl(path) && observed_matches && expected != source_session_id
+            {
+                return Ok(ContextForkProof {
+                    provider,
+                    source_session_id: source_session_id.clone(),
+                    new_session_id: expected.clone(),
+                    backing_path: path.to_path_buf(),
+                    captured_via: "context_fork_verified".to_string(),
+                    attribution_confidence: "high".to_string(),
+                    managed_backing_root: None,
+                });
+            }
+        }
+        if let Some(provider_path) = std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .and_then(|home| {
+                crate::provider::session_scan::claude::projects_dir_for_cwd(&home, spawn_cwd)
+            })
+            .map(|root| root.join(&expected_name))
+        {
+            let observed_matches = session_id_from_jsonl(&provider_path)
+                .is_some_and(|observed| observed == expected.as_str());
+            let changed = file_stamp(&provider_path)
+                .is_some_and(|stamp| before.files.get(&provider_path) != Some(&stamp));
+            if changed
+                && readable_jsonl(&provider_path)
+                && observed_matches
+                && expected != source_session_id
+            {
+                return Ok(ContextForkProof {
+                    provider,
+                    source_session_id: source_session_id.clone(),
+                    new_session_id: expected.clone(),
+                    backing_path: provider_path,
+                    captured_via: "context_fork_verified".to_string(),
+                    attribution_confidence: "high".to_string(),
+                    managed_backing_root: None,
+                });
+            }
+        }
+        if started.elapsed() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    Err(ContextForkTermination::Timeout {
+        provider,
+        deadline_ms: deadline.as_millis(),
+    })
+}

package/crates/team-agent/src/provider/session/context_fork/codex.rs

@@ -0,0 +1,65 @@
+use super::*;
+
+pub(super) fn verify_codex_fork(
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    agent_id: &str,
+    spawn_cwd: &Path,
+    spawned_at: &str,
+    deadline: Duration,
+) -> Result<ContextForkProof, ContextForkTermination> {
+    let context = crate::provider::session_scan::CaptureSessionContext {
+        agent_id: agent_id.to_string(),
+        spawn_cwd: spawn_cwd.to_path_buf(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: Some(spawned_at.to_string()),
+        expected_session_id: plan.expected_session_id.clone(),
+        provider_projects_root: plan.provider_projects_root.clone(),
+    };
+    let excluded = outcome::source_exclusions(before, source_session_id);
+    let started = std::time::Instant::now();
+    loop {
+        let current = jsonl_files(&before.root);
+        for candidate in
+            crate::provider::session_scan::scan_session_candidates_once(Provider::Codex, &context)?
+        {
+            let Some(path) = candidate.captured.rollout_path.as_ref() else {
+                continue;
+            };
+            let Some(stamp) = current.get(path.as_path()) else {
+                continue;
+            };
+            let snapshot_changed = before.files.get(path.as_path()) != Some(stamp);
+            if !snapshot_changed {
+                continue;
+            }
+            let Some(new_session_id) = candidate.captured.session_id else {
+                continue;
+            };
+            if excluded.contains(new_session_id.as_str())
+                || excluded.contains(&path.as_path().to_string_lossy().to_string())
+            {
+                continue;
+            }
+            return Ok(ContextForkProof {
+                provider: Provider::Codex,
+                source_session_id: source_session_id.clone(),
+                new_session_id,
+                backing_path: path.as_path().to_path_buf(),
+                captured_via: "context_fork_verified".to_string(),
+                attribution_confidence: "high".to_string(),
+                managed_backing_root: None,
+            });
+        }
+        if started.elapsed() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    Err(ContextForkTermination::Timeout {
+        provider: Provider::Codex,
+        deadline_ms: deadline.as_millis(),
+    })
+}

package/crates/team-agent/src/provider/session/context_fork/outcome.rs

@@ -0,0 +1,138 @@
+use super::*;
+use std::collections::BTreeSet;
+
+pub(super) fn source_exclusions(
+    before: &ContextBackingSnapshot,
+    source_session_id: &SessionId,
+) -> BTreeSet<String> {
+    let mut excluded = BTreeSet::from([source_session_id.as_str().to_string()]);
+    for path in before.files.keys() {
+        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
+            excluded.insert(path.to_string_lossy().to_string());
+        }
+    }
+    excluded
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct PendingContextFork {
+    pub source_session_id: SessionId,
+    pub target_agent: String,
+    pub spawned_at: String,
+    pub scanner_context: crate::provider::session_scan::CaptureSessionContext,
+}
+
+#[derive(Debug)]
+pub(crate) enum ContextForkOutcome {
+    Verified(ContextForkProof),
+    Pending(PendingContextFork),
+    Rejected(ProviderError),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ContextForkPendingFailure {
+    TranscriptMissing,
+}
+
+pub(crate) fn transition_pending_context_fork(
+    triggered: bool,
+    grace_expired: bool,
+) -> Option<ContextForkPendingFailure> {
+    (triggered && grace_expired).then_some(ContextForkPendingFailure::TranscriptMissing)
+}
+
+pub(crate) fn observe_context_fork(
+    provider: Provider,
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
+    agent_id: &str,
+    spawn_cwd: &Path,
+    spawned_at: &str,
+    deadline: Duration,
+) -> ContextForkOutcome {
+    match verify_context_fork(
+        provider,
+        source_session_id,
+        plan,
+        before,
+        expected_backing_path,
+        agent_id,
+        spawn_cwd,
+        spawned_at,
+        deadline,
+    ) {
+        Ok(proof) => ContextForkOutcome::Verified(proof),
+        Err(ContextForkTermination::Timeout { .. }) => {
+            ContextForkOutcome::Pending(PendingContextFork {
+                source_session_id: source_session_id.clone(),
+                target_agent: agent_id.to_string(),
+                spawned_at: spawned_at.to_string(),
+                scanner_context: crate::provider::session_scan::CaptureSessionContext {
+                    agent_id: agent_id.to_string(),
+                    spawn_cwd: spawn_cwd.to_path_buf(),
+                    pane_id: None,
+                    pane_pid: None,
+                    spawned_at: Some(spawned_at.to_string()),
+                    expected_session_id: plan.expected_session_id.clone(),
+                    provider_projects_root: plan.provider_projects_root.clone(),
+                },
+            })
+        }
+        Err(ContextForkTermination::Rejected(error)) => ContextForkOutcome::Rejected(error),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn convergence_deadlines_are_provider_specific() {
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Claude),
+            Duration::from_secs(45)
+        );
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Codex),
+            Duration::from_secs(10)
+        );
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Copilot),
+            Duration::from_secs(5)
+        );
+    }
+
+    #[test]
+    fn codex_without_new_backing_is_typed_pending() {
+        let root =
+            std::env::temp_dir().join(format!("ta-codex-fork-pending-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(&root).unwrap();
+        let plan = CommandPlan {
+            argv: Vec::new(),
+            expected_session_id: None,
+            provider_projects_root: Some(root.clone()),
+            managed_mcp_config: false,
+        };
+        let before = ContextBackingSnapshot::capture(Provider::Codex, &plan);
+        let outcome = observe_context_fork(
+            Provider::Codex,
+            &SessionId::new("source-session"),
+            &plan,
+            &before,
+            None,
+            "fork",
+            &root,
+            "2026-07-24T00:00:00Z",
+            Duration::ZERO,
+        );
+        let ContextForkOutcome::Pending(pending) = outcome else {
+            panic!("missing backing must remain a typed pending fork")
+        };
+        assert_eq!(pending.source_session_id.as_str(), "source-session");
+        assert_eq!(pending.target_agent, "fork");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+}