@team-agent/installer 0.3.32 → 0.3.34

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.32"
+version = "0.3.34"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.32"
+version = "0.3.34"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/lifecycle/profile_launch.rs

@@ -157,7 +157,9 @@ fn prepare_profile_launch(
     let mut claude_projects_root = None;
     let mut managed_mcp_config = false;
 
-    if matches!(agent.provider, Provider::Claude | Provider::ClaudeCode) {
+    if matches!(agent.provider, Provider::Claude | Provider::ClaudeCode)
+        && agent.auth_mode == AuthMode::CompatibleApi
+    {
         let dir = compatible_claude_config_dir(workspace, &agent.id)?;
         if let Some(config) = mcp_config {
             ensure_compatible_claude_mcp_config(&dir, workspace, config)?;

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -471,7 +471,10 @@ pub(super) fn resume_backing_exists_for_agent(
             let _ = (workspace, agent_id, agent, session_id, rollout_path);
             false
         }
-        Provider::Codex => rollout_path_exists(rollout_path),
+        Provider::Codex => {
+            rollout_path_exists(rollout_path)
+                || codex_session_transcript_exists(agent, session_id.as_str(), rollout_path)
+        }
         Provider::Claude | Provider::ClaudeCode => {
             rollout_path_exists(rollout_path)
                 || event_log_transcript_exists(workspace, agent_id.as_str(), session_id.as_str())
@@ -557,6 +560,68 @@ fn claude_project_transcript_exists(agent: &serde_json::Value, session_id: &str)
         .any(|entry| entry.path().join(&transcript_name).is_file())
 }
 
+fn codex_session_transcript_exists(
+    agent: &serde_json::Value,
+    session_id: &str,
+    rollout_path: Option<&RolloutPath>,
+) -> bool {
+    if session_id.is_empty() {
+        return false;
+    }
+    let mut roots = Vec::new();
+    if let Some(parent) = rollout_path
+        .map(RolloutPath::as_path)
+        .and_then(Path::parent)
+        .filter(|path| path.is_dir())
+    {
+        roots.push(parent.to_path_buf());
+    }
+    if let Some(root) = agent
+        .get("codex_sessions_root")
+        .and_then(serde_json::Value::as_str)
+        .filter(|path| !path.is_empty())
+        .map(PathBuf::from)
+        .filter(|path| path.is_dir())
+    {
+        roots.push(root);
+    }
+    if let Some(root) = std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .map(|home| home.join(".codex").join("sessions"))
+        .filter(|path| path.is_dir())
+    {
+        roots.push(root);
+    }
+    roots.sort();
+    roots.dedup();
+    roots
+        .iter()
+        .any(|root| session_transcript_exists_under(root, session_id, 4))
+}
+
+fn session_transcript_exists_under(root: &Path, session_id: &str, max_depth: usize) -> bool {
+    let Ok(entries) = std::fs::read_dir(root) else {
+        return false;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_file() {
+            let Some(name) = path.file_name().and_then(|name| name.to_str()) else {
+                continue;
+            };
+            if name.ends_with(".jsonl") && name.contains(session_id) {
+                return true;
+            }
+        } else if max_depth > 0
+            && path.is_dir()
+            && session_transcript_exists_under(&path, session_id, max_depth.saturating_sub(1))
+        {
+            return true;
+        }
+    }
+    false
+}
+
 fn copilot_session_store_has_session(session_id: &str) -> bool {
     let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
         return false;
@@ -1082,4 +1147,41 @@ mod e36_transcript_backing_tests {
         let agent = serde_json::json!({});
         assert!(!claude_project_transcript_exists(&agent, ""));
     }
+
+    #[test]
+    fn codex_session_transcript_is_recognized_when_rollout_path_is_stale() {
+        let scratch = ScratchDir::new("codex-recognized");
+        let sessions_root = scratch.path().join("sessions");
+        let dated = sessions_root.join("2026").join("06").join("20");
+        std::fs::create_dir_all(&dated).expect("mkdir dated sessions");
+        let session_id = "019ee540-37ed-7a20-a141-1d654224d209";
+        std::fs::write(
+            dated.join(format!("rollout-2026-06-20T21-37-31-{session_id}.jsonl")),
+            b"{}\n",
+        )
+        .expect("codex transcript");
+
+        let stale = RolloutPath::new(scratch.path().join("old").join("missing.jsonl"));
+        let agent = serde_json::json!({
+            "codex_sessions_root": sessions_root.to_string_lossy(),
+        });
+        assert!(
+            codex_session_transcript_exists(&agent, session_id, Some(&stale)),
+            "matching codex transcript under codex_sessions_root must count as resume backing"
+        );
+    }
+
+    #[test]
+    fn missing_codex_session_transcript_is_not_backing() {
+        let scratch = ScratchDir::new("codex-missing");
+        let sessions_root = scratch.path().join("sessions");
+        std::fs::create_dir_all(&sessions_root).expect("mkdir sessions");
+        let agent = serde_json::json!({
+            "codex_sessions_root": sessions_root.to_string_lossy(),
+        });
+        assert!(
+            !codex_session_transcript_exists(&agent, "019ee540-ffff-7a20-a141-1d654224d209", None,),
+            "no matching codex transcript => no backing"
+        );
+    }
 }

package/crates/team-agent/src/lifecycle/restart/rebuild.rs

@@ -172,7 +172,7 @@ pub fn restart_with_transport_with_session_convergence_deadline(
     if !convergence.converged && convergence.changed {
         save_restart_state(&selected.run_workspace, &mut state, &selected.team_key)?;
     }
-    let mut forced_fresh_missing = if convergence.converged {
+    let forced_fresh_missing = if convergence.converged {
         std::collections::BTreeSet::new()
     } else {
         convergence.missing.iter().cloned().collect()
@@ -183,12 +183,6 @@ pub fn restart_with_transport_with_session_convergence_deadline(
         &state,
         allow_fresh,
     )?;
-    for decision in &plan.decisions {
-        if matches!(decision.decision, ResumeDecision::FreshStart) && decision.session_id.is_some()
-        {
-            forced_fresh_missing.insert(decision.agent_id.as_str().to_string());
-        }
-    }
     write_restart_resume_decision_events(
         &selected.run_workspace,
         &state,

package/crates/team-agent/src/lifecycle/restart.rs

@@ -43,6 +43,7 @@ pub use rebuild::{
     restart, restart_candidates, restart_with_session_convergence_deadline, restart_with_transport,
     restart_with_transport_with_readiness_deadline, select_restart_state,
 };
+pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline;
 pub use remove::{remove_agent, remove_agent_with_transport};
 pub use selection::{classify_first_send_at, classify_restart_plan, decide_start_mode, python_type_name};
 pub(crate) use team_state::write_team_state;

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -1533,6 +1533,107 @@ fn restart_with_transport_spawns_resumable_workers_not_stub() {
     );
 }
 
+#[test]
+fn restart_allow_fresh_does_not_force_fresh_other_agents_when_one_session_capture_times_out() {
+    let ws = temp_ws().join("restartatomic");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartatomic\nobjective: Restart atomicity probe.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(ws.join("agents").join("alpha.md"), DELEG_ROLE_ALPHA).unwrap();
+    std::fs::write(ws.join("agents").join("bravo.md"), DELEG_ROLE_BRAVO).unwrap();
+
+    let sessions_root = ws.join("codex-sessions");
+    let dated = sessions_root.join("2026").join("06").join("20");
+    std::fs::create_dir_all(&dated).unwrap();
+    let alpha_session = "019ee540-37ed-7a20-a141-1d654224d209";
+    std::fs::write(
+        dated.join(format!(
+            "rollout-2026-06-20T21-37-31-{alpha_session}.jsonl"
+        )),
+        "{}\n",
+    )
+    .unwrap();
+
+    let spec = crate::compiler::compile_team(&ws).expect("compile restart team");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-restartatomic",
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": alpha_session,
+                    "rollout_path": ws.join("stale").join("missing-alpha.jsonl").to_string_lossy(),
+                    "codex_sessions_root": sessions_root.to_string_lossy(),
+                    "first_send_at": "2026-05-27T10:00:00+00:00"
+                },
+                "bravo": {
+                    "status": "running",
+                    "provider": "codex",
+                    "session_id": null,
+                    "spawn_cwd": ws.to_string_lossy(),
+                    "first_send_at": "2026-05-27T10:00:00+00:00"
+                }
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&ws);
+    let transport = OfflineTransport::new();
+
+    let result = restart_with_transport_with_session_convergence_deadline(
+        &ws,
+        true,
+        None,
+        &transport,
+        Some(0),
+        None,
+    );
+
+    assert!(
+        matches!(result, Ok(RestartReport::Restarted { .. })),
+        "allow-fresh restart should complete with alpha resumed and bravo fresh; got {result:?}"
+    );
+    let events = crate::event_log::EventLog::new(&ws).tail(80).unwrap();
+    let decisions = events
+        .iter()
+        .filter(|event| {
+            event.get("event").and_then(|v| v.as_str()) == Some("restart.resume_decision")
+        })
+        .collect::<Vec<_>>();
+    let alpha = decisions
+        .iter()
+        .find(|event| event.get("worker_id").and_then(|v| v.as_str()) == Some("alpha"))
+        .expect("alpha decision");
+    assert_eq!(
+        alpha.get("decision").and_then(|v| v.as_str()),
+        Some("resume"),
+        "alpha has session_id plus matching codex transcript and must not be forced fresh: {alpha}"
+    );
+    assert!(
+        alpha.get("forced_fresh").is_none(),
+        "alpha must not inherit bravo's convergence timeout: {alpha}"
+    );
+    let bravo = decisions
+        .iter()
+        .find(|event| event.get("worker_id").and_then(|v| v.as_str()) == Some("bravo"))
+        .expect("bravo decision");
+    assert_eq!(
+        bravo.get("decision").and_then(|v| v.as_str()),
+        Some("fresh_start")
+    );
+    assert_eq!(
+        bravo.get("forced_fresh").and_then(|v| v.as_bool()),
+        Some(true),
+        "only the missing-session agent should carry forced_fresh: {bravo}"
+    );
+}
+
 #[test]
 fn restart_spawn_failure_isolated_to_partial_report() {
     let ws = restart_ws_two_resumable_workers();

package/crates/team-agent/src/provider/adapter.rs

@@ -1476,7 +1476,6 @@ fn claude_base_command(
         };
         argv.push("--mcp-config".to_string());
         argv.push(raw.to_string());
-        argv.push("--strict-mcp-config".to_string());
     }
     for tool in claude_disallowed_tools(tools) {
         argv.push("--disallowedTools".to_string());

package/crates/team-agent/src/provider/tests/adapter.rs

@@ -215,6 +215,31 @@ fn build_command_includes_model_and_system_prompt() {
     );
 }
 
+#[test]
+fn claude_mcp_config_does_not_enable_strict_mode() {
+    let adapter = get_adapter(Provider::ClaudeCode);
+    let config = adapter
+        .mcp_config(AuthMode::Subscription)
+        .expect("mcp config");
+    let argv = adapter
+        .build_command(
+            AuthMode::Subscription,
+            Some(&config),
+            Some("worker"),
+            Some("opus"),
+        )
+        .expect("build command with mcp config");
+
+    assert!(
+        argv_contains_adjacent(&argv, &["--mcp-config"]),
+        "Claude worker argv must still pass Team Agent MCP config: {argv:?}"
+    );
+    assert!(
+        !argv.iter().any(|arg| arg == "--strict-mcp-config"),
+        "--mcp-config must merge with user-level Claude MCP; strict mode hides user MCP: {argv:?}"
+    );
+}
+
 #[test]
 fn unsupported_provider_capability_error_message_shape() {
     // unsupported.py:31 ProviderCapabilityError — placeholder providers reject
@@ -236,4 +261,3 @@ fn unsupported_provider_capability_error_message_shape() {
 // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
 // Lock the CORRECT Python v0.2.11 behavior the strengthened contracts missed.
 // Golden re-probed via /tmp/probe_p2_provider.py vs team-agent-public @ 439bef8.
-

package/package.json

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