@team-agent/installer 0.5.57 → 0.5.59

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.57",
+  "version": "0.5.59",
   "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.57",
-    "@team-agent/cli-darwin-x64": "0.5.57",
-    "@team-agent/cli-linux-x64": "0.5.57"
+    "@team-agent/cli-darwin-arm64": "0.5.59",
+    "@team-agent/cli-darwin-x64": "0.5.59",
+    "@team-agent/cli-linux-x64": "0.5.59"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/SKILL.md

@@ -166,6 +166,7 @@ For diagnosis, run `team-agent profile show deepseek --workspace . --json`; neve
 - `quick-start` is only for first-time team creation from role docs. If that team already has runtime state, use `team-agent restart . --team <session_name_or_team_name>` to resume it. If restart cannot recover context, explain the loss and wait for explicit user consent before using `team-agent restart . --allow-fresh`; never reset context through quick-start.
 - If the user explicitly asks a worker to create or operate a nested child team, first read `references/team-in-team.md`. Child teams must use an independent child workspace, never the parent `.team/current`.
 - `team-agent send --watch-result coder "Do the bounded task"` sends a direct worker message, returns after delivery, and lets the coordinator collect/report completion asynchronously.
+- Positional `TO` has two co-equal forms: an in-team short name, for example `team-agent send reviewer "Review this change"`, and a fully-qualified logical name, `<workspace>::<team>/<agent>`. Use the fully-qualified form across workspaces or when the local team scope is ambiguous.
 - Advanced orchestration callers may add `--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]`. All sinks remain durable and pullable; `casefile`/`silent` suppress only live leader injection. Missing presentation metadata preserves the normal leader-visible behavior.
 - After `send --watch-result` succeeds, do not run `sleep`, `status`, `inbox`, or `collect` polling loops unless the user explicitly asks for diagnosis; the coordinator will notify the leader when the result arrives.
 - `team-agent send --task task_initial "Start"` routes by task.