@team-agent/installer 0.5.59 → 0.5.61

package/crates/team-agent/src/leader/tests/identity.rs

@@ -130,7 +130,7 @@ fn leader_start_plan_external_leader_keeps_exec_provider_in_tmux() {
     std::fs::create_dir_all(&ws).unwrap();
 
     let provider_args = vec!["--".to_string(), "--model".to_string(), "opus".to_string()];
-    let plan = leader_start_plan(
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
         Provider::Fake,
         &provider_args,
         &ws,
@@ -202,7 +202,7 @@ fn managed_leader_uses_dedicated_leader_session_independent_of_state_session_nam
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_runs_provider_in_current_pane() {
+fn in_tmux_default_leader_uses_managed_client_and_external_opt_out_keeps_exec_provider() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_switch_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
@@ -210,26 +210,65 @@ fn in_tmux_default_leader_runs_provider_in_current_pane() {
     let endpoint = format!("/private/tmp/tmux-501/{socket},88432,187");
     let _e = EnvGuard::apply(&[("TMUX", Some(&endpoint)), ("TMUX_PANE", Some("%7"))]);
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let managed = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        false,
+    )
+    .unwrap();
 
-    assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
-    assert_eq!(plan.leader_window, None);
-    assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(
+        managed.mode,
+        LeaderStartMode::ManagedTmuxClient,
+        "N41 managed default: an in-tmux caller on the workspace server must use the managed client path"
+    );
+    assert!(!managed.is_external_leader);
+    assert!(managed.session_name.is_some());
+    assert_eq!(
+        managed.leader_window.as_ref().map(WindowName::as_str),
+        Some("fake")
+    );
     assert!(
-        !plan
+        managed.argv.iter().any(|arg| arg == "switch-client")
+            && !managed.argv.iter().any(|arg| arg == "attach-session"),
+        "N41 managed default: same-server dispatch must switch the existing client, not nested-attach: {:?}",
+        managed.argv
+    );
+    assert_eq!(managed.provider_argv, vec!["fake".to_string()]);
+
+    let external = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
+
+    assert_eq!(external.mode, LeaderStartMode::ExecProvider);
+    assert!(external.is_external_leader);
+    assert_eq!(external.leader_window, None);
+    assert_eq!(external.argv, vec!["fake".to_string()]);
+    assert_eq!(external.provider_argv, vec!["fake".to_string()]);
+    assert!(
+        !external
             .argv
             .iter()
             .any(|arg| arg == "switch-client" || arg == "attach-session"),
-        "in-tmux default launch must not create or attach a background leader session: {:?}",
-        plan.argv
+        "N41 external opt-out: explicit external topology must remain a direct provider path: {:?}",
+        external.argv
     );
 }
 
 #[test]
 #[serial_test::serial(env)]
-fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
+fn in_tmux_external_opt_out_keeps_exec_provider_across_server_boundary() {
     let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
     let _e = EnvGuard::apply(&[
         ("TMUX", Some("/private/tmp/tmux-501/default,88432,187")),
@@ -238,12 +277,21 @@ fn in_tmux_default_leader_does_not_refuse_different_tmux_server() {
     let ws = std::env::temp_dir().join(format!("ta_rs_lsp_refuse_{}", std::process::id()));
     std::fs::create_dir_all(&ws).unwrap();
 
-    let plan = leader_start_plan(Provider::Fake, &[], &ws, false, false, None, false).unwrap();
+    let plan = crate::leader::start::leader_start_plan_after_ambient_authority_check(
+        Provider::Fake,
+        &[],
+        &ws,
+        false,
+        false,
+        None,
+        true,
+    )
+    .unwrap();
 
     assert_eq!(plan.mode, LeaderStartMode::ExecProvider);
-    assert!(!plan.is_external_leader);
-    assert!(plan.session_name.is_none());
+    assert!(plan.is_external_leader);
     assert_eq!(plan.argv, vec!["fake".to_string()]);
+    assert_eq!(plan.provider_argv, vec!["fake".to_string()]);
 }
 
 #[test]
@@ -420,45 +468,4 @@ fn p2_leader_detect_divergence_catches_owner_uuid_split() {
 // refactor must also update these tests.
 // ═══════════════════════════════════════════════════════════════════════
 
-#[test]
-fn unit0_leader_session_prefix_constant_is_stable() {
-    // Pinned: the literal leader session prefix that gates "is this a
-    // leader session" decisions everywhere in the runtime.
-    assert_eq!(
-        crate::leader::start::LEADER_SESSION_PREFIX,
-        "team-agent-leader-"
-    );
-    // The layout module re-exports the same value (kept in sync via
-    // const re-export).
-    assert_eq!(
-        crate::layout::sessions::LEADER_SESSION_PREFIX,
-        crate::leader::start::LEADER_SESSION_PREFIX
-    );
-}
-
-#[test]
-fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
-    // Pinned invariant fed into unit-1 typed identity: any session
-    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
-    // session, never a worker session. unit-1 will wrap this rule in
-    // typed constructors (`WorkerSession::new` rejects the prefix,
-    // `LeaderLauncherSession::new` requires it).
-    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
-    let worker = "team-real-worker";
-    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
-    assert!(leader.starts_with(prefix));
-    assert!(!worker.starts_with(prefix));
-    // Symmetry: the runtime today uses this exact check
-    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
-    // leader sessions during shutdown.
-    let leader_name = crate::transport::SessionName::new(leader);
-    let worker_name = crate::transport::SessionName::new(worker);
-    assert!(
-        crate::layout::sessions::is_leader_session(&leader_name),
-        "is_leader_session must accept a leader-prefixed session",
-    );
-    assert!(
-        !crate::layout::sessions::is_leader_session(&worker_name),
-        "is_leader_session must reject a non-prefixed session",
-    );
-}
+include!("identity_session_names.rs");

package/crates/team-agent/src/leader/tests/identity_session_names.rs

@@ -0,0 +1,42 @@
+#[test]
+fn unit0_leader_session_prefix_constant_is_stable() {
+    // Pinned: the literal leader session prefix that gates "is this a
+    // leader session" decisions everywhere in the runtime.
+    assert_eq!(
+        crate::leader::start::LEADER_SESSION_PREFIX,
+        "team-agent-leader-"
+    );
+    // The layout module re-exports the same value (kept in sync via
+    // const re-export).
+    assert_eq!(
+        crate::layout::sessions::LEADER_SESSION_PREFIX,
+        crate::leader::start::LEADER_SESSION_PREFIX
+    );
+}
+
+#[test]
+fn unit0_leader_prefixed_name_must_never_be_taken_as_worker_session() {
+    // Pinned invariant fed into unit-1 typed identity: any session
+    // name starting with `LEADER_SESSION_PREFIX` is a leader launcher
+    // session, never a worker session. unit-1 will wrap this rule in
+    // typed constructors (`WorkerSession::new` rejects the prefix,
+    // `LeaderLauncherSession::new` requires it).
+    let leader = "team-agent-leader-claude-x-aaaaaaaaaaaa";
+    let worker = "team-real-worker";
+    let prefix = crate::leader::start::LEADER_SESSION_PREFIX;
+    assert!(leader.starts_with(prefix));
+    assert!(!worker.starts_with(prefix));
+    // Symmetry: the runtime today uses this exact check
+    // (cli/mod.rs:261 `starts_with(LEADER_SESSION_PREFIX)`) to spare
+    // leader sessions during shutdown.
+    let leader_name = crate::transport::SessionName::new(leader);
+    let worker_name = crate::transport::SessionName::new(worker);
+    assert!(
+        crate::layout::sessions::is_leader_session(&leader_name),
+        "is_leader_session must accept a leader-prefixed session",
+    );
+    assert!(
+        !crate::layout::sessions::is_leader_session(&worker_name),
+        "is_leader_session must reject a non-prefixed session",
+    );
+}

package/crates/team-agent/src/lib.rs

@@ -50,6 +50,10 @@ pub mod state;
 // step 6 (compiler) — TEAM.md + agents/*.md → 规范 team.spec dict(doc→spec 纯变换)。
 pub mod compiler;
 
+// Official communication-mode catalog. Configuration compilation and every
+// future projection consumer must use this typed single source of truth.
+pub mod communication_mode;
+
 // step 7 (message_store) — team.db 上的核心消息生命周期(create/claim/mark/通知去重)。
 // unit-10 (Stage 4) compat shim. Physical home is now `crate::db::message_store`.
 pub use crate::db::message_store;

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,
@@ -135,7 +126,7 @@ pub fn fork_agent_with_transport(
         new_agent,
         Some(as_agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(
@@ -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()),