@team-agent/installer 0.5.57 → 0.5.59

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.57"
+version = "0.5.59"
 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.57"
+version = "0.5.59"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/emit.rs

@@ -3,7 +3,7 @@
 
 use super::spec::{command_spec, CommandKind, CommandTier, ALL_DISPATCH_KINDS, COMMAND_SPECS};
 use super::*;
-use std::io::Write as _;
+use std::io::{ErrorKind, Write as _};
 
 /// `emit`(`helpers.py:12-23`):`--json`→`json.dumps(indent=2, ensure_ascii=False, sort_keys=True)`;
 /// 否则 dict 逐键 `key: value`(嵌套 dict/list 内联 compact json,`ensure_ascii=False`)、非 dict 直接 print。
@@ -77,12 +77,40 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
 /// Print a handler's CmdResult to stdout (emit formats json/human), then surface its exit code.
 /// (parser.py: `print(emit(result, as_json))` then the ok→exit mapping.)
 fn emit_result(r: CmdResult) -> ExitCode {
+    let persisted_message_id = match &r.output {
+        CmdOutput::Json(value) => value
+            .get("message_id")
+            .and_then(Value::as_str)
+            .map(ToString::to_string),
+        _ => None,
+    };
     if let Some(text) = emit(&r.output, r.as_json) {
-        println!("{text}");
+        if let Err(error) = write_stdout_line(&text) {
+            if let Some(message_id) = persisted_message_id {
+                let stderr = std::io::stderr();
+                let mut stderr = stderr.lock();
+                let _ = writeln!(
+                    stderr,
+                    "stdout unavailable after durable send; persisted_message_id={message_id}"
+                );
+            }
+            return if error.kind() == ErrorKind::BrokenPipe {
+                r.exit
+            } else {
+                ExitCode::Error
+            };
+        }
     }
     r.exit
 }
 
+fn write_stdout_line(text: &str) -> std::io::Result<()> {
+    let stdout = std::io::stdout();
+    let mut stdout = stdout.lock();
+    stdout.write_all(text.as_bytes())?;
+    stdout.write_all(b"\n")
+}
+
 fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliError> {
     let Some(spec) = command_spec(command) else {
         return Ok(emit_unknown_subcommand_usage(command));

package/crates/team-agent/src/cli/mod.rs

@@ -2484,6 +2484,7 @@ pub mod lifecycle_port {
                 "new_agent_id": report.new_agent_id.as_str(),
                 "session_id": report.session_id.as_ref().map(|session| session.as_str()),
                 "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                "backing_state": report.backing_state,
             })),
             Err(e) => Ok(error_value(e)),
         }

package/crates/team-agent/src/cli/send/mailbox.rs

@@ -37,8 +37,8 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
         Ok(s) => s,
         Err(_) => return Ok(None),
     };
-    let team_alive = target_team_is_alive_for_mailbox(&state, &team_key);
-    if !team_alive {
+    let attachment_history = target_team_mailbox_history(&state, &team_key);
+    if attachment_history == MailboxAttachmentHistory::NotEligible {
         return Ok(None);
     }
     let event_log = crate::event_log::EventLog::new(&target_workspace);
@@ -53,47 +53,90 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
     )
     .map_err(|e| CliError::Runtime(e.to_string()))?;
     let message_id = outcome.message_id.clone().unwrap_or_else(|| "".to_string());
-    Ok(Some(json!({
-        "ok": true,
-        "status": "queued_until_leader_attach",
-        "message_status": "queued_until_leader_attach",
-        "channel": "leader_mailbox",
-        "delivered": false,
-        "to_name": to_name,
-        "target_workspace": target_workspace.display().to_string(),
-        "team_key": team_key,
-        "recipient": "leader",
-        "leader_attached": false,
-        "message_id": message_id,
-    })))
+    let receipt = match attachment_history {
+        MailboxAttachmentHistory::NeverAttached => json!({
+            "ok": true,
+            "status": "deferred",
+            "deferred_reason": "never_attached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::PreviouslyAttached => json!({
+            "ok": true,
+            "status": "queued_until_leader_attach",
+            "deferred_reason": "leader_currently_unattached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::NotEligible => unreachable!("refused before persistence"),
+    };
+    Ok(Some(receipt))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum MailboxAttachmentHistory {
+    PreviouslyAttached,
+    NeverAttached,
+    NotEligible,
 }
 
-/// Positive-source liveness heuristic per offline-mailbox-toname-design.md §4:
+/// Positive-source mailbox eligibility per offline-mailbox-toname-design.md §4:
 /// - target workspace has state and the team key is present + not archived/down;
-/// - AND at least one live tmux fact — a persisted `session_name` OR any
-///   agent with a recorded pane on the recorded socket.
+/// - AND a persisted session name establishes a durable replay target;
+/// - a persisted receiver attachment timestamp distinguishes previously attached
+///   teams from teams whose first successful leader attachment is still pending.
 ///
 /// We deliberately do NOT poll coordinator health here — enqueuing is
 /// safe even when the coordinator is transiently down; attach-leader
 /// itself replays via `requeue_blocked_leader_messages` regardless.
-pub(super) fn target_team_is_alive_for_mailbox(state: &Value, team_key: &str) -> bool {
+fn target_team_mailbox_history(state: &Value, team_key: &str) -> MailboxAttachmentHistory {
     let team = state
         .get("teams")
         .and_then(|v| v.as_object())
         .and_then(|teams| teams.get(team_key));
     let Some(team) = team else {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     };
     let status = team
         .get("status")
         .and_then(|v| v.as_str())
         .unwrap_or("alive");
     if matches!(status, "archived" | "down" | "stopped") {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     }
-    // A recorded session_name is enough — target's coordinator/attach
-    // path will re-verify tmux presence when the replay fires.
-    team.get("session_name")
+    let has_session = team
+        .get("session_name")
         .and_then(|v| v.as_str())
-        .is_some_and(|s| !s.is_empty())
+        .is_some_and(|s| !s.is_empty());
+    if !has_session {
+        return MailboxAttachmentHistory::NotEligible;
+    }
+    let previously_attached = team
+        .get("leader_receiver")
+        .and_then(Value::as_object)
+        .is_some_and(|receiver| {
+            receiver
+                .get("attached_at")
+                .and_then(Value::as_str)
+                .is_some_and(|value| !value.is_empty())
+        });
+    if previously_attached {
+        MailboxAttachmentHistory::PreviouslyAttached
+    } else {
+        MailboxAttachmentHistory::NeverAttached
+    }
 }

package/crates/team-agent/src/cli/spec.rs

@@ -155,7 +155,7 @@ pub(crate) struct CommandSpec {
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for a logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
+    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },

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

@@ -57,66 +57,13 @@ pub fn fork_agent_with_transport(
     let text = std::fs::read_to_string(&read_spec_path)
         .map_err(|e| LifecycleError::Compile(format!("{}: {e}", read_spec_path.display())))?;
     let spec = yaml::loads(&text).map_err(|e| LifecycleError::Compile(e.to_string()))?;
-    if find_spec_agent(&spec, as_agent_id).is_some() || leader_id_matches(&spec, as_agent_id) {
+    if fork_spec_agent(&spec, as_agent_id).is_some() || leader_id_matches(&spec, as_agent_id) {
         return Err(LifecycleError::RequirementUnmet(format!(
             "agent id already exists: {as_agent_id}"
         )));
     }
-    let source_agent = find_spec_agent(&spec, source_agent_id).ok_or_else(|| {
-        LifecycleError::RequirementUnmet(format!("unknown worker agent id: {source_agent_id}"))
-    })?;
-    // Fork requires the complete source tuple before treating session_id as
-    // resumable truth; a scalar-only row has no confirmed backing.
-    let source_agent_state = state
-        .get("agents")
-        .and_then(|v| v.get(source_agent_id.as_str()))
-        .ok_or_else(|| {
-            LifecycleError::Provider(format!(
-                "cannot fork {source_agent_id}: source agent row not in state"
-            ))
-        })?;
-    let tuple_field_ok = |field: &str| -> bool {
-        source_agent_state
-            .get(field)
-            .and_then(|v| v.as_str())
-            .is_some_and(|s| !s.is_empty())
-    };
-    let session_id_str = source_agent_state
-        .get("session_id")
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty());
-    let rollout_path_str = source_agent_state
-        .get("rollout_path")
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty());
-    if session_id_str.is_none()
-        || rollout_path_str.is_none()
-        || !tuple_field_ok("captured_at")
-        || !tuple_field_ok("captured_via")
-    {
-        return Err(LifecycleError::Provider(format!(
-            "cannot fork {source_agent_id}: source session backing is missing or incomplete \
-             (session_id+rollout_path+captured_at+captured_via required)"
-        )));
-    }
-    let Some(source_backing_raw) = rollout_path_str else {
-        return Err(LifecycleError::Provider(format!(
-            "cannot fork {source_agent_id}: source session backing is missing"
-        )));
-    };
-    let source_backing = Path::new(source_backing_raw);
-    if !source_backing.is_file() {
-        return Err(LifecycleError::Provider(format!(
-            "cannot fork {source_agent_id}: source session backing is not readable: {}",
-            source_backing.display()
-        )));
-    }
-    let Some(source_session_id) = session_id_str else {
-        return Err(LifecycleError::Provider(format!(
-            "cannot fork {source_agent_id}: source session id is missing"
-        )));
-    };
-    let session_id = crate::provider::SessionId::new(source_session_id.to_string());
+    // Source existence authority: state.get("agents"), matching clone-agent.
+    let (session_id, source_backing) = fork_source_tuple(&state, source_agent_id)?;
     let session_name = state
         .get("session_name")
         .and_then(|v| v.as_str())
@@ -158,7 +105,7 @@ pub fn fork_agent_with_transport(
     crate::model::spec::validate_spec(&new_spec, &validate_ws)
         .map_err(|e| LifecycleError::Compile(e.to_string()))?;
     write_spec_atomic(&spec_path, &new_spec)?;
-    let new_agent = find_spec_agent(&new_spec, as_agent_id).ok_or_else(|| {
+    let new_agent = fork_spec_agent(&new_spec, as_agent_id).ok_or_else(|| {
         LifecycleError::RequirementUnmet(format!("unknown worker agent id: {as_agent_id}"))
     })?;
     let provider = new_agent
@@ -296,13 +243,21 @@ pub fn fork_agent_with_transport(
         plan.provider_projects_root = source_backing.parent().map(Path::to_path_buf);
     }
     let window = WindowName::new(as_agent_id.as_str());
+    let mut claude_fork = prepare_claude_fork_backing(
+        provider,
+        &plan,
+        &source_backing,
+        &session_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
+    })?;
+    // 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.
     let backing_before = crate::provider::session::ContextBackingSnapshot::capture(provider, &plan);
-    let mut claude_fork = prepare_claude_fork_backing(provider, &plan, source_backing, &session_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
-        })?;
     let mut env =
         inherited_env_with_team_overrides(&workspace, as_agent_id.as_str(), Some(&fork_team));
     apply_profile_launch_env(&mut env, &profile_launch);
@@ -401,7 +356,7 @@ pub fn fork_agent_with_transport(
     })?;
     let convergence_deadline =
         crate::provider::session::context_fork_convergence_deadline(provider);
-    let context_proof = match crate::provider::session::verify_context_fork(
+    let context_outcome = crate::provider::session::observe_context_fork(
         provider,
         &session_id,
         &plan,
@@ -411,9 +366,40 @@ pub fn fork_agent_with_transport(
         &workspace,
         &spawned_at,
         convergence_deadline,
-    ) {
-        Ok(proof) => proof,
-        Err(error) => {
+    );
+    let context_proof = match context_outcome {
+        crate::provider::session::ContextForkOutcome::Verified(proof) => Some(proof),
+        crate::provider::session::ContextForkOutcome::Pending(pending) => {
+            if let Err(error) = finalize_pending_fork_state(ForkPendingFinalizeInput {
+                workspace: &workspace,
+                team_key: &fork_team,
+                source_agent_id,
+                agent_id: as_agent_id,
+                spec_agent: new_agent,
+                safety: &safety,
+                plan: &plan,
+                profile_launch: &profile_launch,
+                spawn: &spawn,
+                profile_dir: &profile_dir,
+                dynamic_role_file: materialized_role.path(),
+                pending: &pending,
+                spawn_epoch,
+            }) {
+                rollback_fork_after_spawn(
+                    &workspace,
+                    transport,
+                    &session_name,
+                    &window,
+                    &mcp_config_path,
+                    as_agent_id,
+                    &profile_launch,
+                    &fork_team,
+                );
+                return Err(error);
+            }
+            None
+        }
+        crate::provider::session::ContextForkOutcome::Rejected(error) => {
             rollback_fork_after_spawn(
                 &workspace,
                 transport,
@@ -427,33 +413,35 @@ pub fn fork_agent_with_transport(
             return Err(LifecycleError::Provider(error.to_string()));
         }
     };
-    if let Err(error) = finalize_fork_state(ForkFinalizeInput {
-        workspace: &workspace,
-        team_key: &fork_team,
-        source_agent_id,
-        agent_id: as_agent_id,
-        spec_agent: new_agent,
-        safety: &safety,
-        plan: &plan,
-        profile_launch: &profile_launch,
-        spawn: &spawn,
-        profile_dir: &profile_dir,
-        dynamic_role_file: materialized_role.path(),
-        context_proof: &context_proof,
-        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 Some(context_proof) = context_proof.as_ref() {
+        if let Err(error) = finalize_fork_state(ForkFinalizeInput {
+            workspace: &workspace,
+            team_key: &fork_team,
+            source_agent_id,
+            agent_id: as_agent_id,
+            spec_agent: new_agent,
+            safety: &safety,
+            plan: &plan,
+            profile_launch: &profile_launch,
+            spawn: &spawn,
+            profile_dir: &profile_dir,
+            dynamic_role_file: materialized_role.path(),
+            context_proof: &context_proof,
+            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)
@@ -487,6 +475,11 @@ pub fn fork_agent_with_transport(
     if let Some(materialized) = copilot_fork.as_mut() {
         materialized.keep();
     }
+    let backing_state = if context_proof.is_some() {
+        ForkBackingState::Verified
+    } else {
+        ForkBackingState::PendingContextFork
+    };
     Ok(ForkAgentReport {
         source_agent_id: source_agent_id.clone(),
         new_agent_id: as_agent_id.clone(),
@@ -495,6 +488,7 @@ pub fn fork_agent_with_transport(
             state_file: crate::state::persist::runtime_state_path(&workspace),
             coordinator_started,
         },
-        session_id: Some(context_proof.new_session_id),
+        session_id: context_proof.map(|proof| proof.new_session_id),
+        backing_state,
     })
 }

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

@@ -172,6 +172,110 @@ pub(super) fn finalize_fork_state(input: ForkFinalizeInput<'_>) -> Result<(), Li
         .map_err(|error| LifecycleError::StatePersist(error.to_string()))
 }
 
+pub(super) struct ForkPendingFinalizeInput<'a> {
+    pub workspace: &'a Path,
+    pub team_key: &'a str,
+    pub source_agent_id: &'a AgentId,
+    pub agent_id: &'a AgentId,
+    pub spec_agent: &'a Value,
+    pub safety: &'a DangerousApproval,
+    pub plan: &'a crate::provider::CommandPlan,
+    pub profile_launch: &'a crate::provider::ProviderProfileLaunch,
+    pub spawn: &'a crate::transport::SpawnResult,
+    pub profile_dir: &'a Path,
+    pub dynamic_role_file: &'a Path,
+    pub pending: &'a crate::provider::session::PendingContextFork,
+    pub spawn_epoch: u64,
+}
+
+pub(super) fn finalize_pending_fork_state(
+    input: ForkPendingFinalizeInput<'_>,
+) -> Result<(), LifecycleError> {
+    let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
+        workspace: input.workspace,
+        operation: "fork-agent-pending",
+        team: Some(input.team_key),
+        agent_id: Some(input.agent_id),
+    })?;
+    let mut next_state = crate::state::selector::resolve_active_team(
+        input.workspace,
+        Some(input.team_key),
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|error| LifecycleError::TeamSelect(error.to_string()))?
+    .state;
+    upsert_pending_forked_agent_state(
+        &mut next_state,
+        input.source_agent_id,
+        input.agent_id,
+        input.spec_agent,
+        input.safety,
+        input.plan,
+        input.profile_launch,
+        input.spawn,
+        Some(input.profile_dir),
+        input.dynamic_role_file,
+        input.pending,
+        input.spawn_epoch,
+    )?;
+    maybe_fail_fork_after_spawn("save_runtime_state")?;
+    crate::state::repository::StateRepository::new(input.workspace)
+        .save(
+            crate::state::repository::StateWriteIntent::ForkAgent {
+                team_key: input.team_key,
+                agent_id: input.agent_id.as_str(),
+            },
+            &next_state,
+        )
+        .map_err(|error| LifecycleError::StatePersist(error.to_string()))
+}
+
+pub(crate) fn finalize_pending_fork_capture(
+    agent: &mut serde_json::Map<String, serde_json::Value>,
+    captured: &crate::provider::CapturedSession,
+) -> bool {
+    let Some(session_id) = captured.session_id.as_ref() else {
+        return false;
+    };
+    let Some(rollout_path) = captured.rollout_path.as_ref() else {
+        return false;
+    };
+    if agent
+        .get("fork_source_session_id")
+        .and_then(serde_json::Value::as_str)
+        == Some(session_id.as_str())
+    {
+        return false;
+    }
+    agent.insert(
+        "session_id".to_string(),
+        serde_json::json!(session_id.as_str()),
+    );
+    agent.insert(
+        "rollout_path".to_string(),
+        serde_json::json!(rollout_path.as_path().to_string_lossy()),
+    );
+    agent.insert(
+        "captured_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
+    agent.insert(
+        "captured_via".to_string(),
+        serde_json::to_value(captured.captured_via).unwrap_or(serde_json::Value::Null),
+    );
+    agent.insert(
+        "attribution_confidence".to_string(),
+        serde_json::to_value(captured.attribution_confidence).unwrap_or(serde_json::Value::Null),
+    );
+    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
+}
+
 pub(super) fn verify_fork_registration(
     workspace: &Path,
     team_key: &str,