@team-agent/installer 0.5.52 → 0.5.53

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

@@ -335,7 +335,7 @@ where
         //   * `transcript_missing` — trigger event has fired (report_result /
         //     first_send_at / pane_output_advanced) AND elapsed > threshold
         //     AND zero candidates / no backing
-        //   * `waiting_for_transcript` — still in grace period
+        //   * `pending_first_turn` — no verified backing yet, still in grace
         // The state field surfaces in status/diagnose without changing the
         // authoritative tuple contract (we never write session_id without
         // backing). Throttled event emission is done by the caller (tick).
@@ -415,11 +415,11 @@ where
 /// 0.4.6 Stage 3: classify a pending agent's capture state into one of:
 ///   * `transcript_missing` — has had a strong trigger event AND elapsed
 ///     beyond grace threshold AND still no backing
-///   * `waiting_for_transcript` — still in grace period or no trigger yet
+///   * `pending_first_turn` — still in grace period or no trigger yet
 ///
 /// Trigger events (CR M2): any of `first_send_at`, `last_result_at`, or a
 /// recent `last_pane_output_at` indicates the worker has been interactively
-/// used / done something. Without ANY trigger, we stay in waiting state
+/// used / done something. Without ANY trigger, we stay pending
 /// even past the grace window (silent worker is not a failure to capture).
 ///
 /// Threshold: 30 seconds from spawned_at OR 15 seconds from the first
@@ -477,7 +477,7 @@ fn classify_pending_capture_state(
     if has_trigger && past_spawn_grace && past_trigger_grace && candidate_count == 0 {
         "transcript_missing"
     } else {
-        "waiting_for_transcript"
+        "pending_first_turn"
     }
 }
 
@@ -488,8 +488,7 @@ pub fn incomplete_resumable_agent_ids(state: &Value) -> Vec<String> {
     let mut out = agents
         .iter()
         .filter_map(|(agent_id, agent)| {
-            if pending_session_capture(agent_id, agent, &mut crate::provider::get_adapter).is_some()
-            {
+            if incomplete_resumable_provider(agent, &mut crate::provider::get_adapter).is_some() {
                 Some(agent_id.clone())
             } else {
                 None
@@ -651,27 +650,20 @@ fn pending_session_capture<F>(
 where
     F: FnMut(Provider) -> Box<dyn ProviderAdapter>,
 {
-    if agent
-        .get("status")
-        .and_then(Value::as_str)
-        .is_some_and(|status| status != "running")
-    {
-        return None;
-    }
-    if agent_session_complete(agent) {
-        return None;
-    }
-    let provider = agent
-        .get("provider")
-        .and_then(Value::as_str)
-        .and_then(parse_provider)?;
+    let provider = incomplete_resumable_provider(agent, adapter_for)?;
     let spawn_cwd = agent
         .get("spawn_cwd")
         .and_then(Value::as_str)
         .filter(|cwd| !cwd.is_empty())?;
-    if !adapter_for(provider).caps().resume {
-        return None;
-    }
+    // New cohorts carry a boundary and are filtered fail-closed by the
+    // canonical scanner. Legacy rows may predate spawned_at; keep their
+    // boundary absent so they can still use the allocator's identity,
+    // collision, and unique-candidate guards instead of being skipped.
+    let spawned_at = agent
+        .get("spawned_at")
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string);
     Some(PendingSessionCapture {
         agent_id: agent_id.to_string(),
         provider,
@@ -694,25 +686,7 @@ where
                 .get("pane_pid")
                 .and_then(Value::as_u64)
                 .and_then(|pid| u32::try_from(pid).ok()),
-            spawned_at: agent
-                .get("spawned_at")
-                .and_then(Value::as_str)
-                .filter(|value| !value.is_empty())
-                .map(str::to_string),
-            // 0.3.31 Codex capture correction: Codex does NOT honor
-            // `--session-id`, so any `_pending_session_id` stored for a Codex
-            // agent (stale 0.3.30 state, or the framework's pre-spawn token)
-            // is a local-only token and must NOT be used as expected_session_id
-            // — that would trigger the Stage 1 mismatch guard against Codex's
-            // real session_meta.payload.id and permanently reject the correct
-            // transcript. Codex capture anchors purely on (cwd, spawned_at).
-            // 0.4.7 (B1 verified, partial-resume revert of 9feafc31):
-            // Claude --session-id was restored in adapter.rs build_command_plan
-            // because Claude ≥ 2.1.185 DOES honour framework-supplied session
-            // id and DOES create a transcript at that id. So `_pending_session_id`
-            // is once again valid for Claude — re-enable the Stage 1 pre-pass
-            // for Claude/ClaudeCode. Codex remains excluded (Codex CLI ignores
-            // --session-id, capture must anchor purely on cwd+spawned_at).
+            spawned_at,
             expected_session_id: if matches!(provider, Provider::Codex) {
                 None
             } else {
@@ -731,6 +705,34 @@ where
     })
 }
 
+fn incomplete_resumable_provider<F>(agent: &Value, adapter_for: &mut F) -> Option<Provider>
+where
+    F: FnMut(Provider) -> Box<dyn ProviderAdapter>,
+{
+    if agent
+        .get("status")
+        .and_then(Value::as_str)
+        .is_some_and(|status| status != "running")
+    {
+        return None;
+    }
+    if agent_session_complete(agent) {
+        return None;
+    }
+    let provider = agent
+        .get("provider")
+        .and_then(Value::as_str)
+        .and_then(parse_provider)?;
+    agent
+        .get("spawn_cwd")
+        .and_then(Value::as_str)
+        .filter(|cwd| !cwd.is_empty())?;
+    if !adapter_for(provider).caps().resume {
+        return None;
+    }
+    Some(provider)
+}
+
 fn agent_session_complete(agent: &Value) -> bool {
     // RM-039-SESS-001 step 1 (architect verdict 2026-06-22): historically
     // this returned true the moment `rollout_path` was non-empty — even when
@@ -1150,13 +1152,26 @@ fn claimed_provider_session_keys(
 ) -> BTreeSet<String> {
     let mut keys = BTreeSet::new();
     let team_key = crate::state::projection::team_state_key(state);
-    // 1. Non-pending worker sessions (existing behaviour).
+    // 1. Every other already-known worker session. The pending row itself is
+    // excluded so an incomplete tuple can still be repaired in place.
     for (agent_id, agent) in agents {
         if pending_ids.contains(agent_id) {
             continue;
         }
         push_provider_session_keys(&mut keys, &team_key, agent_id, agent);
     }
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for (nested_team_key, team_state) in teams {
+            if let Some(nested_agents) = team_state.get("agents").and_then(Value::as_object) {
+                for (agent_id, agent) in nested_agents {
+                    if nested_team_key == &team_key && pending_ids.contains(agent_id) {
+                        continue;
+                    }
+                    push_provider_session_keys(&mut keys, nested_team_key, agent_id, agent);
+                }
+            }
+        }
+    }
     // 2. P0 (lane-046-capture-gap): leader anchor sessions. The leader's
     //    own provider transcript must never be attributed to a worker. Scan
     //    state.leader_receiver, state.team_owner, and the same fields under
@@ -1207,6 +1222,12 @@ fn push_provider_session_keys(
             keys.insert(global_session_attribution_key_string(session_id));
         }
     }
+    // Copilot stores every session in one shared session-store.db. Session id
+    // is the attribution identity; treating the shared DB path as globally
+    // exclusive makes an exact expected id collide with every sibling.
+    if matches!(provider, Provider::Copilot) {
+        return;
+    }
     for field in ["rollout_path", "transcript_path"] {
         if let Some(path) = value
             .get(field)
@@ -1246,15 +1267,17 @@ fn captured_provider_session_keys(
         }
         keys.insert(global_session_attribution_key_string(session_id.as_str()));
     }
-    if let Some(rollout_path) = &captured.rollout_path {
-        let path = rollout_path.as_path().to_string_lossy();
-        keys.insert(transcript_attribution_key_string(
-            owner.provider,
-            team_key,
-            owner.agent_id.as_str(),
-            &path,
-        ));
-        keys.insert(global_transcript_attribution_key_string(&path));
+    if !matches!(owner.provider, Provider::Copilot) {
+        if let Some(rollout_path) = &captured.rollout_path {
+            let path = rollout_path.as_path().to_string_lossy();
+            keys.insert(transcript_attribution_key_string(
+                owner.provider,
+                team_key,
+                owner.agent_id.as_str(),
+                &path,
+            ));
+            keys.insert(global_transcript_attribution_key_string(&path));
+        }
     }
     keys
 }
@@ -1869,6 +1892,187 @@ mod u1_tests {
         );
     }
 
+    #[test]
+    fn pending_capture_state_stays_pending_until_a_trigger_expires() {
+        let old = (chrono::Utc::now() - chrono::Duration::seconds(60)).to_rfc3339();
+        let mut agent = serde_json::Map::new();
+        agent.insert("spawned_at".to_string(), serde_json::json!(old));
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "pending_first_turn"
+        );
+
+        let trigger = (chrono::Utc::now() - chrono::Duration::seconds(20)).to_rfc3339();
+        agent.insert("first_send_at".to_string(), serde_json::json!(trigger));
+        assert_eq!(
+            super::classify_pending_capture_state(&agent, 0),
+            "transcript_missing"
+        );
+    }
+
+    #[test]
+    fn canonical_pending_capture_preserves_legacy_missing_boundary() {
+        let agent = serde_json::json!({
+            "provider": "codex",
+            "status": "running",
+            "spawn_cwd": "/tmp/u1-cwd",
+            "capture_state": "pending_first_turn"
+        });
+        let mut adapter_for = crate::provider::get_adapter;
+        let pending = pending_session_capture("clone", &agent, &mut adapter_for)
+            .expect("legacy row still participates in canonical capture");
+        assert_eq!(pending.context.spawned_at, None);
+    }
+
+    #[test]
+    fn canonical_delayed_capture_rejects_prior_round_codex_rollout() {
+        let dir =
+            std::env::temp_dir().join(format!("ta-delayed-stale-codex-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let stale =
+            dir.join("rollout-2026-07-21T23-18-28-019f8541-c986-7f50-b9e6-6503c89df98c.jsonl");
+        std::fs::write(
+            &stale,
+            format!(
+                "{{\"session_meta\":{{\"payload\":{{\"id\":\"019f8541-c986-7f50-b9e6-6503c89df98c\",\"cwd\":\"{}\",\"created_at\":\"2026-07-21T23:18:28+00:00\"}}}}}}\n",
+                dir.to_string_lossy()
+            ),
+        )
+        .unwrap();
+        let mut state = serde_json::json!({
+            "agents": {
+                "clone": {
+                    "provider": "codex",
+                    "status": "running",
+                    "spawn_cwd": dir.to_string_lossy(),
+                    "spawned_at": "2026-07-22T02:12:27+00:00",
+                    "capture_state": "pending_first_turn"
+                }
+            }
+        });
+        let mut adapter_for = crate::provider::get_adapter;
+
+        let report = capture_missing_provider_sessions_once(&mut state, &mut adapter_for, true, 0)
+            .expect("delayed capture pass");
+
+        assert!(report.assigned.is_empty());
+        assert!(state["agents"]["clone"]["session_id"].is_null());
+        assert_ne!(
+            state["agents"]["clone"]["capture_state"],
+            serde_json::json!("captured")
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn canonical_delayed_capture_ignores_active_foreign_cwd_rollouts() {
+        use std::io::Write;
+
+        let root =
+            std::env::temp_dir().join(format!("ta-codex-dirty-domain-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let current_cwd = root.join("current");
+        let foreign_cwd = root.join("foreign");
+        std::fs::create_dir_all(&current_cwd).unwrap();
+        std::fs::create_dir_all(&foreign_cwd).unwrap();
+        let stale_current = current_cwd.join(
+            "cache/current/rollout-2026-07-21T23-18-28-019f8541-c986-7f50-b9e6-6503c89df98c.jsonl",
+        );
+        let fresh_foreign = current_cwd.join(
+            "cache/foreign/rollout-2026-07-22T04-01-00-019f8644-7060-7000-8000-000000000001.jsonl",
+        );
+        let fresh_current = current_cwd.join(
+            "cache/current/rollout-2026-07-22T04-01-01-019f8644-7450-7000-8000-000000000002.jsonl",
+        );
+        let write_rollout = |path: &std::path::Path, cwd: &std::path::Path, id: &str| {
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(
+                path,
+                format!(
+                    "{{\"type\":\"session_meta\",\"payload\":{{\"id\":\"{id}\",\"cwd\":\"{}\"}}}}\n",
+                    cwd.to_string_lossy()
+                ),
+            )
+            .unwrap();
+        };
+        write_rollout(&stale_current, &current_cwd, "stale-current");
+        write_rollout(&fresh_foreign, &foreign_cwd, "fresh-foreign");
+        write_rollout(&fresh_current, &current_cwd, "fresh-current");
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&stale_current)
+            .unwrap()
+            .write_all(b"{\"type\":\"event_msg\"}\n")
+            .unwrap();
+        let mut state = serde_json::json!({
+            "agents": {"clone": {
+                "provider": "codex", "status": "running",
+                "spawn_cwd": current_cwd.to_string_lossy(),
+                "spawned_at": "2026-07-21T20:00:00+00:00",
+                "capture_state": "pending_first_turn"
+            }}
+        });
+        let mut adapter_for = crate::provider::get_adapter;
+
+        let report = capture_missing_provider_sessions_once(&mut state, &mut adapter_for, true, 0)
+            .expect("canonical delayed capture");
+
+        assert_eq!(report.candidate_count_by_agent.get("clone"), Some(&1));
+        assert_eq!(state["agents"]["clone"]["session_id"], "fresh-current");
+        assert_eq!(state["agents"]["clone"]["capture_state"], "captured");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn existing_team_session_is_rejected_while_fresh_candidate_is_accepted() {
+        let mut state = serde_json::json!({
+            "session_name": "current",
+            "agents": {
+                "clone": {
+                    "provider": "codex",
+                    "status": "running",
+                    "spawn_cwd": "/tmp/u1-cwd"
+                }
+            },
+            "teams": {
+                "archived": {
+                    "agents": {
+                        "old-seat": {
+                            "provider": "codex",
+                            "session_id": "stale-session",
+                            "rollout_path": "/tmp/stale.jsonl"
+                        }
+                    }
+                }
+            }
+        });
+        let mut canned = BTreeMap::new();
+        canned.insert(
+            "clone".to_string(),
+            vec![
+                worker_owned_candidate("stale-session", "/tmp/stale.jsonl"),
+                worker_owned_candidate("fresh-session", "/tmp/fresh.jsonl"),
+            ],
+        );
+        let canned_for_adapter = canned.clone();
+        let mut adapter_for = move |provider| {
+            Box::new(
+                test_support::CaptureCandidatesAdapter::new(provider, None, "")
+                    .with_candidates(canned_for_adapter.clone()),
+            ) as Box<dyn ProviderAdapter>
+        };
+
+        let report = capture_missing_provider_sessions_once(&mut state, &mut adapter_for, true, 0)
+            .expect("capture pass succeeds");
+
+        assert_eq!(report.assigned, vec!["clone".to_string()]);
+        assert_eq!(
+            state["agents"]["clone"]["session_id"].as_str(),
+            Some("fresh-session")
+        );
+    }
+
     #[test]
     fn capture_pass_keeps_pending_agent_when_one_adapter_capture_fails() {
         let mut state = serde_json::json!({
@@ -2102,6 +2306,71 @@ mod u1_tests {
         let _ = std::fs::remove_dir(&dir);
     }
 
+    #[test]
+    fn copilot_exact_session_id_does_not_collide_on_shared_store_path() {
+        use crate::provider::{CaptureVia, Confidence, RolloutPath};
+        let dir =
+            std::env::temp_dir().join(format!("ta-copilot-shared-store-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let store = dir.join("session-store.db");
+        std::fs::write(&store, b"fixture").unwrap();
+        let expected = "22222222-2222-4222-8222-222222222222";
+        let candidate = CapturedSessionCandidate {
+            captured: CapturedSession {
+                session_id: Some(SessionId::new(expected)),
+                rollout_path: Some(RolloutPath::new(store.clone())),
+                captured_via: CaptureVia::FsWatch,
+                attribution_confidence: Confidence::High,
+                spawn_cwd: dir.clone(),
+            },
+            embedded_agent_id: None,
+            positive_agent_id_match: false,
+            agent_path_match: false,
+        };
+        let mut by_agent = BTreeMap::new();
+        by_agent.insert("clone".to_string(), vec![candidate]);
+        let mut state = serde_json::json!({
+            "agents": {
+                "source": {
+                    "provider": "copilot",
+                    "status": "running",
+                    "spawn_cwd": dir.to_string_lossy(),
+                    "session_id": "11111111-1111-4111-8111-111111111111",
+                    "rollout_path": store.to_string_lossy(),
+                    "captured_at": "2026-07-22T01:00:00+00:00",
+                    "captured_via": "fs_watch"
+                },
+                "clone": {
+                    "provider": "copilot",
+                    "status": "running",
+                    "spawn_cwd": dir.to_string_lossy(),
+                    "spawned_at": "2026-07-22T02:00:00+00:00",
+                    "_pending_session_id": expected
+                }
+            }
+        });
+        let adapter = test_support::CaptureCandidatesAdapter::new(Provider::Copilot, None, "")
+            .with_candidates(by_agent);
+        let mut adapter_for =
+            move |_provider| Box::new(adapter.clone()) as Box<dyn ProviderAdapter>;
+
+        let report = capture_missing_provider_sessions_once(&mut state, &mut adapter_for, true, 0)
+            .expect("capture shared Copilot store");
+
+        assert_eq!(report.assigned, vec!["clone".to_string()]);
+        assert_eq!(state["agents"]["clone"]["session_id"], expected);
+        assert_eq!(
+            state["agents"]["clone"]["rollout_path"],
+            store.to_string_lossy().as_ref()
+        );
+        assert_eq!(
+            state["agents"]["source"]["session_id"],
+            "11111111-1111-4111-8111-111111111111"
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     /// E57 RED postflight (lane-046-capture-gap): `recover_resume_session_from_events`
     /// must refuse to repair a worker's session from a stale `session.captured`
     /// event whose rollout file is a Claude LEADER transcript