@team-agent/installer 0.5.58 → 0.5.59

package/Cargo.lock

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

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

@@ -3,7 +3,7 @@
 
 use super::spec::{command_spec, CommandKind, CommandTier, ALL_DISPATCH_KINDS, COMMAND_SPECS};
 use super::*;
-use std::io::Write as _;
+use std::io::{ErrorKind, Write as _};
 
 /// `emit`(`helpers.py:12-23`):`--json`→`json.dumps(indent=2, ensure_ascii=False, sort_keys=True)`;
 /// 否则 dict 逐键 `key: value`(嵌套 dict/list 内联 compact json,`ensure_ascii=False`)、非 dict 直接 print。
@@ -77,12 +77,40 @@ pub fn run(argv: &[String], cwd: &Path) -> ExitCode {
 /// Print a handler's CmdResult to stdout (emit formats json/human), then surface its exit code.
 /// (parser.py: `print(emit(result, as_json))` then the ok→exit mapping.)
 fn emit_result(r: CmdResult) -> ExitCode {
+    let persisted_message_id = match &r.output {
+        CmdOutput::Json(value) => value
+            .get("message_id")
+            .and_then(Value::as_str)
+            .map(ToString::to_string),
+        _ => None,
+    };
     if let Some(text) = emit(&r.output, r.as_json) {
-        println!("{text}");
+        if let Err(error) = write_stdout_line(&text) {
+            if let Some(message_id) = persisted_message_id {
+                let stderr = std::io::stderr();
+                let mut stderr = stderr.lock();
+                let _ = writeln!(
+                    stderr,
+                    "stdout unavailable after durable send; persisted_message_id={message_id}"
+                );
+            }
+            return if error.kind() == ErrorKind::BrokenPipe {
+                r.exit
+            } else {
+                ExitCode::Error
+            };
+        }
     }
     r.exit
 }
 
+fn write_stdout_line(text: &str) -> std::io::Result<()> {
+    let stdout = std::io::stdout();
+    let mut stdout = stdout.lock();
+    stdout.write_all(text.as_bytes())?;
+    stdout.write_all(b"\n")
+}
+
 fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliError> {
     let Some(spec) = command_spec(command) else {
         return Ok(emit_unknown_subcommand_usage(command));

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

@@ -37,8 +37,8 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
         Ok(s) => s,
         Err(_) => return Ok(None),
     };
-    let team_alive = target_team_is_alive_for_mailbox(&state, &team_key);
-    if !team_alive {
+    let attachment_history = target_team_mailbox_history(&state, &team_key);
+    if attachment_history == MailboxAttachmentHistory::NotEligible {
         return Ok(None);
     }
     let event_log = crate::event_log::EventLog::new(&target_workspace);
@@ -53,47 +53,90 @@ pub(super) fn maybe_enqueue_offline_leader_mailbox(
     )
     .map_err(|e| CliError::Runtime(e.to_string()))?;
     let message_id = outcome.message_id.clone().unwrap_or_else(|| "".to_string());
-    Ok(Some(json!({
-        "ok": true,
-        "status": "queued_until_leader_attach",
-        "message_status": "queued_until_leader_attach",
-        "channel": "leader_mailbox",
-        "delivered": false,
-        "to_name": to_name,
-        "target_workspace": target_workspace.display().to_string(),
-        "team_key": team_key,
-        "recipient": "leader",
-        "leader_attached": false,
-        "message_id": message_id,
-    })))
+    let receipt = match attachment_history {
+        MailboxAttachmentHistory::NeverAttached => json!({
+            "ok": true,
+            "status": "deferred",
+            "deferred_reason": "never_attached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::PreviouslyAttached => json!({
+            "ok": true,
+            "status": "queued_until_leader_attach",
+            "deferred_reason": "leader_currently_unattached",
+            "message_status": "queued_until_leader_attach",
+            "channel": "leader_mailbox",
+            "delivered": false,
+            "to_name": to_name,
+            "target_workspace": target_workspace.display().to_string(),
+            "team_key": team_key,
+            "recipient": "leader",
+            "leader_attached": false,
+            "message_id": message_id,
+        }),
+        MailboxAttachmentHistory::NotEligible => unreachable!("refused before persistence"),
+    };
+    Ok(Some(receipt))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum MailboxAttachmentHistory {
+    PreviouslyAttached,
+    NeverAttached,
+    NotEligible,
 }
 
-/// Positive-source liveness heuristic per offline-mailbox-toname-design.md §4:
+/// Positive-source mailbox eligibility per offline-mailbox-toname-design.md §4:
 /// - target workspace has state and the team key is present + not archived/down;
-/// - AND at least one live tmux fact — a persisted `session_name` OR any
-///   agent with a recorded pane on the recorded socket.
+/// - AND a persisted session name establishes a durable replay target;
+/// - a persisted receiver attachment timestamp distinguishes previously attached
+///   teams from teams whose first successful leader attachment is still pending.
 ///
 /// We deliberately do NOT poll coordinator health here — enqueuing is
 /// safe even when the coordinator is transiently down; attach-leader
 /// itself replays via `requeue_blocked_leader_messages` regardless.
-pub(super) fn target_team_is_alive_for_mailbox(state: &Value, team_key: &str) -> bool {
+fn target_team_mailbox_history(state: &Value, team_key: &str) -> MailboxAttachmentHistory {
     let team = state
         .get("teams")
         .and_then(|v| v.as_object())
         .and_then(|teams| teams.get(team_key));
     let Some(team) = team else {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     };
     let status = team
         .get("status")
         .and_then(|v| v.as_str())
         .unwrap_or("alive");
     if matches!(status, "archived" | "down" | "stopped") {
-        return false;
+        return MailboxAttachmentHistory::NotEligible;
     }
-    // A recorded session_name is enough — target's coordinator/attach
-    // path will re-verify tmux presence when the replay fires.
-    team.get("session_name")
+    let has_session = team
+        .get("session_name")
         .and_then(|v| v.as_str())
-        .is_some_and(|s| !s.is_empty())
+        .is_some_and(|s| !s.is_empty());
+    if !has_session {
+        return MailboxAttachmentHistory::NotEligible;
+    }
+    let previously_attached = team
+        .get("leader_receiver")
+        .and_then(Value::as_object)
+        .is_some_and(|receiver| {
+            receiver
+                .get("attached_at")
+                .and_then(Value::as_str)
+                .is_some_and(|value| !value.is_empty())
+        });
+    if previously_attached {
+        MailboxAttachmentHistory::PreviouslyAttached
+    } else {
+        MailboxAttachmentHistory::NeverAttached
+    }
 }

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

@@ -155,7 +155,7 @@ pub(crate) struct CommandSpec {
 #[rustfmt::skip]
 pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for a logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
+    CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -336,9 +336,20 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
                     .or_else(|| obj.get("name"))
                     .or_else(|| obj.get("test"))
                     .and_then(text_of_value)?;
+                let status =
+                    match normalize_token(obj.get("status").and_then(Value::as_str)).as_str() {
+                        "executed" => {
+                            if obj.get("exit_code").and_then(Value::as_i64) == Some(0) {
+                                TestStatus::Passed
+                            } else {
+                                TestStatus::Failed
+                            }
+                        }
+                        _ => normalize_test_status(obj.get("status").and_then(Value::as_str)),
+                    };
                 Some(NormalizedTest {
                     command,
-                    status: normalize_test_status(obj.get("status").and_then(Value::as_str)),
+                    status,
                     detail: obj
                         .get("detail")
                         .or_else(|| obj.get("output"))
@@ -346,6 +357,7 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
                         .or_else(|| obj.get("stderr"))
                         .or_else(|| obj.get("summary"))
                         .or_else(|| obj.get("message"))
+                        .or_else(|| obj.get("log_path"))
                         .and_then(text_of_value),
                 })
             }
@@ -358,6 +370,46 @@ pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
         .collect()
 }
 
+pub(crate) fn validate_test_evidence_schema(value: Option<&Value>) -> Result<(), String> {
+    const ALLOWED: &str = r#"allowed schema: {"status":"executed","command":string,"exit_code":integer,"log_path":string}"#;
+    for (index, item) in items_from_value(value).iter().enumerate() {
+        let Value::Object(obj) = item else {
+            continue;
+        };
+        let status = normalize_token(obj.get("status").and_then(Value::as_str));
+        if status == "executed" {
+            let valid = obj.get("command").and_then(Value::as_str).is_some()
+                && obj.get("exit_code").and_then(Value::as_i64).is_some()
+                && obj.get("log_path").and_then(Value::as_str).is_some();
+            if !valid {
+                return Err(format!(
+                    "unsupported_test_evidence_schema at tests[{index}]; {ALLOWED}"
+                ));
+            }
+        } else if !status.is_empty()
+            && !matches!(
+                status.as_str(),
+                "passed"
+                    | "pass"
+                    | "ok"
+                    | "success"
+                    | "failed"
+                    | "fail"
+                    | "error"
+                    | "skipped"
+                    | "skip"
+                    | "not_run"
+                    | "notrun"
+            )
+        {
+            return Err(format!(
+                "unsupported_test_evidence_schema at tests[{index}]; {ALLOWED}"
+            ));
+        }
+    }
+    Ok(())
+}
+
 pub(crate) fn normalize_risks(value: Option<&Value>) -> Vec<NormalizedRisk> {
     items_from_value(value)
         .iter()

package/crates/team-agent/src/mcp_server/tools.rs

@@ -27,7 +27,7 @@ use super::helpers::{
 };
 use super::normalize::{
     compact_tool_result, normalize_report_envelope, normalize_result_status_observed,
-    report_result_integrity_warnings,
+    report_result_integrity_warnings, validate_test_evidence_schema,
 };
 use super::types::{
     Scope, SendOutcome, ToolError, ToolErrorReason, ToolOk, ToolResult, VisiblePeers,
@@ -522,6 +522,13 @@ impl TeamOrchestratorTools {
         {
             self.note_unknown_result_status(&raw);
         }
+        if let Err(error) = validate_test_evidence_schema(base.get("tests")) {
+            return Err(ToolError::new(
+                ToolErrorReason::InvalidToolArguments,
+                error,
+                "UnsupportedTestEvidenceSchema",
+            ));
+        }
         let normalized = normalize_report_envelope(&base);
         if let Some(error) = normalized.presentation_error.as_deref() {
             return Err(ToolError::new(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.58",
+  "version": "0.5.59",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.58",
-    "@team-agent/cli-darwin-x64": "0.5.58",
-    "@team-agent/cli-linux-x64": "0.5.58"
+    "@team-agent/cli-darwin-arm64": "0.5.59",
+    "@team-agent/cli-darwin-x64": "0.5.59",
+    "@team-agent/cli-linux-x64": "0.5.59"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/SKILL.md

@@ -166,6 +166,7 @@ For diagnosis, run `team-agent profile show deepseek --workspace . --json`; neve
 - `quick-start` is only for first-time team creation from role docs. If that team already has runtime state, use `team-agent restart . --team <session_name_or_team_name>` to resume it. If restart cannot recover context, explain the loss and wait for explicit user consent before using `team-agent restart . --allow-fresh`; never reset context through quick-start.
 - If the user explicitly asks a worker to create or operate a nested child team, first read `references/team-in-team.md`. Child teams must use an independent child workspace, never the parent `.team/current`.
 - `team-agent send --watch-result coder "Do the bounded task"` sends a direct worker message, returns after delivery, and lets the coordinator collect/report completion asynchronously.
+- Positional `TO` has two co-equal forms: an in-team short name, for example `team-agent send reviewer "Review this change"`, and a fully-qualified logical name, `<workspace>::<team>/<agent>`. Use the fully-qualified form across workspaces or when the local team scope is ambiguous.
 - Advanced orchestration callers may add `--presentation-sink leader|casefile|silent --message-class CLASS [--case-id CASE]`. All sinks remain durable and pullable; `casefile`/`silent` suppress only live leader injection. Missing presentation metadata preserves the normal leader-visible behavior.
 - After `send --watch-result` succeeds, do not run `sleep`, `status`, `inbox`, or `collect` polling loops unless the user explicitly asks for diagnosis; the coordinator will notify the leader when the result arrives.
 - `team-agent send --task task_initial "Start"` routes by task.