@team-agent/installer 0.5.53 → 0.5.55

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

@@ -446,7 +446,10 @@ fn message_not_silently_stuck_accepted_when_coordinator_dead() {
     assert!(out.ok, "durable persistence is the send success boundary");
     assert_eq!(out.status, DeliveryStatus::Blocked);
     assert_eq!(out.message_status.0, "queued_coordinator_unavailable");
-    assert!(out.message_id.as_deref().is_some_and(|id| id.starts_with("msg_")));
+    assert!(out
+        .message_id
+        .as_deref()
+        .is_some_and(|id| id.starts_with("msg_")));
     assert_eq!(out.reason, Some(DeliveryRefusal::CoordinatorUnavailable));
     assert!(
         out.verification
@@ -2290,6 +2293,53 @@ fn u1_multi_team_send_does_not_backfill_top_level_leader_binding() {
     assert_eq!(owner_team_id.as_deref(), Some("team-b"));
 }
 
+#[test]
+fn casefile_leader_send_is_durable_without_entering_leader_funnel() {
+    let ws = tmp_ws("casefile-send");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "session_name": "team-a",
+            "active_team_key": "team-a",
+            "agents": {}
+        }),
+    )
+    .unwrap();
+    let opts = SendOptions {
+        team: Some(TeamKey::new("team-a")),
+        requires_ack: false,
+        presentation: crate::messaging::presentation::PresentationRequest {
+            sink: crate::messaging::presentation::PresentationSink::Casefile,
+            class: crate::messaging::presentation::PresentationClass::Progress,
+            case_id: Some("case-1".to_string()),
+        },
+        ..SendOptions::default()
+    };
+    let out = send_message(
+        &ws,
+        &MessageTarget::Single("leader".to_string()),
+        "internal progress",
+        &opts,
+    )
+    .unwrap();
+    assert_eq!(out.status, DeliveryStatus::StoredOnly);
+    assert_eq!(out.message_status.0, "stored_only");
+    let store = store_for(&ws);
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    let (status, presentation): (String, String) = conn
+        .query_row(
+            "select status, presentation from messages where message_id = ?1",
+            [out.message_id.as_deref().unwrap()],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+    assert_eq!(status, "stored_only");
+    assert_eq!(
+        serde_json::from_str::<serde_json::Value>(&presentation).unwrap()["effective_sink"],
+        "casefile"
+    );
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // GROUP V — retry_result_deliveries: re-route notify_failed watchers with
 // dedupe_reason rebind_retry. result_delivery.py:19-35.
@@ -3158,6 +3208,72 @@ fn gate054_rebind_replay_requeues_failed_leader_message_on_attach() {
     );
 }
 
+#[test]
+fn claim_requeues_pending_acceptance_for_leader_only() {
+    let ws = tmp_ws("claim-pending-acceptance");
+    let store = store_for(&ws);
+    let log = EventLog::new(&ws);
+    let team_id = "mailbox-team";
+    let leader_message = store
+        .create_message(
+            None,
+            "worker",
+            "leader",
+            "leader canary",
+            None,
+            false,
+            Some(team_id),
+        )
+        .unwrap();
+    let worker_message = store
+        .create_message(
+            None,
+            "worker",
+            "worker-b",
+            "worker canary",
+            None,
+            false,
+            Some(team_id),
+        )
+        .unwrap();
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    for message_id in [&leader_message, &worker_message] {
+        conn.execute(
+            "update messages set status = 'submitted_pending_acceptance' where message_id = ?1",
+            [message_id],
+        )
+        .unwrap();
+    }
+
+    let team = TeamKey::new(team_id);
+    let pane = PaneId::new("%leader");
+    requeue_after_claim_leader(&ws, &store, &log, &team, &pane, None).unwrap();
+
+    let row = |message_id: &str| {
+        conn.query_row(
+            "select status, delivered_at, error from messages where message_id = ?1",
+            [message_id],
+            |row| {
+                Ok((
+                    row.get::<_, String>(0)?,
+                    row.get::<_, Option<String>>(1)?,
+                    row.get::<_, Option<String>>(2)?,
+                ))
+            },
+        )
+        .unwrap()
+    };
+    assert_eq!(row(&leader_message), ("accepted".to_string(), None, None));
+    assert_eq!(
+        row(&worker_message),
+        (
+            "submitted_pending_acceptance".to_string(),
+            None,
+            None
+        )
+    );
+}
+
 #[test]
 fn gate054_status_surfaces_pending_leader_notifications() {
     // Round-2: user-facing visibility — status must show the blocked leader

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

@@ -20,6 +20,8 @@ use super::helpers::MessageStatusShadow;
 #[serde(rename_all = "snake_case")]
 pub enum DeliveryStatus {
     Delivered,
+    /// Durable presentation obligation intentionally did not enter physical injection.
+    StoredOnly,
     Failed,
     /// busy → 延后不丢 (card §131:不 mark failed,留队列)。
     Queued,

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

@@ -195,6 +195,7 @@ fn deliver_primary_watcher(
         false,
         None,
         super::InitialDisposition::Accepted,
+        None,
     )?
     else {
         unreachable!("watcher notifications do not accept caller-supplied ids")
@@ -469,12 +470,13 @@ pub fn requeue_after_claim_leader(
 /// 0.5.5 gate054 round-2: attach-leader (and claim-leader) requeue for leader messages
 /// that were refused with `rebind_required` while no leader pane was attached.
 ///
-/// #231 C-5 semantics: same row, same message_id — flip `status` back from
-/// `failed`/`leader_not_attached` to `accepted` so `deliver_pending_messages`
-/// replays it through the SAME pipeline. The `leader_notification_log` PK is
-/// already there (primitive wrote it before the unbound check), so this replay
-/// cannot create a duplicate notification — exactly-once across rebind, no new
-/// send/notify rows and no second replay mechanism.
+/// #231 C-5 semantics: same row, same message_id — flip an eligible status back
+/// to `accepted` so `deliver_pending_messages` replays it through the SAME
+/// pipeline. The `leader_notification_log` PK prevents a second notification
+/// row for watcher-backed messages. A `submitted_pending_acceptance` row has
+/// already crossed the transport boundary, so its recovery is intentionally
+/// at-least-once: the stable message id/receipt token is preserved, but a replay
+/// can repeat the physical submit if a same-pane claim races the receipt window.
 pub(crate) fn requeue_blocked_leader_messages(
     conn: &rusqlite::Connection,
     event_log: &EventLog,
@@ -488,7 +490,10 @@ pub(crate) fn requeue_blocked_leader_messages(
     // `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.
+    // could not have churned while the leader was unattached. In contrast,
+    // `submitted_pending_acceptance` is an explicit at-least-once recovery arm:
+    // claim convergence favors an eventual receipt over preserving an
+    // unobservable in-flight submit.
     let requeued = conn.execute(
         "update messages
          set status = 'accepted',
@@ -499,6 +504,7 @@ pub(crate) fn requeue_blocked_leader_messages(
            and (
              (status = 'failed' and error = 'leader_not_attached')
              or status = 'queued_until_leader_attach'
+             or status = 'submitted_pending_acceptance'
            )",
         params![owner_team_id.as_str(), chrono::Utc::now().to_rfc3339()],
     )?;

package/crates/team-agent/src/provider/session/capture.rs

@@ -968,6 +968,17 @@ fn allocate_session_candidates(
             CandidateMatchKind::Any,
             item,
         ) {
+            Some(candidate)
+                if codex_no_expected(item)
+                    && candidate_is_visible_to_pending_peer(
+                        item,
+                        &candidate,
+                        pending,
+                        candidates_by_agent,
+                    ) =>
+            {
+                ambiguous.insert(item.agent_id.clone());
+            }
             Some(candidate) => {
                 claimed.extend(captured_provider_session_keys(item, &candidate.captured));
                 assignments.insert(item.agent_id.clone(), candidate);
@@ -985,6 +996,30 @@ fn allocate_session_candidates(
     (assignments, ambiguous)
 }
 
+fn candidate_is_visible_to_pending_peer(
+    owner: &PendingSessionCapture,
+    candidate: &CapturedSessionCandidate,
+    pending: &[PendingSessionCapture],
+    candidates_by_agent: &BTreeMap<String, Vec<CapturedSessionCandidate>>,
+) -> bool {
+    let owner_keys = captured_provider_session_keys(owner, &candidate.captured);
+    pending.iter().any(|peer| {
+        peer.agent_id != owner.agent_id
+            && peer.provider == owner.provider
+            && peer.team_key == owner.team_key
+            && candidates_by_agent
+                .get(&peer.agent_id)
+                .is_some_and(|candidates| {
+                    candidates.iter().any(|peer_candidate| {
+                        !owner_keys.is_disjoint(&captured_provider_session_keys(
+                            peer,
+                            &peer_candidate.captured,
+                        ))
+                    })
+                })
+    })
+}
+
 fn allocate_global_one_to_one(
     pending: &[PendingSessionCapture],
     candidates_by_agent: &BTreeMap<String, Vec<CapturedSessionCandidate>>,
@@ -1702,6 +1737,45 @@ mod u1_tests {
         );
     }
 
+    #[test]
+    fn codex_shared_single_candidate_without_identity_is_deferred() {
+        let mut state = serde_json::json!({
+            "agents": {
+                "parent-peer": {
+                    "provider": "codex",
+                    "status": "running",
+                    "spawn_cwd": "/tmp/u1-cwd"
+                },
+                "worker-a": {
+                    "provider": "codex",
+                    "status": "running",
+                    "spawn_cwd": "/tmp/u1-cwd"
+                }
+            }
+        });
+        let candidate = leader_like_candidate(
+            "019f3327-shared",
+            "/Users/alauda/.codex/sessions/2026/07/06/rollout-shared.jsonl",
+        );
+        let mut canned = BTreeMap::new();
+        canned.insert("parent-peer".to_string(), vec![candidate.clone()]);
+        canned.insert("worker-a".to_string(), vec![candidate]);
+        let canned_for_adapter = canned.clone();
+        let mut adapter_for = move |provider| {
+            Box::new(
+                test_support::CaptureCandidatesAdapter::new(provider, None, "")
+                    .with_candidates(canned_for_adapter.clone()),
+            ) as Box<dyn ProviderAdapter>
+        };
+
+        let report = capture_missing_provider_sessions_once(&mut state, &mut adapter_for, true, 0)
+            .expect("capture pass succeeds");
+
+        assert!(report.assigned.is_empty(), "report={report:?}");
+        assert!(state["agents"]["parent-peer"].get("session_id").is_none());
+        assert!(state["agents"]["worker-a"].get("session_id").is_none());
+    }
+
     #[test]
     fn codex_embedded_identity_assigns_each_same_cwd_worker_to_own_rollout() {
         let mut state = serde_json::json!({

package/crates/team-agent/src/provider/session_scan/common/tests.rs

@@ -0,0 +1,112 @@
+use super::*;
+
+fn temp_dir(name: &str) -> PathBuf {
+    static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    let dir =
+        std::env::temp_dir().join(format!("ta-session-scan-{name}-{}-{n}", std::process::id()));
+    std::fs::create_dir_all(&dir).expect("create temp dir");
+    dir
+}
+
+fn write_codex_rollout(path: &Path, cwd: &Path, session_id: &str, embedded_agent_id: &str) {
+    let text = format!(
+        "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\n\
+         {{\"type\":\"turn_context\",\"payload\":{{}}}}\n\
+         {{\"type\":\"response_item\",\"payload\":{{\"content\":[{{\"type\":\"input_text\",\"text\":\"You are Team Agent worker `{embedded_agent_id}` with role `fixture`.\"}}]}}}}\n",
+        cwd.to_string_lossy()
+    );
+    std::fs::write(path, text).expect("write codex rollout");
+}
+
+#[test]
+fn codex_prompt_worker_identity_is_a_positive_match() {
+    let dir = temp_dir("positive");
+    let rollout = dir.join("rollout-frontend.jsonl");
+    write_codex_rollout(&rollout, &dir, "sess-frontend", "frontend");
+    let context = CaptureSessionContext {
+        agent_id: "frontend".to_string(),
+        spawn_cwd: dir.clone(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: None,
+        expected_session_id: None,
+        provider_projects_root: None,
+    };
+    let candidates = parse_candidate_files(
+        Provider::Codex,
+        &context,
+        vec![SessionCandidate {
+            path: rollout.clone(),
+            requires_cwd_match: false,
+        }],
+    );
+    assert_eq!(candidates.len(), 1);
+    assert!(candidates[0].positive_agent_id_match);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn codex_identity_in_incomplete_final_head_record_is_positive() {
+    let dir = temp_dir("cross-cap-positive");
+    let rollout = dir.join("rollout-worker-a.jsonl");
+    let meta = format!(
+        "{{\"session_meta\":{{\"payload\":{{\"id\":\"sess-worker-a\",\"cwd\":\"{}\"}}}}}}\n",
+        dir.to_string_lossy()
+    );
+    let marker = "You are Team Agent worker `worker-a` with role `fixture`.";
+    let body = format!("{meta}{{\"text\":\"{marker}{}\"}}\n", "x".repeat(70_000));
+    std::fs::write(&rollout, body).expect("write cross-cap rollout");
+    assert!(!read_head_text(&rollout, CAPTURE_HEAD_BYTES)
+        .expect("read complete records")
+        .contains(marker));
+    let context = CaptureSessionContext {
+        agent_id: "worker-a".to_string(),
+        spawn_cwd: dir.clone(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: None,
+        expected_session_id: None,
+        provider_projects_root: None,
+    };
+
+    let candidates = parse_candidate_files(
+        Provider::Codex,
+        &context,
+        vec![SessionCandidate {
+            path: rollout,
+            requires_cwd_match: false,
+        }],
+    );
+
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(candidates[0].embedded_agent_id.as_deref(), Some("worker-a"));
+    assert!(candidates[0].positive_agent_id_match);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn codex_prompt_worker_identity_mismatch_is_rejected_for_that_agent() {
+    let dir = temp_dir("mismatch");
+    let rollout = dir.join("rollout-ios-dev.jsonl");
+    write_codex_rollout(&rollout, &dir, "sess-ios-dev", "ios-dev");
+    let context = CaptureSessionContext {
+        agent_id: "frontend".to_string(),
+        spawn_cwd: dir.clone(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: None,
+        expected_session_id: None,
+        provider_projects_root: None,
+    };
+    let candidates = parse_candidate_files(
+        Provider::Codex,
+        &context,
+        vec![SessionCandidate {
+            path: rollout,
+            requires_cwd_match: false,
+        }],
+    );
+    assert!(candidates.is_empty());
+    let _ = std::fs::remove_dir_all(&dir);
+}

package/crates/team-agent/src/provider/session_scan/common.rs

@@ -69,9 +69,11 @@ pub(super) fn parse_candidate_files(
     let mut out = Vec::new();
     for candidate in candidates {
         let path = candidate.path;
-        let Ok(text) = read_head_text(&path, CAPTURE_HEAD_BYTES) else {
+        let Ok(head_bytes) = read_head_bytes(&path, CAPTURE_HEAD_BYTES) else {
             continue;
         };
+        let text = complete_head_text(&head_bytes);
+        let identity_text = String::from_utf8_lossy(&head_bytes);
         let records = parse_session_records(&text);
         if records.is_empty() {
             continue;
@@ -98,7 +100,7 @@ pub(super) fn parse_candidate_files(
         } else {
             Confidence::Low
         };
-        let embedded_agent_id = embedded_team_agent_worker_id_from_text(&text);
+        let embedded_agent_id = embedded_team_agent_worker_id_from_text(&identity_text);
         if embedded_agent_id
             .as_deref()
             .is_some_and(|id| id != context.agent_id.as_str())
@@ -241,15 +243,23 @@ fn cap_candidates_by_mtime(out: &mut Vec<SessionCandidate>, cap: usize) {
 }
 
 pub(super) fn read_head_text(path: &Path, max_bytes: u64) -> std::io::Result<String> {
+    read_head_bytes(path, max_bytes).map(|bytes| complete_head_text(&bytes))
+}
+
+fn read_head_bytes(path: &Path, max_bytes: u64) -> std::io::Result<Vec<u8>> {
     use std::io::Read;
     let file = std::fs::File::open(path)?;
     let mut bytes = Vec::new();
     file.take(max_bytes).read_to_end(&mut bytes)?;
+    Ok(bytes)
+}
+
+fn complete_head_text(bytes: &[u8]) -> String {
     let complete = match bytes.iter().rposition(|byte| *byte == b'\n') {
         Some(last_newline) => &bytes[..=last_newline],
         None => &bytes[..],
     };
-    Ok(String::from_utf8_lossy(complete).into_owned())
+    String::from_utf8_lossy(complete).into_owned()
 }
 
 fn collect_optional_candidate_files(
@@ -414,86 +424,4 @@ fn path_is_under_team_runtime(path: &Path) -> bool {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn temp_dir(name: &str) -> PathBuf {
-        static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
-        let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let dir =
-            std::env::temp_dir().join(format!("ta-session-scan-{name}-{}-{n}", std::process::id()));
-        std::fs::create_dir_all(&dir).expect("create temp dir");
-        dir
-    }
-
-    fn write_codex_rollout(path: &Path, cwd: &Path, session_id: &str, embedded_agent_id: &str) {
-        let text = format!(
-            "{{\"session_meta\":{{\"payload\":{{\"id\":\"{session_id}\",\"cwd\":\"{}\"}}}}}}\n\
-             {{\"type\":\"turn_context\",\"payload\":{{}}}}\n\
-             {{\"type\":\"response_item\",\"payload\":{{\"content\":[{{\"type\":\"input_text\",\"text\":\"You are Team Agent worker `{embedded_agent_id}` with role `fixture`.\"}}]}}}}\n",
-            cwd.to_string_lossy()
-        );
-        std::fs::write(path, text).expect("write codex rollout");
-    }
-
-    #[test]
-    fn codex_prompt_worker_identity_is_a_positive_match() {
-        let dir = temp_dir("positive");
-        let rollout = dir.join("rollout-frontend.jsonl");
-        write_codex_rollout(&rollout, &dir, "sess-frontend", "frontend");
-        let context = CaptureSessionContext {
-            agent_id: "frontend".to_string(),
-            spawn_cwd: dir.clone(),
-            pane_id: None,
-            pane_pid: None,
-            spawned_at: None,
-            expected_session_id: None,
-            provider_projects_root: None,
-        };
-        let candidates = parse_candidate_files(
-            Provider::Codex,
-            &context,
-            vec![SessionCandidate {
-                path: rollout.clone(),
-                requires_cwd_match: false,
-            }],
-        );
-        assert_eq!(candidates.len(), 1);
-        assert!(
-            candidates[0].positive_agent_id_match,
-            "Codex transcript prompt identity must be treated as a positive worker id source"
-        );
-        let _ = std::fs::remove_file(&rollout);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn codex_prompt_worker_identity_mismatch_is_rejected_for_that_agent() {
-        let dir = temp_dir("mismatch");
-        let rollout = dir.join("rollout-ios-dev.jsonl");
-        write_codex_rollout(&rollout, &dir, "sess-ios-dev", "ios-dev");
-        let context = CaptureSessionContext {
-            agent_id: "frontend".to_string(),
-            spawn_cwd: dir.clone(),
-            pane_id: None,
-            pane_pid: None,
-            spawned_at: None,
-            expected_session_id: None,
-            provider_projects_root: None,
-        };
-        let candidates = parse_candidate_files(
-            Provider::Codex,
-            &context,
-            vec![SessionCandidate {
-                path: rollout.clone(),
-                requires_cwd_match: false,
-            }],
-        );
-        assert!(
-            candidates.is_empty(),
-            "state agent=frontend must not accept a Codex rollout whose prompt says ios-dev"
-        );
-        let _ = std::fs::remove_file(&rollout);
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-}
+mod tests;

package/package.json

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

package/schemas/result-envelope.schema.json

@@ -11,6 +11,16 @@
     "agent_id": { "type": "string", "minLength": 1 },
     "status": { "enum": ["success", "blocked", "failed", "partial"] },
     "summary": { "type": "string" },
+    "presentation": {
+      "type": "object",
+      "required": ["sink", "class"],
+      "additionalProperties": false,
+      "properties": {
+        "sink": { "enum": ["leader", "casefile", "silent"] },
+        "class": { "enum": ["message", "progress", "stage_result", "stage_pass", "bounce", "blocking", "final_review", "timeout"] },
+        "case_id": { "type": "string", "minLength": 1 }
+      }
+    },
     "changes": {
       "type": "array",
       "items": {

package/skills/team-agent/SKILL.md

@@ -166,6 +166,7 @@ For diagnosis, run `team-agent profile show deepseek --workspace . --json`; neve
 - `quick-start` is only for first-time team creation from role docs. If that team already has runtime state, use `team-agent restart . --team <session_name_or_team_name>` to resume it. If restart cannot recover context, explain the loss and wait for explicit user consent before using `team-agent restart . --allow-fresh`; never reset context through quick-start.
 - If the user explicitly asks a worker to create or operate a nested child team, first read `references/team-in-team.md`. Child teams must use an independent child workspace, never the parent `.team/current`.
 - `team-agent send --watch-result coder "Do the bounded task"` sends a direct worker message, returns after delivery, and lets the coordinator collect/report completion asynchronously.
+- Advanced orchestration callers may add `--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]`. All sinks remain durable and pullable; `casefile`/`silent` suppress only live leader injection. Missing presentation metadata preserves the normal leader-visible behavior.
 - After `send --watch-result` succeeds, do not run `sleep`, `status`, `inbox`, or `collect` polling loops unless the user explicitly asks for diagnosis; the coordinator will notify the leader when the result arrives.
 - `team-agent send --task task_initial "Start"` routes by task.
 - `team-agent status` shows team, worker health, result-store counts, `session_id`, `captured_via`, and attribution confidence. `team-agent status --json` is compact and context-safe by default; use `team-agent status --detail --json` only for raw runtime-state diagnostics.
@@ -237,6 +238,8 @@ team_orchestrator.send_message(to="*", content="short broadcast")
 team_orchestrator.report_result(summary="short completion", status="success", tests=[{"command":"command","status":"passed"}])
 ```
 
+For typed orchestration traffic, both `send_message` and `report_result` accept `presentation={"sink":"leader|casefile|silent","class":"message|progress|stage_result|stage_pass|bounce|blocking|final_review|timeout","case_id":"optional-case"}`. If the object is present, `sink` and `class` are required and unknown values fail closed. `casefile` and `silent` are durable-only, not deletion. The fixed critical classes `stage_pass`, `bounce`, `blocking`, `final_review`, and `timeout` always appear on the leader screen even when another sink is requested. Routing uses the typed class, never words in the content or summary.
+
 Do not pass `sender`, `task_id`, `requires_ack`, `schema_version`, or `agent_id` unless doing a low-level compatibility diagnostic. The MCP runtime fills those fields and keeps delivery metadata in runtime state and event logs. If provider env loses the worker id, MCP infers it from active task/message state and falls back to an explicit `unknown` sender instead of treating the worker as leader.
 
 Message targets are team-scoped. Use `leader`, another teammate agent id, or `*` for all other team members. The runtime excludes the sender from `*` broadcasts and never scans unrelated terminal windows for recipients.