@team-agent/installer 0.5.60 → 0.5.62

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

@@ -1,3 +1,4 @@
+//!
 //! E7 (0.5.9 host-leader-registry-design §4.1): `team-agent leaders` command.
 //!
 //! Enumerates entries under `~/.team-agent/leaders`, re-validates each
@@ -13,6 +14,7 @@
 use super::{types::LeadersArgs, CliError, CmdResult};
 use serde_json::{json, Value};
 
+///
 /// E7 CLI entry point (E7 test 2 marker: `cmd_leaders`).
 ///
 /// Reads registry entries, canonical-validates each, and groups by

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

@@ -1,3 +1,4 @@
+//!
 //! step 14b · cli — `team-agent <subcommand>` clap 命令面(真相源 `cli/`)。
 //!
 //! Card: `docs/phase0/subsystems/14-mcp_cli.md`(CLI 半边)。
@@ -78,6 +79,7 @@ pub use send::*;
 pub use status::*;
 pub use types::*;
 
+///
 /// Public `attach-leader` CLI handler. It consumes the typed pane/provider args and
 /// writes/returns a `leader_receiver` binding via the leader lease port.
 pub fn cmd_attach_leader(args: &AttachLeaderArgs) -> Result<CmdResult, CliError> {
@@ -117,6 +119,7 @@ pub mod lifecycle_port {
     use super::*;
     use crate::model::enums::Provider;
 
+    ///
     /// `runtime.quick_start`(`cmd_quick_start` 委派)。返回 `{ok, summary, ...}` 稳定形状。
     pub fn quick_start(
         workspace: &Path,
@@ -140,6 +143,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.start_leader`(`codex`/`claude` passthrough + `cmd_codex`/`cmd_claude`)。
     pub fn start_leader(
         provider: Provider,
@@ -151,7 +155,7 @@ pub mod lifecycle_port {
             .attach_session
             .as_ref()
             .map(|name| crate::transport::SessionName::new(name.clone()));
-        let plan = crate::leader::start::leader_start_plan(
+        let prepared = match crate::leader::start::prepare_leader_start_with_nested_attach(
             provider,
             provider_args,
             cwd,
@@ -159,16 +163,29 @@ pub mod lifecycle_port {
             attach.confirm_attach,
             attach_session.as_ref(),
             attach.external_leader,
-        )
-        .map_err(|e| CliError::Runtime(e.to_string()))?;
-        let outcome = crate::leader::start::execute_leader_plan(&plan, cwd)
+            attach.allow_nested_attach,
+        ) {
+            Ok(prepared) => prepared,
+            Err(crate::leader::start::PrepareLeaderStartError::PaneAuthorityRefused(refusal)) => {
+                return Ok(pane_authority_refusal_value(provider, attach, &refusal));
+            }
+            Err(crate::leader::start::PrepareLeaderStartError::Leader(error)) => {
+                return Err(CliError::Runtime(error.to_string()));
+            }
+        };
+        let outcome = crate::leader::start::execute_prepared_leader_start(&prepared, cwd)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let plan = prepared.plan();
         let ok = match outcome.status {
             crate::leader::LeaderLaunchStatus::Exited => outcome.exit_code == Some(0),
             crate::leader::LeaderLaunchStatus::Detached => true,
             crate::leader::LeaderLaunchStatus::NotStarted => false,
         };
-        let leader_attach_command = leader_attach_command_for_plan(cwd, &plan);
+        let leader_attach_command = if outcome.reason.as_deref() == Some("PaneWorkspaceMismatch") {
+            Some("team-agent attach-leader".to_string())
+        } else {
+            leader_attach_command_for_plan(cwd, &plan)
+        };
         Ok(json!({
             "ok": ok,
             "provider": provider,
@@ -187,6 +204,251 @@ pub mod lifecycle_port {
         }))
     }
 
+    fn pane_authority_refusal_value(
+        provider: Provider,
+        attach: &LeaderLauncherArgs,
+        refusal: &crate::model::pane_authority_refusal::PaneAuthorityRefusal,
+    ) -> Value {
+        use crate::model::pane_authority_refusal::{
+            PaneAuthorityRecoveryAction, PaneAuthorityRecoveryHint, PaneAuthorityRefusalFacts,
+            PaneAuthorityRefusalField, ACTION_FIELD, ACTION_REQUIRED_FIELD, HINT_ACTION_FIELD,
+            REASON_FIELD,
+        };
+
+        let mut facts = Map::new();
+        facts.insert(
+            REASON_FIELD.to_string(),
+            Value::String(refusal.reason().as_str().to_string()),
+        );
+        match &refusal.facts {
+            PaneAuthorityRefusalFacts::AmbientTmuxEndpointUnavailable(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_unavailable_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    payload.endpoint.availability().as_str(),
+                    payload.endpoint.cause.as_str(),
+                );
+            }
+            PaneAuthorityRefusalFacts::AmbientPaneIdUnavailable(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_unavailable_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    payload.observed_pane_id.availability().as_str(),
+                    payload.observed_pane_id.cause.as_str(),
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+            }
+            PaneAuthorityRefusalFacts::AmbientPaneWorkspaceUnavailable(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    &payload.observed_pane_id,
+                );
+                insert_unavailable_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneWorkspace,
+                    payload.observed_pane_workspace.availability().as_str(),
+                    payload.observed_pane_workspace.cause.as_str(),
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+            }
+            PaneAuthorityRefusalFacts::CallerControllingTtyUnavailable(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    &payload.observed_pane_id,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+                insert_unavailable_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::CallerControllingTty,
+                    payload.caller_controlling_tty.availability().as_str(),
+                    payload.caller_controlling_tty.cause.as_str(),
+                );
+            }
+            PaneAuthorityRefusalFacts::ObservedPaneTtyUnavailable(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    &payload.observed_pane_id,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+                insert_unavailable_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneTty,
+                    payload.observed_pane_tty.availability().as_str(),
+                    payload.observed_pane_tty.cause.as_str(),
+                );
+            }
+            PaneAuthorityRefusalFacts::PaneTtyMismatch(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    &payload.observed_pane_id,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+                facts.insert(
+                    PaneAuthorityRefusalField::CallerControllingTty
+                        .as_str()
+                        .to_string(),
+                    Value::from(payload.caller_controlling_tty),
+                );
+                facts.insert(
+                    PaneAuthorityRefusalField::ObservedPaneTty
+                        .as_str()
+                        .to_string(),
+                    Value::from(payload.observed_pane_tty),
+                );
+            }
+            PaneAuthorityRefusalFacts::PaneWorkspaceMismatch(payload) => {
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::RequestedWorkspace,
+                    &payload.requested_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneId,
+                    &payload.observed_pane_id,
+                );
+                insert_path_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::ObservedPaneWorkspace,
+                    &payload.observed_pane_workspace,
+                );
+                insert_string_fact(
+                    &mut facts,
+                    PaneAuthorityRefusalField::Endpoint,
+                    &payload.endpoint,
+                );
+            }
+        }
+
+        let hint_action = match refusal.recovery.hint_action {
+            PaneAuthorityRecoveryHint::AttachLeader => "team-agent attach-leader",
+        };
+        let action = match refusal.recovery.action {
+            PaneAuthorityRecoveryAction::OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane => {
+                "open a new terminal window outside the current tmux/pane, confirm TMUX and \
+                 TMUX_PANE are absent, change directory to the requested workspace, and restart \
+                 the leader; alternatively enter the matching workspace pane and run \
+                 `team-agent attach-leader`"
+            }
+        };
+        facts.insert(
+            ACTION_REQUIRED_FIELD.to_string(),
+            Value::Bool(refusal.recovery.action_required),
+        );
+        facts.insert(
+            HINT_ACTION_FIELD.to_string(),
+            Value::String(hint_action.to_string()),
+        );
+        facts.insert(ACTION_FIELD.to_string(), Value::String(action.to_string()));
+
+        let mut value = json!({
+            "ok": false,
+            "provider": provider,
+            "mode": "exec_provider",
+            "leader_topology": if attach.external_leader { "external" } else { "managed" },
+            "is_external_leader": attach.external_leader,
+            "leader_window": null,
+            "leader_attach_command": hint_action,
+            "status": "not_started",
+            "exit_code": null,
+            "attach_existing": attach.attach_existing,
+            "confirm_attach": attach.confirm_attach,
+            "attach_session": attach.attach_session,
+            "session_name": null,
+        });
+        if let Some(object) = value.as_object_mut() {
+            object.extend(facts);
+        }
+        value
+    }
+
+    fn insert_path_fact(
+        facts: &mut Map<String, Value>,
+        field: crate::model::pane_authority_refusal::PaneAuthorityRefusalField,
+        value: &Path,
+    ) {
+        insert_string_fact(facts, field, &value.to_string_lossy());
+    }
+
+    fn insert_string_fact(
+        facts: &mut Map<String, Value>,
+        field: crate::model::pane_authority_refusal::PaneAuthorityRefusalField,
+        value: &str,
+    ) {
+        facts.insert(field.as_str().to_string(), Value::String(value.to_string()));
+    }
+
+    fn insert_unavailable_fact(
+        facts: &mut Map<String, Value>,
+        field: crate::model::pane_authority_refusal::PaneAuthorityRefusalField,
+        availability: &str,
+        cause: &str,
+    ) {
+        use crate::model::pane_authority_refusal::{AVAILABILITY_FIELD, CAUSE_FIELD};
+
+        let mut value = Map::new();
+        value.insert(
+            AVAILABILITY_FIELD.to_string(),
+            Value::String(availability.to_string()),
+        );
+        value.insert(CAUSE_FIELD.to_string(), Value::String(cause.to_string()));
+        facts.insert(field.as_str().to_string(), Value::Object(value));
+    }
+
     pub(crate) fn leader_attach_command_for_plan(
         cwd: &Path,
         plan: &crate::leader::LeaderStartPlan,
@@ -198,6 +460,7 @@ pub mod lifecycle_port {
         let window = plan.leader_window.as_ref()?;
         crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
     }
+    ///
     /// `runtime.shutdown`(`cmd_shutdown`)。
     ///
     /// 0.5.x Phase 1d Batch 5: the workspace-transport branch now routes
@@ -289,6 +552,7 @@ pub mod lifecycle_port {
         },
     }
 
+    ///
     /// E12 纯决策(单测下沉):spare = `anchor_sessions` ∪ `team-agent-leader-*` 前缀(并集,锚优先)。
     /// 全部 session 都不 spare 且非空 → `KillServerExclusive`(独享 socket 兜底);否则逐 session
     /// kill 非 spare 的(共享 socket / leader 在 → 绝不整 server 拆)。空 session 集 → 逐 kill(no-op)。
@@ -1761,6 +2025,7 @@ pub mod lifecycle_port {
         }
     }
 
+    ///
     /// E4 真机 grounded(任何 team 的 shutdown 都不杀任何 team 的 leader 锚 pane):
     /// 扫 state.json 收集所有 leader-anchor pane_id(top-level team_owner /
     /// leader_receiver + teams[<key>].* 嵌套形态)。返非空 BTreeSet 给
@@ -1972,6 +2237,7 @@ pub mod lifecycle_port {
         protected
     }
 
+    ///
     /// B5/F2 + E4 真机 grounded(任何 team 的 shutdown 都不杀任何 team 的 leader 锚 pane):
     /// the leader terminal's pane process tree joins the protected set (same set, same
     /// mechanism as the invoker ancestry) so the workspace residual sweep's cmdline/cwd
@@ -2337,6 +2603,7 @@ pub mod lifecycle_port {
         let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
         path == root || path.starts_with(root)
     }
+    ///
     /// `runtime.restart`(`cmd_restart`)。
     pub fn restart(
         workspace: &Path,
@@ -2354,6 +2621,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.start_agent`(`cmd_start_agent`)。
     pub fn start_agent(
         workspace: &Path,
@@ -2378,6 +2646,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.stop_agent`(`cmd_stop_agent`)。
     pub fn stop_agent(
         workspace: &Path,
@@ -2390,6 +2659,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.reset_agent`(`cmd_reset_agent`;`--discard-session` 必需)。
     pub fn reset_agent(
         workspace: &Path,
@@ -2440,6 +2710,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.add_agent`(`cmd_add_agent`;`--role-file` 必需)。
     pub fn add_agent(
         workspace: &Path,
@@ -2466,6 +2737,7 @@ pub mod lifecycle_port {
             Err(e) => Ok(error_value(e)),
         }
     }
+    ///
     /// `runtime.fork_agent`(`cmd_fork_agent`;`--as` 必需)。
     pub fn fork_agent(
         workspace: &Path,
@@ -2513,6 +2785,7 @@ pub mod lifecycle_port {
             Err(error) => Ok(error_value(error)),
         }
     }
+    ///
     /// `runtime.remove_agent`(`cmd_remove_agent`;`--from-spec` 须配 `--confirm`)。
     pub fn remove_agent(
         workspace: &Path,
@@ -2684,6 +2957,7 @@ pub mod lifecycle_port {
             format!("'{}'", raw.replace('\'', "'\\''"))
         }
     }
+    ///
     /// `runtime.acknowledge_idle`(`cmd_acknowledge_idle`)。
     pub fn acknowledge_idle(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
         let mut state = crate::state::persist::load_runtime_state(workspace)
@@ -3809,6 +4083,7 @@ pub mod lifecycle_port {
 pub mod diagnose_port {
     use super::*;
 
+    ///
     /// `runtime.doctor(spec)` + schema 注入(`cmd_doctor` 默认分支)。
     pub fn doctor(workspace: &Path, spec: Option<&Path>) -> Result<Value, CliError> {
         let tmux_path = which_path("tmux");
@@ -4076,8 +4351,10 @@ pub mod diagnose_port {
             }
         }
     }
+    ///
     /// `run_comms_selftest`(`--comms`/`--gate comms`)。**纯 state-read,零 token**(MUST-NOT-13)。
-    pub fn comms_selftest(
+    #[cfg(test)]
+    pub(super) fn comms_selftest(
         workspace: &Path,
         team: Option<&str>,
         gate: Option<&str>,
@@ -4085,14 +4362,19 @@ pub mod diagnose_port {
         crate::diagnose::comms::doctor_comms_json(workspace, team, gate)
     }
 
+    ///
     /// `orphan_gate(fix, confirm)`(`--gate orphans`)。CI gate。
-    pub fn orphan_gate(workspace: &Path, fix: bool, confirm: bool) -> Result<Value, CliError> {
+    #[cfg(test)]
+    pub(super) fn orphan_gate(workspace: &Path, fix: bool, confirm: bool) -> Result<Value, CliError> {
         crate::diagnose::orphans::orphan_gate_json(workspace, fix, confirm)
     }
+    ///
     /// `cleanup_orphan_coordinators(confirm)`(`--cleanup-orphans`;dry-run unless `--confirm`)。
-    pub fn cleanup_orphans(workspace: &Path, confirm: bool) -> Result<Value, CliError> {
+    #[cfg(test)]
+    pub(super) fn cleanup_orphans(workspace: &Path, confirm: bool) -> Result<Value, CliError> {
         crate::diagnose::orphans::cleanup_orphans_json(workspace, confirm)
     }
+    ///
     /// `fix_schema_layout`(`--fix-schema`)/`schema_diagnosis`。
     pub fn fix_schema(workspace: &Path) -> Result<Value, CliError> {
         let db_path = workspace.join(".team").join("runtime").join("team.db");
@@ -4262,6 +4544,7 @@ pub mod diagnose_port {
 pub mod leader_port {
     use super::*;
 
+    ///
     /// `runtime.takeover(workspace, team, confirm)` 的 CLI `--json` 投影。
     pub fn takeover(
         workspace: &Path,
@@ -4317,6 +4600,7 @@ pub mod leader_port {
         }
         Ok(value)
     }
+    ///
     /// `runtime.claim_leader(...)` 的 CLI `--json` 投影(`cmd_claim_leader`;含 inbox_hint)。
     pub fn claim_leader(
         workspace: &Path,
@@ -4366,6 +4650,7 @@ pub mod leader_port {
         Ok(value)
     }
 
+    ///
     /// `runtime.attach_leader(...)` 的 CLI `--json` 投影。
     pub fn attach_leader(
         workspace: &Path,
@@ -4393,6 +4678,7 @@ pub mod leader_port {
         Ok(value)
     }
 
+    ///
     /// `runtime.leader_identity(workspace, team)`(`cmd_identity`)。
     pub fn leader_identity(workspace: &Path, team: Option<&str>) -> Result<Value, CliError> {
         crate::leader::leader_identity(workspace, team)
@@ -4462,6 +4748,7 @@ pub mod leader_port {
         );
     }
 
+    ///
     /// E7 GC hook: called from shutdown/unbind success paths.
     pub(crate) fn unregister_after_shutdown_success(
         workspace: &Path,
@@ -4733,6 +5020,7 @@ pub mod leader_port {
         Ok(json!([]))
     }
 
+    ///
     /// R8 D6 (decoupled for offline byte-lock — c-lite): project the requeued-exhausted event into the
     /// CLI `requeued_exhausted_watchers` return. golden (leader/__init__.py:56): the `watcher_ids`
     /// STRING list. (Current divergent body — the `requeued` Vec<WatcherNotice> objects — kept until

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

@@ -1,3 +1,4 @@
+//!
 //! CLI-local stable name resolver for `team-agent send --to-name`.
 
 use std::path::{Path, PathBuf};
@@ -54,6 +55,10 @@ pub(crate) struct NamedAddressError {
     pub action: String,
     pub log: String,
     pub candidates: Vec<Value>,
+    /// A typed live-channel refusal retained separately from the broader
+    /// address error (for example `PaneWorkspaceMismatch` while the address
+    /// remains a leader-not-attached refusal).
+    pub channel_reason: Option<String>,
     // E6: when the caller supplied a `<team>/leader` name that isn't a runtime
     // team_key, echo the requested value + the canonical alternatives so
     // spec/display-name confusion is visibly diagnosed. Empty for other
@@ -76,6 +81,7 @@ impl NamedAddressError {
             action: "inspect team-agent status and use an explicit workspace/team name".to_string(),
             log: "named-address resolver refused before injection".to_string(),
             candidates: Vec::new(),
+            channel_reason: None,
             requested_team: None,
             available_team_keys: Vec::new(),
             suggested_name: None,
@@ -188,6 +194,7 @@ impl NamedAddressError {
         self.with_scoped_suggestions(requested_display, candidate_values, best)
     }
 
+    ///
     /// 0.5.45 naming-addressing (design §3.3/§3.4): attach an
     /// advisory suggestion payload. `requested` is the original typo
     /// (surfaced verbatim in JSON + N38 Action); `ranked_candidates`
@@ -237,6 +244,12 @@ impl NamedAddressError {
             "candidates".to_string(),
             Value::Array(self.candidates.clone()),
         );
+        if let Some(channel_reason) = self.channel_reason.as_deref() {
+            obj.insert(
+                "channel_reason".to_string(),
+                Value::String(channel_reason.to_string()),
+            );
+        }
         if let Some(requested) = self.requested_team.as_deref() {
             obj.insert(
                 "requested_team".to_string(),
@@ -458,6 +471,7 @@ fn normalize_bare_with_team_scope(
     }
 }
 
+///
 /// E6 wiring helper (`cli::send::maybe_enqueue_offline_leader_mailbox`):
 /// re-parse a `<workspace>::<team>/leader` name and return the resolved
 /// target workspace + canonical team_key so send.rs can enqueue the
@@ -489,10 +503,14 @@ struct ParsedNamedAddress {
 
 impl ParsedNamedAddress {
     fn display_name(&self) -> String {
-        match &self.target {
+        let target = match &self.target {
             ParsedTarget::BareAgent(agent) => agent.clone(),
             ParsedTarget::TeamEntity { team, entity } => format!("{team}/{entity}"),
             ParsedTarget::SessionWindow { session, window } => format!("{session}:{window}"),
+        };
+        match &self.workspace {
+            Some(workspace) => format!("{}::{target}", workspace.display()),
+            None => target,
         }
     }
 }
@@ -987,7 +1005,13 @@ fn resolve_leader(
                 window,
                 socket,
             );
-            err.log = format!("{} channel_unbound={reason:?}", err.log);
+            if matches!(
+                &reason,
+                crate::messaging::LeaderChannelUnbound::PaneWorkspaceMismatch(_)
+            ) {
+                err.channel_reason = Some(reason.reason_code().to_string());
+            }
+            err.log = format!("{} channel_unbound={}", err.log, reason.reason_code());
             err.candidates =
                 leader_advisory_candidates(state, team, transport, "state_recorded_socket");
             Err(err)

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

@@ -1,3 +1,4 @@
+//!
 //! `profile {init,doctor,show}` CLI verb.
 
 use super::*;
@@ -159,7 +160,7 @@ fn validate_auth_mode(auth_mode: &str) -> Result<(), CliError> {
 fn profile_template(name: &str, auth_mode: &str) -> String {
     match auth_mode {
         "compatible_api" | "official_api" => {
-            format!("AUTH_MODE={auth_mode}\nPROFILE_NAME={name}\nAPI_KEY=\nMODEL=\n")
+            format!("AUTH_MODE={auth_mode}\nPROFILE_NAME={name}\nBASE_URL=\nAPI_KEY=\nMODEL=\n")
         }
         _ => format!("AUTH_MODE=subscription\nPROFILE_NAME={name}\n"),
     }

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

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

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

@@ -1,3 +1,4 @@
+//!
 use super::*;
 
 pub(super) fn maybe_enqueue_offline_leader_mailbox(
@@ -64,6 +65,7 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
             "to_name": to_name,
             "target_workspace": target_workspace.display().to_string(),
             "team_key": team_key,
+            "sender": sender,
             "recipient": "leader",
             "leader_attached": false,
             "message_id": message_id,
@@ -78,6 +80,7 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
             "to_name": to_name,
             "target_workspace": target_workspace.display().to_string(),
             "team_key": team_key,
+            "sender": sender,
             "recipient": "leader",
             "leader_attached": false,
             "message_id": message_id,

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

@@ -1,3 +1,4 @@
+//!
 use super::coordinator::{
     append_loud_ensure_fields, dirty_topology_refusal_value, loud_ensure_coordinator,
     target_has_known_worker,

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

@@ -1,3 +1,4 @@
+//!
 use crate::cli::{CliError, CmdOutput, CmdResult, ExitCode};
 use crate::messaging::{
     DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus, MessageTarget, SendOptions,
@@ -169,6 +170,7 @@ pub(super) fn cmd_send_result(value: Value, as_json: bool) -> CmdResult {
             output: CmdOutput::Human(send_human_output(&value)),
             exit,
             as_json: false,
+            preserve_json_order: false,
         }
     }
 }
@@ -312,6 +314,7 @@ pub(super) fn delivery_refusal_wire(reason: DeliveryRefusal) -> &'static str {
         DeliveryRefusal::TmuxTargetMissing => "tmux_target_missing",
         DeliveryRefusal::MessageAlreadyClaimed => "message_already_claimed",
         DeliveryRefusal::LeaderNotAttached => "leader_not_attached",
+        DeliveryRefusal::PaneWorkspaceMismatch => "PaneWorkspaceMismatch",
         DeliveryRefusal::CoordinatorUnavailable => "coordinator_unavailable",
         DeliveryRefusal::NoCallerPane => "no_caller_pane",
         DeliveryRefusal::TeamOwnerMismatch => "team_owner_mismatch",