@team-agent/installer 0.5.70 → 0.5.72

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/lane_ops.rs

@@ -1846,3 +1846,171 @@ fn lanea_fork_rollback_complete_on_post_spawn_failure() {
     // Golden contract (operations.py:384-394): a post-spawn failure kills the spawned window, restores
     // the old spec text + prior state, and runs cleanup_mcp before re-raising.
 }
+
+#[test]
+fn schema_invalid_pi_role_is_rejected_before_normal_and_force_mutation() {
+    let ws = lanea_ws_agents(json!({
+        "alpha": { "status": "stopped", "provider": "codex", "window": "alpha" },
+        "bravo": { "status": "running", "provider": "codex", "window": "bravo" }
+    }));
+    let tx = LaneTransport::new("team-laneateam", &[]);
+    seed_healthy_coordinator(&ws);
+    let role_dir = ws.join("role-masters");
+    std::fs::create_dir_all(&role_dir).unwrap();
+    let role = role_dir.join("invalid-pi.md");
+    std::fs::write(
+        &role,
+        CHARLIE_ROLE
+            .replace(
+                "provider: codex\nmodel: gpt-5.5",
+                "provider: pi\nmodel: openai-codex/gpt-5.6-sol",
+            )
+            .replace("  - mcp_team", "  - fs_read"),
+    )
+    .unwrap();
+
+    let spec_path = selected_spec_path(&ws);
+    let state_path = crate::state::persist::runtime_state_path(&ws);
+    let event_path = ws.join(".team/logs/events.jsonl");
+    let copied_role = ws.join("agents/charlie.md");
+    let team_state_path = ws.join("team_state.md");
+    let charlie_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
+        &ws,
+        "laneateam",
+        "charlie",
+    );
+    let alpha_paths =
+        crate::lifecycle::launch::pi_mcp::pi_seat_paths(&ws, "laneateam", "alpha");
+    let spec_before = std::fs::read(&spec_path).unwrap();
+    let state_before = std::fs::read(&state_path).unwrap();
+    let role_before = std::fs::read(&role).unwrap();
+    let alpha_before = serde_json::from_slice::<serde_json::Value>(&state_before).unwrap()
+        ["agents"]["alpha"]
+        .clone();
+    for path in [
+        &event_path,
+        &copied_role,
+        &team_state_path,
+        &charlie_paths.wrapper,
+        &charlie_paths.sessions,
+        &alpha_paths.wrapper,
+        &alpha_paths.sessions,
+    ] {
+        assert!(!path.exists(), "precondition: {} must be absent", path.display());
+    }
+
+    let assert_schema_error = |error: crate::lifecycle::LifecycleError| match error {
+        crate::lifecycle::LifecycleError::Compile(message) => {
+            assert!(message.contains("Pi roles require mcp_team"), "{message}");
+        }
+        other => panic!("expected Pi role schema error, got {other:?}"),
+    };
+    let assert_unchanged = |expected_role: &[u8]| {
+        assert_eq!(spec_before, std::fs::read(&spec_path).unwrap());
+        assert_eq!(state_before, std::fs::read(&state_path).unwrap());
+        assert_eq!(expected_role, std::fs::read(&role).unwrap());
+        for path in [
+            &event_path,
+            &copied_role,
+            &team_state_path,
+            &charlie_paths.wrapper,
+            &charlie_paths.sessions,
+            &alpha_paths.wrapper,
+            &alpha_paths.sessions,
+        ] {
+            assert!(!path.exists(), "preflight created {}", path.display());
+        }
+        let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+        assert_eq!(state["agents"]["alpha"], alpha_before);
+        assert!(state["agents"].get("charlie").is_none(), "no reservation row");
+        assert!(tx.spawns().is_empty());
+        assert!(tx.killed().is_empty());
+    };
+
+    let mut normal_calls = 0;
+    let mut normal_discover = |_requested: &str| {
+        normal_calls += 1;
+        Ok(Vec::new())
+    };
+    let normal = crate::lifecycle::add_agent_with_transport_pi_preflight(
+        &ws,
+        &aid("charlie"),
+        &role,
+        false,
+        None,
+        &tx,
+        &mut normal_discover,
+    )
+    .expect_err("invalid Pi schema must fail before reservation");
+    drop(normal_discover);
+    assert_eq!(normal_calls, 0);
+    assert_schema_error(normal);
+    assert_unchanged(&role_before);
+
+    let mut force_calls = 0;
+    let mut force_discover = |_requested: &str| {
+        force_calls += 1;
+        Ok(Vec::new())
+    };
+    let force = crate::lifecycle::add_agent_with_transport_force_pi_preflight(
+        &ws,
+        &aid("alpha"),
+        &role,
+        false,
+        None,
+        true,
+        &tx,
+        &mut force_discover,
+    )
+    .expect_err("invalid Pi replacement schema must fail before old-seat consumption");
+    drop(force_discover);
+    assert_eq!(force_calls, 0);
+    assert_schema_error(force);
+    assert_unchanged(&role_before);
+
+    std::fs::write(
+        &role,
+        CHARLIE_ROLE.replace(
+            "provider: codex\nmodel: gpt-5.5",
+            "provider: pi\nmodel: gpt-5.6-sol",
+        ),
+    )
+    .unwrap();
+    let model_role_before = std::fs::read(&role).unwrap();
+    let assert_model_diagnostic = |error: crate::lifecycle::LifecycleError| match error {
+        crate::lifecycle::LifecycleError::PiModelPreflight {
+            requested,
+            candidates,
+            not_ready,
+            ..
+        } => {
+            assert_eq!(requested, "gpt-5.6-sol");
+            assert_eq!(candidates, vec!["openai-codex/gpt-5.6-sol"]);
+            assert!(!not_ready);
+        }
+        other => panic!("expected typed Pi preflight error, got {other:?}"),
+    };
+    for (force, agent_id) in [(false, "charlie"), (true, "alpha")] {
+        let mut calls = 0;
+        let mut discover = |requested: &str| {
+            calls += 1;
+            assert_eq!(requested, "gpt-5.6-sol");
+            Ok(vec!["openai-codex/gpt-5.6-sol".into()])
+        };
+        let error = crate::lifecycle::add_agent_with_transport_force_pi_preflight(
+            &ws,
+            &aid(agent_id),
+            &role,
+            false,
+            None,
+            force,
+            &tx,
+            &mut discover,
+        )
+        .expect_err("unqualified Pi model must fail before mutation");
+        drop(discover);
+        assert_eq!(calls, 1);
+        assert_model_diagnostic(error);
+        assert_unchanged(&model_role_before);
+    }
+}

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

@@ -375,6 +375,215 @@ fn quick_start_invalid_role_doc_surfaces_real_compile_error() {
     );
 }
 
+#[test]
+fn quick_start_absent_or_empty_roles_preserves_compile_outcome_without_pi_preflight_mutation() {
+    for (label, create_agents, expected) in [
+        ("absent", false, "missing agents directory"),
+        ("empty", true, "no role docs found"),
+    ] {
+        let team = temp_ws().join(format!("teamdir-{label}"));
+        std::fs::create_dir_all(&team).unwrap();
+        std::fs::write(team.join("TEAM.md"), QS_TEAM_MD).unwrap();
+        if create_agents {
+            std::fs::create_dir(team.join("agents")).unwrap();
+        }
+        let workspace = crate::model::paths::team_workspace(&team).unwrap();
+        let team_md_before = std::fs::read(team.join("TEAM.md")).unwrap();
+        let absent_paths = [
+            team.join("team.spec.yaml"),
+            crate::state::persist::runtime_state_path(&workspace),
+            crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
+            workspace.join("team_state.md"),
+            workspace.join(".team/logs/events.jsonl"),
+            workspace.join(".team/runtime/team.db"),
+        ];
+        for path in &absent_paths {
+            assert!(!path.exists(), "precondition: {} must be absent", path.display());
+        }
+
+        let transport = OfflineTransport::new();
+        let mut calls = 0;
+        let mut discover = |_requested: &str| {
+            calls += 1;
+            Ok(Vec::new())
+        };
+        let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+            &workspace,
+            &team,
+            None,
+            true,
+            None,
+            &transport,
+            true,
+            &mut discover,
+        )
+        .expect_err("an empty role input must preserve the existing compile outcome");
+        drop(discover);
+        assert_eq!(calls, 0, "{label} role input must not invoke Pi discovery");
+        match error {
+            LifecycleError::Compile(message) => {
+                assert!(message.contains(expected), "{label}: {message}");
+            }
+            other => panic!("{label}: expected existing compile outcome, got {other:?}"),
+        }
+        assert_eq!(team_md_before, std::fs::read(team.join("TEAM.md")).unwrap());
+        for path in &absent_paths {
+            assert!(!path.exists(), "{label} role input created {}", path.display());
+        }
+        assert!(transport.calls().is_empty(), "{label}: no transport mutation");
+        assert!(transport.spawn_records().is_empty(), "{label}: no spawn");
+    }
+}
+
+#[test]
+fn quick_start_injected_pi_preflight_is_typed_and_mutation_free() {
+    let role_doc = QS_VALID_ROLE.replace(
+        "provider: codex\nmodel: gpt-5.5",
+        "provider: pi\nmodel: gpt-5.6-sol",
+    );
+    let team = quick_start_team_dir(&role_doc);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let role_path = team.join("agents/implementer.md");
+    let team_md_path = team.join("TEAM.md");
+    let local_spec_path = team.join("team.spec.yaml");
+    let runtime_state_path = crate::state::persist::runtime_state_path(&workspace);
+    let runtime_spec_path = crate::model::paths::runtime_spec_path(&workspace, "quickteam");
+    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
+        &workspace,
+        "quickteam",
+        "implementer",
+    );
+    let role_before = std::fs::read(&role_path).unwrap();
+    let team_md_before = std::fs::read(&team_md_path).unwrap();
+    for path in [
+        &local_spec_path,
+        &runtime_state_path,
+        &runtime_spec_path,
+        &pi_paths.wrapper,
+        &pi_paths.sessions,
+    ] {
+        assert!(!path.exists(), "precondition: {} must be absent", path.display());
+    }
+
+    let transport = OfflineTransport::new();
+    let mut calls = 0;
+    let mut discover = |requested: &str| {
+        calls += 1;
+        assert_eq!(requested, "gpt-5.6-sol");
+        Ok(vec!["openai-codex/gpt-5.6-sol".into()])
+    };
+    let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+        &workspace,
+        &team,
+        None,
+        true,
+        None,
+        &transport,
+        true,
+        &mut discover,
+    )
+    .expect_err("unqualified Pi role must fail before quick-start mutation");
+    drop(discover);
+    assert_eq!(calls, 1);
+    match error {
+        LifecycleError::PiModelPreflight {
+            requested,
+            candidates,
+            action,
+            not_ready,
+        } => {
+            assert_eq!(requested, "gpt-5.6-sol");
+            assert_eq!(candidates, vec!["openai-codex/gpt-5.6-sol"]);
+            assert_eq!(
+                action,
+                "copy a candidate into the role, or run `team-agent models --provider pi --search gpt-5.6-sol`"
+            );
+            assert!(!not_ready);
+        }
+        other => panic!("expected typed Pi preflight error, got {other:?}"),
+    }
+    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
+    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
+    for path in [
+        &local_spec_path,
+        &runtime_state_path,
+        &runtime_spec_path,
+        &pi_paths.wrapper,
+        &pi_paths.sessions,
+    ] {
+        assert!(!path.exists(), "quick-start preflight created {}", path.display());
+    }
+    assert!(transport.calls().is_empty(), "no transport calls before preflight rejection");
+    assert!(transport.spawn_records().is_empty());
+}
+
+#[test]
+fn quick_start_schema_invalid_pi_role_is_mutation_free() {
+    let role_doc = QS_VALID_ROLE
+        .replace(
+            "provider: codex\nmodel: gpt-5.5",
+            "provider: pi\nmodel: openai-codex/gpt-5.6-sol",
+        )
+        .replace("  - mcp_team", "  - fs_read");
+    let team = quick_start_team_dir(&role_doc);
+    let workspace = crate::model::paths::team_workspace(&team).unwrap();
+    let role_path = team.join("agents/implementer.md");
+    let team_md_path = team.join("TEAM.md");
+    let role_before = std::fs::read(&role_path).unwrap();
+    let team_md_before = std::fs::read(&team_md_path).unwrap();
+    let pi_paths = crate::lifecycle::launch::pi_mcp::pi_seat_paths(
+        &workspace,
+        "quickteam",
+        "implementer",
+    );
+    let absent_paths = [
+        team.join("team.spec.yaml"),
+        crate::state::persist::runtime_state_path(&workspace),
+        crate::model::paths::runtime_spec_path(&workspace, "quickteam"),
+        workspace.join("team_state.md"),
+        workspace.join(".team/logs/events.jsonl"),
+        workspace.join(".team/runtime/team.db"),
+        pi_paths.wrapper,
+        pi_paths.sessions,
+    ];
+    for path in &absent_paths {
+        assert!(!path.exists(), "precondition: {} must be absent", path.display());
+    }
+
+    let transport = OfflineTransport::new();
+    let mut calls = 0;
+    let mut discover = |_requested: &str| {
+        calls += 1;
+        Ok(Vec::new())
+    };
+    let error = quick_start_with_transport_in_workspace_with_display_pi_preflight(
+        &workspace,
+        &team,
+        None,
+        true,
+        None,
+        &transport,
+        true,
+        &mut discover,
+    )
+    .expect_err("invalid Pi schema must fail before quick-start mutation");
+    drop(discover);
+    assert_eq!(calls, 0, "qualified models must not invoke discovery");
+    match error {
+        LifecycleError::Compile(message) => {
+            assert!(message.contains("Pi roles require mcp_team"), "{message}");
+        }
+        other => panic!("expected Pi role schema error, got {other:?}"),
+    }
+    assert_eq!(role_before, std::fs::read(&role_path).unwrap());
+    assert_eq!(team_md_before, std::fs::read(&team_md_path).unwrap());
+    for path in &absent_paths {
+        assert!(!path.exists(), "schema preflight created {}", path.display());
+    }
+    assert!(transport.calls().is_empty(), "no transport calls before schema rejection");
+    assert!(transport.spawn_records().is_empty());
+}
+
 // P0 — launch (dry_run) over a real compiled spec must resolve the REAL route/permission plan
 // (no spawn) — NOT the hardcoded RequirementUnmet stub. Golden: launch/core.py dry_run resolves
 // routing + permissions without starting any process.

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/crates/team-agent/src/lifecycle/types.rs

@@ -495,6 +495,14 @@ pub enum LifecycleError {
     /// 编译 spec / role doc 失败(`compile_team`/`compile_role_doc_agent`)。
     #[error("spec compile failed: {0}")]
     Compile(String),
+    /// Pi model/schema admission failed before lifecycle reservation or writes.
+    #[error("pi model preflight failed: {requested}")]
+    PiModelPreflight {
+        requested: String,
+        candidates: Vec<String>,
+        action: String,
+        not_ready: bool,
+    },
     /// provider 命令构造 / resume 不可用(`ResumeUnavailable`)。
     #[error("provider error: {0}")]
     Provider(String),