@team-agent/installer 0.5.59 → 0.5.61

package/crates/team-agent/src/provider/session/context_fork/codex.rs

@@ -1,14 +1,319 @@
 use super::*;
+use std::collections::BTreeSet;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+#[derive(Debug)]
+pub(crate) struct CodexForkMaterialization {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl CodexForkMaterialization {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn mark_handoff(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl crate::provider::adapter::ForkBackingMaterialization for CodexForkMaterialization {
+    fn path(&self) -> &Path {
+        self.path()
+    }
+
+    fn handoff(&mut self) {
+        self.mark_handoff();
+    }
+}
+
+impl Drop for CodexForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(crate) fn materialize_codex_fork(
+    source_path: &Path,
+    source_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+    plan: &mut CommandPlan,
+) -> Result<CodexForkMaterialization, ProviderError> {
+    let target_session_id = SessionId::new(codex_session_v7());
+    let parent = source_path.parent().ok_or_else(|| {
+        ProviderError::Io(format!(
+            "codex source backing has no parent: {}",
+            source_path.display()
+        ))
+    })?;
+    let timestamp = chrono::Utc::now().format("%Y-%m-%dT%H-%M-%S");
+    let target_path = parent.join(format!(
+        "rollout-{timestamp}-{}.jsonl",
+        target_session_id.as_str()
+    ));
+    let source = complete_source_snapshot(source_path)?;
+    let rewritten = rewrite_snapshot(
+        &source,
+        source_session_id,
+        &target_session_id,
+        source_agent_id,
+        target_agent_id,
+    )?;
+    publish_target_no_clobber(&target_path, rewritten.as_bytes())?;
+    if let Err(error) =
+        validate_materialized_target(&target_path, &target_session_id, target_agent_id)
+    {
+        let _ = std::fs::remove_file(&target_path);
+        return Err(error);
+    }
+    apply_resume_target(plan, source_session_id, &target_session_id)?;
+    Ok(CodexForkMaterialization {
+        path: target_path,
+        keep: false,
+    })
+}
+
+fn complete_source_snapshot(path: &Path) -> Result<String, ProviderError> {
+    let file = File::open(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let visible_len = file
+        .metadata()
+        .map_err(|error| ProviderError::Io(error.to_string()))?
+        .len();
+    let mut bytes = Vec::new();
+    file.take(visible_len)
+        .read_to_end(&mut bytes)
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+    let Some(boundary) = bytes.iter().rposition(|byte| *byte == b'\n') else {
+        return Err(ProviderError::Io(
+            "codex fork source has no complete JSONL record".to_string(),
+        ));
+    };
+    bytes.truncate(boundary + 1);
+    String::from_utf8(bytes).map_err(|error| ProviderError::Io(error.to_string()))
+}
+
+fn rewrite_snapshot(
+    source: &str,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+) -> Result<String, ProviderError> {
+    let source_marker = format!("You are Team Agent worker `{source_agent_id}`");
+    let target_marker = format!("You are Team Agent worker `{target_agent_id}`");
+    let mut meta_count = 0_usize;
+    let mut marker_count = 0_usize;
+    let mut output = String::new();
+    for (index, line) in source.lines().enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let mut record = serde_json::from_str::<serde_json::Value>(line).map_err(|error| {
+            ProviderError::Io(format!(
+                "codex fork source has invalid JSONL at line {}: {error}",
+                index + 1
+            ))
+        })?;
+        if record.get("type").and_then(serde_json::Value::as_str) == Some("session_meta") {
+            let id = record
+                .get_mut("payload")
+                .and_then(serde_json::Value::as_object_mut)
+                .and_then(|payload| payload.get_mut("id"))
+                .and_then(|id| id.as_str())
+                .ok_or_else(|| {
+                    ProviderError::Io(
+                        "codex fork session_meta has no string payload.id".to_string(),
+                    )
+                })?;
+            if id != source_session_id.as_str() {
+                return Err(ProviderError::Io(
+                    "codex fork session_meta id does not match source".to_string(),
+                ));
+            }
+            record["payload"]["id"] =
+                serde_json::Value::String(target_session_id.as_str().to_string());
+            meta_count += 1;
+        }
+        marker_count += replace_exact_marker(&mut record, &source_marker, &target_marker);
+        output.push_str(
+            &serde_json::to_string(&record)
+                .map_err(|error| ProviderError::Io(error.to_string()))?,
+        );
+        output.push('\n');
+    }
+    if meta_count != 1 || marker_count != 1 {
+        return Err(ProviderError::Io(format!(
+            "codex fork source identity is ambiguous: session_meta={meta_count}, marker={marker_count}"
+        )));
+    }
+    Ok(output)
+}
+
+fn replace_exact_marker(value: &mut serde_json::Value, source: &str, target: &str) -> usize {
+    match value {
+        serde_json::Value::String(text) => {
+            let count = text.matches(source).count();
+            if count == 1 {
+                *text = text.replacen(source, target, 1);
+            }
+            count
+        }
+        serde_json::Value::Array(items) => items
+            .iter_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        serde_json::Value::Object(fields) => fields
+            .values_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        _ => 0,
+    }
+}
+
+fn publish_target_no_clobber(path: &Path, bytes: &[u8]) -> Result<(), ProviderError> {
+    let parent = path.parent().ok_or_else(|| {
+        ProviderError::Io(format!("codex target has no parent: {}", path.display()))
+    })?;
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("codex-fork"),
+        std::process::id()
+    ));
+    let result = (|| -> std::io::Result<()> {
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&temp)?;
+        file.write_all(bytes)?;
+        file.sync_all()?;
+        std::fs::hard_link(&temp, path)?;
+        File::open(parent)?.sync_all()?;
+        std::fs::remove_file(&temp)?;
+        Ok(())
+    })();
+    if let Err(error) = result {
+        let _ = std::fs::remove_file(&temp);
+        return Err(ProviderError::Io(error.to_string()));
+    }
+    Ok(())
+}
+
+fn validate_materialized_target(
+    path: &Path,
+    session_id: &SessionId,
+    target_agent_id: &str,
+) -> Result<(), ProviderError> {
+    let text =
+        std::fs::read_to_string(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let actual = session_id_from_jsonl(path);
+    let marker = format!("You are Team Agent worker `{target_agent_id}`");
+    if actual.as_deref() != Some(session_id.as_str())
+        || !path
+            .file_stem()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name.ends_with(session_id.as_str()))
+        || text.matches(&marker).count() != 1
+    {
+        return Err(ProviderError::Io(
+            "codex fork target read-back identity mismatch".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+fn apply_resume_target(
+    plan: &mut CommandPlan,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+) -> Result<(), ProviderError> {
+    if plan.argv.first().map(String::as_str) != Some("codex")
+        || plan.argv.get(1).map(String::as_str) != Some("fork")
+        || plan.argv.last().map(String::as_str) != Some(source_session_id.as_str())
+    {
+        return Err(ProviderError::Command(
+            "codex fork command shape cannot be converted to exact resume".to_string(),
+        ));
+    }
+    plan.argv[1] = "resume".to_string();
+    *plan.argv.last_mut().expect("validated non-empty argv") =
+        target_session_id.as_str().to_string();
+    plan.expected_session_id = Some(target_session_id.clone());
+    Ok(())
+}
+
+fn codex_session_v7() -> String {
+    use sha2::Digest;
+
+    static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+    let millis = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |duration| duration.as_millis() as u64);
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(millis.to_le_bytes());
+    hasher.update(std::process::id().to_le_bytes());
+    hasher.update(
+        COUNTER
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+            .to_le_bytes(),
+    );
+    let digest = hasher.finalize();
+    let mut bytes = [0_u8; 16];
+    bytes[..6].copy_from_slice(&millis.to_be_bytes()[2..]);
+    bytes[6..].copy_from_slice(&digest[..10]);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    format!(
+        "{:08x}-{:04x}-{:04x}-{:04x}-{:012x}",
+        u32::from_be_bytes(bytes[0..4].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[4..6].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[6..8].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[8..10].try_into().expect("fixed slice")),
+        u64::from_be_bytes([
+            0, 0, bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]
+        ])
+    )
+}
 
 pub(super) fn verify_codex_fork(
     source_session_id: &SessionId,
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
     deadline: Duration,
 ) -> Result<ContextForkProof, ContextForkTermination> {
+    let Some(expected) = plan.expected_session_id.as_ref() else {
+        return verify_legacy_codex_fork(
+            source_session_id,
+            plan,
+            before,
+            agent_id,
+            spawn_cwd,
+            spawned_at,
+            deadline,
+        );
+    };
+    if expected == source_session_id {
+        return Err(ProviderError::CaptureFailed(
+            "context_fork_unverified: codex target session equals source".to_string(),
+        )
+        .into());
+    }
+    let expected_path = expected_backing_path.ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: codex plan has no materialized target backing".to_string(),
+        )
+    })?;
     let context = crate::provider::session_scan::CaptureSessionContext {
         agent_id: agent_id.to_string(),
         spawn_cwd: spawn_cwd.to_path_buf(),
@@ -18,28 +323,25 @@ pub(super) fn verify_codex_fork(
         expected_session_id: plan.expected_session_id.clone(),
         provider_projects_root: plan.provider_projects_root.clone(),
     };
-    let excluded = outcome::source_exclusions(before, source_session_id);
     let started = std::time::Instant::now();
     loop {
-        let current = jsonl_files(&before.root);
         for candidate in
             crate::provider::session_scan::scan_session_candidates_once(Provider::Codex, &context)?
         {
             let Some(path) = candidate.captured.rollout_path.as_ref() else {
                 continue;
             };
-            let Some(stamp) = current.get(path.as_path()) else {
-                continue;
-            };
-            let snapshot_changed = before.files.get(path.as_path()) != Some(stamp);
-            if !snapshot_changed {
+            if path.as_path() != expected_path {
                 continue;
             }
             let Some(new_session_id) = candidate.captured.session_id else {
                 continue;
             };
-            if excluded.contains(new_session_id.as_str())
-                || excluded.contains(&path.as_path().to_string_lossy().to_string())
+            if &new_session_id != expected || &new_session_id == source_session_id {
+                continue;
+            }
+            if !candidate.positive_agent_id_match
+                || candidate.embedded_agent_id.as_deref() != Some(agent_id)
             {
                 continue;
             }
@@ -63,3 +365,78 @@ pub(super) fn verify_codex_fork(
         deadline_ms: deadline.as_millis(),
     })
 }
+
+fn verify_legacy_codex_fork(
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    agent_id: &str,
+    spawn_cwd: &Path,
+    spawned_at: &str,
+    deadline: Duration,
+) -> Result<ContextForkProof, ContextForkTermination> {
+    let mut excluded_session_ids = BTreeSet::new();
+    excluded_session_ids.insert(source_session_id.as_str().to_string());
+    let mut excluded_backing_paths = BTreeSet::new();
+    for path in before.files.keys() {
+        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
+            excluded_backing_paths.insert(path.clone());
+        }
+    }
+    let context = crate::provider::session_scan::CaptureSessionContext {
+        agent_id: agent_id.to_string(),
+        spawn_cwd: spawn_cwd.to_path_buf(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: Some(spawned_at.to_string()),
+        expected_session_id: None,
+        provider_projects_root: plan.provider_projects_root.clone(),
+    };
+    let started = std::time::Instant::now();
+    loop {
+        let current = jsonl_files(&provider_backing_root(Provider::Codex, plan));
+        let mut matches = Vec::new();
+        for candidate in
+            crate::provider::session_scan::scan_session_candidates_once(Provider::Codex, &context)?
+        {
+            let Some(path) = candidate.captured.rollout_path.as_ref() else {
+                continue;
+            };
+            if excluded_backing_paths.contains(path.as_path()) {
+                continue;
+            }
+            let Some(stamp) = current.get(path.as_path()) else {
+                continue;
+            };
+            if before.files.get(path.as_path()) == Some(stamp) {
+                continue;
+            }
+            let Some(session_id) = candidate.captured.session_id else {
+                continue;
+            };
+            if excluded_session_ids.contains(session_id.as_str()) {
+                continue;
+            }
+            matches.push((session_id, path.as_path().to_path_buf()));
+        }
+        if let [(new_session_id, backing_path)] = matches.as_slice() {
+            return Ok(ContextForkProof {
+                provider: Provider::Codex,
+                source_session_id: source_session_id.clone(),
+                new_session_id: new_session_id.clone(),
+                backing_path: backing_path.clone(),
+                captured_via: "context_fork_verified".to_string(),
+                attribution_confidence: "high".to_string(),
+                managed_backing_root: None,
+            });
+        }
+        if started.elapsed() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    Err(ContextForkTermination::Timeout {
+        provider: Provider::Codex,
+        deadline_ms: deadline.as_millis(),
+    })
+}

package/crates/team-agent/src/provider/session/context_fork/outcome.rs

@@ -1,18 +1,4 @@
 use super::*;
-use std::collections::BTreeSet;
-
-pub(super) fn source_exclusions(
-    before: &ContextBackingSnapshot,
-    source_session_id: &SessionId,
-) -> BTreeSet<String> {
-    let mut excluded = BTreeSet::from([source_session_id.as_str().to_string()]);
-    for path in before.files.keys() {
-        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
-            excluded.insert(path.to_string_lossy().to_string());
-        }
-    }
-    excluded
-}
 
 #[derive(Debug, Clone)]
 pub(crate) struct PendingContextFork {
@@ -47,6 +33,7 @@ pub(crate) fn observe_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -58,6 +45,7 @@ pub(crate) fn observe_context_fork(
         plan,
         before,
         expected_backing_path,
+        source_agent_id,
         agent_id,
         spawn_cwd,
         spawned_at,
@@ -123,6 +111,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &root,
             "2026-07-24T00:00:00Z",

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

@@ -21,6 +21,7 @@ pub(crate) enum ContextForkTermination {
 mod claude;
 mod codex;
 mod outcome;
+pub(crate) use codex::materialize_codex_fork;
 pub(crate) use outcome::{
     observe_context_fork, transition_pending_context_fork, ContextForkOutcome, PendingContextFork,
 };
@@ -47,7 +48,6 @@ pub struct ContextForkProof {
 
 #[derive(Debug, Clone)]
 pub(crate) struct ContextBackingSnapshot {
-    root: PathBuf,
     files: BTreeMap<PathBuf, FileStamp>,
 }
 
@@ -61,7 +61,7 @@ impl ContextBackingSnapshot {
     pub(crate) fn capture(provider: Provider, plan: &CommandPlan) -> Self {
         let root = provider_backing_root(provider, plan);
         let files = jsonl_files(&root);
-        Self { root, files }
+        Self { files }
     }
 }
 
@@ -71,6 +71,7 @@ pub(crate) fn verify_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    _source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -84,6 +85,7 @@ pub(crate) fn verify_context_fork(
             source_session_id,
             plan,
             before,
+            expected_backing_path,
             agent_id,
             spawn_cwd,
             spawned_at,
@@ -298,6 +300,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &current_cwd,
             "2026-07-21T20:00:00+00:00",
@@ -344,6 +347,7 @@ mod tests {
             &plan,
             &before,
             Some(&expected_path),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",
@@ -382,6 +386,7 @@ mod tests {
             &plan,
             &before,
             Some(&missing),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",

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

@@ -10,8 +10,9 @@ pub mod resume;
 
 pub use context_fork::ContextForkProof;
 pub(crate) use context_fork::{
-    context_fork_convergence_deadline, observe_context_fork, transition_pending_context_fork,
-    ContextBackingSnapshot, ContextForkOutcome, PendingContextFork,
+    context_fork_convergence_deadline, materialize_codex_fork, observe_context_fork,
+    transition_pending_context_fork, ContextBackingSnapshot, ContextForkOutcome,
+    PendingContextFork,
 };
 
 pub use resume::{

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

@@ -1,6 +1,7 @@
 use std::path::{Path, PathBuf};
 
-use crate::provider::types::SessionId;
+use crate::provider::helpers::find_session_id;
+use crate::provider::types::{CaptureVia, CapturedSession, Confidence, RolloutPath, SessionId};
 use crate::provider::Provider;
 
 use super::{CaptureSessionContext, CapturedSessionCandidate};
@@ -14,7 +15,7 @@ pub(crate) fn projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<Path
     Some(home.join(".claude").join("projects").join(encoded))
 }
 
-fn encode_projects_dir(path: &str) -> String {
+pub(super) 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() {
@@ -26,6 +27,65 @@ fn encode_projects_dir(path: &str) -> String {
     out
 }
 
+pub(super) fn scan_expected_session(
+    context: &CaptureSessionContext,
+) -> Vec<CapturedSessionCandidate> {
+    let Some(expected) = context.expected_session_id.as_ref() else {
+        return Vec::new();
+    };
+    let Some(projects_root) = context.provider_projects_root.clone().or_else(|| {
+        std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .map(|home| home.join(".claude").join("projects"))
+    }) else {
+        return Vec::new();
+    };
+    let canonical =
+        std::fs::canonicalize(&context.spawn_cwd).unwrap_or_else(|_| context.spawn_cwd.clone());
+    let encoded = encode_projects_dir(&canonical.to_string_lossy());
+    if encoded.is_empty() {
+        return Vec::new();
+    }
+    let path = projects_root
+        .join(encoded)
+        .join(format!("{}.jsonl", expected.as_str()));
+    let Ok(text) = super::common::read_head_text(&path, super::common::CAPTURE_HEAD_BYTES) else {
+        return Vec::new();
+    };
+    let records = super::common::parse_session_records(&text);
+    let session_matches = records
+        .iter()
+        .find_map(find_session_id)
+        .is_some_and(|session_id| session_id == expected.as_str());
+    let has_lifecycle_record = records.iter().any(|record| {
+        matches!(
+            record.get("type").and_then(serde_json::Value::as_str),
+            Some("user" | "assistant")
+        )
+    });
+    if !session_matches
+        || !has_lifecycle_record
+        || records_have_leader_marker(&records)
+        || !records.iter().any(has_cwd_field)
+    {
+        return Vec::new();
+    }
+    let embedded_agent_id = super::common::embedded_team_agent_worker_id_from_text(&text);
+    let positive_agent_id_match = embedded_agent_id.as_deref() == Some(context.agent_id.as_str());
+    vec![CapturedSessionCandidate {
+        captured: CapturedSession {
+            session_id: Some(expected.clone()),
+            rollout_path: Some(RolloutPath::new(path)),
+            captured_via: CaptureVia::FsWatch,
+            attribution_confidence: Confidence::High,
+            spawn_cwd: context.spawn_cwd.clone(),
+        },
+        embedded_agent_id,
+        positive_agent_id_match,
+        agent_path_match: false,
+    }]
+}
+
 pub(crate) fn rollout_path_has_leader_marker(provider: Provider, rollout_path: &Path) -> bool {
     if !matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return false;
@@ -112,6 +172,7 @@ mod tests {
         std::fs::create_dir_all(dir).unwrap();
         let path = dir.join(format!("{uuid}.jsonl"));
         let line = serde_json::json!({
+            "type": "user",
             "sessionId": uuid,
             "cwd": cwd.to_string_lossy(),
         });
@@ -119,6 +180,11 @@ mod tests {
         path
     }
 
+    fn expected_transcript_dir(projects_root: &Path, cwd: &Path) -> PathBuf {
+        let canonical = std::fs::canonicalize(cwd).unwrap_or_else(|_| cwd.to_path_buf());
+        projects_root.join(encode_projects_dir(&canonical.to_string_lossy()))
+    }
+
     #[test]
     fn claude_leader_marker_in_custom_title_is_detected() {
         let records = vec![serde_json::json!({
@@ -205,7 +271,11 @@ mod tests {
         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 expected = write_transcript(
+            &expected_transcript_dir(&proj, &cwd),
+            "22222222-2222-4222-8222-222222222222",
+            &cwd,
+        );
         let ctx = CaptureSessionContext {
             agent_id: "w1".to_string(),
             spawn_cwd: cwd.clone(),
@@ -221,6 +291,10 @@ mod tests {
             out[0].captured.session_id.as_ref().unwrap().as_str(),
             "22222222-2222-4222-8222-222222222222"
         );
+        assert_eq!(
+            out[0].captured.rollout_path.as_ref().unwrap().as_path(),
+            expected
+        );
         let _ = std::fs::remove_dir_all(&base);
     }
 
@@ -284,6 +358,21 @@ mod tests {
         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 addressed =
+            expected_transcript_dir(&proj, &cwd).join("99999999-9999-4999-8999-999999999999.jsonl");
+        std::fs::create_dir_all(addressed.parent().unwrap()).unwrap();
+        std::fs::write(
+            &addressed,
+            format!(
+                "{}\n",
+                serde_json::json!({
+                    "type": "user",
+                    "sessionId": "22222222-2222-4222-8222-222222222222",
+                    "cwd": cwd.to_string_lossy(),
+                })
+            ),
+        )
+        .unwrap();
         let _ = (leader, stale);
         let ctx = CaptureSessionContext {
             agent_id: "claude-worker".to_string(),