@team-agent/installer 0.5.81 → 0.5.83

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

@@ -28,20 +28,20 @@ use crate::model::permissions::{resolve_permissions, AgentPermissionInput};
 
 const RUNTIME_CONTRACT_SECTION: &str = r#"# Team Agent Teammate Runtime Contract
 
-You are a teammate in a Team Agent runtime. The leader cannot see your terminal
-output. All communication must go through Team Agent MCP tools.
+You are a Team Agent teammate; leader cannot see terminal output.
+All communication must go through Team Agent MCP tools.
 
-## Communication (mandatory)
+## Communication:
 
-- Coordinate with teammate: {send_message}(to='<agent_id>', content='...')
-- Broadcast to all teammates: {send_message}(to='*', content='...')
-- Task complete: {report_result}(summary='...') — call exactly once
+- Teammate: {send_message}(to='<agent_id>', content='...')
+- Broadcast: {send_message}(to='*', content='...')
+- Complete: {report_result}(summary='...') — call exactly once
 
-## Rules
+## Rules:
 
-- Do not pass sender, task_id, or schema_version — the MCP runtime fills them.
-- If blocked or waiting, send_message to the leader. Do not wait silently.
-- On 500/529/rate-limit errors, wait 1-2 minutes before retrying."#;
+- Do not pass sender, task_id, or schema_version — MCP fills them.
+- Do not reply to pure ACKs, greetings, or unchanged status notices (such as "paused" or "waiting"); after reporting a blocker once or completing a task, remain silent until a new actionable instruction arrives.
+- On 500/529/rate limits, retry only after 1-2 minutes."#;
 
 // 0.4.11 trimmed: the runtime contract section above already covers
 // send_message signatures and report_result exactly-once. The output
@@ -363,9 +363,7 @@ fn pi_communication_contract(mode: CommunicationMode) -> String {
 
 - Progress, blockers, questions: mcp({tool:"team_orchestrator_send_message", args:{to:"leader", content:"..."}})
 
-When you receive a message from the leader or a teammate, you MUST respond
-through MCP tools. Writing a reply in your terminal does nothing — the sender
-will never see it."#
+Respond through Team Agent MCP tools only to actionable requests or questions; writing in your terminal does not deliver it."#
             .to_string(),
         CommunicationMode::Orchestrated => mode.runtime_contract("mcp"),
     }
@@ -598,4 +596,40 @@ mod tests {
         assert!(prompt.contains(&slowdown_phrase));
         assert!(prompt.contains("Runtime Developer"));
     }
+
+    #[test]
+    fn all_provider_mode_prompts_share_silence_contract_without_unconditional_replies() {
+        for provider in [Provider::Codex, Provider::Pi] {
+            for mode in CommunicationMode::ALL.iter().copied() {
+                let agent = WorkerCommandAgent {
+                    id: Some("worker".to_string()),
+                    provider,
+                    role: Some("developer".to_string()),
+                    declared_tools: Some(vec!["mcp_team".to_string()]),
+                    system_prompt_inline: Some("worker body".to_string()),
+                    system_prompt_file: None,
+                    output_contract_format: Some("result_envelope_v1".to_string()),
+                    communication_mode: mode,
+                    dangerously_skip_permissions: false,
+                };
+                let prompt = compile_worker_system_prompt(&agent).unwrap();
+                assert!(prompt.contains(
+                    "Do not reply to pure ACKs, greetings, or unchanged status notices (such as \"paused\" or \"waiting\"); after reporting a blocker once or completing a task, remain silent until a new actionable instruction arrives."
+                ));
+                assert!(!prompt.contains("Silence and resumption (mandatory)"));
+                assert!(!prompt.contains("When you receive a message from the leader or a teammate, you MUST respond"));
+                match mode {
+                    CommunicationMode::LeaderCentric => {
+                        assert!(prompt.contains(
+                            "Respond through Team Agent MCP tools only to actionable requests or questions; writing in your terminal does not deliver it."
+                        ));
+                    }
+                    CommunicationMode::Orchestrated => {
+                        assert!(prompt.contains("Respond to task-related messages through Team Agent MCP tools."));
+                        assert!(prompt.contains("A pure ACK, unrelated status, or non-task message does not require a response."));
+                    }
+                }
+            }
+        }
+    }
 }

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

@@ -58,7 +58,6 @@ pub(crate) enum PiSessionSelector<'a> {
 }
 
 pub(crate) struct PiCommandRequest<'a> {
-    pub executable: &'a Path,
     pub extension: &'a Path,
     pub model: Option<&'a str>,
     pub effort: Option<ProviderEffort>,
@@ -72,14 +71,13 @@ pub(crate) struct PiCommandRequest<'a> {
 
 /// ---
 /// purpose: 从已验证 semantic request 构造仅追加 Team Agent MCP/提示/session 的 Pi argv
-/// returns: exact ordered fresh/resume argv
+/// returns: exact ordered fresh/resume argv，argv[0] 固定为裸 `pi`
 /// errors: 必需字段、mcp_team 或工具 category 非法时返回 ProviderError
 /// ---
 pub(crate) fn build_pi_command_argv(
     request: PiCommandRequest<'_>,
 ) -> Result<Vec<String>, ProviderError> {
-    if request.executable.as_os_str().is_empty()
-        || request.extension.as_os_str().is_empty()
+    if request.extension.as_os_str().is_empty()
         || request
             .session_dir
             .is_some_and(|session_dir| session_dir.as_os_str().is_empty())
@@ -88,7 +86,7 @@ pub(crate) fn build_pi_command_argv(
         || request.agent_id.trim().is_empty()
     {
         return Err(ProviderError::Command(
-            "Pi command requires executable, extension, prompt, and agent id".to_string(),
+            "Pi command requires extension, prompt, and agent id".to_string(),
         ));
     }
 
@@ -110,8 +108,10 @@ pub(crate) fn build_pi_command_argv(
         ));
     }
 
+    // Executable discovery/preflight belongs to the lifecycle materializer;
+    // the actual command must remain PATH-resolved at spawn time.
     let mut argv = vec![
-        request.executable.to_string_lossy().into_owned(),
+        "pi".to_string(),
         "-e".to_string(),
         request.extension.to_string_lossy().into_owned(),
     ];

package/crates/team-agent/src/state/persist.rs

@@ -1706,12 +1706,35 @@ pub(crate) fn load_runtime_state_without_migrations(workspace: &Path) -> Result<
     Ok(state)
 }
 
+/// Run a read-only callback while holding the canonical `state-save` lock.
+/// Unlike `load_runtime_state`, this helper performs no migration, cache
+/// update, or write. A missing state file is represented as `None` so callers
+/// can conservatively retain derived indexes during workspace unavailability.
+pub(crate) fn with_runtime_state_lock_without_migrations<T>(
+    workspace: &Path,
+    callback: impl FnOnce(Option<Value>) -> T,
+) -> Result<T, StateError> {
+    let path = runtime_state_path(workspace);
+    if !path.exists() {
+        return Ok(callback(None));
+    }
+    let _lock = RuntimeLock::acquire(workspace, "state-save", 2.0)?;
+    let state = match std::fs::read_to_string(&path) {
+        Ok(text) => Some(serde_json::from_str::<Value>(&text)?),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => None,
+        Err(error) => return Err(error.into()),
+    };
+    Ok(callback(state))
+}
+
 pub(crate) fn save_runtime_state_without_migrations(
     workspace: &Path,
     state: &Value,
 ) -> Result<(), StateError> {
     let path = runtime_state_path(workspace);
-    let _lock = RuntimeLock::acquire(workspace, "state-save-raw", 2.0)?;
+    // Raw writers share the canonical lock so readers/pruners cannot race
+    // a restore write through a parallel lock namespace.
+    let _lock = RuntimeLock::acquire(workspace, "state-save", 2.0)?;
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)?;
     }
@@ -3546,4 +3569,30 @@ mod tests {
             2,
         );
     }
+
+    #[test]
+    fn state_save_lock_serializes_raw_writer_and_prune_reader() {
+        let ws = temp_ws();
+        save_runtime_state(&ws, &json!({"teams": {"fresh": {}}})).unwrap();
+        let lock = RuntimeLock::acquire(&ws, "state-save", 2.0).unwrap();
+
+        let writer_ws = ws.clone();
+        let writer = std::thread::spawn(move || {
+            save_runtime_state_without_migrations(&writer_ws, &json!({"teams": {"fresh": {}}}))
+        });
+        std::thread::sleep(Duration::from_millis(100));
+        assert!(!writer.is_finished(), "raw writer must share state-save lock");
+        drop(lock);
+        writer.join().unwrap().unwrap();
+
+        let lock = RuntimeLock::acquire(&ws, "state-save", 2.0).unwrap();
+        let reader_ws = ws.clone();
+        let reader = std::thread::spawn(move || {
+            with_runtime_state_lock_without_migrations(&reader_ws, |state| state.is_some())
+        });
+        std::thread::sleep(Duration::from_millis(100));
+        assert!(!reader.is_finished(), "prune reader must use state-save lock");
+        drop(lock);
+        assert!(reader.join().unwrap().unwrap());
+    }
 }

package/package.json

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