@team-agent/installer 0.5.58 → 0.5.60

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/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/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)]
@@ -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 \