@team-agent/installer 0.5.58 → 0.5.60

package/crates/team-agent/src/provider/session/context_fork/codex.rs

@@ -1,14 +1,319 @@
 use super::*;
+use std::collections::BTreeSet;
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Write};
+
+#[derive(Debug)]
+pub(crate) struct CodexForkMaterialization {
+    path: PathBuf,
+    keep: bool,
+}
+
+impl CodexForkMaterialization {
+    pub(crate) fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn mark_handoff(&mut self) {
+        self.keep = true;
+    }
+}
+
+impl crate::provider::adapter::ForkBackingMaterialization for CodexForkMaterialization {
+    fn path(&self) -> &Path {
+        self.path()
+    }
+
+    fn handoff(&mut self) {
+        self.mark_handoff();
+    }
+}
+
+impl Drop for CodexForkMaterialization {
+    fn drop(&mut self) {
+        if !self.keep {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+}
+
+pub(crate) fn materialize_codex_fork(
+    source_path: &Path,
+    source_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+    plan: &mut CommandPlan,
+) -> Result<CodexForkMaterialization, ProviderError> {
+    let target_session_id = SessionId::new(codex_session_v7());
+    let parent = source_path.parent().ok_or_else(|| {
+        ProviderError::Io(format!(
+            "codex source backing has no parent: {}",
+            source_path.display()
+        ))
+    })?;
+    let timestamp = chrono::Utc::now().format("%Y-%m-%dT%H-%M-%S");
+    let target_path = parent.join(format!(
+        "rollout-{timestamp}-{}.jsonl",
+        target_session_id.as_str()
+    ));
+    let source = complete_source_snapshot(source_path)?;
+    let rewritten = rewrite_snapshot(
+        &source,
+        source_session_id,
+        &target_session_id,
+        source_agent_id,
+        target_agent_id,
+    )?;
+    publish_target_no_clobber(&target_path, rewritten.as_bytes())?;
+    if let Err(error) =
+        validate_materialized_target(&target_path, &target_session_id, target_agent_id)
+    {
+        let _ = std::fs::remove_file(&target_path);
+        return Err(error);
+    }
+    apply_resume_target(plan, source_session_id, &target_session_id)?;
+    Ok(CodexForkMaterialization {
+        path: target_path,
+        keep: false,
+    })
+}
+
+fn complete_source_snapshot(path: &Path) -> Result<String, ProviderError> {
+    let file = File::open(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let visible_len = file
+        .metadata()
+        .map_err(|error| ProviderError::Io(error.to_string()))?
+        .len();
+    let mut bytes = Vec::new();
+    file.take(visible_len)
+        .read_to_end(&mut bytes)
+        .map_err(|error| ProviderError::Io(error.to_string()))?;
+    let Some(boundary) = bytes.iter().rposition(|byte| *byte == b'\n') else {
+        return Err(ProviderError::Io(
+            "codex fork source has no complete JSONL record".to_string(),
+        ));
+    };
+    bytes.truncate(boundary + 1);
+    String::from_utf8(bytes).map_err(|error| ProviderError::Io(error.to_string()))
+}
+
+fn rewrite_snapshot(
+    source: &str,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+    source_agent_id: &str,
+    target_agent_id: &str,
+) -> Result<String, ProviderError> {
+    let source_marker = format!("You are Team Agent worker `{source_agent_id}`");
+    let target_marker = format!("You are Team Agent worker `{target_agent_id}`");
+    let mut meta_count = 0_usize;
+    let mut marker_count = 0_usize;
+    let mut output = String::new();
+    for (index, line) in source.lines().enumerate() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let mut record = serde_json::from_str::<serde_json::Value>(line).map_err(|error| {
+            ProviderError::Io(format!(
+                "codex fork source has invalid JSONL at line {}: {error}",
+                index + 1
+            ))
+        })?;
+        if record.get("type").and_then(serde_json::Value::as_str) == Some("session_meta") {
+            let id = record
+                .get_mut("payload")
+                .and_then(serde_json::Value::as_object_mut)
+                .and_then(|payload| payload.get_mut("id"))
+                .and_then(|id| id.as_str())
+                .ok_or_else(|| {
+                    ProviderError::Io(
+                        "codex fork session_meta has no string payload.id".to_string(),
+                    )
+                })?;
+            if id != source_session_id.as_str() {
+                return Err(ProviderError::Io(
+                    "codex fork session_meta id does not match source".to_string(),
+                ));
+            }
+            record["payload"]["id"] =
+                serde_json::Value::String(target_session_id.as_str().to_string());
+            meta_count += 1;
+        }
+        marker_count += replace_exact_marker(&mut record, &source_marker, &target_marker);
+        output.push_str(
+            &serde_json::to_string(&record)
+                .map_err(|error| ProviderError::Io(error.to_string()))?,
+        );
+        output.push('\n');
+    }
+    if meta_count != 1 || marker_count != 1 {
+        return Err(ProviderError::Io(format!(
+            "codex fork source identity is ambiguous: session_meta={meta_count}, marker={marker_count}"
+        )));
+    }
+    Ok(output)
+}
+
+fn replace_exact_marker(value: &mut serde_json::Value, source: &str, target: &str) -> usize {
+    match value {
+        serde_json::Value::String(text) => {
+            let count = text.matches(source).count();
+            if count == 1 {
+                *text = text.replacen(source, target, 1);
+            }
+            count
+        }
+        serde_json::Value::Array(items) => items
+            .iter_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        serde_json::Value::Object(fields) => fields
+            .values_mut()
+            .map(|item| replace_exact_marker(item, source, target))
+            .sum(),
+        _ => 0,
+    }
+}
+
+fn publish_target_no_clobber(path: &Path, bytes: &[u8]) -> Result<(), ProviderError> {
+    let parent = path.parent().ok_or_else(|| {
+        ProviderError::Io(format!("codex target has no parent: {}", path.display()))
+    })?;
+    let temp = parent.join(format!(
+        ".{}.tmp-{}",
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("codex-fork"),
+        std::process::id()
+    ));
+    let result = (|| -> std::io::Result<()> {
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&temp)?;
+        file.write_all(bytes)?;
+        file.sync_all()?;
+        std::fs::hard_link(&temp, path)?;
+        File::open(parent)?.sync_all()?;
+        std::fs::remove_file(&temp)?;
+        Ok(())
+    })();
+    if let Err(error) = result {
+        let _ = std::fs::remove_file(&temp);
+        return Err(ProviderError::Io(error.to_string()));
+    }
+    Ok(())
+}
+
+fn validate_materialized_target(
+    path: &Path,
+    session_id: &SessionId,
+    target_agent_id: &str,
+) -> Result<(), ProviderError> {
+    let text =
+        std::fs::read_to_string(path).map_err(|error| ProviderError::Io(error.to_string()))?;
+    let actual = session_id_from_jsonl(path);
+    let marker = format!("You are Team Agent worker `{target_agent_id}`");
+    if actual.as_deref() != Some(session_id.as_str())
+        || !path
+            .file_stem()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name.ends_with(session_id.as_str()))
+        || text.matches(&marker).count() != 1
+    {
+        return Err(ProviderError::Io(
+            "codex fork target read-back identity mismatch".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+fn apply_resume_target(
+    plan: &mut CommandPlan,
+    source_session_id: &SessionId,
+    target_session_id: &SessionId,
+) -> Result<(), ProviderError> {
+    if plan.argv.first().map(String::as_str) != Some("codex")
+        || plan.argv.get(1).map(String::as_str) != Some("fork")
+        || plan.argv.last().map(String::as_str) != Some(source_session_id.as_str())
+    {
+        return Err(ProviderError::Command(
+            "codex fork command shape cannot be converted to exact resume".to_string(),
+        ));
+    }
+    plan.argv[1] = "resume".to_string();
+    *plan.argv.last_mut().expect("validated non-empty argv") =
+        target_session_id.as_str().to_string();
+    plan.expected_session_id = Some(target_session_id.clone());
+    Ok(())
+}
+
+fn codex_session_v7() -> String {
+    use sha2::Digest;
+
+    static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+    let millis = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |duration| duration.as_millis() as u64);
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(millis.to_le_bytes());
+    hasher.update(std::process::id().to_le_bytes());
+    hasher.update(
+        COUNTER
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+            .to_le_bytes(),
+    );
+    let digest = hasher.finalize();
+    let mut bytes = [0_u8; 16];
+    bytes[..6].copy_from_slice(&millis.to_be_bytes()[2..]);
+    bytes[6..].copy_from_slice(&digest[..10]);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    format!(
+        "{:08x}-{:04x}-{:04x}-{:04x}-{:012x}",
+        u32::from_be_bytes(bytes[0..4].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[4..6].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[6..8].try_into().expect("fixed slice")),
+        u16::from_be_bytes(bytes[8..10].try_into().expect("fixed slice")),
+        u64::from_be_bytes([
+            0, 0, bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]
+        ])
+    )
+}
 
 pub(super) fn verify_codex_fork(
     source_session_id: &SessionId,
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
+    expected_backing_path: Option<&Path>,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
     deadline: Duration,
 ) -> Result<ContextForkProof, ContextForkTermination> {
+    let Some(expected) = plan.expected_session_id.as_ref() else {
+        return verify_legacy_codex_fork(
+            source_session_id,
+            plan,
+            before,
+            agent_id,
+            spawn_cwd,
+            spawned_at,
+            deadline,
+        );
+    };
+    if expected == source_session_id {
+        return Err(ProviderError::CaptureFailed(
+            "context_fork_unverified: codex target session equals source".to_string(),
+        )
+        .into());
+    }
+    let expected_path = expected_backing_path.ok_or_else(|| {
+        ProviderError::CaptureFailed(
+            "context_fork_unverified: codex plan has no materialized target backing".to_string(),
+        )
+    })?;
     let context = crate::provider::session_scan::CaptureSessionContext {
         agent_id: agent_id.to_string(),
         spawn_cwd: spawn_cwd.to_path_buf(),
@@ -18,28 +323,25 @@ pub(super) fn verify_codex_fork(
         expected_session_id: plan.expected_session_id.clone(),
         provider_projects_root: plan.provider_projects_root.clone(),
     };
-    let excluded = outcome::source_exclusions(before, source_session_id);
     let started = std::time::Instant::now();
     loop {
-        let current = jsonl_files(&before.root);
         for candidate in
             crate::provider::session_scan::scan_session_candidates_once(Provider::Codex, &context)?
         {
             let Some(path) = candidate.captured.rollout_path.as_ref() else {
                 continue;
             };
-            let Some(stamp) = current.get(path.as_path()) else {
-                continue;
-            };
-            let snapshot_changed = before.files.get(path.as_path()) != Some(stamp);
-            if !snapshot_changed {
+            if path.as_path() != expected_path {
                 continue;
             }
             let Some(new_session_id) = candidate.captured.session_id else {
                 continue;
             };
-            if excluded.contains(new_session_id.as_str())
-                || excluded.contains(&path.as_path().to_string_lossy().to_string())
+            if &new_session_id != expected || &new_session_id == source_session_id {
+                continue;
+            }
+            if !candidate.positive_agent_id_match
+                || candidate.embedded_agent_id.as_deref() != Some(agent_id)
             {
                 continue;
             }
@@ -63,3 +365,78 @@ pub(super) fn verify_codex_fork(
         deadline_ms: deadline.as_millis(),
     })
 }
+
+fn verify_legacy_codex_fork(
+    source_session_id: &SessionId,
+    plan: &CommandPlan,
+    before: &ContextBackingSnapshot,
+    agent_id: &str,
+    spawn_cwd: &Path,
+    spawned_at: &str,
+    deadline: Duration,
+) -> Result<ContextForkProof, ContextForkTermination> {
+    let mut excluded_session_ids = BTreeSet::new();
+    excluded_session_ids.insert(source_session_id.as_str().to_string());
+    let mut excluded_backing_paths = BTreeSet::new();
+    for path in before.files.keys() {
+        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
+            excluded_backing_paths.insert(path.clone());
+        }
+    }
+    let context = crate::provider::session_scan::CaptureSessionContext {
+        agent_id: agent_id.to_string(),
+        spawn_cwd: spawn_cwd.to_path_buf(),
+        pane_id: None,
+        pane_pid: None,
+        spawned_at: Some(spawned_at.to_string()),
+        expected_session_id: None,
+        provider_projects_root: plan.provider_projects_root.clone(),
+    };
+    let started = std::time::Instant::now();
+    loop {
+        let current = jsonl_files(&provider_backing_root(Provider::Codex, plan));
+        let mut matches = Vec::new();
+        for candidate in
+            crate::provider::session_scan::scan_session_candidates_once(Provider::Codex, &context)?
+        {
+            let Some(path) = candidate.captured.rollout_path.as_ref() else {
+                continue;
+            };
+            if excluded_backing_paths.contains(path.as_path()) {
+                continue;
+            }
+            let Some(stamp) = current.get(path.as_path()) else {
+                continue;
+            };
+            if before.files.get(path.as_path()) == Some(stamp) {
+                continue;
+            }
+            let Some(session_id) = candidate.captured.session_id else {
+                continue;
+            };
+            if excluded_session_ids.contains(session_id.as_str()) {
+                continue;
+            }
+            matches.push((session_id, path.as_path().to_path_buf()));
+        }
+        if let [(new_session_id, backing_path)] = matches.as_slice() {
+            return Ok(ContextForkProof {
+                provider: Provider::Codex,
+                source_session_id: source_session_id.clone(),
+                new_session_id: new_session_id.clone(),
+                backing_path: backing_path.clone(),
+                captured_via: "context_fork_verified".to_string(),
+                attribution_confidence: "high".to_string(),
+                managed_backing_root: None,
+            });
+        }
+        if started.elapsed() >= deadline {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(50));
+    }
+    Err(ContextForkTermination::Timeout {
+        provider: Provider::Codex,
+        deadline_ms: deadline.as_millis(),
+    })
+}

package/crates/team-agent/src/provider/session/context_fork/outcome.rs

@@ -1,18 +1,4 @@
 use super::*;
-use std::collections::BTreeSet;
-
-pub(super) fn source_exclusions(
-    before: &ContextBackingSnapshot,
-    source_session_id: &SessionId,
-) -> BTreeSet<String> {
-    let mut excluded = BTreeSet::from([source_session_id.as_str().to_string()]);
-    for path in before.files.keys() {
-        if session_id_from_jsonl(path).as_deref() == Some(source_session_id.as_str()) {
-            excluded.insert(path.to_string_lossy().to_string());
-        }
-    }
-    excluded
-}
 
 #[derive(Debug, Clone)]
 pub(crate) struct PendingContextFork {
@@ -47,6 +33,7 @@ pub(crate) fn observe_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -58,6 +45,7 @@ pub(crate) fn observe_context_fork(
         plan,
         before,
         expected_backing_path,
+        source_agent_id,
         agent_id,
         spawn_cwd,
         spawned_at,
@@ -123,6 +111,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &root,
             "2026-07-24T00:00:00Z",

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

@@ -21,6 +21,7 @@ pub(crate) enum ContextForkTermination {
 mod claude;
 mod codex;
 mod outcome;
+pub(crate) use codex::materialize_codex_fork;
 pub(crate) use outcome::{
     observe_context_fork, transition_pending_context_fork, ContextForkOutcome, PendingContextFork,
 };
@@ -47,7 +48,6 @@ pub struct ContextForkProof {
 
 #[derive(Debug, Clone)]
 pub(crate) struct ContextBackingSnapshot {
-    root: PathBuf,
     files: BTreeMap<PathBuf, FileStamp>,
 }
 
@@ -61,7 +61,7 @@ impl ContextBackingSnapshot {
     pub(crate) fn capture(provider: Provider, plan: &CommandPlan) -> Self {
         let root = provider_backing_root(provider, plan);
         let files = jsonl_files(&root);
-        Self { root, files }
+        Self { files }
     }
 }
 
@@ -71,6 +71,7 @@ pub(crate) fn verify_context_fork(
     plan: &CommandPlan,
     before: &ContextBackingSnapshot,
     expected_backing_path: Option<&Path>,
+    _source_agent_id: &str,
     agent_id: &str,
     spawn_cwd: &Path,
     spawned_at: &str,
@@ -84,6 +85,7 @@ pub(crate) fn verify_context_fork(
             source_session_id,
             plan,
             before,
+            expected_backing_path,
             agent_id,
             spawn_cwd,
             spawned_at,
@@ -298,6 +300,7 @@ mod tests {
             &plan,
             &before,
             None,
+            "source",
             "fork",
             &current_cwd,
             "2026-07-21T20:00:00+00:00",
@@ -344,6 +347,7 @@ mod tests {
             &plan,
             &before,
             Some(&expected_path),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",
@@ -382,6 +386,7 @@ mod tests {
             &plan,
             &before,
             Some(&missing),
+            "source",
             "fork",
             &root,
             "2026-07-22T00:00:00Z",

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

@@ -10,8 +10,9 @@ pub mod resume;
 
 pub use context_fork::ContextForkProof;
 pub(crate) use context_fork::{
-    context_fork_convergence_deadline, observe_context_fork, transition_pending_context_fork,
-    ContextBackingSnapshot, ContextForkOutcome, PendingContextFork,
+    context_fork_convergence_deadline, materialize_codex_fork, observe_context_fork,
+    transition_pending_context_fork, ContextBackingSnapshot, ContextForkOutcome,
+    PendingContextFork,
 };
 
 pub use resume::{

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

@@ -4,12 +4,40 @@ pub(super) fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
         .map(|dt| std::time::SystemTime::from(dt.with_timezone(&chrono::Utc)))
 }
 
+pub(super) fn truncate_to_uuid_precision(
+    timestamp: std::time::SystemTime,
+) -> Option<std::time::SystemTime> {
+    let since_epoch = timestamp
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)
+        .ok()?;
+    std::time::SystemTime::UNIX_EPOCH.checked_add(std::time::Duration::from_millis(
+        u64::try_from(since_epoch.as_millis()).ok()?,
+    ))
+}
+
 pub(super) fn rollout_created_at(path: &std::path::Path) -> Option<std::time::SystemTime> {
     created_at_from_rollout_uuid(path)
         .or_else(|| created_at_from_rollout_head(path))
         .or_else(|| created_at_from_rollout_filename(path))
 }
 
+pub(super) fn apply_expected_session_filter(
+    context: &super::CaptureSessionContext,
+    mut out: Vec<super::CapturedSessionCandidate>,
+) -> Vec<super::CapturedSessionCandidate> {
+    let Some(expected) = context.expected_session_id.as_ref() else {
+        return out;
+    };
+    out.retain(|candidate| {
+        candidate
+            .captured
+            .session_id
+            .as_ref()
+            .is_some_and(|session| session.as_str() == expected.as_str())
+    });
+    out
+}
+
 pub(super) fn retain_spawn_cwd(
     context: &super::CaptureSessionContext,
     out: &mut Vec<super::CapturedSessionCandidate>,

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

@@ -146,13 +146,23 @@ pub(super) fn apply_spawned_at_filter(
         out.clear();
         return;
     };
+    let codex_spawned_at =
+        if matches!(provider, Provider::Codex) && context.expected_session_id.is_some() {
+            let Some(timestamp) = super::codex::truncate_to_uuid_precision(spawned_at) else {
+                out.clear();
+                return;
+            };
+            timestamp
+        } else {
+            spawned_at
+        };
     out.retain(|candidate| {
         let Some(path) = candidate.captured.rollout_path.as_ref() else {
             return false;
         };
         if matches!(provider, Provider::Codex) {
             return super::codex::rollout_created_at(path.as_path())
-                .is_some_and(|created_at| created_at >= spawned_at);
+                .is_some_and(|created_at| created_at >= codex_spawned_at);
         }
         candidate_mtime(path.as_path()).is_some_and(|mtime| mtime >= spawned_at)
     });

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

@@ -72,6 +72,9 @@ pub(crate) fn scan_session_candidates_once(
     if matches!(provider, Provider::Claude | Provider::ClaudeCode) {
         return claude::apply_expected_session_filter(context, out);
     }
+    if matches!(provider, Provider::Codex) {
+        out = codex::apply_expected_session_filter(context, out);
+    }
 
     common::apply_spawn_time_window_if_unique(provider, context, &mut out);
     common::sort_expected_first_if_needed(context, &mut out);

package/package.json

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

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.
+- Positional `TO` has two co-equal forms: an in-team short name, for example `team-agent send reviewer "Review this change"`, and a fully-qualified logical name, `<workspace>::<team>/<agent>`. Use the fully-qualified form across workspaces or when the local team scope is ambiguous.
 - 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.