@team-agent/installer 0.5.49 → 0.5.51

package/Cargo.lock

@@ -575,7 +575,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.49"
+version = "0.5.51"
 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.51"
 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()
         },
@@ -841,8 +841,8 @@ fn provider_command(provider: &str) -> &str {
 }
 
 fn seed_fake_e2e_state(workspace: &Path) -> Result<(), CliError> {
-    crate::state::persist::save_runtime_state(
-        workspace,
+    crate::state::repository::StateRepository::new(workspace).save(
+        crate::state::repository::StateWriteIntent::FakeE2eSeed,
         &json!({
             "leader": {"id": "leader"},
             "session_name": "team-agent-fake-e2e",
@@ -876,7 +876,8 @@ fn fake_shutdown(workspace: &Path) -> Result<Value, CliError> {
             }
         }
     }
-    crate::state::persist::save_runtime_state(workspace, &state)?;
+    crate::state::repository::StateRepository::new(workspace)
+        .save(crate::state::repository::StateWriteIntent::FakeE2eSeed, &state)?;
     Ok(json!({
         "ok": true,
         "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
@@ -1353,6 +1354,7 @@ pub fn cmd_add_agent(args: &AddAgentArgs) -> Result<CmdResult, CliError> {
             &args.role_file,
             !args.no_display,
             args.team.as_deref(),
+            args.force,
         )?,
         args.json,
     ))

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(),
@@ -341,7 +329,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("reset-agent") => "usage: team-agent reset-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--discard-session] [--no-display] [--json]".to_string(),
         Some("start-agent") => "usage: team-agent start-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--force] [--allow-fresh] [--no-display] [--json]".to_string(),
         Some("stop-agent") => "usage: team-agent stop-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
+        Some("add-agent") => "usage: team-agent add-agent AGENT --role-file FILE [--force] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("fork-agent") => "usage: team-agent fork-agent SOURCE_AGENT --as AGENT [--label LABEL] [--workspace WORKSPACE] [--team TEAM] [--no-display] [--json]".to_string(),
         Some("remove-agent") => "usage: team-agent remove-agent AGENT [--workspace WORKSPACE] [--team TEAM] [--from-spec] [--confirm] [--force] [--json]".to_string(),
         // 0.5.26 (§7.6): removed from help; dispatch was never wired.
@@ -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+
@@ -1282,6 +1345,7 @@ fn add_agent_args(args: &[String], cwd: &Path) -> Result<AddAgentArgs, CliError>
         role_file: parsed
             .role_file
             .ok_or_else(|| CliError::Usage("missing --role-file".to_string()))?,
+        force: parsed.force,
         no_display: parsed.no_display,
         json: parsed.json,
     })
@@ -1760,19 +1824,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)";
@@ -884,7 +884,13 @@ pub mod lifecycle_port {
             if session_killed && !verification_degraded {
                 mark_active_team_shutdown(&mut state, team_shutdown_status);
             }
-            crate::state::projection::save_team_scoped_state(&run_workspace, &state)?;
+            crate::state::repository::StateRepository::new(&run_workspace).save(
+                crate::state::repository::StateWriteIntent::ShutdownTeam {
+                    team_key: team,
+                    clean: session_killed && !verification_degraded,
+                },
+                &state,
+            )?;
             promote_live_sibling_after_scoped_shutdown(&run_workspace, &state)?;
         } else {
             let _changed_keys = mark_matching_session_teams_stopped(
@@ -893,7 +899,13 @@ pub mod lifecycle_port {
                 session_killed && !verification_degraded,
                 team_shutdown_status,
             );
-            crate::state::persist::save_runtime_state(&run_workspace, &state)?;
+            crate::state::repository::StateRepository::new(&run_workspace).save(
+                crate::state::repository::StateWriteIntent::ShutdownTeam {
+                    team_key: None,
+                    clean: session_killed && !verification_degraded,
+                },
+                &state,
+            )?;
         }
         let coordinator_status = if coordinator_timeout {
             "timeout"
@@ -2310,14 +2322,16 @@ pub mod lifecycle_port {
         role_file: &str,
         open_display: bool,
         team: Option<&str>,
+        force: bool,
     ) -> Result<Value, CliError> {
         let agent_id = crate::model::ids::AgentId::new(agent);
-        match crate::lifecycle::add_agent(
+        match crate::lifecycle::add_agent_force(
             workspace,
             &agent_id,
             Path::new(role_file),
             open_display,
             team,
+            force,
         ) {
             Ok(report) => Ok(json!({
                 "ok": true,
@@ -2372,7 +2386,7 @@ pub mod lifecycle_port {
                     ));
                 }
             }
-            Err(error) if confirm => return Ok(error_value(error)),
+            Err(error) if confirm && !force => return Ok(error_value(error)),
             Err(_) => {}
         }
         if !confirm {
@@ -2548,7 +2562,13 @@ pub mod lifecycle_port {
             .and_then(|agents| agents.keys().next().cloned())
             .map(Value::String)
             .unwrap_or(Value::Null);
-        crate::state::persist::save_runtime_state(workspace, &state)
+        crate::state::repository::StateRepository::new(workspace)
+            .save(
+                crate::state::repository::StateWriteIntent::IdleAck {
+                    team_key: Some(&team),
+                },
+                &state,
+            )
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         crate::event_log::EventLog::new(workspace)
             .write(
@@ -3553,7 +3573,13 @@ pub mod lifecycle_port {
             return Ok(());
         };
         let promoted = crate::state::projection::project_top_level_view(&raw, next_key);
-        crate::state::persist::save_runtime_state(workspace, &promoted)?;
+        crate::state::repository::StateRepository::new(workspace).save(
+            crate::state::repository::StateWriteIntent::PromoteLiveSiblingAfterShutdown {
+                stopped_team_key: stopped_key,
+                promoted_team_key: next_key,
+            },
+            &promoted,
+        )?;
         Ok(())
     }
 
@@ -3966,14 +3992,6 @@ pub mod diagnose_port {
         format!("{:012x}", now & 0xffffffffffff)
     }
 
-    fn read_runtime_state(workspace: &Path) -> Value {
-        let path = workspace.join(".team").join("runtime").join("state.json");
-        std::fs::read_to_string(path)
-            .ok()
-            .and_then(|s| serde_json::from_str(&s).ok())
-            .unwrap_or_else(|| json!({}))
-    }
-
     fn which_path(binary: &str) -> Option<String> {
         let path = std::env::var_os("PATH")?;
         for dir in std::env::split_paths(&path) {

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

@@ -505,57 +505,20 @@ enum ParsedTarget {
 }
 
 fn parse_named_address(raw_name: &str) -> Result<ParsedNamedAddress, NamedAddressError> {
-    let raw = raw_name.trim();
-    if raw.is_empty() {
-        return Err(name_invalid("name is empty"));
-    }
-    let (workspace, name) = if let Some((workspace, rest)) = raw.split_once("::") {
-        if workspace.trim().is_empty() || rest.trim().is_empty() {
-            return Err(name_invalid(
-                "workspace-qualified name must include workspace and target",
-            ));
-        }
-        (Some(PathBuf::from(workspace)), rest.trim())
-    } else {
-        (None, raw)
-    };
-
-    if name.contains("//") {
-        return Err(name_invalid("name contains an empty path segment"));
-    }
-
-    let target = if name.contains('/') {
-        let parts = name.split('/').collect::<Vec<_>>();
-        if parts.len() != 2 || !valid_component(parts[0]) || !valid_component(parts[1]) {
-            return Err(name_invalid("expected <team>/<agent> or <team>/leader"));
+    let parsed = crate::messaging::parse_logical_address(raw_name).map_err(name_invalid)?;
+    let target = match parsed.target {
+        crate::messaging::LogicalAddressTarget::Worker(agent) => ParsedTarget::BareAgent(agent),
+        crate::messaging::LogicalAddressTarget::TeamEntity { team, entity } => {
+            ParsedTarget::TeamEntity { team, entity }
         }
-        ParsedTarget::TeamEntity {
-            team: parts[0].to_string(),
-            entity: parts[1].to_string(),
+        crate::messaging::LogicalAddressTarget::SessionWindow { session, window } => {
+            ParsedTarget::SessionWindow { session, window }
         }
-    } else if name.contains(':') {
-        let parts = name.split(':').collect::<Vec<_>>();
-        if parts.len() != 2 || parts[0].trim().is_empty() || parts[1].trim().is_empty() {
-            return Err(name_invalid("expected <session>:<window>"));
-        }
-        ParsedTarget::SessionWindow {
-            session: parts[0].to_string(),
-            window: parts[1].to_string(),
-        }
-    } else {
-        if !valid_component(name) {
-            return Err(name_invalid("expected a non-empty agent id"));
-        }
-        ParsedTarget::BareAgent(name.to_string())
     };
-    Ok(ParsedNamedAddress { workspace, target })
-}
-
-fn valid_component(raw: &str) -> bool {
-    !raw.trim().is_empty()
-        && !raw.contains(char::is_whitespace)
-        && !raw.contains('/')
-        && !raw.contains(':')
+    Ok(ParsedNamedAddress {
+        workspace: parsed.workspace,
+        target,
+    })
 }
 
 fn resolve_workspace(
@@ -680,12 +643,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 +709,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 +740,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,