@team-agent/installer 0.5.84 → 0.5.86

package/crates/team-agent/src/messaging/results.rs

@@ -130,6 +130,12 @@ fn collect_scoped(
     owner_team_id: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     let paths = collect_paths(workspace)?;
+    #[cfg(test)]
+    collection_tests::boundary("before_lock")?;
+    // Serialize collectors, but do not hold a SQLite write transaction while
+    // committing state. A process exit releases this existing OS file lock.
+    let collection_lock =
+        crate::state::persist::acquire_result_collection_lock(&paths.run_workspace)?;
     let log = EventLog::new(&paths.run_workspace);
     let resolved_owner_team_id = match owner_team_id.filter(|team| !team.is_empty()) {
         Some(team) => Some(resolve_owner_team_for_read(
@@ -159,7 +165,11 @@ fn collect_scoped(
     let store = MessageStore::open(&paths.run_workspace)?;
     let conn = crate::db::schema::open_db(store.db_path())?;
     if let Some(path) = result_file {
+        #[cfg(test)]
+        collection_tests::boundary("before_ingest")?;
         ingest_result_file(&conn, path, owner_team_id)?;
+        #[cfg(test)]
+        collection_tests::boundary("after_ingest")?;
     }
     let sql = match owner_team_id {
         Some(_) => {
@@ -197,7 +207,7 @@ fn collect_scoped(
     let mut collected_results = Vec::new();
     let mut invalid_results = Vec::new();
     let mut fatal_invalid_results = 0usize;
-    let mut state_dirty = false;
+    let mut ready = Vec::new();
     let mut task_updates = Vec::new();
     for row in rows {
         let envelope: serde_json::Value = match serde_json::from_str(&row.envelope) {
@@ -242,25 +252,75 @@ fn collect_scoped(
             )?;
             continue;
         };
-        match owner_team_id {
-            Some(team) => {
-                conn.execute(
-                    "update results set status = 'collected' where result_id = ?1 and owner_team_id = ?2",
-                    params![row.result_id.as_str(), team],
-                )?;
-            }
-            None => {
-                conn.execute(
-                    "update results set status = 'collected' where result_id = ?1",
-                    params![row.result_id.as_str()],
-                )?;
-            }
-        }
         if scope == "task" {
-            mark_task_done(&mut state, &row.task_id, &row.result_id);
             task_updates.push((row.task_id.clone(), row.result_id.clone()));
-            state_dirty = true;
         }
+        ready.push((row, envelope, scope));
+    }
+    // Pending DB rows remain eligible until the complete task delta is durable.
+    // Preserve the original created_at/result_id order: its last row per task wins.
+    if !task_updates.is_empty() {
+        let mut task_winners = Vec::new();
+        let mut updated = std::collections::BTreeSet::new();
+        for (task_id, result_id) in task_updates.iter().rev() {
+            if updated.insert(task_id) {
+                task_winners.push((task_id.clone(), result_id.clone()));
+            }
+        }
+        #[cfg(test)]
+        collection_tests::boundary("before_state")?;
+        state = crate::state::repository::StateRepository::new(&paths.run_workspace).commit(
+            crate::state::repository::StateWriteIntent::ResultCollection { owner_team_id },
+            |latest| {
+                for (task_id, result_id) in &task_winners {
+                    let already_applied = latest
+                        .get("tasks")
+                        .and_then(serde_json::Value::as_array)
+                        .is_some_and(|tasks| {
+                            tasks.iter().any(|task| {
+                                task.get("id").and_then(serde_json::Value::as_str)
+                                    == Some(task_id.as_str())
+                                    && task.get("status").and_then(serde_json::Value::as_str)
+                                        == Some("done")
+                                    && task
+                                        .get("accepted_result_id")
+                                        .and_then(serde_json::Value::as_str)
+                                        == Some(result_id.as_str())
+                            })
+                        });
+                    if !already_applied {
+                        mark_task_done(latest, task_id, result_id);
+                    }
+                }
+            },
+        )?;
+        for (task_id, result_id) in &task_winners {
+            let applied = state
+                .get("tasks")
+                .and_then(serde_json::Value::as_array)
+                .is_some_and(|tasks| {
+                    tasks.iter().any(|task| {
+                        task.get("id").and_then(serde_json::Value::as_str) == Some(task_id.as_str())
+                            && task.get("status").and_then(serde_json::Value::as_str)
+                                == Some("done")
+                            && task
+                                .get("accepted_result_id")
+                                .and_then(serde_json::Value::as_str)
+                                == Some(result_id.as_str())
+                    })
+                });
+            if !applied {
+                return Err(MessagingError::Validation(format!(
+                    "task result projection missing after commit: task_id={task_id} result_id={result_id}"
+                )));
+            }
+        }
+        #[cfg(test)]
+        collection_tests::boundary("after_state")?;
+    }
+    for (row, envelope, scope) in ready {
+        #[cfg(test)]
+        collection_tests::boundary("before_event")?;
         log.write(
             "collect.result",
             serde_json::json!({
@@ -270,6 +330,29 @@ fn collect_scoped(
                 "scope": scope,
             }),
         )?;
+        #[cfg(test)]
+        collection_tests::boundary("after_event")?;
+        #[cfg(test)]
+        collection_tests::boundary("before_finalize")?;
+        let finalized = match owner_team_id {
+            Some(team) => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1 and owner_team_id = ?2 and status not in ('collected', 'invalid')",
+                    params![row.result_id.as_str(), team],
+                )?
+            }
+            None => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1 and status not in ('collected', 'invalid')",
+                    params![row.result_id.as_str()],
+                )?
+            }
+        };
+        #[cfg(test)]
+        collection_tests::boundary("after_finalize")?;
+        if finalized == 0 {
+            continue;
+        }
         collected.push(envelope.clone());
         let summary = serde_json::json!({
             "result_id": row.result_id,
@@ -286,17 +369,8 @@ fn collect_scoped(
         });
         collected_results.push(summary);
     }
-    if state_dirty {
-        state = crate::state::repository::StateRepository::new(&paths.run_workspace).commit(
-            crate::state::repository::StateWriteIntent::ResultCollection { owner_team_id },
-            |latest| {
-                for (task_id, result_id) in &task_updates {
-                    mark_task_done(latest, task_id, result_id);
-                }
-            },
-        )?;
-    }
     let counts = result_counts(&conn, owner_team_id)?;
+    drop(collection_lock);
     // results.py:157 — ensure_coordinator=true runs the REAL ensure step; the
     // `{ok:false,status:"not_required"}` literal is ONLY the ensure=false branch.
     let coordinator = if ensure_coordinator {
@@ -1483,6 +1557,9 @@ pub fn collect_results_and_notify_watchers(
     }))
 }
 
+#[cfg(test)]
+mod collection_tests;
+
 #[cfg(test)]
 mod tests {
     use super::{format_report_result_notification, report_result};

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

@@ -227,29 +227,6 @@ pub enum PermissionMode {
     Trusted,
 }
 
-/// 规范化 tool(`CANONICAL_TOOLS` `permissions.py:5-14`)。别名(`fs_*`/`@builtin`/`*`)
-/// 在 `expand_tools` 展开 —— 那是单独的 alias 输入枚举,不在此(step 2 后续)。
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum Tool {
-    FsRead,
-    FsWrite,
-    FsList,
-    ExecuteBash,
-    GitDiff,
-    Network,
-    McpTeam,
-    ProviderBuiltin,
-}
-
-/// provider×tool enforcement(`PROVIDER_ENFORCEMENT` `permissions.py:44-65`)。
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum Enforcement {
-    Hard,
-    PromptOnly,
-}
-
 /// tmux pane 存活态(`state.py:336-341`)。**`Unknown` 既不可当 dead 也不可当 live**
 /// (owner-gate `state.py:382` 用 `!= LIVE`)—— 穷尽 match,不 fallthrough(§11)。
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -345,18 +322,6 @@ mod tests {
                 serde_json::to_string(&DisplayBackend::Adaptive).unwrap(),
                 "\"adaptive\"",
             ),
-            (
-                serde_json::to_string(&Tool::ExecuteBash).unwrap(),
-                "\"execute_bash\"",
-            ),
-            (
-                serde_json::to_string(&Tool::ProviderBuiltin).unwrap(),
-                "\"provider_builtin\"",
-            ),
-            (
-                serde_json::to_string(&Enforcement::PromptOnly).unwrap(),
-                "\"prompt_only\"",
-            ),
             (
                 serde_json::to_string(&PaneLiveness::Unknown).unwrap(),
                 "\"unknown\"",

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

@@ -21,7 +21,6 @@ pub mod ids;
 pub(crate) mod name_similarity;
 pub mod pane_authority_refusal;
 pub mod paths;
-pub mod permissions;
 pub mod routing;
 pub mod spec;
 pub mod task_graph;

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

@@ -6,20 +6,18 @@
 //! serde_json `preserve_order` 保证 child 迭代序 == Python 插入序。
 //!
 //! 本文件先落地 `validate_result_envelope`(自包含,step 7/11 的门)。`validate_spec`
-//! 依赖 `expand_tools`(permissions)+ `find_dependency_cycle`(task_graph)+ yaml Value,
-//! 待那几个叶子模块集成后再加。
+//! 依赖 `find_dependency_cycle`(task_graph)+ yaml Value。
 
 use std::path::Path;
 
 use serde_json::Value;
 
-use crate::model::enums::{Provider, TaskStatus};
+use crate::model::enums::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::model::yaml;
 use crate::provider::wire::{is_claude_family, parse_canonical_provider};
 
 /// result_envelope_v1 顶层 required(= allowed)。
@@ -333,12 +331,13 @@ fn basic_schema_errors(spec: &Yaml) -> Vec<String> {
     if !matches!(mode, Some("supervisor_worker" | "swarm_limited")) {
         e.push("/team/mode: invalid mode".to_string());
     }
-    let leader_keys = &["id", "role", "provider", "model", "tools", "context_policy"];
+    let leader_keys = &["id", "role", "provider", "model", "context_policy"];
+    let leader_allowed = &["id", "role", "provider", "model", "tools", "context_policy"];
     check_keys_y(
         spec.get("leader"),
         "/leader",
         leader_keys,
-        leader_keys,
+        leader_allowed,
         &mut e,
     );
     let cp_keys = &[
@@ -407,7 +406,6 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
         "model",
         "working_directory",
         "system_prompt",
-        "tools",
         "dangerously_skip_permissions",
         "preferred_for",
         "avoid_for",
@@ -483,7 +481,6 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
         &["inline", "file"],
         errors,
     );
-    check_list_y(agent.get("tools"), &format!("{path}/tools"), errors);
     check_list_y(
         agent.get("preferred_for"),
         &format!("{path}/preferred_for"),
@@ -787,67 +784,6 @@ fn semantic_errors(spec: &Yaml, base_dir: &Path) -> Vec<String> {
                 ));
             }
         }
-        let tools: Vec<&str> = agent
-            .get("tools")
-            .and_then(Yaml::as_list)
-            .unwrap_or(&[])
-            .iter()
-            .filter_map(Yaml::as_str)
-            .collect();
-        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)
-                ));
-            }
-        }
-        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"
-                ));
-            }
-        }
-    }
-
-    let leader_tools: Vec<&str> = leader
-        .and_then(|l| l.get("tools"))
-        .and_then(Yaml::as_list)
-        .unwrap_or(&[])
-        .iter()
-        .filter_map(Yaml::as_str)
-        .collect();
-    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)
-            ));
-        }
-    }
-    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"
-            ));
-        }
     }
 
     let routing = spec.get("routing");
@@ -1070,7 +1006,7 @@ mod tests {
     }
 
     #[test]
-    fn pi_spec_accepts_native_categories_and_rejects_provider_builtin() {
+    fn tools_are_transparent_for_all_providers() {
         let pi_text = include_str!("testdata/team.spec.yaml")
             .lines()
             .filter(|line| {
@@ -1093,22 +1029,26 @@ mod tests {
             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}"
+            validate_spec(&bad_agent, Path::new(TD)).is_ok(),
+            "Pi tools metadata must be ignored"
         );
 
-        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();
+        let missing_tools = pi_text
+            .replacen(
+                "  tools:\n    - fs_read\n    - fs_list\n    - mcp_team\n",
+                "",
+                1,
+            )
+            .replacen(
+                "    tools:\n      - fs_read\n      - fs_write\n      - fs_list\n      - execute_bash\n      - mcp_team\n",
+                "",
+                1,
+            );
+        let missing_tools = yaml::loads(&missing_tools).unwrap();
         assert!(
-            error.contains("/leader/tools: Pi does not support Team Agent tool category \"provider_builtin\""),
-            "spec validation must reject the Pi leader category: {error}"
+            validate_spec(&missing_tools, Path::new(TD)).is_ok(),
+            "omitted tools metadata must be accepted"
         );
     }
 
@@ -1121,7 +1061,6 @@ mod tests {
                 "/version: must equal 1",
                 "/team/mode: invalid mode",
                 "/leader/provider: unknown provider 'badprov'",
-                "/agents/0/tools: unknown tool 'banana'",
             ]
         );
     }