@team-agent/installer 0.5.60 → 0.5.61

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.60"
+version = "0.5.61"
 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.61"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -483,6 +483,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 +1522,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/diagnose.rs

@@ -1,5 +1,10 @@
 //! 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 +200,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

@@ -9,13 +9,25 @@ use std::io::{ErrorKind, Write as _};
 /// 否则 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
@@ -84,7 +96,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 +192,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 +239,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "install-skill",
     "profile",
     "collect",
+    "results",
     "diagnose",
     "preflight",
     "wait-ready",
@@ -271,7 +285,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,
@@ -346,10 +360,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 +397,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 +821,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 +915,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),
@@ -1089,10 +1106,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,
@@ -1114,7 +1135,7 @@ 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(),
@@ -1177,6 +1198,7 @@ fn validate_send_flags(args: &[String]) -> Result<(), CliError> {
         "--timeout",
         "--confirm-human",
         "--message-id",
+        "--mailbox",
         "--presentation-sink",
         "--message-class",
         "--case-id",
@@ -1593,6 +1615,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 +2136,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 +2164,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 +2179,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/leader.rs

@@ -39,6 +39,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 +62,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=")
 }