@team-agent/installer 0.5.78 → 0.5.80

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

@@ -220,31 +220,128 @@ pub fn deliver_pending_message(
             turn_verification: None,
         });
     };
-    let mut canonical_owner_team_id = message.owner_team_id.clone();
-    let scoped_state;
-    let state = match message.owner_team_id.as_deref() {
-        Some(team) if !team.is_empty() => {
-            match project_state_for_owner_team(
-                workspace,
-                team,
+    match prepare_message_state(
+        workspace, store, message_id, event_log, state, &message, false,
+    )? {
+        Ok(prepared) => deliver_prepared_message(
+            workspace, store, transport, message_id, event_log, state, message, prepared,
+        ),
+        Err(outcome) => Ok(outcome),
+    }
+}
+
+// Thread-local observation only; no production cache or scheduling hook.
+#[cfg(test)]
+pub(super) mod preparation_probe {
+    std::thread_local! {
+        pub static COUNTS: std::cell::Cell<(usize, usize, usize)> = const { std::cell::Cell::new((0, 0, 0)) };
+        pub static BEFORE_CLAIM: std::cell::RefCell<Option<Box<dyn FnOnce()>>> = const { std::cell::RefCell::new(None) };
+    }
+}
+
+struct PreparedMessageState {
+    scoped: Option<serde_json::Value>,
+    canonical_owner_team_id: Option<String>,
+}
+
+fn prepare_message_state(
+    workspace: &Path,
+    store: &MessageStore,
+    message_id: &str,
+    event_log: &EventLog,
+    state: &serde_json::Value,
+    message: &PendingMessage,
+    batch: bool,
+) -> Result<Result<PreparedMessageState, DeliveryOutcome>, MessagingError> {
+    #[cfg(test)]
+    preparation_probe::COUNTS.with(|counts| {
+        let (prepare, project, claim) = counts.get();
+        counts.set((prepare + 1, project, claim));
+    });
+    let mut prepared = PreparedMessageState {
+        scoped: None,
+        canonical_owner_team_id: message.owner_team_id.clone(),
+    };
+    if let Some(team) = message
+        .owner_team_id
+        .as_deref()
+        .filter(|team| !team.is_empty())
+    {
+        match project_state_for_owner_team(
+            workspace,
+            team,
+            state,
+            Some(store),
+            Some(message_id),
+            Some(event_log),
+        )? {
+            OwnerTeamProjection::Projected {
                 state,
-                Some(store),
-                Some(message_id),
-                Some(event_log),
-            )? {
-                OwnerTeamProjection::Projected {
-                    state,
-                    canonical_team,
-                } => {
-                    canonical_owner_team_id = Some(canonical_team);
-                    scoped_state = state;
-                    &scoped_state
+                canonical_team,
+            } => {
+                prepared.scoped = Some(state);
+                prepared.canonical_owner_team_id = Some(canonical_team);
+            }
+            OwnerTeamProjection::Refused(outcome) => {
+                if batch {
+                    let _ = event_log.write(
+                        "delivery.projection_refused",
+                        serde_json::json!({
+                            "message_id": message_id,
+                            "owner_team_id": team,
+                            "status": super::helpers::status_wire(outcome.status),
+                            "verification": outcome.verification,
+                            "reason": format!("{:?}", outcome.reason),
+                        }),
+                    );
                 }
-                OwnerTeamProjection::Refused(outcome) => return Ok(outcome),
+                return Ok(Err(outcome));
             }
         }
-        _ => state,
-    };
+    }
+    if batch
+        && recipient_is_busy(
+            prepared.scoped.as_ref().unwrap_or(state),
+            &message.recipient,
+        )
+    {
+        event_log.write(
+            "send.deferred_busy",
+            serde_json::json!({
+                "message_id": message_id,
+                "sender": message.sender,
+                "recipient": message.recipient,
+                "reason": "recipient_busy",
+            }),
+        )?;
+        return Ok(Err(DeliveryOutcome {
+            ok: false,
+            status: DeliveryStatus::Queued,
+            message_status: MessageStatusShadow(message.status.clone()),
+            message_id: Some(message_id.to_string()),
+            verification: None,
+            stage: None,
+            reason: None,
+            channel: None,
+            ack_forced_off: false,
+            turn_verification: None,
+        }));
+    }
+    Ok(Ok(prepared))
+}
+
+fn deliver_prepared_message(
+    workspace: &Path,
+    store: &MessageStore,
+    transport: &dyn Transport,
+    message_id: &str,
+    event_log: &EventLog,
+    fallback: &serde_json::Value,
+    message: PendingMessage,
+    prepared: PreparedMessageState,
+) -> Result<DeliveryOutcome, MessagingError> {
+    let canonical_owner_team_id = prepared.canonical_owner_team_id;
+    let state = prepared.scoped.as_ref().unwrap_or(fallback);
     if message.recipient == "leader"
         && matches!(
             message.status.as_str(),
@@ -291,6 +388,18 @@ pub fn deliver_pending_message(
             }),
         )?;
     }
+    #[cfg(test)]
+    {
+        preparation_probe::BEFORE_CLAIM.with(|hook| {
+            if let Some(hook) = hook.borrow_mut().take() {
+                hook();
+            }
+        });
+        preparation_probe::COUNTS.with(|counts| {
+            let (prepare, project, claim) = counts.get();
+            counts.set((prepare, project, claim + 1));
+        });
+    }
     let attempt = if store.claim_for_delivery(message_id)? {
         message.delivery_attempts.saturating_add(1)
     } else {
@@ -1946,10 +2055,7 @@ fn merge_inject_readback_fields(
     };
     let inject_pane = target.and_then(inject_pane_id);
     if let Some(pane) = inject_pane {
-        obj.insert(
-            "inject_target_pane_id".to_string(),
-            serde_json::json!(pane),
-        );
+        obj.insert("inject_target_pane_id".to_string(), serde_json::json!(pane));
     }
     let resolved_pane = metadata.map(|meta| meta.target_pane_id.as_str());
     obj.insert(
@@ -2190,59 +2296,30 @@ pub fn deliver_pending_messages(
     };
     let mut delivered = Vec::new();
     for message_id in message_ids {
-        if let Some(message) = message_for_delivery(&store, &message_id)? {
-            let scoped_state;
-            let state = match message.owner_team_id.as_deref() {
-                Some(team) if !team.is_empty() => {
-                    match project_state_for_owner_team(
-                        workspace,
-                        team,
-                        state,
-                        Some(&store),
-                        Some(&message_id),
-                        Some(event_log),
-                    )? {
-                        OwnerTeamProjection::Projected { state, .. } => {
-                            scoped_state = state;
-                            &scoped_state
-                        }
-                        OwnerTeamProjection::Refused(outcome) => {
-                            let _ = event_log.write(
-                                "delivery.projection_refused",
-                                serde_json::json!({
-                                    "message_id": message_id.as_str(),
-                                    "owner_team_id": team,
-                                    "status": super::helpers::status_wire(outcome.status),
-                                    "verification": outcome.verification,
-                                    "reason": format!("{:?}", outcome.reason),
-                                }),
-                            );
-                            continue;
-                        }
-                    }
-                }
-                _ => state,
-            };
-            if recipient_is_busy(state, &message.recipient) {
-                event_log.write(
-                    "send.deferred_busy",
-                    serde_json::json!({
-                        "message_id": message_id,
-                        "sender": message.sender,
-                        "recipient": message.recipient,
-                        "reason": "recipient_busy",
-                    }),
-                )?;
-                continue;
-            }
-        }
-        let outcome = match deliver_pending_message(
+        let Some(message) = message_for_delivery(&store, &message_id)? else {
+            continue;
+        };
+        let prepared = match prepare_message_state(
+            workspace,
+            &store,
+            &message_id,
+            event_log,
+            state,
+            &message,
+            true,
+        )? {
+            Ok(prepared) => prepared,
+            Err(_) => continue,
+        };
+        let outcome = match deliver_prepared_message(
             workspace,
             &store,
             transport,
             &message_id,
             event_log,
             state,
+            message,
+            prepared,
         ) {
             Ok(outcome) => outcome,
             Err(error) => {
@@ -2963,6 +3040,11 @@ fn project_state_for_owner_team(
     message_id: Option<&str>,
     event_log: Option<&EventLog>,
 ) -> Result<OwnerTeamProjection, MessagingError> {
+    #[cfg(test)]
+    preparation_probe::COUNTS.with(|counts| {
+        let (prepare, project, claim) = counts.get();
+        counts.set((prepare, project + 1, claim));
+    });
     let raw = crate::state::persist::load_runtime_state(workspace)?;
     let fallback_has_teams = fallback
         .get("teams")

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

@@ -556,3 +556,130 @@ impl Transport for RecordingTransport {
         Ok(AttachOutcome::Attached)
     }
 }
+
+#[test]
+fn resource188_batch_and_public_single_prepare_once_and_keep_fresh_leader_load() {
+    use crate::messaging::delivery::preparation_probe::COUNTS;
+    for batch in [true, false] {
+        let case = Case::new(if batch { "188-batch" } else { "188-single" });
+        let transport = RecordingTransport::new("");
+        let message = case
+            .store
+            .create_message(
+                None,
+                "worker",
+                "leader",
+                "count",
+                None,
+                false,
+                Some("acceptance-team"),
+            )
+            .unwrap();
+        COUNTS.with(|counts| counts.set((0, 0, 0)));
+        if batch {
+            deliver_pending_messages(&case.workspace, &case.state, &transport, &case.event_log)
+                .unwrap();
+        } else {
+            deliver_pending_message(
+                &case.workspace,
+                &case.store,
+                &transport,
+                &message,
+                &case.event_log,
+                &case.state,
+            )
+            .unwrap();
+        }
+        assert_eq!(
+            COUNTS.with(|counts| counts.get()),
+            (1, 2, 1),
+            "one preparation, pre/post-claim projections, one claim"
+        );
+        assert_eq!(transport.inject_count(), 1);
+        assert_eq!(
+            case.message_status(&message),
+            "submitted_pending_acceptance"
+        );
+    }
+}
+
+#[test]
+fn resource188_busy_and_refused_candidates_prepare_once_without_claiming() {
+    use crate::messaging::delivery::preparation_probe::COUNTS;
+    let mut case = Case::new("188-busy");
+    case.state["agents"] = serde_json::json!({"worker": {"agent_id": "worker", "status": "busy"}});
+    case.state["teams"] =
+        serde_json::json!({"acceptance-team": {"agents": case.state["agents"].clone()}});
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let transport = RecordingTransport::new("");
+    let busy = case
+        .store
+        .create_message(
+            None,
+            "leader",
+            "worker",
+            "busy",
+            None,
+            false,
+            Some("acceptance-team"),
+        )
+        .unwrap();
+    let refused = case
+        .store
+        .create_message(
+            None,
+            "leader",
+            "worker",
+            "refuse",
+            None,
+            false,
+            Some("missing-team"),
+        )
+        .unwrap();
+    let before = case.message_status(&busy);
+    COUNTS.with(|counts| counts.set((0, 0, 0)));
+    deliver_pending_messages(&case.workspace, &case.state, &transport, &case.event_log).unwrap();
+    assert_eq!(COUNTS.with(|counts| counts.get()), (2, 2, 0));
+    assert_eq!(case.message_status(&busy), before);
+    assert_ne!(case.message_status(&refused), "delivered");
+    assert_eq!(transport.inject_count(), 0);
+    assert!(case.events().contains("send.deferred_busy"));
+    assert!(case.events().contains("delivery.projection_refused"));
+}
+
+#[test]
+fn resource188_receiver_revoked_between_prepare_and_claim_is_reloaded() {
+    use crate::messaging::delivery::preparation_probe::{BEFORE_CLAIM, COUNTS};
+    let case = Case::new("188-revoke");
+    let transport = RecordingTransport::new("");
+    let message = case
+        .store
+        .create_message(
+            None,
+            "worker",
+            "leader",
+            "race",
+            None,
+            false,
+            Some("acceptance-team"),
+        )
+        .unwrap();
+    let workspace = case.workspace.clone();
+    BEFORE_CLAIM.with(|hook| {
+        *hook.borrow_mut() = Some(Box::new(move || {
+            let mut latest = crate::state::persist::load_runtime_state(&workspace).unwrap();
+            latest["leader_receiver"]["status"] = serde_json::json!("rebind_required");
+            crate::state::persist::save_runtime_state(&workspace, &latest).unwrap();
+        }))
+    });
+    COUNTS.with(|counts| counts.set((0, 0, 0)));
+    deliver_pending_messages(&case.workspace, &case.state, &transport, &case.event_log).unwrap();
+    assert_eq!(COUNTS.with(|counts| counts.get()), (1, 2, 1));
+    assert_eq!(
+        transport.inject_count(),
+        0,
+        "must not use the prepared attached receiver after revoke"
+    );
+    assert_eq!(case.message_status(&message), "failed");
+    assert!(case.events().contains("leader_receiver.delivery_blocked"));
+}

package/crates/team-agent/src/provider/session_scan/common/tests.rs

@@ -1,5 +1,50 @@
 use super::*;
 
+#[derive(Default, Debug)]
+struct EnumerationCounts {
+    directories: Vec<PathBuf>,
+    entries: usize,
+    following_metadata: usize,
+}
+
+thread_local! {
+    static ENUMERATION: std::cell::RefCell<EnumerationCounts> =
+        std::cell::RefCell::new(EnumerationCounts::default());
+}
+
+pub(super) fn record_directory_read(path: &Path) {
+    ENUMERATION.with(|counts| counts.borrow_mut().directories.push(path.to_path_buf()));
+}
+
+pub(super) fn record_entry() {
+    ENUMERATION.with(|counts| counts.borrow_mut().entries += 1);
+}
+
+pub(super) fn record_following_metadata() {
+    ENUMERATION.with(|counts| counts.borrow_mut().following_metadata += 1);
+}
+
+fn take_counts() -> EnumerationCounts {
+    ENUMERATION.with(|counts| std::mem::take(&mut *counts.borrow_mut()))
+}
+
+// The previous traversal boundary, run only on the synthetic fixture. Count
+// explicit metadata calls, not inferred OS syscalls or elapsed-time thresholds.
+fn legacy_enumeration_counts(dir: &Path, depth: usize, counts: &mut EnumerationCounts) {
+    if depth > 4 {
+        return;
+    }
+    counts.directories.push(dir.to_path_buf());
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let path = entry.unwrap().path();
+        counts.entries += 1;
+        counts.following_metadata += 1;
+        if path.is_dir() {
+            legacy_enumeration_counts(&path, depth + 1, counts);
+        }
+    }
+}
+
 fn temp_dir(name: &str) -> PathBuf {
     static N: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
     let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
@@ -110,3 +155,162 @@ fn codex_prompt_worker_identity_mismatch_is_rejected_for_that_agent() {
     assert!(candidates.is_empty());
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn repeated_wide_directory_scans_remove_leaf_metadata_without_hiding_new_files() {
+    let dir = temp_dir("wide-discovery");
+    for group in 0..4 {
+        let child = dir.join("source").join(format!("group-{group}"));
+        std::fs::create_dir_all(&child).unwrap();
+        for index in 0..128 {
+            std::fs::write(child.join(format!("code-{index}.rs")), "").unwrap();
+        }
+    }
+    for _ in 0..2 {
+        let mut before = EnumerationCounts::default();
+        legacy_enumeration_counts(&dir, 0, &mut before);
+        assert_eq!((before.directories.len(), before.entries), (6, 517));
+        assert_eq!(before.following_metadata, 517);
+
+        take_counts();
+        let mut candidates = Vec::new();
+        collect_candidate_files(&dir, "worker", 0, false, None, &mut candidates).unwrap();
+        let after = take_counts();
+        assert!(candidates.is_empty());
+        assert_eq!((after.directories.len(), after.entries), (6, 517));
+        assert_eq!(after.following_metadata, 0);
+    }
+    // No .team subtree is needed to reproduce the redundant metadata work.
+    // A negative scan must not suppress a later file in the same nested cwd.
+    let rollout = dir.join("source/group-3/rollout-worker.jsonl");
+    write_codex_rollout(&rollout, &dir, "late-worker", "worker");
+    let mut candidates = Vec::new();
+    collect_candidate_files(&dir, "worker", 0, false, None, &mut candidates).unwrap();
+    let after = take_counts();
+    assert_eq!((after.directories.len(), after.entries), (6, 518));
+    assert_eq!(after.following_metadata, 0);
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(candidates[0].path, rollout);
+    assert!(!candidates[0].requires_cwd_match);
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn team_subtrees_are_pruned_before_enumeration_but_claude_root_and_ancestors_survive() {
+    let dir = temp_dir("team-pruning");
+    let allowed = dir.join(".team/runtime/claude/projects");
+    let owned = allowed.join("cwd/owned.jsonl");
+    let unrelated = dir.join(".team/artifacts/deep/ignored.jsonl");
+    let sibling = dir.join(".team/runtime/other/ignored.jsonl");
+    for path in [&owned, &unrelated, &sibling] {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(path, "{}").unwrap();
+    }
+
+    let mut before = EnumerationCounts::default();
+    legacy_enumeration_counts(&dir, 0, &mut before);
+    assert_eq!((before.directories.len(), before.entries), (8, 10));
+    assert_eq!(before.following_metadata, 10);
+
+    take_counts();
+    let mut candidates = Vec::new();
+    collect_candidate_files(&dir, "worker", 0, false, None, &mut candidates).unwrap();
+    let counts = take_counts();
+    assert!(candidates.is_empty());
+    assert_eq!(counts.directories, vec![dir.clone()]);
+    assert_eq!((counts.entries, counts.following_metadata), (1, 0));
+
+    // Starting at the runtime ancestor must reach the explicit Claude root,
+    // while siblings inside .team remain excluded before read_dir.
+    let ancestor = dir.join(".team");
+    collect_candidate_files(&ancestor, "worker", 0, true, Some(&allowed), &mut candidates)
+        .unwrap();
+    let counts = take_counts();
+    assert_eq!(counts.directories.len(), 5);
+    assert_eq!((counts.entries, counts.following_metadata), (7, 0));
+    assert!(!counts
+        .directories
+        .iter()
+        .any(|path| path.starts_with(dir.join(".team/artifacts"))));
+    assert!(!counts
+        .directories
+        .iter()
+        .any(|path| path.starts_with(dir.join(".team/runtime/other"))));
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(candidates[0].path, owned);
+    assert!(candidates[0].requires_cwd_match);
+
+    candidates.clear();
+    collect_optional_candidate_files(&allowed, "worker", Some(&allowed), &mut candidates)
+        .unwrap();
+    assert_eq!(take_counts().directories.len(), 2);
+    assert_eq!(candidates.len(), 1);
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+fn traversal_keeps_depth_limit_and_required_root_errors() {
+    let dir = temp_dir("depth-limit");
+    let at_limit = dir.join("one/two/three/four/at-limit.jsonl");
+    let beyond = dir.join("one/two/three/four/five/beyond.jsonl");
+    std::fs::create_dir_all(beyond.parent().unwrap()).unwrap();
+    std::fs::write(&at_limit, "{}").unwrap();
+    std::fs::write(&beyond, "{}").unwrap();
+    take_counts();
+    let mut candidates = Vec::new();
+    collect_candidate_files(&dir, "worker", 0, false, None, &mut candidates).unwrap();
+    let counts = take_counts();
+    assert_eq!(counts.directories.len(), 5);
+    assert_eq!(counts.following_metadata, 0);
+    assert_eq!(candidates.len(), 1);
+    assert_eq!(candidates[0].path, at_limit);
+    assert!(collect_candidate_files(
+        &dir.join("missing"),
+        "worker",
+        0,
+        false,
+        None,
+        &mut Vec::new()
+    )
+    .is_err());
+    assert!(collect_optional_candidate_files(
+        &dir.join("missing"),
+        "worker",
+        None,
+        &mut Vec::new()
+    )
+    .is_ok());
+    std::fs::remove_dir_all(dir).unwrap();
+}
+
+#[test]
+#[cfg(unix)]
+fn symlink_files_directories_and_cycles_keep_following_metadata_and_depth_semantics() {
+    use std::os::unix::fs::symlink;
+    let dir = temp_dir("symlink-discovery");
+    let target = dir.join("target");
+    std::fs::create_dir(&target).unwrap();
+    std::fs::write(target.join("session.jsonl"), "{}").unwrap();
+    symlink(&target, dir.join("linked-dir")).unwrap();
+    symlink(target.join("session.jsonl"), dir.join("linked-file.jsonl")).unwrap();
+    symlink(dir.join("absent"), dir.join("dangling.jsonl")).unwrap();
+    symlink(&target, target.join("cycle")).unwrap();
+    take_counts();
+    let mut candidates = Vec::new();
+    collect_candidate_files(&dir, "worker", 0, false, None, &mut candidates).unwrap();
+    let counts = take_counts();
+    assert_eq!(counts.directories.len(), 9);
+    assert_eq!(counts.entries, 20);
+    assert_eq!(counts.following_metadata, 11);
+    assert_eq!(candidates.len(), 10);
+    assert!(candidates
+        .iter()
+        .any(|item| item.path == dir.join("linked-file.jsonl")));
+    assert!(candidates
+        .iter()
+        .any(|item| item.path == dir.join("linked-dir/session.jsonl")));
+    assert!(candidates
+        .iter()
+        .any(|item| item.path == dir.join("dangling.jsonl")));
+    std::fs::remove_dir_all(dir).unwrap();
+}

package/crates/team-agent/src/provider/session_scan/common.rs

@@ -441,9 +441,11 @@ fn collect_candidate_files(
     allowed_team_root: Option<&Path>,
     out: &mut Vec<SessionCandidate>,
 ) -> Result<(), ProviderError> {
-    if depth > 4 {
+    if depth > 4 || !may_traverse_session_directory(dir, allowed_team_root) {
         return Ok(());
     }
+    #[cfg(test)]
+    tests::record_directory_read(dir);
     let entries = match std::fs::read_dir(dir) {
         Ok(entries) => entries,
         Err(e) if depth == 0 => return Err(ProviderError::Io(format!("{}: {e}", dir.display()))),
@@ -453,8 +455,23 @@ fn collect_candidate_files(
         let Ok(entry) = entry else {
             continue;
         };
+        #[cfg(test)]
+        tests::record_entry();
         let path = entry.path();
-        if path.is_dir() {
+        if !may_traverse_session_directory(&path, allowed_team_root) {
+            continue;
+        }
+        // read_dir already supplies the type for ordinary entries. Only links
+        // (or an unavailable type) need the old, following metadata lookup.
+        let is_dir = match entry.file_type() {
+            Ok(kind) if !kind.is_symlink() => kind.is_dir(),
+            _ => {
+                #[cfg(test)]
+                tests::record_following_metadata();
+                path.is_dir()
+            }
+        };
+        if is_dir {
             collect_candidate_files(
                 &path,
                 agent_id,
@@ -473,6 +490,11 @@ fn collect_candidate_files(
     Ok(())
 }
 
+fn may_traverse_session_directory(path: &Path, allowed_team_root: Option<&Path>) -> bool {
+    !path_is_under_team_runtime(path)
+        || allowed_team_root.is_some_and(|root| path.starts_with(root) || root.starts_with(path))
+}
+
 fn looks_like_session_file(path: &Path, agent_id: &str, allowed_team_root: Option<&Path>) -> bool {
     if path_is_under_team_runtime(path)
         && !allowed_team_root.is_some_and(|root| path.starts_with(root))