@team-agent/installer 0.5.53 → 0.5.54

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.54",
   "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.54",
+    "@team-agent/cli-darwin-x64": "0.5.54",
+    "@team-agent/cli-linux-x64": "0.5.54"
   },
   "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.