@team-agent/installer 0.3.4 → 0.3.5

package/crates/team-agent/src/message_store.rs

@@ -320,6 +320,54 @@ impl MessageStore {
         Ok(rows.into_iter().rev().collect())
     }
 
+    /// `latest_results` (`core.py:458-471`): newest non-invalid result rows, oldest
+    /// first (Python fetches `created_at desc limit ?` then reverses).
+    pub fn latest_results(
+        &self,
+        limit: usize,
+        owner_team_id: Option<&str>,
+    ) -> Result<Vec<serde_json::Value>, MessageStoreError> {
+        let conn = crate::db::schema::open_db(&self.path)?;
+        let limit = i64::try_from(limit).unwrap_or(i64::MAX);
+        let sql = match owner_team_id {
+            Some(_) => {
+                "select owner_team_id, result_id, task_id, agent_id, envelope, status, created_at
+                 from results
+                 where status != 'invalid' and owner_team_id = ?2
+                 order by created_at desc
+                 limit ?1"
+            }
+            None => {
+                "select owner_team_id, result_id, task_id, agent_id, envelope, status, created_at
+                 from results
+                 where status != 'invalid'
+                 order by created_at desc
+                 limit ?1"
+            }
+        };
+        let mut stmt = conn.prepare(sql)?;
+        let map_row = |row: &rusqlite::Row<'_>| {
+            Ok(serde_json::json!({
+                "owner_team_id": row.get::<_, Option<String>>(0)?,
+                "result_id": row.get::<_, String>(1)?,
+                "task_id": row.get::<_, Option<String>>(2)?,
+                "agent_id": row.get::<_, Option<String>>(3)?,
+                "envelope": row.get::<_, Option<String>>(4)?,
+                "status": row.get::<_, Option<String>>(5)?,
+                "created_at": row.get::<_, Option<String>>(6)?,
+            }))
+        };
+        let rows = match owner_team_id {
+            Some(team) => stmt
+                .query_map(params![limit, team], map_row)?
+                .collect::<Result<Vec<_>, _>>()?,
+            None => stmt
+                .query_map(params![limit], map_row)?
+                .collect::<Result<Vec<_>, _>>()?,
+        };
+        Ok(rows.into_iter().rev().collect())
+    }
+
     /// Allow direct peer messages in both directions. Golden stores `(a,b)` and
     /// `(b,a)` so either sender/recipient lookup can use a single ordered key.
     pub fn allow_peer(&self, a: &str, b: &str) -> Result<(), MessageStoreError> {
@@ -410,6 +458,38 @@ fn row_to_message_value(row: &rusqlite::Row<'_>) -> rusqlite::Result<serde_json:
     }))
 }
 
+/// `result_summary_from_row`(`status/queries.py:92-106`):解析 result 行的 envelope,
+/// 产出 status/watch 共用的 result 摘要;envelope 坏/非对象 → `None`。
+pub fn result_summary_from_row(row: &serde_json::Value) -> Option<serde_json::Value> {
+    let envelope = match row.get("envelope") {
+        Some(serde_json::Value::String(text)) => {
+            serde_json::from_str::<serde_json::Value>(text).ok()?
+        }
+        Some(value @ serde_json::Value::Object(_)) => value.clone(),
+        _ => return None,
+    };
+    if !envelope.is_object() {
+        return None;
+    }
+    // Python `envelope.get(k) or row.get(k)` — falsy (null/empty) falls through to the row.
+    let pick = |key: &str| {
+        envelope
+            .get(key)
+            .filter(|v| !v.is_null() && v.as_str() != Some(""))
+            .or_else(|| row.get(key))
+            .cloned()
+            .unwrap_or(serde_json::Value::Null)
+    };
+    Some(serde_json::json!({
+        "result_id": row.get("result_id").cloned().unwrap_or(serde_json::Value::Null),
+        "task_id": pick("task_id"),
+        "agent_id": pick("agent_id"),
+        "status": pick("status"),
+        "summary": envelope.get("summary").cloned().unwrap_or(serde_json::Value::Null),
+        "created_at": row.get("created_at").cloned().unwrap_or(serde_json::Value::Null),
+    }))
+}
+
 fn now_ts() -> String {
     chrono::Utc::now().to_rfc3339()
 }

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

@@ -40,7 +40,6 @@ fn collect_scoped(
     ensure_coordinator: bool,
     owner_team_id: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
-    let _ = ensure_coordinator;
     let paths = collect_paths(workspace)?;
     let log = EventLog::new(&paths.run_workspace);
     let resolved_owner_team_id = match owner_team_id.filter(|team| !team.is_empty()) {
@@ -195,6 +194,13 @@ fn collect_scoped(
         }
     }
     let counts = result_counts(&conn, owner_team_id)?;
+    // results.py:157 — ensure_coordinator=true runs the REAL ensure step; the
+    // `{ok:false,status:"not_required"}` literal is ONLY the ensure=false branch.
+    let coordinator = if ensure_coordinator {
+        ensure_coordinator_after_collect(&paths.run_workspace, &state, &log)
+    } else {
+        serde_json::json!({"ok": false, "status": "not_required"})
+    };
     Ok(serde_json::json!({
         "ok": fatal_invalid_results == 0,
         "collected": collected,
@@ -203,13 +209,78 @@ fn collect_scoped(
         "invalid_results": invalid_results,
         "results": counts,
         "state_file": spec_workspace.join("team_state.md").to_string_lossy().to_string(),
-        "coordinator": {
-            "ok": false,
-            "status": "not_required",
-        },
+        "coordinator": coordinator,
     }))
 }
 
+/// `_ensure_coordinator_after_collect`(`results.py:176-184`)。
+fn ensure_coordinator_after_collect(
+    workspace: &Path,
+    state: &serde_json::Value,
+    log: &EventLog,
+) -> serde_json::Value {
+    if !coordinator_should_run(state) {
+        return serde_json::json!({"ok": false, "status": "not_required"});
+    }
+    let workspace_path = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
+    let coordinator = match crate::coordinator::start_coordinator(&workspace_path) {
+        Ok(report) => start_report_value(&report),
+        Err(e) => serde_json::json!({"ok": false, "status": "start_failed", "error": e.to_string()}),
+    };
+    let _ = log.write(
+        "collect.coordinator_checked",
+        serde_json::json!({"coordinator": coordinator.clone()}),
+    );
+    coordinator
+}
+
+/// `_coordinator_should_run`(`results.py:187-188`)。
+fn coordinator_should_run(state: &serde_json::Value) -> bool {
+    let has_session = state
+        .get("session_name")
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|s| !s.is_empty());
+    has_session || leader_receiver_is_direct(state.get("leader_receiver"))
+}
+
+/// `_leader_receiver_is_direct`(`messaging/leader.py:449-450`)。
+fn leader_receiver_is_direct(receiver: Option<&serde_json::Value>) -> bool {
+    receiver.is_some_and(|receiver| {
+        receiver.get("mode").and_then(serde_json::Value::as_str) == Some("direct_tmux")
+            && receiver
+                .get("pane_id")
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|pane| !pane.is_empty())
+    })
+}
+
+/// `start_coordinator` dict 形(`lifecycle.py:54/86/121` 的 JSON 面)。
+fn start_report_value(report: &crate::coordinator::StartReport) -> serde_json::Value {
+    let status = match report.status {
+        crate::coordinator::StartOutcome::AlreadyRunning => "already_running",
+        crate::coordinator::StartOutcome::RestartIncompatibleStopFailed => {
+            "restart_incompatible_stop_failed"
+        }
+        crate::coordinator::StartOutcome::SchemaIncompatible => "schema_incompatible",
+        crate::coordinator::StartOutcome::Started => "started",
+    };
+    let mut value = serde_json::json!({
+        "ok": report.ok,
+        "pid": report.pid.map(|p| p.get()),
+        "status": status,
+    });
+    if let Some(log) = &report.log {
+        value["log"] = serde_json::json!(log.to_string_lossy().to_string());
+    }
+    if let Some(error) = &report.schema_error {
+        value["schema_error"] = serde_json::json!(format!("{error:?}"));
+    }
+    if let Some(action) = &report.action {
+        value["action"] = serde_json::json!(action);
+    }
+    value
+}
+
 fn resolve_owner_team_for_read(
     workspace: &Path,
     requested: &str,

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

@@ -121,6 +121,8 @@ pub fn send_message(
             return fanout_send(workspace, &state, &recipients, content, opts, &event_log, "*");
         }
         MessageTarget::Fanout(recipients) if recipients.is_empty() => {
+            // swallow batch 3 ②: a failed send carries its reason (Python send error
+            // reason style) — "failed with no reason" is an unexplained exit.
             return Ok(DeliveryOutcome {
                 ok: false,
                 status: DeliveryStatus::Failed,
@@ -128,7 +130,7 @@ pub fn send_message(
                 message_id: None,
                 verification: None,
                 stage: None,
-                reason: None,
+                reason: Some(crate::messaging::DeliveryRefusal::EmptyTargetList),
                 channel: None,
             });
         }

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

@@ -39,7 +39,7 @@ pub enum DeliveryStatus {
 
 /// 投递/发件拒绝原因 (card §42)。Python 散裸字符串靠 `==` 比对易拼错;Rust 穷尽 enum。
 /// 值散落 `send.py`/`delivery.py`/`leader.py`/`session_drift.py`/`owner_gate`。
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum DeliveryRefusal {
     TargetNotInTeam,
@@ -62,6 +62,20 @@ pub enum DeliveryRefusal {
     /// is content, not a target. Distinct from `TargetNotInTeam` (where caller
     /// did pick a target but it's unknown).
     RoutingAmbiguous,
+    /// swallow batch 3: an explicit empty `--to` target list (a failed send always
+    /// carries its reason; an unexplained `failed` is a swallowed error).
+    EmptyTargetList,
+}
+
+/// Debug 输出 = wire snake_case 字面(单一真相源 = serde rename),与事件/JSON 面一致,
+/// 测试与日志里的 `{:?}` 不再出现与 wire 不同的 CamelCase 第二形态。
+impl std::fmt::Debug for DeliveryRefusal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match serde_json::to_value(self) {
+            Ok(serde_json::Value::String(wire)) => write!(f, "{wire}"),
+            _ => write!(f, "delivery_refusal"),
+        }
+    }
 }
 
 /// 注入失败阶段 (审计用;`delivery.py:309` injection.stage)。card §43。

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

@@ -298,48 +298,86 @@ pub fn retry_result_deliveries(
 ) -> Result<Vec<WatcherNotice>, MessagingError> {
     let store = MessageStore::open(workspace)?;
     let conn = crate::db::schema::open_db(store.db_path())?;
+    // result_delivery.py:19-35 — retries route through notify_result_watchers (the REAL
+    // 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, result_id from result_watchers
-         where status in ('pending', 'notify_failed') and result_id is not null and notified_message_id is null
+        "select watcher_id, owner_team_id, task_id, agent_id, leader_id, status, created_at,
+                result_id, notified_message_id
+         from result_watchers
+         where status in ('pending', 'notify_failed')
          order by created_at, watcher_id",
     )?;
-    let rows = stmt.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?;
+    let watchers = stmt
+        .query_map([], |row| {
+            Ok(serde_json::json!({
+                "watcher_id": row.get::<_, String>(0)?,
+                "owner_team_id": row.get::<_, Option<String>>(1)?,
+                "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)?,
+            }))
+        })?
+        .collect::<Result<Vec<_>, _>>()?;
+    drop(stmt);
     let mut notices = Vec::new();
-    for row in rows {
-        let (watcher_id, result_id) = row?;
-        let result: Option<String> = conn
+    for watcher in watchers {
+        if watcher.get("status").and_then(|v| v.as_str()) != Some("notify_failed") {
+            continue;
+        }
+        let Some(result_id) = watcher
+            .get("result_id")
+            .and_then(|v| v.as_str())
+            .filter(|id| !id.is_empty())
+            .map(ToString::to_string)
+        else {
+            continue;
+        };
+        let row: Option<(String, Option<String>)> = conn
             .query_row(
-                "select envelope from results where result_id = ?1",
+                "select envelope, created_at from results where result_id = ?1",
                 params![result_id],
-                |r| r.get(0),
+                |r| Ok((r.get(0)?, r.get(1)?)),
             )
             .optional()?;
-        if let Some(envelope) = result {
-            let parsed: serde_json::Value = serde_json::from_str(&envelope)?;
-            conn.execute(
-                "update result_watchers set status = 'notified', completed_at = ?2 where watcher_id = ?1",
-                params![watcher_id, chrono::Utc::now().to_rfc3339()],
-            )?;
-            event_log.write(
-                "result_watcher.retry_notified",
-                serde_json::json!({"watcher_id": watcher_id, "result_id": result_id}),
-            )?;
-            notices.push(WatcherNotice {
-                watcher_id,
-                result_id: Some(result_id),
-                ok: true,
-                status: Some("notified".to_string()),
-                notified_message_id: delivered_result_message(&store, parsed.get("result_id").and_then(|v| v.as_str()).unwrap_or(""), None, None)?
-                    .and_then(|v| v.get("message_id").and_then(|id| id.as_str()).map(ToString::to_string)),
-                primary_watcher_id: None,
-                prior_state: None,
-                error: None,
-            });
-        }
+        let Some((envelope, created_at)) = row else {
+            continue;
+        };
+        let result = result_entry_from_row(&result_id, &envelope, created_at.as_deref())?;
+        notices.extend(notify_result_watchers(
+            workspace,
+            &result,
+            event_log,
+            Some(std::slice::from_ref(&watcher)),
+            Some("rebind_retry"),
+        )?);
     }
     Ok(notices)
 }
 
+/// `_result_entry_from_row`(`result_delivery.py:365-377`)。
+fn result_entry_from_row(
+    result_id: &str,
+    envelope: &str,
+    created_at: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    let envelope: serde_json::Value = serde_json::from_str(envelope)?;
+    Ok(serde_json::json!({
+        "result_id": result_id,
+        "task_id": envelope.get("task_id").cloned().unwrap_or(serde_json::Value::Null),
+        "agent_id": envelope.get("agent_id").cloned().unwrap_or(serde_json::Value::Null),
+        "status": envelope.get("status").cloned().unwrap_or(serde_json::Value::Null),
+        "summary": envelope.get("summary").cloned().unwrap_or(serde_json::Value::Null),
+        "tests": envelope.get("tests").cloned().unwrap_or_else(|| serde_json::json!([])),
+        "created_at": created_at,
+        "scope": "task",
+    }))
+}
+
 /// `requeue_after_claim_leader` (`result_delivery.py:428`):Gap 26 —— 认领新 leader pane 后把
 /// 未投递 watcher 重路由到新 pane。**`notified_message_id` 必须存活** (Gap 32,清空会二次注入)。
 /// step 10 claim-leader 调。

package/crates/team-agent/src/model/enums.rs

@@ -15,6 +15,10 @@ pub enum Provider {
     Claude,
     ClaudeCode,
     Codex,
+    /// GitHub Copilot CLI(0.3.x 新增)。一期 subscription-only(已登录态),无 fork
+    /// 能力(caps.fork=false → CapabilityUnsupported),system prompt 走 per-worker
+    /// AGENTS.md + `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` env(B2 灵魂件降级,§C2)。
+    Copilot,
     GeminiCli,
     Fake,
 }
@@ -257,7 +261,9 @@ mod tests {
     #[test]
     fn unknown_provider_string_is_rejected() {
         // 与 receive_worker_outputs 不同:Provider 是封闭集,未知值必须 Err(不 passthrough)。
-        assert!(serde_json::from_str::<Provider>("\"copilot\"").is_err());
+        // NOTE: "copilot" 已 0.3.5 加入(design + cr verdict 全 APPROVE),改用一个
+        // 仍未注册的串验"封闭集"语义。
+        assert!(serde_json::from_str::<Provider>("\"gibberish\"").is_err());
     }
 
     #[test]

package/crates/team-agent/src/model/permissions.rs

@@ -184,6 +184,13 @@ pub fn provider_enforcement(provider: Provider, tool: Tool) -> Enforcement {
             FsRead | FsWrite | FsList | ExecuteBash | GitDiff | ProviderBuiltin => Hard,
         },
         Provider::Fake => Hard,
+        // Copilot(C-2-1 cr verdict):execute_bash/fs_write/network/mcp_team = hard,
+        // fs_read/fs_list/git_diff/provider_builtin = prompt_only(诚实:copilot 无
+        // 对应 deny kind,framework 不替决,留给 provider prompt 控制;MUST-NOT-13)。
+        Provider::Copilot => match tool {
+            FsRead | FsList | GitDiff | ProviderBuiltin => PromptOnly,
+            Network | FsWrite | ExecuteBash | McpTeam => Hard,
+        },
         // codex: 全 prompt_only。claude: 不在表中 → 全 prompt_only(同 fallback)。
         Provider::Codex | Provider::Claude => PromptOnly,
     }

package/crates/team-agent/src/model/spec.rs

@@ -175,7 +175,9 @@ fn result_schema_errors(envelope: &Value) -> Vec<String> {
 const ROOT_KEYS: &[&str] = &[
     "version", "team", "leader", "agents", "routing", "communication", "runtime", "context", "tasks",
 ];
-const SUPPORTED_PROVIDERS: &[&str] = &["claude", "claude_code", "codex", "gemini_cli", "fake"];
+// Copilot 一期加入白名单(design §B compiler.py:249-251 同位 + cr verdict 总裁,
+// MUST-NOT-7 跨厂商等价 — 设计 / cr 已落地 26 约束)。
+const SUPPORTED_PROVIDERS: &[&str] = &["claude", "claude_code", "codex", "copilot", "gemini_cli", "fake"];
 const AUTH_MODES: &[&str] = &["subscription", "official_api", "compatible_api"];
 const VALID_DISPLAY_BACKENDS: &[&str] = &[
     "none", "tmux_attach", "iterm", "ghostty", "ghostty_window", "ghostty_workspace", "adaptive",