@team-agent/installer 0.5.49 → 0.5.51

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

@@ -0,0 +1,145 @@
+use crate::cli::CliError;
+use serde_json::{json, Value};
+
+/// `format_status` agent 分支(`queries.py:135-162`)。
+pub(super) fn format_agent_status(
+    status: &Value,
+    agent_id: &str,
+    inbox_rows: &[Value],
+) -> Result<String, CliError> {
+    ensure_agent_known(status, agent_id)?;
+    let agents = status.get("agents").and_then(Value::as_object);
+    let health = status.get("agent_health").and_then(Value::as_object);
+    let empty = json!({});
+    let agent = agents.and_then(|map| map.get(agent_id)).unwrap_or(&empty);
+    let row = health.and_then(|map| map.get(agent_id)).unwrap_or(&empty);
+    let status_text = row
+        .get("status")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+        .unwrap_or_else(|| {
+            agent_health_status_text(agent.get("status").and_then(Value::as_str).unwrap_or(""))
+        });
+    let tasks = status
+        .get("tasks")
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default();
+    let task_id = current_task_for_agent(&tasks, agent_id).unwrap_or_else(|| "-".to_string());
+    let mut lines = vec![
+        format!("{agent_id}  {status_text}"),
+        format!("  provider: {}", py_get(agent, "provider")),
+        format!("  model: {}", py_get(agent, "model")),
+        format!("  profile: {}", py_get(agent, "profile")),
+        format!("  session_id: {}", py_get_or_dash(agent, "session_id")),
+        format!("  captured_via: {}", py_get_or_dash(agent, "captured_via")),
+        format!(
+            "  attribution_confidence: {}",
+            py_get_or_dash(agent, "attribution_confidence")
+        ),
+        format!("  task: {task_id}"),
+        format!("  handoff: {}", py_get(agent, "handoff_path")),
+        "  recent messages:".to_string(),
+    ];
+    if inbox_rows.is_empty() {
+        lines.push("    none".to_string());
+    } else {
+        for item in inbox_rows {
+            let content = item.get("content").and_then(Value::as_str).unwrap_or("");
+            let content: String = content.chars().take(120).collect();
+            lines.push(format!(
+                "    {} {} -> {} {}: {content}",
+                py_get_or_dash(item, "created_at"),
+                py_get_or_dash(item, "sender"),
+                py_get_or_dash(item, "recipient"),
+                py_get_or_dash(item, "status"),
+            ));
+        }
+    }
+    Ok(lines.join("\n"))
+}
+
+pub(super) fn ensure_agent_known(status: &Value, agent_id: &str) -> Result<(), CliError> {
+    let agents = status.get("agents").and_then(Value::as_object);
+    let health = status.get("agent_health").and_then(Value::as_object);
+    let known = agents.is_some_and(|map| map.contains_key(agent_id))
+        || health.is_some_and(|map| map.contains_key(agent_id));
+    if !known {
+        return Err(CliError::Runtime(format!("unknown agent id: {agent_id}")));
+    }
+    Ok(())
+}
+
+/// `current_task_for_agent`(`approvals/status.py:127-132`)。
+pub(super) fn current_task_for_agent(tasks: &[Value], agent_id: &str) -> Option<String> {
+    const ACTIVE: [&str; 5] = ["pending", "ready", "running", "blocked", "needs_retry"];
+    for task in tasks.iter().rev() {
+        let assignee = task.get("assignee").and_then(Value::as_str);
+        let status = task
+            .get("status")
+            .and_then(Value::as_str)
+            .unwrap_or("pending");
+        if assignee == Some(agent_id) && ACTIVE.contains(&status) {
+            return task.get("id").and_then(Value::as_str).map(str::to_string);
+        }
+    }
+    None
+}
+
+pub(super) fn agent_health_status_text(status: &str) -> String {
+    serde_json::to_value(crate::provider::agent_health_status(status))
+        .ok()
+        .and_then(|v| v.as_str().map(str::to_string))
+        .unwrap_or_else(|| "-".to_string())
+}
+
+/// Python `agent.get(key, '-')`:键缺失 → `-`;键存在但为 null → 打印 `None`。
+pub(super) fn py_get(agent: &Value, key: &str) -> String {
+    match agent.get(key) {
+        None => "-".to_string(),
+        Some(Value::Null) => "None".to_string(),
+        Some(Value::String(s)) => s.clone(),
+        Some(other) => other.to_string(),
+    }
+}
+
+/// Python `agent.get(key) or '-'`:缺失/null/空串都落 `-`。
+pub(super) fn py_get_or_dash(agent: &Value, key: &str) -> String {
+    match agent.get(key) {
+        Some(Value::String(s)) if !s.is_empty() => s.clone(),
+        Some(Value::Number(n)) => n.to_string(),
+        _ => "-".to_string(),
+    }
+}
+
+/// `status.approvals(workspace, agent_id)`(JSON)/`format_approvals`(人读)。
+pub fn format_approvals(value: &Value) -> String {
+    let approvals = value
+        .get("approvals")
+        .and_then(Value::as_array)
+        .map(Vec::as_slice)
+        .unwrap_or(&[]);
+    if approvals.is_empty() {
+        return "No pending approvals.".to_string();
+    }
+    approvals
+        .iter()
+        .map(|approval| {
+            let agent = approval
+                .get("agent_id")
+                .and_then(Value::as_str)
+                .unwrap_or("-");
+            let kind = approval
+                .get("kind")
+                .and_then(Value::as_str)
+                .unwrap_or("unknown");
+            let prompt = approval
+                .get("prompt")
+                .and_then(Value::as_str)
+                .or_else(|| approval.get("subject").and_then(Value::as_str))
+                .unwrap_or("-");
+            format!("{agent}: {kind} {prompt}")
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}

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

@@ -0,0 +1,36 @@
+use super::*;
+
+pub fn inbox(
+    workspace: &Path,
+    agent: &str,
+    limit: usize,
+    since: Option<&str>,
+    as_json: bool,
+    owner_team_id: Option<&str>,
+) -> Result<Value, CliError> {
+    let _ = as_json;
+    let store = crate::message_store::MessageStore::open(workspace)
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let mut messages = store
+        .inbox(agent, limit, owner_team_id)
+        .map_err(|e| CliError::Runtime(e.to_string()))?;
+    if let Some(cutoff) = since.and_then(parse_rfc3339) {
+        messages.retain(|message| {
+            message
+                .get("created_at")
+                .and_then(Value::as_str)
+                .and_then(parse_rfc3339)
+                .is_some_and(|created| created >= cutoff)
+        });
+    }
+    Ok(json!({
+        "ok": true,
+        "agent_id": agent,
+        "messages": messages,
+        "since": since,
+    }))
+}
+
+pub(super) fn parse_rfc3339(value: &str) -> Option<chrono::DateTime<chrono::FixedOffset>> {
+    chrono::DateTime::parse_from_rfc3339(value).ok()
+}

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

@@ -0,0 +1,195 @@
+use super::*;
+
+/// 0.5.41 Slice 3 (fault-invisibility-locate.md §5): single-source
+/// runtime freshness projection consumed by status/diagnose. Read-
+/// only over existing sources (`coordinator_health`, heartbeat
+/// sidecar, watch state); computes NO transport calls of its own.
+#[derive(Default, Clone)]
+pub(crate) struct RuntimeFreshness {
+    pub coordinator_service_available: bool,
+    pub host_boot_stale: bool,
+    pub host_boot_recorded: Option<String>,
+    pub host_boot_current: Option<String>,
+    pub provider_exited_agents: std::collections::BTreeSet<String>,
+}
+
+impl RuntimeFreshness {
+    pub(super) fn host_boot_stale_reason(&self) -> Option<&'static str> {
+        self.host_boot_stale.then_some("host_boot_mismatch")
+    }
+}
+
+pub(crate) fn compute_runtime_freshness(
+    workspace: &Path,
+    state: &Value,
+    health: &crate::coordinator::HealthReport,
+) -> RuntimeFreshness {
+    let workspace_path = crate::coordinator::WorkspacePath::new(workspace.to_path_buf());
+    let heartbeat = crate::coordinator::read_coordinator_heartbeat(&workspace_path);
+    let host_boot_recorded = heartbeat
+        .as_ref()
+        .and_then(|hb| hb.get("host_boot_id"))
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty() && *s != "unknown")
+        .map(str::to_string);
+    let host_boot_current = crate::coordinator::probe_host_boot_id();
+    let host_boot_stale = match (host_boot_recorded.as_deref(), host_boot_current.as_deref()) {
+        (Some(recorded), Some(current)) => recorded != current,
+        _ => false,
+    };
+    // Collect worker-provider-exited agents from the coordinator
+    // abnormal_exit_watch payload. Only the typed positive provider-exit
+    // marker participates here: generic process/pane death diagnostics are
+    // not proof that the provider exited. Read from top-level
+    // `coordinator.abnormal_exit_watch`
+    // OR the team-scoped mirror `teams.<key>.coordinator...`.
+    let mut provider_exited_agents = std::collections::BTreeSet::new();
+    for path in [
+        "/coordinator/abnormal_exit_watch",
+        &format!(
+            "/teams/{}/coordinator/abnormal_exit_watch",
+            state
+                .get("active_team_key")
+                .and_then(Value::as_str)
+                .unwrap_or("")
+        ),
+    ] {
+        if let Some(watch) = state.pointer(path).and_then(Value::as_object) {
+            for (agent_id, entry) in watch {
+                let exited =
+                    entry.get("worker_provider_exited").and_then(Value::as_bool) == Some(true);
+                if exited {
+                    provider_exited_agents.insert(agent_id.clone());
+                }
+            }
+        }
+    }
+    RuntimeFreshness {
+        coordinator_service_available: health.service_available,
+        host_boot_stale,
+        host_boot_recorded,
+        host_boot_current,
+        provider_exited_agents,
+    }
+}
+
+pub(super) fn build_runtime_status_block(
+    coordinator_running: bool,
+    undelivered: i64,
+    tmux_session_missing: bool,
+    freshness: &RuntimeFreshness,
+) -> Value {
+    let mut runtime = serde_json::Map::new();
+    runtime.insert(
+        "coordinator".to_string(),
+        json!({"ok": coordinator_running}),
+    );
+    runtime.insert("undelivered".to_string(), json!(undelivered));
+    // 0.5.41 Slice 3 (fault-invisibility-locate.md §5/§6.3): expose
+    // typed issues on the runtime block so `status --json --detail`
+    // can be scanned for `runtime_bindings_stale_after_boot` the
+    // same way `diagnose` surfaces it. Hint precedence: session-
+    // missing > host-boot-stale > coordinator-not-running-with-
+    // backlog — most-actionable-first.
+    let mut issues: Vec<Value> = Vec::new();
+    if freshness.host_boot_stale {
+        issues.push(json!({
+            "id": "runtime_bindings_stale_after_boot",
+            "recorded_host_boot_id": freshness.host_boot_recorded,
+            "current_host_boot_id": freshness.host_boot_current,
+        }));
+    }
+    if !issues.is_empty() {
+        runtime.insert("issues".to_string(), Value::Array(issues));
+    }
+    if tmux_session_missing {
+        runtime.insert(
+            "hint".to_string(),
+            json!("tmux session missing — run team-agent restart"),
+        );
+    } else if freshness.host_boot_stale {
+        runtime.insert(
+            "hint".to_string(),
+            json!("runtime_bindings_stale_after_boot — run team-agent restart"),
+        );
+    } else if !coordinator_running && undelivered > 0 {
+        runtime.insert(
+            "hint".to_string(),
+            json!(format!(
+                "coordinator not running with {undelivered} undelivered — run team-agent restart"
+            )),
+        );
+    }
+    Value::Object(runtime)
+}
+
+/// Whether the coordinator HealthReport reflects a running tick loop. Used by the
+/// runtime block + the hint gate.
+pub(super) fn coordinator_status_running(health: &crate::coordinator::HealthReport) -> bool {
+    // 0.5.41 Slice 3 (fault-invisibility-locate.md §5/§6.3): runtime
+    // service predicate is `service_available`, not any-`Running` pid.
+    // A stale-pid daemon is CoordinatorHealthStatus::Stale (or Running
+    // with metadata_ok=false); a service-compatible newer daemon is
+    // Running + service_available=true — send/diagnose already use
+    // this same truth source, and status must agree.
+    health.service_available
+}
+
+/// Count of messages currently sitting in delivery-able backlog
+/// (accepted/pending/queued forms — not delivered / not failed / not refused).
+/// owner_team_id scope honored when present.
+pub(super) fn coordinator_health_value(health: crate::coordinator::HealthReport) -> Value {
+    let expose_binary_drift = health.service_available && !health.metadata_ok;
+    let binary_identity_relation = health.binary_identity_relation.as_str();
+    let mut value = json!({
+        "ok": health.ok,
+        "status": coordinator_status_wire(health.status),
+        "pid": health.pid.map(|p| p.get()),
+        "metadata": health.metadata.map(|m| json!({
+            "pid": m.pid.get(),
+            "protocol_version": m.protocol_version,
+            "message_store_schema_version": m.message_store_schema_version,
+            "binary_path": m.binary_path,
+            "binary_version": m.binary_version,
+            "source": m.source,
+            "updated_at": m.updated_at,
+        })),
+        "metadata_ok": health.metadata_ok,
+        "metadata_mismatch_reason": health.metadata_mismatch_reason,
+        "binary_path": health.current_binary_identity.binary_path,
+        "binary_version": health.current_binary_identity.binary_version,
+        "schema_ok": health.schema.ok,
+        "schema_error": health.schema.error.map(|e| format!("{e:?}")),
+        "schema": {
+            "message_store_schema_version": health.schema.schema_version,
+        },
+        // 0.5.41 Slice 3 (fault-invisibility-locate.md §5/§6.3):
+        // `service_available` is now always exposed alongside `ok`
+        // and `status` so status/diagnose consumers can share one
+        // service-availability truth without keying on the legacy
+        // `expose_binary_drift` conditional (that path only fired
+        // for the newer-daemon-preserved shape). `binary_identity_
+        // relation` moves to always-on for the same reason — RED3
+        // scans the summary for `daemon_newer_than_caller`.
+        "service_available": health.service_available,
+        "binary_identity_relation": binary_identity_relation,
+    });
+    if expose_binary_drift {
+        if let Some(obj) = value.as_object_mut() {
+            obj.insert("wire_metadata_ok".to_string(), Value::Bool(true));
+            obj.insert("binary_identity_ok".to_string(), Value::Bool(false));
+        }
+    }
+    value
+}
+
+pub(super) fn coordinator_status_wire(
+    status: crate::coordinator::CoordinatorHealthStatus,
+) -> &'static str {
+    match status {
+        crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+        crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+        crate::coordinator::CoordinatorHealthStatus::Running => "running",
+        crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+    }
+}

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

@@ -0,0 +1,181 @@
+use super::agents::{enrich_agents, tmux_session_present};
+use super::compact::compact_status;
+use super::runtime::{
+    build_runtime_status_block, compute_runtime_freshness, coordinator_health_value,
+    coordinator_status_running,
+};
+use super::store::{
+    agent_health, count_undelivered_backlog, latest_result_summaries, message_counts,
+    pending_leader_notifications, queued_messages, result_counts,
+};
+use crate::cli::CliError;
+use crate::state::projection::OwnerTeamResolution;
+use serde_json::{json, Value};
+use std::path::Path;
+
+pub(crate) struct RuntimeSnapshot {
+    full: Value,
+}
+
+impl RuntimeSnapshot {
+    pub(crate) fn assemble(
+        workspace: &Path,
+        state: &Value,
+        owner_team_id: Option<&str>,
+    ) -> Result<Self, CliError> {
+        let resolved_owner_team_id = resolve_status_owner_team(workspace, owner_team_id)?;
+        let owner_team_id = resolved_owner_team_id.as_deref().or(owner_team_id);
+        let health = crate::coordinator::coordinator_health(
+            &crate::coordinator::WorkspacePath::new(workspace.to_path_buf()),
+        );
+        let store = crate::message_store::MessageStore::open(workspace)
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        let conn = crate::db::schema::open_db(store.db_path())
+            .map_err(|e| CliError::Runtime(e.to_string()))?;
+        // B-5 / 036b N38 explicable — status 出口 runtime 块:把 coordinator_health
+        // (现状)+ undelivered backlog count 一起暴露;coordinator not running ∧
+        // backlog>0 才挂 down-hint(anti-nag)。auto-recovery 不做(user 已裁)。
+        let coordinator_running = coordinator_status_running(&health);
+        let undelivered_backlog = count_undelivered_backlog(&conn, owner_team_id)?;
+        let session_name = state.get("session_name").cloned().unwrap_or(Value::Null);
+        let tmux_present = tmux_session_present(workspace, state, session_name.as_str());
+        // 0.5.41 Slice 3 (fault-invisibility-locate.md §5/§6.3): resolve
+        // RuntimeFreshness once and thread it through the runtime block
+        // and per-agent enrichment. This is the single-source read that
+        // makes host-boot / coordinator / provider-exit staleness win
+        // over cached state.agents and DB agent_health.
+        let freshness = compute_runtime_freshness(workspace, state, &health);
+        let runtime_block = build_runtime_status_block(
+            coordinator_running,
+            undelivered_backlog,
+            !tmux_present,
+            &freshness,
+        );
+        let agents = enrich_agents(workspace, state, tmux_present, &freshness);
+        let tasks = state.get("tasks").cloned().unwrap_or_else(|| json!([]));
+        let leader_receiver = state
+            .get("leader_receiver")
+            .cloned()
+            .unwrap_or_else(|| json!({}));
+        let is_external_leader = crate::state::projection::state_is_external_leader(state);
+        let leader_topology = if is_external_leader {
+            "external"
+        } else {
+            "managed"
+        };
+        let leader_attach_command = if is_external_leader {
+            None
+        } else {
+            let window_name = state
+                .pointer("/leader_receiver/window_name")
+                .and_then(Value::as_str)
+                .unwrap_or("leader");
+            session_name.as_str().and_then(|session| {
+                // Bug #7 (gate review §6): build the attach command from the
+                // SAME endpoint the readiness probe uses (state's persisted
+                // tmux_endpoint/tmux_socket), so the printed command matches
+                // where the session actually lives.
+                crate::tmux_backend::attach_command_for_runtime_state_or_workspace(
+                    workspace,
+                    Some(state),
+                    &crate::transport::SessionName::new(session.to_string()),
+                    window_name,
+                )
+            })
+        };
+        let mut readiness_state = state.clone();
+        if let Some(obj) = readiness_state.as_object_mut() {
+            obj.insert(
+                "tmux_session_present".to_string(),
+                serde_json::json!(tmux_present),
+            );
+        }
+        let readiness = crate::cli::diagnose::wait_readiness(&readiness_state);
+        let full = crate::redaction::redact_external_value(&json!({
+            "ok": true,
+            "team": state.pointer("/leader/id").cloned().unwrap_or_else(|| json!("leader")),
+            "session_name": state.get("session_name").cloned().unwrap_or(Value::Null),
+            "leader_topology": leader_topology,
+            "is_external_leader": is_external_leader,
+            "leader_attach_command": leader_attach_command,
+            "leader_client": state.get("leader_client").cloned().unwrap_or(Value::Null),
+            "tmux_session_present": tmux_present,
+            "all_spawned": readiness.get("all_spawned").cloned().unwrap_or(Value::Bool(false)),
+            "all_attached_receiver": readiness.get("all_attached_receiver").cloned().unwrap_or(Value::Bool(true)),
+            "all_resumable_have_session": readiness.get("all_resumable_have_session").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_complete": readiness.get("session_capture_complete").cloned().unwrap_or(Value::Bool(true)),
+            "session_capture_incomplete": readiness.get("session_capture_incomplete").cloned().unwrap_or(Value::Bool(false)),
+            "incomplete_session_capture_agents": readiness.get("incomplete_session_capture_agents").cloned().unwrap_or_else(|| json!([])),
+            "pending_session_agent_ids": readiness.get("pending_session_agent_ids").cloned().unwrap_or_else(|| json!([])),
+            "leader_receiver": leader_receiver,
+            "teams": state.get("teams").cloned().unwrap_or_else(|| json!({})),
+            "agents": agents,
+            "agent_health": agent_health(&conn, owner_team_id)?,
+            "tasks": tasks,
+            "messages": message_counts(&conn, owner_team_id)?,
+            "queued_messages": queued_messages(&conn, owner_team_id, 8)?,
+            "pending_leader_notifications": pending_leader_notifications(&conn, owner_team_id, 8)?,
+            "results": result_counts(&conn, owner_team_id)?,
+            "latest_results": latest_result_summaries(&store, owner_team_id)?,
+            "readiness": readiness,
+            "coordinator": coordinator_health_value(health),
+            "runtime": runtime_block,
+            "reminder": crate::cli::STATUS_REMINDER,
+            "last_events": Value::Array(
+                crate::event_log::EventLog::new(workspace)
+                    .tail(10)
+                    .map_err(|e| CliError::Runtime(e.to_string()))?,
+            ),
+        }));
+        Ok(Self { full })
+    }
+
+    pub(crate) fn full(&self) -> &Value {
+        &self.full
+    }
+
+    pub(crate) fn into_full(self) -> Value {
+        self.full
+    }
+
+    pub(crate) fn compact(&self) -> Value {
+        compact_status(self.full.clone())
+    }
+}
+
+pub(super) fn read_runtime_state(workspace: &Path) -> Value {
+    crate::state::repository::StateRepository::new(workspace)
+        .load_workspace_if_exists_without_migrations()
+        .ok()
+        .flatten()
+        .unwrap_or_else(|| json!({}))
+}
+
+pub(super) fn resolve_status_owner_team(
+    workspace: &Path,
+    owner_team_id: Option<&str>,
+) -> Result<Option<String>, CliError> {
+    let Some(requested) = owner_team_id.filter(|team| !team.is_empty()) else {
+        return Ok(None);
+    };
+    let state = read_runtime_state(workspace);
+    match crate::state::projection::resolve_owner_team_id(&state, requested) {
+        OwnerTeamResolution::Canonical(canonical) => Ok(Some(canonical)),
+        OwnerTeamResolution::LegacyAlias {
+            requested,
+            canonical,
+        } => {
+            let log = crate::event_log::EventLog::new(workspace);
+            crate::messaging::delivery::normalize_owner_team_id_rows(
+                workspace,
+                &requested,
+                &canonical,
+                None,
+                Some(&log),
+            )
+            .map_err(CliError::from)?;
+            Ok(Some(canonical))
+        }
+        OwnerTeamResolution::Unresolved { .. } | OwnerTeamResolution::Ambiguous { .. } => Ok(None),
+    }
+}