@team-agent/installer 0.2.10 → 0.3.0

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

@@ -0,0 +1,306 @@
+//! `profile {init,doctor,show}` CLI verb.
+
+use super::*;
+
+const SECRET_BOUNDARY: &str = "# Team Agent Profile Secret Boundary\n";
+
+pub fn cmd_profile(args: &ProfileArgs) -> Result<CmdResult, CliError> {
+    let value = match args.command.as_str() {
+        "init" => init_profile(args)?,
+        "doctor" => doctor_profile(args)?,
+        "show" => show_profile(args)?,
+        other => {
+            return Err(CliError::Usage(format!("invalid profile command: {other}")));
+        }
+    };
+    Ok(CmdResult::from_json(value, args.json))
+}
+
+fn init_profile(args: &ProfileArgs) -> Result<Value, CliError> {
+    let auth_mode = args.auth_mode.as_deref().unwrap_or("subscription");
+    validate_auth_mode(auth_mode)?;
+    let dir = profile_dir(args);
+    std::fs::create_dir_all(&dir)?;
+    let path = dir.join(format!("{}.env", args.name));
+    let template_path = dir.join(format!("{}.example.env", args.name));
+    let body = profile_template(&args.name, auth_mode);
+    let created_profile = write_new_file(&path, &body)?;
+    if created_profile {
+        set_owner_only_permissions(&path)?;
+    }
+    let created_template = write_new_file(&template_path, &body)?;
+    write_boundary_files(&dir)?;
+
+    let mut obj = Map::new();
+    obj.insert("ok".to_string(), Value::Bool(true));
+    obj.insert("profile".to_string(), Value::String(args.name.clone()));
+    obj.insert("auth_mode".to_string(), Value::String(auth_mode.to_string()));
+    obj.insert("path".to_string(), path_value(&path));
+    obj.insert("template_path".to_string(), path_value(&template_path));
+    obj.insert("created_profile".to_string(), Value::Bool(created_profile));
+    obj.insert("created_template".to_string(), Value::Bool(created_template));
+    obj.insert("secret_written".to_string(), Value::Bool(created_profile));
+    obj.insert(
+        "safe_inspection_command".to_string(),
+        Value::String(safe_inspection_command(args)),
+    );
+    obj.insert(
+        "raw_file_read_allowed_for_agents".to_string(),
+        Value::Bool(false),
+    );
+    obj.insert(
+        "instruction".to_string(),
+        Value::String("Inspect credentials with team-agent profile show; do not read raw profile files from agent context.".to_string()),
+    );
+    Ok(Value::Object(obj))
+}
+
+fn doctor_profile(args: &ProfileArgs) -> Result<Value, CliError> {
+    let dir = profile_dir(args);
+    let path = dir.join(format!("{}.env", args.name));
+    let template_path = dir.join(format!("{}.example.env", args.name));
+    if !path.exists() {
+        return Ok(missing_profile_value(args, &path, Some(&template_path)));
+    }
+    let values = read_profile_env(&path)?;
+    let auth_mode =
+        profile_value(&values, "AUTH_MODE").unwrap_or_else(|| "subscription".to_string());
+    let secret_keys = secret_keys_present(&values);
+    let keys = sorted_keys(&values);
+    let mut obj = Map::new();
+    obj.insert("ok".to_string(), Value::Bool(true));
+    obj.insert("path".to_string(), path_value(&path));
+    obj.insert("profile".to_string(), Value::String(args.name.clone()));
+    obj.insert(
+        "credential_present".to_string(),
+        Value::Bool(credential_present(&values)),
+    );
+    obj.insert("auth_mode".to_string(), Value::String(auth_mode));
+    obj.insert("keys_present".to_string(), string_array(keys));
+    obj.insert(
+        "raw_file_read_allowed_for_agents".to_string(),
+        Value::Bool(false),
+    );
+    obj.insert(
+        "redaction_engine".to_string(),
+        Value::String("key_name".to_string()),
+    );
+    obj.insert("safe_for_agent_context".to_string(), Value::Bool(true));
+    obj.insert(
+        "safe_inspection_command".to_string(),
+        Value::String(safe_inspection_command(args)),
+    );
+    obj.insert("secret_keys_present".to_string(), string_array(secret_keys));
+    obj.insert("secret_values_printed".to_string(), Value::Bool(false));
+    obj.insert("suggestion".to_string(), Value::Null);
+    obj.insert("template_path".to_string(), path_value(&template_path));
+    Ok(Value::Object(obj))
+}
+
+fn show_profile(args: &ProfileArgs) -> Result<Value, CliError> {
+    let path = profile_dir(args).join(format!("{}.env", args.name));
+    if !path.exists() {
+        return Ok(missing_profile_value(args, &path, None));
+    }
+    let values = read_profile_env(&path)?;
+    let auth_mode =
+        profile_value(&values, "AUTH_MODE").unwrap_or_else(|| "subscription".to_string());
+    let secret_keys = secret_keys_present(&values);
+    let missing_common = missing_common_keys(&values, &auth_mode);
+    let mut obj = Map::new();
+    obj.insert("ok".to_string(), Value::Bool(true));
+    obj.insert("profile".to_string(), Value::String(args.name.clone()));
+    obj.insert(
+        "credential_present".to_string(),
+        Value::Bool(credential_present(&values)),
+    );
+    obj.insert("auth_mode".to_string(), Value::String(auth_mode));
+    obj.insert("values".to_string(), redacted_values(&values));
+    obj.insert("keys_present".to_string(), string_array(sorted_keys(&values)));
+    obj.insert("secret_keys_present".to_string(), string_array(secret_keys));
+    obj.insert("missing_common".to_string(), string_array(missing_common));
+    obj.insert("safe_for_agent_context".to_string(), Value::Bool(true));
+    obj.insert("secret_values_printed".to_string(), Value::Bool(false));
+    obj.insert(
+        "raw_file_read_allowed_for_agents".to_string(),
+        Value::Bool(false),
+    );
+    obj.insert(
+        "instruction".to_string(),
+        Value::String("Values are redacted for safe inspection by agents.".to_string()),
+    );
+    Ok(Value::Object(obj))
+}
+
+fn profile_dir(args: &ProfileArgs) -> PathBuf {
+    let _ = &args.team;
+    args.workspace.join(".team").join("current").join("profiles")
+}
+
+fn validate_auth_mode(auth_mode: &str) -> Result<(), CliError> {
+    match auth_mode {
+        "compatible_api" | "official_api" | "subscription" => Ok(()),
+        other => Err(CliError::Usage(format!("invalid --auth-mode: {other}"))),
+    }
+}
+
+fn profile_template(name: &str, auth_mode: &str) -> String {
+    match auth_mode {
+        "compatible_api" | "official_api" => {
+            format!("AUTH_MODE={auth_mode}\nPROFILE_NAME={name}\nAPI_KEY=\nMODEL=\n")
+        }
+        _ => format!("AUTH_MODE=subscription\nPROFILE_NAME={name}\n"),
+    }
+}
+
+fn write_new_file(path: &Path, body: &str) -> Result<bool, CliError> {
+    if path.exists() {
+        return Ok(false);
+    }
+    std::fs::write(path, body)?;
+    Ok(true)
+}
+
+fn write_boundary_files(dir: &Path) -> Result<(), CliError> {
+    for name in ["AGENTS.md", "CLAUDE.md"] {
+        write_new_file(&dir.join(name), SECRET_BOUNDARY)?;
+    }
+    Ok(())
+}
+
+#[cfg(unix)]
+fn set_owner_only_permissions(path: &Path) -> Result<(), CliError> {
+    use std::os::unix::fs::PermissionsExt as _;
+    let mut permissions = std::fs::metadata(path)?.permissions();
+    permissions.set_mode(0o600);
+    std::fs::set_permissions(path, permissions)?;
+    Ok(())
+}
+
+#[cfg(not(unix))]
+fn set_owner_only_permissions(path: &Path) -> Result<(), CliError> {
+    let _ = path;
+    Ok(())
+}
+
+fn read_profile_env(path: &Path) -> Result<Map<String, Value>, CliError> {
+    let raw = std::fs::read_to_string(path)?;
+    let mut values = Map::new();
+    for line in raw.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        let Some((key, value)) = trimmed.split_once('=') else {
+            continue;
+        };
+        values.insert(key.to_string(), Value::String(value.to_string()));
+    }
+    Ok(values)
+}
+
+fn redacted_values(values: &Map<String, Value>) -> Value {
+    let mut out = Map::new();
+    for key in sorted_keys(values) {
+        let value = values.get(&key).and_then(Value::as_str).unwrap_or("");
+        let mut item = Map::new();
+        item.insert("present".to_string(), Value::Bool(!value.is_empty()));
+        if is_secret_key(&key) {
+            item.insert("redacted".to_string(), Value::Bool(true));
+        } else {
+            item.insert("value".to_string(), Value::String(value.to_string()));
+        }
+        out.insert(key, Value::Object(item));
+    }
+    Value::Object(out)
+}
+
+fn profile_value(values: &Map<String, Value>, key: &str) -> Option<String> {
+    values
+        .get(key)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+fn missing_profile_value(args: &ProfileArgs, path: &Path, template_path: Option<&Path>) -> Value {
+    let mut obj = Map::new();
+    obj.insert("ok".to_string(), Value::Bool(false));
+    obj.insert("profile".to_string(), Value::String(args.name.clone()));
+    obj.insert("path".to_string(), path_value(path));
+    if let Some(template) = template_path {
+        obj.insert("template_path".to_string(), path_value(template));
+    }
+    obj.insert(
+        "suggestion".to_string(),
+        Value::String(format!(
+            "Run team-agent profile init {} --auth-mode subscription.",
+            args.name
+        )),
+    );
+    obj.insert(
+        "safe_inspection_command".to_string(),
+        Value::String(safe_inspection_command(args)),
+    );
+    Value::Object(obj)
+}
+
+fn safe_inspection_command(args: &ProfileArgs) -> String {
+    format!(
+        "team-agent profile show {} --workspace {}",
+        args.name,
+        args.workspace.display()
+    )
+}
+
+fn path_value(path: &Path) -> Value {
+    Value::String(path.to_string_lossy().to_string())
+}
+
+fn sorted_keys(values: &Map<String, Value>) -> Vec<String> {
+    let mut keys = values.keys().cloned().collect::<Vec<_>>();
+    keys.sort();
+    keys
+}
+
+fn string_array(values: Vec<String>) -> Value {
+    Value::Array(values.into_iter().map(Value::String).collect())
+}
+
+fn secret_keys_present(values: &Map<String, Value>) -> Vec<String> {
+    sorted_keys(values)
+        .into_iter()
+        .filter(|key| is_secret_key(key))
+        .collect()
+}
+
+fn credential_present(values: &Map<String, Value>) -> bool {
+    values.iter().any(|(key, value)| {
+        is_secret_key(key) && value.as_str().is_some_and(|raw| !raw.is_empty())
+    })
+}
+
+fn missing_common_keys(values: &Map<String, Value>, auth_mode: &str) -> Vec<String> {
+    let required = match auth_mode {
+        "compatible_api" | "official_api" => ["API_KEY", "MODEL"].as_slice(),
+        _ => ["AUTH_MODE", "PROFILE_NAME"].as_slice(),
+    };
+    required
+        .iter()
+        .filter(|key| {
+            values
+                .get(**key)
+                .and_then(Value::as_str)
+                .is_none_or(str::is_empty)
+        })
+        .map(|key| (*key).to_string())
+        .collect()
+}
+
+fn is_secret_key(key: &str) -> bool {
+    let upper = key.to_ascii_uppercase();
+    upper.contains("SECRET")
+        || upper.contains("TOKEN")
+        || upper.contains("PASSWORD")
+        || upper.contains("API_KEY")
+        || upper.ends_with("_KEY")
+}

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

@@ -0,0 +1,215 @@
+//! cli · send — `cmd_send` + target 解析(`_send_target`)+ `SendArgs`→`SendOptions` 翻译
+//! (`send_options_from_args`,旗标取反语义)。
+
+use super::*;
+use crate::messaging::{DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus};
+
+/// `cmd_send`(`commands.py:164`)。解析 target(`--to` fanout / 单 target / `*`)→ [`MessageTarget`],
+/// 拼 [`SendOptions`](no_ack→requires_ack 取反、no_wait→wait_visible 取反等)→ `messaging::send_message`。
+pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
+    let selected = crate::state::selector::resolve_active_team(
+        &args.workspace,
+        args.team.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    let target = send_target(args.targets.as_deref(), args.target.as_deref());
+    let mut opts = send_options_from_args(args);
+    if opts.team.is_none() {
+        opts.team = Some(TeamKey::new(selected.team_key.clone()));
+    }
+    let content = args.message.join(" ");
+    // CR-061/N27 routing-ambiguous: a single positional with no `--to`/`--targets` and an
+    // empty message body is a prompt-only invocation (`team-agent send "fix the build"`).
+    // The lone positional is CONTENT, not a target — reject with `routing_ambiguous`
+    // (NOT `target_not_in_team`, which would lie that the user did pick a target).
+    if let Some(amb) = routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts) {
+        return Ok(CmdResult::from_json(amb, args.json));
+    }
+    let outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
+    let mut value = delivery_outcome_json(&outcome, &target, &content, &opts);
+    if opts.watch_result {
+        if let Some(obj) = value.as_object_mut() {
+            obj.insert("watch".to_string(), watch_notice_json(&target, &opts));
+        }
+    }
+    Ok(CmdResult::from_json(value, args.json))
+}
+
+fn routing_ambiguous_value(
+    workspace: &Path,
+    args: &SendArgs,
+    target: &MessageTarget,
+    content: &str,
+    opts: &SendOptions,
+) -> Option<Value> {
+    if args.targets.is_some() || !content.is_empty() {
+        return None;
+    }
+    let MessageTarget::Single(name) = target else {
+        return None;
+    };
+    if name.is_empty() {
+        return None;
+    }
+    let state = crate::state::persist::load_runtime_state(workspace).ok()?;
+    let in_team = state
+        .get("agents")
+        .and_then(|v| v.as_object())
+        .is_some_and(|a| a.contains_key(name));
+    if in_team {
+        return None;
+    }
+    Some(json!({
+        "ok": false,
+        "status": "refused",
+        "target": null,
+        "agent_id": null,
+        "content": name,
+        "sender": opts.sender,
+        "message_id": null,
+        "message_status": "refused",
+        "verification": null,
+        "stage": null,
+        "reason": "routing_ambiguous",
+        "channel": null,
+    }))
+}
+
+/// `_send_target`(`commands.py:181-184`):`--to` comma-split fanout / `target` 单值 / None。
+pub fn send_target(targets: Option<&str>, target: Option<&str>) -> MessageTarget {
+    if let Some(targets) = targets.filter(|s| !s.is_empty()) {
+        let recipients: Vec<String> = targets
+            .split(',')
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .map(ToString::to_string)
+            .collect();
+        return MessageTarget::Fanout(recipients);
+    }
+    match target {
+        Some("*") => MessageTarget::Broadcast,
+        Some(target) => MessageTarget::Single(target.to_string()),
+        None => MessageTarget::Single(String::new()),
+    }
+}
+
+/// `cmd_send` 的 [`SendArgs`]→[`SendOptions`] 翻译(`commands.py:170-177`)。CLI **独占**的
+/// 旗标取反语义(经典 off-by-inversion bug 面):`no_ack→!requires_ack`、`no_wait→!wait_visible`、
+/// `watch_result` 直传、`task_id`/`sender`/`confirm_human`/`timeout`/`team` 透传。
+/// (其余 `lock_timeout`/`block_until_delivered` 用 [`SendOptions::default`]。)
+pub fn send_options_from_args(args: &SendArgs) -> SendOptions {
+    SendOptions {
+        task_id: args.task.as_ref().map(|s| TaskId::new(s.clone())),
+        route_task_id: true,
+        sender: args.sender.clone(),
+        requires_ack: !args.no_ack,
+        confirm_human: args.confirm_human,
+        wait_visible: !args.no_wait,
+        timeout: args.timeout,
+        watch_result: args.watch_result,
+        team: args.team.as_ref().map(|s| TeamKey::new(s.clone())),
+        message_id: args.message_id.clone(),
+        ..SendOptions::default()
+    }
+}
+
+fn watch_notice_json(target: &MessageTarget, opts: &SendOptions) -> Value {
+    let agent_id = match target {
+        MessageTarget::Single(agent) => agent.clone(),
+        MessageTarget::Broadcast => "*".to_string(),
+        MessageTarget::Fanout(recipients) => recipients.first().cloned().unwrap_or_else(|| "-".to_string()),
+    };
+    json!({
+        "status": "registered",
+        "watcher_id": format!("watch-{agent_id}"),
+        "task_id": opts.task_id.as_ref().map(|t| t.as_str().to_string()),
+        "agent_id": agent_id,
+        "notice": "Team Agent will collect the result and notify the leader when this task reports completion."
+    })
+}
+
+fn delivery_outcome_json(
+    outcome: &DeliveryOutcome,
+    target: &MessageTarget,
+    content: &str,
+    opts: &SendOptions,
+) -> Value {
+    let target_wire = target_json(target);
+    json!({
+        "ok": outcome.ok,
+        "status": delivery_status_wire(outcome.status),
+        "target": target_wire,
+        "agent_id": first_target(target),
+        "content": content,
+        "sender": opts.sender,
+        "message_id": outcome.message_id,
+        "message_status": outcome.message_status.0,
+        "verification": outcome.verification,
+        "stage": outcome.stage.map(delivery_stage_wire),
+        "reason": outcome.reason.map(delivery_refusal_wire),
+        "channel": outcome.channel,
+    })
+}
+
+fn target_json(target: &MessageTarget) -> Value {
+    match target {
+        MessageTarget::Single(agent) => json!(agent),
+        MessageTarget::Broadcast => json!("*"),
+        MessageTarget::Fanout(recipients) => json!(recipients),
+    }
+}
+
+fn first_target(target: &MessageTarget) -> String {
+    match target {
+        MessageTarget::Single(agent) => agent.clone(),
+        MessageTarget::Broadcast => "*".to_string(),
+        MessageTarget::Fanout(recipients) => recipients.first().cloned().unwrap_or_default(),
+    }
+}
+
+fn delivery_status_wire(status: DeliveryStatus) -> &'static str {
+    match status {
+        DeliveryStatus::Delivered => "delivered",
+        DeliveryStatus::Failed => "failed",
+        DeliveryStatus::Queued => "queued",
+        DeliveryStatus::Blocked => "blocked",
+        DeliveryStatus::Refused => "refused",
+        DeliveryStatus::RetryScheduled => "retry_scheduled",
+        DeliveryStatus::TrustAutoAnswerExhausted => "trust_auto_answer_exhausted",
+        DeliveryStatus::AlreadyDelivered => "already_delivered",
+        DeliveryStatus::FallbackLog => "fallback_log",
+        DeliveryStatus::BroadcastDelivered => "broadcast_delivered",
+        DeliveryStatus::BroadcastPartial => "broadcast_partial",
+        DeliveryStatus::FanoutDelivered => "fanout_delivered",
+        DeliveryStatus::FanoutPartial => "fanout_partial",
+    }
+}
+
+fn delivery_refusal_wire(reason: DeliveryRefusal) -> &'static str {
+    match reason {
+        DeliveryRefusal::TargetNotInTeam => "target_not_in_team",
+        DeliveryRefusal::HumanConfirmationRequired => "human_confirmation_required",
+        DeliveryRefusal::MissingPermissions => "missing_permissions",
+        DeliveryRefusal::RecipientBusy => "recipient_busy",
+        DeliveryRefusal::UnknownRecipient => "unknown_recipient",
+        DeliveryRefusal::TmuxTargetMissing => "tmux_target_missing",
+        DeliveryRefusal::MessageAlreadyClaimed => "message_already_claimed",
+        DeliveryRefusal::LeaderNotAttached => "leader_not_attached",
+        DeliveryRefusal::NoCallerPane => "no_caller_pane",
+        DeliveryRefusal::TeamOwnerMismatch => "team_owner_mismatch",
+        DeliveryRefusal::Ambiguous => "ambiguous",
+        DeliveryRefusal::RecipientPaneInNonInputMode => "recipient_pane_in_non_input_mode",
+        DeliveryRefusal::SessionDrift => "session_drift",
+        DeliveryRefusal::Duplicate => "duplicate",
+        DeliveryRefusal::RoutingAmbiguous => "routing_ambiguous",
+    }
+}
+
+fn delivery_stage_wire(stage: DeliveryStage) -> &'static str {
+    match stage {
+        DeliveryStage::TrustAutoAnswerDismissalWait => "trust_auto_answer_dismissal_wait",
+        DeliveryStage::Inject => "inject",
+        DeliveryStage::Submit => "submit",
+        DeliveryStage::VisibleCheck => "visible_check",
+    }
+}

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

@@ -0,0 +1,179 @@
+//! cli · status — 五行 triage summary 渲染 + agent 分类计数(commands.py
+//! `_format_status_summary` / `_agent_summary_counts` / `_interaction_counts` /
+//! `_latest_result_line` + `cmd_status` 的 compact 不变量)。
+
+use super::*;
+
+/// 单 agent 双信号(`status` × `agent_health.status`)→ 桶分类(`_agent_summary_counts` 内层)。
+/// **穷尽 match,禁默认 idle 臂**(§11)。`raw`/`hstatus` 已 lowercase。
+pub fn classify_agent_bucket(raw_status: &str, health_status: &str) -> SummaryBucket {
+    let raw = raw_status.to_ascii_lowercase();
+    let health = health_status.to_ascii_lowercase();
+    if matches!(raw.as_str(), "failed" | "error") || matches!(health.as_str(), "failed" | "error")
+    {
+        SummaryBucket::Failed
+    } else if matches!(raw.as_str(), "stopped" | "done") || health == "done" {
+        SummaryBucket::Stopped
+    } else if raw == "busy" || matches!(health.as_str(), "running" | "working") {
+        SummaryBucket::Busy
+    } else if health == "idle" {
+        SummaryBucket::Idle
+    } else if raw == "running" {
+        SummaryBucket::Running
+    } else {
+        SummaryBucket::Unknown
+    }
+}
+
+/// `_agent_summary_counts`(`commands.py:309-330`):遍历 agents×health → [`SummaryCounts`]。
+pub fn agent_summary_counts(agents: &Value, health: &Value) -> SummaryCounts {
+    let mut counts = SummaryCounts::default();
+    let Some(agent_map) = agents.as_object() else {
+        return counts;
+    };
+    for (agent_id, agent) in agent_map {
+        let raw = agent
+            .get("status")
+            .and_then(Value::as_str)
+            .unwrap_or("");
+        let hstatus = health
+            .get(agent_id)
+            .and_then(|v| v.get("status"))
+            .and_then(Value::as_str)
+            .unwrap_or("");
+        match classify_agent_bucket(raw, hstatus) {
+            SummaryBucket::Running => counts.running += 1,
+            SummaryBucket::Busy => counts.busy += 1,
+            SummaryBucket::Idle => counts.idle += 1,
+            SummaryBucket::Stopped => counts.stopped += 1,
+            SummaryBucket::Failed => counts.failed += 1,
+            SummaryBucket::Unknown => counts.unknown += 1,
+        }
+    }
+    counts
+}
+
+/// `_interaction_counts`(`commands.py:292-306`):遍历 agents 的 `interacted` 字段。
+pub fn interaction_counts(agents: &Value) -> InteractionCounts {
+    let mut counts = InteractionCounts::default();
+    let Some(agent_map) = agents.as_object() else {
+        return counts;
+    };
+    for agent in agent_map.values() {
+        let interacted = agent
+            .get("interacted")
+            .and_then(Value::as_str)
+            .unwrap_or("");
+        if !interacted.is_empty() && interacted != "never" {
+            counts.interacted += 1;
+        } else {
+            counts.never += 1;
+        }
+    }
+    counts
+}
+
+/// `_format_status_summary`(`commands.py:263-289`):把 status `Value` 渲染成五行 triage 文本。
+/// **Gap 18a 字节锁(§11)**:line[2] 精确串
+/// `agents: N — running=.. busy=.. idle=.. stopped=.. failed=.. unknown=..`,
+/// `(N interacted, M never)` 仅当 interacted>0 才追加(`commands.py:280-282`)。
+/// 五行:coordinator / receiver / agents / queued / latest result。空格/破折号/顺序禁改。
+pub fn format_status_summary(data: &Value) -> String {
+    let coordinator = non_empty_str(
+        data.get("coordinator")
+            .and_then(|v| v.get("status"))
+            .and_then(Value::as_str),
+        "stopped",
+    );
+    let schema_ok = python_truthy(
+        data
+        .get("coordinator")
+        .and_then(|v| v.get("schema_ok"))
+            .unwrap_or(&Value::Null),
+    );
+    let tmux = python_truthy(data.get("tmux_session_present").unwrap_or(&Value::Null));
+    let receiver = data.get("leader_receiver").unwrap_or(&Value::Null);
+    let pane = non_empty_str(
+        receiver.get("pane_id").and_then(Value::as_str),
+        "-",
+    );
+    let cmd = first_non_empty_str(
+        &[
+            receiver.get("pane_current_command").and_then(Value::as_str),
+            receiver.get("current_command").and_then(Value::as_str),
+        ],
+        "-",
+    );
+    let agents = data.get("agents").unwrap_or(&Value::Null);
+    let health = data.get("agent_health").unwrap_or(&Value::Null);
+    let counts = agent_summary_counts(agents, health);
+    let interactions = interaction_counts(agents);
+    let mut agent_line = format!(
+        "agents: {} — running={} busy={} idle={} stopped={} failed={} unknown={}",
+        counts.total(),
+        counts.running,
+        counts.busy,
+        counts.idle,
+        counts.stopped,
+        counts.failed,
+        counts.unknown
+    );
+    if interactions.interacted > 0 {
+        agent_line.push_str(&format!(
+            " ({} interacted, {} never)",
+            interactions.interacted, interactions.never
+        ));
+    }
+    let queued = data
+        .get("queued_messages")
+        .and_then(Value::as_array)
+        .map(Vec::len)
+        .unwrap_or(0);
+    let latest = data
+        .get("latest_results")
+        .and_then(Value::as_array)
+        .and_then(|arr| arr.first())
+        .filter(|v| python_truthy(v))
+        .map(format_latest_result)
+        .unwrap_or_else(|| "none".to_string());
+    format!(
+        "coordinator: {coordinator} schema_ok={schema_ok} tmux={tmux}\nreceiver: {pane} cmd={cmd}\n{agent_line}\nqueued: {queued} mailbox messages awaiting delivery\nlatest result: {latest}"
+    )
+}
+
+/// `_latest_result_line`(`commands.py:333-337`):agent_id/summary/created_at 渲染单行。
+/// summary `\n`→` ` 后 [:80] 截断、空 → `-`;agent_id 空 → `-`;created_at 经 age_text。
+pub(crate) fn format_latest_result(value: &Value) -> String {
+    let agent = non_empty_str(
+        value
+        .get("agent_id")
+        .and_then(Value::as_str)
+        ,
+        "-",
+    );
+    let raw_summary = value
+        .get("summary")
+        .and_then(Value::as_str)
+        .unwrap_or("");
+    let summary_flat = raw_summary.replace('\n', " ");
+    let summary = prefix_chars(&summary_flat, 80);
+    let summary = if summary.is_empty() {
+        "-".to_string()
+    } else {
+        summary
+    };
+    let created = age_text(
+        value
+        .get("created_at")
+        .and_then(Value::as_str)
+        ,
+    );
+    format!("{agent} -> {summary} @ {created}")
+}
+
+/// `cmd_status` 的 `--json` 分支 CLI **独占**的不变量(`commands.py:99`):
+/// `compact = not (detail is True)`。即 `detail=false ⇒ compact=true`(默认压缩),
+/// `detail=true ⇒ compact=false`(全量)。这是 CLI 在 status 委派之上唯一拥有的字节级映射。
+pub fn status_compact_flag(detail: bool) -> bool {
+    !detail
+}