@team-agent/installer 0.5.72 → 0.5.74

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -1,5 +1,6 @@
 use super::*;
 use crate::transport::test_support::OfflineTransport;
+use crate::transport::{PaneId, Target};
 
 fn pane_info(pane_id: &str, session: &str, window: &str) -> PaneInfo {
     PaneInfo {
@@ -3421,3 +3422,236 @@ fn gate054_fallback_pane_grep_guard_no_cross_server_chain_when_socket_recorded()
         "fallback injection must consume the shared resolver's typed channel"
     );
 }
+
+fn delivery_blocked_channel_reasons(ws: &std::path::Path) -> Vec<String> {
+    EventLog::new(ws)
+        .tail(80)
+        .unwrap()
+        .into_iter()
+        .filter(|event| event.get("event") == Some(&serde_json::json!("leader_receiver.delivery_blocked")))
+        .filter_map(|event| {
+            event
+                .get("channel_reason")
+                .and_then(serde_json::Value::as_str)
+                .map(str::to_string)
+        })
+        .collect()
+}
+
+fn live_leader_pane(ws: &std::path::Path, pane_id: &str) -> PaneInfo {
+    let mut pane = pane_info(pane_id, "team-current", "leader");
+    pane.current_path = Some(ws.to_path_buf());
+    pane
+}
+
+#[test]
+fn owner_projection_null_fallback_projects_nested_current_receiver() {
+    let ws = tmp_ws("proj-null-current");
+    let state = serde_json::json!({
+        "active_team_key": "current",
+        "team_key": "current",
+        "teams": {
+            "current": {
+                "team_key": "current",
+                "leader_receiver": {
+                    "status": "attached",
+                    "mode": "direct_tmux",
+                    "pane_id": "%9"
+                },
+                "agents": {}
+            }
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "nested current", None, false, Some("current"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%9")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        !delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "fresh Null fallback must project teams.current, not return Null; out={out:?} reasons={:?}",
+        delivery_blocked_channel_reasons(&ws)
+    );
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::Pane(PaneId::new("%9"))],
+        "nested current receiver must select pane %9; out={out:?}"
+    );
+}
+
+#[test]
+fn owner_projection_non_object_does_not_match_current() {
+    assert!(
+        !crate::messaging::delivery::top_level_state_matches_owner_team(
+            &serde_json::Value::Null,
+            "current"
+        ),
+        "Null must not match current through team_state_key default"
+    );
+    assert!(
+        !crate::messaging::delivery::top_level_state_matches_owner_team(
+            &serde_json::json!([]),
+            "current"
+        ),
+        "non-object must not match current"
+    );
+}
+
+#[test]
+fn owner_projection_legacy_top_level_receiver_survives_null_fallback() {
+    let ws = tmp_ws("proj-legacy-top");
+    let state = serde_json::json!({
+        "active_team_key": "current",
+        "leader_receiver": {
+            "status": "attached",
+            "mode": "direct_tmux",
+            "pane_id": "%3"
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "legacy top", None, false, Some("current"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%3")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        !delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "legacy top-level receiver must remain usable; out={out:?}"
+    );
+    assert_eq!(
+        transport.inject_targets(),
+        vec![Target::Pane(PaneId::new("%3"))],
+        "legacy top-level receiver must select pane %3; out={out:?}"
+    );
+}
+
+#[test]
+fn owner_projection_missing_selected_does_not_borrow_sibling() {
+    let ws = tmp_ws("proj-no-sibling");
+    let state = serde_json::json!({
+        "active_team_key": "alpha",
+        "team_key": "alpha",
+        "teams": {
+            "alpha": {
+                "team_key": "alpha",
+                "agents": {}
+            },
+            "beta": {
+                "team_key": "beta",
+                "leader_receiver": {
+                    "status": "attached",
+                    "mode": "direct_tmux",
+                    "pane_id": "%beta"
+                },
+                "agents": {}
+            }
+        },
+        "agents": {}
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(None, "w1", "leader", "alpha has no receiver", None, false, Some("alpha"))
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![live_leader_pane(&ws, "%beta")]);
+
+    let out = deliver_pending_message(&ws, &store, &transport, &message_id, &log, &serde_json::json!({}))
+        .unwrap();
+
+    assert!(
+        delivery_blocked_channel_reasons(&ws)
+            .iter()
+            .any(|reason| reason == "receiver_missing"),
+        "alpha must not borrow beta's receiver; out={out:?} reasons={:?}",
+        delivery_blocked_channel_reasons(&ws)
+    );
+    assert_eq!(transport.inject_targets().len(), 0, "must not inject into the sibling pane");
+}
+
+#[test]
+fn owner_projection_peer_inject_uses_nested_worker_pane_not_top_level() {
+    let ws = tmp_ws("proj-peer-nested");
+    let state = serde_json::json!({
+        "active_team_key": "teamA",
+        "session_name": "team-top",
+        "agents": {
+            "worker_b": {
+                "provider": "fake",
+                "status": "running",
+                "window": "worker_b",
+                "pane_id": "%top-b"
+            }
+        },
+        "teams": {
+            "teamA": {
+                "session_name": "team-nested",
+                "agents": {
+                    "worker_b": {
+                        "provider": "fake",
+                        "status": "running",
+                        "window": "worker_b",
+                        "pane_id": "%nested-b"
+                    }
+                }
+            }
+        }
+    });
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let message_id = store
+        .create_message(
+            None,
+            "worker_a",
+            "worker_b",
+            "MCP_SIM_BROADCAST_CANARY",
+            None,
+            false,
+            Some("teamA"),
+        )
+        .unwrap();
+    let transport = OfflineTransport::new().with_targets(vec![
+        pane_info("%top-b", "team-top", "worker_b"),
+        pane_info("%nested-b", "team-nested", "worker_b"),
+    ]);
+
+    let out = deliver_pending_message(
+        &ws,
+        &store,
+        &transport,
+        &message_id,
+        &log,
+        &serde_json::json!({}),
+    )
+    .unwrap();
+
+    let targets = transport.inject_targets();
+    assert!(
+        !targets.is_empty(),
+        "owner teamA peer inject must attempt the nested worker pane; out={out:?}"
+    );
+    assert!(
+        targets
+            .iter()
+            .all(|target| target == &Target::Pane(PaneId::new("%nested-b"))),
+        "owner teamA peer inject must select nested worker pane %nested-b, not top-level %top-b; out={out:?} targets={targets:?}"
+    );
+}

package/crates/team-agent/src/model/spec.rs

@@ -13,12 +13,13 @@ use std::path::Path;
 
 use serde_json::Value;
 
-use crate::model::enums::TaskStatus;
+use crate::model::enums::{Provider, TaskStatus};
 use crate::model::errors::ModelError;
 use crate::model::ids::TaskId;
 use crate::model::task_graph::{find_dependency_cycle, TaskNode};
 use crate::model::yaml::Value as Yaml;
 use crate::model::{permissions, yaml};
+use crate::provider::adapters::pi::first_unsupported_pi_tool_category;
 use crate::provider::wire::{is_claude_family, parse_canonical_provider};
 
 /// result_envelope_v1 顶层 required(= allowed)。
@@ -793,11 +794,26 @@ fn semantic_errors(spec: &Yaml, base_dir: &Path) -> Vec<String> {
             .iter()
             .filter_map(Yaml::as_str)
             .collect();
-        for tool in permissions::expand_tool_strings(tools) {
-            if !permissions::is_canonical_tool(&tool) {
+        let expanded_tools = permissions::expand_tool_strings(tools);
+        for tool in &expanded_tools {
+            if !permissions::is_canonical_tool(tool) {
                 e.push(format!(
                     "/agents/{idx}/tools: unknown tool {}",
-                    py_repr_str(&tool)
+                    py_repr_str(tool)
+                ));
+            }
+        }
+        if parse_canonical_provider(provider.and_then(Yaml::as_str).unwrap_or(""))
+            == Some(Provider::Pi)
+        {
+            if let Some(category) = first_unsupported_pi_tool_category(
+                expanded_tools
+                    .iter()
+                    .filter(|tool| permissions::is_canonical_tool(tool))
+                    .map(String::as_str),
+            ) {
+                e.push(format!(
+                    "/agents/{idx}/tools: Pi does not support Team Agent tool category {category:?}; remove it from this agent's tools"
                 ));
             }
         }
@@ -810,11 +826,26 @@ fn semantic_errors(spec: &Yaml, base_dir: &Path) -> Vec<String> {
         .iter()
         .filter_map(Yaml::as_str)
         .collect();
-    for tool in permissions::expand_tool_strings(leader_tools) {
-        if !permissions::is_canonical_tool(&tool) {
+    let expanded_leader_tools = permissions::expand_tool_strings(leader_tools);
+    for tool in &expanded_leader_tools {
+        if !permissions::is_canonical_tool(tool) {
             e.push(format!(
                 "/leader/tools: unknown tool {}",
-                py_repr_str(&tool)
+                py_repr_str(tool)
+            ));
+        }
+    }
+    if parse_canonical_provider(leader_provider.and_then(Yaml::as_str).unwrap_or(""))
+        == Some(Provider::Pi)
+    {
+        if let Some(category) = first_unsupported_pi_tool_category(
+            expanded_leader_tools
+                .iter()
+                .filter(|tool| permissions::is_canonical_tool(tool))
+                .map(String::as_str),
+        ) {
+            e.push(format!(
+                "/leader/tools: Pi does not support Team Agent tool category {category:?}; remove it from the leader's tools"
             ));
         }
     }
@@ -1038,6 +1069,49 @@ mod tests {
         assert!(r.is_ok(), "expected valid, got: {r:?}");
     }
 
+    #[test]
+    fn pi_spec_accepts_native_categories_and_rejects_provider_builtin() {
+        let pi_text = include_str!("testdata/team.spec.yaml")
+            .lines()
+            .filter(|line| {
+                !line.contains("provider_builtin")
+                    && !line.contains("git_diff")
+                    && !line.contains("network")
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        let pi_text = pi_text.replace("provider: codex", "provider: pi");
+        let pi_spec = yaml::loads(&pi_text).unwrap();
+        assert!(
+            validate_spec(&pi_spec, Path::new(TD)).is_ok(),
+            "Pi must accept the native Team Agent categories"
+        );
+
+        let bad_agent_text = pi_text.replacen(
+            "      - mcp_team\n",
+            "      - mcp_team\n      - provider_builtin\n",
+            1,
+        );
+        let bad_agent = yaml::loads(&bad_agent_text).unwrap();
+        let error = validate_spec(&bad_agent, Path::new(TD)).unwrap_err().to_string();
+        assert!(
+            error.contains("/agents/0/tools: Pi does not support Team Agent tool category \"provider_builtin\""),
+            "spec validation must reject the Pi agent category: {error}"
+        );
+
+        let bad_leader_text = pi_text.replacen(
+            "    - mcp_team\n",
+            "    - mcp_team\n    - provider_builtin\n",
+            1,
+        );
+        let bad_leader = yaml::loads(&bad_leader_text).unwrap();
+        let error = validate_spec(&bad_leader, Path::new(TD)).unwrap_err().to_string();
+        assert!(
+            error.contains("/leader/tools: Pi does not support Team Agent tool category \"provider_builtin\""),
+            "spec validation must reject the Pi leader category: {error}"
+        );
+    }
+
     #[test]
     fn invalid_spec_a_matches_python_golden() {
         let spec = yaml::loads(include_str!("testdata/spec_invalid_a.yaml")).unwrap();

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -37,6 +37,20 @@ pub(crate) fn pi_tool_mapping(category: &str) -> PiToolMapping {
     }
 }
 
+/// Return the first canonical category that Pi cannot map. Callers own alias
+/// expansion and generic unknown-category validation; this keeps the provider
+/// mapping itself as the only Pi capability contract.
+pub(crate) fn first_unsupported_pi_tool_category<'a, I>(
+    categories: I,
+) -> Option<&'a str>
+where
+    I: IntoIterator<Item = &'a str>,
+{
+    categories
+        .into_iter()
+        .find(|category| matches!(pi_tool_mapping(category), PiToolMapping::Unsupported))
+}
+
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PiSessionSelector<'a> {
     Fresh { session_id: &'a str },
@@ -50,7 +64,8 @@ pub(crate) struct PiCommandRequest<'a> {
     pub effort: Option<ProviderEffort>,
     pub system_prompt: &'a str,
     pub tool_categories: &'a [&'a str],
-    pub session_dir: &'a Path,
+    /// Team-owned session root for isolated seats; `None` preserves Pi's native default.
+    pub session_dir: Option<&'a Path>,
     pub session: PiSessionSelector<'a>,
     pub agent_id: &'a str,
 }
@@ -65,14 +80,15 @@ pub(crate) fn build_pi_command_argv(
 ) -> Result<Vec<String>, ProviderError> {
     if request.executable.as_os_str().is_empty()
         || request.extension.as_os_str().is_empty()
-        || request.session_dir.as_os_str().is_empty()
+        || request
+            .session_dir
+            .is_some_and(|session_dir| session_dir.as_os_str().is_empty())
         || request.model.is_some_and(|model| model.trim().is_empty())
         || request.system_prompt.trim().is_empty()
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, prompt, session directory, and agent id"
-                .to_string(),
+            "Pi command requires executable, extension, prompt, and agent id".to_string(),
         ));
     }
 
@@ -110,9 +126,13 @@ pub(crate) fn build_pi_command_argv(
     argv.extend([
         "--append-system-prompt".to_string(),
         request.system_prompt.to_string(),
-        "--session-dir".to_string(),
-        request.session_dir.to_string_lossy().into_owned(),
     ]);
+    if let Some(session_dir) = request.session_dir {
+        argv.extend([
+            "--session-dir".to_string(),
+            session_dir.to_string_lossy().into_owned(),
+        ]);
+    }
     // The shared lifecycle materializer always revalidates resume root/path/header.
     // Keep the pure argv builder usable before a fixture root is materialized, while
     // refusing a missing exact file once the recorded path's parent exists.