@team-agent/installer 0.5.66 → 0.5.68

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

@@ -4081,6 +4081,9 @@ pub mod lifecycle_port {
 /// `run_comms_selftest`、`diagnose/orphan_cleanup.py` `orphan_gate`/`cleanup_orphan_coordinators`、
 /// `message_store/schema_migration.py` `schema_diagnosis`/`fix_schema_layout`)。
 /// `cmd_doctor` 的所有分支委派点。返回 `Value`(稳定 JSON 形状由 diagnose lane 拥有)。
+pub mod grok_slot;
+pub(crate) use grok_slot::grok_slot_report;
+
 pub mod diagnose_port {
     use super::*;
 
@@ -4134,6 +4137,13 @@ pub mod diagnose_port {
         let health = crate::coordinator::coordinator_health(
             &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
         );
+        let coordinator_ok = health.ok;
+        let coordinator_error = health.metadata_mismatch_reason.clone();
+        let state = crate::state::persist::load_runtime_state(workspace).unwrap_or(Value::Null);
+        let grok_slot = crate::cli::grok_slot_report(workspace, &state).to_json();
+        let grok_slot_ok = grok_slot.get("consistent").and_then(Value::as_bool) == Some(true)
+            && grok_slot.get("readable").and_then(Value::as_bool) == Some(true);
+        let ok = ok && grok_slot_ok && coordinator_ok;
         Ok(json!({
             "tmux": {
                 "installed": tmux_installed,
@@ -4149,11 +4159,21 @@ pub mod diagnose_port {
             "secret_scan": secret_scan(workspace),
             "profile_smoke": profile_smoke_value,
             "coordinator": coordinator_health_value(health),
+            "grok_slot": grok_slot,
             "ok": ok,
             "error": if ok {
                 Value::Null
+            } else if !grok_slot_ok {
+                grok_slot
+                    .get("reason")
+                    .cloned()
+                    .unwrap_or_else(|| json!("grok_slot_mismatch"))
             } else if !profile_smoke_ok && !legacy_only_failure {
                 json!("profile_smoke_failed")
+            } else if !coordinator_ok {
+                coordinator_error
+                    .map(Value::String)
+                    .unwrap_or_else(|| json!("coordinator_unavailable"))
             } else if workspace_valid {
                 json!("workspace has no Team Agent spec or runtime context")
             } else {

package/crates/team-agent/src/cli/send/presentation.rs

@@ -3,6 +3,7 @@ use crate::cli::{CliError, CmdOutput, CmdResult, ExitCode};
 use crate::messaging::{
     DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus, MessageTarget, SendOptions,
 };
+use crate::transport::{turn_verification_wire, TurnVerification};
 use serde_json::{json, Value};
 
 pub(super) fn watch_notice_json(target: &MessageTarget, opts: &SendOptions) -> Value {
@@ -113,6 +114,11 @@ pub(super) fn delivery_outcome_json(
         "stage": outcome.stage.map(delivery_stage_wire),
         "reason": outcome.reason.map(delivery_refusal_wire),
         "channel": outcome.channel,
+        "turn_verification": turn_verification_wire(
+            outcome
+                .turn_verification
+                .unwrap_or(TurnVerification::NotYetObserved),
+        ),
     })
 }
 
@@ -183,7 +189,7 @@ pub(super) fn send_human_output(value: &Value) -> String {
         send_human_field(value, "message_id"),
         format!("target: {}", send_human_target(value)),
     ];
-    for key in ["verification", "stage", "reason", "channel"] {
+    for key in ["verification", "stage", "reason", "channel", "turn_verification"] {
         if !value.get(key).is_none_or(Value::is_null) {
             parts.push(send_human_field(value, key));
         }

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

@@ -179,6 +179,8 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "codex", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "codex" }, summary: "launch a Codex leader", usage: "usage: team-agent codex [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "claude", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "claude" }, summary: "launch a Claude leader", usage: "usage: team-agent claude [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "copilot", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "copilot" }, summary: "launch a Copilot leader", usage: "usage: team-agent copilot [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "grok", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "grok" }, summary: "launch a Grok leader", usage: "usage: team-agent grok [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "cursor", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::LeaderPassthrough { provider: "cursor" }, summary: "launch a Cursor leader", usage: "usage: team-agent cursor [provider args...]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::Yes, alias_of: None, sunset: None, action: None, governance: None },
 
     CommandSpec { name: "init", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::Dispatch(DispatchKind::Init), summary: "legacy bootstrap command", usage: "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: Some("quick-start"), sunset: Some("C2"), action: Some("use `team-agent quick-start`"), governance: None },
     CommandSpec { name: "start", tier: CommandTier::CompatHidden, category: CommandCategory::Compat, kind: CommandKind::SpecOnlyAlias { alias_of: "quick-start" }, summary: "legacy start alias", usage: "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::Conditional, alias_of: Some("quick-start"), sunset: Some("C2"), action: Some("use `team-agent quick-start` or `team-agent restart`"), governance: None },

package/crates/team-agent/src/cli/status_port/compact.rs

@@ -4,6 +4,9 @@ use super::*;
 pub(super) fn compact_status(full: Value) -> Value {
     let not_ready = compact_not_ready(&full);
     let ready = compact_ready(&full, &not_ready);
+    let grok_slot = full.get("grok_slot").cloned().unwrap_or(Value::Null);
+    let grok_identity_slot_ok = grok_slot.get("consistent").and_then(Value::as_bool) == Some(true)
+        && grok_slot.get("readable").and_then(Value::as_bool) == Some(true);
     json!({
         "ok": true,
         "team": full.get("team").cloned().unwrap_or(Value::Null),
@@ -11,6 +14,8 @@ pub(super) fn compact_status(full: Value) -> Value {
         "leader_attach_command": full.get("leader_attach_command").cloned().unwrap_or(Value::Null),
         "ready": ready,
         "not_ready": not_ready,
+        "grok_slot": grok_slot,
+        "grok_identity_slot_ok": grok_identity_slot_ok,
         "agents": compact_agents(full.get("agents")),
     })
 }
@@ -55,11 +60,20 @@ pub(super) fn compact_not_ready(full: &Value) -> Value {
         })
         .unwrap_or_default();
     let mut obj = Map::new();
+    let channel_unbound = reasons
+        .iter()
+        .any(|reason| reason == "leader_receiver_unbound");
     obj.insert(
         "reasons".to_string(),
         Value::Array(reasons.into_iter().map(Value::String).collect()),
     );
     obj.insert("agents".to_string(), Value::Array(agents));
+    if channel_unbound {
+        obj.insert(
+            "next_action".to_string(),
+            Value::String("claim-leader".to_string()),
+        );
+    }
     Value::Object(obj)
 }
 
@@ -112,6 +126,20 @@ pub(super) fn not_ready_reasons(full: &Value) -> Vec<String> {
     {
         reasons.push("awaiting_trust_prompt".to_string());
     }
+    let grok_slot = full.get("grok_slot");
+    let grok_readable = grok_slot
+        .and_then(|slot| slot.get("readable"))
+        .and_then(Value::as_bool);
+    let grok_consistent = grok_slot
+        .and_then(|slot| slot.get("consistent"))
+        .and_then(Value::as_bool);
+    if grok_readable != Some(true) || grok_consistent != Some(true) {
+        if grok_readable == Some(false) || grok_slot.is_none() || grok_slot == Some(&Value::Null) {
+            reasons.push("grok_slot_unjudgeable".to_string());
+        } else {
+            reasons.push("grok_slot_mismatch".to_string());
+        }
+    }
     reasons
 }
 

package/crates/team-agent/src/cli/status_port/snapshot.rs

@@ -90,7 +90,29 @@ impl RuntimeSnapshot {
                 serde_json::json!(tmux_present),
             );
         }
-        let readiness = crate::cli::diagnose::wait_readiness(&readiness_state);
+        let mut readiness = crate::cli::diagnose::wait_readiness(&readiness_state);
+        let team_key = owner_team_id
+            .filter(|team| !team.is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| crate::state::projection::team_state_key(state));
+        if !team_key.is_empty()
+            && !crate::lifecycle::launch::launched_team_receiver_is_attached(workspace, &team_key)
+        {
+            if let Some(object) = readiness.as_object_mut() {
+                object.insert("all_attached_receiver".to_string(), json!(false));
+                object.insert("ready".to_string(), json!(false));
+                object.insert("state".to_string(), json!("leader_receiver_unbound"));
+                object.insert("next_action".to_string(), json!("claim-leader"));
+                object.insert(
+                    "reason".to_string(),
+                    json!("leader registry does not authorize this workspace"),
+                );
+            }
+        }
+        let grok_slot = crate::cli::grok_slot_report(workspace, state).to_json();
+        let grok_identity_slot_ok = grok_slot.get("consistent").and_then(Value::as_bool)
+            == Some(true)
+            && grok_slot.get("readable").and_then(Value::as_bool) == Some(true);
         let full = crate::redaction::redact_external_value(&json!({
             "ok": true,
             "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
@@ -120,6 +142,8 @@ impl RuntimeSnapshot {
             "readiness": readiness,
             "coordinator": coordinator_health_value(health),
             "runtime": runtime_block,
+            "grok_slot": grok_slot,
+            "grok_identity_slot_ok": grok_identity_slot_ok,
             "reminder": crate::cli::STATUS_REMINDER,
             "last_events": Value::Array(
                 crate::event_log::EventLog::new(workspace)

package/crates/team-agent/src/cli/tests/base.rs

@@ -753,20 +753,43 @@ fn cmd_leader_passthrough_help_returns_none() {
     assert_eq!(r2.output, CmdOutput::None);
     let r3 = cmd_leader_passthrough("copilot", &["--help".into()], Path::new(".")).unwrap();
     assert_eq!(r3.output, CmdOutput::None);
+    let r4 = cmd_leader_passthrough("grok", &["-h".into()], Path::new(".")).unwrap();
+    assert_eq!(r4.output, CmdOutput::None);
+    let r5 = cmd_leader_passthrough("cursor", &["--help".into()], Path::new(".")).unwrap();
+    assert_eq!(r5.output, CmdOutput::None);
 }
 
 #[test]
 fn cmd_leader_passthrough_maps_copilot_provider() {
     assert_eq!(
         leader_passthrough_provider("codex"),
-        crate::model::enums::Provider::Codex
+        Some(crate::model::enums::Provider::Codex)
     );
     assert_eq!(
         leader_passthrough_provider("claude"),
-        crate::model::enums::Provider::ClaudeCode
+        Some(crate::model::enums::Provider::ClaudeCode)
     );
     assert_eq!(
         leader_passthrough_provider("copilot"),
-        crate::model::enums::Provider::Copilot
+        Some(crate::model::enums::Provider::Copilot)
     );
 }
+
+#[test]
+fn cmd_leader_passthrough_maps_grok_and_cursor_not_claude() {
+    assert_eq!(
+        leader_passthrough_provider("grok"),
+        Some(crate::model::enums::Provider::Grok)
+    );
+    assert_eq!(
+        leader_passthrough_provider("cursor"),
+        Some(crate::model::enums::Provider::CursorAgent)
+    );
+    assert_ne!(
+        leader_passthrough_provider("cursor"),
+        Some(crate::model::enums::Provider::ClaudeCode)
+    );
+    assert_eq!(leader_passthrough_provider("agent"), None);
+    assert_eq!(leader_passthrough_provider("cursor_agent"), None);
+    assert_eq!(leader_passthrough_provider("not-a-passthrough"), None);
+}

package/crates/team-agent/src/cli/tests/missing_subcommands.rs

@@ -37,6 +37,75 @@ impl Drop for WorkspaceCleanup {
     }
 }
 
+struct IsolatedHome {
+    prev: Option<String>,
+    dir: std::path::PathBuf,
+}
+
+impl IsolatedHome {
+    fn enter(tag: &str) -> Self {
+        let base = std::env::var_os("TEAM_AGENT_TEST_TMP")
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(std::env::temp_dir);
+        let dir = base.join(format!(
+            "ta-cli-home-{tag}-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(dir.join(".team-agent").join("leaders")).unwrap();
+        let prev = std::env::var("HOME").ok();
+        std::env::set_var("HOME", &dir);
+        Self { prev, dir }
+    }
+}
+
+impl Drop for IsolatedHome {
+    fn drop(&mut self) {
+        match &self.prev {
+            Some(value) => std::env::set_var("HOME", value),
+            None => std::env::remove_var("HOME"),
+        }
+        let _ = std::fs::remove_dir_all(&self.dir);
+    }
+}
+
+fn seed_self_signed_attached_leader(ws: &std::path::Path) {
+    std::fs::write(
+        ws.join(".team").join("runtime").join("state.json"),
+        serde_json::to_vec(&json!({
+            "team_key": "current",
+            "leader": {"id": "leader"},
+            "leader_receiver": {
+                "mode": "direct_tmux",
+                "status": "attached",
+                "pane_id": "%1",
+                "provider": "codex"
+            },
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+}
+
+fn seed_leader_registry_entry(ws: &std::path::Path) {
+    let entry = crate::leader::registry::build_entry(
+        ws,
+        "current",
+        "direct_tmux",
+        json!({"status": "attached", "pane_id": "%1"}),
+        1,
+        "diagnose-healthy-fixture",
+        "2026-08-18T00:00:00Z".to_string(),
+    );
+    assert!(
+        crate::leader::registry::write_entry_best_effort(&entry).is_some(),
+        "hermetic HOME must accept a leaders/ registry write"
+    );
+}
+
 // =========================================================================
 // WAVE-2 NON-SUB CHECKPOINT — missing CLI subcommands (ABSENT from cli/emit.rs dispatch).
 // emit.rs `dispatch` has NO arm for sessions, peek, collect, e2e, diagnose,
@@ -255,33 +324,74 @@ fn dispatch_routes_collect_with_spec() {
         );
 }
 
-// ── diagnose ── golden parser.py:298 `cmd_diagnose` -> runtime.diagnose(ws) (diagnose/health.py:19).
-// ok:true only when there are zero issues. Seed leader_receiver=attached + NO session_name + NO
-// agents -> issues=[] -> EXIT 0, golden top keys (sort): event_log,issues,ok,runtime,suggested_repairs.
-// RED: unrouted -> Error.
+// ── diagnose ── attached is host-registry authority, not state.json self-sign.
+// Seed leader_receiver=attached + a ~/.team-agent/leaders/ row for this workspace
+// + NO session_name + NO agents -> issues=[] -> EXIT 0.
 #[test]
+#[serial(env)]
 fn dispatch_routes_diagnose_healthy_leader() {
+    let _env = EnvUnsetGuard::unset(&[
+        "TMUX",
+        "TMUX_PANE",
+        "TEAM_AGENT_WORKSPACE",
+        "TEAM_AGENT_TEAM_ID",
+        "TEAM_AGENT_OWNER_TEAM_ID",
+        "TEAM_AGENT_ACTIVE_TEAM",
+        "TEAM_AGENT_ID",
+        "TEAM_AGENT_LEADER_PANE_ID",
+        "TEAM_AGENT_LEADER_SESSION_UUID",
+        "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+        "TEAM_AGENT_LEADER_PROVIDER",
+    ]);
+    let _home = IsolatedHome::enter("diagnose-healthy");
     let ws = tmp_workspace();
-    std::fs::write(
-            ws.join(".team").join("runtime").join("state.json"),
-            serde_json::to_vec(&json!({
-                "leader": {"id": "leader"},
-                "leader_receiver": {"mode": "direct_tmux", "status": "attached", "pane_id": "%1", "provider": "codex"},
-            }))
-            .unwrap(),
-        )
-        .unwrap();
+    seed_self_signed_attached_leader(&ws);
+    seed_leader_registry_entry(&ws);
     let code = run(
         &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
         &ws,
     );
     assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`diagnose` must ROUTE to cmd_diagnose (parser.py:298); a healthy (attached, no-session, \
-             no-agent) state yields zero issues -> exit 0 {{event_log,issues,ok,runtime,suggested_repairs}}; \
-             today -> unknown-subcommand Error"
-        );
+        code,
+        ExitCode::Ok,
+        "`diagnose` must be Ok when state.json looks attached AND ~/.team-agent/leaders/ \
+         has a matching attached row; got {code:?}"
+    );
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+#[serial(env)]
+fn dispatch_routes_diagnose_self_signed_attached_without_registry_is_not_ok() {
+    // 已废除的行为：旧实现只信 `state.json` 的自签 attached（F2 谎话本体），此断言证明它确实没了。
+    // 夹具只种 leader_receiver.status=attached，注册表无该 workspace 条目。
+    // 旧 diagnose 会因此报 Ok；新 diagnose 必须以注册表为可投递权威，判非 Ok。
+    let _env = EnvUnsetGuard::unset(&[
+        "TMUX",
+        "TMUX_PANE",
+        "TEAM_AGENT_WORKSPACE",
+        "TEAM_AGENT_TEAM_ID",
+        "TEAM_AGENT_OWNER_TEAM_ID",
+        "TEAM_AGENT_ACTIVE_TEAM",
+        "TEAM_AGENT_ID",
+        "TEAM_AGENT_LEADER_PANE_ID",
+        "TEAM_AGENT_LEADER_SESSION_UUID",
+        "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+        "TEAM_AGENT_LEADER_PROVIDER",
+    ]);
+    let _home = IsolatedHome::enter("diagnose-f2-tombstone");
+    let ws = tmp_workspace();
+    seed_self_signed_attached_leader(&ws);
+    let code = run(
+        &cli_argv(&["diagnose", "--workspace", &ws.to_string_lossy(), "--json"]),
+        &ws,
+    );
+    assert_ne!(
+        code,
+        ExitCode::Ok,
+        "self-signed state.json attached with no leaders/ row must not diagnose Ok (F2 lie is dead); \
+         got {code:?}"
+    );
     let _ = std::fs::remove_dir_all(&ws);
 }