@team-agent/installer 0.5.7 → 0.5.9

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

@@ -26,6 +26,7 @@ use super::helpers::{
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
+    report_result_integrity_warnings,
 };
 use super::types::{
     Scope, SendOutcome, ToolError, ToolErrorReason, ToolOk, ToolResult, VisiblePeers,
@@ -116,6 +117,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 +141,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.
@@ -389,7 +400,13 @@ impl TeamOrchestratorTools {
             self.note_unknown_result_status(&raw);
         }
         let normalized = normalize_report_envelope(&base);
-        let env_value = normalized_envelope_value(&normalized);
+        let warnings = report_result_integrity_warnings(&base, &normalized);
+        let mut env_value = normalized_envelope_value(&normalized);
+        if !warnings.is_empty() {
+            if let Some(obj) = env_value.as_object_mut() {
+                obj.insert("warnings".to_string(), Value::Array(warnings));
+            }
+        }
         let owner_team = self.canonical_owner_team_key()?;
         messaging::report_result_for_owner_team(
             &self.workspace,
@@ -989,6 +1006,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/leader_receiver.rs

@@ -541,3 +541,61 @@ fn render_fallback_pane_message(content: &str, message_id: &str, primary_error:
          [team-agent-token:{message_id}]"
     )
 }
+
+/// E6 (0.5.9 offline-mailbox-toname-design §6.3): enqueue a leader-bound message
+/// row in the TARGET workspace `team.db` with status `queued_until_leader_attach`.
+///
+/// This is a durable "leader mailbox" write, NOT a delivery. Coordinator delivery
+/// never claims this status (§3.3), so the row will not churn or be marked
+/// `failed` while the leader is unattached. When the target owner runs
+/// `attach-leader` / `claim-leader`, the existing `requeue_blocked_leader_messages`
+/// helper flips the same row to `accepted` and the standard delivery pipeline
+/// injects it exactly once.
+///
+/// Safety boundary (§5): only the `messages` table is touched. Owner identity
+/// (`leader_receiver` / `team_owner` / `owner_epoch`) is never written by this
+/// path, and no provider/worker process is spawned.
+pub fn enqueue_leader_mailbox_until_attach(
+    target_workspace: &Path,
+    canonical_team_key: &str,
+    content: &str,
+    task_id: Option<&TaskId>,
+    sender: &str,
+    event_log: &EventLog,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let store = MessageStore::open(target_workspace)?;
+    let message_id = store.create_message(
+        task_id.map(TaskId::as_str),
+        sender,
+        "leader",
+        content,
+        None,
+        false,
+        Some(canonical_team_key),
+    )?;
+    // The default row status after `create_message` is `accepted`. Flip it to
+    // `queued_until_leader_attach` so it stays out of `claim_for_delivery`
+    // eligible set and out of `deliver_pending_messages` scan until an
+    // attach/claim explicitly requeues it (see requeue_blocked_leader_messages).
+    store.mark(&message_id, "queued_until_leader_attach", None)?;
+    event_log.write(
+        "leader_mailbox.queued_until_attach",
+        serde_json::json!({
+            "message_id": message_id,
+            "owner_team_id": canonical_team_key,
+            "sender": sender,
+            "target_workspace": target_workspace.display().to_string(),
+            "channel": "leader_mailbox",
+        }),
+    )?;
+    Ok(DeliveryOutcome {
+        ok: true,
+        status: DeliveryStatus::Queued,
+        message_status: MessageStatusShadow("queued_until_leader_attach".to_string()),
+        message_id: Some(message_id),
+        verification: None,
+        stage: None,
+        reason: None,
+        channel: Some("leader_mailbox".to_string()),
+    })
+}

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

@@ -83,7 +83,8 @@ pub use delivery::{
 };
 pub use helpers::fail_leader_delivery;
 pub use leader_receiver::{
-    deliver_to_leader_fallback_pane, mirror_peer_message_to_leader, send_to_leader_receiver,
+    deliver_to_leader_fallback_pane, enqueue_leader_mailbox_until_attach,
+    mirror_peer_message_to_leader, send_to_leader_receiver,
     send_to_leader_receiver_with_message_id,
 };
 pub use peers::allow_peer_talk;

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

@@ -263,11 +263,21 @@ fn ensure_coordinator_after_collect(
 }
 
 /// `_coordinator_should_run`(`results.py:187-188`)。
+///
+/// The top-level `state.leader_receiver` read below is a coordinator-scope
+/// legacy compat bridge (pre-teams-map single-team layout) — deliberately
+/// NOT team-scoped because this predicate answers "is a coordinator worth
+/// starting for this workspace at all?" and does not itself route any
+/// message. The `ALLOWED-LEGACY-READ` marker documents the exception and
+/// keeps grep sweeps honest; delete once B1 canonical layout lands and
+/// every state carries a `teams` map
+/// (`.team/artifacts/next-version-staged-plan.md §5 Phase-Foundation-1`).
 fn coordinator_should_run(state: &serde_json::Value) -> bool {
     let has_session = state
         .get("session_name")
         .and_then(serde_json::Value::as_str)
         .is_some_and(|s| !s.is_empty());
+    // ALLOWED-LEGACY-READ: pre-teams-map coordinator-scope existence probe; never used for routing.
     has_session || leader_receiver_is_direct(state.get("leader_receiver"))
 }
 
@@ -942,6 +952,12 @@ fn report_result_for_owner_team_inner(
         );
     }
     out.insert("notification_event_id".to_string(), serde_json::Value::Null);
+    if let Some(warnings) = report_result_array(envelope, "warnings") {
+        out.insert(
+            "warnings".to_string(),
+            serde_json::Value::Array(warnings.clone()),
+        );
+    }
     Ok(serde_json::Value::Object(out))
 }
 
@@ -1036,6 +1052,9 @@ fn format_report_result_notification(
     if let Some(tests) = format_report_result_tests(envelope) {
         lines.push(tests);
     }
+    if let Some(warnings) = format_report_result_warnings(envelope) {
+        lines.push(warnings);
+    }
     if let Some(changes) = format_report_result_changes(envelope) {
         lines.push(changes);
     }
@@ -1075,6 +1094,29 @@ fn format_report_result_tests(envelope: &serde_json::Value) -> Option<String> {
     }
 }
 
+fn format_report_result_warnings(envelope: &serde_json::Value) -> Option<String> {
+    let parts = report_result_array(envelope, "warnings")?
+        .iter()
+        .filter_map(|warning| {
+            let code = report_field(warning, "code")?;
+            let field = report_field(warning, "field").unwrap_or("result");
+            let severity = report_field(warning, "severity").unwrap_or("warning");
+            let advisory =
+                if warning.get("advisory").and_then(serde_json::Value::as_bool) == Some(true) {
+                    " advisory"
+                } else {
+                    ""
+                };
+            Some(format!("{severity}{advisory} {field}: {code}"))
+        })
+        .collect::<Vec<_>>();
+    if parts.is_empty() {
+        None
+    } else {
+        Some(format!("Verification warnings: {}", parts.join(", ")))
+    }
+}
+
 fn report_result_array<'a>(
     envelope: &'a serde_json::Value,
     key: &str,
@@ -1203,6 +1245,14 @@ mod tests {
             "tests": [
                 {"command": "cargo test", "status": "passed"}
             ],
+            "warnings": [
+                {
+                    "code": "result_success_without_executed_tests",
+                    "field": "tests",
+                    "severity": "warning",
+                    "advisory": true
+                }
+            ],
             "risks": [
                 {"severity": "low", "description": "none known"}
             ],
@@ -1217,6 +1267,9 @@ mod tests {
             format_report_result_notification("res_1", "task-1", "worker", "success", &envelope);
         assert!(notification.contains("Task task-1 reported success from worker: done"));
         assert!(notification.contains("Tests: cargo test=passed"));
+        assert!(notification.contains(
+            "Verification warnings: warning advisory tests: result_success_without_executed_tests"
+        ));
         assert!(notification.contains("Changes: modified src/a.rs: patched delivery"));
         assert!(notification.contains("Risks: low: none known"));
         assert!(notification.contains("Artifacts: .team/artifacts/evidence.md: evidence"));

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/crates/team-agent/src/messaging/watchers.rs

@@ -459,15 +459,25 @@ pub(crate) fn requeue_blocked_leader_messages(
     owner_team_id: &TeamKey,
     claimed_pane_id: &PaneId,
 ) -> Result<usize, MessagingError> {
+    // E6 (0.5.9 offline-mailbox §6.5): also requeue rows that a third-party
+    // sender left in `queued_until_leader_attach` via the leader mailbox.
+    // Same idempotent requeue funnel (row/message_id/leader_notification_log
+    // PK are all preserved) — after attach/claim the coordinator's normal
+    // `deliver_pending_messages` picks them up as `accepted` and injects
+    // exactly once. status `queued_until_leader_attach` is deliberately NOT
+    // in the `claim_for_delivery` eligible set (see message_store.rs) so it
+    // could not have churned while the leader was unattached.
     let requeued = conn.execute(
         "update messages
          set status = 'accepted',
              error = null,
              updated_at = ?2
          where recipient = 'leader'
-           and status = 'failed'
-           and error = 'leader_not_attached'
-           and owner_team_id = ?1",
+           and owner_team_id = ?1
+           and (
+             (status = 'failed' and error = 'leader_not_attached')
+             or status = 'queued_until_leader_attach'
+           )",
         params![owner_team_id.as_str(), chrono::Utc::now().to_rfc3339()],
     )?;
     if requeued > 0 {

package/package.json

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