@team-agent/installer 0.3.12 → 0.3.13

package/crates/team-agent/src/leader/rediscover.rs

@@ -383,6 +383,7 @@ struct LeaderTarget {
     current_command: Option<String>,
     current_path: Option<PathBuf>,
     active: bool,
+    pane_pid: Option<u32>,
     leader_env: BTreeMap<String, String>,
     provider: Option<Provider>,
     leader_session_uuid: Option<LeaderSessionUuid>,
@@ -394,7 +395,7 @@ impl LeaderTarget {
         if !info.active {
             return None;
         }
-        let provider = leader_command_provider(info.current_command.as_deref().unwrap_or(""));
+        let provider = super::attribute_pane_provider(info);
         let leader_session_uuid = info
             .leader_env
             .get("TEAM_AGENT_LEADER_SESSION_UUID")
@@ -411,6 +412,7 @@ impl LeaderTarget {
             current_command: info.current_command.clone(),
             current_path: info.current_path.clone(),
             active: info.active,
+            pane_pid: info.pane_pid,
             leader_env: info.leader_env.clone(),
             provider,
             leader_session_uuid,
@@ -508,8 +510,26 @@ impl OwnerIdentity {
 fn target_from_value(value: &Value) -> Option<LeaderTarget> {
     let pane_id = get_str(value, "pane_id").or_else(|| get_str(value, "pane"))?;
     let current_command = get_str(value, "pane_current_command").or_else(|| get_str(value, "current_command"));
-    let provider = current_command.as_deref().and_then(leader_command_provider);
     let leader_env = map_env(value.get("leader_env").or_else(|| value.get("env")));
+    let pane_pid = get_u32(value, "pane_pid");
+    let provider = super::attribute_pane_provider(&PaneInfo {
+        pane_id: PaneId::new(pane_id.clone()),
+        session: get_str(value, "session_name")
+            .or_else(|| get_str(value, "session"))
+            .map(SessionName::new)
+            .unwrap_or_else(|| SessionName::new("")),
+        window_index: get_u32(value, "window_index"),
+        window_name: get_str(value, "window_name").map(WindowName::new),
+        pane_index: get_u32(value, "pane_index"),
+        tty: get_str(value, "pane_tty").or_else(|| get_str(value, "tty")),
+        current_command: current_command.clone(),
+        current_path: get_str(value, "pane_current_path")
+            .or_else(|| get_str(value, "current_path"))
+            .map(PathBuf::from),
+        active: value.get("active").and_then(Value::as_bool).unwrap_or(true),
+        pane_pid,
+        leader_env: leader_env.clone(),
+    });
     let leader_session_uuid = get_str(value, "leader_session_uuid")
         .or_else(|| leader_env.get("TEAM_AGENT_LEADER_SESSION_UUID").cloned())
         .and_then(|raw| serde_json::from_value(Value::String(raw)).ok());
@@ -528,6 +548,7 @@ fn target_from_value(value: &Value) -> Option<LeaderTarget> {
             .or_else(|| get_str(value, "current_path"))
             .map(PathBuf::from),
         active: value.get("active").and_then(Value::as_bool).unwrap_or(true),
+        pane_pid,
         leader_env,
         provider,
         leader_session_uuid,
@@ -584,21 +605,6 @@ fn path_in_workspace(path: &Path, workspace: &Path) -> bool {
     cwd == root || cwd.starts_with(root)
 }
 
-fn leader_command_provider(command: &str) -> Option<Provider> {
-    let lower = command.to_ascii_lowercase();
-    if lower.contains("claude") {
-        Some(Provider::ClaudeCode)
-    } else if lower.contains("codex") {
-        Some(Provider::Codex)
-    } else if lower.contains("copilot") {
-        Some(Provider::Copilot)
-    } else if lower.contains("fake") {
-        Some(Provider::Fake)
-    } else {
-        None
-    }
-}
-
 fn target_matches_owner_identity(target: &LeaderTarget, identity: &OwnerIdentity) -> bool {
     identity
         .pane_id
@@ -624,6 +630,7 @@ fn pane_info_value(
         "pane_index": info.pane_index,
         "pane_tty": info.tty,
         "pane_current_command": info.current_command,
+        "pane_pid": info.pane_pid,
         "pane_current_path": info.current_path.as_ref().map(|path| path.to_string_lossy().to_string()),
         "fingerprint": info.leader_env.get("TEAM_AGENT_MACHINE_FINGERPRINT"),
         "provider": provider.map(provider_wire),
@@ -1100,5 +1107,15 @@ fn get_str(value: &Value, key: &str) -> Option<String> {
         .filter(|s| !s.is_empty())
 }
 
+fn get_u32(value: &Value, key: &str) -> Option<u32> {
+    value
+        .get(key)
+        .and_then(|raw| {
+            raw.as_u64()
+                .or_else(|| raw.as_i64().and_then(|n| u64::try_from(n).ok()))
+        })
+        .and_then(|n| u32::try_from(n).ok())
+}
+
 #[cfg(test)]
 mod tests;

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

@@ -9,7 +9,7 @@ use crate::model::ids::AgentId;
 use crate::model::permissions::{self, AgentPermissionInput};
 use crate::model::yaml::{self, Value};
 use crate::state::persist::{load_runtime_state, save_runtime_state};
-use crate::transport::{SessionName, Target, Transport, WindowName};
+use crate::transport::{PaneId, SessionName, Target, Transport, WindowName};
 
 use super::*;
 
@@ -595,7 +595,7 @@ fn merge_workspace_team_state_with_key(
     launched_key: &str,
 ) -> serde_json::Value {
     let mut launched_obj = launched.as_object().cloned().unwrap_or_default();
-    let mut teams = launched
+    let mut teams = existing
         .get("teams")
         .and_then(serde_json::Value::as_object)
         .cloned()
@@ -638,6 +638,41 @@ fn merge_workspace_team_state_with_key(
     serde_json::Value::Object(merged)
 }
 
+#[cfg(test)]
+mod merge_workspace_team_state_with_key_tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn empty_top_level_existing_session_preserves_existing_teams() {
+        let existing = json!({
+            "session_name": "",
+            "active_team_key": "parent",
+            "teams": {
+                "parent": {
+                    "session_name": "team-parent",
+                    "agents": {"parent_worker": {"status": "running"}}
+                }
+            }
+        });
+        let launched = json!({
+            "session_name": "team-child",
+            "agents": {"child_worker": {"status": "running"}}
+        });
+        let merged = merge_workspace_team_state_with_key(&existing, &launched, "child");
+        assert_eq!(
+            merged.pointer("/teams/parent/session_name"),
+            Some(&json!("team-parent")),
+            "existing.teams must survive even when existing.session_name is empty: {merged}"
+        );
+        assert_eq!(
+            merged.pointer("/teams/child/session_name"),
+            Some(&json!("team-child")),
+            "launched team must still be inserted under its runtime key: {merged}"
+        );
+    }
+}
+
 fn promote_launched_binding_from_team_entry(launched: &mut serde_json::Value, launched_key: &str) {
     let entry = launched
         .get("teams")
@@ -849,6 +884,29 @@ fn write_invalid_leader_pane_env_warning(workspaces: &[&Path], pane_id_raw: &str
     }
 }
 
+fn warn_ignored_owner_team_id(workspace: &Path, team_dir: &Path, runtime_team_key: &str) {
+    let Ok(Some(ignored)) = crate::compiler::ignored_owner_team_id_from_team_md(team_dir) else {
+        return;
+    };
+    eprintln!("Warning: ignored TEAM.md {}={}", ignored.field, ignored.value);
+    eprintln!("Reason: owner identity is the canonical runtime team key ({runtime_team_key}), not TEAM.md front matter");
+    eprintln!("Action: remove {} from TEAM.md", ignored.field);
+    if let Err(err) = crate::event_log::EventLog::new(workspace).write(
+        "spec.field_ignored",
+        serde_json::json!({
+            "field": ignored.field,
+            "source": team_dir.join("TEAM.md").to_string_lossy().to_string(),
+            "value": ignored.value,
+            "warning": "ignored user-set owner_team_id",
+            "reason": "owner identity is derived from the canonical runtime team key",
+            "action": "remove owner_team_id from TEAM.md",
+            "runtime_team_key": runtime_team_key,
+        }),
+    ) {
+        eprintln!("Warning: spec.field_ignored event write failed: {err}");
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum LeaderPaneEnvState {
     Live,
@@ -932,12 +990,13 @@ fn seed_unbound_launched_owner(launched: &mut serde_json::Value, launched_key: &
     let Some(owner) = unbound_launched_owner(launched, launched_key) else {
         return;
     };
-    let provider = launched
-        .get("team_owner")
-        .and_then(|owner| owner.get("provider"))
+    let Some(provider) = owner
+        .get("provider")
         .and_then(serde_json::Value::as_str)
         .filter(|provider| !provider.is_empty())
-        .unwrap_or("codex");
+    else {
+        return;
+    };
     let owner_epoch = 1u64;
     let receiver = serde_json::json!({
         "mode": "direct_tmux",
@@ -958,12 +1017,7 @@ fn unbound_launched_owner(
     launched: &serde_json::Value,
     launched_key: &str,
 ) -> Option<serde_json::Value> {
-    let provider = launched
-        .get("team_owner")
-        .and_then(|owner| owner.get("provider"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|provider| !provider.is_empty())
-        .unwrap_or("codex");
+    let provider = unbound_launched_provider(launched)?;
     let machine_fingerprint = launched
         .get("team_owner")
         .and_then(|owner| owner.get("machine_fingerprint"))
@@ -994,6 +1048,97 @@ fn unbound_launched_owner(
     }))
 }
 
+fn unbound_launched_provider(launched: &serde_json::Value) -> Option<String> {
+    if let Some(provider) = launched
+        .get("team_owner")
+        .and_then(|owner| owner.get("provider"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|provider| !provider.is_empty())
+        .and_then(parse_provider)
+        .and_then(provider_wire_string)
+    {
+        return Some(provider);
+    }
+    let workspace = launched
+        .get("workspace")
+        .and_then(serde_json::Value::as_str)
+        .filter(|workspace| !workspace.is_empty())?;
+    let pane = launched
+        .get("team_owner")
+        .and_then(|owner| owner.get("pane_id"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty())?;
+    let target = PaneId::new(pane);
+    crate::tmux_backend::TmuxBackend::for_workspace(Path::new(workspace))
+        .list_targets()
+        .ok()?
+        .into_iter()
+        .find(|info| info.pane_id == target)
+        .and_then(|info| crate::leader::attribute_pane_provider(&info))
+        .and_then(provider_wire_string)
+}
+
+fn provider_wire_string(provider: Provider) -> Option<String> {
+    serde_json::to_value(provider)
+        .ok()
+        .and_then(|value| value.as_str().map(str::to_string))
+}
+
+#[cfg(test)]
+mod e22_unbound_owner_provider_tests {
+    use super::*;
+
+    #[test]
+    fn unbound_owner_preserves_explicit_copilot_provider() {
+        let mut launched = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "team_owner": {
+                "provider": "copilot",
+                "machine_fingerprint": "machine"
+            }
+        });
+
+        seed_unbound_launched_owner(&mut launched, "team-e22");
+
+        assert_eq!(
+            launched
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+        assert_eq!(
+            launched
+                .pointer("/leader_receiver/provider")
+                .and_then(serde_json::Value::as_str),
+            Some("copilot")
+        );
+    }
+
+    #[test]
+    fn unbound_owner_without_attributed_provider_does_not_default_codex() {
+        let mut launched = serde_json::json!({
+            "workspace": "/tmp/team-agent-e22",
+            "team_owner": {
+                "machine_fingerprint": "machine"
+            }
+        });
+
+        seed_unbound_launched_owner(&mut launched, "team-e22");
+
+        assert!(
+            launched.get("leader_receiver").is_none(),
+            "unattributed unbound owner must not seed a codex receiver: {launched}"
+        );
+        assert!(
+            launched
+                .pointer("/team_owner/provider")
+                .and_then(serde_json::Value::as_str)
+                != Some("codex"),
+            "unattributed unbound owner must not silently become codex: {launched}"
+        );
+    }
+}
+
 fn owner_pane_belongs_to_other_team(
     existing: &serde_json::Value,
     launched_key: &str,
@@ -2144,6 +2289,7 @@ pub fn quick_start_with_transport_in_workspace(
     let state_team_key = explicit_team_key.clone().unwrap_or_else(|| {
         runtime_team_key_for_spec(&agents_dir.join("team.spec.yaml"), &spec, &session_name)
     });
+    warn_ignored_owner_team_id(workspace.as_path(), agents_dir, &state_team_key);
     // E5 spec 迁移:spec 写到 .team/runtime/<team_key>/(中间产物,绝不落用户目录 agents_dir)。
     // Bug2:原子写(tmp+rename),避免半截 spec。
     let spec_path = crate::model::paths::runtime_spec_path(&workspace, &state_team_key);

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

@@ -212,35 +212,49 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
             .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     }
-    let mut last_spawned: Option<AgentId> = None;
+    let mut successful_agents: Vec<RestartedAgent> = Vec::new();
+    let mut failed_agents: Vec<RestartFailedAgent> = Vec::new();
+    // B5 restart isolation loop: per-agent spawn failures must be recorded and
+    // isolated here. Do not reintroduce `?`, `break`, or `return` inside this loop.
+    // BEGIN_B5_RESTART_ISOLATION_LOOP
     for decision in &plan.decisions {
-        let agent = state
+        let Some(agent) = state
             .get("agents")
             .and_then(|v| v.get(decision.agent_id.as_str()))
-            .ok_or_else(|| {
-                LifecycleError::RequirementUnmet(format!(
-                    "agent {} not found for restart",
-                    decision.agent_id
-                ))
-            })?
-            .clone();
+            .cloned()
+        else {
+            let error = format!("agent {} not found for restart", decision.agent_id);
+            mark_agent_restart_failed(&mut state, decision, &error);
+            let _ = write_restart_agent_failed_event(&selected.run_workspace, decision, "spawn", &error);
+            failed_agents.push(restart_failed_agent(decision, "spawn", error));
+            continue;
+        };
         let session_id = if matches!(decision.restart_mode, StartMode::Resumed) {
             decision.session_id.as_ref()
         } else {
             None
         };
-        let session_live = session_live_or_default(transport, &session_name, false);
+        let mut session_live = session_live_or_default(transport, &session_name, false);
         if !session_live {
-            if let Some(previous) = &last_spawned {
-                return Err(LifecycleError::Transport(format!(
+            if let Some(previous) = successful_agents.pop() {
+                let error = format!(
                     "session_disappeared_after_spawn: provider_resume_exited for {}; session {} disappeared before spawning {}",
-                    previous,
+                    previous.agent_id,
                     session_name.as_str(),
                     decision.agent_id
-                )));
+                );
+                mark_agent_restart_failed(&mut state, &previous, &error);
+                let _ = write_restart_agent_failed_event(
+                    &selected.run_workspace,
+                    &previous,
+                    "resume",
+                    &error,
+                );
+                failed_agents.push(restart_failed_agent(&previous, "resume", error));
+                session_live = false;
             }
         }
-        let spawn = spawn_agent_window(
+        let spawn = match spawn_agent_window(
             &selected.run_workspace,
             &session_name,
             &decision.agent_id,
@@ -250,10 +264,33 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             transport,
             Some(&safety),
             Some(spec_workspace),
-        )?;
-        verify_spawned_agent_live(&decision.agent_id, &spawn, transport)?;
-        mark_agent_respawned(&mut state, &decision.agent_id, &spawn, transport, &safety)?;
-        last_spawned = Some(decision.agent_id.clone());
+        ) {
+            Ok(spawn) => spawn,
+            Err(error) => {
+                let error = error.to_string();
+                mark_agent_restart_failed(&mut state, decision, &error);
+                let _ = write_restart_agent_failed_event(&selected.run_workspace, decision, "spawn", &error);
+                failed_agents.push(restart_failed_agent(decision, "spawn", error));
+                continue;
+            }
+        };
+        if let Err(error) = verify_spawned_agent_live(&decision.agent_id, &spawn, transport)
+            .and_then(|_| {
+                mark_agent_respawned(&mut state, &decision.agent_id, &spawn, transport, &safety)
+            })
+        {
+            let error = error.to_string();
+            mark_agent_restart_failed(&mut state, decision, &error);
+            let _ = write_restart_agent_failed_event(
+                &selected.run_workspace,
+                decision,
+                "readiness",
+                &error,
+            );
+            failed_agents.push(restart_failed_agent(decision, "readiness", error));
+            continue;
+        }
+        successful_agents.push(decision.clone());
         if let Some(agent) = state
             .get_mut("agents")
             .and_then(serde_json::Value::as_object_mut)
@@ -263,14 +300,31 @@ pub fn restart_with_transport_with_session_convergence_deadline(
             persist_effective_approval_policy_for_restart(agent, &safety);
         }
     }
+    // END_B5_RESTART_ISOLATION_LOOP
     crate::state::projection::save_team_scoped_state(&selected.run_workspace, &state)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if successful_agents.is_empty() && !failed_agents.is_empty() {
+        let attach_commands = Vec::new();
+        let next_actions = restart_failure_next_actions(&failed_agents);
+        write_restart_completed_event(
+            &selected.run_workspace,
+            &successful_agents,
+            &failed_agents,
+            "fail",
+        )?;
+        return Ok(RestartReport::Failed {
+            session_name,
+            failed_agents,
+            next_actions,
+            attach_commands,
+        });
+    }
     let coordinator_started = start_coordinator_for_workspace(&selected.run_workspace)?;
     wait_restart_readiness_or_timeout(
         &selected.run_workspace,
         &state,
         &session_name,
-        &plan.decisions,
+        &successful_agents,
         transport,
         restart_readiness_deadline(readiness_deadline_ms),
         restart_readiness_poll_interval(),
@@ -278,14 +332,37 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     let attach_commands = crate::tmux_backend::attach_commands_for_windows(
         &selected.run_workspace,
         &session_name,
-        plan.decisions
+        successful_agents
             .iter()
             .map(|decision| decision.agent_id.as_str()),
     );
-    let next_actions = attach_commands.clone();
+    let mut next_actions = attach_commands.clone();
+    if !failed_agents.is_empty() {
+        next_actions.extend(restart_failure_next_actions(&failed_agents));
+        write_restart_completed_event(
+            &selected.run_workspace,
+            &successful_agents,
+            &failed_agents,
+            "partial",
+        )?;
+        return Ok(RestartReport::Partial {
+            session_name,
+            agents: successful_agents,
+            failed_agents,
+            coordinator_started,
+            next_actions,
+            attach_commands,
+        });
+    }
+    write_restart_completed_event(
+        &selected.run_workspace,
+        &successful_agents,
+        &failed_agents,
+        "ok",
+    )?;
     Ok(RestartReport::Restarted {
         session_name,
-        agents: plan.decisions,
+        agents: successful_agents,
         coordinator_started,
         next_actions,
         attach_commands,
@@ -749,6 +826,134 @@ fn mark_agent_respawned(
     Ok(())
 }
 
+fn restart_failed_agent(
+    decision: &RestartedAgent,
+    phase: impl Into<String>,
+    error: String,
+) -> RestartFailedAgent {
+    RestartFailedAgent {
+        agent_id: decision.agent_id.clone(),
+        restart_mode: decision.restart_mode,
+        decision: decision.decision,
+        session_id: decision.session_id.clone(),
+        phase: phase.into(),
+        error,
+    }
+}
+
+fn mark_agent_restart_failed(
+    state: &mut serde_json::Value,
+    decision: &RestartedAgent,
+    error: &str,
+) {
+    let Some(agent) = state
+        .get_mut("agents")
+        .and_then(serde_json::Value::as_object_mut)
+        .and_then(|agents| agents.get_mut(decision.agent_id.as_str()))
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return;
+    };
+    agent.insert("status".to_string(), serde_json::json!("failed"));
+    agent.insert("restart_error".to_string(), serde_json::json!(error));
+    agent.insert(
+        "restart_failed_at".to_string(),
+        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+    );
+    agent.remove("pane_id");
+    agent.remove("pane_pid");
+}
+
+fn write_restart_agent_failed_event(
+    workspace: &Path,
+    decision: &RestartedAgent,
+    phase: &str,
+    error: &str,
+) -> Result<(), LifecycleError> {
+    crate::event_log::EventLog::new(workspace)
+        .write(
+            "restart.agent_failed",
+            serde_json::json!({
+                "agent_id": decision.agent_id.as_str(),
+                "restart_mode": start_mode_wire(decision.restart_mode),
+                "decision": resume_decision_wire(decision.decision),
+                "session_id": decision.session_id.as_ref().map(|session| session.as_str()),
+                "phase": phase,
+                "error": error,
+                "action": format!(
+                    "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                    decision.agent_id,
+                    decision.agent_id
+                ),
+                "log": format!(
+                    ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
+                    decision.agent_id
+                ),
+            }),
+        )
+        .map(|_| ())
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
+fn write_restart_completed_event(
+    workspace: &Path,
+    successful_agents: &[RestartedAgent],
+    failed_agents: &[RestartFailedAgent],
+    rc: &str,
+) -> Result<(), LifecycleError> {
+    crate::event_log::EventLog::new(workspace)
+        .write(
+            "restart.completed",
+            serde_json::json!({
+                "rc": rc,
+                "status": rc,
+                "successful_agents": successful_agents
+                    .iter()
+                    .map(|agent| agent.agent_id.as_str())
+                    .collect::<Vec<_>>(),
+                "failed_agents": failed_agents
+                    .iter()
+                    .map(|failure| serde_json::json!({
+                        "agent_id": failure.agent_id.as_str(),
+                        "phase": failure.phase,
+                        "error": failure.error,
+                    }))
+                    .collect::<Vec<_>>(),
+            }),
+        )
+        .map(|_| ())
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))
+}
+
+fn restart_failure_next_actions(failed_agents: &[RestartFailedAgent]) -> Vec<String> {
+    failed_agents
+        .iter()
+        .map(|failure| {
+            format!(
+                "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
+                failure.agent_id, failure.agent_id
+            )
+        })
+        .collect()
+}
+
+fn start_mode_wire(mode: StartMode) -> &'static str {
+    match mode {
+        StartMode::Resumed => "resumed",
+        StartMode::Fresh => "fresh",
+        StartMode::FreshAfterMissingRollout => "fresh_after_missing_rollout",
+        StartMode::Noop => "noop",
+    }
+}
+
+fn resume_decision_wire(decision: ResumeDecision) -> &'static str {
+    match decision {
+        ResumeDecision::Resume => "resume",
+        ResumeDecision::FreshStart => "fresh_start",
+        ResumeDecision::Refuse => "refuse",
+    }
+}
+
 fn write_restart_resume_decision_events(
     workspace: &Path,
     state: &serde_json::Value,
@@ -768,11 +973,7 @@ fn write_restart_resume_decision_events(
             .filter(|s| !s.is_empty())
             .map(|s| s.to_string());
         let session_id = decision.session_id.as_ref().map(|s| s.as_str().to_string());
-        let decision_wire = match decision.decision {
-            ResumeDecision::Resume => "resume",
-            ResumeDecision::FreshStart => "fresh_start",
-            ResumeDecision::Refuse => "refuse",
-        };
+        let decision_wire = resume_decision_wire(decision.decision);
         write_restart_resume_decision_event(
             workspace,
             decision.agent_id.as_str(),