@team-agent/installer 0.5.52 → 0.5.54

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

@@ -449,6 +449,15 @@ fn restart_with_selected_team_and_transport(
              moved leader to dedicated session)",
             session_name.as_str()
         );
+        let targets = vec![session_name.as_str().to_string()];
+        crate::kill_audit::pre_kill_audit(
+            &crate::event_log::EventLog::new(&selected.run_workspace),
+            transport,
+            "restart.stale_worker_session",
+            crate::kill_audit::KILL_SESSION,
+            &targets,
+        )
+        .map_err(|error| LifecycleError::Transport(format!("pre-kill audit failed: {error}")))?;
         transport
             .kill_session(&session_name)
             .map_err(|e| LifecycleError::Transport(e.to_string()))?;
@@ -1984,7 +1993,7 @@ fn mark_agent_respawned(
     }
     agent.insert(
         "spawned_at".to_string(),
-        serde_json::json!(chrono::Utc::now().to_rfc3339()),
+        serde_json::json!(spawn.spawned_at.as_str()),
     );
     agent.insert(
         "spawn_cwd".to_string(),
@@ -2462,6 +2471,7 @@ impl Clone for ParallelSpawnResult {
         Self {
             spawn: SpawnedAgentWindow {
                 spawn: self.spawn.spawn.clone(),
+                spawned_at: self.spawn.spawned_at.clone(),
                 plan: self.spawn.plan.clone(),
                 profile_launch: self.spawn.profile_launch.clone(),
                 layout_placement: self.spawn.layout_placement.clone(),
@@ -3689,6 +3699,7 @@ tasks:
                 }
             }
         });
+        let before = chrono::Utc::now();
         let spawn = SpawnedAgentWindow {
             spawn: SpawnResult {
                 pane_id: PaneId::new("%new"),
@@ -3696,14 +3707,13 @@ tasks:
                 window: WindowName::new("w1"),
                 child_pid: Some(2020),
             },
+            spawned_at: chrono::Utc::now().to_rfc3339(),
             plan: crate::provider::CommandPlan::argv_only(vec!["codex".to_string()]),
             profile_launch: crate::provider::ProviderProfileLaunch::default(),
             layout_placement: None,
             spawn_cwd: std::path::PathBuf::from("/tmp/team-epoch"),
             owner_team_id: None,
         };
-        let before = chrono::Utc::now();
-
         mark_agent_respawned(
             &mut state,
             &AgentId::new("w1"),

package/crates/team-agent/src/lifecycle/tests/lane_ops.rs

@@ -8,6 +8,60 @@ const DELEG_ROLE_ALPHA_COMPAT: &str = "---\nname: alpha\nrole: Alpha Worker\npro
 type LaneKills = std::sync::Arc<std::sync::Mutex<Vec<String>>>;
 pub(super) type LaneSpawns = std::sync::Arc<std::sync::Mutex<Vec<(String, Vec<String>)>>>;
 
+fn emit_codex_fork_backing(argv: &[String], cwd: &std::path::Path) {
+    if !argv.windows(2).any(|pair| pair == ["codex", "fork"]) {
+        return;
+    }
+    static SESSION_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    let sequence = SESSION_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    let session_id = format!("lane-fork-{}-{sequence}", std::process::id());
+    let root = std::env::var_os("HOME")
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|| std::path::PathBuf::from("."))
+        .join(".codex/sessions/lane-fixture");
+    std::fs::create_dir_all(&root).unwrap();
+    std::fs::write(
+        root.join(format!("rollout-{session_id}.jsonl")),
+        format!(
+            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}},\"created_at\":\"{}\"}}\n",
+            cwd.to_string_lossy(),
+            chrono::Utc::now().to_rfc3339()
+        ),
+    )
+    .unwrap();
+}
+
+pub(super) struct LaneHomeGuard {
+    previous: Option<std::ffi::OsString>,
+    root: PathBuf,
+}
+
+impl LaneHomeGuard {
+    pub(super) fn enter(tag: &str) -> Self {
+        static HOME_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+        let root = std::env::temp_dir().join(format!(
+            "ta-lane-home-{tag}-{}-{}",
+            std::process::id(),
+            HOME_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(&root).unwrap();
+        let previous = std::env::var_os("HOME");
+        std::env::set_var("HOME", &root);
+        Self { previous, root }
+    }
+}
+
+impl Drop for LaneHomeGuard {
+    fn drop(&mut self) {
+        match &self.previous {
+            Some(value) => std::env::set_var("HOME", value),
+            None => std::env::remove_var("HOME"),
+        }
+        let _ = std::fs::remove_dir_all(&self.root);
+    }
+}
+
 /// Recording transport for Lane-A v2: `list_windows`/`list_targets` answer from a configurable window
 /// set (golden's `_tmux_window_exists` primitive = `tmux list-windows`); `kill_window` + spawn_first/into
 /// are RECORDED. Every other method returns a benign Ok (never panics) so stop/reset/remove/fork run
@@ -18,6 +72,7 @@ pub(super) struct LaneTransport {
     foreign: std::sync::Arc<std::sync::Mutex<Vec<(String, String)>>>,
     killed: LaneKills,
     spawns: LaneSpawns,
+    spawn_observed_at: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
 }
 impl LaneTransport {
     pub(super) fn new(session: &str, windows: &[&str]) -> Self {
@@ -29,6 +84,7 @@ impl LaneTransport {
             foreign: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             killed: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
             spawns: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
+            spawn_observed_at: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
         }
     }
     pub(super) fn killed(&self) -> Vec<String> {
@@ -37,6 +93,9 @@ impl LaneTransport {
     pub(super) fn spawns(&self) -> Vec<(String, Vec<String>)> {
         self.spawns.lock().unwrap().clone()
     }
+    fn spawn_observed_at(&self) -> Vec<String> {
+        self.spawn_observed_at.lock().unwrap().clone()
+    }
     fn add_foreign(&self, session: &str, window: &str) {
         self.foreign
             .lock()
@@ -53,9 +112,14 @@ impl crate::transport::Transport for LaneTransport {
         session: &crate::transport::SessionName,
         window: &crate::transport::WindowName,
         argv: &[String],
-        _c: &std::path::Path,
+        c: &std::path::Path,
         _e: &std::collections::BTreeMap<String, String>,
     ) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
+        self.spawn_observed_at
+            .lock()
+            .unwrap()
+            .push(chrono::Utc::now().to_rfc3339());
+        emit_codex_fork_backing(argv, c);
         self.spawns
             .lock()
             .unwrap()
@@ -84,9 +148,14 @@ impl crate::transport::Transport for LaneTransport {
         session: &crate::transport::SessionName,
         window: &crate::transport::WindowName,
         argv: &[String],
-        _c: &std::path::Path,
+        c: &std::path::Path,
         _e: &std::collections::BTreeMap<String, String>,
     ) -> Result<crate::transport::SpawnResult, crate::transport::TransportError> {
+        self.spawn_observed_at
+            .lock()
+            .unwrap()
+            .push(chrono::Utc::now().to_rfc3339());
+        emit_codex_fork_backing(argv, c);
         self.spawns
             .lock()
             .unwrap()
@@ -147,7 +216,7 @@ impl crate::transport::Transport for LaneTransport {
         &self,
         _p: &crate::transport::PaneId,
     ) -> Result<crate::model::enums::PaneLiveness, crate::transport::TransportError> {
-        Ok(crate::model::enums::PaneLiveness::Unknown)
+        Ok(crate::model::enums::PaneLiveness::Live)
     }
     fn list_targets(
         &self,
@@ -1594,14 +1663,11 @@ fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
     );
 }
 
-// ── FORK (fork-report-session-id-is-pane-id) [RED] — report session_id is the captured id / None, not pane
-// Golden operations.py:399,408 returns state['agents'][as_agent_id].get('session_id') — the captured
-// provider session id (or None if capture missed, raise_on_missed=False). Rust sets
-// session_id: Some(SessionId::new(spawn.pane_id)) (launch.rs:502) — the tmux pane id ('%newfork'),
-// a different value kind. RED: the report session_id must NOT be the pane id (None, since the Rust fork
-// path performs no session capture).
+// Successful fork reports the verified provider session id, never the pane id.
 #[test]
+#[serial_test::serial(env)]
 fn lanea_fork_report_session_id_is_not_pane_id() {
+    let _home = LaneHomeGuard::enter("fork-report");
     let ws = fork_ws(DELEG_ROLE_ALPHA); // codex+subscription -> native fork supported -> full success path
     let tx = LaneTransport::new("team-laneateam", &[]);
     let report =
@@ -1613,9 +1679,41 @@ fn lanea_fork_report_session_id_is_not_pane_id() {
         "golden operations.py:399,408: report.session_id is the captured provider session id / None, NEVER the \
          tmux pane id; Rust returns Some(pane_id='%newfork')"
     );
-    assert_eq!(
-        report.session_id, None,
-        "the Rust fork path captures no session -> report.session_id must be None (golden capture-missed), not the pane id"
+    assert!(
+        report.session_id.is_some(),
+        "a successful fork must carry the verified NEW provider session id"
+    );
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let row = &state["agents"]["newfork"];
+    assert!(row["spawned_at"]
+        .as_str()
+        .is_some_and(|value| chrono::DateTime::parse_from_rfc3339(value).is_ok()));
+    assert_eq!(row["spawn_epoch"], serde_json::json!(1));
+}
+
+#[test]
+fn fresh_start_persists_boundary_from_before_transport_spawn() {
+    let ws = lanea_one_agent_ws("stopped");
+    let tx = LaneTransport::new("team-laneateam", &[]);
+    crate::lifecycle::start_agent_with_transport(&ws, &aid("alpha"), false, false, true, None, &tx)
+        .expect("fresh start");
+
+    let transport_observed_at = tx
+        .spawn_observed_at()
+        .into_iter()
+        .next()
+        .expect("transport spawn observation");
+    let transport_observed_at =
+        chrono::DateTime::parse_from_rfc3339(&transport_observed_at).unwrap();
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let spawned_at = state["agents"]["alpha"]["spawned_at"]
+        .as_str()
+        .and_then(|value| chrono::DateTime::parse_from_rfc3339(value).ok())
+        .expect("persisted spawn boundary");
+    assert!(
+        spawned_at <= transport_observed_at,
+        "the persisted capture boundary must precede the transport spawn; \
+         spawned_at={spawned_at}, transport_observed_at={transport_observed_at}"
     );
 }
 

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -71,10 +71,11 @@ fn codex_identity_rollout(
     std::fs::write(
         &path,
         format!(
-            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\n\
+            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\",\"created_at\":\"{}\"}}}}}}\n\
              {{\"type\":\"turn_context\",\"payload\":{{}}}}\n\
              {{\"type\":\"response_item\",\"payload\":{{\"content\":[{{\"type\":\"input_text\",\"text\":\"You are Team Agent worker `{embedded_agent_id}` with role `fixture`.\"}}]}}}}\n",
-            workspace.to_string_lossy()
+            workspace.to_string_lossy(),
+            chrono::Utc::now().to_rfc3339()
         ),
     )
     .unwrap();
@@ -2481,6 +2482,10 @@ fn restart_allow_fresh_copilot_keeps_session_id_null_until_capture_confirms() {
         .windows(2)
         .find_map(|pair| (pair[0] == "--session-id").then(|| pair[1].clone()))
         .expect("copilot fresh spawn argv must include --session-id");
+    let instructions =
+        std::fs::read_to_string(ws.join(".team/runtime/copilot-instructions/alpha/AGENTS.md"))
+            .expect("restart/add/clone spawn must materialize Copilot instructions");
+    assert!(instructions.contains("Alpha Worker"));
     let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
     let agent = state.pointer("/agents/alpha").expect("alpha state");
     // 0.4.6 contract: session_id stays null until scanner confirms sqlite.
@@ -3084,6 +3089,7 @@ fn quick_start_running_agent_state_shape_after_spawn_is_golden() {
             "captured_at",
             "captured_via",
             "attribution_confidence",
+            "capture_state",
             "spawn_cwd",
             "spawned_at",
             "pane_id",

package/crates/team-agent/src/lifecycle/tests/main_preserved.rs

@@ -318,6 +318,7 @@ fn reset_agent_discard_session_rebuilds_window_via_start_respawn() {
 }
 
 #[test]
+#[serial_test::serial(env)]
 fn reset_agent_discard_session_syncs_projection_epoch_inputs_for_restart_agent_command() {
     let ws = restart_ws_two_resumable_workers();
     let mut state = crate::state::persist::load_runtime_state(&ws).expect("load state");

package/crates/team-agent/src/lifecycle/tests/phase_b_contracts.rs

@@ -1,5 +1,5 @@
 use super::agent_ops::lanea_team_ws;
-use super::lane_ops::{fork_ws, LaneTransport};
+use super::lane_ops::{fork_ws, LaneHomeGuard, LaneTransport};
 use super::launch_spawn::{
     quick_start_team_dir, seed_healthy_coordinator, DELEG_ROLE_ALPHA, QS_VALID_ROLE,
 };
@@ -129,7 +129,9 @@ fn concurrent_reset_discard_session_serializes() {
 }
 
 #[test]
+#[serial_test::serial(env)]
 fn add_fork_remove_share_lifecycle_lock_behavior() {
+    let _home = LaneHomeGuard::enter("phase-b-fork");
     let (add_team, add_workspace, add_role, add_transport) = add_fixture();
     let add_agent = aid("w2");
     let add_state_before =

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -267,6 +267,7 @@ fn run_phase_golden(spec: PhaseGolden) -> Value {
         confirm_human: false,
         json: true,
         message_id: Some("phase-golden-message".to_string()),
+        presentation: crate::messaging::presentation::PresentationRequest::default(),
         pane: None,
         to_name: None,
         to_leader: None,

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

@@ -666,6 +666,23 @@ pub struct ForkAgentReport {
     pub session_id: Option<SessionId>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CloneAgentReport {
+    pub source_agent_id: AgentId,
+    pub new_agent_id: AgentId,
+    pub env: AgentActionEnvelope,
+    pub session_id: Option<SessionId>,
+    pub backing_path: Option<PathBuf>,
+    pub backing_state: CloneBackingState,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CloneBackingState {
+    Verified,
+    PendingFirstTurn,
+}
+
 /// Read-only remove-agent flag requirements for the target's current state.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RemoveAgentFlagRequirements {

package/crates/team-agent/src/mcp_server/lifecycle_tools/agent_ops.rs

@@ -134,6 +134,41 @@ pub(crate) fn fork_agent(
     })
 }
 
+pub(crate) fn clone_agent(
+    workspace: &Path,
+    owner_team: Option<&TeamKey>,
+    source_agent_id: &str,
+    as_agent_id: &str,
+    label: Option<&str>,
+) -> ToolResult {
+    emit_newer_daemon_preserved_if_present(workspace)?;
+    let lifecycle_workspace = lifecycle_workspace(workspace, owner_team, false)?;
+    let report = crate::lifecycle::launch::clone_agent(
+        &lifecycle_workspace,
+        &AgentId::new(source_agent_id),
+        &AgentId::new(as_agent_id),
+        label,
+        false,
+        owner_team.map(TeamKey::as_str),
+    )
+    .map_err(tool_runtime_error)?;
+    Ok(ToolOk {
+        fields: object_fields(serde_json::json!({
+            "ok": true,
+            "status": "cloned",
+            "source_agent_id": report.source_agent_id.as_str(),
+            "agent_id": report.new_agent_id.as_str(),
+            "new_agent_id": report.new_agent_id.as_str(),
+            "state_file": report.env.state_file.to_string_lossy().to_string(),
+            "coordinator_started": report.env.coordinator_started,
+            "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+            "backing_path": report.backing_path.as_ref().map(|path| path.to_string_lossy().to_string()),
+            "backing_state": report.backing_state,
+        })),
+    })
+}
+
 fn reset_refusal_reason(reason: ResetRefusal) -> Value {
     match reason {
         ResetRefusal::DiscardSessionRequired => {
@@ -440,9 +475,9 @@ fn prepare_selected_team_state(
             state,
         )
         .map_err(|e| {
-        tool_runtime_error(format!(
-            "save MCP lifecycle scoped state {}: {e}",
-            workspace.display()
-        ))
-    })
+            tool_runtime_error(format!(
+                "save MCP lifecycle scoped state {}: {e}",
+                workspace.display()
+            ))
+        })
 }

package/crates/team-agent/src/mcp_server/lifecycle_tools/mod.rs

@@ -6,5 +6,5 @@
 mod agent_ops;
 mod state_status;
 
-pub(crate) use agent_ops::{fork_agent, reset_agent, stop_agent};
+pub(crate) use agent_ops::{clone_agent, fork_agent, reset_agent, stop_agent};
 pub(crate) use state_status::{get_team_status, update_state};

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -104,6 +104,12 @@ pub fn normalize_report_envelope(env: &Value) -> NormalizedReportEnvelope {
     let summary = text_field(env, "summary").unwrap_or_else(|| "completed".to_string());
     let task_id = text_field(env, "task_id").unwrap_or_else(|| "manual".to_string());
     let agent_id = text_field(env, "agent_id").unwrap_or_else(|| "unknown".to_string());
+    let (presentation_request, presentation_error) =
+        crate::messaging::presentation::normalize_report_presentation(env.get("presentation"));
+    let presentation = crate::messaging::presentation::decide_presentation(
+        &presentation_request,
+        crate::messaging::presentation::PresentationSource::ReportResult,
+    );
     NormalizedReportEnvelope {
         schema_version: "result_envelope_v1".to_string(),
         task_id: TaskId::new(task_id),
@@ -115,6 +121,8 @@ pub fn normalize_report_envelope(env: &Value) -> NormalizedReportEnvelope {
         risks: normalize_risks(env.get("risks")),
         artifacts: normalize_artifacts(env.get("artifacts")),
         next_actions: normalize_next_actions(env.get("next_actions")),
+        presentation,
+        presentation_error,
     }
 }