@team-agent/installer 0.5.56 → 0.5.58

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

@@ -0,0 +1,65 @@
+use super::*;
+
+pub(super) fn verify_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 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: 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 {
+                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())
+            {
+                continue;
+            }
+            return Ok(ContextForkProof {
+                provider: Provider::Codex,
+                source_session_id: source_session_id.clone(),
+                new_session_id,
+                backing_path: path.as_path().to_path_buf(),
+                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

@@ -0,0 +1,138 @@
+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 {
+    pub source_session_id: SessionId,
+    pub target_agent: String,
+    pub spawned_at: String,
+    pub scanner_context: crate::provider::session_scan::CaptureSessionContext,
+}
+
+#[derive(Debug)]
+pub(crate) enum ContextForkOutcome {
+    Verified(ContextForkProof),
+    Pending(PendingContextFork),
+    Rejected(ProviderError),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ContextForkPendingFailure {
+    TranscriptMissing,
+}
+
+pub(crate) fn transition_pending_context_fork(
+    triggered: bool,
+    grace_expired: bool,
+) -> Option<ContextForkPendingFailure> {
+    (triggered && grace_expired).then_some(ContextForkPendingFailure::TranscriptMissing)
+}
+
+pub(crate) fn observe_context_fork(
+    provider: Provider,
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
+    agent_id: &str,
+    spawn_cwd: &Path,
+    spawned_at: &str,
+    deadline: Duration,
+) -> ContextForkOutcome {
+    match verify_context_fork(
+        provider,
+        source_session_id,
+        plan,
+        before,
+        expected_backing_path,
+        agent_id,
+        spawn_cwd,
+        spawned_at,
+        deadline,
+    ) {
+        Ok(proof) => ContextForkOutcome::Verified(proof),
+        Err(ContextForkTermination::Timeout { .. }) => {
+            ContextForkOutcome::Pending(PendingContextFork {
+                source_session_id: source_session_id.clone(),
+                target_agent: agent_id.to_string(),
+                spawned_at: spawned_at.to_string(),
+                scanner_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: plan.expected_session_id.clone(),
+                    provider_projects_root: plan.provider_projects_root.clone(),
+                },
+            })
+        }
+        Err(ContextForkTermination::Rejected(error)) => ContextForkOutcome::Rejected(error),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn convergence_deadlines_are_provider_specific() {
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Claude),
+            Duration::from_secs(45)
+        );
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Codex),
+            Duration::from_secs(10)
+        );
+        assert_eq!(
+            context_fork_convergence_deadline(Provider::Copilot),
+            Duration::from_secs(5)
+        );
+    }
+
+    #[test]
+    fn codex_without_new_backing_is_typed_pending() {
+        let root =
+            std::env::temp_dir().join(format!("ta-codex-fork-pending-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(&root).unwrap();
+        let plan = CommandPlan {
+            argv: Vec::new(),
+            expected_session_id: None,
+            provider_projects_root: Some(root.clone()),
+            managed_mcp_config: false,
+        };
+        let before = ContextBackingSnapshot::capture(Provider::Codex, &plan);
+        let outcome = observe_context_fork(
+            Provider::Codex,
+            &SessionId::new("source-session"),
+            &plan,
+            &before,
+            None,
+            "fork",
+            &root,
+            "2026-07-24T00:00:00Z",
+            Duration::ZERO,
+        );
+        let ContextForkOutcome::Pending(pending) = outcome else {
+            panic!("missing backing must remain a typed pending fork")
+        };
+        assert_eq!(pending.source_session_id.as_str(), "source-session");
+        assert_eq!(pending.target_agent, "fork");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+}

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

@@ -5,7 +5,28 @@ use std::time::{Duration, SystemTime};
 use crate::model::enums::Provider;
 use crate::provider::{CommandPlan, ProviderError, SessionId};
 
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum ContextForkTermination {
+    #[error(
+        "context_fork_unverified: {provider:?} produced no readable NEW session backing within {deadline_ms}ms"
+    )]
+    Timeout {
+        provider: Provider,
+        deadline_ms: u128,
+    },
+    #[error(transparent)]
+    Rejected(#[from] ProviderError),
+}
+
+mod claude;
+mod codex;
+mod outcome;
+pub(crate) use outcome::{
+    observe_context_fork, transition_pending_context_fork, ContextForkOutcome, PendingContextFork,
+};
+
 pub(crate) fn context_fork_convergence_deadline(provider: Provider) -> Duration {
+    // Expiration is consumed by ContextForkOutcome::Pending(PendingContextFork).
     match provider {
         Provider::Claude | Provider::ClaudeCode => Duration::from_secs(45),
         Provider::Codex => Duration::from_secs(10),
@@ -54,12 +75,12 @@ pub(crate) fn verify_context_fork(
     spawn_cwd: &Path,
     spawned_at: &str,
     deadline: Duration,
-) -> Result<ContextForkProof, ProviderError> {
+) -> Result<ContextForkProof, ContextForkTermination> {
     if provider == Provider::Copilot {
-        return verify_copilot_fork(source_session_id, plan);
+        return verify_copilot_fork(source_session_id, plan).map_err(Into::into);
     }
     if provider == Provider::Codex {
-        return verify_codex_fork(
+        return codex::verify_codex_fork(
             source_session_id,
             plan,
             before,
@@ -70,132 +91,20 @@ pub(crate) fn verify_context_fork(
         );
     }
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
-        return verify_claude_fork(
+        return claude::verify_claude_fork(
             provider,
             source_session_id,
             plan,
             before,
             expected_backing_path,
+            spawn_cwd,
             deadline,
         );
     }
     Err(ProviderError::CaptureFailed(format!(
         "context_fork_unverified: {provider:?} has no verifiable fork backing"
-    )))
-}
-fn verify_claude_fork(
-    provider: Provider,
-    source_session_id: &SessionId,
-    plan: &CommandPlan,
-    before: &ContextBackingSnapshot,
-    expected_backing_path: Option<&Path>,
-    deadline: Duration,
-) -> Result<ContextForkProof, ProviderError> {
-    let expected = plan.expected_session_id.as_ref().ok_or_else(|| {
-        ProviderError::CaptureFailed(
-            "context_fork_unverified: Claude plan has no expected session id".to_string(),
-        )
-    })?;
-    let path = expected_backing_path.ok_or_else(|| {
-        ProviderError::CaptureFailed(
-            "context_fork_unverified: Claude plan has no exact snapshot backing".to_string(),
-        )
-    })?;
-    let expected_name = format!("{}.jsonl", expected.as_str());
-    if path.file_name().and_then(|name| name.to_str()) != Some(expected_name.as_str()) {
-        return Err(ProviderError::CaptureFailed(format!(
-            "context_fork_unverified: Claude snapshot backing does not match expected session {}",
-            expected.as_str()
-        )));
-    }
-    let started = std::time::Instant::now();
-    loop {
-        if let Some(stamp) = file_stamp(path) {
-            let changed = before.files.get(path).is_none_or(|old| *old != stamp);
-            let observed_matches =
-                session_id_from_jsonl(path).is_none_or(|observed| observed == expected.as_str());
-            if changed && readable_jsonl(path) && observed_matches && expected != source_session_id
-            {
-                return Ok(ContextForkProof {
-                    provider,
-                    source_session_id: source_session_id.clone(),
-                    new_session_id: expected.clone(),
-                    backing_path: path.to_path_buf(),
-                    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(ProviderError::CaptureFailed(format!(
-        "context_fork_unverified: {provider:?} produced no readable NEW session backing within {}ms",
-        deadline.as_millis()
-    )))
-}
-
-fn verify_codex_fork(
-    source_session_id: &SessionId,
-    plan: &CommandPlan,
-    before: &ContextBackingSnapshot,
-    agent_id: &str,
-    spawn_cwd: &Path,
-    spawned_at: &str,
-    deadline: Duration,
-) -> Result<ContextForkProof, ProviderError> {
-    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: plan.expected_session_id.clone(),
-        provider_projects_root: plan.provider_projects_root.clone(),
-    };
-    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;
-            };
-            if before.files.get(path.as_path()) == Some(stamp) {
-                continue;
-            }
-            let Some(new_session_id) = candidate.captured.session_id else {
-                continue;
-            };
-            if new_session_id == *source_session_id {
-                continue;
-            }
-            return Ok(ContextForkProof {
-                provider: Provider::Codex,
-                source_session_id: source_session_id.clone(),
-                new_session_id,
-                backing_path: path.as_path().to_path_buf(),
-                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(ProviderError::CaptureFailed(format!(
-        "context_fork_unverified: Codex produced no readable NEW session backing within {}ms",
-        deadline.as_millis()
-    )))
+    ))
+    .into())
 }
 
 fn verify_copilot_fork(
@@ -242,6 +151,8 @@ fn verify_copilot_fork(
             "context_fork_unverified: copilot NEW session is absent from session-store".to_string(),
         ));
     }
+    // Copilot's isolated database row is its synchronous fork proof; the
+    // pre-spawn materialization baseline is never accepted by transcript scan.
     Ok(ContextForkProof {
         provider: Provider::Copilot,
         source_session_id: source_session_id.clone(),
@@ -335,22 +246,6 @@ mod tests {
     use super::*;
     use std::io::Write;
 
-    #[test]
-    fn context_fork_deadlines_are_provider_specific() {
-        assert_eq!(
-            context_fork_convergence_deadline(Provider::Claude),
-            Duration::from_secs(45)
-        );
-        assert_eq!(
-            context_fork_convergence_deadline(Provider::Codex),
-            Duration::from_secs(10)
-        );
-        assert_eq!(
-            context_fork_convergence_deadline(Provider::Copilot),
-            Duration::from_secs(5)
-        );
-    }
-
     #[test]
     fn codex_fork_proof_ignores_changed_stale_and_foreign_rollouts() {
         let root =

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

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

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

@@ -5,7 +5,7 @@ use crate::provider::Provider;
 
 use super::{CaptureSessionContext, CapturedSessionCandidate};
 
-pub(super) fn projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<PathBuf> {
+pub(crate) 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() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.56",
+  "version": "0.5.58",
   "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.56",
-    "@team-agent/cli-darwin-x64": "0.5.56",
-    "@team-agent/cli-linux-x64": "0.5.56"
+    "@team-agent/cli-darwin-arm64": "0.5.58",
+    "@team-agent/cli-darwin-x64": "0.5.58",
+    "@team-agent/cli-linux-x64": "0.5.58"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",