@team-agent/installer 0.5.6 → 0.5.8

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

@@ -112,29 +112,43 @@ fn send_outcome_direct_renders_compact_body() {
 // ════════════════════════════════════════════════════════════════════════
 // CONTROL-PLANE: send_message worker recipient → WorkerAccepted (tools.py:135-183)
 // ════════════════════════════════════════════════════════════════════════
-#[test]
-fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
-    // A worker recipient w/ a delivered message_id → async accepted carrying the
-    // byte-stable poll hint. Identity anchored on injected env (no candidate scan).
-    // golden: a leader WITH owner_team_id on an unseeded ws would hit the C23 cross-team
-    // refusal first (worker-1 not in visible peers) -> PeerNotInScope. owner_team_id=None
-    // (legacy single-team) bypasses that, isolating the worker-recipient accepted path.
-    // The cross-team refusal has its own tests (refuse_cross_team_peer_* / send_message_cross_team_*).
-    // A-7: the accepted path needs a REAL stored message_id (tools.py:175-181 —
-    // fabricated ids are gone), so the workspace seeds a running worker-1 the
-    // delivery layer can actually queue for.
-    let ws = unique_ws("send-worker");
+fn seed_current_worker_state(tag: &str) -> std::path::PathBuf {
+    let ws = unique_ws(tag);
     crate::state::persist::save_runtime_state(
         &ws,
         &serde_json::json!({
             "session_name": "team-x",
+            "active_team_key": "current",
             "agents": {
                 "worker-1": {"status": "running", "agent_id": "worker-1", "window": "worker-1"},
             },
+            "teams": {
+                "current": {
+                    "status": "alive",
+                    "agents": {
+                        "worker-1": {"status": "running", "agent_id": "worker-1", "window": "worker-1"},
+                    },
+                },
+            },
         }),
     )
     .unwrap();
-    let tools = TeamOrchestratorTools::with_identity(&ws, Some(AgentId::new("leader")), None);
+    ws
+}
+
+#[test]
+fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
+    // A worker recipient w/ a delivered message_id → async accepted carrying the
+    // byte-stable poll hint. Identity anchored on injected env (no candidate scan).
+    // A-7: the accepted path needs a REAL stored message_id (tools.py:175-181 —
+    // fabricated ids are gone), so the workspace seeds a running worker-1 the
+    // delivery layer can actually queue for.
+    let ws = seed_current_worker_state("send-worker");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
     let outcome = tools.send_message(
         &MessageTarget::Single("worker-1".to_string()),
         "do the thing",
@@ -155,6 +169,104 @@ fn send_message_worker_recipient_returns_accepted_with_poll_hint() {
     }
 }
 
+#[test]
+fn ordinary_send_assign_shape_has_no_recovery_marker() {
+    let ws = seed_current_worker_state("ordinary-no-recovery");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
+
+    let sent = tools
+        .send_message(
+            &MessageTarget::Single("worker-1".to_string()),
+            "ordinary send",
+            None,
+            None,
+            None,
+            None,
+        )
+        .expect("ordinary send ok")
+        .to_value();
+    assert!(
+        !sent.as_object().unwrap().contains_key("recovery"),
+        "ordinary send must not carry recovery marker: {sent}"
+    );
+    assert!(
+        sent.get("acceptance_marker").is_none(),
+        "ordinary send must not carry acceptance marker: {sent}"
+    );
+
+    let assigned = tools
+        .assign_task(
+            &json!({"id": "ordinary-task", "assignee": "worker-1", "title": "ordinary"}),
+            None,
+        )
+        .expect("ordinary assign ok");
+    let assigned_value = serde_json::to_value(&assigned).expect("serialize ordinary assign");
+    assert!(
+        !assigned_value.as_object().unwrap().contains_key("recovery"),
+        "ordinary assign must not carry recovery marker: {assigned_value}"
+    );
+    assert!(
+        assigned_value.get("acceptance_marker").is_none(),
+        "ordinary assign must not carry acceptance marker: {assigned_value}"
+    );
+
+    let recovery_false_assigned = tools
+        .assign_task(
+            &json!({
+                "id": "ordinary-recovery-false-task",
+                "assignee": "worker-1",
+                "title": "ordinary recovery false",
+                "recovery": false,
+            }),
+            None,
+        )
+        .expect("recovery=false assign ok");
+    let recovery_false_value =
+        serde_json::to_value(&recovery_false_assigned).expect("serialize recovery=false assign");
+    assert!(
+        !recovery_false_value
+            .as_object()
+            .unwrap()
+            .contains_key("recovery"),
+        "recovery=false assign must not carry recovery marker: {recovery_false_value}"
+    );
+    assert!(
+        recovery_false_value.get("acceptance_marker").is_none(),
+        "recovery=false assign must not carry acceptance marker: {recovery_false_value}"
+    );
+}
+
+#[test]
+fn recovery_assign_shape_has_structured_marker() {
+    let ws = seed_current_worker_state("recovery-marker");
+    let tools = TeamOrchestratorTools::with_identity(
+        &ws,
+        Some(AgentId::new("leader")),
+        Some(TeamKey::new("current")),
+    );
+
+    let assigned = tools
+        .assign_task(
+            &json!({
+                "id": "recovery-task",
+                "assignee": "worker-1",
+                "title": "recover",
+                "recovery": true,
+            }),
+            None,
+        )
+        .expect("recovery assign ok");
+    assert_eq!(assigned.fields.get("recovery"), Some(&json!(true)));
+    assert_eq!(
+        assigned.fields.get("acceptance_marker"),
+        Some(&json!("recovery"))
+    );
+}
+
 #[test]
 fn send_message_worker_recipient_surfaces_dead_coordinator_warning() {
     let ws = unique_ws("send-worker-dead-coord");

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

@@ -116,6 +116,7 @@ impl TeamOrchestratorTools {
         };
 
         let task_value = Value::Object(task_obj.clone());
+        let recovery = task_recovery_marker(&task_value);
         let mut state = load_runtime_state(&self.workspace).map_err(tool_runtime_error)?;
         ensure_object(&mut state);
         let team_key = self
@@ -139,7 +140,16 @@ impl TeamOrchestratorTools {
             None,
             None,
         )?;
-        compact_tool_result(&out.to_value())
+        let mut ok = compact_tool_result(&out.to_value())?;
+        if recovery {
+            ok.fields
+                .insert("recovery".to_string(), serde_json::json!(true));
+            ok.fields.insert(
+                "acceptance_marker".to_string(),
+                Value::String("recovery".to_string()),
+            );
+        }
+        Ok(ok)
     }
 
     /// `send_message` (`tools.py:135-183`): C14/C15/C17 scope resolution.
@@ -989,6 +999,11 @@ fn assignment_message(task: &Value, explicit: Option<&str>) -> String {
     json_dumps_default(task)
 }
 
+fn task_recovery_marker(task: &Value) -> bool {
+    task.get("recovery").and_then(Value::as_bool) == Some(true)
+        || task.get("acceptance_marker").and_then(Value::as_str) == Some("recovery")
+}
+
 fn scope_override_name(scope: Scope) -> Option<&'static str> {
     match scope {
         Scope::Team => Some("team"),

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

@@ -1981,12 +1981,19 @@ fn arm_turn_open(state: &mut serde_json::Value, recipient: &str, message_id: &Op
         .and_then(|agents| agents.get_mut(recipient))
         .and_then(serde_json::Value::as_object_mut)
     {
-        agent.insert(
-            "current_task_id".to_string(),
-            message_id.as_ref().map_or(serde_json::Value::Null, |id| {
+        // Phase-DX E2 (CR P0 red line #5): the leader→worker turn message id.
+        // Renamed from a misleading legacy field name (which was never a task
+        // FSM id — task FSM is A1) to `current_turn_message_id`, matching its
+        // actual semantic. Reader compatibility lives in `coordinator/tick.rs`
+        // (whitelisted for the transition) and `mcp_server/helpers.rs`; other
+        // messaging/lifecycle/mcp_server code MUST NOT treat this as
+        // authoritative task state.
+        let field = message_id
+            .as_ref()
+            .map_or(serde_json::Value::Null, |id| {
                 serde_json::Value::String(id.clone())
-            }),
-        );
+            });
+        agent.insert("current_turn_message_id".to_string(), field);
     }
 }
 

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

@@ -1581,10 +1581,15 @@ fn deliver_pending_submit_unverified_is_not_saved_by_readback() {
         Some(&serde_json::json!(message_id)),
         "current-turn fact is armed immediately after physical inject succeeds"
     );
+    // Phase-DX E2 rename: the leader→worker turn message id lives under
+    // `current_turn_message_id` (the previous name misleadingly implied a task
+    // FSM id — that is A1 territory). Same value written by
+    // `delivery::arm_turn_open`; the invariant of arming-without-delivered is
+    // unchanged.
     assert_eq!(
-        updated.pointer("/agents/w1/current_task_id"),
+        updated.pointer("/agents/w1/current_turn_message_id"),
         Some(&serde_json::json!(message_id)),
-        "agent current_task_id is armed without marking the message delivered"
+        "agent current-turn message id is armed without marking the message delivered"
     );
 }
 

package/package.json

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