@team-agent/installer 0.3.10 → 0.3.11

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.10"
+version = "0.3.11"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.10"
+version = "0.3.11"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -22,7 +22,9 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     // empty message body is a prompt-only invocation (`team-agent send "fix the build"`).
     // The lone positional is CONTENT, not a target — reject with `routing_ambiguous`
     // (NOT `target_not_in_team`, which would lie that the user did pick a target).
-    if let Some(amb) = routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts) {
+    if let Some(amb) =
+        routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts)
+    {
         return Ok(CmdResult::from_json(amb, args.json));
     }
     let outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
@@ -117,7 +119,10 @@ fn watch_notice_json(target: &MessageTarget, opts: &SendOptions) -> Value {
     let agent_id = match target {
         MessageTarget::Single(agent) => agent.clone(),
         MessageTarget::Broadcast => "*".to_string(),
-        MessageTarget::Fanout(recipients) => recipients.first().cloned().unwrap_or_else(|| "-".to_string()),
+        MessageTarget::Fanout(recipients) => recipients
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "-".to_string()),
     };
     json!({
         "status": "registered",
@@ -174,6 +179,7 @@ fn delivery_status_wire(status: DeliveryStatus) -> &'static str {
         DeliveryStatus::Queued => "queued",
         DeliveryStatus::Blocked => "blocked",
         DeliveryStatus::Refused => "refused",
+        DeliveryStatus::Degraded => "degraded",
         DeliveryStatus::RetryScheduled => "retry_scheduled",
         DeliveryStatus::TrustAutoAnswerExhausted => "trust_auto_answer_exhausted",
         DeliveryStatus::AlreadyDelivered => "already_delivered",
@@ -195,6 +201,7 @@ fn delivery_refusal_wire(reason: DeliveryRefusal) -> &'static str {
         DeliveryRefusal::TmuxTargetMissing => "tmux_target_missing",
         DeliveryRefusal::MessageAlreadyClaimed => "message_already_claimed",
         DeliveryRefusal::LeaderNotAttached => "leader_not_attached",
+        DeliveryRefusal::CoordinatorUnavailable => "coordinator_unavailable",
         DeliveryRefusal::NoCallerPane => "no_caller_pane",
         DeliveryRefusal::TeamOwnerMismatch => "team_owner_mismatch",
         DeliveryRefusal::Ambiguous => "ambiguous",

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

@@ -8,7 +8,7 @@ use crate::model::enums::Provider;
 use crate::provider::ProviderAdapter;
 
 use super::health::{coordinator_pid_path, write_coordinator_metadata};
-use super::tick::TickError;
+use super::tick::{TickError, TickReport};
 use super::types::{
     ErrorLists, MetadataSource, Pid, ProviderRegistry, WorkspacePath, BACKOFF_MAX_SEC,
     DEFAULT_TICK_INTERVAL_SEC,
@@ -87,7 +87,7 @@ pub fn run_daemon_with_coordinator(
             );
             break;
         }
-        match coordinator.tick() {
+        match run_tick_with_panic_marker(&event_log, || coordinator.tick()) {
             Ok(report) => {
                 if consecutive_failures > 0 {
                     event_log.write(
@@ -150,6 +150,36 @@ pub fn run_daemon_with_coordinator(
     Ok(())
 }
 
+fn run_tick_with_panic_marker<F>(event_log: &EventLog, tick: F) -> Result<TickReport, TickError>
+where
+    F: FnOnce() -> Result<TickReport, TickError>,
+{
+    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(tick)) {
+        Ok(result) => result,
+        Err(payload) => {
+            let panic_message = panic_payload_message(payload.as_ref());
+            event_log.write(
+                "coordinator.tick_panic",
+                serde_json::json!({
+                    "panic": panic_message,
+                    "backtrace": std::backtrace::Backtrace::force_capture().to_string(),
+                }),
+            )?;
+            Err(TickError::Panic(panic_message))
+        }
+    }
+}
+
+fn panic_payload_message(payload: &(dyn std::any::Any + Send)) -> String {
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        (*message).to_string()
+    } else if let Some(message) = payload.downcast_ref::<String>() {
+        message.clone()
+    } else {
+        "non-string panic payload".to_string()
+    }
+}
+
 /// 当前 ppid(`os.getppid()`,孤儿自检输入)。
 fn current_ppid() -> u32 {
     u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
@@ -199,3 +229,54 @@ pub enum DaemonError {
     #[error("tick: {0}")]
     Tick(#[from] TickError),
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tmp_ws(tag: &str) -> std::path::PathBuf {
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static N: AtomicU64 = AtomicU64::new(0);
+        let n = N.fetch_add(1, Ordering::Relaxed);
+        let path =
+            std::env::temp_dir().join(format!("ta-rs-coord-{tag}-{}-{n}", std::process::id()));
+        std::fs::create_dir_all(&path).unwrap();
+        path
+    }
+
+    #[test]
+    fn coordinator_tick_panic_writes_durable_marker() {
+        let workspace = tmp_ws("tick-panic");
+        let event_log = EventLog::new(&workspace);
+
+        let old_hook = std::panic::take_hook();
+        std::panic::set_hook(Box::new(|_| {}));
+        let result = run_tick_with_panic_marker(&event_log, || -> Result<TickReport, TickError> {
+            panic!("synthetic tick panic")
+        });
+        std::panic::set_hook(old_hook);
+
+        assert!(
+            matches!(result, Err(TickError::Panic(message)) if message == "synthetic tick panic")
+        );
+        let events = event_log.tail(20).unwrap();
+        let panic_event = events
+            .iter()
+            .find(|event| {
+                event.get("event").and_then(serde_json::Value::as_str)
+                    == Some("coordinator.tick_panic")
+            })
+            .expect("coordinator.tick_panic event");
+        assert_eq!(
+            panic_event.get("panic").and_then(serde_json::Value::as_str),
+            Some("synthetic tick panic")
+        );
+        assert!(
+            panic_event
+                .get("backtrace")
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|backtrace| !backtrace.is_empty()),
+            "panic marker must carry a backtrace; event={panic_event}"
+        );
+    }
+}