@team-agent/installer 0.5.50 → 0.5.52

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

@@ -18,13 +18,15 @@ pub fn start_agent(
     team: Option<&str>,
 ) -> Result<StartAgentOutcome, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     start_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -54,9 +56,12 @@ pub fn start_agent_with_transport(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(error),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "start-agent",
@@ -778,13 +783,15 @@ pub fn stop_agent(
     team: Option<&str>,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     stop_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -801,6 +808,8 @@ pub fn stop_agent_with_transport(
     transport: &dyn crate::transport::Transport,
 ) -> Result<StopAgentReport, LifecycleError> {
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "stop-agent",
@@ -840,9 +849,12 @@ pub(crate) fn start_agent_at_paths_for_recovery(
         Err(_) if team.is_none() => LifecyclePaths {
             run_workspace: workspace.to_path_buf(),
             spec_workspace: workspace.to_path_buf(),
+            selected: None,
         },
         Err(error) => return Err(RecoveryError::Lifecycle(error.to_string())),
     };
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     // Best-effort stop: if the live pane still exists we tear it down so the
     // subsequent start creates a fresh provider process instead of a Noop.
     // Stop errors are absorbed into the start attempt result — the important
@@ -884,26 +896,38 @@ pub(super) fn stop_agent_at_paths(
     transport: &dyn crate::transport::Transport,
 ) -> Result<StopAgentReport, LifecycleError> {
     // golden operations.py:64-66: resolve_team_scoped_state -> owner gate, BEFORE the unknown-worker raise.
-    let mut state = resolve_team_scoped_state_or_refuse(workspace, team)?;
-    crate::lifecycle::launch::ensure_owner_allowed_for_state(&state, Some(agent_id))?;
-    let spec = load_team_spec(spec_workspace)?;
-    let agent = find_spec_agent(&spec, agent_id).ok_or_else(|| unknown_worker(agent_id))?;
-    let session_name = state_session_name_from_spec(&state, &spec);
-    let window = state
-        .get("agents")
-        .and_then(|v| v.get(agent_id.as_str()))
-        .and_then(|v| v.get("window"))
-        .and_then(|v| v.as_str())
-        .filter(|s| !s.is_empty())
-        .unwrap_or_else(|| agent_id.as_str())
-        .to_string();
-    let pane_id = state
-        .get("agents")
-        .and_then(|v| v.get(agent_id.as_str()))
-        .and_then(|v| v.get("pane_id"))
-        .and_then(|v| v.as_str())
-        .filter(|pane| !pane.is_empty())
-        .map(crate::transport::PaneId::new);
+    let seat = super::remove::resolve_seat(workspace, spec_workspace, agent_id, team, transport)?;
+    if seat.consistency == super::remove::SeatConsistency::Absent {
+        return Err(unknown_worker(agent_id));
+    }
+    let mut state = seat.state;
+    let spec = seat.spec;
+    let state_agent = state.get("agents").and_then(|v| v.get(agent_id.as_str()));
+    // Persisted-only seats must remain stoppable. Build the minimal provider
+    // projection consumed by mark_agent_stopped instead of requiring a spec
+    // row that is precisely what recovery is repairing.
+    let fallback_agent = YamlValue::Map(vec![(
+        "provider".to_string(),
+        YamlValue::Str(
+            state_agent
+                .and_then(|agent| agent.get("provider"))
+                .and_then(|value| value.as_str())
+                .unwrap_or("codex")
+                .to_string(),
+        ),
+    )]);
+    let agent = find_spec_agent(&spec, agent_id).unwrap_or(&fallback_agent);
+    let session_name = seat.session;
+    let window = seat.window;
+    let pane_id = seat.physical.map(|pane| pane.pane_id).or_else(|| {
+        state
+            .get("agents")
+            .and_then(|agents| agents.get(agent_id.as_str()))
+            .and_then(|agent| agent.get("pane_id"))
+            .and_then(serde_json::Value::as_str)
+            .filter(|pane| !pane.is_empty())
+            .map(crate::transport::PaneId::new)
+    });
     let target_str = pane_id
         .as_ref()
         .map(|pane| pane.as_str().to_string())
@@ -995,12 +1019,15 @@ pub(super) fn stop_agent_at_paths(
     }
     close_agent_display(&mut state, agent_id);
     mark_agent_stopped(&mut state, agent_id, agent, &window)?;
+    let team_key = restart_projection_team_key(&state, team);
     // golden operations.py:95: save_team_scoped_state (team projection) — NOT a raw save, so a
     // multi-team workspace keeps the other teams' persisted runtime state instead of being clobbered.
-    crate::state::projection::save_team_scoped_state_with_lifecycle_topology_authority(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::StopAgent {
+            team_key: &team_key,
+            agent_id: agent_id.as_str(),
+        },
         &state,
-        &[agent_id.as_str()],
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     // golden operations.py:96-99: snapshot (side-effect), then state_file = write_team_state path.
@@ -1202,13 +1229,15 @@ pub fn reset_agent(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",
         team,
         agent_id: Some(agent_id),
     })?;
-    let transport = lifecycle_worker_tmux_backend_for_selected_state(&paths.run_workspace, team)?;
+    let transport = paths.tmux_backend()?;
     reset_agent_at_paths(
         &paths.run_workspace,
         &paths.spec_workspace,
@@ -1234,6 +1263,8 @@ pub fn reset_agent_with_transport(
         });
     }
     let paths = lifecycle_paths(workspace, team)?;
+    let canonical_team = paths.canonical_team(team).map(str::to_string);
+    let team = canonical_team.as_deref();
     let _lock = acquire_agent_lifecycle_lock(LifecycleLockRequest {
         workspace: &paths.run_workspace,
         operation: "reset-agent",
@@ -1447,10 +1478,13 @@ fn reset_agent_at_paths(
     sync_restart_team_projections(&mut state, &team_key);
     // golden operations.py (reset): save_team_scoped_state on the team projection — same multi-team
     // preservation as stop, not a raw save_runtime_state.
-    crate::state::projection::save_team_scoped_state_with_tombstone_lifecycle_topology_authority(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::ResetAgent {
+            team_key: &team_key,
+            agent_id: agent_id.as_str(),
+            discard_session,
+        },
         &state,
-        &[agent_id.as_str()],
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
     // golden operations.py:125: write_team_state after the discard-save (the intermediate stopped snapshot).

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

@@ -373,8 +373,8 @@ pub(super) fn spawn_agent_window(
         let tmux_endpoint = transport.tmux_endpoint();
         let event_log = crate::event_log::EventLog::new(workspace);
         let _ = event_log.write(
-            "provider.worker.spawn_argv",
-            serde_json::json!({
+            crate::event_log::PROVIDER_WORKER_SPAWN_ARGV,
+            crate::event_log::provider_worker_spawn_argv_fields(serde_json::json!({
                 "agent_id": agent_id.as_str(),
                 "provider": provider,
                 "argv": plan.argv,
@@ -388,7 +388,7 @@ pub(super) fn spawn_agent_window(
                 "source": "restart",
                 "tmux_endpoint": tmux_endpoint,
                 "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
-            }),
+            })),
         );
     }
 
@@ -817,11 +817,13 @@ pub(super) fn save_restart_projected_state_with_capture_backfill_skip(
     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_and_capture_backfill_skip(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::RestartTeam {
+            team_key,
+            topology_authority_agent_ids,
+            skip_capture_backfill_agent_ids,
+        },
         state,
-        skip_capture_backfill_agent_ids,
-        topology_authority_agent_ids,
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
@@ -1316,21 +1318,16 @@ pub(crate) fn converge_missing_provider_sessions(
         poll_interval,
         restart_required_missing_session_agent_ids,
         |progress| {
-            let pending_agent_ids = progress.pending_agent_ids.clone();
             write_session_convergence_progress_event(
                 workspace,
                 serde_json::json!({
-                    "ts": chrono::Utc::now().to_rfc3339(),
-                    "event": "provider.session.converging",
                     "iteration": progress.iteration,
                     "elapsed_ms": progress.elapsed_ms,
                     "deadline_ms": progress.deadline_ms,
                     "changed": progress.changed,
                     "assigned": progress.assigned,
                     "missing": progress.missing,
-                    "required_missing": progress.required_missing_agent_ids.clone(),
                     "required_missing_agent_ids": progress.required_missing_agent_ids,
-                    "pending": pending_agent_ids,
                     "pending_agent_ids": progress.pending_agent_ids,
                     "candidate_count_by_agent": progress.candidate_count_by_agent,
                     "remaining_ms": progress.remaining_ms,
@@ -1344,22 +1341,11 @@ pub(crate) fn converge_missing_provider_sessions(
 
 fn write_session_convergence_progress_event(
     workspace: &Path,
-    event: serde_json::Value,
+    fields: serde_json::Value,
 ) -> Result<(), String> {
-    use std::io::Write as _;
-
-    let path = workspace.join(".team").join("logs").join("events.jsonl");
-    if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
-    }
-    let line = serde_json::to_string(&event).map_err(|e| e.to_string())?;
-    let mut file = std::fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(path)
-        .map_err(|e| e.to_string())?;
-    file.write_all(line.as_bytes())
-        .and_then(|_| file.write_all(b"\n"))
+    crate::event_log::EventLog::new(workspace)
+        .write(crate::event_log::PROVIDER_SESSION_CONVERGING, fields)
+        .map(|_| ())
         .map_err(|e| e.to_string())
 }
 
@@ -1837,6 +1823,46 @@ mod e36_transcript_backing_tests {
         }
     }
 
+    #[test]
+    fn convergence_event_uses_central_scrub_and_preserves_required_failure() {
+        let scratch = ScratchDir::new("event-log-central");
+        let marker = "synthetic-convergence-marker";
+        write_session_convergence_progress_event(
+            scratch.path(),
+            serde_json::json!({
+                "diagnostic": format!("mcp_servers.demo.env.OPENAI_API_KEY=\"{marker}\""),
+                "required_missing_agent_ids": ["worker"],
+                "pending_agent_ids": ["worker"],
+            }),
+        )
+        .expect("central EventLog write");
+        let bytes = std::fs::read_to_string(
+            scratch
+                .path()
+                .join(".team")
+                .join("logs")
+                .join("events.jsonl"),
+        )
+        .expect("events");
+        assert!(!bytes.contains(marker));
+        assert!(bytes.contains("[REDACTED]"));
+
+        let blocked = ScratchDir::new("event-log-required");
+        std::fs::create_dir_all(
+            blocked
+                .path()
+                .join(".team")
+                .join("logs")
+                .join("events.jsonl"),
+        )
+        .expect("occupy event path with directory");
+        assert!(write_session_convergence_progress_event(
+            blocked.path(),
+            serde_json::json!({"pending_agent_ids": ["worker"]}),
+        )
+        .is_err());
+    }
+
     // E36 fix-B RED→GREEN: a real Claude worker that sent a message has its session
     // transcript landed at <projects_root>/<slug>/<session_id>.jsonl, but neither
     // rollout_path was persisted to state nor a session.captured event was logged.

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

@@ -1841,11 +1841,13 @@ fn save_restart_state_with_lifecycle_topology_authority_and_capture_backfill_ski
         .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,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::RestartTeam {
+            team_key,
+            topology_authority_agent_ids: &topology_agent_ids,
+            skip_capture_backfill_agent_ids: &skip_capture_backfill_agent_ids,
+        },
         state,
-        &skip_capture_backfill_agent_ids,
-        &topology_agent_ids,
     )
     .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
@@ -1858,7 +1860,11 @@ fn save_restart_session_repairs(
 ) -> Result<(), LifecycleError> {
     let repairs = collect_session_repair_fields(state, agent_ids);
     sync_restart_team_projections(state, team_key);
-    match crate::state::projection::save_team_scoped_state(workspace, state) {
+    let repository = crate::state::repository::StateRepository::new(workspace);
+    match repository.save(
+        crate::state::repository::StateWriteIntent::RestartSessionRepair { team_key },
+        state,
+    ) {
         Ok(()) => Ok(()),
         Err(crate::state::StateError::SaveConflict(_)) => {
             let mut latest =
@@ -1868,7 +1874,11 @@ fn save_restart_session_repairs(
                 apply_session_repair_fields(&mut latest, agent_id, repair);
             }
             sync_restart_team_projections(&mut latest, team_key);
-            crate::state::projection::save_team_scoped_state(workspace, &latest)
+            repository
+                .save(
+                    crate::state::repository::StateWriteIntent::RestartSessionRepair { team_key },
+                    &latest,
+                )
                 .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
             *state = latest;
             Ok(())
@@ -2266,8 +2276,8 @@ fn write_fake_harness_spawn_argv_event(
     tmux_endpoint_source: Option<&str>,
 ) {
     let _ = crate::event_log::EventLog::new(workspace).write(
-        "provider.worker.spawn_argv",
-        serde_json::json!({
+        crate::event_log::PROVIDER_WORKER_SPAWN_ARGV,
+        crate::event_log::provider_worker_spawn_argv_fields(serde_json::json!({
             "agent_id": decision.agent_id.as_str(),
             "provider": agent_provider(agent),
             "argv": [],
@@ -2277,7 +2287,7 @@ fn write_fake_harness_spawn_argv_event(
             "source": "restart",
             "tmux_endpoint": transport.tmux_endpoint(),
             "tmux_endpoint_source": tmux_endpoint_source.unwrap_or("transport"),
-        }),
+        })),
     );
 }
 
@@ -2924,15 +2934,7 @@ fn write_restart_resume_decision_event(
     forced_fresh_convergence: Option<&crate::session_capture::SessionConvergence>,
     unresumable: Option<&crate::lifecycle::types::UnresumableWorker>,
 ) -> Result<(), LifecycleError> {
-    use std::io::Write as _;
-
-    let path = workspace.join(".team").join("logs").join("events.jsonl");
-    if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent).map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    }
     let mut event = serde_json::json!({
-        "ts": chrono::Utc::now().to_rfc3339(),
-        "event": crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
         "worker_id": worker_id,
         "has_first_send_at": first_send_at.is_some(),
         "has_session_id": session_id.is_some(),
@@ -3039,15 +3041,12 @@ fn write_restart_resume_decision_event(
             }
         }
     }
-    let line =
-        serde_json::to_string(&event).map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    let mut file = std::fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&path)
-        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
-    file.write_all(line.as_bytes())
-        .and_then(|_| file.write_all(b"\n"))
+    crate::event_log::EventLog::new(workspace)
+        .write(
+            crate::lifecycle::types::event_names::RESTART_RESUME_DECISION,
+            event,
+        )
+        .map(|_| ())
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
 
@@ -3120,10 +3119,16 @@ fn restart_candidate_from_state(
         .filter(|s| !s.is_empty())
         .map(SessionName::new)
         .unwrap_or_else(|| SessionName::new(team_name));
+    let retired = retired_agent_ids(state);
     let mut agents = state
         .get("agents")
         .and_then(serde_json::Value::as_object)
-        .map(|map| map.keys().map(AgentId::new).collect::<Vec<_>>())
+        .map(|map| {
+            map.keys()
+                .filter(|agent_id| !retired.contains(agent_id.as_str()))
+                .map(AgentId::new)
+                .collect::<Vec<_>>()
+        })
         .unwrap_or_default();
     agents.sort_by(|a, b| a.as_str().cmp(b.as_str()));
     RestartCandidate {
@@ -3136,6 +3141,19 @@ fn restart_candidate_from_state(
     }
 }
 
+fn retired_agent_ids(state: &serde_json::Value) -> std::collections::BTreeSet<String> {
+    state
+        .get("agent_lifecycle")
+        .and_then(serde_json::Value::as_object)
+        .into_iter()
+        .flat_map(|lifecycle| lifecycle.iter())
+        .filter(|(_, entry)| {
+            entry.get("state").and_then(serde_json::Value::as_str) == Some("retired")
+        })
+        .map(|(agent_id, _)| agent_id.clone())
+        .collect()
+}
+
 /// E5 task#3 / RC-A6a:每次 restart 都以**角色定义**(team_dir 的 TEAM.md+agents/*.md)
 /// compile_team 重建 runtime spec(覆盖),保留运行期 override(session_name 必须延续,
 /// 否则 tmux session 对不上)。写到 .team/runtime/<team_key>/team.spec.yaml。
@@ -3205,6 +3223,7 @@ fn rebuild_runtime_spec_from_roles(
     // 静态 team_dir/agents/*.md + state 记录的 dynamic role source。缺文件 fail-closed
     // 三行式,不静默 prune 已 live 的 helper(persist SaveConflict 保护继续生效)。
     merge_state_dynamic_role_files(&mut spec, run_workspace, &team_dir, team_key, state)?;
+    filter_retired_agents_from_spec(&mut spec, &retired_agent_ids(state));
     // 写 runtime spec(覆盖,原子 tmp+rename;Bug2)。
     let spec_path = crate::model::paths::runtime_spec_path(run_workspace, team_key);
     crate::lifecycle::launch::write_spec_atomic(&spec_path, &spec)?;
@@ -3217,6 +3236,15 @@ fn rebuild_runtime_spec_from_roles(
     Ok(spec)
 }
 
+fn filter_retired_agents_from_spec(
+    spec: &mut YamlValue,
+    retired: &std::collections::BTreeSet<String>,
+) {
+    for agent_id in retired {
+        *spec = super::remove::spec_without_agent(spec, &AgentId::new(agent_id));
+    }
+}
+
 /// 0.5.30 (`add-agent-restart-saveconflict-locate.md` §4/§11): 把 add-agent
 /// 写入 `state.agents.<id>.dynamic_role_file` 的动态 role 文档合并回 restart
 /// 重建 spec。规则:
@@ -3419,6 +3447,118 @@ mod tests {
         TransportError,
     };
 
+    #[test]
+    fn retired_filter_clears_every_spec_reference_via_remove_primitive() {
+        let mut spec = crate::model::yaml::loads(
+            r#"
+name: retirement-filter
+agents:
+  - id: gone
+  - id: keep
+runtime:
+  startup_order:
+    - gone
+    - keep
+routing:
+  default_assignee: gone
+  rules:
+    - match: gone-task
+      assign_to: gone
+    - match: keep-task
+      assign_to: keep
+tasks:
+  - title: gone-task
+    assignee: gone
+  - title: keep-task
+    assignee: keep
+"#,
+        )
+        .expect("fixture spec");
+        let retired = std::collections::BTreeSet::from(["gone".to_string()]);
+
+        filter_retired_agents_from_spec(&mut spec, &retired);
+
+        let agents = spec
+            .get("agents")
+            .and_then(YamlValue::as_list)
+            .expect("agents");
+        assert!(agents.iter().all(|agent| {
+            agent.get("id").and_then(YamlValue::as_str) != Some("gone")
+        }));
+        let startup_order = spec
+            .get("runtime")
+            .and_then(|runtime| runtime.get("startup_order"))
+            .and_then(YamlValue::as_list)
+            .expect("startup_order");
+        assert!(startup_order
+            .iter()
+            .all(|agent_id| agent_id.as_str() != Some("gone")));
+        let routing = spec.get("routing").expect("routing");
+        assert_ne!(
+            routing
+                .get("default_assignee")
+                .and_then(YamlValue::as_str),
+            Some("gone"),
+            "spec_default_assignee must not return a retired agent"
+        );
+        let rules = routing
+            .get("rules")
+            .and_then(YamlValue::as_list)
+            .expect("routing rules");
+        assert!(rules.iter().all(|rule| {
+            rule.get("assign_to").and_then(YamlValue::as_str) != Some("gone")
+        }));
+        let tasks = spec
+            .get("tasks")
+            .and_then(YamlValue::as_list)
+            .expect("tasks");
+        assert!(tasks.iter().all(|task| {
+            task.get("assignee").and_then(YamlValue::as_str) != Some("gone")
+        }));
+    }
+
+    #[test]
+    fn resume_decision_event_uses_central_scrub_and_preserves_required_failure() {
+        let marker = "synthetic-resume-decision-marker";
+        let workspace =
+            std::env::temp_dir().join(format!("ta-resume-decision-event-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&workspace);
+        write_restart_resume_decision_event(
+            &workspace,
+            "worker",
+            Some(format!("mcp_servers.demo.env.OPENAI_API_KEY=\"{marker}\"")),
+            None,
+            false,
+            "fresh_start",
+            false,
+            None,
+            None,
+        )
+        .expect("central EventLog write");
+        let bytes =
+            std::fs::read_to_string(workspace.join(".team").join("logs").join("events.jsonl"))
+                .expect("events");
+        assert!(!bytes.contains(marker));
+        assert!(bytes.contains("[REDACTED]"));
+        let _ = std::fs::remove_dir_all(&workspace);
+
+        std::fs::create_dir_all(workspace.join(".team").join("logs").join("events.jsonl"))
+            .expect("occupy event path with directory");
+        let result = write_restart_resume_decision_event(
+            &workspace,
+            "worker",
+            None,
+            None,
+            false,
+            "fresh_start",
+            false,
+            None,
+            None,
+        );
+        assert!(matches!(result, Err(LifecycleError::StatePersist(_))));
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+
     struct RespawnEpochTransport;
 
     impl Transport for RespawnEpochTransport {