@team-agent/installer 0.3.0 → 0.3.2

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

@@ -10,7 +10,7 @@ use crate::model::ids::{OwnerEpoch, TaskId};
 use crate::transport::Transport;
 
 use super::helpers::MessageStatusShadow;
-use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
+use super::{DeliveryOutcome, DeliveryStatus, MessagingError};
 
 /// `_send_to_leader_receiver` (`leader.py:69`) — **N31/N32 funnel primitive**:所有 leader-bound
 /// caller(send_message(to=leader) / report_result / request_human / idle reminder /
@@ -105,40 +105,6 @@ pub fn send_to_leader_receiver(
             "result_id": result_id,
         }),
     )?;
-    // I-4: unbound leader pane → rebind_required (not the legacy diagnostic success).
-    // The row IS persisted (caller / rebind audit / future replay need the message_id),
-    // but marked `failed` so `deliver_pending_messages` does NOT pick it up — pane stays
-    // untouched, ok=false, channel=rebind_required. #231 auto-reclaim's
-    // requeue_after_claim_leader flips this row back to `accepted` after rebind, and
-    // deliver_pending replays it through the same pipeline (same message_id, exactly once).
-    let pane_attached = leader_pane_id(state)
-        .filter(|pane_id| leader_pane_is_live(workspace, pane_id))
-        .is_some();
-    if !pane_attached {
-        let _ = store.mark(&message_id, "failed", Some("leader_not_attached"));
-        event_log.write(
-            "leader_receiver.delivery_blocked",
-            serde_json::json!({
-                "message_id": message_id,
-                "sender": sender,
-                "leader_id": leader_id,
-                "owner_team_id": owner_team,
-                "reason": "leader_not_attached",
-                "channel": "rebind_required",
-                "action": "run team-agent claim-leader or team-agent takeover",
-            }),
-        )?;
-        return Ok(DeliveryOutcome {
-            ok: false,
-            status: DeliveryStatus::Blocked,
-            message_status: MessageStatusShadow("blocked".to_string()),
-            message_id: Some(message_id),
-            verification: None,
-            stage: None,
-            reason: Some(DeliveryRefusal::LeaderNotAttached),
-            channel: Some("rebind_required".to_string()),
-        });
-    }
     event_log.write(
         "leader_receiver.queued",
         serde_json::json!({
@@ -221,6 +187,15 @@ pub fn claim_leader_receiver(
         copy_candidate_field(receiver, candidate, "pane_id");
         copy_candidate_field(receiver, candidate, "provider");
         copy_candidate_field(receiver, candidate, "leader_session_uuid");
+        if let Some(socket) = candidate
+            .get("tmux_socket")
+            .and_then(Value::as_str)
+            .filter(|socket| std::path::Path::new(socket).is_absolute())
+            .map(str::to_string)
+            .or_else(crate::tmux_backend::socket_name_from_tmux_env)
+        {
+            receiver.insert("tmux_socket".to_string(), serde_json::json!(socket));
+        }
     }
     crate::state::persist::save_runtime_state(workspace, state)?;
     event_log.write(
@@ -310,10 +285,17 @@ fn leader_session_uuid(state: &Value) -> Option<&str> {
 
 pub(crate) fn leader_pane_bound_but_not_live(workspace: &Path, state: &Value) -> bool {
     leader_pane_id(state)
-        .is_some_and(|pane_id| !leader_pane_is_live(workspace, pane_id))
+        .is_some_and(|pane_id| !leader_pane_is_live(workspace, state, pane_id))
 }
 
-fn leader_pane_is_live(workspace: &Path, pane_id: &str) -> bool {
+fn leader_pane_is_live(workspace: &Path, state: &Value, pane_id: &str) -> bool {
+    if let Some(socket) = leader_tmux_socket(state) {
+        return crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket)
+            .list_targets()
+            .unwrap_or_default()
+            .iter()
+            .any(|target| target.pane_id.as_str() == pane_id);
+    }
     let mut targets = crate::tmux_backend::TmuxBackend::for_workspace(workspace)
         .list_targets()
         .unwrap_or_default();
@@ -329,6 +311,13 @@ fn leader_pane_id(state: &Value) -> Option<&str> {
     leader_record_field(state, "pane_id").and_then(Value::as_str)
 }
 
+fn leader_tmux_socket(state: &Value) -> Option<&str> {
+    leader_record_field(state, "tmux_socket")
+        .and_then(Value::as_str)
+        .filter(|socket| !socket.is_empty())
+        .filter(|socket| std::path::Path::new(socket).is_absolute())
+}
+
 fn copy_candidate_field(
     out: &mut serde_json::Map<String, Value>,
     candidate: &Value,

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

@@ -86,7 +86,7 @@ pub use leader_receiver::{
     claim_leader_receiver, mirror_peer_message_to_leader, send_to_leader_receiver,
 };
 pub use peers::allow_peer_talk;
-pub use results::{collect, collect_results_and_notify_watchers, report_result};
+pub use results::{collect, collect_for_team, collect_results_and_notify_watchers, report_result};
 pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events, stuck_cancel, stuck_list};
 pub use selftest::{evaluate_idle_behavior, run_comms_selftest, CommsSelftestDriver};
 pub use send::{apply_worker_sender_bypass, send_message, session_drift_refusal, MessageTarget, SendOptions};

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

@@ -10,6 +10,7 @@ use crate::message_store::MessageStore;
 use super::helpers::{next_result_id, required_str, validate_result_envelope};
 use super::types::SEND_RETRY_MAX_ATTEMPTS;
 use crate::model::ids::TaskId;
+use crate::state::projection::OwnerTeamResolution;
 use super::watchers::retry_result_deliveries;
 use super::MessagingError;
 
@@ -19,26 +20,65 @@ pub fn collect(
     workspace: &Path,
     result_file: Option<&Path>,
     ensure_coordinator: bool,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, None)
+}
+
+pub fn collect_for_team(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, owner_team_id)
+}
+
+fn collect_scoped(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     let _ = ensure_coordinator;
     let paths = collect_paths(workspace)?;
-    let spec_path = paths.spec_workspace.join("team.spec.yaml");
+    let log = EventLog::new(&paths.run_workspace);
+    let resolved_owner_team_id = match owner_team_id.filter(|team| !team.is_empty()) {
+        Some(team) => Some(resolve_owner_team_for_read(&paths.run_workspace, team, Some(&log))?),
+        None => None,
+    };
+    let owner_team_id = resolved_owner_team_id.as_deref();
+    let mut state = match owner_team_id {
+        Some(team) => crate::state::projection::select_runtime_state(&paths.run_workspace, Some(team))?,
+        None => crate::state::persist::load_runtime_state(&paths.run_workspace)?,
+    };
+    let spec_workspace = owner_team_id
+        .and_then(|_| state_spec_workspace_from_value(&state))
+        .unwrap_or_else(|| paths.spec_workspace.clone());
+    let spec_path = spec_workspace.join("team.spec.yaml");
     if !spec_path.exists() {
         return Err(MessagingError::Validation(format!("Cannot read {}", spec_path.display())));
     }
     let store = MessageStore::open(&paths.run_workspace)?;
     let conn = crate::db::schema::open_db(store.db_path())?;
     if let Some(path) = result_file {
-        ingest_result_file(&conn, path)?;
+        ingest_result_file(&conn, path, owner_team_id)?;
     }
-    let mut stmt = conn.prepare(
-        "select result_id, task_id, agent_id, envelope, status, created_at
-         from results
-         where status not in ('collected', 'invalid')
-         order by created_at, result_id",
-    )?;
-    let rows = stmt
-        .query_map([], |row| {
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             order by created_at, result_id"
+        }
+        None => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid')
+             order by created_at, result_id"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| {
             Ok(StoredResult {
                 result_id: row.get(0)?,
                 task_id: row.get(1)?,
@@ -47,16 +87,18 @@ pub fn collect(
                 status: row.get(4)?,
                 created_at: row.get(5)?,
             })
-        })?
+        };
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?
         .collect::<Result<Vec<_>, _>>()?;
     drop(stmt);
 
-    let mut state = crate::state::persist::load_runtime_state(&paths.run_workspace)?;
     let mut collected = Vec::new();
     let mut collected_results = Vec::new();
     let mut invalid_results = Vec::new();
     let mut state_dirty = false;
-    let log = EventLog::new(&paths.run_workspace);
     for row in rows {
         let envelope: serde_json::Value = match serde_json::from_str(&row.envelope) {
             Ok(envelope) => envelope,
@@ -83,7 +125,7 @@ pub fn collect(
         }
         let scope = if task_exists(&state, &row.task_id) {
             "task"
-        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id)? {
+        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id, owner_team_id)? {
             "message"
         } else {
             record_invalid_result(
@@ -95,10 +137,20 @@ pub fn collect(
             )?;
             continue;
         };
-        conn.execute(
-            "update results set status = 'collected' where result_id = ?1",
-            params![row.result_id.as_str()],
-        )?;
+        match owner_team_id {
+            Some(team) => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1 and owner_team_id = ?2",
+                    params![row.result_id.as_str(), team],
+                )?;
+            }
+            None => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1",
+                    params![row.result_id.as_str()],
+                )?;
+            }
+        }
         if scope == "task" {
             mark_task_done(&mut state, &row.task_id, &row.result_id);
             state_dirty = true;
@@ -129,9 +181,13 @@ pub fn collect(
         collected_results.push(summary);
     }
     if state_dirty {
-        crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        if owner_team_id.is_some() {
+            crate::state::projection::save_team_scoped_state(&paths.run_workspace, &state)?;
+        } else {
+            crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        }
     }
-    let counts = result_counts(&conn)?;
+    let counts = result_counts(&conn, owner_team_id)?;
     Ok(serde_json::json!({
         "ok": invalid_results.is_empty(),
         "collected": collected,
@@ -139,7 +195,7 @@ pub fn collect(
         "delivered_messages": [],
         "invalid_results": invalid_results,
         "results": counts,
-        "state_file": paths.spec_workspace.join("team_state.md").to_string_lossy().to_string(),
+        "state_file": spec_workspace.join("team_state.md").to_string_lossy().to_string(),
         "coordinator": {
             "ok": false,
             "status": "not_required",
@@ -147,12 +203,48 @@ pub fn collect(
     }))
 }
 
+fn resolve_owner_team_for_read(
+    workspace: &Path,
+    requested: &str,
+    event_log: Option<&EventLog>,
+) -> Result<String, MessagingError> {
+    let state = crate::state::persist::load_runtime_state(workspace)?;
+    match crate::state::projection::resolve_owner_team_id(&state, requested) {
+        OwnerTeamResolution::Canonical(canonical) => Ok(canonical),
+        OwnerTeamResolution::LegacyAlias { requested, canonical } => {
+            crate::messaging::delivery::normalize_owner_team_id_rows(
+                workspace,
+                &requested,
+                &canonical,
+                None,
+                event_log,
+            )?;
+            Ok(canonical)
+        }
+        OwnerTeamResolution::Unresolved { requested } => {
+            Err(MessagingError::Routing(format!("owner_team_unresolved: {requested}")))
+        }
+        OwnerTeamResolution::Ambiguous { requested, matches } => {
+            Err(MessagingError::Routing(format!(
+                "owner_team_ambiguous: {requested} matches {}",
+                matches.join(",")
+            )))
+        }
+    }
+}
+
 struct CollectPaths {
     run_workspace: PathBuf,
     spec_workspace: PathBuf,
 }
 
 fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
+    if collect_input_has_no_local_team_context(workspace) {
+        return Ok(CollectPaths {
+            run_workspace: workspace.to_path_buf(),
+            spec_workspace: workspace.to_path_buf(),
+        });
+    }
     let run_workspace = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| MessagingError::Routing(e.to_string()))?;
     let spec_workspace = if workspace.join("team.spec.yaml").exists() {
@@ -168,8 +260,24 @@ fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
     })
 }
 
+fn collect_input_has_no_local_team_context(workspace: &Path) -> bool {
+    !workspace.join("team.spec.yaml").exists()
+        && !workspace.join(".team").exists()
+        && !crate::state::persist::runtime_state_path(workspace).exists()
+        && workspace.file_name().and_then(|s| s.to_str()) != Some(".team")
+        && workspace
+            .parent()
+            .and_then(|p| p.file_name())
+            .and_then(|s| s.to_str())
+            != Some(".team")
+}
+
 fn state_spec_workspace(run_workspace: &Path) -> Option<PathBuf> {
     let state = crate::state::persist::load_runtime_state(run_workspace).ok()?;
+    state_spec_workspace_from_value(&state)
+}
+
+fn state_spec_workspace_from_value(state: &serde_json::Value) -> Option<PathBuf> {
     if let Some(spec_path) = state.get("spec_path").and_then(serde_json::Value::as_str) {
         return PathBuf::from(spec_path).parent().map(Path::to_path_buf);
     }
@@ -200,7 +308,11 @@ fn record_invalid_result(
     Ok(())
 }
 
-fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), MessagingError> {
+fn ingest_result_file(
+    conn: &rusqlite::Connection,
+    path: &Path,
+    owner_team_id: Option<&str>,
+) -> Result<(), MessagingError> {
     let raw = std::fs::read_to_string(path)?;
     let mut envelope: serde_json::Value = serde_json::from_str(&raw)?;
     validate_result_envelope(&envelope)?;
@@ -226,7 +338,7 @@ fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), Me
         agent_id,
         &envelope.to_string(),
         status,
-        None,
+        owner_team_id,
     )?;
     Ok(())
 }
@@ -273,39 +385,55 @@ fn is_message_scoped_result(
     conn: &rusqlite::Connection,
     task_id: &str,
     agent_id: &str,
+    owner_team_id: Option<&str>,
 ) -> Result<bool, MessagingError> {
     if !task_id.starts_with("msg_") {
         return Ok(false);
     }
-    let count: i64 = conn.query_row(
-        "select count(*) from messages where message_id = ?1 and recipient = ?2",
-        params![task_id, agent_id],
-        |row| row.get(0),
-    )?;
+    let count: i64 = match owner_team_id {
+        Some(team) => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2 and owner_team_id = ?3",
+            params![task_id, agent_id, team],
+            |row| row.get(0),
+        )?,
+        None => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2",
+            params![task_id, agent_id],
+            |row| row.get(0),
+        )?,
+    };
     Ok(count > 0)
 }
 
-fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, MessagingError> {
-    let total: i64 = conn.query_row("select count(*) from results", [], |row| row.get(0))?;
-    let collected: i64 = conn.query_row(
-        "select count(*) from results where status = 'collected'",
-        [],
-        |row| row.get(0),
-    )?;
-    let invalid: i64 = conn.query_row(
-        "select count(*) from results where status = 'invalid'",
-        [],
-        |row| row.get(0),
-    )?;
+fn result_counts(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    let total: i64 = count_results(conn, owner_team_id, None)?;
+    let collected: i64 = count_results(conn, owner_team_id, Some("collected"))?;
+    let invalid: i64 = count_results(conn, owner_team_id, Some("invalid"))?;
     let uncollected = total - collected - invalid;
     let mut by_status = serde_json::Map::new();
-    let mut stmt = conn.prepare(
-        "select status, count(*) from results
-         where status not in ('collected', 'invalid')
-         group by status
-         order by status",
-    )?;
-    let rows = stmt.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)))?;
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             group by status
+             order by status"
+        }
+        None => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid')
+             group by status
+             order by status"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?));
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?;
     for row in rows {
         let (status, count) = row?;
         by_status.insert(status, serde_json::Value::Number(count.into()));
@@ -319,6 +447,31 @@ fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, Messa
     }))
 }
 
+fn count_results(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+    status: Option<&str>,
+) -> Result<i64, MessagingError> {
+    match (owner_team_id, status) {
+        (Some(team), Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1 and status = ?2",
+            params![team, status],
+            |row| row.get(0),
+        )?),
+        (Some(team), None) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1",
+            params![team],
+            |row| row.get(0),
+        )?),
+        (None, Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where status = ?1",
+            params![status],
+            |row| row.get(0),
+        )?),
+        (None, None) => Ok(conn.query_row("select count(*) from results", [], |row| row.get(0))?),
+    }
+}
+
 /// `report_result` (`results.py:191`):worker 报结果 —— 校验 envelope、存 result、ack 任务消息、
 /// **排队** send 事件通知 leader、推进 orchestrator (软依赖,失败仅记 `orchestrator.advance_skipped`)。
 /// MCP `report_result` 工具调。
@@ -394,7 +547,7 @@ pub fn report_result(
     let content = format_report_result_notification(&result_id, task_id, agent_id, status, envelope);
     let state = crate::state::persist::load_runtime_state(workspace).unwrap_or(serde_json::json!({}));
     let event_log = EventLog::new(workspace);
-    let outcome = super::leader_receiver::send_to_leader_receiver(
+    let mut outcome = super::leader_receiver::send_to_leader_receiver(
         workspace,
         &state,
         "leader",
@@ -405,10 +558,26 @@ pub fn report_result(
         Some(&result_id),
         &event_log,
     )?;
+    if matches!(outcome.status, crate::messaging::DeliveryStatus::Queued) {
+        if let Some(message_id) = outcome.message_id.clone() {
+            let store = MessageStore::open(workspace)?;
+            let transport = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+            outcome = super::delivery::deliver_pending_message(
+                workspace,
+                &store,
+                &transport,
+                &message_id,
+                &event_log,
+                &state,
+            )?;
+        }
+    }
     let leader_notified = outcome.ok;
     let notification_status_wire = if outcome.ok {
         "delivered"
-    } else if matches!(outcome.status, crate::messaging::DeliveryStatus::Blocked) {
+    } else if outcome.channel.as_deref() == Some("rebind_required")
+        || matches!(outcome.status, crate::messaging::DeliveryStatus::Blocked)
+    {
         "rebind_required"
     } else {
         "refused"

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

@@ -8,7 +8,7 @@ use crate::model::enums::PaneLiveness;
 use crate::transport::{PaneId, Transport};
 
 use super::helpers::{status_wire, MessageStatusShadow};
-use super::leader_receiver::{leader_pane_bound_but_not_live, send_to_leader_receiver};
+use super::leader_receiver::send_to_leader_receiver;
 use super::{DeliveryOutcome, DeliveryRefusal, DeliveryStatus, MessagingError};
 
 /// 发件目标:单 target / 广播 `*` / 扇出 list (`send.py:36` `target: str|list[str]|None`)。
@@ -86,25 +86,9 @@ pub fn send_message(
         .map(|team| crate::state::projection::project_top_level_view(&raw_state, team.as_str()))
         .unwrap_or_else(|| raw_state.clone());
     backfill_leader_binding_for_delivery_view(&mut state, &raw_state);
-    let target_is_leader = matches!(target, MessageTarget::Single(target) if target == "leader");
-    if target_is_leader
-        && sender_is_leader(&state, &opts.sender)
-        && leader_pane_bound_but_not_live(workspace, &state)
-    {
-        event_log.write(
-            "leader_receiver.delivery_blocked",
-            serde_json::json!({
-                "sender": opts.sender,
-                "reason": "leader_not_attached",
-                "channel": "rebind_required",
-                "action": "run team-agent claim-leader or team-agent takeover",
-            }),
-        )?;
-        return Ok(rebind_required_outcome(None));
-    }
     let recipient = match target {
         MessageTarget::Single(target) if target == "leader" => {
-            return send_to_leader_receiver(
+            let outcome = send_to_leader_receiver(
                 workspace,
                 &state,
                 "leader",
@@ -114,7 +98,19 @@ pub fn send_message(
                 opts.requires_ack,
                 None,
                 &event_log,
-            );
+            )?;
+            if matches!(outcome.status, DeliveryStatus::Queued) && owner_pane_is_dead(&state) {
+                if let Some(message_id) = outcome.message_id.clone() {
+                    let team_key = owner_gate_hint_team_key(&state);
+                    if !explicit_claim_applied(workspace, &team_key, "") {
+                        return Ok(rebind_required_outcome_with_verification(
+                            Some(message_id),
+                            format!("team-agent claim-leader --team {team_key}"),
+                        ));
+                    }
+                }
+            }
+            return Ok(outcome);
         }
         MessageTarget::Single(target) if target.is_empty() => {
             return Ok(refused_outcome(DeliveryRefusal::UnknownRecipient));