@team-agent/installer 0.5.64 → 0.5.66

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

@@ -214,6 +214,7 @@ pub fn send_message(
                 stage: None,
                 reason: Some(crate::messaging::DeliveryRefusal::EmptyTargetList),
                 channel: None,
+                ack_forced_off: false,
             });
         }
         MessageTarget::Fanout(recipients) => {
@@ -351,6 +352,7 @@ pub fn send_message(
         stage: None,
         reason: None,
         channel: None,
+        ack_forced_off: false,
     })
 }
 
@@ -404,6 +406,7 @@ fn persist_stored_only_send(
         stage: None,
         reason: None,
         channel: Some(presentation.effective_sink.as_str().to_string()),
+        ack_forced_off: false,
     })
 }
 
@@ -451,6 +454,7 @@ fn refused_outcome_with_id(reason: DeliveryRefusal, message_id: Option<String>)
         stage: None,
         reason: Some(reason),
         channel: None,
+        ack_forced_off: false,
     }
 }
 
@@ -467,6 +471,7 @@ fn refused_outcome_with_verification(
         stage: None,
         reason: Some(reason),
         channel: None,
+        ack_forced_off: false,
     }
 }
 
@@ -549,6 +554,7 @@ fn coordinator_unavailable_outcome(
             stage: None,
             reason: Some(DeliveryRefusal::CoordinatorUnavailable),
             channel: Some("coordinator_unavailable".to_string()),
+            ack_forced_off: false,
         },
     }))
 }
@@ -573,6 +579,7 @@ fn rebind_required_outcome_with_verification(
         stage: None,
         reason: Some(DeliveryRefusal::LeaderNotAttached),
         channel: Some("rebind_required".to_string()),
+        ack_forced_off: false,
     }
 }
 
@@ -804,6 +811,7 @@ pub(crate) fn session_drift_refusal(
         stage: None,
         reason: Some(DeliveryRefusal::SessionDrift),
         channel: None,
+        ack_forced_off: false,
     }))
 }
 
@@ -924,5 +932,6 @@ fn fanout_send(
         } else {
             channel_label.to_string()
         }),
+        ack_forced_off: false,
     })
 }

package/crates/team-agent/src/messaging/tests/main_preserved.rs

@@ -94,7 +94,7 @@ fn collect_result_file_ingests_valid_known_task_envelope_into_results() {
     .unwrap();
     std::fs::write(
         team.join("agents").join("w1.md"),
-        "---\nname: w1\nrole: Worker\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nW1.\n",
+        "---\nname: w1\nrole: Worker\nprovider: codex\nmodel: gpt-5.5\nauth_mode: subscription\ndangerously_skip_permissions: false\ntools:\n  - mcp_team\n---\n\nW1.\n",
     )
     .unwrap();
     let spec = crate::compiler::compile_team(&team).expect("compile collect team");

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -709,6 +709,38 @@ fn report_result_invalid_envelope_errors_validation() {
     );
 }
 
+#[test]
+fn leader_receiver_reports_requires_ack_forced_off() {
+    let ws = tmp_ws("ack-forced-off");
+    let log = EventLog::new(&ws);
+    let state = json(serde_json::json!({
+        "active_team_key": "team-a",
+        "teams": {"team-a": {}}
+    }));
+
+    let outcome = send_to_leader_receiver(
+        &ws,
+        &state,
+        "leader",
+        "ack contract probe",
+        None,
+        "worker",
+        true,
+        None,
+        &log,
+    )
+    .unwrap();
+
+    let value = crate::mcp_server::helpers::delivery_outcome_value(&outcome);
+    assert_eq!(
+        value
+            .get("ack_forced_off")
+            .and_then(serde_json::Value::as_bool),
+        Some(true),
+        "requires_ack=true must report that the unavailable ack guarantee was forced off"
+    );
+}
+
 // ════════════════════════════════════════════════════════════════════════
 // GROUP N — notify_result_watchers dedupe (exactly-once, Gap 32/38).
 // result_delivery.py:38-132. superseded for duplicate watchers same result.

package/crates/team-agent/src/messaging/types.rs

@@ -295,6 +295,8 @@ pub enum PaneWidthQuery {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DeliveryOutcome {
     pub ok: bool,
+    /// Whether a caller-requested ack guarantee was unavailable and forced off.
+    pub ack_forced_off: bool,
     /// 投递层结果态 (≠ 行态)。
     pub status: DeliveryStatus,
     /// step 7 `messages.status` 行态原文 (shadow;leader 集成时收口为 step 7 enum)。

package/crates/team-agent/src/messaging/wait.rs

@@ -0,0 +1,366 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use super::MessagingError;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WaitResult {
+    pub task_id: String,
+    pub result_id: String,
+    pub waited: bool,
+}
+
+impl WaitResult {
+    pub fn to_json(&self) -> Value {
+        serde_json::json!({
+            "ok": true,
+            "status": "completed",
+            "task_id": self.task_id,
+            "result_id": self.result_id,
+            "waited": self.waited,
+        })
+    }
+}
+
+#[cfg(not(unix))]
+pub fn wait_for_result(_workspace: &Path, _task_id: &str) -> Result<WaitResult, MessagingError> {
+    Err(MessagingError::Validation(
+        "wait --task requires POSIX FIFO support".to_string(),
+    ))
+}
+
+#[cfg(unix)]
+mod unix {
+    use std::ffi::CString;
+    use std::fs::{File, OpenOptions};
+    use std::io::{self, Read};
+    use std::os::fd::{AsRawFd, RawFd};
+    use std::os::unix::fs::OpenOptionsExt;
+    use std::path::{Path, PathBuf};
+    use std::sync::atomic::{AtomicI32, Ordering};
+
+    use rusqlite::{params, OptionalExtension};
+
+    use crate::event_log::EventLog;
+    use crate::message_store::MessageStore;
+
+    use super::{MessagingError, WaitResult};
+
+    static CAUGHT_SIGNAL: AtomicI32 = AtomicI32::new(0);
+
+    enum Registration {
+        Completed(String),
+        Pending,
+    }
+
+    struct FifoEndpoints {
+        path: PathBuf,
+        reader: File,
+        _keepalive_writer: File,
+    }
+
+    impl Drop for FifoEndpoints {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_file(&self.path);
+        }
+    }
+
+    struct RegistrationCleanup {
+        db_path: PathBuf,
+        watcher_id: String,
+        active: bool,
+    }
+
+    impl RegistrationCleanup {
+        fn cleanup(&mut self) -> Result<(), MessagingError> {
+            if self.active {
+                let conn = crate::db::schema::open_db(&self.db_path)?;
+                conn.execute(
+                    "delete from result_watchers where watcher_id = ?1",
+                    params![self.watcher_id],
+                )?;
+                self.active = false;
+            }
+            Ok(())
+        }
+    }
+
+    impl Drop for RegistrationCleanup {
+        fn drop(&mut self) {
+            if self.active {
+                if let Ok(conn) = crate::db::schema::open_db(&self.db_path) {
+                    let _ = conn.execute(
+                        "delete from result_watchers where watcher_id = ?1",
+                        params![self.watcher_id],
+                    );
+                }
+            }
+        }
+    }
+
+    struct SignalGuard {
+        old_int: libc::sigaction,
+        old_term: libc::sigaction,
+    }
+
+    impl SignalGuard {
+        fn install() -> io::Result<Self> {
+            CAUGHT_SIGNAL.store(0, Ordering::SeqCst);
+            let mut action: libc::sigaction = unsafe { std::mem::zeroed() };
+            action.sa_sigaction = record_signal as *const () as libc::sighandler_t;
+            action.sa_flags = 0;
+            unsafe {
+                libc::sigemptyset(&mut action.sa_mask);
+            }
+            let mut old_int: libc::sigaction = unsafe { std::mem::zeroed() };
+            let mut old_term: libc::sigaction = unsafe { std::mem::zeroed() };
+            if unsafe { libc::sigaction(libc::SIGINT, &action, &mut old_int) } != 0 {
+                return Err(io::Error::last_os_error());
+            }
+            if unsafe { libc::sigaction(libc::SIGTERM, &action, &mut old_term) } != 0 {
+                let error = io::Error::last_os_error();
+                unsafe {
+                    libc::sigaction(libc::SIGINT, &old_int, std::ptr::null_mut());
+                }
+                return Err(error);
+            }
+            Ok(Self { old_int, old_term })
+        }
+    }
+
+    impl Drop for SignalGuard {
+        fn drop(&mut self) {
+            unsafe {
+                libc::sigaction(libc::SIGINT, &self.old_int, std::ptr::null_mut());
+                libc::sigaction(libc::SIGTERM, &self.old_term, std::ptr::null_mut());
+            }
+        }
+    }
+
+    extern "C" fn record_signal(signal: libc::c_int) {
+        CAUGHT_SIGNAL.store(signal, Ordering::SeqCst);
+    }
+
+    pub fn wait_for_result(workspace: &Path, task_id: &str) -> Result<WaitResult, MessagingError> {
+        if task_id.trim().is_empty() {
+            return Err(MessagingError::Validation(
+                "wait --task requires a non-empty task id".to_string(),
+            ));
+        }
+        let _signals = SignalGuard::install()?;
+        let store = MessageStore::open(workspace)?;
+        let workspace = std::fs::canonicalize(workspace)?;
+        let watcher_id = format!("wait-{}", random_suffix()?);
+        let fifo_path = fifo_path(&workspace, task_id, &watcher_id)?;
+        let fifo = create_fifo(&fifo_path)?;
+        let conn = crate::db::schema::open_db(store.db_path())?;
+        let registration = register(&conn, &watcher_id, task_id, &fifo_path)?;
+        if let Registration::Completed(result_id) = registration {
+            return Ok(WaitResult {
+                task_id: task_id.to_string(),
+                result_id,
+                waited: false,
+            });
+        }
+
+        let mut cleanup = RegistrationCleanup {
+            db_path: store.db_path().to_path_buf(),
+            watcher_id: watcher_id.clone(),
+            active: true,
+        };
+        EventLog::new(&workspace).write(
+            "result_wake.registered",
+            serde_json::json!({
+                "task_id": task_id,
+                "watcher_id": watcher_id,
+                "recipient": fifo_path,
+            }),
+        )?;
+        let result_id = read_wake_line(fifo.reader.as_raw_fd())?;
+        cleanup.cleanup()?;
+        Ok(WaitResult {
+            task_id: task_id.to_string(),
+            result_id,
+            waited: true,
+        })
+    }
+
+    fn register(
+        conn: &rusqlite::Connection,
+        watcher_id: &str,
+        task_id: &str,
+        fifo_path: &Path,
+    ) -> Result<Registration, MessagingError> {
+        conn.execute_batch("BEGIN IMMEDIATE")?;
+        let operation = (|| -> Result<Registration, MessagingError> {
+            let completed = conn
+                .query_row(
+                    "select result_id from results
+                     where task_id = ?1 order by created_at, result_id limit 1",
+                    params![task_id],
+                    |row| row.get::<_, String>(0),
+                )
+                .optional()?;
+            if let Some(result_id) = completed {
+                return Ok(Registration::Completed(result_id));
+            }
+            conn.execute(
+                "insert into result_watchers(
+                     watcher_id, owner_team_id, task_id, agent_id, message_id,
+                     leader_id, recipient, status, created_at
+                 ) values (?1, null, ?2, null, null, 'team-agent', ?3, 'pending', ?4)",
+                params![
+                    watcher_id,
+                    task_id,
+                    fifo_path.to_string_lossy().as_ref(),
+                    chrono::Utc::now().to_rfc3339(),
+                ],
+            )?;
+            Ok(Registration::Pending)
+        })();
+        match operation {
+            Ok(registration) => match conn.execute_batch("COMMIT") {
+                Ok(()) => Ok(registration),
+                Err(error) => {
+                    let _ = conn.execute_batch("ROLLBACK");
+                    Err(error.into())
+                }
+            },
+            Err(error) => {
+                let _ = conn.execute_batch("ROLLBACK");
+                Err(error)
+            }
+        }
+    }
+
+    fn fifo_path(
+        workspace: &Path,
+        task_id: &str,
+        watcher_id: &str,
+    ) -> Result<PathBuf, MessagingError> {
+        let dir = workspace.join(".team/runtime/wake");
+        std::fs::create_dir_all(&dir)?;
+        let task = task_id
+            .chars()
+            .map(|ch| {
+                if ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_') {
+                    ch
+                } else {
+                    '_'
+                }
+            })
+            .take(80)
+            .collect::<String>();
+        let task = if task.is_empty() { "task" } else { &task };
+        Ok(dir.join(format!("{task}-{watcher_id}.fifo")))
+    }
+
+    fn random_suffix() -> Result<String, MessagingError> {
+        let mut bytes = [0_u8; 16];
+        File::open("/dev/urandom")?.read_exact(&mut bytes)?;
+        Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect())
+    }
+
+    fn create_fifo(path: &Path) -> Result<FifoEndpoints, MessagingError> {
+        let c_path = CString::new(path.as_os_str().as_encoded_bytes())
+            .map_err(|_| MessagingError::Validation("FIFO path contains a NUL byte".to_string()))?;
+        if unsafe { libc::mkfifo(c_path.as_ptr(), 0o600) } != 0 {
+            return Err(io::Error::last_os_error().into());
+        }
+        let reader = match OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_NONBLOCK)
+            .open(path)
+        {
+            Ok(reader) => reader,
+            Err(error) => {
+                let _ = std::fs::remove_file(path);
+                return Err(error.into());
+            }
+        };
+        let keepalive_writer = match OpenOptions::new()
+            .write(true)
+            .custom_flags(libc::O_NONBLOCK)
+            .open(path)
+        {
+            Ok(writer) => writer,
+            Err(error) => {
+                let _ = std::fs::remove_file(path);
+                return Err(error.into());
+            }
+        };
+        set_blocking(reader.as_raw_fd())?;
+        Ok(FifoEndpoints {
+            path: path.to_path_buf(),
+            reader,
+            _keepalive_writer: keepalive_writer,
+        })
+    }
+
+    fn set_blocking(fd: RawFd) -> io::Result<()> {
+        let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
+        if flags < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        if unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) } < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
+    fn read_wake_line(fd: RawFd) -> Result<String, MessagingError> {
+        let mut line = Vec::new();
+        loop {
+            if let Some(signal) = caught_signal() {
+                return Err(interrupted(signal).into());
+            }
+            let mut bytes = [0_u8; 256];
+            let count =
+                unsafe { libc::read(fd, bytes.as_mut_ptr().cast::<libc::c_void>(), bytes.len()) };
+            if count > 0 {
+                line.extend_from_slice(&bytes[..count as usize]);
+                if let Some(newline) = line.iter().position(|byte| *byte == b'\n') {
+                    line.truncate(newline);
+                    let result_id = String::from_utf8(line).map_err(|error| {
+                        MessagingError::Validation(format!("invalid FIFO wake line: {error}"))
+                    })?;
+                    let result_id = result_id.trim().to_string();
+                    if result_id.is_empty() {
+                        return Err(MessagingError::Validation(
+                            "FIFO wake line did not contain a result id".to_string(),
+                        ));
+                    }
+                    return Ok(result_id);
+                }
+                continue;
+            }
+            if count == 0 {
+                continue;
+            }
+            let error = io::Error::last_os_error();
+            if error.kind() == io::ErrorKind::Interrupted {
+                if let Some(signal) = caught_signal() {
+                    return Err(interrupted(signal).into());
+                }
+                continue;
+            }
+            return Err(error.into());
+        }
+    }
+
+    fn caught_signal() -> Option<i32> {
+        let signal = CAUGHT_SIGNAL.load(Ordering::SeqCst);
+        (signal != 0).then_some(signal)
+    }
+
+    fn interrupted(signal: i32) -> io::Error {
+        io::Error::new(
+            io::ErrorKind::Interrupted,
+            format!("wait interrupted by signal {signal}"),
+        )
+    }
+}
+
+#[cfg(unix)]
+pub use unix::wait_for_result;

package/crates/team-agent/src/messaging/watchers.rs

@@ -2,6 +2,13 @@
 
 use std::path::Path;
 
+#[cfg(unix)]
+use std::fs::OpenOptions;
+#[cfg(unix)]
+use std::io::Write as _;
+#[cfg(unix)]
+use std::os::unix::fs::OpenOptionsExt;
+
 use rusqlite::{params, OptionalExtension};
 
 use crate::event_log::EventLog;
@@ -119,6 +126,128 @@ fn watcher_matches(
     task_matches && agent_matches
 }
 
+pub(crate) fn notify_fifo_result_watchers(
+    conn: &rusqlite::Connection,
+    event_log: &EventLog,
+    task_id: &str,
+    result_id: &str,
+) -> Result<(), MessagingError> {
+    let mut stmt = conn.prepare(
+        "select watcher_id, recipient from result_watchers
+         where task_id = ?1 and status = 'pending' and recipient is not null
+         order by created_at, watcher_id",
+    )?;
+    let rows = stmt
+        .query_map(params![task_id], |row| {
+            Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
+        })?
+        .collect::<Result<Vec<_>, _>>()?;
+    drop(stmt);
+    for (watcher_id, recipient) in rows {
+        let _ = notify_fifo_waiter(conn, event_log, &watcher_id, task_id, result_id, &recipient)?;
+    }
+    Ok(())
+}
+
+#[cfg(unix)]
+fn notify_fifo_waiter(
+    conn: &rusqlite::Connection,
+    event_log: &EventLog,
+    watcher_id: &str,
+    task_id: &str,
+    result_id: &str,
+    recipient: &str,
+) -> Result<WatcherNotice, MessagingError> {
+    let write = (|| -> std::io::Result<()> {
+        let mut fifo = OpenOptions::new()
+            .write(true)
+            .custom_flags(libc::O_NONBLOCK)
+            .open(recipient)?;
+        fifo.write_all(format!("{result_id}\n").as_bytes())
+    })();
+    match write {
+        Ok(()) => {
+            event_log.write(
+                "result_wake.notified",
+                serde_json::json!({
+                    "task_id": task_id,
+                    "result_id": result_id,
+                    "watcher_id": watcher_id,
+                    "recipient": recipient,
+                }),
+            )?;
+            Ok(WatcherNotice {
+                watcher_id: watcher_id.to_string(),
+                result_id: Some(result_id.to_string()),
+                ok: true,
+                status: Some("notified".to_string()),
+                notified_message_id: None,
+                primary_watcher_id: None,
+                prior_state: None,
+                error: None,
+            })
+        }
+        Err(error)
+            if matches!(
+                error.raw_os_error(),
+                Some(code) if code == libc::ENXIO || code == libc::ENOENT
+            ) =>
+        {
+            let reason = if error.raw_os_error() == Some(libc::ENXIO) {
+                "ENXIO"
+            } else {
+                "ENOENT"
+            };
+            conn.execute(
+                "delete from result_watchers where watcher_id = ?1",
+                params![watcher_id],
+            )?;
+            event_log.write(
+                "result_wake.notify_failed",
+                serde_json::json!({
+                    "task_id": task_id,
+                    "result_id": result_id,
+                    "watcher_id": watcher_id,
+                    "recipient": recipient,
+                    "reason": reason,
+                }),
+            )?;
+            Ok(WatcherNotice {
+                watcher_id: watcher_id.to_string(),
+                result_id: Some(result_id.to_string()),
+                ok: false,
+                status: Some("removed".to_string()),
+                notified_message_id: None,
+                primary_watcher_id: None,
+                prior_state: None,
+                error: Some(reason.to_string()),
+            })
+        }
+        Err(error) => Err(error.into()),
+    }
+}
+
+#[cfg(not(unix))]
+fn notify_fifo_waiter(
+    _conn: &rusqlite::Connection,
+    _event_log: &EventLog,
+    watcher_id: &str,
+    _task_id: &str,
+    result_id: &str,
+    _recipient: &str,
+) -> Result<WatcherNotice, MessagingError> {
+    Ok(WatcherNotice {
+        watcher_id: watcher_id.to_string(),
+        result_id: Some(result_id.to_string()),
+        ok: false,
+        status: Some("unsupported".to_string()),
+        notified_message_id: None,
+        primary_watcher_id: None,
+        prior_state: None,
+        error: Some("POSIX FIFO support unavailable".to_string()),
+    })
+}
+
 fn deliver_primary_watcher(
     workspace: &Path,
     conn: &rusqlite::Connection,
@@ -143,6 +272,20 @@ fn deliver_primary_watcher(
             "missing_result_id",
         );
     };
+    if let Some(recipient) = watcher
+        .get("recipient")
+        .and_then(|value| value.as_str())
+        .filter(|recipient| Path::new(recipient).is_absolute())
+    {
+        return notify_fifo_waiter(
+            conn,
+            event_log,
+            watcher_id,
+            result_task.unwrap_or_default(),
+            result_id,
+            recipient,
+        );
+    }
     if let Some(existing) = delivered_result_message(
         store,
         result_id,
@@ -196,7 +339,10 @@ fn deliver_primary_watcher(
             .get("leader_id")
             .and_then(|v| v.as_str())
             .unwrap_or("team-agent"),
-        "leader",
+        watcher
+            .get("recipient")
+            .and_then(|value| value.as_str())
+            .unwrap_or("leader"),
         &content,
         None,
         false,
@@ -332,7 +478,7 @@ pub fn retry_result_deliveries(
     // delivery path with dedupe/attempt bounds); a watcher is never flipped to
     // `notified` without a delivery. Missing result rows are skipped (still retryable).
     let mut stmt = conn.prepare(
-        "select watcher_id, owner_team_id, task_id, agent_id, leader_id, status, created_at,
+        "select watcher_id, owner_team_id, task_id, agent_id, leader_id, recipient, status, created_at,
                 result_id, notified_message_id
          from result_watchers
          where status in ('pending', 'notify_failed')
@@ -346,10 +492,11 @@ pub fn retry_result_deliveries(
                 "task_id": row.get::<_, Option<String>>(2)?,
                 "agent_id": row.get::<_, Option<String>>(3)?,
                 "leader_id": row.get::<_, Option<String>>(4)?,
-                "status": row.get::<_, Option<String>>(5)?,
-                "created_at": row.get::<_, Option<String>>(6)?,
-                "result_id": row.get::<_, Option<String>>(7)?,
-                "notified_message_id": row.get::<_, Option<String>>(8)?,
+                "recipient": row.get::<_, Option<String>>(5)?,
+                "status": row.get::<_, Option<String>>(6)?,
+                "created_at": row.get::<_, Option<String>>(7)?,
+                "result_id": row.get::<_, Option<String>>(8)?,
+                "notified_message_id": row.get::<_, Option<String>>(9)?,
             }))
         })?
         .collect::<Result<Vec<_>, _>>()?;