@team-agent/installer 0.5.89 → 0.5.91

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.89"
+version = "0.5.91"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.89"
+version = "0.5.91"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -429,83 +429,6 @@ pub fn cmd_sessions(args: &SessionsArgs) -> Result<CmdResult, CliError> {
     ))
 }
 
-/// `cmd_collect`(`parser.py:292`)。
-#[cfg(test)]
-pub(crate) fn cmd_collect(args: &CollectArgs) -> Result<CmdResult, CliError> {
-    cmd_collect_for_team(args, args.team.as_deref())
-}
-
-pub fn cmd_collect_for_team(args: &CollectArgs, team: Option<&str>) -> Result<CmdResult, CliError> {
-    let selected = match crate::state::selector::resolve_active_team(
-        &args.workspace,
-        team,
-        crate::state::selector::SelectorMode::RuntimeOnly,
-    ) {
-        Ok(selected) => selected,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": args.workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let value = match if team.is_some() {
-        messaging::collect_for_team(
-            &selected.run_workspace,
-            args.result_file.as_deref(),
-            false,
-            Some(&selected.team_key),
-        )
-    } else {
-        messaging::collect(&selected.run_workspace, args.result_file.as_deref(), false)
-    } {
-        Ok(value) => value,
-        Err(error) => {
-            return Ok(CmdResult::from_json(
-                json!({
-                    "ok": false,
-                    "error": error.to_string(),
-                    "workspace": selected.run_workspace.to_string_lossy().to_string(),
-                }),
-                args.json,
-            ));
-        }
-    };
-    let results = value.get("results").cloned().unwrap_or_else(|| json!({}));
-    let ok = value.get("ok").and_then(Value::as_bool).unwrap_or(true);
-    Ok(CmdResult::from_json(
-        json!({
-            "collected": [],
-            "collected_results": value.get("collected_results").cloned().unwrap_or_else(|| json!([])),
-            "coordinator": {
-                "ok": false,
-                "status": "not_required",
-            },
-            "delivered_messages": value.get("delivered_messages").cloned().unwrap_or_else(|| json!([])),
-            "invalid_results": value.get("invalid_results").cloned().unwrap_or_else(|| json!([])),
-            "ok": ok,
-            "results": results,
-            "state_file": value
-                .get("state_file")
-                .cloned()
-                .unwrap_or_else(|| {
-                    json!(selected
-                        .spec_workspace
-                        .as_deref()
-                        .unwrap_or(&selected.run_workspace)
-                        .join("team_state.md")
-                        .to_string_lossy()
-                        .to_string())
-                }),
-        }),
-        args.json,
-    ))
-}
-
 pub fn cmd_results(args: &ResultsArgs) -> Result<CmdResult, CliError> {
     let selected = match crate::state::selector::resolve_active_team(
         &args.workspace,
@@ -846,14 +769,14 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 .mark(message_id, "delivered", None)
                 .map_err(crate::messaging::MessagingError::from)?;
         }
-        let _ = messaging::report_result(
+        let report = messaging::report_result(
             workspace,
             &json!({
                 "schema_version": "result_envelope_v1",
                 "task_id": "task_impl",
                 "agent_id": "fake_impl",
                 "status": "success",
-                "summary": "fake result collected",
+                "summary": "fake result finalized",
                 "changes": [],
                 "tests": [],
                 "risks": [],
@@ -861,25 +784,29 @@ fn run_fake_e2e(workspace: &Path) -> Result<Value, CliError> {
                 "next_actions": [],
             }),
         )?;
-    }
-    let mut collect = messaging::collect(workspace, None, false)?;
-    let collected = collect
-        .get("collected_results")
-        .and_then(Value::as_array)
-        .is_some_and(|items| !items.is_empty());
-    if let Some(obj) = collect.as_object_mut() {
-        obj.insert("collected".to_string(), Value::Bool(collected));
+        let auto_finalized = report
+            .get("finalization_status")
+            .and_then(Value::as_str)
+            == Some("auto_finalized");
+        let shutdown = fake_shutdown(workspace)?;
+        let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
+            && send.ok
+            && auto_finalized
+            && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
+        return Ok(json!({
+            "ok": ok,
+            "launch": launch,
+            "send": send_value,
+            "report": report,
+            "shutdown": shutdown,
+        }));
     }
     let shutdown = fake_shutdown(workspace)?;
-    let ok = launch.get("ok").and_then(Value::as_bool) == Some(true)
-        && send.ok
-        && collected
-        && shutdown.get("ok").and_then(Value::as_bool) == Some(true);
     Ok(json!({
-        "ok": ok,
+        "ok": false,
         "launch": launch,
         "send": send_value,
-        "collect": collect,
+        "report": null,
         "shutdown": shutdown,
     }))
 }
@@ -1286,89 +1213,82 @@ pub fn cmd_inbox(args: &InboxArgs) -> Result<CmdResult, CliError> {
         &selected.run_workspace,
         &args.agent,
         args.limit,
-        args.since.as_deref(),
-        args.json,
         Some(&selected.team_key),
     )?;
     if args.json {
         Ok(CmdResult::from_json(value, true))
     } else {
-        Ok(CmdResult::human(format_inbox_human(
-            &selected.run_workspace,
-            &args.agent,
-            args.since.as_deref(),
-            &value,
-            Some(&selected.team_key),
-        )?))
+        Ok(CmdResult::human(format_inbox_human(&args.agent, &value)))
     }
 }
 
-fn format_inbox_human(
-    workspace: &Path,
-    agent: &str,
-    since: Option<&str>,
-    value: &Value,
-    owner_team_id: Option<&str>,
-) -> Result<String, CliError> {
+const INBOX_LINE_LIMIT_BYTES: usize = 160;
+
+fn clean_inbox_field(value: &str) -> String {
+    value.chars().filter(|ch| !ch.is_control()).collect()
+}
+
+fn truncate_inbox_line(line: &str) -> String {
+    if line.len() <= INBOX_LINE_LIMIT_BYTES {
+        return line.to_string();
+    }
+    let budget = INBOX_LINE_LIMIT_BYTES.saturating_sub("…".len());
+    let mut end = 0;
+    for (index, ch) in line.char_indices() {
+        let next = index + ch.len_utf8();
+        if next > budget {
+            break;
+        }
+        end = next;
+    }
+    format!("{}…", &line[..end])
+}
+
+fn format_inbox_human(agent: &str, value: &Value) -> String {
     let messages = value
         .get("messages")
         .and_then(Value::as_array)
         .cloned()
         .unwrap_or_default();
-    let mut lines = Vec::new();
     if messages.is_empty() {
-        let mut line = format!("{agent}: no messages");
-        if let Some(since) = since {
-            line.push_str(" since ");
-            line.push_str(since);
-        }
-        lines.push(line);
-    } else {
-        lines.push(format!("{agent}: {} message(s)", messages.len()));
-        for message in messages {
-            let sender = message.get("sender").and_then(Value::as_str).unwrap_or("-");
-            let content = message.get("content").and_then(Value::as_str).unwrap_or("");
-            let status = message.get("status").and_then(Value::as_str).unwrap_or("-");
-            let attempts = message
-                .get("delivery_attempts")
-                .and_then(Value::as_i64)
-                .unwrap_or(0);
-            let error = message.get("error").and_then(Value::as_str).unwrap_or("-");
-            lines.push(format!(
-                "- {sender}: {content} [status={status} attempts={attempts} error={error}]"
-            ));
-        }
+        return format!("{agent}: no messages");
     }
-    let pending = uncollected_result_count(workspace, owner_team_id)?;
-    let mut note = "final results are not in inbox; use team-agent collect".to_string();
-    if pending > 0 {
-        note.push_str(&format!(" ({pending} uncollected result(s) pending)"));
-    }
-    lines.push(note);
-    Ok(lines.join("\n"))
-}
-
-fn uncollected_result_count(
-    workspace: &Path,
-    owner_team_id: Option<&str>,
-) -> Result<i64, CliError> {
-    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()))?;
-    match owner_team_id {
-        Some(team) => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid') and owner_team_id = ?1",
-            [team],
-            |row| row.get::<_, i64>(0),
-        ),
-        None => conn.query_row(
-            "select count(*) from results where status not in ('collected', 'invalid')",
-            [],
-            |row| row.get::<_, i64>(0),
-        ),
-    }
-    .map_err(|e| CliError::Runtime(e.to_string()))
+    messages
+        .iter()
+        .map(|message| {
+            let id = clean_inbox_field(
+                message
+                    .get("message_id")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let sender = clean_inbox_field(
+                message.get("sender").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let recipient = clean_inbox_field(
+                message
+                    .get("recipient")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let status = clean_inbox_field(
+                message.get("status").and_then(Value::as_str).unwrap_or("-"),
+            );
+            let time = clean_inbox_field(
+                message
+                    .get("created_at")
+                    .and_then(Value::as_str)
+                    .unwrap_or("-"),
+            );
+            let summary = clean_inbox_field(
+                message.get("summary").and_then(Value::as_str).unwrap_or(""),
+            );
+            truncate_inbox_line(&format!(
+                "[{id}] [{sender} -> {recipient}] [{status}] [{time}] [{summary}]"
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
 /// `cmd_takeover`(`commands.py:152`)。
@@ -1629,11 +1549,31 @@ mod tests {
     #![allow(clippy::unwrap_used)]
 
     use super::{
-        agent_pane_id, append_send_guidance, quickstart_human, send_command, split_shell_argv,
+        agent_pane_id, append_send_guidance, format_inbox_human, quickstart_human, send_command,
+        split_shell_argv,
     };
     use serde_json::{json, Value};
     use std::path::{Path, PathBuf};
 
+    #[test]
+    fn inbox_human_output_sanitizes_controls_and_caps_each_line() {
+        let value = json!({
+            "messages": [{
+                "message_id": "msg-\u{001b}[31m".repeat(20),
+                "sender": "sender\t\u{001b}[2J".repeat(20),
+                "recipient": "worker".repeat(20),
+                "status": "delivered",
+                "created_at": "2026-09-19T00:00:00Z",
+                "summary": "中".repeat(120)
+            }]
+        });
+        let output = format_inbox_human("worker", &value);
+        for line in output.lines() {
+            assert!(line.len() <= 160, "line is {} bytes: {line:?}", line.len());
+            assert!(!line.chars().any(char::is_control), "controls leaked: {line:?}");
+        }
+    }
+
     // E13:happy 人类输出必须带 attach 块(此前 else 分支只打 summary 丢 attach_commands)。
     #[test]
     fn e13_quickstart_human_includes_attach_commands() {

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

@@ -223,10 +223,6 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "validate" => cmd_validate(&validate_args(args, cwd)).map(emit_result),
         "install-skill" => cmd_install_skill(&install_skill_args(args)?).map(emit_result),
         "profile" => cmd_profile(&profile_args(args, cwd)?).map(emit_result),
-        "collect" => {
-            cmd_collect_for_team(&collect_args(args, cwd)?, parse_args(args).team.as_deref())
-                .map(emit_result)
-        }
         "results" => cmd_results(&results_args(args, cwd)?).map(emit_result),
         "wait" => cmd_wait(&wait_args(args, cwd)?).map(emit_result),
         "diagnose" => cmd_diagnose(&diagnose_args(args, cwd)).map(emit_result),
@@ -275,7 +271,6 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "validate",
     "install-skill",
     "profile",
-    "collect",
     "results",
     "wait",
     "diagnose",
@@ -328,7 +323,6 @@ pub(crate) fn default_help() -> String {
             "quick-start",
             "send",
             "status",
-            "collect",
             "results",
             "models",
             "leaders",
@@ -441,14 +435,13 @@ fn command_help(command: Option<&str>) -> String {
         Some("attach-app-server-leader") => "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]".to_string(),
         Some("identity") => "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("approvals") => "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
-        Some("inbox") => "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]".to_string(),
+        Some("inbox") => "usage: team-agent inbox AGENT [-n N|--limit N] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("doctor") => "usage: team-agent doctor [SPEC] [--workspace WORKSPACE] [--team TEAM] [--gate orphans|comms] [--comms] [--fix] [--fix-schema] [--cleanup-orphans] [--confirm] [--json]".to_string(),
         Some("watch") => "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]".to_string(),
         Some("sessions") => "usage: team-agent sessions [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("validate") => "usage: team-agent validate [SPEC] [--json]".to_string(),
         Some("install-skill") => "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]".to_string(),
         Some("profile") => "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]".to_string(),
-        Some("collect") => "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]".to_string(),
         Some("results") => "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("wait") => "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]".to_string(),
         Some("diagnose") => "usage: team-agent diagnose [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
@@ -842,7 +835,6 @@ struct ParsedArgs {
     confirm: bool,
     alert_type: Option<String>,
     limit: Option<usize>,
-    since: Option<String>,
     gate: Option<String>,
     comms: bool,
     fix: bool,
@@ -856,7 +848,6 @@ struct ParsedArgs {
     tail: Option<usize>,
     head: Option<usize>,
     search: Option<String>,
-    result_file: Option<PathBuf>,
     file: Option<PathBuf>,
     result: Option<String>,
     real: bool,
@@ -936,10 +927,9 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--from-spec" => parsed.from_spec = true,
             "--confirm" => parsed.confirm = true,
             "--alert-type" => parsed.alert_type = next_arg(args, &mut i),
-            "--limit" => {
+            "-n" | "--limit" => {
                 parsed.limit = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok())
             }
-            "--since" => parsed.since = next_arg(args, &mut i),
             "--gate" => parsed.gate = next_arg(args, &mut i),
             "--comms" => parsed.comms = true,
             "--fix" => parsed.fix = true,
@@ -955,7 +945,6 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--tail" => parsed.tail = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok()),
             "--head" => parsed.head = next_arg(args, &mut i).and_then(|v| v.parse::<usize>().ok()),
             "--search" => parsed.search = next_arg(args, &mut i),
-            "--result-file" => parsed.result_file = next_arg(args, &mut i).map(PathBuf::from),
             "--file" => parsed.file = next_arg(args, &mut i).map(PathBuf::from),
             "--result" => parsed.result = next_arg(args, &mut i),
             "--real" => parsed.real = true,
@@ -1438,12 +1427,19 @@ fn approvals_args(args: &[String], cwd: &Path) -> ApprovalsArgs {
 }
 
 fn inbox_args(args: &[String], cwd: &Path) -> Result<InboxArgs, CliError> {
+    if args
+        .iter()
+        .any(|arg| arg == "--since" || arg.starts_with("--since="))
+    {
+        return Err(CliError::Usage(
+            "inbox only supports -n/--limit; --since is not supported".to_string(),
+        ));
+    }
     let parsed = parse_args(args);
     Ok(InboxArgs {
         agent: required_pos(&parsed, 0, "agent")?,
         workspace: workspace(&parsed, cwd),
-        limit: parsed.limit.unwrap_or(20),
-        since: parsed.since,
+        limit: parsed.limit.unwrap_or(3),
         json: parsed.json,
         team: parsed.team,
     })
@@ -1848,18 +1844,6 @@ fn profile_args(args: &[String], cwd: &Path) -> Result<ProfileArgs, CliError> {
     })
 }
 
-fn collect_args(args: &[String], cwd: &Path) -> Result<CollectArgs, CliError> {
-    let parsed = parse_args(args);
-    let workspace = workspace(&parsed, cwd);
-    refuse_if_multi_alive_team_missing_scope("collect", &workspace, parsed.team.as_deref())?;
-    Ok(CollectArgs {
-        workspace,
-        result_file: parsed.result_file,
-        json: parsed.json,
-        team: parsed.team,
-    })
-}
-
 fn results_args(args: &[String], cwd: &Path) -> Result<ResultsArgs, CliError> {
     if args
         .iter()
@@ -2349,15 +2333,11 @@ mod tests {
                     "--json",
                 ][..],
             ),
-            (
-                "collect",
-                &["--workspace", "--team", "--result-file", "--json"][..],
-            ),
             ("stuck-list", &["--workspace", "--team", "--json"][..]),
             ("approvals", &["--workspace", "--team", "--json"][..]),
             (
                 "inbox",
-                &["--workspace", "--team", "--limit", "--since", "--json"][..],
+                &["--workspace", "--team", "-n", "--limit", "--json"][..],
             ),
             ("sessions", &["--workspace", "--team", "--json"][..]),
             ("diagnose", &["--workspace", "--team", "--json"][..]),
@@ -2665,37 +2645,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn refuse_helper_passes_when_explicit_team_provided_even_in_multi_alive() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        assert!(
-            refuse_if_multi_alive_team_missing_scope("collect", &ws, Some("alpha")).is_ok(),
-            "explicit --team alpha must bypass the ambiguity gate"
-        );
-    }
-
-    #[test]
-    fn refuse_helper_refuses_when_multi_alive_team_and_no_explicit_team() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        let err = refuse_if_multi_alive_team_missing_scope("collect", &ws, None)
-            .expect_err("multi-alive-team must refuse without --team");
-        let message = err.to_string();
-        assert!(
-            message.contains("multiple alive teams"),
-            "refusal must name the ambiguity; got: {message}"
-        );
-        assert!(
-            message.contains("alpha") && message.contains("beta"),
-            "refusal must list candidate teams; got: {message}"
-        );
-        assert!(
-            message.contains("collect"),
-            "refusal must name the command for diagnostic clarity; got: {message}"
-        );
-    }
-
     #[test]
     fn stuck_cancel_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();
@@ -2708,18 +2657,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn collect_args_builder_refuses_on_multi_alive_team() {
-        let ws = tmp_workspace();
-        seed_two_alive_teams_in(&ws);
-        let argv = cli_argv(&["--workspace", &ws.to_string_lossy()]);
-        let err = collect_args(&argv, &ws).expect_err("must refuse");
-        assert!(
-            err.to_string().contains("multiple alive teams"),
-            "collect args builder must surface the refusal; got: {err}"
-        );
-    }
-
     #[test]
     fn shutdown_args_builder_refuses_on_multi_alive_team() {
         let ws = tmp_workspace();

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

@@ -51,7 +51,7 @@ use crate::model::ids::{TaskId, TeamKey};
 pub(crate) const COMMS_BOUNDARY_TEXT: &str = "validates live pane binding consistency and zero-token comms contracts. Does NOT perform live runtime message round-trip. (zero token, zero pollution)";
 pub(crate) const QUICK_START_REMINDER: &str = "Reminder: Do not inspect raw worker terminal output during normal operation. Use team-agent status / inbox / collect instead. Wait for report_result.";
 pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker to report_result. Do not poll the worker terminal with capture-pane.";
-pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
+pub(crate) const STATUS_REMINDER: &str = "Results are finalized automatically; use --watch-result or team-agent inbox AGENT -n 3 for transport fallback. Do not capture-pane worker terminals.";
 
 pub mod adapters;
 pub mod attach_app_server_leader;

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

@@ -76,7 +76,6 @@ pub(crate) enum DispatchKind {
     Validate,
     InstallSkill,
     Profile,
-    Collect,
     Results,
     Wait,
     Diagnose,
@@ -123,7 +122,6 @@ pub(crate) const ALL_DISPATCH_KINDS: &[DispatchKind] = &[
     DispatchKind::Validate,
     DispatchKind::InstallSkill,
     DispatchKind::Profile,
-    DispatchKind::Collect,
     DispatchKind::Results,
     DispatchKind::Wait,
     DispatchKind::Diagnose,
@@ -170,7 +168,6 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--mailbox] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
-    CommandSpec { name: "collect", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Collect), summary: "collect reported results", usage: "usage: team-agent collect [--workspace WORKSPACE] [--team TEAM] [--result-file FILE] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, alias_of: None, sunset: None, action: None, governance: None },
@@ -208,7 +205,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "approvals", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Approvals), summary: "inspect provider approval state", usage: "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "approval diagnostics" }) },
     CommandSpec { name: "profile", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::Profile), summary: "manage provider profiles", usage: "usage: team-agent profile COMMAND NAME [--workspace WORKSPACE] [--team TEAM] [--auth-mode MODE] [--proxy-mode direct|inherit] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "provider/profile setup" }) },
     CommandSpec { name: "install-skill", tier: CommandTier::Secondary, category: CommandCategory::Setup, kind: CommandKind::Dispatch(DispatchKind::InstallSkill), summary: "install or uninstall Team Agent skills", usage: "usage: team-agent install-skill (--source DIR | --uninstall) [--target codex|claude|copilot|all] [--dest DIR] [--dry-run] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: Some(GovernanceNote { decision: "secondary", reason: "capability setup" }) },
-    CommandSpec { name: "inbox", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Inbox), summary: "inspect queued messages", usage: "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
+    CommandSpec { name: "inbox", tier: CommandTier::Secondary, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Inbox), summary: "inspect recent message summaries", usage: "usage: team-agent inbox AGENT [-n N|--limit N] [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
 
     CommandSpec { name: "identity", tier: CommandTier::DevInternal, category: CommandCategory::Dev, kind: CommandKind::Dispatch(DispatchKind::Identity), summary: "inspect identity metadata", usage: "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },
     CommandSpec { name: "watch", tier: CommandTier::DevInternal, category: CommandCategory::Dev, kind: CommandKind::Dispatch(DispatchKind::Watch), summary: "watch event logs", usage: "usage: team-agent watch [--workspace WORKSPACE] [--team TEAM]", default_help: false, command_help: true, suggestion_index: false, token_usage: TokenUsage::No, alias_of: None, sunset: None, action: None, governance: None },