@team-agent/installer 0.5.20 → 0.5.22

package/Cargo.lock

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

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

@@ -142,11 +142,25 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     {
         return Ok(cmd_send_result(amb, args.json));
     }
+    if let Some(value) = dirty_topology_refusal_value(&selected, args.team.as_deref()) {
+        return Ok(cmd_send_result(value, args.json));
+    }
+    let coordinator_ensure = if target_has_known_worker(&selected.state, &target, &opts.sender) {
+        loud_ensure_coordinator(&selected)?
+    } else {
+        None
+    };
+    if let Some(value) =
+        coordinator_ensure_unavailable_value(coordinator_ensure.as_ref(), &target, &content, &opts)
+    {
+        return Ok(cmd_send_result(value, args.json));
+    }
     let mut outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
     if opts.watch_result {
         outcome = observe_initial_delivery_for_watch(&selected, &target, &outcome, &opts)?;
     }
     let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    append_loud_ensure_fields(&mut value, coordinator_ensure.as_ref());
     if opts.watch_result && initial_delivery_allows_watch(outcome.status) {
         if let Some(obj) = value.as_object_mut() {
             obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
@@ -156,6 +170,194 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     Ok(cmd_send_result(value, args.json))
 }
 
+fn dirty_topology_refusal_value(
+    selected: &crate::state::selector::SelectedTeam,
+    requested_team: Option<&str>,
+) -> Option<Value> {
+    let issue_ids = crate::topology::restart_dirty_topology_issue_ids(&selected.state);
+    if issue_ids.is_empty() {
+        return None;
+    }
+    let session_name = selected
+        .state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let reason = issue_ids
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "dirty_topology".to_string());
+    let repair_team = requested_team
+        .filter(|team| !team.is_empty())
+        .unwrap_or(selected.team_key.as_str());
+    Some(json!({
+        "ok": false,
+        "status": "refused_dirty_topology",
+        "reason": reason,
+        "session_name": session_name,
+        "error": "send refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before sending",
+        "issues": issue_ids
+            .iter()
+            .map(|id| json!({"id": id}))
+            .collect::<Vec<_>>(),
+        "next_actions": [
+            "team-agent diagnose --json",
+            format!("team-agent claim-leader --team {repair_team} --confirm --json"),
+            format!("team-agent takeover --team {repair_team} --confirm --json")
+        ],
+    }))
+}
+
+fn target_has_known_worker(state: &Value, target: &MessageTarget, sender: &str) -> bool {
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return false;
+    };
+    match target {
+        MessageTarget::Single(target) => agents.contains_key(target),
+        MessageTarget::Broadcast => agents.keys().any(|agent| agent != sender),
+        MessageTarget::Fanout(recipients) => recipients
+            .iter()
+            .any(|recipient| agents.contains_key(recipient)),
+    }
+}
+
+#[derive(Debug, Clone)]
+struct LoudEnsureResult {
+    previous_status: String,
+    start: crate::coordinator::StartReport,
+}
+
+fn loud_ensure_coordinator(
+    selected: &crate::state::selector::SelectedTeam,
+) -> Result<Option<LoudEnsureResult>, CliError> {
+    if in_process_unit_test() {
+        return Ok(None);
+    }
+    let workspace = crate::coordinator::WorkspacePath::new(selected.run_workspace.clone());
+    let previous = crate::coordinator::coordinator_health(&workspace);
+    if previous.ok {
+        return Ok(None);
+    }
+    let previous_status = coordinator_health_status_wire(previous.status).to_string();
+    let start = crate::coordinator::start_coordinator_with_team(
+        &workspace,
+        Some(selected.team_key.as_str()),
+    )
+    .map_err(|error| CliError::Runtime(error.to_string()))?;
+    if !start.ok {
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    if matches!(
+        start.status,
+        crate::coordinator::StartOutcome::Started
+            | crate::coordinator::StartOutcome::StartedAfterRotation
+    ) {
+        crate::event_log::EventLog::new(&selected.run_workspace)
+            .write(
+                "coordinator.ensure_restarted",
+                json!({
+                    "coordinator_previous_status": previous_status,
+                    "status": start.status,
+                    "pid": start.pid.map(|pid| pid.get()),
+                    "previous_pid": start.previous_pid.map(|pid| pid.get()),
+                    "binary_path": start.binary_path,
+                    "binary_version": start.binary_version,
+                    "rotation_reason": start.rotation_reason,
+                }),
+            )
+            .map_err(|error| CliError::Runtime(error.to_string()))?;
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    Ok(None)
+}
+
+#[cfg(test)]
+fn in_process_unit_test() -> bool {
+    true
+}
+
+#[cfg(not(test))]
+fn in_process_unit_test() -> bool {
+    false
+}
+
+fn coordinator_ensure_unavailable_value(
+    ensure: Option<&LoudEnsureResult>,
+    target: &MessageTarget,
+    content: &str,
+    opts: &SendOptions,
+) -> Option<Value> {
+    let ensure = ensure?;
+    if ensure.start.ok {
+        return None;
+    }
+    let warning = format!(
+        "coordinator is not running; message was not queued for {}. Run `team-agent diagnose` or restart the team before sending again.",
+        first_target(target)
+    );
+    let mut value = json!({
+        "ok": false,
+        "status": "degraded",
+        "delivery_status": "degraded",
+        "delivered": false,
+        "target": target_json(target),
+        "agent_id": first_target(target),
+        "content_length_bytes": content.len(),
+        "sender": opts.sender,
+        "message_id": Value::Null,
+        "message_status": "degraded",
+        "verification": warning,
+        "stage": Value::Null,
+        "reason": "coordinator_unavailable",
+        "channel": "coordinator_unavailable",
+    });
+    append_loud_ensure_fields(&mut value, Some(ensure));
+    Some(value)
+}
+
+fn append_loud_ensure_fields(value: &mut Value, ensure: Option<&LoudEnsureResult>) {
+    let Some(ensure) = ensure else {
+        return;
+    };
+    if !ensure.start.ok {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("coordinator_auto_restarted".to_string(), json!(true));
+        obj.insert(
+            "coordinator_previous_status".to_string(),
+            json!(ensure.previous_status),
+        );
+        obj.insert(
+            "coordinator".to_string(),
+            coordinator_start_json(&ensure.start),
+        );
+    }
+}
+
+fn coordinator_start_json(report: &crate::coordinator::StartReport) -> Value {
+    let summary = crate::lifecycle::CoordinatorStartSummary::from_start_report(report);
+    crate::lifecycle::coordinator_start_summary_value(&summary)
+}
+
+fn coordinator_health_status_wire(
+    status: crate::coordinator::CoordinatorHealthStatus,
+) -> &'static str {
+    match status {
+        crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+        crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+        crate::coordinator::CoordinatorHealthStatus::Running => "running",
+        crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+    }
+}
+
 /// F1 (0.3.26): direct pane-id send — bypasses agent-name routing + team
 /// membership check. Constructs `Target::Pane`, renders the message with
 /// the standard protocol block (Team Agent message from sender + token),

package/crates/team-agent/src/coordinator/backoff.rs

@@ -552,7 +552,19 @@ fn sleep_seconds(seconds: f64) {
     if seconds <= 0.0 {
         return;
     }
-    std::thread::sleep(std::time::Duration::from_secs_f64(seconds));
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs_f64(seconds);
+    loop {
+        #[cfg(unix)]
+        if SIGNAL_STOP_REQUESTED.load(std::sync::atomic::Ordering::SeqCst) {
+            return;
+        }
+        let now = std::time::Instant::now();
+        if now >= deadline {
+            return;
+        }
+        let remaining = deadline.saturating_duration_since(now);
+        std::thread::sleep(remaining.min(std::time::Duration::from_millis(100)));
+    }
 }
 
 /// 子进程退出错误(daemon bin 顶层用 anyhow,但 lib 入口仍给 typed)。
@@ -661,4 +673,22 @@ mod tests {
             "panic marker must carry a backtrace; event={panic_event}"
         );
     }
+
+    #[cfg(unix)]
+    #[test]
+    fn signal_stop_request_interrupts_daemon_sleep_without_consuming_signal() {
+        SIGNAL_STOP_NUMBER.store(libc::SIGTERM, std::sync::atomic::Ordering::SeqCst);
+        SIGNAL_STOP_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
+
+        let started = std::time::Instant::now();
+        sleep_seconds(1.0);
+        let elapsed = started.elapsed();
+        let signal = take_signal_stop_request();
+
+        assert_eq!(signal, Some("SIGTERM"));
+        assert!(
+            elapsed < std::time::Duration::from_millis(500),
+            "daemon sleep must wake promptly after SIGTERM stop flag; elapsed={elapsed:?}"
+        );
+    }
 }

package/crates/team-agent/src/coordinator/health.rs

@@ -632,12 +632,44 @@ fn coordinator_metadata_mismatch_reason_with_identity(
     if binary_version != identity.binary_version {
         return Some(CoordinatorMetadataMismatchReason::BinaryVersionMismatch);
     }
-    if binary_path != identity.binary_path {
+    if !binary_path_matches_current_identity(binary_path, &identity.binary_path) {
         return Some(CoordinatorMetadataMismatchReason::BinaryPathMismatch);
     }
     None
 }
 
+fn binary_path_matches_current_identity(metadata_path: &str, identity_path: &str) -> bool {
+    if metadata_path == identity_path {
+        return true;
+    }
+    test_harness_binary_path_matches(metadata_path)
+}
+
+/// Test harness escape hatch for integration tests whose process identity is the
+/// test binary while fixture metadata intentionally points at the built CLI.
+/// Production must not infer this from path shape; callers must set the
+/// `TEAM_AGENT_TEST_HARNESS_BINARY_PATH_MATCH` env explicitly to either the
+/// expected binary path or the target directory containing `team-agent`.
+fn test_harness_binary_path_matches(metadata_path: &str) -> bool {
+    let Ok(path) = std::env::var("TEAM_AGENT_TEST_HARNESS_BINARY_PATH_MATCH") else {
+        return false;
+    };
+    let path = PathBuf::from(path);
+    path_matches(metadata_path, &path)
+        || path_matches(metadata_path, &path.join("team-agent"))
+        || path
+            .parent()
+            .is_some_and(|parent| path_matches(metadata_path, &parent.join("team-agent")))
+}
+
+fn path_matches(metadata_path: &str, path: &Path) -> bool {
+    path.to_string_lossy() == metadata_path
+        || path
+            .canonicalize()
+            .ok()
+            .is_some_and(|path| path.to_string_lossy() == metadata_path)
+}
+
 /// `write_coordinator_metadata`(`metadata.py:46-61`)。写 `coordinator.json`(pretty indent=2),
 /// `updated_at = now(utc).isoformat()`。
 pub fn write_coordinator_metadata(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "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.20",
-    "@team-agent/cli-darwin-x64": "0.5.20",
-    "@team-agent/cli-linux-x64": "0.5.20"
+    "@team-agent/cli-darwin-arm64": "0.5.22",
+    "@team-agent/cli-darwin-x64": "0.5.22",
+    "@team-agent/cli-linux-x64": "0.5.22"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",