@team-agent/installer 0.5.59 → 0.5.60

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.59"
+version = "0.5.60"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.59"
+version = "0.5.60"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/coordinator/tick.rs

@@ -269,12 +269,17 @@ impl Coordinator {
         }
 
         self.record_step("capture_missing");
-        if let Err(error) = self.capture_missing_sessions(&mut state, &event_log) {
-            let _ = event_log.write(
-                "coordinator.tick.capture_missing_failed",
-                serde_json::json!({"error": error.to_string()}),
-            );
-        }
+        let pending_context_fork_audits =
+            match self.capture_missing_sessions(&mut state, &event_log) {
+                Ok(audits) => audits,
+                Err(error) => {
+                    let _ = event_log.write(
+                        "coordinator.tick.capture_missing_failed",
+                        serde_json::json!({"error": error.to_string()}),
+                    );
+                    Vec::new()
+                }
+            };
 
         // Slice 1 energy gate: one pane snapshot per tick feeds probe eligibility,
         // health sync, and abnormal-exit detection. Missing panes are filtered
@@ -454,6 +459,14 @@ impl Coordinator {
                 collections,
             ));
         }
+        for context_fork in &pending_context_fork_audits {
+            context_fork.write_audit(&event_log).map_err(|error| {
+                eprintln!(
+                    "[coordinator] context_fork audit publish failed after state commit: {error}"
+                );
+                TickError::EventLog(error)
+            })?;
+        }
 
         // 0.5.36 (`.team/artifacts/supermarket-api-error-recovery-locate.md` §7.3):
         // post-save recovery step. Reloads fresh state, consumes due
@@ -487,7 +500,7 @@ impl Coordinator {
         &self,
         state: &mut Value,
         event_log: &EventLog,
-    ) -> Result<(), TickError> {
+    ) -> Result<Vec<crate::lifecycle::launch::ContextForkFinalized>, TickError> {
         let report = crate::session_capture::capture_missing_provider_sessions_once(
             state,
             &mut |provider| self.provider_registry.adapter_for(provider),
@@ -651,7 +664,7 @@ impl Coordinator {
                 }),
             )?;
         }
-        Ok(())
+        Ok(report.context_forks)
     }
 
     fn sync_agent_health(

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

@@ -0,0 +1,58 @@
+use super::super::*;
+
+pub(super) struct CompleteForkInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub agent_id: &'a AgentId,
+    pub spawn: &'a crate::transport::SpawnResult,
+    pub window: &'a WindowName,
+    pub transport: &'a dyn Transport,
+    pub session_name: &'a SessionName,
+    pub mcp_config_path: &'a Path,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub materialized_role: &'a mut MaterializedRole,
+    pub claude_fork:
+        &'a mut Option<crate::provider::adapters::claude_fork::ClaudeForkMaterialization>,
+    pub copilot_fork:
+        &'a mut Option<crate::provider::adapters::copilot_fork::CopilotForkMaterialization>,
+}
+
+pub(super) fn complete_fork(input: CompleteForkInput<'_>) -> Result<bool, LifecycleError> {
+    if let Err(error) = verify_fork_registration(
+        input.workspace,
+        input.team_key,
+        input.agent_id,
+        input.spawn,
+        input.window,
+    ) {
+        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,
+        );
+        return Err(error);
+    }
+    let coordinator_started = start_fork_coordinator(ForkCoordinatorInput {
+        workspace: input.workspace,
+        team_key: input.team_key,
+        agent_id: input.agent_id,
+        transport: input.transport,
+        session_name: input.session_name,
+        window: input.window,
+        mcp_config_path: input.mcp_config_path,
+        profile_launch: input.profile_launch,
+    })?;
+    input.materialized_role.keep();
+    if let Some(materialized) = input.claude_fork.as_mut() {
+        materialized.keep();
+    }
+    if let Some(materialized) = input.copilot_fork.as_mut() {
+        materialized.keep();
+    }
+    Ok(coordinator_started)
+}

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

@@ -1,16 +1,7 @@
 use super::*;
-use crate::lifecycle::lock::{acquire_agent_lifecycle_lock, LifecycleLockRequest};
 use crate::lifecycle::profile_launch::parse_provider;
-use crate::lifecycle::*;
-use crate::model::enums::{AuthMode, DisplayBackend, Provider, ProviderEffort};
-use crate::model::ids::AgentId;
-use crate::model::permissions::{self, AgentPermissionInput};
-use crate::model::yaml::{self, Value};
-use crate::state::persist::load_runtime_state;
-use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
-use std::collections::{BTreeMap, BTreeSet};
-use std::path::{Path, PathBuf};
-use std::process::Command;
+
+mod completion;
 
 pub fn fork_agent_with_transport(
     workspace: &Path,
@@ -239,6 +230,23 @@ pub fn fork_agent_with_transport(
         as_agent_id.as_str(),
         Some(&fork_team),
     );
+    let spawned_at = spawn_timestamp_for_agent(1);
+    let mut fork_backing = adapter
+        .materialize_fork_backing(
+            &source_backing,
+            &session_id,
+            source_agent_id.as_str(),
+            as_agent_id.as_str(),
+            &mut plan,
+        )
+        .map_err(|error| {
+            let _ = std::fs::write(&spec_path, text.as_bytes());
+            cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
+            LifecycleError::Provider(error.to_string())
+        })?;
+    let mut expected_backing_path = fork_backing
+        .as_ref()
+        .map(|materialized| materialized.path().to_path_buf());
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         plan.provider_projects_root = source_backing.parent().map(Path::to_path_buf);
     }
@@ -248,12 +256,19 @@ pub fn fork_agent_with_transport(
         &plan,
         &source_backing,
         &session_id,
+        source_agent_id,
+        as_agent_id,
     )
     .map_err(|error| {
         let _ = std::fs::write(&spec_path, text.as_bytes());
         cleanup_fork_mcp_artifacts(&workspace, as_agent_id, &mcp_config_path, &profile_launch);
         error
     })?;
+    if expected_backing_path.is_none() {
+        expected_backing_path = claude_fork
+            .as_ref()
+            .map(|materialized| materialized.path().to_path_buf());
+    }
     // The framework-created Claude snapshot is only fork input, not provider
     // proof. Observe changes made after materialization so a spawn-only
     // provider cannot turn the copied source backing into a Verified result.
@@ -307,7 +322,6 @@ pub fn fork_agent_with_transport(
     // Release the metadata lock before per-seat provider convergence; finalize reacquires it.
     drop(_lock);
     let spawn_epoch = 1_u64;
-    let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
     let spawn_result = if session_live {
         transport.spawn_into_with_env_unset(
             &session_name,
@@ -343,6 +357,9 @@ pub fn fork_agent_with_transport(
             return Err(LifecycleError::Transport(error.to_string()));
         }
     };
+    if let Some(materialized) = fork_backing.as_mut() {
+        materialized.handoff();
+    }
     ensure_fork_spawn_live(ForkPostSpawnInput {
         workspace: &workspace,
         transport,
@@ -361,7 +378,8 @@ pub fn fork_agent_with_transport(
         &session_id,
         &plan,
         &backing_before,
-        claude_fork.as_ref().map(|materialized| materialized.path()),
+        expected_backing_path.as_deref(),
+        source_agent_id.as_str(),
         as_agent_id.as_str(),
         &workspace,
         &spawned_at,
@@ -414,7 +432,7 @@ pub fn fork_agent_with_transport(
         }
     };
     if let Some(context_proof) = context_proof.as_ref() {
-        if let Err(error) = finalize_fork_state(ForkFinalizeInput {
+        let finalized = match finalize_fork_state(ForkFinalizeInput {
             workspace: &workspace,
             team_key: &fork_team,
             source_agent_id,
@@ -430,51 +448,39 @@ pub fn fork_agent_with_transport(
             spawned_at: &spawned_at,
             spawn_epoch,
         }) {
-            rollback_fork_after_spawn(
-                &workspace,
-                transport,
-                &session_name,
-                &window,
-                &mcp_config_path,
-                as_agent_id,
-                &profile_launch,
-                &fork_team,
-            );
-            return Err(error);
-        }
-    }
-    if let Err(error) =
-        verify_fork_registration(&workspace, &fork_team, as_agent_id, &spawn, &window)
-    {
-        rollback_fork_after_spawn(
-            &workspace,
-            transport,
-            &session_name,
-            &window,
-            &mcp_config_path,
-            as_agent_id,
-            &profile_launch,
-            &fork_team,
-        );
-        return Err(error);
+            Ok(finalized) => finalized,
+            Err(error) => {
+                rollback_fork_after_spawn(
+                    &workspace,
+                    transport,
+                    &session_name,
+                    &window,
+                    &mcp_config_path,
+                    as_agent_id,
+                    &profile_launch,
+                    &fork_team,
+                );
+                return Err(error);
+            }
+        };
+        finalized
+            .write_audit(&crate::event_log::EventLog::new(&workspace))
+            .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
     }
-    let coordinator_started = start_fork_coordinator(ForkCoordinatorInput {
+    let coordinator_started = completion::complete_fork(completion::CompleteForkInput {
         workspace: &workspace,
         team_key: &fork_team,
         agent_id: as_agent_id,
+        spawn: &spawn,
+        window: &window,
         transport,
         session_name: &session_name,
-        window: &window,
         mcp_config_path: &mcp_config_path,
         profile_launch: &profile_launch,
+        materialized_role: &mut materialized_role,
+        claude_fork: &mut claude_fork,
+        copilot_fork: &mut copilot_fork,
     })?;
-    materialized_role.keep();
-    if let Some(materialized) = claude_fork.as_mut() {
-        materialized.keep();
-    }
-    if let Some(materialized) = copilot_fork.as_mut() {
-        materialized.keep();
-    }
     let backing_state = if context_proof.is_some() {
         ForkBackingState::Verified
     } else {

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

@@ -44,6 +44,8 @@ pub(super) fn prepare_claude_fork_backing(
     plan: &crate::provider::CommandPlan,
     source_backing: &Path,
     source_session_id: &crate::provider::SessionId,
+    source_agent_id: &AgentId,
+    target_agent_id: &AgentId,
 ) -> Result<Option<crate::provider::adapters::claude_fork::ClaudeForkMaterialization>, LifecycleError>
 {
     if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
@@ -56,6 +58,8 @@ pub(super) fn prepare_claude_fork_backing(
         source_backing,
         source_session_id,
         target_session_id,
+        source_agent_id.as_str(),
+        target_agent_id.as_str(),
     )
     .map(Some)
     .map_err(|error| {
@@ -122,7 +126,75 @@ pub(super) struct ForkFinalizeInput<'a> {
     pub spawn_epoch: u64,
 }
 
-pub(super) fn finalize_fork_state(input: ForkFinalizeInput<'_>) -> Result<(), LifecycleError> {
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ContextForkFinalized {
+    source_agent_id: String,
+    agent_id: String,
+    session_id: String,
+    rollout_path: String,
+    captured_via: String,
+    attribution_confidence: String,
+}
+
+impl ContextForkFinalized {
+    fn new(
+        source_agent_id: &str,
+        agent_id: &str,
+        session_id: &str,
+        rollout_path: &Path,
+        captured_via: &str,
+        attribution_confidence: &str,
+    ) -> Self {
+        Self {
+            source_agent_id: source_agent_id.to_string(),
+            agent_id: agent_id.to_string(),
+            session_id: session_id.to_string(),
+            rollout_path: rollout_path.to_string_lossy().to_string(),
+            captured_via: captured_via.to_string(),
+            attribution_confidence: attribution_confidence.to_string(),
+        }
+    }
+
+    fn from_captured(
+        source_agent_id: &str,
+        agent_id: &str,
+        captured: &crate::provider::CapturedSession,
+    ) -> Option<Self> {
+        let captured_via = serde_json::to_value(captured.captured_via).ok()?;
+        let attribution_confidence = serde_json::to_value(captured.attribution_confidence).ok()?;
+        Some(Self::new(
+            source_agent_id,
+            agent_id,
+            captured.session_id.as_ref()?.as_str(),
+            captured.rollout_path.as_ref()?.as_path(),
+            captured_via.as_str()?,
+            attribution_confidence.as_str()?,
+        ))
+    }
+
+    pub(crate) fn write_audit(
+        &self,
+        event_log: &crate::event_log::EventLog,
+    ) -> Result<(), crate::event_log::EventLogError> {
+        event_log
+            .write(
+                crate::lifecycle::types::event_names::CONTEXT_FORK,
+                serde_json::json!({
+                    "source_agent_id": self.source_agent_id,
+                    "agent_id": self.agent_id,
+                    "session_id": self.session_id,
+                    "rollout_path": self.rollout_path,
+                    "captured_via": self.captured_via,
+                    "attribution_confidence": self.attribution_confidence,
+                }),
+            )
+            .map(|_| ())
+    }
+}
+
+pub(super) fn finalize_fork_state(
+    input: ForkFinalizeInput<'_>,
+) -> Result<ContextForkFinalized, LifecycleError> {
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: input.workspace,
         operation: "fork-agent-finalize",
@@ -169,7 +241,15 @@ pub(super) fn finalize_fork_state(input: ForkFinalizeInput<'_>) -> Result<(), Li
             },
             &next_state,
         )
-        .map_err(|error| LifecycleError::StatePersist(error.to_string()))
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))?;
+    Ok(ContextForkFinalized::new(
+        input.source_agent_id.as_str(),
+        input.agent_id.as_str(),
+        input.context_proof.new_session_id.as_str(),
+        &input.context_proof.backing_path,
+        &input.context_proof.captured_via,
+        &input.context_proof.attribution_confidence,
+    ))
 }
 
 pub(super) struct ForkPendingFinalizeInput<'a> {
@@ -233,20 +313,36 @@ pub(super) fn finalize_pending_fork_state(
 pub(crate) fn finalize_pending_fork_capture(
     agent: &mut serde_json::Map<String, serde_json::Value>,
     captured: &crate::provider::CapturedSession,
-) -> bool {
+) -> Option<ContextForkFinalized> {
     let Some(session_id) = captured.session_id.as_ref() else {
-        return false;
+        return None;
     };
     let Some(rollout_path) = captured.rollout_path.as_ref() else {
-        return false;
+        return None;
     };
     if agent
         .get("fork_source_session_id")
         .and_then(serde_json::Value::as_str)
         == Some(session_id.as_str())
     {
-        return false;
+        return None;
     }
+    let finalized = ContextForkFinalized::from_captured(
+        agent
+            .get("forked_from")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or_default(),
+        agent
+            .get("agent_id")
+            .and_then(serde_json::Value::as_str)
+            .or_else(|| {
+                agent
+                    .get("pending_target_agent")
+                    .and_then(serde_json::Value::as_str)
+            })
+            .unwrap_or_default(),
+        captured,
+    )?;
     agent.insert(
         "session_id".to_string(),
         serde_json::json!(session_id.as_str()),
@@ -269,11 +365,55 @@ pub(crate) fn finalize_pending_fork_capture(
     );
     agent.remove("_pending_session_id");
     agent.remove("attribution_ambiguous");
-    agent.remove("fork_source_session_id");
     agent.remove("pending_target_agent");
     agent.remove("pending_grace_secs");
     agent.insert("capture_state".to_string(), serde_json::json!("captured"));
-    true
+    Some(finalized)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn context_fork_finalized_writes_catalog_event_and_canonical_fields() {
+        let workspace = std::env::temp_dir().join(format!(
+            "team-agent-context-fork-audit-{}",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_dir_all(&workspace);
+        std::fs::create_dir_all(&workspace).expect("create audit workspace");
+        let event_log = crate::event_log::EventLog::new(&workspace);
+        ContextForkFinalized::new(
+            "source",
+            "target",
+            "target-session",
+            Path::new("/tmp/target.jsonl"),
+            "context_fork_verified",
+            "high",
+        )
+        .write_audit(&event_log)
+        .expect("write context fork audit");
+
+        let events = event_log.tail(0).expect("read context fork audit");
+        let event = events.last().expect("context fork audit event");
+        assert_eq!(
+            event.get("event").and_then(serde_json::Value::as_str),
+            Some(crate::lifecycle::types::event_names::CONTEXT_FORK)
+        );
+        assert_eq!(
+            event
+                .get("source_agent_id")
+                .and_then(serde_json::Value::as_str),
+            Some("source")
+        );
+        assert_eq!(
+            event.get("agent_id").and_then(serde_json::Value::as_str),
+            Some("target")
+        );
+        assert!(event.get("prompt").is_none());
+        let _ = std::fs::remove_dir_all(workspace);
+    }
 }
 
 pub(super) fn verify_fork_registration(

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

@@ -354,6 +354,11 @@ pub(super) fn upsert_forked_agent_state(
         "forked_from".to_string(),
         serde_json::json!(source_agent_id.as_str()),
     );
+    entry.insert(
+        "fork_source_session_id".to_string(),
+        serde_json::json!(context_proof.source_session_id.as_str()),
+    );
+    entry.insert("capture_state".to_string(), serde_json::json!("captured"));
     entry.insert(
         "dynamic_role_file".to_string(),
         serde_json::json!(dynamic_role_file.to_string_lossy().to_string()),

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

@@ -295,8 +295,8 @@ 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::*;
+pub(crate) use fork_finalize::{finalize_pending_fork_capture, ContextForkFinalized};
 
 mod role_source;
 pub(super) use role_source::*;

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

@@ -1178,7 +1178,29 @@ pub(super) fn fork_ws(alpha_role: &str) -> PathBuf {
         std::process::id(),
         n
     ));
-    std::fs::write(&rollout, b"{}\n").expect("seed fork source rollout");
+    std::fs::write(
+        &rollout,
+        format!(
+            "{}\n{}\n",
+            json!({
+                "type": "session_meta",
+                "payload": {
+                    "id": "sess-a",
+                    "cwd": ws,
+                }
+            }),
+            json!({
+                "type": "response_item",
+                "payload": {
+                    "content": [{
+                        "type": "input_text",
+                        "text": "You are Team Agent worker `alpha` with role `fixture`."
+                    }]
+                }
+            })
+        ),
+    )
+    .expect("seed identity-complete fork source rollout");
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
@@ -1669,6 +1691,18 @@ fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
 fn lanea_fork_report_session_id_is_not_pane_id() {
     let _home = LaneHomeGuard::enter("fork-report");
     let ws = fork_ws(DELEG_ROLE_ALPHA); // codex+subscription -> native fork supported -> full success path
+    let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let source = PathBuf::from(state["agents"]["alpha"]["rollout_path"].as_str().unwrap());
+    let codex_root = std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .unwrap()
+        .join(".codex/sessions/lane-fixture");
+    std::fs::create_dir_all(&codex_root).unwrap();
+    let discoverable_source = codex_root.join("rollout-sess-a.jsonl");
+    std::fs::copy(source, &discoverable_source).unwrap();
+    state["agents"]["alpha"]["rollout_path"] =
+        json!(discoverable_source.to_string_lossy().to_string());
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let tx = LaneTransport::new("team-laneateam", &[]);
     let report =
         fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx)

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

@@ -36,6 +36,7 @@ pub mod event_names {
     pub const ADD_FAILED: &str = "lifecycle.add_failed";
     pub const REMOVE_STEP_COMPLETED: &str = "lifecycle.remove_step_completed";
     pub const REMOVE_ROLLED_BACK: &str = "lifecycle.remove_rolled_back";
+    pub const CONTEXT_FORK: &str = "context_fork";
     // restart 决策事件(Route B audit 契约必发)。
     pub const RESTART_RESUME_DECISION: &str = "restart.resume_decision";
     pub const RESTART_ATOMIC_REFUSAL: &str = "restart.atomic_refusal";

package/crates/team-agent/src/provider/adapter.rs

@@ -12,6 +12,11 @@ use super::{AuthMode, Provider};
 
 pub use crate::provider::session_scan::{CaptureSessionContext, CapturedSessionCandidate};
 
+pub trait ForkBackingMaterialization {
+    fn path(&self) -> &Path;
+    fn handoff(&mut self);
+}
+
 // ===========================================================================
 // TRAIT: ProviderAdapter (method SIGNATURES only — 无 body)
 // ===========================================================================
@@ -187,6 +192,24 @@ pub trait ProviderAdapter {
         .map(CommandPlan::argv_only)
     }
 
+    fn materialize_fork_backing(
+        &self,
+        source_path: &Path,
+        source_session_id: &SessionId,
+        source_agent_id: &str,
+        target_agent_id: &str,
+        plan: &mut CommandPlan,
+    ) -> Result<Option<Box<dyn ForkBackingMaterialization>>, ProviderError> {
+        let _ = (
+            source_path,
+            source_session_id,
+            source_agent_id,
+            target_agent_id,
+            plan,
+        );
+        Ok(None)
+    }
+
     /// 计算本 provider 该用的 MCP server 配置(`adapter.py` mcp_config;claude
     /// compatible_api 走 `ensure_compatible_claude_mcp_config`)。
     fn mcp_config(&self, auth_mode: AuthMode) -> Result<McpConfig, ProviderError>;
@@ -549,6 +572,29 @@ impl ProviderAdapter for BasicProviderAdapter {
         }
     }
 
+    fn materialize_fork_backing(
+        &self,
+        source_path: &Path,
+        source_session_id: &SessionId,
+        source_agent_id: &str,
+        target_agent_id: &str,
+        plan: &mut CommandPlan,
+    ) -> Result<Option<Box<dyn ForkBackingMaterialization>>, ProviderError> {
+        match self.provider {
+            Provider::Codex => crate::provider::session::materialize_codex_fork(
+                source_path,
+                source_session_id,
+                source_agent_id,
+                target_agent_id,
+                plan,
+            )
+            .map(|materialized| {
+                Some(Box::new(materialized) as Box<dyn ForkBackingMaterialization>)
+            }),
+            _ => Ok(None),
+        }
+    }
+
     fn capture_session_id(
         &self,
         agent_id: &str,
@@ -1198,3 +1244,14 @@ pub(crate) fn next_session_token() -> String {
         bytes[15],
     )
 }
+
+#[cfg(test)]
+mod fork_materialization_source_guard {
+    #[test]
+    fn lifecycle_uses_provider_neutral_fork_materialization_dispatch() {
+        let source = include_str!("../lifecycle/launch/fork_agent.rs");
+        assert!(source.contains(".materialize_fork_backing("));
+        assert!(!source.contains("materialize_codex_fork"));
+        assert!(!source.contains("codex_fork"));
+    }
+}