@team-agent/installer 0.5.70 → 0.5.71

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.70"
+version = "0.5.71"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.70"
+version = "0.5.71"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/mod.rs

@@ -3393,6 +3393,40 @@ pub mod lifecycle_port {
                 Some(crate::cli::QUICK_START_REMINDER)
             );
         }
+
+        #[test]
+        fn spawn_failure_without_session_does_not_claim_a_worker_pane_exists() {
+            let value = restart_value(
+                crate::lifecycle::RestartReport::Failed {
+                    session_name: crate::transport::SessionName::new("team-current"),
+                    failed_agents: vec![crate::lifecycle::RestartFailedAgent {
+                        agent_id: crate::model::ids::AgentId::new("coder"),
+                        restart_mode: crate::lifecycle::StartMode::Fresh,
+                        decision: crate::lifecycle::ResumeDecision::FreshStart,
+                        session_id: None,
+                        phase: "spawn".to_string(),
+                        error: "provider io error".to_string(),
+                    }],
+                    next_actions: Vec::new(),
+                    attach_commands: Vec::new(),
+                },
+                None,
+            );
+            let action = value
+                .pointer("/failed_agents/0/action")
+                .and_then(Value::as_str)
+                .expect("spawn failure action");
+
+            assert!(
+                action.contains("before a pane was created"),
+                "action={action}"
+            );
+            assert!(
+                !action.contains("inspect worker coder output"),
+                "action={action}"
+            );
+            assert!(!action.contains("restart-agent"), "action={action}");
+        }
     }
 
     fn restart_value(report: crate::lifecycle::RestartReport, team: Option<&str>) -> Value {
@@ -3436,10 +3470,10 @@ pub mod lifecycle_port {
                     "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
                     "phase": failure.phase,
                     "error": failure.error,
-                    "action": format!(
-                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                        failure.agent_id,
-                        failure.agent_id
+                    "action": crate::lifecycle::restart_failure_action(
+                        &failure.agent_id,
+                        &failure.phase,
+                        failure.session_id.as_ref(),
                     ),
                     "log": format!(
                         ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
@@ -3470,10 +3504,10 @@ pub mod lifecycle_port {
                     "session_id": failure.session_id.as_ref().map(|session| session.as_str()),
                     "phase": failure.phase,
                     "error": failure.error,
-                    "action": format!(
-                        "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                        failure.agent_id,
-                        failure.agent_id
+                    "action": crate::lifecycle::restart_failure_action(
+                        &failure.agent_id,
+                        &failure.phase,
+                        failure.session_id.as_ref(),
                     ),
                     "log": format!(
                         ".team/logs/coordinator.log and .team/runtime/state.json agent={}",

package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs

@@ -450,13 +450,24 @@ pub(crate) fn validate_pi_wrapper_source(
 /// errors: identity、序列化、目录、写盘或 rename 失败时返回 ProviderError
 /// ---
 pub(crate) fn write_pi_wrapper(request: PiWrapperRequest<'_>) -> Result<PathBuf, ProviderError> {
+    write_pi_wrapper_with_publish(request, |from, to| std::fs::rename(from, to))
+}
+
+pub(crate) fn write_pi_wrapper_with_publish(
+    request: PiWrapperRequest<'_>,
+    publish: impl FnOnce(&Path, &Path) -> std::io::Result<()>,
+) -> Result<PathBuf, ProviderError> {
     let source = render_pi_wrapper(&request)?;
     validate_pi_wrapper_source(&source, request.adapter, request.candidate_executable)?;
     let parent = request.destination.parent().ok_or_else(|| {
         ProviderError::Io("Pi wrapper destination has no parent directory".to_string())
     })?;
-    std::fs::create_dir_all(parent)
-        .map_err(|error| ProviderError::Io(format!("{}: {error}", parent.display())))?;
+    std::fs::create_dir_all(parent).map_err(|error| {
+        ProviderError::Io(format!(
+            "Pi wrapper atomic write stage=create_parent path={}: {error}",
+            parent.display()
+        ))
+    })?;
     let temp = parent.join(format!(".team-mcp.ts.{}.tmp", std::process::id()));
     let write_result = (|| {
         let mut file = OpenOptions::new()
@@ -464,22 +475,38 @@ pub(crate) fn write_pi_wrapper(request: PiWrapperRequest<'_>) -> Result<PathBuf,
             .write(true)
             .mode(0o600)
             .open(&temp)
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        file.write_all(source.as_bytes())
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        file.sync_all()
-            .map_err(|error| ProviderError::Io(format!("{}: {error}", temp.display())))?;
-        std::fs::rename(&temp, request.destination).map_err(|error| {
+            .map_err(|error| {
+                ProviderError::Io(format!(
+                    "Pi wrapper atomic write stage=open_temp path={}: {error}",
+                    temp.display()
+                ))
+            })?;
+        file.write_all(source.as_bytes()).map_err(|error| {
             ProviderError::Io(format!(
-                "rename {} to {}: {error}",
-                temp.display(),
-                request.destination.display()
+                "Pi wrapper atomic write stage=write_temp path={}: {error}",
+                temp.display()
             ))
         })?;
-        std::fs::set_permissions(request.destination, std::fs::Permissions::from_mode(0o600))
+        file.set_permissions(std::fs::Permissions::from_mode(0o600))
             .map_err(|error| {
-                ProviderError::Io(format!("{}: {error}", request.destination.display()))
+                ProviderError::Io(format!(
+                    "Pi wrapper atomic write stage=chmod_temp_fd path={}: {error}",
+                    temp.display()
+                ))
             })?;
+        file.sync_all().map_err(|error| {
+            ProviderError::Io(format!(
+                "Pi wrapper atomic write stage=fsync_temp path={}: {error}",
+                temp.display()
+            ))
+        })?;
+        publish(&temp, request.destination).map_err(|error| {
+            ProviderError::Io(format!(
+                "Pi wrapper atomic write stage=rename_publish from={} to={}: {error}",
+                temp.display(),
+                request.destination.display()
+            ))
+        })?;
         Ok(request.destination.to_path_buf())
     })();
     if write_result.is_err() {

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

@@ -2522,10 +2522,10 @@ fn write_restart_agent_failed_event(
                 "session_id": decision.session_id.as_ref().map(|session| session.as_str()),
                 "phase": phase,
                 "error": error,
-                "action": format!(
-                    "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                    decision.agent_id,
-                    decision.agent_id
+                "action": restart_failure_action(
+                    &decision.agent_id,
+                    phase,
+                    decision.session_id.as_ref(),
                 ),
                 "log": format!(
                     ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
@@ -3008,14 +3008,30 @@ fn restart_failure_next_actions(failed_agents: &[RestartFailedAgent]) -> Vec<Str
     failed_agents
         .iter()
         .map(|failure| {
-            format!(
-                "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                failure.agent_id, failure.agent_id
+            restart_failure_action(
+                &failure.agent_id,
+                &failure.phase,
+                failure.session_id.as_ref(),
             )
         })
         .collect()
 }
 
+pub(crate) fn restart_failure_action(
+    agent_id: &AgentId,
+    phase: &str,
+    session_id: Option<&SessionId>,
+) -> String {
+    if phase == "spawn" && session_id.is_none() {
+        return format!(
+            "worker {agent_id} failed before a pane was created; inspect the reported provider error, then rerun `team-agent restart --allow-fresh`"
+        );
+    }
+    format!(
+        "inspect worker {agent_id} output, then reset that worker with `team-agent reset-agent {agent_id}` or rerun `team-agent restart --allow-fresh`"
+    )
+}
+
 fn start_mode_wire(mode: StartMode) -> &'static str {
     match mode {
         StartMode::Resumed => "resumed",

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

@@ -92,7 +92,8 @@ pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline
 // timer + worker timing writer so `lifecycle::launch::launch_with_transport_in_workspace`
 // can emit the same instrumentation event family with `source="launch"`.
 pub(crate) use rebuild::{
-    provider_wire_from_state, write_worker_spawn_timing_event, RestartPhaseTimer,
+    provider_wire_from_state, restart_failure_action, write_worker_spawn_timing_event,
+    RestartPhaseTimer,
 };
 pub use rebuild::{restart, restart_with_session_convergence_deadline};
 pub(crate) use rebuild::{

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

@@ -3,9 +3,10 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU32, Ordering};
 
 use crate::lifecycle::launch::pi_mcp::{
-    parse_pi_list_models_table, resolve_pi_executable_chain, validate_pi_adapter_identity,
-    validate_pi_executable_chain, validate_pi_wrapper_source, write_pi_wrapper, PiAdapterIdentity,
-    PiExecutableChain, PiExecutableFileType, PiWrapperRequest,
+    parse_pi_list_models_table, pi_seat_paths, resolve_pi_executable_chain,
+    validate_pi_adapter_identity, validate_pi_executable_chain, validate_pi_wrapper_source,
+    write_pi_wrapper, write_pi_wrapper_with_publish, PiAdapterIdentity, PiExecutableChain,
+    PiExecutableFileType, PiWrapperRequest,
 };
 use crate::provider::McpConfig;
 
@@ -336,6 +337,124 @@ fn pi_wrapper_is_atomic_body(hermetic: &HermeticTestEnv) {
     std::fs::remove_dir_all(root).expect("remove wrapper fixture");
 }
 
+#[test]
+fn pi_leader_wrapper_materializes_from_empty_unicode_wsl_workspace() {
+    let root = temp_root("empty-unicode-leader");
+    let workspace = root.join("mnt/f/测试基础设施");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(&workspace).expect("create empty Unicode workspace");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+    assert!(
+        !workspace.join(".team").exists(),
+        "fixture must begin without a .team directory"
+    );
+
+    let paths = pi_seat_paths(&workspace, "current", "leader");
+    let adapter = adapter_identity(&root);
+    let written = write_pi_wrapper(PiWrapperRequest {
+        destination: &paths.wrapper,
+        adapter: &adapter,
+        candidate_executable: &candidate,
+        mcp_config: &mcp_config(&candidate, &workspace, "leader"),
+        team_id: "current",
+        agent_id: "leader",
+        workspace: &workspace,
+        include_tools: &["assign_task", "send_message"],
+    })
+    .expect("materialize Pi leader wrapper from an empty Unicode workspace");
+
+    assert_eq!(written, paths.wrapper);
+    assert!(written.is_file(), "published leader wrapper must exist");
+    assert!(
+        paths.runtime_root.is_dir(),
+        "leader runtime root must be created recursively"
+    );
+    let source = std::fs::read_to_string(&written).expect("read complete leader wrapper");
+    validate_pi_wrapper_source(&source, &adapter, &candidate)
+        .expect("published leader wrapper must be complete and valid");
+    assert!(source.contains("TEAM_AGENT_ID") && source.contains("leader"));
+    assert!(source.contains("TEAM_AGENT_OWNER_TEAM_ID") && source.contains("current"));
+    std::fs::remove_dir_all(root).expect("remove Unicode leader fixture");
+}
+
+#[test]
+fn pi_wrapper_permissions_are_finalized_before_atomic_publish() {
+    let source = include_str!("../launch/pi_mcp.rs");
+    let write_start = source
+        .find("pub(crate) fn write_pi_wrapper")
+        .expect("write_pi_wrapper source");
+    let write_source = &source[write_start..];
+    let permissions = write_source
+        .find("file.set_permissions")
+        .expect("wrapper permissions must use the open temp-file handle");
+    let publish = write_source
+        .find("publish(&temp, request.destination)")
+        .expect("atomic wrapper publish");
+
+    assert!(
+        permissions < publish,
+        "DrvFS may not resolve the destination immediately after rename; finalize mode through the open temp-file handle before publishing"
+    );
+    assert!(
+        !write_source.contains("std::fs::set_permissions(request.destination"),
+        "atomic publish must not require a second destination-path lookup"
+    );
+}
+
+#[test]
+fn pi_wrapper_publish_needs_no_final_path_metadata_lookup() {
+    let root = temp_root("publish-path-enoent");
+    let workspace = root.join("mnt/f/测试基础设施");
+    let candidate = root.join("candidate/team-agent");
+    std::fs::create_dir_all(&workspace).expect("create Unicode workspace");
+    std::fs::create_dir_all(candidate.parent().expect("candidate parent"))
+        .expect("create candidate parent");
+    std::fs::write(&candidate, b"candidate").expect("write candidate fixture");
+
+    let paths = pi_seat_paths(&workspace, "current", "leader");
+    let published_parent = paths.runtime_root.clone();
+    let hidden_parent = published_parent.with_file_name("leader-after-rename");
+    let adapter = adapter_identity(&root);
+    write_pi_wrapper_with_publish(
+        PiWrapperRequest {
+            destination: &paths.wrapper,
+            adapter: &adapter,
+            candidate_executable: &candidate,
+            mcp_config: &mcp_config(&candidate, &workspace, "leader"),
+            team_id: "current",
+            agent_id: "leader",
+            workspace: &workspace,
+            include_tools: &["assign_task", "send_message"],
+        },
+        |temp, destination| {
+            std::fs::rename(temp, destination)?;
+            std::fs::rename(&published_parent, &hidden_parent)?;
+            assert_eq!(
+                std::fs::metadata(destination)
+                    .expect_err("simulate DrvFS final-path metadata ENOENT after rename")
+                    .kind(),
+                std::io::ErrorKind::NotFound
+            );
+            Ok(())
+        },
+    )
+    .expect("successful publish must not perform final-path metadata operations");
+
+    let published = hidden_parent.join("team-mcp.ts");
+    assert!(published.is_file(), "rename published a complete wrapper");
+    assert_eq!(
+        std::fs::metadata(&published)
+            .expect("published wrapper metadata through converged path")
+            .permissions()
+            .mode()
+            & 0o777,
+        0o600
+    );
+    std::fs::remove_dir_all(root).expect("remove publish-path fixture");
+}
+
 #[test]
 fn pi_wrapper_runtime_registration_does_not_copy_ambient_config() {
     run_process_isolated(PI_WRAPPER_AMBIENT_CHILD, PI_WRAPPER_AMBIENT_TEST, || {

package/package.json

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

package/skills/team-agent/SKILL.md

@@ -2,7 +2,7 @@
 name: team-agent
 description: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.
 requires_team_agent: ">=0.5.0"
-last_verified_against: "0.5.70"
+last_verified_against: "0.5.71"
 ---
 
 # Team Agent