@team-agent/installer 0.5.49 → 0.5.51

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

@@ -884,26 +884,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 +1007,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.
@@ -1447,10 +1462,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()))
 }
 
@@ -3419,6 +3418,48 @@ mod tests {
         TransportError,
     };
 
+    #[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 {