@team-agent/installer 0.5.48 → 0.5.50

package/Cargo.lock

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

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

@@ -721,7 +721,7 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
         &SendOptions {
             task_id: Some(TaskId::new("task_impl")),
             route_task_id: false,
-            sender: "leader".to_string(),
+            sender: messaging::TrustedSender::leader(),
             requires_ack: true,
             ..SendOptions::default()
         },

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

@@ -315,21 +315,9 @@ fn command_help(command: Option<&str>) -> String {
         Some("start") => compat_hidden_help("start", "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]"),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
         Some("send") => concat!(
-            "usage: team-agent send TARGET MESSAGE... ",
-            "[--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] ",
-            "[--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] ",
-            "[--watch-result] [--requires-ack|--no-ack] [--no-wait] ",
-            "[--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\n",
-            "TARGET is a short id scoped by --team; MCP `to` is a short id scoped ",
-            "by the worker's owner team.\n",
-            "--to-name accepts: --to-name AGENT, --to-name TEAM/AGENT, or ",
-            "--to-name WORKSPACE::TEAM/AGENT.\n",
-            "--team scopes only a bare --to-name AGENT; qualified forms keep the ",
-            "scope in the address.\n",
-            "TEAM/AGENT and WORKSPACE::TEAM/AGENT are not valid positional TARGET ",
-            "or MCP `to` values.\n\n",
-            "MVP: name-based cross-workspace addressing assumes trusted local ",
-            "caller; no auth gate."
+            "usage: team-agent send TO MESSAGE... ",
+            "[--workspace WORKSPACE] [--team TEAM] [--json]\n\n",
+            "TO is a logical recipient; send returns after the message is persisted."
         )
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
@@ -732,7 +720,6 @@ struct ParsedArgs {
     team_id: Option<String>,
     targets: Option<String>,
     task: Option<String>,
-    sender: Option<String>,
     watch_result: bool,
     requires_ack: bool,
     no_ack: bool,
@@ -816,7 +803,6 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--targets" | "--target" | "--to" => parsed.targets = next_arg(args, &mut i),
             "--task" => parsed.task = next_arg(args, &mut i),
             "--task-id" => parsed.task_id = next_arg(args, &mut i),
-            "--sender" => parsed.sender = next_arg(args, &mut i),
             "--agent-id" => parsed.agent_id = next_arg(args, &mut i),
             "--watch-result" => parsed.watch_result = true,
             "--requires-ack" => parsed.requires_ack = true,
@@ -1027,6 +1013,8 @@ fn resolve_cli_path(cwd: &Path, path: &Path) -> PathBuf {
 }
 
 fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
+    validate_send_flags(args)?;
+    warn_send_legacy_delivery_flags(args);
     let parsed = parse_args(args);
     let target = if parsed.targets.is_some()
         || parsed.pane.is_some()
@@ -1050,21 +1038,96 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
         targets: parsed.targets,
         workspace,
         team: parsed.team,
-        task: parsed.task,
-        sender: parsed.sender.unwrap_or_else(|| "leader".to_string()),
-        no_ack: parsed.no_ack && !parsed.requires_ack,
-        no_wait: parsed.no_wait,
-        watch_result: parsed.watch_result,
-        timeout: parsed.timeout.unwrap_or(30.0),
-        confirm_human: parsed.confirm_human,
+        task: None,
+        sender: trusted_cli_sender(),
+        no_ack: false,
+        no_wait: true,
+        watch_result: false,
+        timeout: 0.0,
+        confirm_human: false,
         json: parsed.json,
-        message_id: parsed.message_id,
+        message_id: None,
         pane: parsed.pane.clone(),
         to_name: parsed.to_name.clone(),
         to_leader: parsed.to_leader.clone(),
     })
 }
 
+fn trusted_cli_sender() -> TrustedSender {
+    std::env::var("TEAM_AGENT_ID")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .map(crate::model::ids::AgentId::new)
+        .map(TrustedSender::from_runtime_identity)
+        .unwrap_or_else(TrustedSender::leader)
+}
+
+fn warn_send_legacy_delivery_flags(args: &[String]) {
+    const FLAGS: &[&str] = &[
+        "--task",
+        "--watch-result",
+        "--requires-ack",
+        "--no-ack",
+        "--no-wait",
+        "--timeout",
+        "--confirm-human",
+        "--message-id",
+    ];
+    let spec = command_spec("send");
+    let sunset = spec
+        .and_then(|spec| spec.sunset)
+        .unwrap_or("next compatibility release");
+    let action = spec
+        .and_then(|spec| spec.action)
+        .unwrap_or("use positional logical TO and the returned message id");
+    for flag in FLAGS {
+        if args
+            .iter()
+            .any(|arg| arg == flag || arg.starts_with(&format!("{flag}=")))
+        {
+            eprintln!("warning: {flag} is deprecated; sunset: {sunset}; action: {action}");
+        }
+    }
+}
+
+fn validate_send_flags(args: &[String]) -> Result<(), CliError> {
+    const ALLOWED: &[&str] = &[
+        "--workspace",
+        "--team",
+        "--targets",
+        "--target",
+        "--to",
+        "--to-name",
+        "--to-leader",
+        "--pane",
+        "--task",
+        "--watch-result",
+        "--requires-ack",
+        "--no-ack",
+        "--no-wait",
+        "--timeout",
+        "--confirm-human",
+        "--message-id",
+        "--json",
+        "-h",
+        "--help",
+    ];
+    const ALLOWED_PREFIXES: &[&str] = &["--team=", "--pane=", "--to-name=", "--to-leader="];
+    if let Some(flag) = args.iter().find(|arg| {
+        arg.starts_with('-')
+            && !ALLOWED.contains(&arg.as_str())
+            && !ALLOWED_PREFIXES
+                .iter()
+                .any(|prefix| arg.starts_with(prefix))
+    }) {
+        return Err(CliError::Usage(format!(
+            "unrecognized argument for `send`: {flag}"
+        )));
+    }
+    Ok(())
+}
+
 /// Stage 4 of identity-boundary unified plan (architect direction
 /// 2026-06-24, .team/artifacts/identity-boundary-unified-plan.md §2 Stage
 /// 4): destructive command ambiguity gate. When the workspace has 2+
@@ -1760,19 +1823,7 @@ mod tests {
                 "quick-start",
                 &["--workspace", "--team-id", "--yes", "--json"][..],
             ),
-            (
-                "send",
-                &[
-                    "--workspace",
-                    "--team",
-                    "--targets",
-                    "--to-name",
-                    "--pane",
-                    "--watch-result",
-                    "--timeout",
-                    "--json",
-                ][..],
-            ),
+            ("send", &["--workspace", "--team", "--json"][..]),
             (
                 "status",
                 &["--workspace", "--team", "--summary", "--json", "--detail"][..],

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

@@ -44,7 +44,7 @@ use serde_json::{json, Map, Value};
 use thiserror::Error;
 
 // REUSE in-tree(只 import,不 redefine):
-use crate::messaging::{self, AlertType, MessageTarget, SendOptions};
+use crate::messaging::{self, AlertType, MessageTarget, SendOptions, TrustedSender};
 use crate::model::ids::{TaskId, TeamKey};
 
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";

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

@@ -472,7 +472,10 @@ pub(crate) fn parse_leader_target_workspace_and_team(
     let target_workspace = resolve_workspace(sender_workspace, parsed.workspace.as_deref())?;
     match parsed.target {
         ParsedTarget::TeamEntity { team, entity } if entity == "leader" => {
-            Ok(Some((target_workspace, team)))
+            let state = load_state_checked(&target_workspace)?;
+            let canonical = canonical_named_team_key(&target_workspace, &state, &team)
+                .unwrap_or(team);
+            Ok(Some((target_workspace, canonical)))
         }
         _ => Ok(None),
     }
@@ -607,23 +610,30 @@ fn resolve_in_workspace(
         ParsedTarget::BareAgent(agent) => {
             resolve_bare_agent(sender_workspace, target_workspace, state, agent, transport)
         }
-        ParsedTarget::TeamEntity { team, entity } if entity == "leader" => resolve_leader(
-            sender_workspace,
-            target_workspace,
-            state,
-            team,
-            parsed,
-            transport,
-        ),
-        ParsedTarget::TeamEntity { team, entity } => resolve_worker(
-            sender_workspace,
-            target_workspace,
-            state,
-            team,
-            entity,
-            parsed,
-            transport,
-        ),
+        ParsedTarget::TeamEntity { team, entity } => {
+            let canonical = canonical_named_team_key(target_workspace, state, team)
+                .unwrap_or_else(|| team.clone());
+            if entity == "leader" {
+                resolve_leader(
+                    sender_workspace,
+                    target_workspace,
+                    state,
+                    &canonical,
+                    parsed,
+                    transport,
+                )
+            } else {
+                resolve_worker(
+                    sender_workspace,
+                    target_workspace,
+                    state,
+                    &canonical,
+                    entity,
+                    parsed,
+                    transport,
+                )
+            }
+        }
         ParsedTarget::SessionWindow { session, window } => resolve_session_window(
             sender_workspace,
             target_workspace,
@@ -670,12 +680,38 @@ fn resolve_worker(
                 .with_scoped_suggestions_for_agent(team_entry, team, agent, parsed));
         }
     };
-    let session = string_field(team_entry, "session_name")
-        .ok_or_else(|| name_not_resolvable("team is missing session_name"))?;
+    let Some(session) = string_field(team_entry, "session_name") else {
+        return Ok(resolved_worker_without_live(
+            sender_workspace,
+            target_workspace,
+            team,
+            agent,
+            parsed,
+            agent_entry,
+            None,
+            agent,
+            transport.tmux_endpoint(),
+        ));
+    };
     let window = string_field(agent_entry, "window")
         .or_else(|| string_field(agent_entry, "window_name"))
         .unwrap_or(agent);
-    let targets = list_targets(transport)?;
+    let targets = match list_targets(transport) {
+        Ok(targets) => targets,
+        Err(_) => {
+            return Ok(resolved_worker_without_live(
+                sender_workspace,
+                target_workspace,
+                team,
+                agent,
+                parsed,
+                agent_entry,
+                Some(session),
+                window,
+                transport.tmux_endpoint(),
+            ));
+        }
+    };
     let matches = matching_session_window(&targets, session, window);
     match matches.len() {
         1 => {
@@ -710,10 +746,14 @@ fn resolve_worker(
                 warning,
             })
         }
-        0 => Err(name_not_live_worker(
+        0 => Ok(resolved_worker_without_live(
+            sender_workspace,
+            target_workspace,
             team,
             agent,
-            session,
+            parsed,
+            agent_entry,
+            Some(session),
             window,
             transport.tmux_endpoint(),
         )),
@@ -737,6 +777,42 @@ fn resolve_worker(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+fn resolved_worker_without_live(
+    sender_workspace: &Path,
+    target_workspace: &Path,
+    team: &str,
+    agent: &str,
+    parsed: &ParsedNamedAddress,
+    agent_entry: &Value,
+    session: Option<&str>,
+    window: &str,
+    tmux_endpoint: Option<String>,
+) -> ResolvedNamedAddress {
+    let state_pane_id = string_field(agent_entry, "pane_id").map(str::to_string);
+    ResolvedNamedAddress {
+        raw_name: parsed.display_name(),
+        target_kind: NamedTargetKind::Worker,
+        sender_workspace: sender_workspace.to_path_buf(),
+        target_workspace: target_workspace.to_path_buf(),
+        team_key: Some(team.to_string()),
+        agent_id: Some(agent.to_string()),
+        pane_id: state_pane_id.clone().unwrap_or_default(),
+        session_name: session.map(str::to_string),
+        window_name: Some(window.to_string()),
+        tmux_endpoint,
+        transport_kind: Some("direct_tmux".to_string()),
+        app_server: None,
+        state_pane_id,
+        state_pane_stale: true,
+        agent_status: string_field(agent_entry, "status").map(str::to_string),
+        warning: Some(
+            "agent has no live pane; message will be persisted for standard delivery recovery"
+                .to_string(),
+        ),
+    }
+}
+
 fn resolve_bare_agent(
     sender_workspace: &Path,
     target_workspace: &Path,
@@ -1149,8 +1225,10 @@ fn transport_for_cli_target(
     parsed: &ParsedNamedAddress,
 ) -> Box<dyn Transport> {
     if let ParsedTarget::TeamEntity { team, entity } = &parsed.target {
+        let canonical = canonical_named_team_key(target_workspace, state, team)
+            .unwrap_or_else(|| team.clone());
         if entity == "leader" {
-            let team_scoped_socket = team_entry(state, team)
+            let team_scoped_socket = team_entry(state, &canonical)
                 .and_then(|entry| entry.get("leader_receiver"))
                 .and_then(|receiver| string_field(receiver, "tmux_socket"));
             let socket = team_scoped_socket.map(str::to_string).or_else(|| {
@@ -1164,7 +1242,7 @@ fn transport_for_cli_target(
                 return Box::new(crate::tmux_backend::TmuxBackend::for_tmux_endpoint(&socket));
             }
         }
-        if let Some(entry) = team_entry(state, team) {
+        if let Some(entry) = team_entry(state, &canonical) {
             let selected = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
                 target_workspace,
                 Some(entry),
@@ -1247,6 +1325,30 @@ fn team_entry<'a>(state: &'a Value, team: &str) -> Option<&'a Value> {
         .and_then(|teams| teams.get(team))
 }
 
+fn canonical_named_team_key(
+    target_workspace: &Path,
+    state: &Value,
+    requested: &str,
+) -> Option<String> {
+    if team_entry(state, requested).is_some() || is_legacy_single_team_active(state, requested) {
+        return Some(requested.to_string());
+    }
+    let selected = crate::state::projection::select_runtime_state(
+        target_workspace,
+        Some(requested),
+    )
+    .ok()?;
+    let canonical = selected
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|team| !team.is_empty())?;
+    state
+        .get("teams")
+        .and_then(Value::as_object)
+        .is_some_and(|teams| teams.contains_key(canonical))
+        .then(|| canonical.to_string())
+}
+
 /// 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