@team-agent/installer 0.5.60 → 0.5.62

package/crates/team-agent/src/cli/send/resolve.rs

@@ -1,3 +1,4 @@
+//!
 use super::mailbox::maybe_enqueue_offline_leader_mailbox;
 use super::persist::persist_resolved_target;
 use crate::cli::{CliError, SendArgs};
@@ -207,7 +208,7 @@ pub(super) fn send_to_logical_to(
                         &args.workspace,
                         name,
                         content,
-                        args.sender.as_str(),
+                        args.sender.display_name(),
                         args.task.as_deref(),
                         &error,
                     )? {
@@ -359,3 +360,207 @@ pub(super) fn send_to_resolved_name(
     }
     Ok(value)
 }
+
+#[cfg(test)]
+mod a13_red_tests {
+    #![allow(clippy::expect_used, clippy::unwrap_used, clippy::panic)]
+
+    use super::send_to_resolved_name;
+    use crate::cli::named_address::{NamedTargetKind, ResolvedNamedAddress};
+    use crate::cli::SendArgs;
+    use crate::message_store::MessageStore;
+    use crate::messaging::TrustedSender;
+    use crate::model::ids::AgentId;
+    use serde_json::{json, Value};
+    use std::path::{Path, PathBuf};
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    fn fresh_workspace(tag: &str) -> PathBuf {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        let workspace = std::env::temp_dir().join(format!(
+            "team-agent-a13-{tag}-{}-{}",
+            std::process::id(),
+            NEXT.fetch_add(1, Ordering::Relaxed)
+        ));
+        let _ = std::fs::remove_dir_all(&workspace);
+        std::fs::create_dir_all(workspace.join(".team/runtime")).expect("create fixture");
+        workspace
+    }
+
+    fn seed_team(workspace: &Path, team: &str) {
+        let session = format!("team-{team}");
+        let state = json!({
+            "active_team_key": team,
+            "status": "alive",
+            "session_name": session,
+            "agents": {},
+            "teams": {
+                team: {
+                    "status": "alive",
+                    "session_name": session,
+                    "agents": {},
+                    "leader_receiver": {"status": "unbound"}
+                }
+            }
+        });
+        crate::state::persist::save_runtime_state(workspace, &state).expect("save fixture state");
+        MessageStore::open(workspace).expect("create fixture store");
+    }
+
+    fn send_args(workspace: &Path) -> SendArgs {
+        SendArgs {
+            target: None,
+            message: vec!["payload".to_string()],
+            targets: None,
+            workspace: workspace.to_path_buf(),
+            team: None,
+            task: None,
+            sender: TrustedSender::from_runtime_identity_with_source(
+                AgentId::new("worker-1"),
+                workspace.display(),
+                "sender-team",
+            ),
+            no_ack: false,
+            no_wait: true,
+            watch_result: false,
+            timeout: 0.0,
+            confirm_human: false,
+            json: true,
+            message_id: None,
+            presentation: crate::messaging::presentation::PresentationRequest::default(),
+            pane: None,
+            to_name: Some("other-team/leader".to_string()),
+            to_leader: None,
+        }
+    }
+
+    fn leader_address(sender_workspace: &Path, target_workspace: &Path) -> ResolvedNamedAddress {
+        ResolvedNamedAddress {
+            raw_name: format!("{}::other-team/leader", target_workspace.display()),
+            target_kind: NamedTargetKind::Leader,
+            sender_workspace: sender_workspace.to_path_buf(),
+            target_workspace: target_workspace.to_path_buf(),
+            team_key: Some("other-team".to_string()),
+            agent_id: None,
+            pane_id: String::new(),
+            session_name: Some("team-other-team".to_string()),
+            window_name: None,
+            tmux_endpoint: None,
+            transport_kind: Some("direct_tmux".to_string()),
+            app_server: None,
+            state_pane_id: None,
+            state_pane_stale: false,
+            agent_status: None,
+            warning: None,
+        }
+    }
+
+    fn message_count(workspace: &Path) -> i64 {
+        let store = MessageStore::open(workspace).expect("open fixture store");
+        crate::db::schema::open_db(store.db_path())
+            .expect("open fixture database")
+            .query_row("select count(*) from messages", [], |row| row.get(0))
+            .expect("count fixture messages")
+    }
+
+    #[test]
+    fn a13_worker_cross_workspace_leader_send_preserves_target_scope() {
+        let sender_workspace = fresh_workspace("sender");
+        let target_workspace = fresh_workspace("target");
+        seed_team(&target_workspace, "other-team");
+        let mut args = send_args(&sender_workspace);
+        let to_name = format!("{}::other-team/leader", target_workspace.display());
+        args.to_name = Some(to_name.clone());
+        let value = super::send_to_logical_to(&args, &to_name, "payload")
+            .expect("cross-workspace leader send must preserve a structured outcome");
+        assert_eq!(
+            value["to_name"],
+            json!(to_name),
+            "cross-workspace receipt must retain the original target: {value}"
+        );
+        assert_eq!(
+            value["sender"],
+            json!(format!(
+                "{}::sender-team/worker-1",
+                sender_workspace.display()
+            )),
+            "cross-workspace receipt must retain the full sender: {value}"
+        );
+        assert_eq!(
+            message_count(&sender_workspace),
+            0,
+            "cross-workspace send must not fold into the sender workspace"
+        );
+        assert_eq!(
+            message_count(&target_workspace),
+            1,
+            "cross-workspace send must persist in the target workspace"
+        );
+
+        let _ = std::fs::remove_dir_all(sender_workspace);
+        let _ = std::fs::remove_dir_all(target_workspace);
+    }
+
+    #[test]
+    fn a13_worker_cross_workspace_identity_is_preserved_in_row_and_render() {
+        let sender_workspace = fresh_workspace("identity-sender");
+        let target_workspace = fresh_workspace("identity-target");
+        seed_team(&target_workspace, "other-team");
+        let mut args = send_args(&sender_workspace);
+        args.to_name = Some(format!("{}::other-team/leader", target_workspace.display()));
+        let resolved = leader_address(&sender_workspace, &target_workspace);
+
+        send_to_resolved_name(&args, &resolved, "identity payload")
+            .expect("cross-workspace identity send must persist");
+        let store = MessageStore::open(&target_workspace).expect("open target store");
+        let connection = crate::db::schema::open_db(store.db_path()).expect("open target db");
+        let sender: String = connection
+            .query_row("select sender from messages limit 1", [], |row| row.get(0))
+            .expect("read sender");
+        let expected = format!("{}::sender-team/worker-1", sender_workspace.display());
+        assert_eq!(
+            sender, expected,
+            "durable row must retain the full sender identity"
+        );
+        let rendered = crate::messaging::delivery::render_message(
+            &sender,
+            None,
+            "identity payload",
+            "msg-a13",
+        );
+        assert!(
+            rendered.contains(&expected),
+            "rendered pane must show full sender: {rendered}"
+        );
+        assert!(
+            !rendered.contains("from leader"),
+            "worker must not render as leader: {rendered}"
+        );
+
+        let _ = std::fs::remove_dir_all(sender_workspace);
+        let _ = std::fs::remove_dir_all(target_workspace);
+    }
+
+    #[test]
+    fn a13_worker_in_workspace_leader_send_remains_allowed() {
+        let workspace = fresh_workspace("in-workspace");
+        seed_team(&workspace, "other-team");
+        let args = send_args(&workspace);
+        let resolved = leader_address(&workspace, &workspace);
+
+        let value = send_to_resolved_name(&args, &resolved, "payload")
+            .expect("in-workspace leader send should preserve the existing path");
+        assert_ne!(
+            value["reason"],
+            Value::String("target_out_of_scope".to_string()),
+            "in-workspace send must not be classified as cross-workspace: {value}"
+        );
+        assert_eq!(
+            message_count(&workspace),
+            1,
+            "allowed send must persist once"
+        );
+
+        let _ = std::fs::remove_dir_all(workspace);
+    }
+}

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

@@ -1,3 +1,4 @@
+//!
 //! cli · send — `cmd_send` + target 解析(`_send_target`)+ `SendArgs`→`SendOptions` 翻译
 //! (`send_options_from_args`,旗标取反语义)。
 
@@ -180,7 +181,7 @@ pub fn send_to_canonical_leader_target(
 }
 
 /// `_send_target`(`commands.py:181-184`):`--to` comma-split fanout / `target` 单值 / None。
-pub fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
+pub(super) fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
     if let Some(targets) = targets.filter(|s| !s.is_empty()) {
         let recipients: Vec<String> = targets
             .split(',')

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

@@ -1,3 +1,4 @@
+//!
 //! C1 command registry: one catalog for help visibility, known-command gates,
 //! suggestion candidates, and command-tier governance.
 
@@ -76,6 +77,7 @@ pub(crate) enum DispatchKind {
     InstallSkill,
     Profile,
     Collect,
+    Results,
     Diagnose,
     Preflight,
     WaitReady,
@@ -120,6 +122,7 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::InstallSkill,
     DispatchKind::Profile,
     DispatchKind::Collect,
+    DispatchKind::Results,
     DispatchKind::Diagnose,
     DispatchKind::Preflight,
     DispatchKind::WaitReady,
@@ -155,9 +158,10 @@ pub(crate) struct CommandSpec {
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
+    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--mailbox] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "shutdown", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Shutdown), summary: "stop the selected team", usage: "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "add-agent", tier: CommandTier::Core, category: CommandCategory::WorkerLifecycle, kind: CommandKind::Dispatch(DispatchKind::AddAgent), summary: "add or force-recreate a worker", usage: "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },

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

@@ -1,3 +1,4 @@
+//!
 //! cli · status — 五行 triage summary 渲染 + agent 分类计数(commands.py
 //! `_format_status_summary` / `_agent_summary_counts` / `_interaction_counts` /
 //! `_latest_result_line` + `cmd_status` 的 compact 不变量)。
@@ -100,7 +101,7 @@ fn stale_agent_bucket(agent: &Value) -> Option<SummaryBucket> {
 }
 
 /// `_interaction_counts`(`commands.py:292-306`):遍历 agents 的 `interacted` 字段。
-pub fn interaction_counts(agents: &Value) -> InteractionCounts {
+pub(super) fn interaction_counts(agents: &Value) -> InteractionCounts {
     let mut counts = InteractionCounts::default();
     let Some(agent_map) = agents.as_object() else {
         return counts;

package/crates/team-agent/src/cli/status_port/compact.rs

@@ -1,3 +1,4 @@
+//!
 use super::*;
 
 pub(super) fn compact_status(full: Value) -> Value {

package/crates/team-agent/src/cli/status_port/format.rs

@@ -1,3 +1,4 @@
+//!
 use crate::cli::CliError;
 use serde_json::{json, Value};
 

package/crates/team-agent/src/cli/status_port/inbox.rs

@@ -1,3 +1,4 @@
+//!
 use super::*;
 
 pub fn inbox(

package/crates/team-agent/src/cli/status_port/store.rs

@@ -393,12 +393,16 @@ pub(super) fn count_undelivered_backlog(
     conn: &rusqlite::Connection,
     owner_team_id: Option<&str>,
 ) -> Result<i64, CliError> {
-    // Backlog statuses chosen to mirror what `deliver_pending` would pick up.
+    // Delivery debt is broader than requeue eligibility: a physically injected
+    // row awaiting a future receipt remains undelivered even though it must not
+    // be claimed or injected again.
     let sql = match owner_team_id {
             Some(_) => "select count(*) from messages
-                       where owner_team_id = ?1 and status in ('accepted','pending','queued','queued_until_trust')",
+                       where owner_team_id = ?1 and status in
+                       ('accepted','pending','queued','queued_until_trust','injected_awaiting_receipt')",
             None => "select count(*) from messages
-                     where status in ('accepted','pending','queued','queued_until_trust')",
+                     where status in
+                     ('accepted','pending','queued','queued_until_trust','injected_awaiting_receipt')",
         };
     let count: i64 = match owner_team_id {
         Some(team) => conn

package/crates/team-agent/src/cli/tests/named_address.rs

@@ -135,6 +135,17 @@ fn assert_kind(
     assert!(n38.contains("Log: "), "{n38}");
 }
 
+fn assert_broad_leader_not_attached(err: NamedAddressError) {
+    assert_eq!(err.kind, NamedAddressErrorKind::LeaderNotAttached);
+    assert_eq!(err.channel_reason, None);
+    let value = err.to_json();
+    assert_eq!(value["reason"], json!("leader_not_attached"));
+    assert!(
+        value.get("channel_reason").is_none(),
+        "broad refusal must not expose a typed channel reason: {value}"
+    );
+}
+
 fn named_send_args(
     ws: &Path,
     to_name: Option<&str>,
@@ -372,6 +383,60 @@ fn resolve_leader_name_not_live() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn resolve_leader_receiver_not_attached_stays_broad() {
+    let ws = named_ws("leader-receiver-not-attached");
+    let mut team = leader_team("alpha-session", "%leader", "/tmp/leader.sock");
+    team["leader_receiver"]["status"] = json!("rebind_required");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": team
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/leader.sock")
+        .with_targets(vec![pane("alpha-session-leader", "codex", "%leader")]);
+
+    let err = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap_err();
+    assert_broad_leader_not_attached(err);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_leader_pane_not_live_stays_broad() {
+    let ws = named_ws("leader-pane-not-live");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": leader_team("alpha-session", "%missing", "/tmp/leader.sock")
+        })),
+    );
+    let transport = OfflineTransport::new().with_tmux_endpoint("/tmp/leader.sock");
+
+    let err = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap_err();
+    assert_broad_leader_not_attached(err);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn resolve_leader_probe_failure_stays_broad() {
+    let ws = named_ws("leader-probe-failed");
+    seed_state(
+        &ws,
+        state_with_teams(json!({
+            "alpha": leader_team("alpha-session", "%leader", "/tmp/leader.sock")
+        })),
+    );
+    let transport = OfflineTransport::new()
+        .with_tmux_endpoint("/tmp/leader.sock")
+        .with_list_targets_error("injected leader pane probe failure");
+
+    let err = resolve_name_with_transport(&ws, "alpha/leader", &transport).unwrap_err();
+    assert_broad_leader_not_attached(err);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 #[test]
 fn resolve_leader_name_after_rebind() {
     let ws = named_ws("leader-rebind");

package/crates/team-agent/src/cli/tests/verb_profile.rs

@@ -122,6 +122,44 @@ fn profile_init_routes_and_creates_secret_boundary_files() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
+#[test]
+fn compatible_api_profile_init_template_contains_common_five_fields() {
+    let ws = tmp_workspace();
+    let code = run(
+        &profile_argv(&[
+            "profile",
+            "init",
+            "compat",
+            "--workspace",
+            ".",
+            "--auth-mode",
+            "compatible_api",
+            "--json",
+        ]),
+        &ws,
+    );
+    assert_eq!(
+        code,
+        ExitCode::Ok,
+        "compatible_api profile init must route and exit 0"
+    );
+
+    let expected =
+        "AUTH_MODE=compatible_api\nPROFILE_NAME=compat\nBASE_URL=\nAPI_KEY=\nMODEL=\n";
+    let dir = profiles_dir(&ws);
+    assert_eq!(
+        std::fs::read_to_string(dir.join("compat.env")).unwrap(),
+        expected,
+        "compatible_api profile must expose the documented five-field template"
+    );
+    assert_eq!(
+        std::fs::read_to_string(dir.join("compat.example.env")).unwrap(),
+        expected,
+        "compatible_api example must expose the documented five-field template"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
 // Golden source:
 // - profiles/core.py:95-119 doctor_profile returns ok=true for existing profiles and
 //   ok=false for missing profiles; parser.py:506-508 maps result.ok false to exit 1.

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

@@ -1,3 +1,4 @@
+//!
 //! cli · types — 错误信封 / 退出码 / 命令结果载体 / leader passthrough 参数 /
 //! 每子命令的 clap-style arg 结构 / 五行 summary 计数桶。
 
@@ -13,7 +14,7 @@ use crate::transport::PaneId;
 /// `{ok:false, error, action, log, reason?, session_name?, next_actions?}`(字节级保留)。
 /// 人读时打 `error:`/`action:`/`log:` 三行到 stderr(`helpers.py:132-134`)。
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CliErrorPayload {
+pub(crate) struct CliErrorPayload {
     /// 恒 `false`(错误信封)。
     pub ok: bool,
     pub error: String,
@@ -70,7 +71,7 @@ impl From<crate::messaging::MessagingError> for CliError {
 impl CliError {
     /// `_cli_error_payload`(`helpers.py:137-155`):落盘日志后构造稳定信封。tmux session
     /// 冲突时按 command 富化 reason/session_name/next_actions(`helpers.py:158-187`)。
-    pub fn to_payload(&self, log_path: &Path, command: &str) -> CliErrorPayload {
+    pub(crate) fn to_payload(&self, log_path: &Path, command: &str) -> CliErrorPayload {
         let error = self.to_string();
         let mut payload = CliErrorPayload {
             ok: false,
@@ -107,6 +108,10 @@ impl CliError {
             payload.action = String::from(
                 "move the Team Agent launcher flag before `--`; only provider flags belong after `--`",
             );
+        } else if error.contains("managed launcher refuses a different ambient tmux server") {
+            payload.action = String::from(
+                "leave the current tmux client and retry, or pass `--allow-nested-attach` before `--` to opt in to a nested managed attach",
+            );
         }
         payload
     }
@@ -160,6 +165,8 @@ pub struct CmdResult {
     pub exit: ExitCode,
     /// `--json` 旗标(决定 `emit` 与 inbox 摘要落 stderr vs stdout,`parser.py:505-506`)。
     pub as_json: bool,
+    /// Preserve nested object insertion order for byte-faithful stored envelopes.
+    pub preserve_json_order: bool,
 }
 
 impl CmdResult {
@@ -174,6 +181,20 @@ impl CmdResult {
             output: CmdOutput::Json(value),
             exit,
             as_json,
+            preserve_json_order: false,
+        }
+    }
+    pub fn from_ordered_json(value: Value) -> Self {
+        let exit = if value.get("ok").and_then(Value::as_bool) == Some(false) {
+            ExitCode::Error
+        } else {
+            ExitCode::Ok
+        };
+        Self {
+            output: CmdOutput::Json(value),
+            exit,
+            as_json: true,
+            preserve_json_order: true,
         }
     }
     pub fn human(text: impl Into<String>) -> Self {
@@ -181,6 +202,7 @@ impl CmdResult {
             output: CmdOutput::Human(text.into()),
             exit: ExitCode::Ok,
             as_json: false,
+            preserve_json_order: false,
         }
     }
     pub fn none() -> Self {
@@ -188,6 +210,7 @@ impl CmdResult {
             output: CmdOutput::None,
             exit: ExitCode::Ok,
             as_json: false,
+            preserve_json_order: false,
         }
     }
 }
@@ -210,6 +233,8 @@ pub struct LeaderLauncherArgs {
     pub attach_session: Option<String>,
     /// 0.3.16 topology opt-out: keep the old external/current-pane leader launcher path.
     pub external_leader: bool,
+    /// N41 explicit opt-in for attaching a managed leader from another tmux server.
+    pub allow_nested_attach: bool,
 }
 
 // =============================================================================
@@ -643,6 +668,15 @@ pub struct CollectArgs {
     pub team: Option<String>,
 }
 
+/// Read-only lookup of all stored result envelopes for one case.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResultsArgs {
+    pub case_id: String,
+    pub workspace: PathBuf,
+    pub team: Option<String>,
+    pub json: bool,
+}
+
 /// `diagnose`(`parser.py:298`) runtime health report, distinct from `doctor`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DiagnoseArgs {

package/crates/team-agent/src/communication_mode/mod.rs

@@ -0,0 +1,54 @@
+//!
+//! Official communication modes shared by configuration and projection consumers.
+
+/// The complete product-supported communication-mode catalog.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CommunicationMode {
+    LeaderCentric,
+    Orchestrated,
+}
+
+const LEADER_CENTRIC_RUNTIME_CONTRACT: &str = r#"# Team Agent communication contract: leader_centric
+
+- Progress, blockers, questions: team_orchestrator.send_message(to='leader', content='...')
+
+When you receive a message from the leader or a teammate, you MUST respond
+through MCP tools. Writing a reply in your terminal does nothing — the sender
+will never see it."#;
+
+const ORCHESTRATED_RUNTIME_CONTRACT: &str = r#"# Team Agent communication contract: orchestrated
+
+- Send progress only through the declared channel for the assigned task.
+- Respond to task-related messages through Team Agent MCP tools.
+- A pure ACK, unrelated status, or non-task message does not require a response."#;
+
+impl CommunicationMode {
+    pub const ALL: &[Self] = &[Self::LeaderCentric, Self::Orchestrated];
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::LeaderCentric => "leader_centric",
+            Self::Orchestrated => "orchestrated",
+        }
+    }
+
+    pub fn parse(value: &str) -> Option<Self> {
+        Self::ALL
+            .iter()
+            .copied()
+            .find(|mode| mode.as_str() == value)
+    }
+
+    pub const fn runtime_contract(self) -> &'static str {
+        match self {
+            Self::LeaderCentric => LEADER_CENTRIC_RUNTIME_CONTRACT,
+            Self::Orchestrated => ORCHESTRATED_RUNTIME_CONTRACT,
+        }
+    }
+}
+
+impl Default for CommunicationMode {
+    fn default() -> Self {
+        Self::LeaderCentric
+    }
+}