@team-agent/installer 0.5.59 → 0.5.61

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

@@ -120,7 +120,7 @@ pub(super) fn spawn_agents(
             agent,
             Some(agent_id_raw),
             provider,
-        );
+        )?;
         let system_prompt =
             crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
         let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -295,8 +295,8 @@ mod fork_state;
 pub(super) use fork_state::*;
 
 mod fork_finalize;
-pub(crate) use fork_finalize::finalize_pending_fork_capture;
 pub(super) use fork_finalize::*;
+pub(crate) use fork_finalize::{finalize_pending_fork_capture, ContextForkFinalized};
 
 mod role_source;
 pub(super) use role_source::*;

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

@@ -1635,7 +1635,7 @@ fn write_start_agent_start_event(
         agent,
         Some(agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -220,7 +220,7 @@ pub(super) fn spawn_agent_window(
         agent,
         Some(agent_id.as_str()),
         provider,
-    );
+    )?;
     let system_prompt =
         crate::lifecycle::worker_command_context::compile_worker_system_prompt(&command_agent)?;
     let tools = crate::lifecycle::worker_command_context::resolved_tool_strings_for_command(

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

@@ -1178,7 +1178,29 @@ pub(super) fn fork_ws(alpha_role: &str) -> PathBuf {
         std::process::id(),
         n
     ));
-    std::fs::write(&rollout, b"{}\n").expect("seed fork source rollout");
+    std::fs::write(
+        &rollout,
+        format!(
+            "{}\n{}\n",
+            json!({
+                "type": "session_meta",
+                "payload": {
+                    "id": "sess-a",
+                    "cwd": ws,
+                }
+            }),
+            json!({
+                "type": "response_item",
+                "payload": {
+                    "content": [{
+                        "type": "input_text",
+                        "text": "You are Team Agent worker `alpha` with role `fixture`."
+                    }]
+                }
+            })
+        ),
+    )
+    .expect("seed identity-complete fork source rollout");
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
@@ -1669,6 +1691,18 @@ fn lanea_fork_gate_error_text_and_spec_rollback_on_adapter_arm() {
 fn lanea_fork_report_session_id_is_not_pane_id() {
     let _home = LaneHomeGuard::enter("fork-report");
     let ws = fork_ws(DELEG_ROLE_ALPHA); // codex+subscription -> native fork supported -> full success path
+    let mut state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    let source = PathBuf::from(state["agents"]["alpha"]["rollout_path"].as_str().unwrap());
+    let codex_root = std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .unwrap()
+        .join(".codex/sessions/lane-fixture");
+    std::fs::create_dir_all(&codex_root).unwrap();
+    let discoverable_source = codex_root.join("rollout-sess-a.jsonl");
+    std::fs::copy(source, &discoverable_source).unwrap();
+    state["agents"]["alpha"]["rollout_path"] =
+        json!(discoverable_source.to_string_lossy().to_string());
+    crate::state::persist::save_runtime_state(&ws, &state).unwrap();
     let tx = LaneTransport::new("team-laneateam", &[]);
     let report =
         fork_agent_with_transport(&ws, &aid("alpha"), &aid("newfork"), None, false, None, &tx)

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

@@ -36,6 +36,7 @@ pub mod event_names {
     pub const ADD_FAILED: &str = "lifecycle.add_failed";
     pub const REMOVE_STEP_COMPLETED: &str = "lifecycle.remove_step_completed";
     pub const REMOVE_ROLLED_BACK: &str = "lifecycle.remove_rolled_back";
+    pub const CONTEXT_FORK: &str = "context_fork";
     // restart 决策事件(Route B audit 契约必发)。
     pub const RESTART_RESUME_DECISION: &str = "restart.resume_decision";
     pub const RESTART_ATOMIC_REFUSAL: &str = "restart.atomic_refusal";

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::communication_mode::CommunicationMode;
 use crate::lifecycle::types::{DangerousApproval, LifecycleError};
 use crate::model::enums::{Enforcement, Provider};
 use crate::model::ids::AgentId;
@@ -12,15 +13,10 @@ output. All communication must go through Team Agent MCP tools.
 
 ## Communication (mandatory)
 
-- Progress, blockers, questions: team_orchestrator.send_message(to='leader', content='...')
 - Coordinate with teammate: team_orchestrator.send_message(to='<agent_id>', content='...')
 - Broadcast to all teammates: team_orchestrator.send_message(to='*', content='...')
 - Task complete: team_orchestrator.report_result(summary='...') — call exactly once
 
-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.
-
 ## Rules
 
 - Do not pass sender, task_id, or schema_version — the MCP runtime fills them.
@@ -45,6 +41,7 @@ pub(crate) struct WorkerCommandAgent {
     system_prompt_inline: Option<String>,
     system_prompt_file: Option<String>,
     output_contract_format: Option<String>,
+    communication_mode: CommunicationMode,
 }
 
 impl WorkerCommandAgent {
@@ -52,9 +49,9 @@ impl WorkerCommandAgent {
         agent: &crate::model::yaml::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(crate::model::yaml::Value::as_str)
@@ -90,16 +87,21 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(crate::model::yaml::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(crate::model::yaml::Value::as_str),
+            )?,
+        })
     }
 
     pub(crate) fn from_json(
         agent: &serde_json::Value,
         fallback_id: Option<&str>,
         provider: Provider,
-    ) -> Self {
+    ) -> Result<Self, LifecycleError> {
         let system_prompt = agent.get("system_prompt");
-        Self {
+        Ok(Self {
             id: agent
                 .get("id")
                 .and_then(serde_json::Value::as_str)
@@ -135,7 +137,12 @@ impl WorkerCommandAgent {
                 .and_then(|contract| contract.get("format"))
                 .and_then(serde_json::Value::as_str)
                 .map(str::to_string),
-        }
+            communication_mode: communication_mode(
+                agent
+                    .get("communication_mode")
+                    .and_then(serde_json::Value::as_str),
+            )?,
+        })
     }
 }
 
@@ -149,6 +156,7 @@ pub(crate) fn compile_worker_system_prompt(
     let mut chunks = vec![
         identity_section(agent),
         runtime_contract_section(),
+        agent.communication_mode.runtime_contract().to_string(),
         role_body(agent)?,
     ];
     if let Some(contract) = output_contract(agent) {
@@ -197,6 +205,14 @@ fn runtime_contract_section() -> String {
     RUNTIME_CONTRACT_SECTION.to_string()
 }
 
+fn communication_mode(value: Option<&str>) -> Result<CommunicationMode, LifecycleError> {
+    let Some(value) = value else {
+        return Ok(CommunicationMode::default());
+    };
+    CommunicationMode::parse(value)
+        .ok_or_else(|| LifecycleError::Compile(format!("unknown communication_mode {value:?}")))
+}
+
 fn identity_section(agent: &WorkerCommandAgent) -> String {
     format!(
         "You are Team Agent worker `{}` with role `{}`. When asked about your role or identity, answer with this Team Agent worker identity first, not only the generic provider product identity.",
@@ -291,6 +307,7 @@ mod tests {
             system_prompt_inline: None,
             system_prompt_file: None,
             output_contract_format: None,
+            communication_mode: CommunicationMode::default(),
         };
         let tools =
             resolved_tool_strings_for_command(&agent, Provider::ClaudeCode, &disabled_safety())
@@ -335,6 +352,7 @@ mod tests {
             system_prompt_inline: Some("Implement the assigned slice.".to_string()),
             system_prompt_file: None,
             output_contract_format: Some("result_envelope_v1".to_string()),
+            communication_mode: CommunicationMode::default(),
         };
         let prompt = compile_worker_system_prompt(&agent).unwrap();
         assert!(

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -260,6 +260,7 @@ pub fn compact_tool_result(result: &Value) -> ToolResult {
             "notification_channel",
             "notification_event_id",
             "warnings",
+            "warning",
         ]
     };
     for key in keys {

package/crates/team-agent/src/mcp_server/tests/send.rs

@@ -78,6 +78,7 @@ fn send_outcome_worker_accepted_envelope_byte_stable() {
     let outcome = SendOutcome::WorkerAccepted {
         message_id: "42".to_string(),
         poll_via: "team-agent inbox 42".to_string(),
+        warning: None,
     };
     let v = outcome.to_value();
     assert_eq!(
@@ -160,6 +161,7 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
         Ok(SendOutcome::WorkerAccepted {
             message_id,
             poll_via,
+            ..
         }) => {
             assert!(!message_id.is_empty());
             assert_eq!(poll_via, format!("team-agent inbox {message_id}"));
@@ -353,6 +355,30 @@ fn send_message_leader_recipient_is_direct_not_accepted() {
     );
 }
 
+#[test]
+fn send_message_mailbox_is_durable_without_live_injection() {
+    let tools = TeamOrchestratorTools::with_identity(
+        &unique_ws("send-leader-mailbox"),
+        Some(AgentId::new("worker-1")),
+        Some(TeamKey::new("teamA")),
+    );
+    let mailbox = json!(true);
+    let outcome = tools
+        .send_message_with_presentation(
+            &MessageTarget::Single("leader".to_string()),
+            "stored update",
+            None,
+            None,
+            None,
+            Some(&mailbox),
+            None,
+        )
+        .expect("mailbox send persists");
+    let value = outcome.to_value();
+    assert_eq!(value.get("status"), Some(&json!("stored_only")));
+    assert!(value.get("message_id").and_then(Value::as_str).is_some());
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // CROSS-TEAM PRE-REFUSAL (C23) — refuse_cross_team_peer (tools.py:185-213)
 // ════════════════════════════════════════════════════════════════════════

package/crates/team-agent/src/mcp_server/tests/wire.rs

@@ -79,7 +79,7 @@ fn tools_contract_has_thirteen_tools_in_order() {
         .unwrap();
     assert_eq!(
             send["description"],
-            json!("Send a message to a teammate, the leader, or '*' for all other team members. Team Agent fills identity and delivery metadata; optional presentation routing is durable and never drops the message.")
+            json!("Send a message to a teammate, the leader, or '*' for all other team members. mailbox=true stores durably without live injection; the default is live delivery.")
         );
     assert_eq!(send["inputSchema"]["additionalProperties"], json!(false));
     assert_eq!(send["inputSchema"]["required"], json!(["to", "content"]));

package/crates/team-agent/src/mcp_server/tools.rs

@@ -17,17 +17,17 @@ use crate::state::persist::{
 };
 
 // ── REUSE: step 11 messaging delegate surface ───────────────────────────────
-use crate::messaging::{self, MessageTarget, SendOptions, TrustedSender};
+use crate::messaging::{self, DeliveryStatus, MessageTarget, SendOptions, TrustedSender};
 
 use super::helpers::{
     current_reportable_message_for, delivery_outcome_value, direct_message_attribution_for,
-    ensure_object, enum_value, insert_array, is_worker_recipient, json_dumps_default,
-    latest_task_for_assignee, non_empty_string, normalized_envelope_value, object_fields,
-    requires_ack_for_target, tool_runtime_error, DirectMessageAttribution,
+    ensure_object, enum_value, is_worker_recipient, json_dumps_default, latest_task_for_assignee,
+    non_empty_string, object_fields, requires_ack_for_target, tool_runtime_error,
+    DirectMessageAttribution,
 };
 use super::normalize::{
-    compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
-    report_result_integrity_warnings, validate_test_evidence_schema,
+    compact_tool_result, normalize_report_envelope, report_result_integrity_warnings,
+    validate_test_evidence_schema,
 };
 use super::types::{
     Scope, SendOutcome, ToolError, ToolErrorReason, ToolOk, ToolResult, VisiblePeers,
@@ -116,6 +116,22 @@ impl TeamOrchestratorTools {
                 "ValueError",
             ));
         };
+        if let Some(route) = task.get("result_route") {
+            let Some(route) = route.as_str() else {
+                return Err(ToolError::new(
+                    ToolErrorReason::InvalidToolArguments,
+                    "assign_task task.result_route must be 'leader' or 'pipeline'",
+                    "ValueError",
+                ));
+            };
+            if crate::messaging::results::ResultRoute::parse(route).is_none() {
+                return Err(ToolError::new(
+                    ToolErrorReason::InvalidToolArguments,
+                    format!("assign_task task.result_route has unknown value: {route}"),
+                    "ValueError",
+                ));
+            }
+        }
 
         let task_value = Value::Object(task_obj.clone());
         let recovery = task_recovery_marker(&task_value);
@@ -185,6 +201,7 @@ impl TeamOrchestratorTools {
             requires_ack,
             scope_override,
             None,
+            None,
         )
     }
 
@@ -195,17 +212,20 @@ impl TeamOrchestratorTools {
         task_id: Option<&str>,
         requires_ack: Option<bool>,
         scope_override: Option<Scope>,
+        mailbox: Option<&Value>,
         presentation: Option<&Value>,
     ) -> Result<SendOutcome, ToolError> {
-        let (presentation, presentation_error) =
-            crate::messaging::presentation::normalize_presentation(presentation);
-        if let Some(error) = presentation_error {
-            return Err(ToolError::new(
-                ToolErrorReason::InvalidToolArguments,
-                format!("invalid presentation: {error}"),
-                "PresentationError",
-            ));
-        }
+        let normalized =
+            crate::messaging::presentation::normalize_send_presentation(mailbox, presentation)
+                .map_err(|error| {
+                    ToolError::new(
+                        ToolErrorReason::InvalidToolArguments,
+                        format!("invalid send routing: {error}"),
+                        "PresentationError",
+                    )
+                })?;
+        let presentation = normalized.request;
+        let deprecation = normalized.deprecation;
         let canonical_owner_team = self.canonical_owner_team_key()?;
         if matches!(scope_override, Some(Scope::Workspace)) {
             return Err(self.rpc_scope_refused(
@@ -261,6 +281,21 @@ impl TeamOrchestratorTools {
         if is_worker_recipient(to) {
             let out = messaging::send_message(&self.workspace, to, content, &opts)
                 .map_err(tool_runtime_error)?;
+            if matches!(out.status, DeliveryStatus::StoredOnly) {
+                let value = delivery_outcome_value(&out);
+                let mut ok = compact_tool_result(&value)?;
+                if let Some(verification) = out.verification.as_deref() {
+                    ok.fields.insert(
+                        "verification".to_string(),
+                        Value::String(verification.to_string()),
+                    );
+                }
+                if let Some(deprecation) = deprecation {
+                    ok.fields
+                        .insert("warning".to_string(), Value::String(deprecation));
+                }
+                return Ok(SendOutcome::Direct(ok));
+            }
             // tools.py:175-181 — accepted+poll_via ONLY for a REAL message_id; any other
             // outcome falls back to the compacted direct result. Never invent an
             // `mcp_<timestamp>` id: it does not exist in the store and makes the
@@ -276,12 +311,25 @@ impl TeamOrchestratorTools {
             return Ok(SendOutcome::WorkerAccepted {
                 poll_via: format!("team-agent inbox {message_id}"),
                 message_id,
+                warning: deprecation,
             });
         }
         let out = messaging::send_message(&self.workspace, to, content, &opts)
             .map_err(tool_runtime_error)?;
         let value = delivery_outcome_value(&out);
-        let ok = compact_tool_result(&value)?;
+        let mut ok = compact_tool_result(&value)?;
+        if matches!(out.status, DeliveryStatus::StoredOnly) {
+            if let Some(verification) = out.verification.as_deref() {
+                ok.fields.insert(
+                    "verification".to_string(),
+                    Value::String(verification.to_string()),
+                );
+            }
+        }
+        if let Some(deprecation) = deprecation {
+            ok.fields
+                .insert("warning".to_string(), Value::String(deprecation));
+        }
         Ok(SendOutcome::Direct(ok))
     }
 
@@ -352,10 +400,11 @@ impl TeamOrchestratorTools {
         task_id: Option<&str>,
         agent_id: Option<&str>,
     ) -> ToolResult {
+        let status = enum_value(status);
         self.report_result_with_presentation(
             envelope,
             summary,
-            status,
+            status.as_str(),
             changes,
             tests,
             risks,
@@ -372,7 +421,7 @@ impl TeamOrchestratorTools {
         &self,
         envelope: Option<&Value>,
         summary: Option<&str>,
-        status: ResultStatus,
+        status: Option<&str>,
         changes: Option<&[Value]>,
         tests: Option<&[Value]>,
         risks: Option<&[Value]>,
@@ -404,7 +453,10 @@ impl TeamOrchestratorTools {
                 );
             }
             if !obj.contains_key("status") {
-                obj.insert("status".to_string(), enum_value(status));
+                obj.insert(
+                    "status".to_string(),
+                    Value::String(status.unwrap_or("success").to_string()),
+                );
             }
             if !obj.contains_key("task_id") {
                 // Blocker-1 (prerelease 0.4.0): scoped-team task inference +
@@ -499,29 +551,36 @@ impl TeamOrchestratorTools {
                 obj.insert("agent_id".to_string(), Value::String(resolved));
             }
             if !obj.contains_key("changes") {
-                insert_array(obj, "changes", changes);
+                obj.insert(
+                    "changes".to_string(),
+                    Value::Array(changes.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("tests") {
-                insert_array(obj, "tests", tests);
+                obj.insert(
+                    "tests".to_string(),
+                    Value::Array(tests.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("risks") {
-                insert_array(obj, "risks", risks);
+                obj.insert(
+                    "risks".to_string(),
+                    Value::Array(risks.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("artifacts") {
-                insert_array(obj, "artifacts", artifacts);
+                obj.insert(
+                    "artifacts".to_string(),
+                    Value::Array(artifacts.unwrap_or(&[]).to_vec()),
+                );
             }
             if !obj.contains_key("next_actions") {
-                insert_array(obj, "next_actions", next_actions);
+                obj.insert(
+                    "next_actions".to_string(),
+                    Value::Array(next_actions.unwrap_or(&[]).to_vec()),
+                );
             }
         }
-        // T3-1 cr verdict (refined): an unknown non-empty status literal normalizes to
-        // Partial and must be OBSERVABLE at this ingestion boundary (the envelope-borne
-        // path; the wire `status` arg path emits at dispatch). Never a silent swallow.
-        if let Some(raw) =
-            normalize_result_status_observed(base.get("status").and_then(Value::as_str)).1
-        {
-            self.note_unknown_result_status(&raw);
-        }
         if let Err(error) = validate_test_evidence_schema(base.get("tests")) {
             return Err(ToolError::new(
                 ToolErrorReason::InvalidToolArguments,
@@ -538,8 +597,15 @@ impl TeamOrchestratorTools {
             ));
         }
         let warnings = report_result_integrity_warnings(&base, &normalized);
-        let mut env_value = normalized_envelope_value(&normalized);
-        copy_report_attribution_fields(&base, &mut env_value);
+        let mut env_value = base;
+        if let Some(obj) = env_value.as_object_mut() {
+            obj.entry("schema_version")
+                .or_insert_with(|| Value::String("result_envelope_v1".to_string()));
+            obj.insert(
+                "presentation".to_string(),
+                serde_json::to_value(&normalized.presentation).unwrap_or(Value::Null),
+            );
+        }
         if !warnings.is_empty() {
             if let Some(obj) = env_value.as_object_mut() {
                 obj.insert("warnings".to_string(), Value::Array(warnings));
@@ -555,20 +621,6 @@ impl TeamOrchestratorTools {
         .and_then(|value| compact_tool_result(&value))
     }
 
-    /// T3-1 cr verdict: the observable record of an unknown→Partial status
-    /// normalization (`provider.result.unknown_status_normalized`, raw literal
-    /// included) — MUST-NOT-13: the swallow is never silent.
-    pub(crate) fn note_unknown_result_status(&self, raw: &str) {
-        let _ = EventLog::new(&self.workspace).write(
-            "provider.result.unknown_status_normalized",
-            serde_json::json!({
-                "agent_id": self.agent_id.as_ref().map(AgentId::as_str),
-                "raw_status": raw,
-                "normalized": "partial",
-            }),
-        );
-    }
-
     /// `update_state` (`tools.py:316-325`): delegated through the lifecycle tools
     /// facade. S0 preserves the old placeholder behavior.
     pub fn update_state(&self, note: &str) -> ToolResult {
@@ -1179,24 +1231,6 @@ fn merge_object_fields(existing: &mut Value, incoming: &Value) {
     }
 }
 
-fn copy_report_attribution_fields(source: &Value, target: &mut Value) {
-    let Some(src) = source.as_object() else {
-        return;
-    };
-    let Some(dst) = target.as_object_mut() else {
-        return;
-    };
-    for key in [
-        "attributed_message_id",
-        "attribution_scope",
-        "task_id_source",
-    ] {
-        if let Some(value) = src.get(key) {
-            dst.entry(key.to_string()).or_insert(value.clone());
-        }
-    }
-}
-
 fn push_report_warning(obj: &mut serde_json::Map<String, Value>, warning: Value) {
     let Some(code) = warning.get("code").and_then(Value::as_str) else {
         return;

package/crates/team-agent/src/mcp_server/types.rs

@@ -322,6 +322,7 @@ pub enum SendOutcome {
         message_id: String,
         /// Byte-stable `"team-agent inbox <message_id>"`.
         poll_via: String,
+        warning: Option<String>,
     },
     /// Compacted delegate result (leader / `*` / broadcast / fanout).
     Direct(ToolOk),
@@ -335,12 +336,16 @@ impl SendOutcome {
             SendOutcome::WorkerAccepted {
                 message_id,
                 poll_via,
+                warning,
             } => {
                 let mut obj = serde_json::Map::new();
                 obj.insert("status".to_string(), Value::String("accepted".to_string()));
                 obj.insert("delivery_pending".to_string(), Value::Bool(true));
                 obj.insert("poll_via".to_string(), Value::String(poll_via.clone()));
                 obj.insert("message_id".to_string(), Value::String(message_id.clone()));
+                if let Some(warning) = warning {
+                    obj.insert("warning".to_string(), Value::String(warning.clone()));
+                }
                 Value::Object(obj)
             }
             SendOutcome::Direct(ok) => Value::Object(ok.fields.clone()),