@team-agent/installer 0.5.59 → 0.5.60

package/crates/team-agent/src/provider/adapters/claude_fork.rs

@@ -30,6 +30,8 @@ pub(crate) fn materialize_claude_fork(
     source_path: &Path,
     source_session_id: &SessionId,
     target_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
 ) -> Result<ClaudeForkMaterialization, ProviderError> {
     let parent = source_path.parent().ok_or_else(|| {
         ProviderError::Io(format!(
@@ -46,7 +48,12 @@ pub(crate) fn materialize_claude_fork(
     }
     let source = std::fs::read_to_string(source_path)
         .map_err(|error| ProviderError::Io(error.to_string()))?;
-    let rewritten = source.replace(source_session_id.as_str(), target_session_id.as_str());
+    let rewritten = source
+        .replace(source_session_id.as_str(), target_session_id.as_str())
+        .replace(
+            &format!("You are Team Agent worker `{source_agent_id}`"),
+            &format!("You are Team Agent worker `{target_agent_id}`"),
+        );
     validate_jsonl(&rewritten)?;
     let temp = parent.join(format!(
         ".{}.tmp-{}",
@@ -108,7 +115,8 @@ mod tests {
         std::fs::write(&source_path, &source).unwrap();
 
         let mut materialized =
-            materialize_claude_fork(&source_path, &source_id, &target_id).unwrap();
+            materialize_claude_fork(&source_path, &source_id, &target_id, "source", "target")
+                .unwrap();
         let target_path = dir.join(format!("{}.jsonl", target_id.as_str()));
         let target = std::fs::read_to_string(&target_path).unwrap();
         assert!(!target.contains(source_id.as_str()));

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

@@ -29,6 +29,7 @@ pub struct CapturePassReport {
     /// (coordinator tick) emits a throttled
     /// `provider.session.transcript_missing` event for each entry.
     pub transcript_missing: Vec<TranscriptMissing>,
+    pub(crate) context_forks: Vec<crate::lifecycle::launch::ContextForkFinalized>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -306,9 +307,12 @@ where
             // partial candidates (no session_id or no rollout_path). When
             // it returns false, the row stays unchanged; capture re-runs
             // on the next coordinator tick.
-            if apply_captured_session(agent_obj, &candidate.captured) {
+            if let Some(applied) = apply_captured_session(agent_obj, &candidate.captured) {
                 report.changed = true;
                 report.assigned.push(item.agent_id);
+                if let AppliedCapture::ContextFork(context_fork) = applied {
+                    report.context_forks.push(context_fork);
+                }
             }
             continue;
         }
@@ -676,6 +680,17 @@ where
         .and_then(Value::as_str)
         .filter(|value| !value.is_empty())
         .map(str::to_string);
+    let expected_session_id = agent
+        .get("_pending_session_id")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(SessionId::new);
+    if matches!(provider, Provider::Codex)
+        && agent.get("capture_state").and_then(Value::as_str) == Some("pending_context_fork")
+        && expected_session_id.is_none()
+    {
+        return None;
+    }
     Some(PendingSessionCapture {
         agent_id: agent_id.to_string(),
         provider,
@@ -699,15 +714,7 @@ where
                 .and_then(Value::as_u64)
                 .and_then(|pid| u32::try_from(pid).ok()),
             spawned_at,
-            expected_session_id: if matches!(provider, Provider::Codex) {
-                None
-            } else {
-                agent
-                    .get("_pending_session_id")
-                    .and_then(Value::as_str)
-                    .filter(|value| !value.is_empty())
-                    .map(SessionId::new)
-            },
+            expected_session_id,
             provider_projects_root: agent
                 .get("claude_projects_root")
                 .and_then(Value::as_str)
@@ -1144,6 +1151,11 @@ fn candidate_key(owner: &PendingSessionCapture, candidate: &CapturedSessionCandi
         .join("|")
 }
 
+enum AppliedCapture {
+    Session,
+    ContextFork(crate::lifecycle::launch::ContextForkFinalized),
+}
+
 /// 0.4.6 tuple-atomic contract (audit §Capture 修改清单, line 111): writes
 /// the authoritative session tuple if and only if the candidate carries
 /// BOTH `session_id` and `rollout_path`. A partial candidate (e.g.
@@ -1154,15 +1166,16 @@ fn candidate_key(owner: &PendingSessionCapture, candidate: &CapturedSessionCandi
 fn apply_captured_session(
     agent_obj: &mut serde_json::Map<String, Value>,
     captured: &CapturedSession,
-) -> bool {
+) -> Option<AppliedCapture> {
     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);
+        return crate::lifecycle::finalize_pending_fork_capture(agent_obj, captured)
+            .map(AppliedCapture::ContextFork);
     }
     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;
     };
     agent_obj.insert(
         "session_id".to_string(),
@@ -1192,7 +1205,7 @@ fn apply_captured_session(
     // diagnose/status observability.
     agent_obj.remove("_pending_session_id");
     agent_obj.insert("capture_state".to_string(), serde_json::json!("captured"));
-    true
+    Some(AppliedCapture::Session)
 }
 
 fn claimed_provider_session_keys(
@@ -2621,7 +2634,7 @@ mod u1_tests {
             spawn_cwd: PathBuf::from("/tmp/cwd"),
         };
         let written = super::apply_captured_session(&mut agent, &captured);
-        assert!(written, "apply must return true for valid captured");
+        assert!(written.is_some(), "apply must accept valid captured");
         assert!(
             agent.get("_pending_session_id").is_none(),
             "S1-CAPTURE-001: _pending_session_id must be removed after capture \

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

@@ -1,14 +1,319 @@
 use super::*;
+use std::collections::BTreeSet;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+#[derive(Debug)]
+pub(crate) struct CodexForkMaterialization {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl CodexForkMaterialization {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn mark_handoff(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl crate::provider::adapter::ForkBackingMaterialization for CodexForkMaterialization {
+    fn path(&self) -> &Path {
+        self.path()
+    }
+
+    fn handoff(&mut self) {
+        self.mark_handoff();
+    }
+}
+
+impl Drop for CodexForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(crate) fn materialize_codex_fork(
+    source_path: &Path,
+    source_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+    plan: &mut CommandPlan,
+) -> Result<CodexForkMaterialization, ProviderError> {
+    let target_session_id = SessionId::new(codex_session_v7());
+    let parent = source_path.parent().ok_or_else(|| {
+        ProviderError::Io(format!(
+            "codex source backing has no parent: {}",
+            source_path.display()
+        ))
+    })?;
+    let timestamp = chrono::Utc::now().format("%Y-%m-%dT%H-%M-%S");
+    let target_path = parent.join(format!(
+        "rollout-{timestamp}-{}.jsonl",
+        target_session_id.as_str()
+    ));
+    let source = complete_source_snapshot(source_path)?;
+    let rewritten = rewrite_snapshot(
+        &source,
+        source_session_id,
+        &target_session_id,
+        source_agent_id,
+        target_agent_id,
+    )?;
+    publish_target_no_clobber(&target_path, rewritten.as_bytes())?;
+    if let Err(error) =
+        validate_materialized_target(&target_path, &target_session_id, target_agent_id)
+    {
+        let _ = std::fs::remove_file(&target_path);
+        return Err(error);
+    }
+    apply_resume_target(plan, source_session_id, &target_session_id)?;
+    Ok(CodexForkMaterialization {
+        path: target_path,
+        keep: false,
+    })
+}
+
+fn complete_source_snapshot(path: &Path) -> Result<String, ProviderError> {
+    let file = File::open(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let visible_len = file
+        .metadata()
+        .map_err(|error| ProviderError::Io(error.to_string()))?
+        .len();
+    let mut bytes = Vec::new();
+    file.take(visible_len)
+        .read_to_end(&mut bytes)
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+    let Some(boundary) = bytes.iter().rposition(|byte| *byte == b'\n') else {
+        return Err(ProviderError::Io(
+            "codex fork source has no complete JSONL record".to_string(),
+        ));
+    };
+    bytes.truncate(boundary + 1);
+    String::from_utf8(bytes).map_err(|error| ProviderError::Io(error.to_string()))
+}
+
+fn rewrite_snapshot(
+    source: &str,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+) -> Result<String, ProviderError> {
+    let source_marker = format!("You are Team Agent worker `{source_agent_id}`");
+    let target_marker = format!("You are Team Agent worker `{target_agent_id}`");
+    let mut meta_count = 0_usize;
+    let mut marker_count = 0_usize;
+    let mut output = String::new();
+    for (index, line) in source.lines().enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let mut record = serde_json::from_str::<serde_json::Value>(line).map_err(|error| {
+            ProviderError::Io(format!(
+                "codex fork source has invalid JSONL at line {}: {error}",
+                index + 1
+            ))
+        })?;
+        if record.get("type").and_then(serde_json::Value::as_str) == Some("session_meta") {
+            let id = record
+                .get_mut("payload")
+                .and_then(serde_json::Value::as_object_mut)
+                .and_then(|payload| payload.get_mut("id"))
+                .and_then(|id| id.as_str())
+                .ok_or_else(|| {
+                    ProviderError::Io(
+                        "codex fork session_meta has no string payload.id".to_string(),
+                    )
+                })?;
+            if id != source_session_id.as_str() {
+                return Err(ProviderError::Io(
+                    "codex fork session_meta id does not match source".to_string(),
+                ));
+            }
+            record["payload"]["id"] =
+                serde_json::Value::String(target_session_id.as_str().to_string());
+            meta_count += 1;
+        }
+        marker_count += replace_exact_marker(&mut record, &source_marker, &target_marker);
+        output.push_str(
+            &serde_json::to_string(&record)
+                .map_err(|error| ProviderError::Io(error.to_string()))?,
+        );
+        output.push('\n');
+    }
+    if meta_count != 1 || marker_count != 1 {
+        return Err(ProviderError::Io(format!(
+            "codex fork source identity is ambiguous: session_meta={meta_count}, marker={marker_count}"
+        )));
+    }
+    Ok(output)
+}
+
+fn replace_exact_marker(value: &mut serde_json::Value, source: &str, target: &str) -> usize {
+    match value {
+        serde_json::Value::String(text) => {
+            let count = text.matches(source).count();
+            if count == 1 {
+                *text = text.replacen(source, target, 1);
+            }
+            count
+        }
+        serde_json::Value::Array(items) => items
+            .iter_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        serde_json::Value::Object(fields) => fields
+            .values_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        _ => 0,
+    }
+}
+
+fn publish_target_no_clobber(path: &Path, bytes: &[u8]) -> Result<(), ProviderError> {
+    let parent = path.parent().ok_or_else(|| {
+        ProviderError::Io(format!("codex target has no parent: {}", path.display()))
+    })?;
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("codex-fork"),
+        std::process::id()
+    ));
+    let result = (|| -> std::io::Result<()> {
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&temp)?;
+        file.write_all(bytes)?;
+        file.sync_all()?;
+        std::fs::hard_link(&temp, path)?;
+        File::open(parent)?.sync_all()?;
+        std::fs::remove_file(&temp)?;
+        Ok(())
+    })();
+    if let Err(error) = result {
+        let _ = std::fs::remove_file(&temp);
+        return Err(ProviderError::Io(error.to_string()));
+    }
+    Ok(())
+}
+
+fn validate_materialized_target(
+    path: &Path,
+    session_id: &SessionId,
+    target_agent_id: &str,
+) -> Result<(), ProviderError> {
+    let text =
+        std::fs::read_to_string(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let actual = session_id_from_jsonl(path);
+    let marker = format!("You are Team Agent worker `{target_agent_id}`");
+    if actual.as_deref() != Some(session_id.as_str())
+        || !path
+            .file_stem()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name.ends_with(session_id.as_str()))
+        || text.matches(&marker).count() != 1
+    {
+        return Err(ProviderError::Io(
+            "codex fork target read-back identity mismatch".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+fn apply_resume_target(
+    plan: &mut CommandPlan,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+) -> Result<(), ProviderError> {
+    if plan.argv.first().map(String::as_str) != Some("codex")
+        || plan.argv.get(1).map(String::as_str) != Some("fork")
+        || plan.argv.last().map(String::as_str) != Some(source_session_id.as_str())
+    {
+        return Err(ProviderError::Command(
+            "codex fork command shape cannot be converted to exact resume".to_string(),
+        ));
+    }
+    plan.argv[1] = "resume".to_string();
+    *plan.argv.last_mut().expect("validated non-empty argv") =
+        target_session_id.as_str().to_string();
+    plan.expected_session_id = Some(target_session_id.clone());
+    Ok(())
+}
+
+fn codex_session_v7() -> String {
+    use sha2::Digest;
+
+    static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+    let millis = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |duration| duration.as_millis() as u64);
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(millis.to_le_bytes());
+    hasher.update(std::process::id().to_le_bytes());
+    hasher.update(
+        COUNTER
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+            .to_le_bytes(),
+    );
+    let digest = hasher.finalize();
+    let mut bytes = [0_u8; 16];
+    bytes[..6].copy_from_slice(&millis.to_be_bytes()[2..]);
+    bytes[6..].copy_from_slice(&digest[..10]);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    format!(
+        "{:08x}-{:04x}-{:04x}-{:04x}-{:012x}",
+        u32::from_be_bytes(bytes[0..4].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[4..6].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[6..8].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[8..10].try_into().expect("fixed slice")),
+        u64::from_be_bytes([
+            0, 0, bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]
+        ])
+    )
+}
 
 pub(super) fn verify_codex_fork(
     source_session_id: &SessionId,
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
     deadline: Duration,
 ) -> Result<ContextForkProof, ContextForkTermination> {
+    let Some(expected) = plan.expected_session_id.as_ref() else {
+        return verify_legacy_codex_fork(
+            source_session_id,
+            plan,
+            before,
+            agent_id,
+            spawn_cwd,
+            spawned_at,
+            deadline,
+        );
+    };
+    if expected == source_session_id {
+        return Err(ProviderError::CaptureFailed(
+            "context_fork_unverified: codex target session equals source".to_string(),
+        )
+        .into());
+    }
+    let expected_path = expected_backing_path.ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: codex plan has no materialized target backing".to_string(),
+        )
+    })?;
     let context = crate::provider::session_scan::CaptureSessionContext {
         agent_id: agent_id.to_string(),
         spawn_cwd: spawn_cwd.to_path_buf(),
@@ -18,28 +323,25 @@ pub(super) fn verify_codex_fork(
         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 {
+            if path.as_path() != expected_path {
                 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())
+            if &new_session_id != expected || &new_session_id == source_session_id {
+                continue;
+            }
+            if !candidate.positive_agent_id_match
+                || candidate.embedded_agent_id.as_deref() != Some(agent_id)
             {
                 continue;
             }
@@ -63,3 +365,78 @@ pub(super) fn verify_codex_fork(
         deadline_ms: deadline.as_millis(),
     })
 }
+
+fn verify_legacy_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 mut excluded_session_ids = BTreeSet::new();
+    excluded_session_ids.insert(source_session_id.as_str().to_string());
+    let mut excluded_backing_paths = BTreeSet::new();
+    for path in before.files.keys() {
+        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
+            excluded_backing_paths.insert(path.clone());
+        }
+    }
+    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: None,
+        provider_projects_root: plan.provider_projects_root.clone(),
+    };
+    let started = std::time::Instant::now();
+    loop {
+        let current = jsonl_files(&provider_backing_root(Provider::Codex, plan));
+        let mut matches = Vec::new();
+        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;
+            };
+            if excluded_backing_paths.contains(path.as_path()) {
+                continue;
+            }
+            let Some(stamp) = current.get(path.as_path()) else {
+                continue;
+            };
+            if before.files.get(path.as_path()) == Some(stamp) {
+                continue;
+            }
+            let Some(session_id) = candidate.captured.session_id else {
+                continue;
+            };
+            if excluded_session_ids.contains(session_id.as_str()) {
+                continue;
+            }
+            matches.push((session_id, path.as_path().to_path_buf()));
+        }
+        if let [(new_session_id, backing_path)] = matches.as_slice() {
+            return Ok(ContextForkProof {
+                provider: Provider::Codex,
+                source_session_id: source_session_id.clone(),
+                new_session_id: new_session_id.clone(),
+                backing_path: backing_path.clone(),
+                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

@@ -1,18 +1,4 @@
 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 {
@@ -47,6 +33,7 @@ pub(crate) fn observe_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -58,6 +45,7 @@ pub(crate) fn observe_context_fork(
         plan,
         before,
         expected_backing_path,
+        source_agent_id,
         agent_id,
         spawn_cwd,
         spawned_at,
@@ -123,6 +111,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &root,
             "2026-07-24T00:00:00Z",

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

@@ -21,6 +21,7 @@ pub(crate) enum ContextForkTermination {
 mod claude;
 mod codex;
 mod outcome;
+pub(crate) use codex::materialize_codex_fork;
 pub(crate) use outcome::{
     observe_context_fork, transition_pending_context_fork, ContextForkOutcome, PendingContextFork,
 };
@@ -47,7 +48,6 @@ pub struct ContextForkProof {
 
 #[derive(Debug, Clone)]
 pub(crate) struct ContextBackingSnapshot {
-    root: PathBuf,
     files: BTreeMap<PathBuf, FileStamp>,
 }
 
@@ -61,7 +61,7 @@ impl ContextBackingSnapshot {
     pub(crate) fn capture(provider: Provider, plan: &CommandPlan) -> Self {
         let root = provider_backing_root(provider, plan);
         let files = jsonl_files(&root);
-        Self { root, files }
+        Self { files }
     }
 }
 
@@ -71,6 +71,7 @@ pub(crate) fn verify_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    _source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -84,6 +85,7 @@ pub(crate) fn verify_context_fork(
             source_session_id,
             plan,
             before,
+            expected_backing_path,
             agent_id,
             spawn_cwd,
             spawned_at,
@@ -298,6 +300,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &current_cwd,
             "2026-07-21T20:00:00+00:00",
@@ -344,6 +347,7 @@ mod tests {
             &plan,
             &before,
             Some(&expected_path),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",
@@ -382,6 +386,7 @@ mod tests {
             &plan,
             &before,
             Some(&missing),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",

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

@@ -10,8 +10,9 @@ pub mod resume;
 
 pub use context_fork::ContextForkProof;
 pub(crate) use context_fork::{
-    context_fork_convergence_deadline, observe_context_fork, transition_pending_context_fork,
-    ContextBackingSnapshot, ContextForkOutcome, PendingContextFork,
+    context_fork_convergence_deadline, materialize_codex_fork, observe_context_fork,
+    transition_pending_context_fork, ContextBackingSnapshot, ContextForkOutcome,
+    PendingContextFork,
 };
 
 pub use resume::{