@team-agent/installer 0.5.59 → 0.5.61

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"));
+    }
+}

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)]
@@ -283,12 +284,22 @@ where
                 .zip(candidate.captured.session_id.as_ref())
                 .is_some_and(|(expected, captured)| expected.as_str() != captured.as_str());
             if mismatch {
-                report.ambiguous.push(AmbiguousSessionCapture {
-                    agent_id: item.agent_id.clone(),
-                    spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
-                });
+                let ambiguity_changed = agent_obj
+                    .get("attribution_ambiguous")
+                    .and_then(Value::as_bool)
+                    != Some(true);
+                if !finalize_ambiguous || ambiguity_changed {
+                    report.ambiguous.push(AmbiguousSessionCapture {
+                        agent_id: item.agent_id.clone(),
+                        spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
+                    });
+                }
                 if finalize_ambiguous {
-                    agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                    if ambiguity_changed {
+                        agent_obj
+                            .insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                        report.changed = true;
+                    }
                     // 0.4.6 tuple-atomic contract (audit:93): do NOT write
                     // `captured_at` for ambiguity diagnostics. `captured_at`
                     // is part of the authoritative tuple and may only be
@@ -298,7 +309,6 @@ where
                     // "looks captured" rows. Ambiguity diagnostics live in
                     // the `attribution_ambiguous` flag + events; persist
                     // event log for the timestamp.
-                    report.changed = true;
                 }
                 continue;
             }
@@ -306,26 +316,39 @@ 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;
         }
         if ambiguous_ids.contains(&item.agent_id) {
-            report.ambiguous.push(AmbiguousSessionCapture {
-                agent_id: item.agent_id.clone(),
-                spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
-            });
+            let ambiguity_changed = agent_obj
+                .get("attribution_ambiguous")
+                .and_then(Value::as_bool)
+                != Some(true)
+                || agent_obj.get("capture_state").and_then(Value::as_str)
+                    != Some("attribution_ambiguous");
+            if !finalize_ambiguous || ambiguity_changed {
+                report.ambiguous.push(AmbiguousSessionCapture {
+                    agent_id: item.agent_id.clone(),
+                    spawn_cwd: item.context.spawn_cwd.to_string_lossy().to_string(),
+                });
+            }
             if finalize_ambiguous {
-                agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
-                agent_obj.insert(
-                    "capture_state".to_string(),
-                    serde_json::json!("attribution_ambiguous"),
-                );
-                // 0.4.6 tuple-atomic contract: see comment above. Removed
-                // `captured_at` ambiguity write.
-                report.changed = true;
+                if ambiguity_changed {
+                    agent_obj.insert("attribution_ambiguous".to_string(), serde_json::json!(true));
+                    agent_obj.insert(
+                        "capture_state".to_string(),
+                        serde_json::json!("attribution_ambiguous"),
+                    );
+                    // 0.4.6 tuple-atomic contract: see comment above. Removed
+                    // `captured_at` ambiguity write.
+                    report.changed = true;
+                }
             }
             continue;
         }
@@ -662,6 +685,9 @@ fn pending_session_capture<F>(
 where
     F: FnMut(Provider) -> Box<dyn ProviderAdapter>,
 {
+    if agent.get("capture_state").and_then(Value::as_str) == Some("attribution_ambiguous") {
+        return None;
+    }
     let provider = incomplete_resumable_provider(agent, adapter_for)?;
     let spawn_cwd = agent
         .get("spawn_cwd")
@@ -676,6 +702,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 +736,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 +1173,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 +1188,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 +1227,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 +2656,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 \