@team-agent/installer 0.5.89 → 0.5.92

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

@@ -0,0 +1,183 @@
+//! Command-specific human triage projections for `doctor` and `diagnose`.
+//!
+//! The JSON report remains the source of truth. This renderer only projects its
+//! stable issue and repair entries; it does not perform I/O or recompute health.
+
+use serde_json::Value;
+
+use super::{CmdOutput, CmdResult};
+
+const LINE_LIMIT_BYTES: usize = 160;
+
+pub(crate) fn report(value: Value, as_json: bool, command: &str) -> CmdResult {
+    let result = CmdResult::from_json(value, as_json);
+    if as_json {
+        result
+    } else {
+        human_result(result, command)
+    }
+}
+
+pub(crate) fn human_result(result: CmdResult, command: &str) -> CmdResult {
+    let text = match &result.output {
+        CmdOutput::Json(report) => render(command, report),
+        CmdOutput::Human(text) => text.clone(),
+        CmdOutput::None => String::new(),
+    };
+    CmdResult {
+        output: CmdOutput::Human(text),
+        ..result
+    }
+}
+
+pub(crate) fn render(command: &str, report: &Value) -> String {
+    // Keep the renderer downstream of the external redaction boundary. The
+    // generic emitter redacts again for defense in depth.
+    let report = crate::redaction::redact_external_value(report);
+    let ok = report.get("ok").and_then(Value::as_bool).unwrap_or(false);
+    let mut lines = vec![bounded(format!(
+        "{command}: {}",
+        if ok { "ok" } else { "needs attention" }
+    ))];
+
+    if command == "doctor" {
+        for finding in array_items(
+            report
+                .get("secret_scan")
+                .and_then(|scan| scan.get("findings")),
+        ) {
+            let Some(object) = finding.as_object() else {
+                continue;
+            };
+            let (Some(rule), Some(path), Some(line)) = (
+                object.get("rule").and_then(Value::as_str),
+                object.get("path").and_then(Value::as_str),
+                object.get("line").and_then(Value::as_u64),
+            ) else {
+                continue;
+            };
+            lines.push(bounded(format!("warn: {rule} in {path}:{line}")));
+        }
+    }
+
+    for issue in array_items(report.get("issues")) {
+        lines.push(bounded(format!("issue: {}", summarize(issue, false))));
+    }
+    for repair in array_items(report.get("suggested_repairs")) {
+        lines.push(bounded(format!("repair: {}", summarize(repair, true))));
+    }
+    if let Some(error) = report.get("error").filter(|value| !value.is_null()) {
+        lines.push(bounded(format!("detail: {}", summarize(error, false))));
+    }
+    if lines.len() == 1 {
+        lines.push(bounded("detail: no issues detected".to_string()));
+    }
+    lines.join("\n")
+}
+
+fn array_items(value: Option<&Value>) -> &[Value] {
+    value.and_then(Value::as_array).map(Vec::as_slice).unwrap_or(&[])
+}
+
+fn summarize(value: &Value, repair: bool) -> String {
+    match value {
+        Value::String(value) => value.clone(),
+        Value::Null => "null".to_string(),
+        Value::Bool(value) => value.to_string(),
+        Value::Number(value) => value.to_string(),
+        Value::Array(values) => format!("{} entries", values.len()),
+        Value::Object(object) => {
+            let keys = if repair {
+                ["action", "hint_action", "next_action", "issue", "code", "reason"]
+                    .as_slice()
+            } else {
+                ["code", "issue", "id", "type", "status", "reason", "message"]
+                    .as_slice()
+            };
+            let mut parts = Vec::new();
+            for key in keys {
+                if let Some(value) = object.get(*key).and_then(Value::as_str) {
+                    parts.push(format!("{key}={value}"));
+                }
+            }
+            if parts.is_empty() {
+                let mut names = object.keys().cloned().collect::<Vec<_>>();
+                names.sort_unstable();
+                format!("fields={}", names.join(","))
+            } else {
+                parts.join("; ")
+            }
+        }
+    }
+}
+
+fn bounded(line: String) -> String {
+    let clean = line
+        .chars()
+        .map(|ch| if ch.is_control() { ' ' } else { ch })
+        .collect::<String>();
+    if clean.len() <= LINE_LIMIT_BYTES {
+        return clean;
+    }
+    let budget = LINE_LIMIT_BYTES.saturating_sub('…'.len_utf8());
+    let mut end = 0;
+    for (index, ch) in clean.char_indices() {
+        let next = index + ch.len_utf8();
+        if next > budget {
+            break;
+        }
+        end = next;
+    }
+    format!("{}…", &clean[..end.min(budget)])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn renderer_projects_each_issue_and_repair_without_dumping_runtime() {
+        let report = json!({
+            "ok": false,
+            "issues": ["short_issue", {"code": "object_issue", "message": "detail"}],
+            "suggested_repairs": [{"issue": "object_issue", "action": "run repair"}],
+            "providers": {"claude": {"version": "secret"}},
+            "runtime": {"workspace": "/tmp/secret"}
+        });
+        let output = render("diagnose", &report);
+        assert!(output.contains("issue: short_issue"));
+        assert!(output.contains("issue: code=object_issue"));
+        assert!(output.contains("repair: action=run repair"));
+        assert!(!output.contains("providers:"));
+        assert!(!output.contains("runtime:"));
+    }
+
+    #[test]
+    fn renderer_sanitizes_and_bounds_utf8_lines() {
+        let report = json!({"ok": false, "issues": ["问题\n".to_string() + &"x".repeat(200)]});
+        for line in render("doctor", &report).lines() {
+            assert!(line.len() <= LINE_LIMIT_BYTES);
+            assert!(!line.chars().any(char::is_control));
+        }
+    }
+
+    #[test]
+    fn renderer_projects_secret_findings_without_values() {
+        let report = json!({
+            "ok": false,
+            "secret_scan": {
+                "findings": [{
+                    "rule": "api_key_assignment",
+                    "path": "leaky-role.md",
+                    "line": 7,
+                    "match_excerpt": "OPENAI_API_KEY=secret"
+                }]
+            }
+        });
+        let output = render("doctor", &report);
+        assert!(output.contains("warn: api_key_assignment in leaky-role.md:7"));
+        assert!(!output.contains("match_excerpt"));
+        assert!(!output.contains("OPENAI_API_KEY=secret"));
+    }
+}

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

@@ -44,10 +44,10 @@ pub enum CliError {
     /// state 解析失败(歧义/未找到 team 等)。透传 step 5。
     #[error("{0}")]
     State(#[from] crate::state::StateError),
-    /// messaging 委派失败(send/collect/stuck)。透传 step 11。
+    /// messaging 委派失败(send/stuck)。透传 step 11。
     #[error("{0}")]
     Messaging(crate::messaging::MessagingError),
-    /// I/O(cli-error 落盘、inbox 游标读写)。bug-084:写路径降级,不裸 panic。
+    /// I/O(cli-error 落盘)。bug-084:写路径降级,不裸 panic。
     #[error("io: {0}")]
     Io(#[from] std::io::Error),
     /// JSON 解析。
@@ -407,13 +407,12 @@ pub struct ApprovalsArgs {
     pub team: Option<String>,
 }
 
-/// `inbox`(`parser.py:217`)。`--since` ISO8601(claim-leader inbox_hint 复用)。
+/// `inbox`(`parser.py:217`)。极简消息兜底查看器。
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InboxArgs {
     pub agent: String,
     pub workspace: PathBuf,
     pub limit: usize,
-    pub since: Option<String>,
     pub json: bool,
     /// Stage 4: explicit `--team` scope.
     pub team: Option<String>,
@@ -682,18 +681,6 @@ pub struct ProfileArgs {
     pub json: bool,
 }
 
-/// `collect`(`parser.py:292`)。
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CollectArgs {
-    pub workspace: PathBuf,
-    pub result_file: Option<PathBuf>,
-    pub json: bool,
-    /// Stage 4: explicit `--team` scope. Destructive (consumes result
-    /// envelopes); CLI dispatch refuses bare invocation in a
-    /// multi-alive-team workspace.
-    pub team: Option<String>,
-}
-
 /// Read-only lookup of all stored result envelopes for one case.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ResultsArgs {

package/crates/team-agent/src/coordinator/health.rs

@@ -74,7 +74,19 @@ use super::types::{
 /// returns: HealthReport。ok = 进程在跑 ∧ metadata 三元全等 ∧ 二进制身份一致 ∧ schema 兼容；service_available 刻意排除二进制身份，表示「这个 daemon 还能处理本队队列」；status 区分 Missing / InvalidPid / Running / Stale
 /// ---
 pub fn coordinator_health(workspace: &WorkspacePath) -> HealthReport {
-    let schema = message_store_schema_health(workspace);
+    coordinator_health_with_schema(workspace, message_store_schema_health(workspace))
+}
+
+/// Read-only coordinator health for diagnose. Unlike the lifecycle path, this
+/// never opens MessageStore and therefore cannot initialize or rewrite team.db.
+pub fn coordinator_health_read_only(workspace: &WorkspacePath) -> HealthReport {
+    coordinator_health_with_schema(workspace, message_store_schema_health_read_only(workspace))
+}
+
+fn coordinator_health_with_schema(
+    workspace: &WorkspacePath,
+    schema: SchemaHealth,
+) -> HealthReport {
     let current_binary_identity = current_coordinator_binary_identity();
     let pid_path = coordinator_pid_path(workspace);
     let pid = read_pid_file(&pid_path);
@@ -1004,6 +1016,34 @@ pub(crate) fn message_store_schema_health(workspace: &WorkspacePath) -> SchemaHe
     }
 }
 
+fn message_store_schema_health_read_only(workspace: &WorkspacePath) -> SchemaHealth {
+    let action = Some("run team-agent doctor --fix-schema --json".to_string());
+    match crate::db::migration::schema_diagnosis_workspace_read_only(workspace.as_path()) {
+        Ok(diagnosis) if diagnosis.ok && diagnosis.status == "ok" => SchemaHealth {
+            ok: true,
+            schema_version: crate::db::schema::SCHEMA_VERSION,
+            error: None,
+            action: None,
+        },
+        Ok(diagnosis) => SchemaHealth {
+            ok: false,
+            schema_version: crate::db::schema::SCHEMA_VERSION,
+            error: Some(SchemaError::InitFailed {
+                message: format!("team.db status: {}", diagnosis.status),
+            }),
+            action,
+        },
+        Err(error) => SchemaHealth {
+            ok: false,
+            schema_version: crate::db::schema::SCHEMA_VERSION,
+            error: Some(SchemaError::InitFailed {
+                message: error.to_string(),
+            }),
+            action,
+        },
+    }
+}
+
 fn read_pid_file(path: &Path) -> Option<Pid> {
     let text = std::fs::read_to_string(path).ok()?;
     let raw = text.trim().parse::<u32>().ok()?;

package/crates/team-agent/src/coordinator/tests/tick_core.rs

@@ -82,7 +82,7 @@ fn tick_side_effect_order_is_the_fixed_sequence() {
     //   startup_prompts -> runtime_prompts -> sync_health -> deliver_pending ->
     //   fire_scheduled -> detect_stuck -> record_unknown_idle -> evaluate_takeover ->
     //   detect_deadlocks -> detect_compaction -> detect_drift -> detect_api_errors ->
-    //   ATOMIC_save (bug-084 wrap) -> collect_results -> prune_dedupe_log.
+    //   ATOMIC_save (bug-084 wrap) -> prune_dedupe_log.
     // The porter must push each step name into the injected recorder at its call site.
     let recorder: OrderRecorder = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
     let (coord, _calls) = coord_for_test(true, None, Some(std::sync::Arc::clone(&recorder)));
@@ -106,19 +106,18 @@ fn tick_side_effect_order_is_the_fixed_sequence() {
         "detect_drift",
         "detect_api_errors",
         "atomic_save",
-        "collect_results",
         "prune_dedupe_log",
     ];
     assert_eq!(
         order, expected,
         "tick side-effect ORDER must match the fixed sequence"
     );
-    // ATOMIC save is the LAST mutation before read-only collect/prune (bug-084 wrap point).
+    // ATOMIC save is the LAST mutation before the read-only prune (bug-084 wrap point).
     let save_idx = order.iter().position(|s| *s == "atomic_save").unwrap();
-    let collect_idx = order.iter().position(|s| *s == "collect_results").unwrap();
+    let prune_idx = order.iter().position(|s| *s == "prune_dedupe_log").unwrap();
     assert!(
-        save_idx < collect_idx,
-        "save precedes collect (bug-084 wrap is the last mutation)"
+        save_idx < prune_idx,
+        "save precedes prune (bug-084 wrap is the last mutation)"
     );
 }
 

package/crates/team-agent/src/coordinator/tick.rs

@@ -104,7 +104,7 @@ pub struct TickReport {
     pub session_drift: Vec<SessionDriftResult>,
     /// `detect_leader_api_errors`(`lifecycle.py:344`)——cross-dep step 11。
     pub api_errors: Vec<LeaderApiError>,
-    /// `_collect_results_and_notify_watchers`(`lifecycle.py:364`)——degraded 时为空(未走到)。
+    /// Reserved result projection slot; report_result now finalizes directly.
     pub results: Vec<CollectedResult>,
 }
 
@@ -528,12 +528,6 @@ impl Coordinator {
                 collections,
             ));
         }
-        self.record_step(TickStepGroup::Delivery, "collect_results");
-        collections.results =
-            collect_results(crate::messaging::collect_results_and_notify_watchers(
-                self.workspace.as_path(),
-                &event_log,
-            )?);
         self.record_step(TickStepGroup::Persist, "prune_dedupe_log");
         Ok(base_tick_report(true, false, None, Some(true), collections))
     }
@@ -1554,15 +1548,6 @@ fn empty_tick_report(
     base_tick_report(ok, stop, reason, persisted, TickCollections::default())
 }
 
-fn collect_results(value: Value) -> Vec<CollectedResult> {
-    let Some(result_id) = value.get("result_id").and_then(Value::as_str) else {
-        return Vec::new();
-    };
-    vec![CollectedResult {
-        result_id: result_id.to_string(),
-    }]
-}
-
 struct ProviderTurnClassifier;
 
 impl TurnStateClassifier for ProviderTurnClassifier {

package/crates/team-agent/src/coordinator/types.rs

@@ -543,7 +543,7 @@ pub struct LeaderApiError {
     pub message: String,
 }
 
-/// `_collect_results_and_notify_watchers` 结果(`results.py:430`,step 11 拥有)。**PLACEHOLDER**。
+/// Result projection reported by a coordinator tick. Report results now finalize inline.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CollectedResult {
     pub result_id: String,

package/crates/team-agent/src/db/message_store.rs

@@ -727,9 +727,11 @@ impl MessageStore {
         Ok(changed == 1)
     }
 
-    /// Read inbox rows for an agent. This projection intentionally has no owner-team
-    /// filter when the caller does not provide one: legacy/CLI inbox must surface
-    /// NULL-owner messages stored for the agent.
+    /// Read ordinary inbox rows for an agent. Leader stage-result notifications are
+    /// delivered through the leader receiver, not exposed as mailbox fallback rows.
+    /// This projection intentionally has no owner-team filter when the caller does
+    /// not provide one: legacy/CLI inbox must surface NULL-owner messages stored for
+    /// the agent.
     pub fn inbox(
         &self,
         agent_id: &str,
@@ -744,7 +746,9 @@ impl MessageStore {
                         status, content, artifact_refs, created_at, updated_at, delivered_at,
                         acknowledged_at, error, delivery_attempts
                  from messages
-                 where (sender = ?1 or recipient = ?1) and owner_team_id = ?3
+                 where (sender = ?1 or recipient = ?1)
+                   and owner_team_id = ?3
+                   and coalesce(json_extract(presentation, '$.class'), 'message') != 'stage_result'
                  order by created_at desc
                  limit ?2"
             }
@@ -753,7 +757,8 @@ impl MessageStore {
                         status, content, artifact_refs, created_at, updated_at, delivered_at,
                         acknowledged_at, error, delivery_attempts
                  from messages
-                 where sender = ?1 or recipient = ?1
+                 where (sender = ?1 or recipient = ?1)
+                   and coalesce(json_extract(presentation, '$.class'), 'message') != 'stage_result'
                  order by created_at desc
                  limit ?2"
             }

package/crates/team-agent/src/db/migration.rs

@@ -8,7 +8,7 @@
 
 use std::path::{Path, PathBuf};
 
-use rusqlite::Connection;
+use rusqlite::{Connection, OpenFlags};
 
 use crate::db::schema::{ensure_schema_indexes, table_layout, SCHEMA_VERSION};
 use crate::db::DbError;
@@ -423,22 +423,33 @@ pub fn ensure_table_layout(
 /// `schema_migration.py:schema_diagnosis`:只读判定(不变更 DB)。
 fn schema_diagnosis(db_path: &Path, schema_version: i64) -> Result<Diagnosis, DbError> {
     if !db_path.exists() {
-        // T3-3 cr verdict (A parity lock, 2026-06-10): a missing db is the LEGAL
-        // first-use state — ok:true is layered with the explicit status axis and the
-        // recommended_action guidance (Python schema_migration.py:180-190 verbatim),
-        // never a silent fake-green.
-        return Ok(Diagnosis {
-            ok: true,
-            status: "missing".to_string(),
-            user_version: 0,
-            layout_diffs: vec![],
-            recommended_action:
-                "No team.db exists yet; initialize_schema will create it on first use.".to_string(),
-        });
+        return Ok(missing_schema_diagnosis());
     }
     let conn = Connection::open(db_path)?;
-    let uv = pragma_user_version(&conn)?;
-    let diffs = layout_diffs(&conn)?;
+    schema_diagnosis_from_connection(&conn, schema_version)
+}
+
+fn missing_schema_diagnosis() -> Diagnosis {
+    // T3-3 cr verdict (A parity lock, 2026-06-10): a missing db is the LEGAL
+    // first-use state — ok:true is layered with the explicit status axis and the
+    // recommended_action guidance (Python schema_migration.py:180-190 verbatim),
+    // never a silent fake-green.
+    Diagnosis {
+        ok: true,
+        status: "missing".to_string(),
+        user_version: 0,
+        layout_diffs: vec![],
+        recommended_action:
+            "No team.db exists yet; initialize_schema will create it on first use.".to_string(),
+    }
+}
+
+fn schema_diagnosis_from_connection(
+    conn: &Connection,
+    schema_version: i64,
+) -> Result<Diagnosis, DbError> {
+    let uv = pragma_user_version(conn)?;
+    let diffs = layout_diffs(conn)?;
     let diff_tables: Vec<String> = diffs.iter().map(|d| d.table.to_string()).collect();
     let ok = diffs.is_empty() && uv == schema_version;
     Ok(Diagnosis {
@@ -466,6 +477,16 @@ pub fn schema_diagnosis_workspace(workspace: &Path) -> Result<Diagnosis, DbError
     )
 }
 
+/// 对 workspace 的 team.db 执行严格只读 diagnosis，不创建或初始化缺失/空文件。
+pub fn schema_diagnosis_workspace_read_only(workspace: &Path) -> Result<Diagnosis, DbError> {
+    let db_path = workspace.join(".team").join("runtime").join("team.db");
+    if !db_path.exists() {
+        return Ok(missing_schema_diagnosis());
+    }
+    let conn = Connection::open_with_flags(&db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
+    schema_diagnosis_from_connection(&conn, SCHEMA_VERSION)
+}
+
 /// `schema_migration.py:_workspace_from_db_path`:`<ws>/.team/runtime/team.db` → `<ws>`。
 fn workspace_from_db_path(db_path: &Path) -> Option<PathBuf> {
     let parts: Vec<_> = db_path.iter().collect();

package/crates/team-agent/src/fake_worker.rs

@@ -220,8 +220,8 @@ mod tests {
         let (task_id, agent_id, status, env) = stored_result(ws);
         assert_eq!(
             (task_id.as_str(), agent_id.as_str(), status.as_str()),
-            ("t1", "w1", "success"),
-            "stored result row must be task_id=t1 agent_id=w1 status=success"
+            ("t1", "w1", "collected"),
+            "stored result row must be task_id=t1 agent_id=w1 status=collected"
         );
         assert_eq!(
             env["schema_version"],
@@ -291,8 +291,8 @@ mod tests {
         let (task_id, agent_id, status, envelope) = stored_result(&ws);
         assert_eq!(
             (task_id.as_str(), agent_id.as_str(), status.as_str()),
-            ("m1", "w1", "success"),
-            "a direct-message result must use its message id for message-scope collection"
+            ("m1", "w1", "collected"),
+            "a direct-message result must use its message id for message-scope auto-finalization"
         );
         assert_ne!(
             envelope["task_id"],

package/crates/team-agent/src/lifecycle/tests/harvest2_a_batch_red.rs

@@ -255,8 +255,8 @@ fn t3_unknown_business_status_is_preserved_without_normalized_event() {
     let envelope: serde_json::Value =
         serde_json::from_str(&row.envelope).expect("T3-1 durable envelope JSON");
     assert_eq!(
-        row.status, status,
-        "T3-1 ingress: results.status must preserve the task-local value byte-for-byte"
+        row.status, "collected",
+        "T3-1 ingress: report_result auto-finalization must mark the durable row collected"
     );
     assert_eq!(
         envelope["status"],

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -410,16 +410,6 @@ fn quick_start_teamdir_under_dot_team_uses_project_workspace_for_status_and_coll
         "status should normalize teamdir to project-root runtime state: {status:?}"
     );
 
-    let collect = crate::cli::cmd_collect(&crate::cli::CollectArgs {
-        result_file: None,
-        workspace: team.clone(),
-        json: true,
-        team: None,
-    });
-    assert!(
-        collect.is_ok(),
-        "collect should normalize teamdir to the same project-root state/spec: {collect:?}"
-    );
 }
 
 #[test]

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -1,8 +1,8 @@
 use super::launch_spawn::seed_healthy_coordinator;
 use super::*;
 use crate::cli::{
-    cmd_collect, cmd_diagnose, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult,
-    CollectArgs, DiagnoseArgs, SendArgs, StatusArgs,
+    cmd_diagnose, cmd_send, cmd_status, lifecycle_port, CmdOutput, CmdResult, DiagnoseArgs,
+    SendArgs, StatusArgs,
 };
 use crate::transport::test_support::OfflineTransport;
 use crate::transport::WindowName;
@@ -275,12 +275,6 @@ fn run_phase_golden(spec: PhaseGolden) -> Value {
         to_name: None,
         to_leader: None,
     });
-    let collect = cmd_collect(&CollectArgs {
-        workspace: workspace.clone(),
-        result_file: None,
-        json: true,
-        team: Some(spec.team_key.to_string()),
-    });
     let lifecycle_transport = codex_ready_transport()
         .with_session_present(true)
         .with_windows(vec![WindowName::new("w1"), WindowName::new("w2")]);
@@ -303,7 +297,6 @@ fn run_phase_golden(spec: PhaseGolden) -> Value {
             { "step": "status-json", "result": cmd_value(status_compact) },
             { "step": "status-detail-json", "result": cmd_value(status_detail) },
             { "step": "send", "result": cmd_value(send) },
-            { "step": "collect", "result": cmd_value(collect) },
             { "step": "phase-lifecycle-op", "output": lifecycle },
             {
                 "step": "shutdown-keep-logs",

package/crates/team-agent/src/lifecycle/tests/upgrade_compat_0211_red.rs

@@ -19,9 +19,7 @@ use std::sync::Mutex;
 use rusqlite::params;
 use serde_json::{json, Value};
 use serial_test::serial;
-use team_agent::cli::{
-    cmd_collect_for_team, cmd_status_for_team, CmdOutput, CollectArgs, StatusArgs,
-};
+use team_agent::cli::{cmd_status_for_team, CmdOutput, StatusArgs};
 use team_agent::db::schema::{initialize_schema, open_db, table_layout, SCHEMA_VERSION};
 use team_agent::event_log::EventLog;
 use team_agent::lifecycle::restart::classify_restart_plan;
@@ -239,29 +237,6 @@ fn upgrade_status_collect_scope_by_selected_team_key() {
         "status --team upgrade-key must not expose sibling rows; status={status}"
     );
 
-    let collect = json_output(cmd_collect_for_team(
-        &CollectArgs {
-            workspace: fixture.workspace.clone(),
-            result_file: None,
-            json: true,
-            team: None,
-        },
-        Some(TEAM_KEY),
-    ));
-    let empty = Vec::new();
-    let collected_ids = collect
-        .get("collected_results")
-        .and_then(Value::as_array)
-        .unwrap_or(&empty)
-        .iter()
-        .filter_map(|item| item.get("result_id").and_then(Value::as_str))
-        .collect::<Vec<_>>();
-    assert!(
-        collected_ids.contains(&"res-existing-upgrade")
-            && collected_ids.contains(&"res-upgrade")
-            && !collected_ids.contains(&"res-sibling"),
-        "collect --team upgrade-key must collect only selected runtime-key rows; collect={collect}"
-    );
 }
 
 #[test]

package/crates/team-agent/src/main.rs

@@ -1,7 +1,9 @@
 //! `team-agent` 二进制入口。
 
 fn main() -> anyhow::Result<()> {
-    let mut args = std::env::args().skip(1);
+    let mut args = std::env::args_os()
+        .skip(1)
+        .map(|arg| arg.to_string_lossy().into_owned());
     let command = args.next();
     if matches!(command.as_deref(), Some("fake-worker")) {
         let mut workspace = None;
@@ -35,7 +37,10 @@ fn main() -> anyhow::Result<()> {
         team_agent::mcp_server::main(&workspace, &[])?;
         return Ok(());
     }
-    let argv = std::env::args().skip(1).collect::<Vec<_>>();
+    let argv = std::env::args_os()
+        .skip(1)
+        .map(|arg| arg.to_string_lossy().into_owned())
+        .collect::<Vec<_>>();
     let cwd = std::env::current_dir()?;
     std::process::exit(team_agent::cli::run(&argv, &cwd).code());
 }

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

@@ -22,7 +22,7 @@
 //!     `mcp.identity_inference_failed` / `mcp.task_inference_failed` audit events.
 //!   - [`load_runtime_state`] / [`save_runtime_state`] (step 5 persist) — `assign_task`
 //!     / `update_state` read-modify-write; `get_visible_peers` reads team scope.
-//!   - [`messaging`] (step 11) — `send_message` / `report_result` / `collect` /
+//!   - [`messaging`] (step 11) — `send_message` / auto-finalizing `report_result` /
 //!     `stuck_list` / `stuck_cancel` delegated by the tool handlers.
 //!   - [`crate::model::enums`] (step 2) — [`ResultStatus`] / [`ChangeKind`] /
 //!     [`TestStatus`] / [`RiskSeverity`] are the normalized result-envelope value

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

@@ -102,8 +102,8 @@ pub use persist::{
     LogicalRecipient, PersistResolution, PersistedSend, ResolvedSendIntent, SendOrigin,
 };
 pub use results::{
-    collect, collect_for_team, collect_results_and_notify_watchers, report_result,
-    report_result_for_owner_team, report_result_for_owner_team_with_primary_error,
+    collect, collect_for_team, report_result, report_result_for_owner_team,
+    report_result_for_owner_team_with_primary_error,
 };
 pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events, stuck_cancel, stuck_list};
 pub use selftest::{run_comms_selftest, CommsSelftestDriver};