@team-agent/installer 0.5.49 → 0.5.50

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.49"
+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.49"
+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

@@ -680,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 => {
@@ -720,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(),
         )),
@@ -747,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,