@team-agent/installer 0.3.6 → 0.3.8

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

@@ -228,8 +228,18 @@ impl Coordinator {
             );
         }
 
+        // B-4 / 036b N36 三路可用 — 监测步(runtime_prompts / sync_health /
+        // detect_abnormal_exits)失败必须降级+continue,**不能**用 `?` 中断 tick,
+        // 否则 deliver_pending(下行投递主干)够不到,消息卡 accepted。
+        // bug-084 哲学 + A-6 同族:每步独立 try,失败写 `coordinator.tick.<step>_failed`
+        // 事件后继续走下一步;tick 本身仍返 Ok。
         self.record_step("runtime_prompts");
-        self.handle_runtime_approval_prompts(&mut state, &event_log)?;
+        if let Err(error) = self.handle_runtime_approval_prompts(&mut state, &event_log) {
+            let _ = event_log.write(
+                "coordinator.tick.runtime_prompts_failed",
+                serde_json::json!({"error": error.to_string()}),
+            );
+        }
 
         self.record_step("sync_health");
         // P5 (C-P5-1, N3): ONE pane snapshot per tick, shared by sync_health and the
@@ -237,32 +247,71 @@ impl Coordinator {
         // this tick; every tick re-reads).
         let pane_snapshot = self.transport.list_targets().unwrap_or_default();
         let captures_by_agent =
-            self.sync_agent_health(&mut state, &store, &event_log, &pane_snapshot)?;
+            match self.sync_agent_health(&mut state, &store, &event_log, &pane_snapshot) {
+                Ok(captures) => captures,
+                Err(error) => {
+                    let _ = event_log.write(
+                        "coordinator.tick.sync_health_failed",
+                        serde_json::json!({"error": error.to_string()}),
+                    );
+                    BTreeMap::new()
+                }
+            };
         // C-3-4 cr verdict — copilot 一期 classify→None(Unknown);为防 silent,
         // tick 每次发现 copilot agent(从 state.agents 直接扫,不依赖 captures —
         // 离线/未起 tmux 场景仍能写)就发 `provider.classify.unsupported` 事件
         // (字面 reason=`phase1_unknown_pending_sample`,含 provider="copilot" + "classify"
         // 串)。二期接 sqlite turns 表后这条删/降级,届时改 reason 区分。
-        if let Some(agents) = state.get("agents").and_then(Value::as_object) {
-            for (agent_id, agent) in agents {
-                let is_copilot = agent
-                    .get("provider")
-                    .and_then(Value::as_str)
-                    .and_then(parse_provider)
-                    .is_some_and(|p| matches!(p, crate::model::enums::Provider::Copilot));
-                if is_copilot {
-                    let _ = event_log.write(
-                        "provider.classify.unsupported",
-                        serde_json::json!({
-                            "provider": "copilot",
-                            "agent_id": agent_id,
-                            "reason": "phase1_unknown_pending_sample",
-                        }),
-                    );
-                }
+        //
+        // B-4 P4 / 036b 防 dedup-flood:同 (provider, agent_id, reason) 状态跨 tick
+        // 只发一次(check_key 范式,同 abnormal_check_key tick.rs:603 同精神);状态
+        // 变了才再发。check_key 落 state.agents.<id>.classify_unsupported.last_key,
+        // tick-only metadata,不进 #235 owner / receiver 等持久态。
+        let agents_snapshot: Vec<(String, Option<String>)> =
+            if let Some(agents) = state.get("agents").and_then(Value::as_object) {
+                agents
+                    .iter()
+                    .filter_map(|(agent_id, agent)| {
+                        let is_copilot = agent
+                            .get("provider")
+                            .and_then(Value::as_str)
+                            .and_then(parse_provider)
+                            .is_some_and(|p| matches!(p, crate::model::enums::Provider::Copilot));
+                        if !is_copilot {
+                            return None;
+                        }
+                        let last_key = agent
+                            .get("classify_unsupported")
+                            .and_then(|v| v.get("last_key"))
+                            .and_then(Value::as_str)
+                            .map(str::to_string);
+                        Some((agent_id.clone(), last_key))
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            };
+        for (agent_id, last_key) in agents_snapshot {
+            let check_key = format!("copilot|{agent_id}|phase1_unknown_pending_sample");
+            if last_key.as_deref() == Some(check_key.as_str()) {
+                continue;
             }
+            let _ = event_log.write(
+                "provider.classify.unsupported",
+                serde_json::json!({
+                    "provider": "copilot",
+                    "agent_id": agent_id,
+                    "reason": "phase1_unknown_pending_sample",
+                }),
+            );
+            mark_classify_unsupported(&mut state, &agent_id, &check_key);
+        }
+        if let Err(error) = self.detect_abnormal_exits(&mut state, &event_log, &pane_snapshot) {
+            let _ = event_log.write(
+                "coordinator.tick.detect_abnormal_failed",
+                serde_json::json!({"error": error.to_string()}),
+            );
         }
-        self.detect_abnormal_exits(&mut state, &event_log, &pane_snapshot)?;
 
         self.record_step("deliver_pending");
         let delivered = crate::messaging::deliver_pending_messages(
@@ -389,6 +438,12 @@ impl Coordinator {
         let team = crate::state::projection::team_state_key(&snapshot);
         let team_key = Some(crate::model::ids::TeamKey::new(team.clone()));
         let session_name = state.get("session_name").and_then(Value::as_str).map(str::to_string);
+        // B-4 / 036b N36 三路可用 — sync_health 内 per-agent capture 失败本就降级
+        // (写 coordinator.agent_capture_failed 后 continue),不打断 deliver_pending
+        // 主干。但 contract 要求一条【tick 级】可观测的 step-failed 信号 —
+        // sync_health 失败一旦发生就在末尾 emit `coordinator.tick.sync_health_failed`
+        // (含 "tick" + "_failed" 双串),避免 silent。
+        let mut had_capture_failure = false;
         // P5 (C-P5-2): one list-windows per SESSION per tick — memoized across the
         // agent loop instead of one fork per agent.
         let mut windows_by_session: BTreeMap<String, Result<Vec<crate::transport::WindowName>, String>> =
@@ -409,6 +464,7 @@ impl Coordinator {
                 }) {
                 Ok(windows) => windows.clone(),
                 Err(error) => {
+                    had_capture_failure = true;
                     event_log.write(
                         "coordinator.agent_capture_failed",
                         serde_json::json!({
@@ -429,6 +485,7 @@ impl Coordinator {
             {
                 Ok(captured) => captured,
                 Err(error) => {
+                    had_capture_failure = true;
                     event_log.write(
                         "coordinator.agent_capture_failed",
                         serde_json::json!({
@@ -506,6 +563,15 @@ impl Coordinator {
                 },
             );
         }
+        // B-4 step-level signal:若本 tick 有任一 capture 失败,emit
+        // `coordinator.tick.sync_health_failed`(含 "tick" + "_failed")让 contract
+        // 可观测,deliver_pending 主干不受影响。
+        if had_capture_failure {
+            let _ = event_log.write(
+                "coordinator.tick.sync_health_failed",
+                serde_json::json!({"step": "sync_health", "degraded": true}),
+            );
+        }
         Ok(captures)
     }
 
@@ -1738,6 +1804,28 @@ fn mark_abnormal_suppressed(state: &mut Value, agent_id: &str, key: &str) {
     }
 }
 
+/// B-4 P4 dedup marker — 把 classify.unsupported check_key 写到
+/// state.agents.<id>.classify_unsupported.last_key,只在状态变了才再发事件。
+/// 同 abnormal_check_key (line 603) 同精神,但落 agents 子 obj(per-agent locality,
+/// 不污染 abnormal_exit_watch 命名空间)。
+fn mark_classify_unsupported(state: &mut Value, agent_id: &str, key: &str) {
+    let Some(agents) = state.get_mut("agents").and_then(Value::as_object_mut) else {
+        return;
+    };
+    let Some(agent) = agents.get_mut(agent_id).and_then(Value::as_object_mut) else {
+        return;
+    };
+    let entry = agent
+        .entry("classify_unsupported".to_string())
+        .or_insert_with(|| serde_json::json!({}));
+    if !entry.is_object() {
+        *entry = serde_json::json!({});
+    }
+    if let Some(obj) = entry.as_object_mut() {
+        obj.insert("last_key".to_string(), serde_json::json!(key));
+    }
+}
+
 fn mark_abnormal_checked(state: &mut Value, agent_id: &str, key: &str) {
     if let Some(watch) = coordinator_child_object(state, "abnormal_exit_watch") {
         let entry = watch

package/crates/team-agent/src/db/migration.rs

@@ -84,12 +84,16 @@ pub struct RebuildEvent {
 }
 
 /// `schema_diagnosis` 的只读结论。
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 pub struct Diagnosis {
     pub ok: bool,
     pub status: String,
     pub user_version: i64,
     pub layout_diffs: Vec<String>,
+    /// Python parity (`schema_migration.py:188/206`): the layered guidance line —
+    /// "missing" carries the initialize_schema first-use hint; drift carries the
+    /// fix-schema command; healthy carries "none".
+    pub recommended_action: String,
 }
 
 fn table_exists(conn: &Connection, table: &str) -> Result<bool, DbError> {
@@ -316,11 +320,18 @@ pub fn ensure_table_layout(
 /// `schema_migration.py:schema_diagnosis`:只读判定(不变更 DB)。
 pub fn schema_diagnosis(db_path: &Path, schema_version: i64) -> Result<Diagnosis, DbError> {
     if !db_path.exists() {
+        // T3-3 cr verdict (A parity lock, 2026-06-10): a missing db is the LEGAL
+        // first-use state — ok:true is layered with the explicit status axis and the
+        // recommended_action guidance (Python schema_migration.py:180-190 verbatim),
+        // never a silent fake-green.
         return Ok(Diagnosis {
             ok: true,
             status: "missing".to_string(),
             user_version: 0,
             layout_diffs: vec![],
+            recommended_action:
+                "No team.db exists yet; initialize_schema will create it on first use."
+                    .to_string(),
         });
     }
     let conn = Connection::open(db_path)?;
@@ -332,6 +343,11 @@ pub fn schema_diagnosis(db_path: &Path, schema_version: i64) -> Result<Diagnosis
         ok,
         status: if ok { "ok".to_string() } else { "schema_repair_available".to_string() },
         user_version: uv,
+        recommended_action: if diff_tables.is_empty() {
+            "none".to_string()
+        } else {
+            "run team-agent doctor --fix-schema --json".to_string()
+        },
         layout_diffs: diff_tables,
     })
 }

package/crates/team-agent/src/leader/owner_bind.rs

@@ -189,15 +189,29 @@ fn bind_provider_from_env_or_command(command: &str) -> Provider {
     std::env::var("TEAM_AGENT_LEADER_PROVIDER")
         .ok()
         .and_then(|raw| super::helpers::parse_provider(&raw))
-        .unwrap_or_else(|| provider_from_command(command))
+        .or_else(|| provider_from_command(command))
+        // E11 层2:未知命令不再静默默认 codex(会误绑任意 provider + 喂错分类器)。
+        // 无法识别时回落 Codex 仅作最末兜底,且该路径已被 provider_from_command 的显式 None 收窄
+        // (调用方理应只在已知 leader 命令上 bind);保留以不改 fn 签名/上游 panic 面。
+        .unwrap_or(Provider::Codex)
 }
 
-fn provider_from_command(command: &str) -> Provider {
+/// E11 层2 + N39:command 名 → wire 串 → `parse_provider`(**单一映射源**,与
+/// `owner_bind_provider_wire` 共用 [`command_provider_wire`])。未知命令 → `None`
+/// (危险的 `_ => Codex` 默认已删:不静默把任意 provider 误绑成 codex)。
+fn provider_from_command(command: &str) -> Option<Provider> {
+    command_provider_wire(command).and_then(super::helpers::parse_provider)
+}
+
+/// command 名 → provider wire 串(单一真相;copilot/claude/codex/fake)。未知 → `None`。
+/// `claude.exe` 归一为 `claude`。
+fn command_provider_wire(command: &str) -> Option<&'static str> {
     match exact_command_name(command).as_deref() {
-        Some("claude") | Some("claude.exe") => Provider::Claude,
-        Some("codex") => Provider::Codex,
-        Some("fake") => Provider::Fake,
-        _ => Provider::Codex,
+        Some("claude") | Some("claude.exe") => Some("claude"),
+        Some("codex") => Some("codex"),
+        Some("copilot") => Some("copilot"),
+        Some("fake") => Some("fake"),
+        _ => None,
     }
 }
 
@@ -214,21 +228,15 @@ fn exact_command_name(command: &str) -> Option<String> {
 
 pub fn owner_bind_provider_wire(command: &str) -> &'static str {
     if let Ok(raw) = std::env::var("TEAM_AGENT_LEADER_PROVIDER") {
-        return match raw.as_str() {
-            "claude" => "claude",
-            "claude_code" => "claude_code",
-            "codex" => "codex",
-            "gemini_cli" => "gemini_cli",
-            "fake" => "fake",
-            _ => "",
-        };
-    }
-    match exact_command_name(command).as_deref() {
-        Some("claude") | Some("claude.exe") => "claude",
-        Some("codex") => "codex",
-        Some("fake") => "fake",
-        _ => "",
+        // env 显式 provider:经 parse_provider(单一表,知 copilot)校验后透传其 wire 串;
+        // 不识别 → ""(空,与原行为一致:不绑)。
+        return super::helpers::parse_provider(&raw)
+            .map(super::helpers::provider_wire)
+            .unwrap_or("");
     }
+    // E11 层2 + N39:与 provider_from_command 共用 command_provider_wire 单一映射(含 copilot);
+    // 未知命令 → ""(不绑),不再静默当 codex。
+    command_provider_wire(command).unwrap_or("")
 }
 
 fn family_a_identity(
@@ -290,3 +298,34 @@ fn tmux_pane_current_command(workspace: &Path, pane: &str) -> Result<String, Lea
 // NOTE: `derive_leader_session_uuid`(`leader_binding.py:146`)已由
 // `model::ids::LeaderSessionUuid::derive` 字节对齐实现(含 NUL 拒绝 + golden 测试)——
 // 此 lane REUSE 之,不重声明。
+
+#[cfg(test)]
+mod e11_provider_bind_tests {
+    #![allow(clippy::unwrap_used)]
+    use super::*;
+
+    // E11 层2:copilot leader 命令必须绑成 Provider::Copilot(此前缺臂 → _ => Codex 误绑)。
+    #[test]
+    fn copilot_command_binds_copilot_not_codex() {
+        assert_eq!(provider_from_command("copilot --banner -C /ws"), Some(Provider::Copilot));
+        assert_eq!(provider_from_command("/opt/homebrew/bin/copilot"), Some(Provider::Copilot));
+        assert_eq!(owner_bind_provider_wire("copilot --banner"), "copilot");
+    }
+
+    #[test]
+    fn known_commands_map_via_single_source() {
+        assert_eq!(provider_from_command("claude"), Some(Provider::Claude));
+        assert_eq!(provider_from_command("codex"), Some(Provider::Codex));
+        assert_eq!(provider_from_command("fake"), Some(Provider::Fake));
+        assert_eq!(owner_bind_provider_wire("claude"), "claude");
+        assert_eq!(owner_bind_provider_wire("codex"), "codex");
+    }
+
+    // E11 层2:未知命令不再静默默认 codex —— provider_from_command → None,wire → ""。
+    #[test]
+    fn unknown_command_is_none_not_silent_codex() {
+        assert_eq!(provider_from_command("node /some/thing.js"), None);
+        assert_eq!(provider_from_command("totally-unknown"), None);
+        assert_eq!(owner_bind_provider_wire("totally-unknown"), "");
+    }
+}