@team-agent/installer 0.5.89 → 0.5.91

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.

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/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/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());
 }