@team-agent/installer 0.5.7 → 0.5.9

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

@@ -18,6 +18,14 @@ pub(crate) enum NamedAddressErrorKind {
     NameInvalid,
     WorkspaceNotFound,
     StateNotFound,
+    // E6 (0.5.9 offline-mailbox-toname-design §3.1): three-way taxonomy for
+    // `--to-name <team>/leader` refusal — required by the E6 RED so the top-level
+    // `leader_receiver` fallback is no longer reached for a wrong runtime key.
+    // `WorkspaceNoState` mirrors `StateNotFound` semantics but keeps the wire
+    // reason distinct for third-party sender copy.
+    WorkspaceNoState,
+    TeamKeyNotFound,
+    LeaderNotAttached,
     NameNotResolvable,
     NameNotLive,
     NameAmbiguous,
@@ -29,6 +37,9 @@ impl NamedAddressErrorKind {
             Self::NameInvalid => "name_invalid",
             Self::WorkspaceNotFound => "workspace_not_found",
             Self::StateNotFound => "state_not_found",
+            Self::WorkspaceNoState => "workspace_no_state",
+            Self::TeamKeyNotFound => "team_key_not_found",
+            Self::LeaderNotAttached => "leader_not_attached",
             Self::NameNotResolvable => "name_not_resolvable",
             Self::NameNotLive => "name_not_live",
             Self::NameAmbiguous => "name_ambiguous",
@@ -43,6 +54,13 @@ pub(crate) struct NamedAddressError {
     pub action: String,
     pub log: String,
     pub candidates: Vec<Value>,
+    // 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
+    // refusal kinds.
+    pub requested_team: Option<String>,
+    pub available_team_keys: Vec<String>,
+    pub suggested_name: Option<String>,
 }
 
 impl NamedAddressError {
@@ -53,6 +71,9 @@ 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(),
+            requested_team: None,
+            available_team_keys: Vec::new(),
+            suggested_name: None,
         }
     }
 
@@ -66,15 +87,35 @@ impl NamedAddressError {
     }
 
     pub(crate) fn to_json(&self) -> Value {
-        json!({
-            "ok": false,
-            "status": "refused",
-            "reason": self.kind.as_str(),
-            "error": self.message,
-            "action": self.action,
-            "log": self.log,
-            "candidates": self.candidates,
-        })
+        let mut obj = serde_json::Map::new();
+        obj.insert("ok".to_string(), Value::Bool(false));
+        obj.insert("status".to_string(), Value::String("refused".to_string()));
+        obj.insert(
+            "reason".to_string(),
+            Value::String(self.kind.as_str().to_string()),
+        );
+        obj.insert("error".to_string(), Value::String(self.message.clone()));
+        obj.insert("action".to_string(), Value::String(self.action.clone()));
+        obj.insert("log".to_string(), Value::String(self.log.clone()));
+        obj.insert("candidates".to_string(), Value::Array(self.candidates.clone()));
+        if let Some(requested) = self.requested_team.as_deref() {
+            obj.insert("requested_team".to_string(), Value::String(requested.to_string()));
+        }
+        if !self.available_team_keys.is_empty() {
+            obj.insert(
+                "available_team_keys".to_string(),
+                Value::Array(
+                    self.available_team_keys
+                        .iter()
+                        .map(|k| Value::String(k.clone()))
+                        .collect(),
+                ),
+            );
+        }
+        if let Some(suggested) = self.suggested_name.as_deref() {
+            obj.insert("suggested_name".to_string(), Value::String(suggested.to_string()));
+        }
+        Value::Object(obj)
     }
 }
 
@@ -531,6 +572,61 @@ fn resolve_bare_agent(
     }
 }
 
+/// Phase-DX E3 (plan §4 / CR supplements A/B/C, P0 red lines #1 & #6):
+/// build advisory diagnostic candidates for a failed `--to-name leader`
+/// resolution. The candidate list is deliberately shaped to be **read by
+/// humans**, not consumed as route authority: every entry carries
+/// `advisory: true` and a `source` tag identifying where it was observed.
+///
+/// Candidate source rules:
+/// - The transport passed in is already scoped by [`transport_for_cli_target`]
+///   to the team's recorded `leader_receiver.tmux_socket` (or the workspace
+///   default when no socket was recorded), so `transport.list_targets()`
+///   enumerates only that endpoint. We do NOT scan other tmux sockets or
+///   fall back to reverse-authority tmux-session discovery.
+/// - `pane_id` fields are copied verbatim from `list_targets`. `session` is
+///   the tmux session, and `socket` records the tmux endpoint the candidate
+///   was seen on (whichever the scoped transport reports).
+///
+/// Callers must never treat any candidate as authoritative; MUST-NOT-12 stays
+/// intact — resolver refusal is still the outcome even when candidates fire.
+fn leader_advisory_candidates(
+    state: &Value,
+    team: &str,
+    transport: &dyn Transport,
+    source: &str,
+) -> Vec<Value> {
+    let team_scoped_socket = team_entry(state, team)
+        .and_then(|entry| entry.get("leader_receiver"))
+        .and_then(|receiver| string_field(receiver, "tmux_socket"));
+    let socket = match team_scoped_socket {
+        Some(s) => Some(s.to_string()),
+        None => state
+            // ALLOWED-LEGACY-SINGLE-TEAM: diagnostic-only socket label for the advisory candidates; never fed back into routing.
+            .get("leader_receiver")
+            .and_then(|receiver| string_field(receiver, "tmux_socket"))
+            .map(str::to_string)
+            .or_else(|| transport.tmux_endpoint()),
+    };
+    let targets = match transport.list_targets() {
+        Ok(targets) => targets,
+        Err(_) => return Vec::new(),
+    };
+    targets
+        .into_iter()
+        .map(|pane| {
+            json!({
+                "pane_id": pane.pane_id.as_str(),
+                "session": pane.session.as_str(),
+                "window": pane.window_name.as_ref().map(|w| w.as_str()),
+                "socket": socket,
+                "source": source,
+                "advisory": json!(true),
+            })
+        })
+        .collect()
+}
+
 fn resolve_leader(
     sender_workspace: &Path,
     target_workspace: &Path,
@@ -539,12 +635,27 @@ fn resolve_leader(
     parsed: &ParsedNamedAddress,
     transport: &dyn Transport,
 ) -> Result<ResolvedNamedAddress, NamedAddressError> {
-    let receiver = if let Some(team_entry) = team_entry(state, team) {
-        team_entry.get("leader_receiver")
-    } else {
-        state.get("leader_receiver")
-    }
-    .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
+    // E6 taxonomy split (0.5.9 offline-mailbox-toname-design §3.1): before
+    // reading any leader_receiver, decide whether `<team>` is actually the
+    // runtime team key. Wrong keys must not fall through to top-level
+    // leader_receiver (that was the pre-fix bug where `twitter-autopub/leader`
+    // silently reused the `current` team's receiver and reported a stale
+    // pane_id). Legacy single-team compat is preserved only when the state
+    // has no `teams` map yet and the requested key equals `active_team_key`.
+    let receiver = resolve_team_scoped_leader_receiver(state, team, target_workspace)?
+        .ok_or_else(|| {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                None,
+                None,
+                None,
+                transport.tmux_endpoint(),
+            );
+            err.candidates =
+                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+            err
+        })?;
     if let Some((mode, transport_kind)) = receiver_transport_conflict(receiver) {
         let mut err = NamedAddressError::new(
             NamedAddressErrorKind::NameNotLive,
@@ -569,7 +680,19 @@ fn resolve_leader(
     }
     let pane_id = string_field(receiver, "pane_id")
         .filter(|pane| !pane.is_empty())
-        .ok_or_else(|| name_not_live_leader(team, None, None, None, transport.tmux_endpoint()))?;
+        .ok_or_else(|| {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                None,
+                None,
+                None,
+                transport.tmux_endpoint(),
+            );
+            err.candidates =
+                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+            err
+        })?;
     let session = string_field(receiver, "session_name");
     let window = string_field(receiver, "window_name");
     let socket = string_field(receiver, "tmux_socket")
@@ -599,13 +722,19 @@ fn resolve_leader(
             agent_status: None,
             warning: None,
         }),
-        0 => Err(name_not_live_leader(
-            team,
-            Some(pane_id),
-            session,
-            window,
-            socket,
-        )),
+        0 => {
+            let mut err = leader_not_attached_third_party(
+                target_workspace,
+                team,
+                Some(pane_id),
+                session,
+                window,
+                socket,
+            );
+            err.candidates =
+                leader_advisory_candidates(state, team, transport, "state_recorded_socket");
+            Err(err)
+        }
         _ => Err(name_ambiguous(
             "multiple live panes matched leader_receiver pane id",
             matches
@@ -775,12 +904,18 @@ fn transport_for_cli_target(
 ) -> Box<dyn Transport> {
     if let ParsedTarget::TeamEntity { team, entity } = &parsed.target {
         if entity == "leader" {
-            if let Some(socket) = team_entry(state, team)
+            let team_scoped_socket = team_entry(state, team)
                 .and_then(|entry| entry.get("leader_receiver"))
-                .or_else(|| state.get("leader_receiver"))
-                .and_then(|receiver| string_field(receiver, "tmux_socket"))
-            {
-                return Box::new(crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket));
+                .and_then(|receiver| string_field(receiver, "tmux_socket"));
+            let socket = team_scoped_socket.map(str::to_string).or_else(|| {
+                state
+                    // ALLOWED-LEGACY-SINGLE-TEAM: pre-teams-map compat probe endpoint; canonical taxonomy in `resolve_team_scoped_leader_receiver` still gates identity.
+                    .get("leader_receiver")
+                    .and_then(|receiver| string_field(receiver, "tmux_socket"))
+                    .map(str::to_string)
+            });
+            if let Some(socket) = socket {
+                return Box::new(crate::tmux_backend::TmuxBackend::for_tmux_endpoint(&socket));
             }
         }
         if let Some(entry) = team_entry(state, team) {
@@ -866,6 +1001,46 @@ fn team_entry<'a>(state: &'a Value, team: &str) -> Option<&'a Value> {
         .and_then(|teams| teams.get(team))
 }
 
+/// E6 (0.5.9 offline-mailbox-toname-design §3.1): decide which
+/// `leader_receiver` object, if any, applies to `<team>/leader` before any
+/// downstream code reads it. Wrong runtime keys are rejected here with
+/// `team_key_not_found` — the pre-fix behavior was to silently reuse the
+/// top-level `leader_receiver` (the `current` team's receiver in the gate
+/// evidence), producing misleading `expected_pane=<missing>` messages.
+///
+/// Legacy single-team compat is preserved only when the state has no
+/// `teams` map at all AND the requested team equals `active_team_key`.
+/// That branch is a documented exception to the E6 fallback grep guard;
+/// the exception is tagged inline with `ALLOWED-LEGACY-SINGLE-TEAM` so
+/// the guard admits it explicitly (see the R2 rework in
+/// `.team/artifacts/059-impl-cr-verdict.md §4`). The exception is
+/// scheduled to be removed when B1 canonical state layout lands
+/// (`.team/artifacts/next-version-staged-plan.md §5 Phase-Foundation-1`),
+/// at which point every runtime state carries a `teams` map and the
+/// legacy branch becomes unreachable dead code.
+fn resolve_team_scoped_leader_receiver<'a>(
+    state: &'a Value,
+    team: &str,
+    target_workspace: &Path,
+) -> Result<Option<&'a Value>, NamedAddressError> {
+    if let Some(entry) = team_entry(state, team) {
+        return Ok(entry.get("leader_receiver"));
+    }
+    if is_legacy_single_team_active(state, team) {
+        // ALLOWED-LEGACY-SINGLE-TEAM: pre-teams-map compat; state has no teams map AND request matches active_team_key.
+        return Ok(state.get("leader_receiver"));
+    }
+    Err(team_key_not_found(target_workspace, state, team))
+}
+
+fn is_legacy_single_team_active(state: &Value, team: &str) -> bool {
+    state.get("teams").is_none()
+        && state
+            .get("active_team_key")
+            .and_then(Value::as_str)
+            .is_some_and(|k| k == team)
+}
+
 fn string_field<'a>(value: &'a Value, key: &str) -> Option<&'a str> {
     value
         .get(key)
@@ -944,6 +1119,91 @@ fn name_not_live_worker(
     err
 }
 
+/// E6 (0.5.9 offline-mailbox §3.1): requested `<team>` is not a runtime team_key.
+/// The refusal echoes the requested string plus the canonical alternatives so
+/// the caller can retry with `::<canonical_key>/leader`. The action copy is
+/// deliberately neutral — no `claim-leader` / `takeover` — because a third-party
+/// sender must never be told to seize the target team's leader.
+fn team_key_not_found(target_workspace: &Path, state: &Value, team: &str) -> NamedAddressError {
+    let available = available_team_keys(state);
+    let workspace = target_workspace.display();
+    let mut err = NamedAddressError::new(
+        NamedAddressErrorKind::TeamKeyNotFound,
+        format!(
+            "team key `{team}` is not a runtime key in target workspace `{workspace}` (spec/display name may differ from runtime key)"
+        ),
+    );
+    let suggested_key = available.first().cloned();
+    err.action = match suggested_key.as_deref() {
+        Some(k) => format!(
+            "Retry with the canonical key, e.g. `{workspace}::{k}/leader`; check `team-agent status --workspace {workspace} --json` for team_key"
+        ),
+        None => format!(
+            "No runtime team keys are present; check `team-agent status --workspace {workspace} --json`"
+        ),
+    };
+    err.log = format!(
+        "requested_team={team} available_team_keys={:?} workspace={workspace}",
+        available
+    );
+    err.requested_team = Some(team.to_string());
+    err.suggested_name = suggested_key
+        .as_deref()
+        .map(|k| format!("{workspace}::{k}/leader"));
+    err.available_team_keys = available;
+    err
+}
+
+/// E6 (0.5.9 offline-mailbox §3.1): key hit but the leader receiver is either
+/// absent or not live. `leader_not_attached_third_party` is the neutral variant
+/// used by the resolver: it never suggests `claim-leader` / `takeover` so the
+/// caller (which may be a third-party sender) never sees ownership-seizing copy.
+/// The owner-facing action (attach-leader) belongs to `status_port`
+/// pending_leader_notifications and diagnose.
+fn leader_not_attached_third_party(
+    target_workspace: &Path,
+    team: &str,
+    pane_id: Option<&str>,
+    session: Option<&str>,
+    window: Option<&str>,
+    socket: Option<String>,
+) -> NamedAddressError {
+    let workspace = target_workspace.display();
+    let mut err = NamedAddressError::new(
+        NamedAddressErrorKind::LeaderNotAttached,
+        "target team leader is not attached on its recorded tmux endpoint",
+    );
+    err.action = format!(
+        "Ask the target team owner to run `team-agent attach-leader --workspace {workspace} --team {team}`; the sender-side offline mailbox will requeue the message once attach succeeds"
+    );
+    err.log = format!(
+        "name={team}/leader expected_pane={} expected_session={} expected_window={} tmux_socket={}",
+        pane_id.unwrap_or("<missing>"),
+        session.unwrap_or("<unknown>"),
+        window.unwrap_or("<unknown>"),
+        socket.unwrap_or_else(|| "<unknown>".to_string())
+    );
+    err.requested_team = Some(team.to_string());
+    err
+}
+
+pub(crate) fn available_team_keys(state: &Value) -> Vec<String> {
+    let mut keys: Vec<String> = state
+        .get("teams")
+        .and_then(Value::as_object)
+        .map(|teams| teams.keys().cloned().collect())
+        .unwrap_or_default();
+    if keys.is_empty() {
+        if let Some(active) = state.get("active_team_key").and_then(Value::as_str) {
+            if !active.is_empty() {
+                keys.push(active.to_string());
+            }
+        }
+    }
+    keys.sort();
+    keys
+}
+
 fn name_not_live_leader(
     team: &str,
     pane_id: Option<&str>,

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

@@ -7,6 +7,34 @@ use crate::messaging::{DeliveryOutcome, DeliveryRefusal, DeliveryStage, Delivery
 /// `cmd_send`(`commands.py:164`)。解析 target(`--to` fanout / 单 target / `*`)→ [`MessageTarget`],
 /// 拼 [`SendOptions`](no_ack→requires_ack 取反、no_wait→wait_visible 取反等)→ `messaging::send_message`。
 pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
+    if let Some(ref to_leader) = args.to_leader {
+        // E7 (0.5.9 host-leader-registry-design §4.2): `--to-leader NAME`
+        // resolves NAME through `~/.team-agent/leaders`, canonical-validates
+        // the entry, and delegates to the same E6 leader delivery path
+        // (`send_to_canonical_leader_target`) — so live inject and offline
+        // mailbox (`queued_until_leader_attach` / `leader_mailbox`) both
+        // funnel through one code path. Mutually exclusive with
+        // `--to-name`, TARGET/--to, `--pane`.
+        if args.to_name.is_some()
+            || args.pane.is_some()
+            || args.target.is_some()
+            || args.targets.is_some()
+        {
+            return Err(CliError::Usage(
+                "--to-leader and --to-name/--pane/TARGET/--to are mutually exclusive: \
+                 --to-leader resolves a host leader delivery name via the leader registry"
+                    .to_string(),
+            ));
+        }
+        let content = args.message.join(" ");
+        if content.is_empty() {
+            return Err(CliError::Usage(
+                "--to-leader requires a non-empty message".to_string(),
+            ));
+        }
+        let value = send_to_canonical_leader_target(&args.workspace, to_leader, &content, &args.sender, args.task.as_deref())?;
+        return Ok(cmd_send_result(value, args.json));
+    }
     if let Some(ref to_name) = args.to_name {
         if args.pane.is_some() || args.target.is_some() || args.targets.is_some() {
             return Err(CliError::Usage(
@@ -913,6 +941,208 @@ fn delivery_stage_wire(stage: DeliveryStage) -> &'static str {
     }
 }
 
+/// E7 (0.5.9 host-leader-registry-design §8.3): resolve `NAME` through
+/// `~/.team-agent/leaders`, then delegate to the E6 leader delivery path
+/// so a resolved live target physically injects and a leader-not-attached
+/// target queues via `enqueue_leader_mailbox_until_attach`. Ambiguous
+/// short names refuse with `name_ambiguous` and expose `candidates` —
+/// no priority heuristic ever picks a winner (host-leader-registry-design §5.2).
+///
+/// Return shape reserves the following markers for downstream consumers:
+/// - `resolved_via = "host_leader_registry"` when a registry entry
+///   selected the canonical target (E7 test 2).
+/// - `reason = "leader_name_not_found"` for missing entries; `reason =
+///   "registry_stale"` when canonical validation refuses; `reason =
+///   "name_ambiguous"` for collisions with a candidate list including
+///   `workspace_hash` and `stable_qualified_name`.
+///
+/// The first slice ships the marker/return-shape surface so E6 wiring is
+/// available at the CLI; the full canonical-validate loop follows in a
+/// later commit alongside the registry read implementation.
+pub fn send_to_canonical_leader_target(
+    sender_workspace: &std::path::Path,
+    name: &str,
+    content: &str,
+    sender: &str,
+    task_id: Option<&str>,
+) -> Result<serde_json::Value, CliError> {
+    // Resolve NAME through the registry. Ambiguity is decided *before*
+    // canonical validation so an ambiguous short name never picks a
+    // winner — even when only one candidate happens to be live. Send
+    // uses the no-GC listing so stale entries can still refuse with
+    // `registry_stale` — the leaders CLI is the one that prunes.
+    let classified = crate::leader::registry::list_validated_no_gc();
+    let mut candidates_all: Vec<crate::leader::registry::LeaderRegistryEntry> = Vec::new();
+    for (entry, _status, _reason) in &classified {
+        let matches = entry.delivery_name == name
+            || entry.qualified_name == name
+            || entry.stable_qualified_name == name
+            || entry.aliases.iter().any(|a| a == name);
+        if matches {
+            candidates_all.push(entry.clone());
+        }
+    }
+    if candidates_all.is_empty() {
+        return Ok(serde_json::json!({
+            "ok": false,
+            "status": "refused",
+            "reason": "leader_name_not_found",
+            "requested_name": name,
+            "resolved_via": "host_leader_registry",
+            "candidates": Vec::<serde_json::Value>::new(),
+            "workspace_hash": null,
+            "stable_qualified_name": null,
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "message_status": "queued_until_leader_attach",
+            "action": "run `team-agent leaders` to see registered leaders; retry with a qualified name",
+            "registry_stale": false,
+        }));
+    }
+    if candidates_all.len() > 1 {
+        let cand_json: Vec<serde_json::Value> = candidates_all
+            .iter()
+            .map(|e| {
+                serde_json::json!({
+                    "name": e.qualified_name,
+                    "workspace": e.workspace.display().to_string(),
+                    "team_key": e.team_key,
+                    "workspace_hash": e.workspace_hash,
+                    "stable_qualified_name": e.stable_qualified_name,
+                })
+            })
+            .collect();
+        return Ok(serde_json::json!({
+            "ok": false,
+            "status": "refused",
+            "reason": "name_ambiguous",
+            "requested_name": name,
+            "resolved_via": "host_leader_registry",
+            "candidates": cand_json,
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "action": "run `team-agent leaders` and retry with the qualified name",
+        }));
+    }
+    let entry = candidates_all.into_iter().next().ok_or_else(|| {
+        CliError::Runtime("internal: candidate list must have at least one entry".to_string())
+    })?;
+    // Canonical-validate the entry against target workspace state. Send
+    // through the same E6 --to-name path so live inject and mailbox both
+    // funnel through one code path.
+    let (status, reason) = crate::leader::registry::classify(&entry);
+    if status == "STALE" {
+        // Check whether the underlying team is still alive — if so we
+        // may still queue via the E6 mailbox path (leader-not-attached
+        // shape). If the workspace/team is gone we refuse `registry_stale`.
+        let state = crate::state::persist::load_runtime_state(&entry.workspace).ok();
+        let team_alive = state
+            .as_ref()
+            .and_then(|s| s.get("teams"))
+            .and_then(|v| v.as_object())
+            .and_then(|teams| teams.get(&entry.team_key))
+            .and_then(|t| t.get("status"))
+            .and_then(serde_json::Value::as_str)
+            .map(|s| s == "alive" || s.is_empty())
+            .unwrap_or(false);
+        if !team_alive {
+            return Ok(serde_json::json!({
+                "ok": false,
+                "status": "refused",
+                "reason": "registry_stale",
+                "requested_name": name,
+                "resolved_via": "host_leader_registry",
+                "stale_reason": reason,
+                "workspace_hash": entry.workspace_hash,
+                "stable_qualified_name": entry.stable_qualified_name,
+                "channel": "leader_mailbox",
+                "delivered": false,
+                "action": "target team is not alive; run `team-agent leaders` for current state",
+            }));
+        }
+        // Team alive but leader unattached → E6 mailbox.
+        let event_log = crate::event_log::EventLog::new(&entry.workspace);
+        let task = task_id.map(|s| crate::model::ids::TaskId::new(s.to_string()));
+        let outcome = crate::messaging::enqueue_leader_mailbox_until_attach(
+            &entry.workspace,
+            &entry.team_key,
+            content,
+            task.as_ref(),
+            sender,
+            &event_log,
+        )
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+        return Ok(serde_json::json!({
+            "ok": true,
+            "status": "queued_until_leader_attach",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "resolved_via": "host_leader_registry",
+            "requested_name": name,
+            "to_leader": entry.qualified_name,
+            "target_workspace": entry.workspace.display().to_string(),
+            "workspace_hash": entry.workspace_hash,
+            "stable_qualified_name": entry.stable_qualified_name,
+            "team_key": entry.team_key,
+            "message_id": outcome.message_id,
+        }));
+    }
+    // LIVE: canonical-validated. Delegate to the E6 --to-name path via a
+    // synthesized `<workspace>::<team_key>/leader` name so live inject +
+    // mailbox both go through one code path.
+    let to_name = format!(
+        "{}::{}/leader",
+        entry.workspace.display(),
+        entry.team_key
+    );
+    let (resolved, transport) =
+        match crate::cli::named_address::resolve_name_for_cli(sender_workspace, &to_name) {
+            Ok(r) => r,
+            Err(err) => {
+                // Named-address refusal — surface it verbatim but tag as
+                // registry-resolved so callers can trace the origin.
+                let mut body = err.to_json();
+                if let Some(obj) = body.as_object_mut() {
+                    obj.insert(
+                        "resolved_via".to_string(),
+                        serde_json::Value::String("host_leader_registry".to_string()),
+                    );
+                    obj.insert(
+                        "delivered".to_string(),
+                        serde_json::Value::Bool(false),
+                    );
+                }
+                return Ok(body);
+            }
+        };
+    let mut value = send_to_named_pane_direct(
+        sender_workspace,
+        transport.as_ref(),
+        &resolved,
+        content,
+        sender,
+        task_id,
+        true,
+    )?;
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert(
+            "resolved_via".to_string(),
+            serde_json::Value::String("host_leader_registry".to_string()),
+        );
+        obj.insert(
+            "to_leader".to_string(),
+            serde_json::Value::String(entry.qualified_name.clone()),
+        );
+        // Honest delivered marker. `send_to_named_pane_direct` sets `ok`
+        // to whether physical inject verified — mirror that as
+        // `delivered`.
+        let ok = obj.get("ok").and_then(serde_json::Value::as_bool).unwrap_or(false);
+        obj.insert("delivered".to_string(), serde_json::Value::Bool(ok));
+    }
+    Ok(value)
+}
+
 #[cfg(test)]
 mod e23_tests {
     use super::*;