@team-agent/installer 0.5.3 → 0.5.5

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

@@ -90,9 +90,12 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     {
         return Ok(CmdResult::from_json(amb, args.json));
     }
-    let outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
-    let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    let mut outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
     if opts.watch_result {
+        outcome = observe_initial_delivery_for_watch(&selected, &target, &outcome, &opts)?;
+    }
+    let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    if opts.watch_result && initial_delivery_allows_watch(outcome.status) {
         if let Some(obj) = value.as_object_mut() {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
         }
@@ -575,6 +578,48 @@ fn primary_delivery_succeeded(status: DeliveryStatus) -> bool {
     )
 }
 
+fn initial_delivery_allows_watch(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
+    )
+}
+
+fn observe_initial_delivery_for_watch(
+    selected: &crate::state::selector::SelectedTeam,
+    target: &MessageTarget,
+    outcome: &DeliveryOutcome,
+    opts: &SendOptions,
+) -> Result<DeliveryOutcome, CliError> {
+    if !matches!(target, MessageTarget::Single(agent) if !agent.is_empty()) {
+        return Ok(outcome.clone());
+    }
+    if !matches!(outcome.status, DeliveryStatus::Queued) {
+        return Ok(outcome.clone());
+    }
+    let Some(message_id) = outcome.message_id.as_deref() else {
+        return Ok(outcome.clone());
+    };
+    let store = crate::message_store::MessageStore::open(&selected.run_workspace)
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let transport = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+        &selected.run_workspace,
+        opts.team.as_ref().map(TeamKey::as_str),
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
+    let state = selected_state_with_active_key(selected);
+    crate::messaging::delivery::deliver_pending_message(
+        &selected.run_workspace,
+        &store,
+        &transport,
+        message_id,
+        &event_log,
+        &state,
+    )
+    .map_err(CliError::from)
+}
+
 fn is_business_reject_text(error: &str) -> bool {
     let lower = error.to_ascii_lowercase();
     [
@@ -668,6 +713,8 @@ fn delivery_outcome_json(
     json!({
         "ok": outcome.ok,
         "status": delivery_status_wire(outcome.status),
+        "delivery_status": api_delivery_status(outcome),
+        "delivered": delivery_proven(outcome.status),
         "target": target_wire,
         "agent_id": first_target(target),
         "content_length_bytes": content.len(),
@@ -681,6 +728,26 @@ fn delivery_outcome_json(
     })
 }
 
+fn api_delivery_status(outcome: &DeliveryOutcome) -> &'static str {
+    if delivery_proven(outcome.status) {
+        return "delivered";
+    }
+    if matches!(outcome.status, DeliveryStatus::Queued) && outcome.message_status.0 == "accepted" {
+        return "pending";
+    }
+    delivery_status_wire(outcome.status)
+}
+
+fn delivery_proven(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered
+            | DeliveryStatus::AlreadyDelivered
+            | DeliveryStatus::BroadcastDelivered
+            | DeliveryStatus::FanoutDelivered
+    )
+}
+
 fn add_send_reminder_if_ok(value: &mut Value) {
     if value.get("ok").and_then(Value::as_bool) != Some(true) {
         return;

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

@@ -99,6 +99,7 @@ use rusqlite::params;
             "tasks": tasks,
             "messages": message_counts(&conn, owner_team_id)?,
             "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
+            "pending_leader_notifications": pending_leader_notifications(&conn, owner_team_id, 8)?,
             "results": result_counts(&conn, owner_team_id)?,
             "latest_results": latest_result_summaries(&store, owner_team_id)?,
             "readiness": readiness,
@@ -639,6 +640,67 @@ use rusqlite::params;
         Ok(Value::Array(values))
     }
 
+    /// 0.5.5 gate054 round-2: leader notifications that were refused with
+    /// `rebind_required` (status=failed, error=leader_not_attached) sit as
+    /// failed rows in the store; without a dedicated status field the
+    /// operator sees only `messages.failed=N` and cannot tell that the
+    /// notifications are waiting for a rebind. This field surfaces them
+    /// alongside `queued_messages` so `attach-leader` / `takeover` is
+    /// visibly the fix. Once the pane is rebound the requeue path flips
+    /// each row back to `status=accepted` and it drops out of this list.
+    fn pending_leader_notifications(
+        conn: &rusqlite::Connection,
+        owner_team_id: Option<&str>,
+        limit: usize,
+    ) -> Result<Value, CliError> {
+        let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select message_id, sender, status, error, created_at, delivery_attempts
+                 from messages
+                 where recipient = 'leader'
+                   and status = 'failed'
+                   and error = 'leader_not_attached'
+                   and owner_team_id = ?1
+                 order by created_at desc
+                 limit ?2"
+            }
+            None => {
+                "select message_id, sender, status, error, created_at, delivery_attempts
+                 from messages
+                 where recipient = 'leader'
+                   and status = 'failed'
+                   and error = 'leader_not_attached'
+                 order by created_at desc
+                 limit ?1"
+            }
+        };
+        let mut stmt = conn
+            .prepare(sql)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let map_row = |row: &rusqlite::Row<'_>| {
+            Ok(json!({
+                "message_id": row.get::<_, String>(0)?,
+                "sender": row.get::<_, Option<String>>(1)?,
+                "status": row.get::<_, String>(2)?,
+                "error": row.get::<_, Option<String>>(3)?,
+                "created_at": row.get::<_, Option<String>>(4)?,
+                "delivery_attempts": row.get::<_, i64>(5)?,
+                "channel": "rebind_required",
+                "action": "run team-agent attach-leader or team-agent takeover",
+            }))
+        };
+        let rows = match owner_team_id {
+            Some(team) => stmt.query_map(params![team, limit], map_row),
+            None => stmt.query_map(params![limit], map_row),
+        }
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let values = rows
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        Ok(Value::Array(values))
+    }
+
     /// 0.4.x: slim default compact payload — exactly 7 top-level fields.
     /// Diagnostic detail moves to `--detail`. Plan:
     /// /Users/alauda/Documents/code/team-agent-public/.team/artifacts/status-compact-plan.md

package/crates/team-agent/src/cli/tests/status_send.rs

@@ -511,33 +511,26 @@ use super::*;
     }
 
     #[test]
-    fn cmd_send_watch_result_surfaces_registered_notice() {
-        // gate CRITICAL: --watch-result -> SendOptions.watch_result=true -> send_message attaches
-        // result['watch']={status:'registered', watcher_id, task_id, agent_id, notice}
-        // (send.py:322-337). That dict MUST survive verbatim into CmdResult Json output.
+    fn cmd_send_watch_result_does_not_register_before_delivery() {
+        // 0.5.x send contract: --watch-result may only advertise a watcher after
+        // initial worker delivery is physically proven.
         let r = cmd_send(&send_args_fixture()).expect("cmd_send returns CmdResult");
         let v = match r.output {
             CmdOutput::Json(v) => v,
             other => panic!("expected Json, got {other:?}"),
         };
-        let watch = v
-            .get("watch")
-            .expect("watch_result:true MUST attach result['watch'] (send.py:326)");
-        assert_eq!(
-            watch.get("status").and_then(|s| s.as_str()),
-            Some("registered"),
-            "registered-watcher notice status must be exactly 'registered'"
+        assert!(
+            v.get("delivery_status").and_then(|s| s.as_str()).is_some(),
+            "send output must expose delivery_status; got {v}"
         );
-        assert!(watch.get("watcher_id").is_some(), "watch notice carries watcher_id");
         assert_eq!(
-            watch.get("agent_id").and_then(|s| s.as_str()),
-            Some("alice"),
-            "watch notice agent_id == the send target"
+            v.get("delivered").and_then(|s| s.as_bool()),
+            Some(false),
+            "undelivered send outcome must not look delivered"
         );
-        // non-queued notice golden bytes (send.py:335):
-        assert_eq!(
-            watch.get("notice").and_then(|s| s.as_str()),
-            Some("Team Agent will collect the result and notify the leader when this task reports completion.")
+        assert!(
+            !v.as_object().unwrap().contains_key("watch"),
+            "watch_result:true must not attach result['watch'] before delivery; got {v}"
         );
     }
 

package/crates/team-agent/src/coordinator/tick.rs

@@ -553,6 +553,19 @@ impl Coordinator {
                 }),
             )?;
         }
+        for mismatch in &report.identity_mismatches {
+            event_log.write(
+                "provider.session.identity_mismatch",
+                serde_json::json!({
+                    "agent_id": mismatch.agent_id,
+                    "expected_agent_id": mismatch.expected_agent_id,
+                    "embedded_agent_id": mismatch.embedded_agent_id,
+                    "session_id": mismatch.session_id,
+                    "rollout_path": mismatch.rollout_path,
+                    "spawn_cwd": mismatch.spawn_cwd,
+                }),
+            )?;
+        }
         for ambiguous in report.ambiguous {
             let candidate_count = report
                 .candidate_count_by_agent

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

@@ -374,6 +374,8 @@ fn spawn_agents(
                 );
             }
         }
+        let spawn_epoch = u64::try_from(started.len()).unwrap_or(u64::MAX);
+        let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
         // E6 层1 实证3 + 诊断留痕:落最终 worker argv(spawn 前的真实形态)。
         // 任何"--session-id 预定 UUID 没生效"必须能从 events.jsonl 回答:argv 里到底有没有它。
         // 抽出 --session-id 值单列,方便和盘上 ~/.claude/projects/<cwd> 实际落的 UUID 对账。
@@ -393,6 +395,10 @@ fn spawn_agents(
                     "argv": plan.argv,
                     "session_id_in_argv": session_id_in_argv,
                     "expected_session_id": plan.expected_session_id.as_ref().map(|s| s.as_str()),
+                    "spawn_cwd": workspace.to_string_lossy(),
+                    "spawned_at": spawned_at.as_str(),
+                    "source": "launch",
+                    "spawn_epoch": spawn_epoch,
                 }),
             );
         }
@@ -473,6 +479,7 @@ fn spawn_agents(
             agent_id,
             start_mode: StartMode::Fresh,
             target: spawn.pane_id.as_str().to_string(),
+            spawned_at,
             session_id: None,
             rollout_path: None,
             pending_session_id: plan.expected_session_id.clone(),
@@ -872,7 +879,9 @@ fn persist_spawn_agent_state(
             continue;
         }
         let pane_pid = pane_pids_by_agent.get(id).copied();
-        let spawned_at = spawn_timestamp_for_agent(spawn_index);
+        let spawned_at = started_agent
+            .map(|started| started.spawned_at.clone())
+            .unwrap_or_else(|| spawn_timestamp_for_agent(spawn_index));
         spawn_index = spawn_index.saturating_add(1);
         agents.insert(
             id.to_string(),
@@ -2970,11 +2979,10 @@ pub fn quick_start_in_workspace_with_display_and_backend(
     // `state.transport.shim.pipe_ready = true` marker so its
     // `conpty_pipe_ready` gate opens.
     #[cfg(windows)]
-    let state_value = std::fs::read_to_string(crate::state::persist::runtime_state_path(
-        &workspace,
-    ))
-    .ok()
-    .and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok());
+    let state_value =
+        std::fs::read_to_string(crate::state::persist::runtime_state_path(&workspace))
+            .ok()
+            .and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok());
     #[cfg(windows)]
     let input = match state_value.as_ref() {
         Some(v) => input.with_state(Some(v)),

package/crates/team-agent/src/lifecycle/restart/agent.rs

@@ -143,6 +143,7 @@ pub(crate) fn start_agent_at_paths(
         if let Ok(spec) = load_team_spec(spec_workspace) {
             write_team_state(spec_workspace, &spec, &state)?;
         }
+        replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
         let coordinator_started = start_coordinator_for_workspace(workspace)?;
         let target = format!("{}:{window}", session_name.as_str());
         write_start_agent_noop_event(workspace, agent_id, &target, coordinator_started)?;
@@ -256,7 +257,21 @@ pub(crate) fn start_agent_at_paths(
     // after spawn" race with coordinator and no double source of truth.
     crate::lifecycle::launch::annotate_runtime_tmux_endpoint(&mut state, transport, workspace);
     let team_key = restart_projection_team_key(&state, team);
-    save_restart_projected_state(workspace, &mut state, &team_key, &[agent_id.as_str()])?;
+    let skip_capture_backfill = if matches!(
+        start_mode,
+        StartMode::Fresh | StartMode::FreshAfterMissingRollout
+    ) {
+        vec![agent_id.as_str()]
+    } else {
+        Vec::new()
+    };
+    save_restart_projected_state_with_capture_backfill_skip(
+        workspace,
+        &mut state,
+        &team_key,
+        &skip_capture_backfill,
+        &[agent_id.as_str()],
+    )?;
     write_start_agent_start_event(
         workspace,
         agent_id,
@@ -268,6 +283,7 @@ pub(crate) fn start_agent_at_paths(
         spawn_session_id,
         tmux_start_mode_for_spawn(&spawn, into_existing_session),
     )?;
+    replay_worker_target_missing_messages(workspace, agent_id, &team_key, &state, transport)?;
     let coordinator_started = start_coordinator_for_workspace(workspace)?;
     Ok(StartAgentOutcome::Running {
         env: AgentActionEnvelope {
@@ -283,6 +299,33 @@ pub(crate) fn start_agent_at_paths(
     })
 }
 
+fn replay_worker_target_missing_messages(
+    workspace: &Path,
+    agent_id: &AgentId,
+    team_key: &str,
+    state: &serde_json::Value,
+    transport: &dyn crate::transport::Transport,
+) -> Result<(), LifecycleError> {
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(workspace);
+    let ids = crate::messaging::delivery::requeue_worker_target_missing_messages(
+        workspace,
+        &store,
+        &event_log,
+        agent_id.as_str(),
+        Some(team_key),
+    )
+    .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if !ids.is_empty() {
+        crate::messaging::delivery::deliver_pending_messages(
+            workspace, state, transport, &event_log,
+        )
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    }
+    Ok(())
+}
+
 fn verify_spawned_pane_matches_target(
     transport: &dyn crate::transport::Transport,
     pane: &crate::transport::PaneId,

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -507,7 +507,10 @@ pub(crate) fn lifecycle_worker_tmux_backend_for_selected_state(
     // are expected to migrate to `lifecycle_worker_transport_for_selected_state`
     // during Batch 2/3.
     if let Some(state_ref) = state.as_ref() {
-        if let Some(kind) = state_ref.pointer("/transport/kind").and_then(|v| v.as_str()) {
+        if let Some(kind) = state_ref
+            .pointer("/transport/kind")
+            .and_then(|v| v.as_str())
+        {
             if kind.eq_ignore_ascii_case("conpty") {
                 return Err(LifecycleError::TeamSelect(format!(
                     "backend_kind_mismatch: state.transport.kind={kind:?} but the legacy \
@@ -581,11 +584,28 @@ pub(super) fn save_restart_projected_state(
     state: &mut serde_json::Value,
     team_key: &str,
     topology_authority_agent_ids: &[&str],
+) -> Result<(), LifecycleError> {
+    save_restart_projected_state_with_capture_backfill_skip(
+        workspace,
+        state,
+        team_key,
+        &[],
+        topology_authority_agent_ids,
+    )
+}
+
+pub(super) fn save_restart_projected_state_with_capture_backfill_skip(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+    skip_capture_backfill_agent_ids: &[&str],
+    topology_authority_agent_ids: &[&str],
 ) -> Result<(), LifecycleError> {
     sync_restart_team_projections(state, team_key);
-    crate::state::projection::save_team_scoped_state_with_lifecycle_topology_authority(
+    crate::state::projection::save_team_scoped_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
         workspace,
         state,
+        skip_capture_backfill_agent_ids,
         topology_authority_agent_ids,
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))
@@ -739,6 +759,37 @@ pub(super) struct BackingProbeResult {
     pub checked_paths: Vec<PathBuf>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct SessionIdentityProbeResult {
+    pub identity_ok: Option<bool>,
+    pub embedded_agent_id: Option<String>,
+    pub rollout_path: Option<PathBuf>,
+}
+
+pub(crate) fn session_identity_probe_for_agent(
+    agent_id: &AgentId,
+    _provider: Provider,
+    rollout_path: Option<&RolloutPath>,
+) -> SessionIdentityProbeResult {
+    let Some(path) = rollout_path.map(RolloutPath::as_path) else {
+        return SessionIdentityProbeResult {
+            identity_ok: None,
+            embedded_agent_id: None,
+            rollout_path: None,
+        };
+    };
+    let embedded_agent_id =
+        crate::provider::session_scan::common::rollout_path_embedded_team_agent_worker_id(path);
+    let identity_ok = embedded_agent_id
+        .as_deref()
+        .map(|embedded| embedded == agent_id.as_str());
+    SessionIdentityProbeResult {
+        identity_ok,
+        embedded_agent_id,
+        rollout_path: Some(path.to_path_buf()),
+    }
+}
+
 pub(super) fn resume_backing_probe_for_agent(
     workspace: &Path,
     agent_id: &AgentId,

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -467,10 +467,21 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             .iter()
             .map(|agent| agent.agent_id.as_str().to_string()),
     );
-    save_restart_state_with_lifecycle_topology_authority(
+    let capture_backfill_skip_agent_ids = successful_agents
+        .iter()
+        .filter(|agent| {
+            matches!(
+                agent.restart_mode,
+                StartMode::Fresh | StartMode::FreshAfterMissingRollout
+            )
+        })
+        .map(|agent| agent.agent_id.as_str().to_string())
+        .collect::<Vec<_>>();
+    save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
         &selected.run_workspace,
         &mut state,
         &selected.team_key,
+        &capture_backfill_skip_agent_ids,
         &topology_authority_agent_ids,
     )?;
     if fatal_resume_failure {
@@ -572,6 +583,11 @@ pub fn restart_with_transport_with_session_convergence_deadline(
                 &session_id,
                 agent_rollout_path(&agent).as_ref(),
             );
+            let identity_probe = session_identity_probe_for_agent(
+                &decision.agent_id,
+                provider,
+                agent_rollout_path(&agent).as_ref(),
+            );
             write_restart_resume_postflight_event(
                 &selected.run_workspace,
                 &decision.agent_id,
@@ -579,11 +595,26 @@ pub fn restart_with_transport_with_session_convergence_deadline(
                 probe.exists,
                 &probe.checked_paths,
                 /* recaptured = */ false,
+                identity_probe.identity_ok,
+                identity_probe.embedded_agent_id.as_deref(),
             )?;
-            if probe.exists {
+            if probe.exists && identity_probe.identity_ok != Some(false) {
                 survivors.push(decision);
                 continue;
             }
+            if identity_probe.identity_ok == Some(false) {
+                let phase = "resume_postflight";
+                let error = "session_identity_mismatch_after_restart".to_string();
+                mark_agent_restart_failed(&mut state, &decision, &error);
+                let _ = write_restart_agent_failed_event(
+                    &selected.run_workspace,
+                    &decision,
+                    phase,
+                    &error,
+                );
+                postflight_failed.push(restart_failed_agent(&decision, phase, error));
+                continue;
+            }
             // 0.4.6 tuple-atomic contract: backing went missing between
             // preflight and post-spawn. Clear the FULL authoritative tuple
             // (including session_id) and persist the old provider id only
@@ -640,6 +671,11 @@ pub fn restart_with_transport_with_session_convergence_deadline(
                 &session_id,
                 agent_rollout_path(&agent_after).as_ref(),
             );
+            let identity_probe_after = session_identity_probe_for_agent(
+                &decision.agent_id,
+                provider,
+                agent_rollout_path(&agent_after).as_ref(),
+            );
             write_restart_resume_postflight_event(
                 &selected.run_workspace,
                 &decision.agent_id,
@@ -647,14 +683,20 @@ pub fn restart_with_transport_with_session_convergence_deadline(
                 probe_after.exists,
                 &probe_after.checked_paths,
                 /* recaptured = */ true,
+                identity_probe_after.identity_ok,
+                identity_probe_after.embedded_agent_id.as_deref(),
             )?;
-            if probe_after.exists {
+            if probe_after.exists && identity_probe_after.identity_ok != Some(false) {
                 survivors.push(decision);
                 continue;
             }
             // Still missing. Demote the agent.
             let phase = "resume_postflight";
-            let error = "session_backing_store_missing_after_restart".to_string();
+            let error = if identity_probe_after.identity_ok == Some(false) {
+                "session_identity_mismatch_after_restart".to_string()
+            } else {
+                "session_backing_store_missing_after_restart".to_string()
+            };
             mark_agent_restart_failed(&mut state, &decision, &error);
             let _ =
                 write_restart_agent_failed_event(&selected.run_workspace, &decision, phase, &error);
@@ -1327,8 +1369,38 @@ fn save_restart_state_with_lifecycle_topology_authority(
     team_key: &str,
     agent_ids: &[String],
 ) -> Result<(), LifecycleError> {
-    let agent_ids = agent_ids.iter().map(String::as_str).collect::<Vec<_>>();
-    save_restart_projected_state(workspace, state, team_key, &agent_ids)
+    save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+        workspace,
+        state,
+        team_key,
+        &[],
+        agent_ids,
+    )
+}
+
+fn save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+    workspace: &Path,
+    state: &mut serde_json::Value,
+    team_key: &str,
+    skip_capture_backfill_agent_ids: &[String],
+    topology_agent_ids: &[String],
+) -> Result<(), LifecycleError> {
+    let skip_capture_backfill_agent_ids = skip_capture_backfill_agent_ids
+        .iter()
+        .map(String::as_str)
+        .collect::<Vec<_>>();
+    let topology_agent_ids = topology_agent_ids
+        .iter()
+        .map(String::as_str)
+        .collect::<Vec<_>>();
+    sync_restart_team_projections(state, team_key);
+    crate::state::projection::save_team_scoped_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+        workspace,
+        state,
+        &skip_capture_backfill_agent_ids,
+        &topology_agent_ids,
+    )
+    .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
 fn save_restart_session_repairs(
@@ -1676,6 +1748,8 @@ fn write_restart_resume_postflight_event(
     exists: bool,
     checked_paths: &[std::path::PathBuf],
     recaptured: bool,
+    identity_ok: Option<bool>,
+    embedded_agent_id: Option<&str>,
 ) -> Result<(), LifecycleError> {
     crate::event_log::EventLog::new(workspace)
         .write(
@@ -1689,6 +1763,8 @@ fn write_restart_resume_postflight_event(
                     .map(|p| p.to_string_lossy().into_owned())
                     .collect::<Vec<_>>(),
                 "recaptured": recaptured,
+                "identity_ok": identity_ok,
+                "embedded_agent_id": embedded_agent_id,
             }),
         )
         .map(|_| ())
@@ -1878,6 +1954,32 @@ fn write_restart_resume_decision_event(
                             );
                         }
                     }
+                    if let crate::provider::session::ResumeRefusalReason::SessionIdentityMismatch {
+                        expected_agent_id,
+                        embedded_agent_id,
+                        session_id,
+                        rollout_path,
+                    } = structured
+                    {
+                        obj.insert(
+                            "expected_agent_id".to_string(),
+                            serde_json::json!(expected_agent_id),
+                        );
+                        obj.insert(
+                            "embedded_agent_id".to_string(),
+                            serde_json::json!(embedded_agent_id),
+                        );
+                        obj.insert(
+                            "poisoned_session_id".to_string(),
+                            serde_json::json!(session_id),
+                        );
+                        if let Some(path) = rollout_path {
+                            obj.insert(
+                                "rollout_path".to_string(),
+                                serde_json::json!(path.to_string_lossy()),
+                            );
+                        }
+                    }
                 }
             }
         }