@team-agent/installer 0.5.52 → 0.5.54

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

@@ -1,37 +1,47 @@
-use super::{CaptureSessionContext, CapturedSessionCandidate};
+pub(super) fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
+    chrono::DateTime::parse_from_rfc3339(raw)
+        .ok()
+        .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
+}
 
-pub(super) fn apply_spawned_at_filter(
-    out: &mut Vec<CapturedSessionCandidate>,
-    context: &CaptureSessionContext,
+pub(super) fn rollout_created_at(path: &std::path::Path) -> Option<std::time::SystemTime> {
+    created_at_from_rollout_uuid(path)
+        .or_else(|| created_at_from_rollout_head(path))
+        .or_else(|| created_at_from_rollout_filename(path))
+}
+
+pub(super) fn retain_spawn_cwd(
+    context: &super::CaptureSessionContext,
+    out: &mut Vec<super::CapturedSessionCandidate>,
 ) {
-    let Some(spawned_at) = context.spawned_at.as_deref().and_then(parse_spawned_at) else {
-        return;
-    };
-    let grace = std::time::Duration::from_secs(5);
-    let cutoff = spawned_at.checked_sub(grace).unwrap_or(spawned_at);
     out.retain(|candidate| {
-        let path = match candidate.captured.rollout_path.as_ref() {
-            Some(p) => p.as_path(),
-            None => return false,
+        let Some(path) = candidate.captured.rollout_path.as_ref() else {
+            return false;
         };
-        match codex_rollout_created_at(path) {
-            Some(created_at) => created_at >= cutoff,
-            None => std::fs::metadata(path)
-                .and_then(|meta| meta.modified())
-                .map(|mtime| mtime >= cutoff)
-                .unwrap_or(false),
-        }
+        let Ok(text) =
+            super::common::read_head_text(path.as_path(), super::common::CAPTURE_HEAD_BYTES)
+        else {
+            return false;
+        };
+        super::common::parse_session_records(&text)
+            .iter()
+            .filter_map(super::common::record_cwd)
+            .any(|cwd| {
+                super::common::paths_equivalent(std::path::Path::new(&cwd), &context.spawn_cwd)
+            })
     });
 }
 
-pub(super) fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
-    chrono::DateTime::parse_from_rfc3339(raw)
-        .ok()
-        .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
-}
-
-fn codex_rollout_created_at(path: &std::path::Path) -> Option<std::time::SystemTime> {
-    created_at_from_rollout_head(path).or_else(|| created_at_from_rollout_filename(path))
+fn created_at_from_rollout_uuid(path: &std::path::Path) -> Option<std::time::SystemTime> {
+    let name = path.file_name()?.to_str()?;
+    let stem = name.strip_suffix(".jsonl")?;
+    let uuid = stem.get(stem.len().checked_sub(36)?..)?;
+    if uuid.as_bytes().get(14).copied() != Some(b'7') {
+        return None;
+    }
+    let millis =
+        u64::from_str_radix(&format!("{}{}", uuid.get(..8)?, uuid.get(9..13)?), 16).ok()?;
+    std::time::SystemTime::UNIX_EPOCH.checked_add(std::time::Duration::from_millis(millis))
 }
 
 fn created_at_from_rollout_head(path: &std::path::Path) -> Option<std::time::SystemTime> {
@@ -77,6 +87,10 @@ fn created_at_from_rollout_filename(path: &std::path::Path) -> Option<std::time:
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::provider::session_scan::{common, CaptureSessionContext, CapturedSessionCandidate};
+    use crate::provider::Provider;
+    use crate::provider::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
+    use std::path::PathBuf;
 
     #[test]
     fn parse_spawned_at_rfc3339_roundtrips_and_rejects_junk() {
@@ -84,4 +98,107 @@ mod tests {
         assert!(parse_spawned_at("not-a-date").is_none());
         assert!(parse_spawned_at("").is_none());
     }
+
+    fn candidate(path: PathBuf, session_id: &str) -> CapturedSessionCandidate {
+        CapturedSessionCandidate {
+            captured: CapturedSession {
+                session_id: Some(SessionId::new(session_id)),
+                rollout_path: Some(RolloutPath::new(path)),
+                captured_via: CaptureVia::FsWatch,
+                attribution_confidence: Confidence::High,
+                spawn_cwd: PathBuf::from("/tmp"),
+            },
+            embedded_agent_id: None,
+            positive_agent_id_match: false,
+            agent_path_match: false,
+        }
+    }
+
+    #[test]
+    fn spawned_at_filter_rejects_prior_round_and_accepts_current_rollout() {
+        let dir =
+            std::env::temp_dir().join(format!("ta-codex-spawn-filter-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let stale =
+            dir.join("rollout-2026-07-21T22-45-40-11111111-1111-4111-8111-111111111111.jsonl");
+        let fresh =
+            dir.join("rollout-2026-07-21T23-20-01-22222222-2222-4222-8222-222222222222.jsonl");
+        std::fs::write(&stale, "{}\n").unwrap();
+        std::fs::write(&fresh, "{}\n").unwrap();
+        let context = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: dir.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2026-07-21T23:20:00+00:00".to_string()),
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        let mut out = vec![
+            candidate(stale, "11111111-1111-4111-8111-111111111111"),
+            candidate(fresh.clone(), "22222222-2222-4222-8222-222222222222"),
+        ];
+        common::apply_spawned_at_filter(Provider::Codex, &context, &mut out);
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.rollout_path.as_ref().unwrap().as_path(),
+            fresh
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn spawned_at_filter_fails_closed_with_an_invalid_boundary() {
+        let mut out = vec![candidate(PathBuf::from("/tmp/old.jsonl"), "old")];
+        let mut context = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: PathBuf::from("/tmp"),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        common::apply_spawned_at_filter(Provider::Codex, &context, &mut out);
+        assert_eq!(out.len(), 1, "legacy direct scan has no cohort boundary");
+
+        context.spawned_at = Some("not-a-date".to_string());
+        common::apply_spawned_at_filter(Provider::Codex, &context, &mut out);
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn unique_window_uses_created_at_not_active_sibling_mtime() {
+        let dir =
+            std::env::temp_dir().join(format!("ta-codex-created-window-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let stale =
+            dir.join("rollout-2026-07-22T03-12-13-11111111-1111-4111-8111-111111111111.jsonl");
+        let fresh =
+            dir.join("rollout-2026-07-22T03-15-30-22222222-2222-4222-8222-222222222222.jsonl");
+        std::fs::write(&stale, "{}\n").unwrap();
+        std::fs::write(&fresh, "{}\n").unwrap();
+        let context = CaptureSessionContext {
+            agent_id: "clone".to_string(),
+            spawn_cwd: dir.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2026-07-22T03:15:29+00:00".to_string()),
+            expected_session_id: None,
+            provider_projects_root: None,
+        };
+        let mut out = vec![
+            candidate(stale, "11111111-1111-4111-8111-111111111111"),
+            candidate(fresh.clone(), "22222222-2222-4222-8222-222222222222"),
+        ];
+        common::apply_spawn_time_window_if_unique(Provider::Codex, &context, &mut out);
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.rollout_path.as_ref().unwrap().as_path(),
+            fresh
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
 }

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

@@ -0,0 +1,112 @@
+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);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn codex_identity_in_incomplete_final_head_record_is_positive() {
+    let dir = temp_dir("cross-cap-positive");
+    let rollout = dir.join("rollout-worker-a.jsonl");
+    let meta = format!(
+        "{{\"session_meta\":{{\"payload\":{{\"id\":\"sess-worker-a\",\"cwd\":\"{}\"}}}}}}\n",
+        dir.to_string_lossy()
+    );
+    let marker = "You are Team Agent worker `worker-a` with role `fixture`.";
+    let body = format!("{meta}{{\"text\":\"{marker}{}\"}}\n", "x".repeat(70_000));
+    std::fs::write(&rollout, body).expect("write cross-cap rollout");
+    assert!(!read_head_text(&rollout, CAPTURE_HEAD_BYTES)
+        .expect("read complete records")
+        .contains(marker));
+    let context = CaptureSessionContext {
+        agent_id: "worker-a".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,
+            requires_cwd_match: false,
+        }],
+    );
+
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(candidates[0].embedded_agent_id.as_deref(), Some("worker-a"));
+    assert!(candidates[0].positive_agent_id_match);
+    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,
+            requires_cwd_match: false,
+        }],
+    );
+    assert!(candidates.is_empty());
+    let _ = std::fs::remove_dir_all(&dir);
+}

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

@@ -69,9 +69,11 @@ pub(super) fn parse_candidate_files(
     let mut out = Vec::new();
     for candidate in candidates {
         let path = candidate.path;
-        let Ok(text) = read_head_text(&path, CAPTURE_HEAD_BYTES) else {
+        let Ok(head_bytes) = read_head_bytes(&path, CAPTURE_HEAD_BYTES) else {
             continue;
         };
+        let text = complete_head_text(&head_bytes);
+        let identity_text = String::from_utf8_lossy(&head_bytes);
         let records = parse_session_records(&text);
         if records.is_empty() {
             continue;
@@ -98,7 +100,7 @@ pub(super) fn parse_candidate_files(
         } else {
             Confidence::Low
         };
-        let embedded_agent_id = embedded_team_agent_worker_id_from_text(&text);
+        let embedded_agent_id = embedded_team_agent_worker_id_from_text(&identity_text);
         if embedded_agent_id
             .as_deref()
             .is_some_and(|id| id != context.agent_id.as_str())
@@ -129,7 +131,41 @@ pub(super) fn parse_candidate_files(
     out
 }
 
+/// Reject provider files older than the persisted process-cohort boundary.
+pub(super) fn apply_spawned_at_filter(
+    provider: Provider,
+    context: &CaptureSessionContext,
+    out: &mut Vec<CapturedSessionCandidate>,
+) {
+    let Some(raw_spawned_at) = context.spawned_at.as_deref() else {
+        // Legacy direct capture_session_id callers have no cohort boundary;
+        // the canonical runtime capture path rejects such rows before scan.
+        return;
+    };
+    let Some(spawned_at) = super::codex::parse_spawned_at(raw_spawned_at) else {
+        out.clear();
+        return;
+    };
+    out.retain(|candidate| {
+        let Some(path) = candidate.captured.rollout_path.as_ref() else {
+            return false;
+        };
+        if matches!(provider, Provider::Codex) {
+            return super::codex::rollout_created_at(path.as_path())
+                .is_some_and(|created_at| created_at >= spawned_at);
+        }
+        candidate_mtime(path.as_path()).is_some_and(|mtime| mtime >= spawned_at)
+    });
+}
+
+fn candidate_mtime(path: &Path) -> Option<std::time::SystemTime> {
+    std::fs::metadata(path)
+        .and_then(|meta| meta.modified())
+        .ok()
+}
+
 pub(super) fn apply_spawn_time_window_if_unique(
+    provider: Provider,
     context: &CaptureSessionContext,
     out: &mut Vec<CapturedSessionCandidate>,
 ) {
@@ -150,12 +186,11 @@ pub(super) fn apply_spawn_time_window_if_unique(
                 .captured
                 .rollout_path
                 .as_ref()
-                .and_then(|p| {
-                    std::fs::metadata(p.as_path())
-                        .and_then(|m| m.modified())
-                        .ok()
+                .and_then(|p| match provider {
+                    Provider::Codex => super::codex::rollout_created_at(p.as_path()),
+                    _ => candidate_mtime(p.as_path()),
                 })
-                .is_some_and(|mtime| mtime >= spawned_at)
+                .is_some_and(|created_at| created_at >= spawned_at)
         })
         .cloned()
         .collect();
@@ -208,15 +243,23 @@ fn cap_candidates_by_mtime(out: &mut Vec<SessionCandidate>, cap: usize) {
 }
 
 pub(super) fn read_head_text(path: &Path, max_bytes: u64) -> std::io::Result<String> {
+    read_head_bytes(path, max_bytes).map(|bytes| complete_head_text(&bytes))
+}
+
+fn read_head_bytes(path: &Path, max_bytes: u64) -> std::io::Result<Vec<u8>> {
     use std::io::Read;
     let file = std::fs::File::open(path)?;
     let mut bytes = Vec::new();
     file.take(max_bytes).read_to_end(&mut bytes)?;
+    Ok(bytes)
+}
+
+fn complete_head_text(bytes: &[u8]) -> String {
     let complete = match bytes.iter().rposition(|byte| *byte == b'\n') {
         Some(last_newline) => &bytes[..=last_newline],
         None => &bytes[..],
     };
-    Ok(String::from_utf8_lossy(complete).into_owned())
+    String::from_utf8_lossy(complete).into_owned()
 }
 
 fn collect_optional_candidate_files(
@@ -366,7 +409,7 @@ pub(super) fn record_cwd(record: &serde_json::Value) -> Option<String> {
         .map(ToString::to_string)
 }
 
-fn paths_equivalent(left: &Path, right: &Path) -> bool {
+pub(super) fn paths_equivalent(left: &Path, right: &Path) -> bool {
     if left == right {
         return true;
     }
@@ -381,86 +424,4 @@ fn path_is_under_team_runtime(path: &Path) -> bool {
 }
 
 #[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);
-    }
-}
+mod tests;

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

@@ -1,14 +1,14 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
 
 use super::{CaptureSessionContext, CapturedSessionCandidate};
 
 pub(super) fn scan_session_store(context: &CaptureSessionContext) -> Vec<CapturedSessionCandidate> {
-    let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
+    let Ok(home) = crate::provider::adapters::copilot_fork::copilot_home() else {
         return Vec::new();
     };
-    let db_path = home.join(".copilot").join("session-store.db");
+    let db_path = home.join("session-store.db");
     if !db_path.exists() {
         return Vec::new();
     }
@@ -59,6 +59,7 @@ mod tests {
     #![allow(clippy::unwrap_used)]
 
     use super::*;
+    use std::path::PathBuf;
     use std::sync::atomic::{AtomicU64, Ordering};
 
     struct HomeGuard {
@@ -175,6 +176,49 @@ mod tests {
         let _ = std::fs::remove_dir_all(&base);
     }
 
+    #[test]
+    #[serial_test::serial(env)]
+    fn copilot_scanner_respects_copilot_home() {
+        let base = tmp_root("custom-home");
+        let copilot_home = base.join("isolated-copilot");
+        std::fs::create_dir_all(&copilot_home).unwrap();
+        let worker_id = "1142c4c2-0000-4000-8000-000000000001";
+        let conn = rusqlite::Connection::open(copilot_home.join("session-store.db")).unwrap();
+        conn.execute(
+            "create table sessions (id text primary key, cwd text, updated_at integer)",
+            [],
+        )
+        .unwrap();
+        conn.execute(
+            "insert into sessions (id, cwd, updated_at) values (?1, '/tmp/ws', 1)",
+            [worker_id],
+        )
+        .unwrap();
+        drop(conn);
+        let previous = std::env::var_os("COPILOT_HOME");
+        std::env::set_var("COPILOT_HOME", &copilot_home);
+        let ctx = CaptureSessionContext {
+            agent_id: "worker".to_string(),
+            spawn_cwd: base.join("ws"),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new(worker_id)),
+            provider_projects_root: None,
+        };
+        let out = scan_session_store(&ctx);
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            worker_id
+        );
+        match previous {
+            Some(value) => std::env::set_var("COPILOT_HOME", value),
+            None => std::env::remove_var("COPILOT_HOME"),
+        }
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
     #[test]
     #[serial_test::serial(env)]
     fn copilot_no_expected_same_cwd_only_leader_row_returns_empty_not_leader() {

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

@@ -64,16 +64,16 @@ pub(crate) fn scan_session_candidates_once(
 
     let candidates = common::candidate_session_files(provider, context)?;
     let mut out = common::parse_candidate_files(provider, context, candidates);
-
     if matches!(provider, Provider::Codex) {
-        codex::apply_spawned_at_filter(&mut out, context);
+        codex::retain_spawn_cwd(context, &mut out);
     }
+    common::apply_spawned_at_filter(provider, context, &mut out);
 
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return claude::apply_expected_session_filter(context, out);
     }
 
-    common::apply_spawn_time_window_if_unique(context, &mut out);
+    common::apply_spawn_time_window_if_unique(provider, context, &mut out);
     common::sort_expected_first_if_needed(context, &mut out);
     Ok(out)
 }