@team-agent/installer 0.5.60 → 0.5.62

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.60"
+version = "0.5.62"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.60"
+version = "0.5.62"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/adapters.rs

@@ -1,3 +1,4 @@
+//!
 //! cli · adapters — 每子命令的薄壳 `cmd_*`(commands.py)。委派 status/lifecycle/diagnose/
 //! leader/messaging port,把委派结果包成 [`CmdResult`]。含逻辑的:`cmd_status`(三态互斥)、
 //! `cmd_doctor`(gate/comms/fix-schema/cleanup-orphans 分派)。
@@ -221,7 +222,8 @@ fn warn_ignored_owner_team_id(team_dir: &std::path::Path) {
 
 /// `cmd_status`(`commands.py:90`)。三态:`--summary`(xor json,xor agent)→五行文本;
 /// `--json`→`status_port::status(compact=!detail)`;else→`status_port::format_status(agent)`。
-pub fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
+#[cfg(test)]
+pub(crate) fn cmd_status(args: &StatusArgs) -> Result<CmdResult, CliError> {
     cmd_status_for_team(args, args.team.as_deref())
 }
 
@@ -408,7 +410,8 @@ pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
 }
 
 /// `cmd_collect`(`parser.py:292`)。
-pub fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
+#[cfg(test)]
+pub(crate) fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
     cmd_collect_for_team(args, args.team.as_deref())
 }
 
@@ -483,6 +486,43 @@ pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<Cm
     ))
 }
 
+pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
+    let selected = match crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    ) {
+        Ok(selected) => selected,
+        Err(error) => {
+            return Ok(CmdResult::from_json(
+                json!({
+                    "ok": false,
+                    "error": error.to_string(),
+                    "workspace": args.workspace.to_string_lossy().to_string(),
+                }),
+                args.json,
+            ));
+        }
+    };
+    let results = messaging::results::results_for_case(
+        &selected.run_workspace,
+        &args.case_id,
+        Some(selected.team_key.as_str()),
+        args.team.as_deref(),
+    )?;
+    let value = json!({
+        "ok": true,
+        "case_id": args.case_id,
+        "results": results,
+        "workspace": selected.run_workspace.to_string_lossy().to_string(),
+    });
+    Ok(if args.json {
+        CmdResult::from_ordered_json(value)
+    } else {
+        CmdResult::from_json(value, false)
+    })
+}
+
 /// `cmd_allow_peer_talk`(`parser.py allow-peer-talk`).
 pub fn cmd_allow_peer_talk(args: &AllowPeerTalkArgs) -> Result<CmdResult, CliError> {
     if args.team.is_some() {
@@ -1485,7 +1525,13 @@ pub fn cmd_doctor(args: &DoctorArgs) -> Result<CmdResult, CliError> {
     } else if args.fix_schema {
         diagnose_port::fix_schema(&args.workspace)?
     } else {
-        diagnose_port::doctor(&args.workspace, args.spec.as_deref())?
+        let mut value = diagnose_port::doctor(&args.workspace, args.spec.as_deref())?;
+        crate::cli::diagnose::append_selected_live_leader_workspace_mismatch(
+            &args.workspace,
+            args.team.as_deref(),
+            &mut value,
+        );
+        value
     };
     Ok(CmdResult::from_json(value, args.json))
 }

package/crates/team-agent/src/cli/attach_app_server_leader.rs

@@ -1,3 +1,4 @@
+//!
 use super::*;
 
 /// `team-agent attach-app-server-leader` writes a typed codex_app_server

package/crates/team-agent/src/cli/diagnose.rs

@@ -1,5 +1,11 @@
+//!
 //! diagnose/preflight/wait-ready CLI helpers.
 use super::*;
+use crate::model::pane_authority_refusal::{
+    PaneAuthorityRecoveryAction, PaneAuthorityRecoveryHint, PaneAuthorityRefusal,
+    PaneAuthorityRefusalFacts, PaneAuthorityRefusalField, ACTION_FIELD, ACTION_REQUIRED_FIELD,
+    HINT_ACTION_FIELD, REASON_FIELD,
+};
 use crate::provider::wire::{command_name, parse_provider, provider_wire};
 use crate::transport::Transport;
 
@@ -195,12 +201,190 @@ pub(crate) fn diagnose_runtime_for_workspace(
     backend: &dyn Transport,
 ) -> (Value, Value) {
     let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    append_live_leader_workspace_mismatch_issue(
+        workspace,
+        state,
+        backend,
+        &mut issues,
+        &mut repairs,
+    );
     append_legacy_snapshot_issue(workspace, state, &mut issues);
     append_coordinator_health_issue(workspace, state, &mut issues, &mut repairs);
     append_runtime_bindings_stale_after_boot_issue(workspace, state, &mut issues, &mut repairs);
     (issues, repairs)
 }
 
+fn append_live_leader_workspace_mismatch_issue(
+    workspace: &std::path::Path,
+    state: &Value,
+    backend: &dyn Transport,
+    issues: &mut Value,
+    repairs: &mut Value,
+) {
+    let Some((issue, repair)) = live_leader_workspace_mismatch(workspace, state, backend) else {
+        return;
+    };
+    if let Some(items) = issues.as_array_mut() {
+        items.push(issue);
+    }
+    if let Some(items) = repairs.as_array_mut() {
+        items.push(repair);
+    }
+}
+
+fn live_leader_workspace_mismatch(
+    workspace: &std::path::Path,
+    state: &Value,
+    backend: &dyn Transport,
+) -> Option<(Value, Value)> {
+    let receiver = state.get("leader_receiver")?;
+    let facts = match crate::messaging::resolve_live_leader_channel(workspace, receiver, backend) {
+        crate::messaging::LeaderChannelResolution::Unbound(
+            crate::messaging::LeaderChannelUnbound::PaneWorkspaceMismatch(facts),
+        ) => facts,
+        _ => return None,
+    };
+    let team = state
+        .get("team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty())
+        .unwrap_or("current");
+    let provider = receiver
+        .get("provider")
+        .and_then(Value::as_str)
+        .filter(|provider| !provider.is_empty())
+        .unwrap_or("claude");
+    let refusal =
+        PaneAuthorityRefusal::new(PaneAuthorityRefusalFacts::PaneWorkspaceMismatch(facts));
+    let PaneAuthorityRefusalFacts::PaneWorkspaceMismatch(facts) = &refusal.facts else {
+        return None;
+    };
+    let mut fields = serde_json::Map::new();
+    fields.insert(
+        REASON_FIELD.to_string(),
+        Value::String(refusal.reason().as_str().to_string()),
+    );
+    fields.insert(
+        PaneAuthorityRefusalField::RequestedWorkspace
+            .as_str()
+            .to_string(),
+        Value::String(facts.requested_workspace.to_string_lossy().into_owned()),
+    );
+    fields.insert(
+        PaneAuthorityRefusalField::ObservedPaneId
+            .as_str()
+            .to_string(),
+        Value::String(facts.observed_pane_id.clone()),
+    );
+    fields.insert(
+        PaneAuthorityRefusalField::ObservedPaneWorkspace
+            .as_str()
+            .to_string(),
+        Value::String(facts.observed_pane_workspace.to_string_lossy().into_owned()),
+    );
+    fields.insert(
+        PaneAuthorityRefusalField::Endpoint.as_str().to_string(),
+        Value::String(facts.endpoint.clone()),
+    );
+    let mut issue = Value::Object(fields.clone());
+    if let Some(object) = issue.as_object_mut() {
+        object.insert(
+            "id".to_string(),
+            Value::String("leader_channel_workspace_mismatch".to_string()),
+        );
+    }
+    let mut repair = Value::Object(fields);
+    if let Some(object) = repair.as_object_mut() {
+        object.insert(
+            "issue".to_string(),
+            Value::String("leader_channel_workspace_mismatch".to_string()),
+        );
+        object.insert(
+            ACTION_REQUIRED_FIELD.to_string(),
+            Value::Bool(refusal.recovery.action_required),
+        );
+        object.insert("advisory".to_string(), Value::Bool(true));
+        object.insert(
+            "broken_class".to_string(),
+            Value::String("leader_channel_workspace_mismatch".to_string()),
+        );
+        object.insert(
+            HINT_ACTION_FIELD.to_string(),
+            Value::String(
+                match refusal.recovery.hint_action {
+                    PaneAuthorityRecoveryHint::AttachLeader => "team-agent attach-leader",
+                }
+                .to_string(),
+            ),
+        );
+        object.insert(
+            "dedupe_key".to_string(),
+            Value::String(format!("{team}:leader_channel_workspace_mismatch")),
+        );
+        object.insert(
+            ACTION_FIELD.to_string(),
+            Value::String(match refusal.recovery.action {
+                PaneAuthorityRecoveryAction::OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane => {
+                    format!(
+                        "open a new terminal window outside the current tmux/pane, change \
+                         directory to the requested workspace, then run \
+                         `team-agent attach-leader --team {team} --provider {provider} \
+                         --confirm --json`; then rerun \
+                         `team-agent diagnose --team {team} --json`"
+                    )
+                }
+            }),
+        );
+    }
+    Some((issue, repair))
+}
+
+pub(crate) fn append_selected_live_leader_workspace_mismatch(
+    workspace: &std::path::Path,
+    team: Option<&str>,
+    report: &mut Value,
+) {
+    let Some((issue, repair)) = selected_live_leader_workspace_mismatch(workspace, team) else {
+        return;
+    };
+    let Some(object) = report.as_object_mut() else {
+        return;
+    };
+    object.insert("issues".to_string(), Value::Array(vec![issue]));
+    object.insert("suggested_repairs".to_string(), Value::Array(vec![repair]));
+    object.insert("ok".to_string(), Value::Bool(false));
+    if object.get("error").is_none_or(Value::is_null) {
+        object.insert(
+            "error".to_string(),
+            Value::String("PaneWorkspaceMismatch".to_string()),
+        );
+    }
+}
+
+fn selected_live_leader_workspace_mismatch(
+    workspace: &std::path::Path,
+    team: Option<&str>,
+) -> Option<(Value, Value)> {
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )
+    .ok()?;
+    let backend: Box<dyn crate::transport::Transport> =
+        match crate::transport_factory::resolve_read_only_transport(
+            &selected.run_workspace,
+            Some(&selected.state),
+            crate::transport_factory::TransportPurpose::Diagnose,
+        ) {
+            Ok(resolved) => resolved.backend,
+            Err(_) => Box::new(crate::tmux_backend::TmuxBackend::for_workspace(
+                &selected.run_workspace,
+            )),
+        };
+    live_leader_workspace_mismatch(&selected.run_workspace, &selected.state, backend.as_ref())
+}
+
 /// 0.5.41 Slice 1 (fault-invisibility-locate.md §5/§6.2): read the
 /// coordinator heartbeat sidecar for the last-observed host boot
 /// identity and compare it against the current host boot. If they

package/crates/team-agent/src/cli/emit.rs

@@ -1,3 +1,4 @@
+//!
 //! cli · emit — `emit`(--json vs 人读 dict 逐键)+ 顶层 `run` 调度(parser.py `main`)+
 //! 人读标量/集合渲染(`human_value` / `json_dumps_like`)。
 
@@ -5,17 +6,30 @@ use super::spec::{command_spec, CommandKind, CommandTier, ALL_DISPATCH_KINDS, CO
 use super::*;
 use std::io::{ErrorKind, Write as _};
 
+///
 /// `emit`(`helpers.py:12-23`):`--json`→`json.dumps(indent=2, ensure_ascii=False, sort_keys=True)`;
 /// 否则 dict 逐键 `key: value`(嵌套 dict/list 内联 compact json,`ensure_ascii=False`)、非 dict 直接 print。
 /// 返回应打印到 stdout 的字符串(bin main 负责实际 println)。
 pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
+    emit_with_json_order(output, as_json, false)
+}
+
+fn emit_with_json_order(
+    output: &CmdOutput,
+    as_json: bool,
+    preserve_json_order: bool,
+) -> Option<String> {
     match output {
         CmdOutput::None => None,
         CmdOutput::Human(text) => Some(crate::redaction::redact_external_text(text)),
         CmdOutput::Json(value) => {
             let value = crate::redaction::redact_external_value(value);
             if as_json {
-                return serde_json::to_string_pretty(&sort_json(&value)).ok();
+                return if preserve_json_order {
+                    serde_json::to_string_pretty(&value).ok()
+                } else {
+                    serde_json::to_string_pretty(&sort_json(&value)).ok()
+                };
             }
             if let Value::Object(obj) = value {
                 let lines: Vec<String> = obj
@@ -30,6 +44,7 @@ pub fn emit(output: &CmdOutput, as_json: bool) -> Option<String> {
     }
 }
 
+///
 /// `main(argv)`(`parser.py:84`):**CLI 唯一进程入口**。codex/claude/copilot passthrough 早返回 →
 /// 解析 argv 到 subcommand → 调对应 handler → 异常落盘 + 信封 + `ExitCode::Error` →
 /// `consume_leader_inbox_summary` → `emit` → `result.ok is False ? Error : Ok`。
@@ -84,7 +99,7 @@ fn emit_result(r: CmdResult) -> ExitCode {
             .map(ToString::to_string),
         _ => None,
     };
-    if let Some(text) = emit(&r.output, r.as_json) {
+    if let Some(text) = emit_with_json_order(&r.output, r.as_json, r.preserve_json_order) {
         if let Err(error) = write_stdout_line(&text) {
             if let Some(message_id) = persisted_message_id {
                 let stderr = std::io::stderr();
@@ -180,6 +195,7 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
             cmd_collect_for_team(&collect_args(args, cwd)?, parse_args(args).team.as_deref())
                 .map(emit_result)
         }
+        "results" => cmd_results(&results_args(args, cwd)?).map(emit_result),
         "diagnose" => cmd_diagnose(&diagnose_args(args, cwd)).map(emit_result),
         "preflight" => cmd_preflight(&preflight_args(args, cwd)).map(emit_result),
         "wait-ready" => cmd_wait_ready(&wait_ready_args(args, cwd)).map(emit_result),
@@ -226,6 +242,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "install-skill",
     "profile",
     "collect",
+    "results",
     "diagnose",
     "preflight",
     "wait-ready",
@@ -271,7 +288,7 @@ fn default_help() -> String {
     append_help_section(
         &mut out,
         "Core",
-        &["quick-start", "send", "status", "collect"],
+        &["quick-start", "send", "status", "collect", "results"],
     );
     append_help_section(
         &mut out,
@@ -319,6 +336,7 @@ fn compat_hidden_help(command: &str, usage: &str) -> String {
     format!("{usage}\n\nstatus: hidden compatibility command\nsunset: {sunset}\naction: {action}")
 }
 
+///
 /// Test-only public accessor for `command_help` — allows integration
 /// tests to grep the help copy without depending on internal parser
 /// machinery.
@@ -326,6 +344,7 @@ pub fn __test_command_help(command: Option<&str>) -> String {
     command_help(command)
 }
 
+///
 /// Test-only public accessor for `quick_start_args` — allows
 /// integration tests to exercise the parser without going through
 /// stdio + the full `main` entrypoint.
@@ -346,10 +365,10 @@ fn command_help(command: Option<&str>) -> String {
         Some("send") => concat!(
             "usage: team-agent send TO MESSAGE... ",
             "[--workspace WORKSPACE] [--team TEAM] ",
-            "[--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] ",
+            "[--mailbox] ",
             "[--json]\n\n",
             "TO is a logical recipient; send returns after the message is persisted. ",
-            "Presentation changes live display only; every sink remains durable."
+            "--mailbox stores durably without live injection; omitted sends to the live conversation."
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
@@ -383,6 +402,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--json]".to_string(),
         Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
+        Some("results") => "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("diagnose") => "usage: team-agent diagnose [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("preflight") => "usage: team-agent preflight [TEAMDIR] [--json]".to_string(),
         Some("wait-ready") => "usage: team-agent wait-ready [--workspace WORKSPACE] [--team TEAM] [--timeout SECONDS] [--json]".to_string(),
@@ -806,6 +826,7 @@ struct ParsedArgs {
     socket: Option<String>,
     thread_id: Option<String>,
     message_id: Option<String>,
+    mailbox: bool,
     presentation_sink: Option<String>,
     message_class: Option<String>,
     case_id: Option<String>,
@@ -899,6 +920,7 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--socket" => parsed.socket = next_arg(args, &mut i),
             "--thread-id" => parsed.thread_id = next_arg(args, &mut i),
             "--message-id" => parsed.message_id = next_arg(args, &mut i),
+            "--mailbox" => parsed.mailbox = true,
             "--presentation-sink" => parsed.presentation_sink = next_arg(args, &mut i),
             "--message-class" => parsed.message_class = next_arg(args, &mut i),
             "--case-id" => parsed.case_id = next_arg(args, &mut i),
@@ -1077,6 +1099,7 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     };
     let message_start = usize::from(target.is_some());
     let workspace = workspace(&parsed, cwd);
+    let sender = trusted_cli_sender(&workspace, parsed.team.as_deref())?;
     let presentation_value = if parsed.presentation_sink.is_some()
         || parsed.message_class.is_some()
         || parsed.case_id.is_some()
@@ -1089,10 +1112,14 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     } else {
         None
     };
-    let (presentation, presentation_error) =
-        crate::messaging::presentation::normalize_presentation(presentation_value.as_ref());
-    if let Some(error) = presentation_error {
-        return Err(CliError::Usage(format!("invalid presentation: {error}")));
+    let mailbox_value = parsed.mailbox.then(|| serde_json::json!(true));
+    let normalized = crate::messaging::presentation::normalize_send_presentation(
+        mailbox_value.as_ref(),
+        presentation_value.as_ref(),
+    )
+    .map_err(|error| CliError::Usage(format!("invalid send routing: {error}")))?;
+    if let Some(deprecation) = normalized.deprecation {
+        eprintln!("warning: {deprecation}");
     }
     Ok(SendArgs {
         target,
@@ -1106,7 +1133,7 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
         workspace,
         team: parsed.team,
         task: None,
-        sender: trusted_cli_sender(),
+        sender,
         no_ack: false,
         no_wait: true,
         watch_result: false,
@@ -1114,21 +1141,49 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
         confirm_human: false,
         json: parsed.json,
         message_id: None,
-        presentation,
+        presentation: normalized.request,
         pane: parsed.pane.clone(),
         to_name: parsed.to_name.clone(),
         to_leader: parsed.to_leader.clone(),
     })
 }
 
-fn trusted_cli_sender() -> TrustedSender {
-    std::env::var("TEAM_AGENT_ID")
+fn trusted_cli_sender(workspace: &Path, team: Option<&str>) -> Result<TrustedSender, CliError> {
+    let agent_id = std::env::var("TEAM_AGENT_ID")
         .ok()
         .map(|value| value.trim().to_string())
-        .filter(|value| !value.is_empty())
-        .map(crate::model::ids::AgentId::new)
-        .map(TrustedSender::from_runtime_identity)
-        .unwrap_or_else(TrustedSender::leader)
+        .filter(|value| !value.is_empty());
+    let worker_context = ["TEAM_AGENT_OWNER_TEAM_ID", "TEAM_AGENT_AGENT_ID"]
+        .into_iter()
+        .any(|key| {
+            std::env::var(key)
+                .ok()
+                .is_some_and(|value| !value.trim().is_empty())
+        });
+    let Some(agent_id) = agent_id else {
+        if worker_context {
+            return Err(CliError::Usage(
+                "send requires framework-injected TEAM_AGENT_ID; refusing leader identity fallback"
+                    .to_string(),
+            ));
+        }
+        return Ok(TrustedSender::leader());
+    };
+    let source_workspace = std::env::var("TEAM_AGENT_WORKSPACE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or_else(|| workspace.display().to_string());
+    let source_team = std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
+        .ok()
+        .or_else(|| std::env::var("TEAM_AGENT_TEAM_ID").ok())
+        .or_else(|| team.map(ToOwned::to_owned))
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or_else(|| "unknown".to_string());
+    Ok(TrustedSender::from_runtime_identity_with_source(
+        crate::model::ids::AgentId::new(agent_id),
+        source_workspace,
+        &source_team,
+    ))
 }
 
 fn warn_send_legacy_delivery_flags(args: &[String]) {
@@ -1177,6 +1232,7 @@ fn validate_send_flags(args: &[String]) -> Result<(), CliError> {
         "--timeout",
         "--confirm-human",
         "--message-id",
+        "--mailbox",
         "--presentation-sink",
         "--message-class",
         "--case-id",
@@ -1593,6 +1649,27 @@ fn collect_args(args: &[String], cwd: &Path) -> Result<CollectArgs, CliError> {
     })
 }
 
+fn results_args(args: &[String], cwd: &Path) -> Result<ResultsArgs, CliError> {
+    if args
+        .iter()
+        .any(|arg| arg == "--to" || arg.starts_with("--to="))
+    {
+        return Err(CliError::Usage(
+            "results does not accept --to; it is a read-only command".to_string(),
+        ));
+    }
+    let parsed = parse_args(args);
+    let case_id = option_value(args, "--case")
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| CliError::Usage("missing --case".to_string()))?;
+    Ok(ResultsArgs {
+        case_id,
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        json: parsed.json,
+    })
+}
+
 fn option_value(args: &[String], flag: &str) -> Option<String> {
     let prefix = format!("{flag}=");
     let mut i = 0usize;
@@ -2093,8 +2170,14 @@ mod tests {
     }
 
     #[test]
-    fn send_presentation_flags_map_to_the_typed_request() {
+    fn send_mailbox_and_legacy_progress_map_to_the_one_bit_request() {
         let cwd = tmp_workspace();
+        let mailbox = send_args(&cli_argv(&["leader", "progress", "--mailbox"]), &cwd).unwrap();
+        assert_eq!(
+            mailbox.presentation.sink,
+            crate::messaging::presentation::PresentationSink::Casefile
+        );
+
         let args = send_args(
             &cli_argv(&[
                 "leader",
@@ -2115,9 +2198,9 @@ mod tests {
         );
         assert_eq!(
             args.presentation.class,
-            crate::messaging::presentation::PresentationClass::Progress
+            crate::messaging::presentation::PresentationClass::Message
         );
-        assert_eq!(args.presentation.case_id.as_deref(), Some("case-9"));
+        assert_eq!(args.presentation.case_id, None);
     }
 
     #[test]
@@ -2130,7 +2213,7 @@ mod tests {
         .unwrap_err();
         assert!(matches!(
             error,
-            CliError::Usage(message) if message == "invalid presentation: missing_class"
+            CliError::Usage(message) if message == "invalid send routing: missing_class"
         ));
     }
 

package/crates/team-agent/src/cli/helpers.rs

@@ -1,3 +1,4 @@
+//!
 //! cli · helpers — 跨子模块共用的小工具:tmux 冲突解析、Python 真值/falsy-or 语义、
 //! 字符级截断、相对 age 文本、稳定 key-sorted JSON。
 

package/crates/team-agent/src/cli/leader.rs

@@ -1,3 +1,4 @@
+//!
 //! cli · leader — `codex`/`claude`/`copilot` passthrough(`cmd_leader_passthrough` + `_provider_args` /
 //! `_leader_launcher_args`)+ leader fallback inbox 摘要(`consume_leader_inbox_summary` 及
 //! `_leader_inbox_entries` / `_leader_inbox_summary` / `_leader_inbox_entry_title`)。
@@ -8,6 +9,7 @@ use super::*;
 // `codex`/`claude` passthrough 解析(helpers.py `_provider_args`/`_leader_launcher_args`)
 // =============================================================================
 
+///
 /// `_provider_args`(`helpers.py:190-193`):剥掉前导 `--`(REMAINDER 第一个 token)。
 pub fn provider_args(values: &[String]) -> Vec<String> {
     match values.first().map(String::as_str) {
@@ -16,8 +18,9 @@ pub fn provider_args(values: &[String]) -> Vec<String> {
     }
 }
 
+///
 /// `_leader_launcher_args`(`helpers.py:196-226`):解析 attach 旗标;`--attach-session` 缺值 → Err。
-pub fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, CliError> {
+pub(super) fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, CliError> {
     let mut out = LeaderLauncherArgs::default();
     let mut idx = 0;
     while idx < values.len() {
@@ -39,6 +42,8 @@ pub fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, Cli
             out.confirm_attach = true;
         } else if token == "--external-leader" {
             out.external_leader = true;
+        } else if token == "--allow-nested-attach" {
+            out.allow_nested_attach = true;
         } else if token == "--attach-session" {
             let Some(value) = values.get(idx + 1) else {
                 return Err(CliError::Runtime(
@@ -60,7 +65,12 @@ pub fn leader_launcher_args(values: &[String]) -> Result<LeaderLauncherArgs, Cli
 fn is_leader_launcher_flag(value: &str) -> bool {
     matches!(
         value,
-        "--external-leader" | "--attach" | "--attach-existing" | "--confirm" | "--attach-session"
+        "--external-leader"
+            | "--allow-nested-attach"
+            | "--attach"
+            | "--attach-existing"
+            | "--confirm"
+            | "--attach-session"
     ) || value.starts_with("--attach-session=")
 }
 
@@ -85,6 +95,7 @@ fn without_leader_json(values: &[String]) -> Vec<String> {
     out
 }
 
+///
 /// `codex`/`claude`/`copilot` passthrough(`parser.py:86`/`_run_leader_passthrough`):leader 早返回,
 /// **不**进 subparser。`-h`/`--help` 打 usage 直接返回 [`CmdResult::none`]。否则解析 attach
 /// 旗标 + `lifecycle_port::start_leader`。`command` ∈ {codex, claude, copilot}。
@@ -113,6 +124,7 @@ pub(crate) fn leader_passthrough_provider(command: &str) -> crate::model::enums:
 // leader fallback inbox 摘要(helpers.py `consume_leader_inbox_summary`)
 // =============================================================================
 
+///
 /// `consume_leader_inbox_summary`(`helpers.py:26-55`):每条命令后读
 /// `.team/runtime/leader-inbox.log`,从游标 `.cursor` 起读新增字节,渲染 N 条 fallback 条目摘要
 /// (`_leader_inbox_summary`,字节预算 budget=500 截断 + `Hint: team-agent inbox leader`),