@team-agent/installer 0.5.2 → 0.5.4

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

@@ -85,6 +85,16 @@ fn acquire_agent_lifecycle_lock_with_deadlines(
     timeout: Duration,
     held_long: Duration,
 ) -> Result<LifecycleLockGuard, LifecycleError> {
+    // 0.5.x Windows portability Batch 2: migrated to
+    // `crate::platform::file_lock::{try_lock_once_nonblocking, unlock}`
+    // so the same polling loop + waiter file + 5s `lock_held_long`
+    // event + 30s N38 timeout error shape works on both Unix (`flock`)
+    // and Windows (`LockFileEx`). The Batch 0 non-Unix stub that
+    // returned `lock_timeout_error` unconditionally is now gone —
+    // Windows callers get real lock behavior. Byte-preserving on Unix:
+    // the polling cadence, waiter file writes, `lock_held_long_event`
+    // emission, and error shape are all unchanged relative to the
+    // pre-Batch-2 unix branch.
     let lock_path = agent_lifecycle_lock_path(request.workspace);
     if let Some(parent) = lock_path.parent() {
         std::fs::create_dir_all(parent)
@@ -100,42 +110,38 @@ fn acquire_agent_lifecycle_lock_with_deadlines(
     let started = Instant::now();
     let mut long_event_written = false;
     let mut waiter = None;
-    #[cfg(unix)]
-    {
-        use std::os::unix::io::AsRawFd;
-        let fd = file.as_raw_fd();
-        loop {
-            let rc = unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) };
-            if rc == 0 {
+    loop {
+        match crate::platform::file_lock::try_lock_once_nonblocking(&file) {
+            Ok(true) => {
                 write_lock_metadata(&mut file, &request, &lock_path)?;
                 return Ok(LifecycleLockGuard { file });
             }
-            let elapsed = started.elapsed();
-            if waiter.is_none() {
-                waiter = WaiterFile::create(&request, &lock_path).ok();
+            Ok(false) => {}
+            Err(e) => {
+                return Err(LifecycleError::StatePersist(format!(
+                    "lifecycle lock acquire io error at {}: {e}",
+                    lock_path.display()
+                )));
             }
-            if let Some(waiter) = waiter.as_ref() {
-                let _ = waiter.write(&request, elapsed);
-            }
-            if !long_event_written && elapsed >= held_long {
-                let _ =
-                    write_lock_held_long_event(&request, &lock_path, elapsed, held_long, timeout);
-                long_event_written = true;
-            }
-            if elapsed >= timeout {
-                return Err(lock_timeout_error(&request, &lock_path, elapsed));
-            }
-            std::thread::sleep(std::cmp::min(
-                Duration::from_millis(50),
-                timeout.saturating_sub(elapsed),
-            ));
         }
-    }
-    #[cfg(not(unix))]
-    {
-        let _ = file;
         let elapsed = started.elapsed();
-        Err(lock_timeout_error(&request, &lock_path, elapsed))
+        if waiter.is_none() {
+            waiter = WaiterFile::create(&request, &lock_path).ok();
+        }
+        if let Some(waiter) = waiter.as_ref() {
+            let _ = waiter.write(&request, elapsed);
+        }
+        if !long_event_written && elapsed >= held_long {
+            let _ = write_lock_held_long_event(&request, &lock_path, elapsed, held_long, timeout);
+            long_event_written = true;
+        }
+        if elapsed >= timeout {
+            return Err(lock_timeout_error(&request, &lock_path, elapsed));
+        }
+        std::thread::sleep(std::cmp::min(
+            Duration::from_millis(50),
+            timeout.saturating_sub(elapsed),
+        ));
     }
 }
 
@@ -293,10 +299,11 @@ impl Drop for WaiterFile {
     }
 }
 
-#[cfg(unix)]
 impl Drop for LifecycleLockGuard {
     fn drop(&mut self) {
-        use std::os::unix::io::AsRawFd;
-        unsafe { libc::flock(self.file.as_raw_fd(), libc::LOCK_UN) };
+        // Batch 2: unlock via platform primitive. Best-effort — OS
+        // releases when the file handle closes anyway. Uniform on
+        // both `flock(LOCK_UN)` (unix) and `UnlockFileEx` (windows).
+        let _ = crate::platform::file_lock::unlock(&self.file);
     }
 }

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

@@ -256,7 +256,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,
@@ -559,25 +573,17 @@ pub(super) fn drain_old_pane_and_pid(
     })
 }
 
-/// Best-effort liveness probe for a pid. Returns true if the pid exists
-/// on Unix (signal 0). On other platforms, returns true conservatively.
+/// Best-effort liveness probe for a pid.
+///
+/// 0.5.x Windows portability Batch 3: routes through
+/// `crate::platform::process::pid_is_alive`. Unix uses `kill(pid, 0)`
+/// with the `EPERM = Live` branch preserved byte-for-byte; Windows
+/// uses `OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION)` +
+/// `GetExitCodeProcess` (STILL_ACTIVE = Live). The legacy non-Unix
+/// `true` fallback (which broke drain by reporting every pid alive)
+/// is gone.
 pub(super) fn pid_is_alive(pid: u32) -> bool {
-    #[cfg(unix)]
-    {
-        // SAFETY: kill(pid, 0) checks if pid exists without sending a signal.
-        let ret = unsafe { libc::kill(pid as i32, 0) };
-        if ret == 0 {
-            return true;
-        }
-        // EPERM also means the process exists (we just can't signal it).
-        let err = std::io::Error::last_os_error();
-        matches!(err.raw_os_error(), Some(libc::EPERM))
-    }
-    #[cfg(not(unix))]
-    {
-        let _ = pid;
-        true
-    }
+    crate::platform::process::pid_is_alive(pid)
 }
 
 /// Read state.agents[agent_id].pane_pid (u32) from the runtime state.

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()),
+                            );
+                        }
+                    }
                 }
             }
         }

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

@@ -67,7 +67,11 @@ pub fn classify_first_send_at(raw: &serde_json::Value) -> FirstSendAtState {
 ///   * lifecycle/restart/common.rs::restart_required_missing_session_agent_ids
 pub(crate) fn restart_agent_has_context_to_preserve(agent: &serde_json::Value) -> bool {
     let has_valid_first_send_at = matches!(
-        classify_first_send_at(agent.get("first_send_at").unwrap_or(&serde_json::Value::Null)),
+        classify_first_send_at(
+            agent
+                .get("first_send_at")
+                .unwrap_or(&serde_json::Value::Null)
+        ),
         FirstSendAtState::Valid
     );
     if has_valid_first_send_at {
@@ -242,6 +246,7 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
         let provider = agent_provider(agent);
         let provider_wire = provider_wire(provider);
         let provider_can_resume = provider_supports_resume(provider);
+        let rollout_path = agent_rollout_path(agent);
         // Layer 2 self-healing (leader follow-up 2026-06-22): use the
         // structured probe so we can carry the list of paths the runtime
         // actually checked into the refusal — operators need to see WHICH
@@ -256,16 +261,15 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
                         agent,
                         provider,
                         session,
-                        agent_rollout_path(agent).as_ref(),
+                        rollout_path.as_ref(),
                     );
                     (probe.exists, probe.checked_paths)
                 }
                 (None, Some(_), true) if resumable_provider_requires_backing(provider_wire) => {
-                    let path_opt = agent_rollout_path(agent);
-                    let exists = path_opt
+                    let exists = rollout_path
                         .as_ref()
                         .is_some_and(|path| path.as_path().exists());
-                    let checked = path_opt
+                    let checked = rollout_path
                         .as_ref()
                         .map(|p| vec![p.as_path().to_path_buf()])
                         .unwrap_or_default();
@@ -273,6 +277,12 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
                 }
                 _ => (true, Vec::new()),
             };
+        let identity_probe =
+            session_identity_probe_for_agent(&agent_id, provider, rollout_path.as_ref());
+        let session_identity_mismatch = session_id.is_some()
+            && provider_can_resume
+            && resume_backing_exists
+            && identity_probe.identity_ok == Some(false);
         // 0.4.7 partial-resume + RESTART-RESUME-001 (0.4.8): when a worker
         // has NEVER been captured (no session_id AND no context-bearing
         // signal at all), it is structurally non-resumable — there is no
@@ -292,7 +302,11 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
         let _ = first_send_at_state; // retained for the Corrupt branch above
         let never_captured =
             restart_agent_never_captured(agent, session_id.as_ref().map(|s| s.as_str()));
-        let decision = if session_id.is_some() && provider_can_resume && resume_backing_exists {
+        let decision = if session_id.is_some()
+            && provider_can_resume
+            && resume_backing_exists
+            && !session_identity_mismatch
+        {
             ResumeDecision::Resume
         } else if session_id.is_some() && allow_fresh {
             ResumeDecision::FreshStart
@@ -313,7 +327,24 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
             // (round-tripped through ResumeRefusalReason::wire) so the
             // CLI/JSON contract does not change.
             let (reason_str, structured) = if session_id.is_some() {
-                if !provider_can_resume {
+                if session_identity_mismatch {
+                    let session = session_id
+                        .as_ref()
+                        .map(|session| session.as_str().to_string())
+                        .unwrap_or_default();
+                    (
+                        "session_identity_mismatch".to_string(),
+                        crate::provider::session::ResumeRefusalReason::SessionIdentityMismatch {
+                            expected_agent_id: agent_id.as_str().to_string(),
+                            embedded_agent_id: identity_probe
+                                .embedded_agent_id
+                                .clone()
+                                .unwrap_or_default(),
+                            session_id: session,
+                            rollout_path: identity_probe.rollout_path.clone(),
+                        },
+                    )
+                } else if !provider_can_resume {
                     (
                         "session_unresumable".to_string(),
                         crate::provider::session::ResumeRefusalReason::ProviderResumeUnsupported {
@@ -330,17 +361,15 @@ pub(crate) fn classify_restart_plan_with_resume_validation(
                     // a recovery hint pointing at the agent_id (used as
                     // launch-time `--name`) and spawn_cwd. Operator-facing
                     // diagnostic only — no auto-resume off the hint.
-                    let recovery_hint = Some(
-                        crate::provider::session::RecoveryHint {
-                            provider_session_name_hint: Some(agent_id.as_str().to_string()),
-                            spawn_cwd: agent
-                                .get("spawn_cwd")
-                                .and_then(|v| v.as_str())
-                                .filter(|s| !s.is_empty())
-                                .map(std::path::PathBuf::from),
-                            provider: provider_wire.to_string(),
-                        },
-                    );
+                    let recovery_hint = Some(crate::provider::session::RecoveryHint {
+                        provider_session_name_hint: Some(agent_id.as_str().to_string()),
+                        spawn_cwd: agent
+                            .get("spawn_cwd")
+                            .and_then(|v| v.as_str())
+                            .filter(|s| !s.is_empty())
+                            .map(std::path::PathBuf::from),
+                        provider: provider_wire.to_string(),
+                    });
                     (
                         "session_unresumable".to_string(),
                         crate::provider::session::ResumeRefusalReason::SessionBackingStoreMissing {

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

@@ -1,7 +1,7 @@
 //! lifecycle::restart —— 单 worker 起/停/重置/删 + 整队 Route B 重建 + plan halt/status。
 
-use std::path::Path;
 use std::collections::BTreeMap;
+use std::path::Path;
 
 use crate::model::enums::{AuthMode, Provider};
 use crate::model::ids::AgentId;
@@ -32,22 +32,28 @@ mod remove;
 mod selection;
 mod team_state;
 
-pub use agent::{reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent, stop_agent_with_transport};
 pub(crate) use agent::start_agent_at_paths;
+pub use agent::{
+    reset_agent, reset_agent_with_transport, start_agent, start_agent_with_transport, stop_agent,
+    stop_agent_with_transport,
+};
 pub(crate) use common::refresh_missing_provider_sessions;
 pub(crate) use common::restart_required_missing_session_agent_ids;
+pub(crate) use common::session_identity_probe_for_agent;
 // 0.3.24 add-agent socket drift fix: state-aware tmux resolver shared with
 // `lifecycle::launch::add_agent` / `fork_agent` so all three (restart / add / fork)
 // route to the SAME tmux socket the live team uses.
 pub(crate) use common::lifecycle_worker_tmux_backend_for_selected_state;
 pub use orchestrator::{halt_plan, plan_status};
+pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline;
 pub use rebuild::{
     restart, restart_candidates, restart_with_session_convergence_deadline, restart_with_transport,
     restart_with_transport_with_readiness_deadline, select_restart_state,
 };
-pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline;
 pub use remove::{remove_agent, remove_agent_with_transport};
-pub use selection::{classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name};
+pub use selection::{
+    classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name,
+};
 // Layer 2 (leader follow-up 2026-06-22): test-visible workspace-aware
 // classification so lifecycle/tests/restart.rs can exercise the
 // SessionBackingStoreMissing + checked_paths + RecoveryHint path
@@ -55,7 +61,9 @@ pub use selection::{classify_first_send_at, classify_restart_plan, decide_start_
 pub(crate) use selection::classify_restart_plan_with_resume_validation;
 pub(crate) use team_state::write_team_state;
 
-pub(crate) fn lifecycle_run_workspace(workspace: &Path) -> Result<std::path::PathBuf, LifecycleError> {
+pub(crate) fn lifecycle_run_workspace(
+    workspace: &Path,
+) -> Result<std::path::PathBuf, LifecycleError> {
     crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| LifecycleError::StatePersist(e.to_string()))
 }
@@ -93,7 +101,9 @@ fn lifecycle_paths(workspace: &Path, team: Option<&str>) -> Result<LifecyclePath
         .spec_workspace
         .clone()
         .or_else(|| selected_state_spec_workspace(&selected.state))
-        .ok_or_else(|| LifecycleError::TeamSelect("active team spec workspace not found".to_string()))?;
+        .ok_or_else(|| {
+            LifecycleError::TeamSelect("active team spec workspace not found".to_string())
+        })?;
     Ok(LifecyclePaths {
         run_workspace: selected.run_workspace,
         spec_workspace,

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

@@ -287,6 +287,7 @@ impl Drop for EnvVarGuard {
     }
 }
 
+#[cfg(unix)]
 struct TmuxShim {
     log: std::path::PathBuf,
     _path: EnvVarGuard,
@@ -297,6 +298,7 @@ struct TmuxShim {
     _real_tmux: EnvVarGuard,
 }
 
+#[cfg(unix)]
 fn install_e27_tmux_shim(expected_endpoint: &str, session_name: &str) -> TmuxShim {
     use std::os::unix::fs::PermissionsExt;
 
@@ -441,6 +443,9 @@ fn assert_only_expected_socket_used(log: &std::path::Path, expected_endpoint: &s
     }
 }
 
+// 0.5.x Windows portability Batch 5: E27 tests use a shell-script
+// tmux shim + Unix socket paths. Unix-only.
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_stop_agent_uses_attached_explicit_state_socket() {
@@ -461,6 +466,7 @@ fn e27_stop_agent_uses_attached_explicit_state_socket() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_reset_agent_uses_attached_explicit_state_socket_for_stop_and_spawn() {
@@ -491,6 +497,7 @@ fn e27_reset_agent_uses_attached_explicit_state_socket_for_stop_and_spawn() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_stop_agent_expands_short_state_socket_name() {