@team-agent/installer 0.5.89 → 0.5.92

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;
@@ -66,6 +66,7 @@ pub mod profile;
 pub mod send;
 pub(crate) mod spec;
 pub mod status;
+pub(crate) mod triage;
 pub mod types;
 
 pub use adapters::*;
@@ -5050,17 +5051,44 @@ pub mod diagnose_port {
             return;
         }
         for (idx, line) in text.lines().enumerate() {
-            if line.contains("OPENAI_API_KEY=") || line.contains("ANTHROPIC_API_KEY=") {
-                let rel = path.strip_prefix(root).unwrap_or(path);
-                findings.push(json!({
-                    "path": rel.to_string_lossy().to_string(),
-                    "line": idx.saturating_add(1),
-                    "rule": "api_key_assignment",
-                    "match_excerpt": line.trim(),
-                }));
-            }
+            let Some(key) = secret_assignment_key(line) else {
+                continue;
+            };
+            let rel = path.strip_prefix(root).unwrap_or(path);
+            findings.push(json!({
+                "path": rel.to_string_lossy().to_string(),
+                "line": idx.saturating_add(1),
+                "rule": "api_key_assignment",
+                "match_excerpt": format!("{key}=<redacted>"),
+            }));
         }
     }
+
+    fn secret_assignment_key(line: &str) -> Option<&'static str> {
+        let line = line.trim_start();
+        let line = match line.strip_prefix("export") {
+            Some(rest) if rest.chars().next().is_some_and(char::is_whitespace) => rest.trim_start(),
+            _ => line,
+        };
+        ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"]
+            .into_iter()
+            .find(|key| {
+                line.strip_prefix(*key)
+                    .and_then(|rest| rest.strip_prefix('='))
+                    .is_some_and(|rhs| {
+                        let rhs = rhs.trim();
+                        let rhs = rhs
+                            .strip_prefix('"')
+                            .and_then(|value| value.strip_suffix('"'))
+                            .or_else(|| {
+                                rhs.strip_prefix('\'')
+                                    .and_then(|value| value.strip_suffix('\''))
+                            })
+                            .unwrap_or(rhs);
+                        !rhs.is_empty()
+                    })
+            })
+    }
     ///
     /// `run_comms_selftest`(`--comms`/`--gate comms`)。**纯 state-read,零 token**(MUST-NOT-13)。
     #[cfg(test)]

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 },

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

@@ -1,37 +1,62 @@
 //!
 use super::*;
 
+const SUMMARY_LIMIT: usize = 120;
+
+fn clean_text(text: &str) -> String {
+    text.chars().filter(|ch| !ch.is_control()).collect()
+}
+
+fn compact_field(value: Option<&Value>) -> Value {
+    value
+        .and_then(Value::as_str)
+        .map(|text| Value::String(clean_text(text)))
+        .unwrap_or(Value::Null)
+}
+
 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
+    let 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)
-        });
-    }
+        .map_err(|e| CliError::Runtime(e.to_string()))?
+        .into_iter()
+        .map(compact_message)
+        .collect::<Vec<_>>();
     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()
+fn compact_message(message: Value) -> Value {
+    json!({
+        "message_id": compact_field(message.get("message_id")),
+        "sender": compact_field(message.get("sender")),
+        "recipient": compact_field(message.get("recipient")),
+        "status": compact_field(message.get("status")),
+        "created_at": compact_field(message.get("created_at")),
+        "summary": compact_summary(message.get("content").and_then(Value::as_str).unwrap_or("")),
+    })
+}
+
+fn compact_summary(content: &str) -> String {
+    let summary = content
+        .lines()
+        .map(|line| clean_text(line).trim().to_string())
+        .find(|line| !line.is_empty())
+        .unwrap_or_default();
+    let mut chars = summary.chars();
+    let truncated = chars.by_ref().take(SUMMARY_LIMIT).collect::<String>();
+    if chars.next().is_some() {
+        format!("{truncated}…")
+    } else {
+        truncated
+    }
 }

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

@@ -211,36 +211,44 @@ fn approvals_golden_shape_has_waiting_count_and_scan_not_agent() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
-// ── inbox: golden {ok,agent_id,messages,since} (status/inbox.py:35-38) — key is `agent_id`, carries
-// `since` (not `agent`/`limit`). RUST mod.rs:136-144 stub {ok,agent,limit,messages}. RED. ──────────
+// ── inbox: compact fallback projection ───────────────────────────────────────────────
 #[test]
-fn inbox_golden_shape_is_agent_id_and_since_not_agent_limit() {
+fn inbox_golden_shape_is_compact_and_scoped_to_agent() {
     let ws = tmp_workspace();
-    let v = status_port::inbox(&ws, "alpha", 20, None, true, None).expect("inbox");
+    let v = status_port::inbox(&ws, "alpha", 3, None).expect("inbox");
     let obj = v.as_object().expect("inbox dict");
+    assert_eq!(v["agent_id"], json!("alpha"));
     let order: Vec<&str> = obj.keys().map(String::as_str).collect();
-    assert_eq!(
-            order,
-            vec!["ok", "agent_id", "messages", "since"],
-            "golden inbox 4-key order {{ok,agent_id,messages,since}} (inbox.py:38); Rust stub uses agent/limit. got {order:?}"
-        );
-    assert_eq!(
-        v["agent_id"],
-        json!("alpha"),
-        "golden key is `agent_id` (not `agent`)"
-    );
-    assert!(
-        obj.contains_key("since"),
-        "golden inbox carries `since` (echoed, null here)"
-    );
-    assert!(
-        !obj.contains_key("agent"),
-        "golden inbox has NO bare `agent` key"
-    );
-    assert!(
-        !obj.contains_key("limit"),
-        "golden inbox has NO `limit` key in the result dict"
-    );
+    assert_eq!(order, vec!["ok", "agent_id", "messages"]);
+    let _ = std::fs::remove_dir_all(&ws);
+}
+
+#[test]
+fn inbox_excludes_leader_stage_result_notifications() {
+    let ws = tmp_workspace();
+    let store = crate::message_store::MessageStore::open(&ws).unwrap();
+    let message_id = store
+        .create_message(
+            None,
+            "leader",
+            "worker",
+            "Task t reported success; Result id: res-1",
+            None,
+            false,
+            None,
+        )
+        .unwrap();
+    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
+    conn.execute(
+        "update messages set presentation = ?1 where message_id = ?2",
+        rusqlite::params![
+            json!({"sink": "leader", "class": "stage_result"}).to_string(),
+            message_id,
+        ],
+    )
+    .unwrap();
+    let value = status_port::inbox(&ws, "leader", 3, None).expect("inbox");
+    assert!(value["messages"].as_array().unwrap().is_empty());
     let _ = std::fs::remove_dir_all(&ws);
 }
 

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

@@ -208,7 +208,7 @@ fn inbox_returns_stored_message_for_recipient() {
     let mid = store
         .create_message(None, "leader", "w1", "hello w1", None, true, None)
         .unwrap();
-    let v = status_port::inbox(&ws, "w1", 20, None, true, None).expect("inbox");
+    let v = status_port::inbox(&ws, "w1", 20, None).expect("inbox");
     let messages = v["messages"].as_array().expect("messages array");
     assert_eq!(
             messages.len(),
@@ -223,30 +223,12 @@ fn inbox_returns_stored_message_for_recipient() {
     );
     assert_eq!(m["recipient"], json!("w1"));
     assert_eq!(m["sender"], json!("leader"));
-    assert_eq!(m["content"], json!("hello w1"));
+    assert_eq!(m["summary"], json!("hello w1"));
     assert_eq!(
         m["status"],
         json!("accepted"),
         "create_message persists status='accepted'"
     );
-    // NULL owner_team_id semantics: status.inbox() calls MessageStore.inbox(agent) with
-    // owner_team_id=None (no team clause), so a NULL-owner message MUST surface for its recipient.
-    assert_eq!(
-        m["owner_team_id"],
-        json!(null),
-        "the stored message's owner_team_id is NULL and still returned"
-    );
-    // byte-faithful raw-row columns: requires_ack is the 0/1 INT; artifact_refs the literal text "[]".
-    assert_eq!(
-        m["requires_ack"],
-        json!(1),
-        "requires_ack is the 0/1 int, not a bool"
-    );
-    assert_eq!(
-        m["artifact_refs"],
-        json!("[]"),
-        "artifact_refs is the raw text column, not parsed"
-    );
     let _ = std::fs::remove_dir_all(&ws);
 }
 // ── BUG-2 (match scope) — inbox(agent) returns rows where sender==agent OR recipient==agent, and
@@ -265,11 +247,11 @@ fn inbox_matches_sender_or_recipient_and_excludes_others() {
     store
         .create_message(None, "leader", "w2", "unrelated to w2", None, true, None)
         .unwrap();
-    let v = status_port::inbox(&ws, "w1", 20, None, true, None).expect("inbox");
+    let v = status_port::inbox(&ws, "w1", 20, None).expect("inbox");
     let messages = v["messages"].as_array().expect("messages array");
     let mut contents: Vec<String> = messages
         .iter()
-        .map(|m| m["content"].as_str().unwrap().to_string())
+        .map(|m| m["summary"].as_str().unwrap().to_string())
         .collect();
     contents.sort();
     assert_eq!(
@@ -691,54 +673,6 @@ fn remove_agent_from_spec_refusal_is_not_success_envelope() {
     );
 }
 #[test]
-fn collect_uncollected_result_marks_db_and_outputs_result() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    seed_uncollected_result(&ws, "res_collect_red");
-    let out = json_output(
-        cmd_collect(&CollectArgs {
-            workspace: ws.clone(),
-            result_file: None,
-            json: true,
-            team: None,
-        })
-        .unwrap(),
-    );
-    assert_eq!(out["ok"], json!(true));
-    assert_eq!(
-        out["collected_results"][0]["result_id"],
-        json!("res_collect_red")
-    );
-    assert_eq!(out["collected_results"][0]["scope"], json!("task"));
-    assert_eq!(
-        out["results"],
-        json!({"total": 1, "uncollected": 0, "collected": 1, "invalid": 0, "by_status": {}})
-    );
-    let store = crate::message_store::MessageStore::open(&ws).unwrap();
-    let conn = crate::db::schema::open_db(store.db_path()).unwrap();
-    let status: String = conn
-        .query_row(
-            "select status from results where result_id = 'res_collect_red'",
-            [],
-            |row| row.get(0),
-        )
-        .unwrap();
-    assert_eq!(status, "collected");
-    let state = read_state(&ws);
-    assert_eq!(state["tasks"][0]["status"], json!("done"));
-    assert_eq!(
-        state["tasks"][0]["accepted_result_id"],
-        json!("res_collect_red")
-    );
-    assert!(
-        read_events(&ws)
-            .iter()
-            .any(|e| e["event"] == json!("collect.result")
-                && e["result_id"] == json!("res_collect_red")),
-        "collect must emit collect.result for the stored result"
-    );
-}
-#[test]
 fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
     let ws = tmp_workspace();
     seed_collect_state(&ws);

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

@@ -275,36 +275,6 @@ fn seed_team_spec(ws: &std::path::Path) {
     std::fs::write(ws.join("team.spec.yaml"), spec).unwrap();
 }
 
-fn seed_collect_runtime_state(ws: &std::path::Path) {
-    crate::state::persist::save_runtime_state(
-        ws,
-        &json!({
-            "active_team_key": "fake-e2e",
-            "team_dir": ws.to_string_lossy().to_string(),
-            "spec_path": ws.join("team.spec.yaml").to_string_lossy().to_string(),
-            "session_name": "team-agent-fake-e2e",
-            "leader": {"id": "leader"},
-            "agents": {
-                "fake_impl": {
-                    "status": "running",
-                    "provider": "fake",
-                    "role": "implementation_engineer",
-                    "window": "fake_impl",
-                    "owner_team_id": "fake-e2e"
-                }
-            },
-            "tasks": [{
-                "id": "task_impl",
-                "title": "Fake implementation",
-                "type": "implementation",
-                "status": "pending",
-                "assignee": "fake_impl"
-            }]
-        }),
-    )
-    .unwrap();
-}
-
 // ── sessions ── golden cli/parser.py:230 `cmd_sessions` -> runtime.sessions(ws). EXIT 0.
 // `team-agent sessions --workspace <ws> --json` on an empty ws ->
 //   {"ok":true,"sessions":[],"workspace":"<ws>"}  (--json sort_keys). RED: unrouted -> Error.
@@ -324,44 +294,6 @@ fn dispatch_routes_sessions_subcommand() {
     let _ = std::fs::remove_dir_all(&ws);
 }
 
-// ── collect ── golden parser.py:292 `cmd_collect` -> runtime.collect(ws). With a valid
-// team.spec.yaml present and nothing to collect -> EXIT 0, golden:
-//   {"collected":[],"collected_results":[],"coordinator":{"ok":false,"status":"not_required"},
-//    "delivered_messages":[],"invalid_results":[],"ok":true,"results":{...},"state_file":"<ws>/team_state.md"}
-// RED: unrouted -> Error.
-#[test]
-#[serial(env)]
-fn dispatch_routes_collect_with_spec() {
-    let _env = EnvUnsetGuard::unset(&[
-        "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",
-        "TMUX",
-        "TMUX_PANE",
-    ]);
-    let ws = tmp_workspace();
-    let _cleanup = WorkspaceCleanup(ws.clone());
-    seed_team_spec(&ws);
-    seed_collect_runtime_state(&ws);
-    let code = run(
-        &cli_argv(&["collect", "--workspace", &ws.to_string_lossy(), "--json"]),
-        &ws,
-    );
-    assert_eq!(
-            code,
-            ExitCode::Ok,
-            "`collect` must ROUTE to cmd_collect (parser.py:292); with a valid spec golden exits 0 \
-             {{collected,collected_results,coordinator,delivered_messages,invalid_results,ok,results,state_file}}; \
-             today -> unknown-subcommand 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.