@team-agent/installer 0.5.2 → 0.5.4

package/crates/team-agent/src/provider/session/resume.rs

@@ -95,9 +95,14 @@ pub enum ResumeRefusalReason {
     SessionCaptureIncomplete,
     /// State session_id differs from the provider's observed session
     /// (T6 L5.5 drift). Caller should reconcile before resuming.
-    SessionDrift {
-        expected: String,
-        actual: String,
+    SessionDrift { expected: String, actual: String },
+    /// The persisted provider backing exists, but the transcript itself
+    /// declares a different Team Agent worker identity.
+    SessionIdentityMismatch {
+        expected_agent_id: String,
+        embedded_agent_id: String,
+        session_id: String,
+        rollout_path: Option<PathBuf>,
     },
     /// Catch-all for refusals the structured shape hasn't taxonomized
     /// yet. Carries the legacy free-form string. This variant exists so
@@ -118,11 +123,10 @@ impl ResumeRefusalReason {
             ResumeRefusalReason::SessionBackingStoreMissing { .. } => {
                 "session_backing_store_missing"
             }
-            ResumeRefusalReason::ProviderResumeUnsupported { .. } => {
-                "provider_resume_unsupported"
-            }
+            ResumeRefusalReason::ProviderResumeUnsupported { .. } => "provider_resume_unsupported",
             ResumeRefusalReason::SessionCaptureIncomplete => "session_capture_incomplete",
             ResumeRefusalReason::SessionDrift { .. } => "session_drift",
+            ResumeRefusalReason::SessionIdentityMismatch { .. } => "session_identity_mismatch",
             // For Other we still report the legacy wire so the existing
             // `session_unresumable` JSON shape is preserved end-to-end.
             ResumeRefusalReason::Other { .. } => "session_unresumable",
@@ -134,16 +138,20 @@ impl ResumeRefusalReason {
     pub fn from_legacy(reason: &str) -> Self {
         match reason {
             "no_persisted_session_id" => ResumeRefusalReason::NoSessionId,
-            "session_backing_store_missing" => {
-                ResumeRefusalReason::SessionBackingStoreMissing {
-                    checked_paths: Vec::new(),
-                    recovery_hint: None,
-                }
-            }
+            "session_backing_store_missing" => ResumeRefusalReason::SessionBackingStoreMissing {
+                checked_paths: Vec::new(),
+                recovery_hint: None,
+            },
             "provider_resume_unsupported" => ResumeRefusalReason::ProviderResumeUnsupported {
                 provider: String::new(),
             },
             "session_capture_incomplete" => ResumeRefusalReason::SessionCaptureIncomplete,
+            "session_identity_mismatch" => ResumeRefusalReason::SessionIdentityMismatch {
+                expected_agent_id: String::new(),
+                embedded_agent_id: String::new(),
+                session_id: String::new(),
+                rollout_path: None,
+            },
             other => ResumeRefusalReason::Other {
                 legacy_reason: other.to_string(),
             },
@@ -155,15 +163,11 @@ impl ResumeRefusalReason {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ResumePreflightOutcome {
     /// Worker can resume from the named session.
-    Resume {
-        session_id: String,
-    },
+    Resume { session_id: String },
     /// `--allow-fresh` was set; worker will start fresh.
     FreshStart,
     /// Resume refused. Caller MUST NOT proceed with teardown/spawn.
-    Refuse {
-        reason: ResumeRefusalReason,
-    },
+    Refuse { reason: ResumeRefusalReason },
 }
 
 /// Information about whether a provider backing file is present on disk.
@@ -239,9 +243,7 @@ impl ResumePreflight {
                 } else {
                     ResumePreflightOutcome::Refuse {
                         reason: ResumeRefusalReason::SessionBackingStoreMissing {
-                            checked_paths: backing
-                                .map(|b| b.paths.clone())
-                                .unwrap_or_default(),
+                            checked_paths: backing.map(|b| b.paths.clone()).unwrap_or_default(),
                             recovery_hint,
                         },
                     }
@@ -272,6 +274,7 @@ mod tests {
             "session_backing_store_missing",
             "provider_resume_unsupported",
             "session_capture_incomplete",
+            "session_identity_mismatch",
         ] {
             assert_eq!(ResumeRefusalReason::from_legacy(wire).wire(), wire);
         }
@@ -383,10 +386,11 @@ mod tests {
         );
         match out {
             ResumePreflightOutcome::Refuse {
-                reason: ResumeRefusalReason::SessionBackingStoreMissing {
-                    recovery_hint: Some(h),
-                    ..
-                },
+                reason:
+                    ResumeRefusalReason::SessionBackingStoreMissing {
+                        recovery_hint: Some(h),
+                        ..
+                    },
             } => {
                 assert_eq!(h, hint);
             }
@@ -405,9 +409,7 @@ mod tests {
         let out = ResumePreflight::check(Some("sess-x"), true, Some(&backing), "codex", false);
         match out {
             ResumePreflightOutcome::Refuse {
-                reason: ResumeRefusalReason::SessionBackingStoreMissing {
-                    recovery_hint, ..
-                },
+                reason: ResumeRefusalReason::SessionBackingStoreMissing { recovery_hint, .. },
             } => {
                 assert!(recovery_hint.is_none());
             }

package/crates/team-agent/src/provider/session_scan/common.rs

@@ -98,7 +98,15 @@ pub(super) fn parse_candidate_files(
         } else {
             Confidence::Low
         };
-        let positive_agent_id_match = candidate_text_has_team_agent_id(&text, context);
+        let embedded_agent_id = embedded_team_agent_worker_id_from_text(&text);
+        if embedded_agent_id
+            .as_deref()
+            .is_some_and(|id| id != context.agent_id.as_str())
+        {
+            continue;
+        }
+        let positive_agent_id_match = candidate_text_has_team_agent_id(&text, context)
+            || embedded_agent_id.as_deref() == Some(context.agent_id.as_str());
         let agent_path_match = candidate_path_matches_agent_id(&path, context);
         if matches!(provider, Provider::Claude | Provider::ClaudeCode)
             && super::claude::records_have_leader_marker(&records)
@@ -113,6 +121,7 @@ pub(super) fn parse_candidate_files(
                 attribution_confidence,
                 spawn_cwd: context.spawn_cwd.clone(),
             },
+            embedded_agent_id,
             positive_agent_id_match,
             agent_path_match,
         });
@@ -308,6 +317,28 @@ fn candidate_text_has_team_agent_id(text: &str, context: &CaptureSessionContext)
     .any(|needle| text.contains(needle))
 }
 
+pub(crate) fn embedded_team_agent_worker_id_from_text(text: &str) -> Option<String> {
+    const PREFIX: &str = "You are Team Agent worker `";
+    let start = text.find(PREFIX)? + PREFIX.len();
+    let rest = &text[start..];
+    let end = rest.find('`')?;
+    let id = &rest[..end];
+    if id.is_empty()
+        || !id
+            .chars()
+            .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '_' | '-' | '.'))
+    {
+        return None;
+    }
+    Some(id.to_string())
+}
+
+pub(crate) fn rollout_path_embedded_team_agent_worker_id(path: &Path) -> Option<String> {
+    read_head_text(path, CAPTURE_HEAD_BYTES)
+        .ok()
+        .and_then(|text| embedded_team_agent_worker_id_from_text(&text))
+}
+
 fn candidate_path_matches_agent_id(path: &Path, context: &CaptureSessionContext) -> bool {
     let id = context.agent_id.as_str();
     if id.is_empty() {
@@ -348,3 +379,88 @@ fn path_is_under_team_runtime(path: &Path) -> bool {
     path.components()
         .any(|c| c.as_os_str() == std::ffi::OsStr::new(".team"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn temp_dir(name: &str) -> PathBuf {
+        static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+        let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let dir =
+            std::env::temp_dir().join(format!("ta-session-scan-{name}-{}-{n}", std::process::id()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn write_codex_rollout(path: &Path, cwd: &Path, session_id: &str, embedded_agent_id: &str) {
+        let text = format!(
+            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\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",
+            cwd.to_string_lossy()
+        );
+        std::fs::write(path, text).expect("write codex rollout");
+    }
+
+    #[test]
+    fn codex_prompt_worker_identity_is_a_positive_match() {
+        let dir = temp_dir("positive");
+        let rollout = dir.join("rollout-frontend.jsonl");
+        write_codex_rollout(&rollout, &dir, "sess-frontend", "frontend");
+        let context = CaptureSessionContext {
+            agent_id: "frontend".to_string(),
+            spawn_cwd: dir.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        let candidates = parse_candidate_files(
+            Provider::Codex,
+            &context,
+            vec![SessionCandidate {
+                path: rollout.clone(),
+                requires_cwd_match: false,
+            }],
+        );
+        assert_eq!(candidates.len(), 1);
+        assert!(
+            candidates[0].positive_agent_id_match,
+            "Codex transcript prompt identity must be treated as a positive worker id source"
+        );
+        let _ = std::fs::remove_file(&rollout);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn codex_prompt_worker_identity_mismatch_is_rejected_for_that_agent() {
+        let dir = temp_dir("mismatch");
+        let rollout = dir.join("rollout-ios-dev.jsonl");
+        write_codex_rollout(&rollout, &dir, "sess-ios-dev", "ios-dev");
+        let context = CaptureSessionContext {
+            agent_id: "frontend".to_string(),
+            spawn_cwd: dir.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        let candidates = parse_candidate_files(
+            Provider::Codex,
+            &context,
+            vec![SessionCandidate {
+                path: rollout.clone(),
+                requires_cwd_match: false,
+            }],
+        );
+        assert!(
+            candidates.is_empty(),
+            "state agent=frontend must not accept a Codex rollout whose prompt says ios-dev"
+        );
+        let _ = std::fs::remove_file(&rollout);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

package/crates/team-agent/src/provider/session_scan/copilot.rs

@@ -48,6 +48,7 @@ fn copilot_candidate(
             attribution_confidence: Confidence::High,
             spawn_cwd: context.spawn_cwd.clone(),
         },
+        embedded_agent_id: None,
         positive_agent_id_match: false,
         agent_path_match: false,
     }

package/crates/team-agent/src/provider/session_scan.rs

@@ -49,6 +49,7 @@ pub struct CaptureSessionContext {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CapturedSessionCandidate {
     pub captured: CapturedSession,
+    pub embedded_agent_id: Option<String>,
     pub positive_agent_id_match: bool,
     pub agent_path_match: bool,
 }

package/crates/team-agent/src/state/persist.rs

@@ -146,7 +146,14 @@ fn errno_name(errno: Option<i32>) -> Option<&'static str> {
 }
 
 /// `runtime.py:_runtime_lock` 的 flock 版(RAII;Drop 释放)。state-save 不发锁事件。
-/// POSIX flock(unix);Windows 锁(LockFileEx)延平台层(step 9+)。
+///
+/// 0.5.x Windows portability Batch 2: migrated to
+/// `crate::platform::file_lock::{try_lock_once_nonblocking, unlock}` so
+/// the same polling loop + timeout + `StateError::Locked(name)` shape
+/// works on both Unix (`flock`) and Windows (`LockFileEx`) — 1:1
+/// semantic mapping. The Batch 0 non-Unix `not_yet_implemented`
+/// fallback is now removed (CR C-2 fallback burn-down; grep guard
+/// `platform_fallback_burndown_batch0.rs` flipped in this batch).
 struct RuntimeLock {
     #[allow(dead_code)]
     file: std::fs::File,
@@ -160,42 +167,37 @@ impl RuntimeLock {
         }
         let file = std::fs::OpenOptions::new()
             .create(true)
+            .read(true)
             .write(true)
             .truncate(false)
             .open(&lock_path)?;
-        #[cfg(unix)]
-        {
-            use std::os::unix::io::AsRawFd;
-            let fd = file.as_raw_fd();
-            let start = Instant::now();
-            loop {
-                // SAFETY: fd 来自打开的 lock_file,LOCK_EX|LOCK_NB 非阻塞。
-                let rc = unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) };
-                if rc == 0 {
-                    return Ok(Self { file });
+        let start = Instant::now();
+        loop {
+            match crate::platform::file_lock::try_lock_once_nonblocking(&file) {
+                Ok(true) => return Ok(Self { file }),
+                Ok(false) => {
+                    if start.elapsed().as_secs_f64() >= timeout {
+                        return Err(StateError::Locked(name.to_string()));
+                    }
+                    std::thread::sleep(Duration::from_millis(50));
                 }
-                if start.elapsed().as_secs_f64() >= timeout {
-                    return Err(StateError::Locked(name.to_string()));
+                Err(e) => {
+                    // Byte-preserving: a real I/O error surfaces as a
+                    // `StateError::Io` (via `From<io::Error>`), same as
+                    // the current inline code would if `file.open()`
+                    // failed. The lock-would-block case took the
+                    // Ok(false) arm above.
+                    return Err(StateError::from(e));
                 }
-                std::thread::sleep(Duration::from_millis(50));
             }
         }
-        #[cfg(not(unix))]
-        {
-            let _ = timeout;
-            Err(StateError::Locked(format!(
-                "{name} (runtime lock not yet implemented on non-unix)"
-            )))
-        }
     }
 }
 
-#[cfg(unix)]
 impl Drop for RuntimeLock {
     fn drop(&mut self) {
-        use std::os::unix::io::AsRawFd;
-        // SAFETY: 释放本进程持有的 flock。
-        unsafe { libc::flock(self.file.as_raw_fd(), libc::LOCK_UN) };
+        // Best-effort unlock. OS releases on handle close if this fails.
+        let _ = crate::platform::file_lock::unlock(&self.file);
     }
 }
 
@@ -232,6 +234,23 @@ pub(crate) fn save_runtime_state_with_lifecycle_topology_authority(
     save_runtime_state_with_merge_options(workspace, state, &[], None, &[], agent_ids)
 }
 
+pub(crate) fn save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+    workspace: &Path,
+    state: &Value,
+    skip_capture_backfill_team_key: &str,
+    skip_capture_backfill_agent_ids: &[&str],
+    topology_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_runtime_state_with_merge_options(
+        workspace,
+        state,
+        &[],
+        Some(skip_capture_backfill_team_key),
+        skip_capture_backfill_agent_ids,
+        topology_agent_ids,
+    )
+}
+
 pub(crate) fn save_runtime_state_with_deleted_agents(
     workspace: &Path,
     state: &Value,
@@ -451,6 +470,18 @@ fn apply_persist_merge_contract(
         // teams.<key> entry-scoped preservation at :370 remains so legacy
         // teams.<key>.team_owner entries still survive a save that omits
         // them.
+
+        // 0.5.x Windows portability Batch 7 F6 (leader msg_700a016675d0):
+        // preserve `state.transport.shim` across saves. The coordinator
+        // writes this block when it spawns `windows-shim.exe` during
+        // quick-start (see `coordinator::conpty_shim::finalize`).
+        // Downstream saves inside the same quick-start (leader-persist,
+        // worker-persist) construct their `incoming` state from an
+        // in-memory copy that predates the shim-spawn, so without this
+        // preserve step the shim block is silently dropped. That
+        // clobber broke Batch 6 CHECK 6 (`shutdown` couldn't route to
+        // the shim pid because `state.transport.shim.pid` was gone).
+        preserve_transport_shim(incoming, latest);
     }
 
     let latest_teams = latest.get("teams").and_then(Value::as_object);
@@ -478,6 +509,47 @@ fn apply_persist_merge_contract(
     Ok(())
 }
 
+/// 0.5.x Windows portability Batch 7 F6: copy `latest.transport.shim`
+/// into `incoming` if the incoming save omitted it. The coordinator's
+/// `conpty_shim::finalize` writes `state.transport.shim = {pid,
+/// pipe_name, pipe_ready}` after Hello succeeds. If a subsequent save
+/// in the same quick-start starts from a stale in-memory `Value` that
+/// predates the finalize, this preserve step keeps the on-disk shim
+/// block alive.
+///
+/// Only runs when the top-level projection matches (same active team
+/// key + same session name) — no risk of leaking a shim block into
+/// an unrelated projection.
+///
+/// Windows-relevant behavior; on Unix `transport.shim` is never
+/// written, so this fn is a no-op (both branches see `None`).
+fn preserve_transport_shim(incoming: &mut Value, latest: &Value) {
+    // The shim block only matters when `latest` has one AND
+    // `incoming` doesn't (or `incoming.transport` doesn't exist).
+    let Some(latest_shim) = latest
+        .get("transport")
+        .and_then(|t| t.get("shim"))
+        .cloned()
+    else {
+        return;
+    };
+    let Some(incoming_obj) = incoming.as_object_mut() else {
+        return;
+    };
+    let transport = incoming_obj
+        .entry("transport".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    let Some(transport_obj) = transport.as_object_mut() else {
+        return;
+    };
+    // If the incoming already has a shim block, respect it (the
+    // caller has authoritative newer state — e.g. shim was rotated).
+    if transport_obj.contains_key("shim") {
+        return;
+    }
+    transport_obj.insert("shim".to_string(), latest_shim);
+}
+
 fn should_skip_capture_backfill(
     current_team_key: Option<&str>,
     skip_team_key: Option<&str>,
@@ -1696,6 +1768,131 @@ mod tests {
         );
     }
 
+    // 0.5.x Windows portability Batch 7 F6 (leader msg_700a016675d0):
+    // `state.transport.shim` must survive a downstream save whose
+    // `incoming` was constructed from a stale in-memory Value.
+    #[test]
+    fn transport_shim_block_is_preserved_across_merge() {
+        let ws = temp_ws();
+        // Disk state has the shim block (coordinator wrote it after
+        // Hello succeeded).
+        write_state(
+            &ws,
+            &json!({
+                "session_name": "team-a",
+                "active_team_key": "team-a",
+                "agents": {},
+                "transport": {
+                    "kind": "conpty",
+                    "shim": { "pid": 4242, "pipe_name": r"\\.\pipe\team-agent-conpty-abc-team-a", "pipe_ready": true }
+                }
+            }),
+        );
+        // Incoming save (leader-persist or worker-persist) doesn't
+        // know about the shim block.
+        let incoming = json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {},
+            "transport": {
+                "kind": "conpty"
+            }
+        });
+        save_runtime_state(&ws, &incoming).unwrap();
+        let saved = read_state(&ws);
+        // Shim block must survive the merge.
+        assert_eq!(
+            saved.pointer("/transport/shim/pid").and_then(Value::as_u64),
+            Some(4242),
+            "shim.pid must be preserved: {saved}"
+        );
+        assert_eq!(
+            saved
+                .pointer("/transport/shim/pipe_name")
+                .and_then(Value::as_str),
+            Some(r"\\.\pipe\team-agent-conpty-abc-team-a"),
+        );
+        assert_eq!(
+            saved
+                .pointer("/transport/shim/pipe_ready")
+                .and_then(Value::as_bool),
+            Some(true),
+        );
+        // And the incoming's `transport.kind` still wins.
+        assert_eq!(
+            saved.pointer("/transport/kind").and_then(Value::as_str),
+            Some("conpty"),
+        );
+    }
+
+    #[test]
+    fn transport_shim_incoming_authoritative_overrides_latest() {
+        // If the caller has a NEWER shim block (e.g. rotation), it
+        // wins — preserve_transport_shim only fills in the gap.
+        let ws = temp_ws();
+        write_state(
+            &ws,
+            &json!({
+                "session_name": "team-a",
+                "active_team_key": "team-a",
+                "agents": {},
+                "transport": {
+                    "kind": "conpty",
+                    "shim": { "pid": 1000, "pipe_name": "old", "pipe_ready": true }
+                }
+            }),
+        );
+        let incoming = json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {},
+            "transport": {
+                "kind": "conpty",
+                "shim": { "pid": 9999, "pipe_name": "new", "pipe_ready": true }
+            }
+        });
+        save_runtime_state(&ws, &incoming).unwrap();
+        let saved = read_state(&ws);
+        assert_eq!(
+            saved.pointer("/transport/shim/pid").and_then(Value::as_u64),
+            Some(9999),
+            "incoming shim block must win when both sides have one"
+        );
+        assert_eq!(
+            saved
+                .pointer("/transport/shim/pipe_name")
+                .and_then(Value::as_str),
+            Some("new"),
+        );
+    }
+
+    #[test]
+    fn transport_shim_no_leak_when_latest_lacks_block() {
+        // If disk has no shim block, save must not synthesize one.
+        let ws = temp_ws();
+        write_state(
+            &ws,
+            &json!({
+                "session_name": "team-a",
+                "active_team_key": "team-a",
+                "agents": {},
+                "transport": {"kind": "tmux"}
+            }),
+        );
+        let incoming = json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {},
+            "transport": {"kind": "tmux"}
+        });
+        save_runtime_state(&ws, &incoming).unwrap();
+        let saved = read_state(&ws);
+        assert!(
+            saved.pointer("/transport/shim").is_none(),
+            "shim must not appear when neither side had one: {saved}"
+        );
+    }
+
     #[test]
     fn projection_paths_do_not_cross_backfill_topology() {
         let ws = temp_ws();