@team-agent/installer 0.4.11 → 0.5.1

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

@@ -0,0 +1,309 @@
+use std::path::{Path, PathBuf};
+
+use crate::provider::types::SessionId;
+use crate::provider::Provider;
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+pub(super) fn projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<PathBuf> {
+    let canonical = std::fs::canonicalize(spawn_cwd).unwrap_or_else(|_| spawn_cwd.to_path_buf());
+    let encoded = encode_projects_dir(&canonical.to_string_lossy());
+    if encoded.is_empty() {
+        return None;
+    }
+    Some(home.join(".claude").join("projects").join(encoded))
+}
+
+fn encode_projects_dir(path: &str) -> String {
+    let mut out = String::with_capacity(path.len());
+    for c in path.chars() {
+        if c.is_ascii_alphanumeric() {
+            out.push(c);
+        } else {
+            out.push('-');
+        }
+    }
+    out
+}
+
+pub(crate) fn rollout_path_has_leader_marker(provider: Provider, rollout_path: &Path) -> bool {
+    if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
+        return false;
+    }
+    let Ok(text) = super::common::read_head_text(rollout_path, super::common::CAPTURE_HEAD_BYTES)
+    else {
+        return false;
+    };
+    let records = super::common::parse_session_records(&text);
+    records_have_leader_marker(&records)
+}
+
+pub(super) fn records_have_leader_marker(records: &[serde_json::Value]) -> bool {
+    records.iter().any(|record| {
+        let custom_title = record
+            .get("customTitle")
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_ascii_lowercase);
+        let agent_name = record
+            .get("agentName")
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_ascii_lowercase);
+        matches!(custom_title.as_deref(), Some("claude leader"))
+            || matches!(agent_name.as_deref(), Some("claude leader"))
+    })
+}
+
+pub(super) fn has_cwd_field(record: &serde_json::Value) -> bool {
+    super::common::record_cwd(record).is_some()
+}
+
+pub(super) fn apply_expected_session_filter(
+    context: &CaptureSessionContext,
+    mut out: Vec<CapturedSessionCandidate>,
+) -> Result<Vec<CapturedSessionCandidate>, crate::provider::types::ProviderError> {
+    if let Some(expected) = context.expected_session_id.as_ref() {
+        if let Some(hit) = out
+            .iter()
+            .find(|candidate| session_matches(candidate, expected))
+        {
+            return Ok(vec![hit.clone()]);
+        }
+        let positive_only: Vec<CapturedSessionCandidate> = out
+            .iter()
+            .filter(|candidate| candidate.positive_agent_id_match || candidate.agent_path_match)
+            .cloned()
+            .collect();
+        return Ok(positive_only);
+    }
+    super::common::apply_spawn_time_window_if_unique(context, &mut out);
+    Ok(out)
+}
+
+fn session_matches(candidate: &CapturedSessionCandidate, expected: &SessionId) -> bool {
+    candidate
+        .captured
+        .session_id
+        .as_ref()
+        .is_some_and(|session| session.as_str() == expected.as_str())
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::unwrap_used)]
+
+    use super::*;
+    use crate::provider::types::SessionId;
+    use crate::provider::Provider;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    fn tmp_root(tag: &str) -> PathBuf {
+        static CTR: AtomicU64 = AtomicU64::new(0);
+        let dir = std::env::temp_dir().join(format!(
+            "ta-e6-attr-{}-{}-{}",
+            tag,
+            std::process::id(),
+            CTR.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn write_transcript(dir: &Path, uuid: &str, cwd: &Path) -> PathBuf {
+        std::fs::create_dir_all(dir).unwrap();
+        let path = dir.join(format!("{uuid}.jsonl"));
+        let line = serde_json::json!({
+            "sessionId": uuid,
+            "cwd": cwd.to_string_lossy(),
+        });
+        std::fs::write(&path, format!("{line}\n")).unwrap();
+        path
+    }
+
+    #[test]
+    fn claude_leader_marker_in_custom_title_is_detected() {
+        let records = vec![serde_json::json!({
+            "type": "custom-title",
+            "customTitle": "claude leader",
+            "sessionId": "ea059b82",
+        })];
+        assert!(records_have_leader_marker(&records));
+    }
+
+    #[test]
+    fn claude_leader_marker_in_agent_name_is_detected() {
+        let records = vec![serde_json::json!({
+            "type": "agent-name",
+            "agentName": "claude leader",
+            "sessionId": "ea059b82",
+        })];
+        assert!(records_have_leader_marker(&records));
+    }
+
+    #[test]
+    fn claude_worker_records_have_no_leader_marker() {
+        let records = vec![
+            serde_json::json!({
+                "type": "custom-title",
+                "customTitle": "claude release-engineer",
+                "sessionId": "abc12345",
+            }),
+            serde_json::json!({
+                "type": "user",
+                "content": "Team Agent message from leader: do X",
+                "sessionId": "abc12345",
+            }),
+        ];
+        assert!(!records_have_leader_marker(&records));
+    }
+
+    #[test]
+    fn claude_leader_marker_is_case_insensitive() {
+        let records = vec![serde_json::json!({
+            "customTitle": "Claude Leader",
+        })];
+        assert!(records_have_leader_marker(&records));
+    }
+
+    #[test]
+    fn claude_projects_dir_for_cwd_encodes_slashes_to_dashes() {
+        let home = Path::new("/home/u");
+        let cwd = tmp_root("encode");
+        let got = projects_dir_for_cwd(home, &cwd).unwrap();
+        let canon = std::fs::canonicalize(&cwd).unwrap();
+        let expected_leaf = encode_projects_dir(&canon.to_string_lossy());
+        assert_eq!(
+            got,
+            home.join(".claude").join("projects").join(expected_leaf)
+        );
+        let _ = std::fs::remove_dir_all(&cwd);
+    }
+
+    #[test]
+    fn encode_claude_projects_dir_parity_with_real_claude_naming() {
+        assert_eq!(
+            encode_projects_dir("/Users/alauda/code"),
+            "-Users-alauda-code"
+        );
+        assert_eq!(
+            encode_projects_dir("/Users/alauda/Documents/code/agent前沿探索/多agent协作"),
+            "-Users-alauda-Documents-code-agent------agent--"
+        );
+        assert_eq!(
+            encode_projects_dir("/Users/foo bar.baz/v1.2"),
+            "-Users-foo-bar-baz-v1-2"
+        );
+        assert_eq!(
+            encode_projects_dir("/proj/.team/runtime"),
+            "-proj--team-runtime"
+        );
+    }
+
+    #[test]
+    fn scan_expected_session_id_hit_returns_only_that_candidate() {
+        let base = tmp_root("c-hit");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        write_transcript(&proj, "11111111-1111-4111-8111-111111111111", &cwd);
+        write_transcript(&proj, "22222222-2222-4222-8222-222222222222", &cwd);
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: Some(SessionId::new("22222222-2222-4222-8222-222222222222")),
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = super::super::scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            "22222222-2222-4222-8222-222222222222"
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn scan_spawn_time_window_disambiguates_two_siblings() {
+        let base = tmp_root("b-window");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        let old = write_transcript(&proj, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", &cwd);
+        let new = write_transcript(&proj, "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb", &cwd);
+        let long_ago =
+            std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_000_000);
+        filetime_set(&old, long_ago);
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2020-01-01T00:00:00+00:00".to_string()),
+            expected_session_id: None,
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = super::super::scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert_eq!(out.len(), 1);
+        assert_eq!(
+            out[0].captured.session_id.as_ref().unwrap().as_str(),
+            "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
+        );
+        let _ = new;
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn scan_no_spawned_at_keeps_both_siblings_ambiguous() {
+        let base = tmp_root("b-noamb");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        write_transcript(&proj, "cccccccc-cccc-4ccc-8ccc-cccccccccccc", &cwd);
+        write_transcript(&proj, "dddddddd-dddd-4ddd-8ddd-dddddddddddd", &cwd);
+        let ctx = CaptureSessionContext {
+            agent_id: "w1".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: None,
+            expected_session_id: None,
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = super::super::scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert!(out.len() >= 2);
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    #[test]
+    fn scan_expected_session_id_miss_refuses_to_pick_leader_sibling() {
+        let base = tmp_root("strict-no-leader-fallback");
+        let cwd = base.join("ws");
+        std::fs::create_dir_all(&cwd).unwrap();
+        let proj = base.join("projects");
+        let leader = write_transcript(&proj, "11111111-1111-4111-8111-111111111111", &cwd);
+        let stale = write_transcript(&proj, "22222222-2222-4222-8222-222222222222", &cwd);
+        let _ = (leader, stale);
+        let ctx = CaptureSessionContext {
+            agent_id: "claude-worker".to_string(),
+            spawn_cwd: cwd.clone(),
+            pane_id: None,
+            pane_pid: None,
+            spawned_at: Some("2020-01-01T00:00:00+00:00".to_string()),
+            expected_session_id: Some(SessionId::new("99999999-9999-4999-8999-999999999999")),
+            provider_projects_root: Some(proj.clone()),
+        };
+        let out = super::super::scan_session_candidates_once(Provider::ClaudeCode, &ctx).unwrap();
+        assert!(
+            out.is_empty(),
+            "expected-id miss must not fall back to latest"
+        );
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
+    fn filetime_set(path: &Path, when: std::time::SystemTime) {
+        let f = std::fs::OpenOptions::new().write(true).open(path).unwrap();
+        f.set_modified(when).unwrap();
+    }
+}

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

@@ -0,0 +1,40 @@
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+pub(super) fn apply_spawned_at_filter(
+    out: &mut Vec<CapturedSessionCandidate>,
+    context: &CaptureSessionContext,
+) {
+    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,
+        };
+        std::fs::metadata(path)
+            .and_then(|meta| meta.modified())
+            .map(|mtime| mtime >= cutoff)
+            .unwrap_or(false)
+    });
+}
+
+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)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_spawned_at_rfc3339_roundtrips_and_rejects_junk() {
+        assert!(parse_spawned_at("2026-06-10T21:40:00+00:00").is_some());
+        assert!(parse_spawned_at("not-a-date").is_none());
+        assert!(parse_spawned_at("").is_none());
+    }
+}

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

@@ -0,0 +1,350 @@
+use std::path::{Path, PathBuf};
+
+use crate::provider::helpers::{find_session_id, parse_jsonl_records};
+use crate::provider::types::{
+    CaptureVia, CapturedSession, Confidence, ProviderError, RolloutPath, SessionId,
+};
+use crate::provider::Provider;
+
+use super::{CaptureSessionContext, CapturedSessionCandidate};
+
+pub(super) struct SessionCandidate {
+    pub(super) path: PathBuf,
+    requires_cwd_match: bool,
+}
+
+/// P2 (C-P2-2/3) / Python claude.py:300 — candidates are capped to the newest `cap`
+/// by mtime (descending priority: old candidates must not crowd out new ones).
+const CAPTURE_CANDIDATE_CAP: usize = 300;
+
+/// P2 (C-P2-1): head window >= Python's 200-line read.
+pub(super) const CAPTURE_HEAD_BYTES: u64 = 65_536;
+
+pub(super) fn candidate_session_files(
+    provider: Provider,
+    context: &CaptureSessionContext,
+) -> Result<Vec<SessionCandidate>, ProviderError> {
+    let mut out = Vec::new();
+    if let Some(root) = context.provider_projects_root.as_ref() {
+        collect_optional_candidate_files(root, &context.agent_id, &mut out)?;
+    }
+    collect_candidate_files(&context.spawn_cwd, &context.agent_id, 0, false, &mut out)?;
+    if let Some(home) = std::env::var_os("HOME").map(PathBuf::from) {
+        match provider {
+            Provider::Codex => {
+                collect_optional_candidate_files(
+                    &home.join(".codex").join("sessions"),
+                    &context.agent_id,
+                    &mut out,
+                )?;
+            }
+            Provider::Claude | Provider::ClaudeCode => {
+                if let Some(dir) = super::claude::projects_dir_for_cwd(&home, &context.spawn_cwd) {
+                    collect_optional_candidate_files(&dir, &context.agent_id, &mut out)?;
+                }
+                collect_optional_candidate_files(
+                    &home.join(".claude").join("projects"),
+                    &context.agent_id,
+                    &mut out,
+                )?;
+            }
+            Provider::Copilot | Provider::GeminiCli | Provider::Fake => {}
+        }
+    }
+    out.sort_by(|a, b| {
+        a.requires_cwd_match
+            .cmp(&b.requires_cwd_match)
+            .then_with(|| a.path.to_string_lossy().cmp(&b.path.to_string_lossy()))
+    });
+    out.dedup_by(|a, b| a.path == b.path && a.requires_cwd_match == b.requires_cwd_match);
+    cap_candidates_by_mtime(&mut out, CAPTURE_CANDIDATE_CAP);
+    Ok(out)
+}
+
+pub(super) fn parse_candidate_files(
+    provider: Provider,
+    context: &CaptureSessionContext,
+    candidates: Vec<SessionCandidate>,
+) -> Vec<CapturedSessionCandidate> {
+    let mut out = Vec::new();
+    for candidate in candidates {
+        let path = candidate.path;
+        let Ok(text) = read_head_text(&path, CAPTURE_HEAD_BYTES) else {
+            continue;
+        };
+        let records = parse_session_records(&text);
+        if records.is_empty() {
+            continue;
+        }
+        if candidate.requires_cwd_match
+            && !provider_home_records_match_spawn_cwd(&records, &context.spawn_cwd)
+        {
+            continue;
+        }
+        let session_id = records.iter().find_map(find_session_id);
+        if matches!(provider, Provider::Claude | Provider::ClaudeCode)
+            && session_id.is_some()
+            && !records.iter().any(super::claude::has_cwd_field)
+        {
+            continue;
+        }
+        let captured_via = if session_id.is_some() {
+            CaptureVia::FsWatch
+        } else {
+            CaptureVia::FsMtimeFallback
+        };
+        let attribution_confidence = if session_id.is_some() {
+            Confidence::High
+        } else {
+            Confidence::Low
+        };
+        let positive_agent_id_match = candidate_text_has_team_agent_id(&text, context);
+        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)
+        {
+            continue;
+        }
+        out.push(CapturedSessionCandidate {
+            captured: CapturedSession {
+                session_id: session_id.map(SessionId::new),
+                rollout_path: Some(RolloutPath::new(path)),
+                captured_via,
+                attribution_confidence,
+                spawn_cwd: context.spawn_cwd.clone(),
+            },
+            positive_agent_id_match,
+            agent_path_match,
+        });
+    }
+    out
+}
+
+pub(super) fn apply_spawn_time_window_if_unique(
+    context: &CaptureSessionContext,
+    out: &mut Vec<CapturedSessionCandidate>,
+) {
+    if context.expected_session_id.is_some() && out.len() <= 1 {
+        return;
+    }
+    let Some(spawned_at) = context
+        .spawned_at
+        .as_deref()
+        .and_then(super::codex::parse_spawned_at)
+    else {
+        return;
+    };
+    let within: Vec<CapturedSessionCandidate> = out
+        .iter()
+        .filter(|candidate| {
+            candidate
+                .captured
+                .rollout_path
+                .as_ref()
+                .and_then(|p| {
+                    std::fs::metadata(p.as_path())
+                        .and_then(|m| m.modified())
+                        .ok()
+                })
+                .is_some_and(|mtime| mtime >= spawned_at)
+        })
+        .cloned()
+        .collect();
+    if within.len() == 1 {
+        *out = within;
+    }
+}
+
+pub(super) fn sort_expected_first_if_needed(
+    context: &CaptureSessionContext,
+    out: &mut [CapturedSessionCandidate],
+) {
+    if let Some(expected) = context.expected_session_id.as_ref() {
+        out.sort_by_key(|candidate| {
+            candidate
+                .captured
+                .session_id
+                .as_ref()
+                .is_none_or(|session| session.as_str() != expected.as_str())
+        });
+    }
+}
+
+fn cap_candidates_by_mtime(out: &mut Vec<SessionCandidate>, cap: usize) {
+    if out.len() <= cap {
+        return;
+    }
+    let mut ranked: Vec<(std::time::SystemTime, usize)> = out
+        .iter()
+        .enumerate()
+        .map(|(index, candidate)| {
+            let mtime = std::fs::metadata(&candidate.path)
+                .and_then(|meta| meta.modified())
+                .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
+            (mtime, index)
+        })
+        .collect();
+    ranked.sort_by(|a, b| b.0.cmp(&a.0));
+    let keep: std::collections::BTreeSet<usize> = ranked
+        .into_iter()
+        .take(cap)
+        .map(|(_, index)| index)
+        .collect();
+    let mut index = 0;
+    out.retain(|_| {
+        let kept = keep.contains(&index);
+        index += 1;
+        kept
+    });
+}
+
+pub(super) fn read_head_text(path: &Path, max_bytes: u64) -> std::io::Result<String> {
+    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)?;
+    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())
+}
+
+fn collect_optional_candidate_files(
+    dir: &Path,
+    agent_id: &str,
+    out: &mut Vec<SessionCandidate>,
+) -> Result<(), ProviderError> {
+    if dir.exists() {
+        let _ = collect_candidate_files(dir, agent_id, 0, true, out);
+    }
+    Ok(())
+}
+
+fn collect_candidate_files(
+    dir: &Path,
+    agent_id: &str,
+    depth: usize,
+    requires_cwd_match: bool,
+    out: &mut Vec<SessionCandidate>,
+) -> Result<(), ProviderError> {
+    if depth > 4 {
+        return Ok(());
+    }
+    let entries = match std::fs::read_dir(dir) {
+        Ok(entries) => entries,
+        Err(e) if depth == 0 => return Err(ProviderError::Io(format!("{}: {e}", dir.display()))),
+        Err(_) => return Ok(()),
+    };
+    for entry in entries {
+        let Ok(entry) = entry else {
+            continue;
+        };
+        let path = entry.path();
+        if path.is_dir() {
+            collect_candidate_files(
+                &path,
+                agent_id,
+                depth.saturating_add(1),
+                requires_cwd_match,
+                out,
+            )?;
+        } else if looks_like_session_file(&path, agent_id) {
+            out.push(SessionCandidate {
+                path,
+                requires_cwd_match,
+            });
+        }
+    }
+    Ok(())
+}
+
+fn looks_like_session_file(path: &Path, agent_id: &str) -> bool {
+    if path_is_under_team_runtime(path) {
+        return false;
+    }
+    let Some(name) = path.file_name().and_then(|s| s.to_str()) else {
+        return false;
+    };
+    name.ends_with(".jsonl")
+        || name.ends_with(".json")
+        || name.contains("session")
+        || name.contains("rollout")
+        || (!agent_id.is_empty() && name.contains(agent_id))
+}
+
+pub(super) fn parse_session_records(text: &str) -> Vec<serde_json::Value> {
+    match serde_json::from_str::<serde_json::Value>(text) {
+        Ok(serde_json::Value::Array(items)) => items,
+        Ok(value) => vec![value],
+        Err(_) => parse_jsonl_records(text),
+    }
+}
+
+fn provider_home_records_match_spawn_cwd(records: &[serde_json::Value], spawn_cwd: &Path) -> bool {
+    let cwd_values: Vec<String> = records.iter().filter_map(record_cwd).collect();
+    !cwd_values.is_empty()
+        && cwd_values
+            .iter()
+            .any(|cwd| paths_equivalent(Path::new(cwd), spawn_cwd))
+}
+
+fn candidate_text_has_team_agent_id(text: &str, context: &CaptureSessionContext) -> bool {
+    let id = context.agent_id.as_str();
+    if id.is_empty() {
+        return false;
+    }
+    [
+        format!("\"TEAM_AGENT_ID\":\"{id}\""),
+        format!("\"TEAM_AGENT_ID\": \"{id}\""),
+        format!("TEAM_AGENT_ID={id}"),
+        format!("env.TEAM_AGENT_ID=\"{id}\""),
+        format!("env.TEAM_AGENT_ID=\\\"{id}\\\""),
+        format!("\"TEAM_AGENT_AGENT_ID\":\"{id}\""),
+        format!("\"TEAM_AGENT_AGENT_ID\": \"{id}\""),
+        format!("TEAM_AGENT_AGENT_ID={id}"),
+    ]
+    .iter()
+    .any(|needle| text.contains(needle))
+}
+
+fn candidate_path_matches_agent_id(path: &Path, context: &CaptureSessionContext) -> bool {
+    let id = context.agent_id.as_str();
+    if id.is_empty() {
+        return false;
+    }
+    let Some(name) = path.file_name().and_then(|value| value.to_str()) else {
+        return false;
+    };
+    let dashed = id.replace('_', "-");
+    name.contains(id) || name.contains(&dashed)
+}
+
+pub(super) fn record_cwd(record: &serde_json::Value) -> Option<String> {
+    record
+        .get("cwd")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            record
+                .get("session_meta")
+                .and_then(|v| v.get("payload"))
+                .or_else(|| record.get("payload"))
+                .and_then(|v| v.get("cwd"))
+                .and_then(serde_json::Value::as_str)
+        })
+        .map(ToString::to_string)
+}
+
+fn paths_equivalent(left: &Path, right: &Path) -> bool {
+    if left == right {
+        return true;
+    }
+    let left = std::fs::canonicalize(left).unwrap_or_else(|_| left.to_path_buf());
+    let right = std::fs::canonicalize(right).unwrap_or_else(|_| right.to_path_buf());
+    left == right || left.parent().is_some_and(|parent| parent == right)
+}
+
+fn path_is_under_team_runtime(path: &Path) -> bool {
+    path.components()
+        .any(|c| c.as_os_str() == std::ffi::OsStr::new(".team"))
+}