@team-agent/installer 0.5.3 → 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

@@ -234,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,

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

@@ -17,6 +17,7 @@ use super::StateError;
 use crate::state::persist::{
     load_runtime_state, save_runtime_state_with_deleted_agents,
     save_runtime_state_with_lifecycle_topology_authority,
+    save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip,
     save_runtime_state_with_team_tombstone_lifecycle_topology_authority,
     save_runtime_state_with_team_tombstoned_agents,
 };
@@ -595,7 +596,7 @@ pub(crate) fn save_team_scoped_state_with_tombstone_lifecycle_topology_authority
     team_state: &Value,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], agent_ids, agent_ids)
+    save_team_scoped_state_with_merge_options(workspace, team_state, &[], agent_ids, &[], agent_ids)
 }
 
 pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority(
@@ -603,7 +604,23 @@ pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority(
     team_state: &Value,
     agent_ids: &[&str],
 ) -> Result<(), StateError> {
-    save_team_scoped_state_with_merge_options(workspace, team_state, &[], &[], agent_ids)
+    save_team_scoped_state_with_merge_options(workspace, team_state, &[], &[], &[], agent_ids)
+}
+
+pub(crate) fn save_team_scoped_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+    workspace: &Path,
+    team_state: &Value,
+    skip_capture_backfill_agent_ids: &[&str],
+    topology_agent_ids: &[&str],
+) -> Result<(), StateError> {
+    save_team_scoped_state_with_merge_options(
+        workspace,
+        team_state,
+        &[],
+        &[],
+        skip_capture_backfill_agent_ids,
+        topology_agent_ids,
+    )
 }
 
 fn save_team_scoped_state_with_merge_exceptions(
@@ -618,6 +635,7 @@ fn save_team_scoped_state_with_merge_exceptions(
         deleted_agent_ids,
         tombstoned_agent_ids,
         &[],
+        &[],
     )
 }
 
@@ -626,6 +644,7 @@ fn save_team_scoped_state_with_merge_options(
     team_state: &Value,
     deleted_agent_ids: &[&str],
     tombstoned_agent_ids: &[&str],
+    skip_capture_backfill_agent_ids: &[&str],
     topology_agent_ids: &[&str],
 ) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
@@ -669,12 +688,30 @@ fn save_team_scoped_state_with_merge_options(
                     topology_agent_ids,
                 );
             }
+            if !skip_capture_backfill_agent_ids.is_empty() {
+                return save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                    workspace,
+                    &merged,
+                    &target_key,
+                    skip_capture_backfill_agent_ids,
+                    topology_agent_ids,
+                );
+            }
             return save_runtime_state_with_lifecycle_topology_authority(
                 workspace,
                 &merged,
                 topology_agent_ids,
             );
         }
+        if !skip_capture_backfill_agent_ids.is_empty() {
+            return save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                workspace,
+                &merged,
+                &target_key,
+                skip_capture_backfill_agent_ids,
+                &[],
+            );
+        }
         if tombstoned_agent_ids.is_empty() {
             return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
         }
@@ -709,10 +746,28 @@ fn save_team_scoped_state_with_merge_options(
     }
     if tombstoned_agent_ids.is_empty() {
         if !topology_agent_ids.is_empty() {
-            save_runtime_state_with_lifecycle_topology_authority(
+            if !skip_capture_backfill_agent_ids.is_empty() {
+                save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
+                    workspace,
+                    &Value::Object(merged),
+                    &target_key,
+                    skip_capture_backfill_agent_ids,
+                    topology_agent_ids,
+                )
+            } else {
+                save_runtime_state_with_lifecycle_topology_authority(
+                    workspace,
+                    &Value::Object(merged),
+                    topology_agent_ids,
+                )
+            }
+        } else if !skip_capture_backfill_agent_ids.is_empty() {
+            save_runtime_state_with_lifecycle_topology_authority_and_capture_backfill_skip(
                 workspace,
                 &Value::Object(merged),
-                topology_agent_ids,
+                &target_key,
+                skip_capture_backfill_agent_ids,
+                &[],
             )
         } else {
             save_runtime_state_with_deleted_agents(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.3",
-    "@team-agent/cli-darwin-x64": "0.5.3",
-    "@team-agent/cli-linux-x64": "0.5.3"
+    "@team-agent/cli-darwin-arm64": "0.5.4",
+    "@team-agent/cli-darwin-x64": "0.5.4",
+    "@team-agent/cli-linux-x64": "0.5.4"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",