@team-agent/installer 0.5.86 → 0.5.91

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/compiler.rs

@@ -32,8 +32,8 @@ use crate::model::enums::{Provider, ProviderEffort};
 use crate::model::yaml::Value;
 use crate::model::{paths, spec, yaml, ModelError};
 use crate::provider::wire::{
-    builtin_provider_model as wire_builtin_provider_model, is_claude_family,
-    parse_canonical_provider, provider_model_keys,
+    builtin_provider_model as wire_builtin_provider_model, parse_canonical_provider,
+    provider_model_keys,
 };
 
 pub const IGNORED_OWNER_TEAM_ID_FIELD: &str = "owner_team_id";
@@ -602,12 +602,9 @@ fn compile_role_agent_with_mode(
             })
             .unwrap_or("");
         let provider_enum = parse_canonical_provider(provider_str).unwrap_or(Provider::Codex);
-        if effort.is_claude_only()
-            && !is_claude_family(provider_enum)
-            && provider_enum != Provider::Pi
-        {
+        if let Err(reason) = effort.resolve_for_provider(provider_enum) {
             return Err(ModelError::Validation(format!(
-                "{}: effort '{}' is only supported by claude/claude_code (provider: {provider_str})",
+                "{}: {reason} (effort: {}; provider: {provider_str})",
                 role_path.display(),
                 effort.as_str()
             )));

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/launch/identity.rs

@@ -9,7 +9,7 @@
 //!     - name: transport_has_session
 //!       what: 探测 tmux session 是否存在，探测本身出错一律当不存在
 //!     - name: provider_effort_from_raw
-//!       what: 解析 effort 并要求该 provider 支持，否则 None
+//!       what: 解析 effort，保留兼容忽略项并拒绝非法 provider 组合
 //!     - name: quick_start_depth_guard
 //!       what: 定出本次 quick-start 的父团队与层级，推不出父团队时拒绝
 //!     - name: annotate_persisted_team_depth
@@ -135,24 +135,24 @@ pub(super) fn parse_auth_mode(raw: &str) -> Option<AuthMode> {
 /// purpose: 从原始字符串解析 effort，并要求当前 provider 支持它
 /// params:
 ///   raw: effort 原文，None 或空白返回 None
-/// returns: 解析成功且该 provider 支持时返回该档位，否则 None
+/// returns: 支持的档位或兼容忽略的 None；已知非法 provider/effort 组合返回错误
 /// ---
 /// 0.4.x provider effort MVP step 4: low-level from a raw string. Returns
-/// `Some(effort)` when the level parses AND the provider supports it.
+/// `Some(effort)` for supported levels, None for legacy ignored values,
+/// and an error for provider/effort combinations rejected by configuration.
 pub(crate) fn provider_effort_from_raw(
     raw: Option<&str>,
     provider: Provider,
-) -> Option<ProviderEffort> {
-    let raw = raw?.trim();
-    if raw.is_empty() {
-        return None;
-    }
-    let effort = ProviderEffort::parse(raw)?;
-    if effort.is_supported_by(provider) {
-        Some(effort)
-    } else {
-        None
-    }
+) -> Result<Option<ProviderEffort>, LifecycleError> {
+    let Some(effort) = raw.and_then(ProviderEffort::parse) else {
+        return Ok(None);
+    };
+    effort.resolve_for_provider(provider).map_err(|reason| {
+        LifecycleError::RequirementUnmet(format!(
+            "{reason} (effort: {}; provider: {provider:?})",
+            effort.as_str()
+        ))
+    })
 }
 
 /// ---
@@ -171,7 +171,7 @@ pub(crate) fn provider_effort_event_payload(
         return None;
     }
     let effort = ProviderEffort::parse(raw)?;
-    if effort.is_supported_by(provider) {
+    if !matches!(effort.resolve_for_provider(provider), Ok(None)) {
         return None;
     }
     Some(serde_json::json!({
@@ -221,7 +221,7 @@ pub(crate) fn extend_worker_env_unset_for_effort(
 pub(crate) fn provider_effort_for_spawn(
     agent: &crate::model::yaml::Value,
     provider: Provider,
-) -> Option<ProviderEffort> {
+) -> Result<Option<ProviderEffort>, LifecycleError> {
     provider_effort_from_raw(agent.get("effort").and_then(|v| v.as_str()), provider)
 }
 
@@ -252,7 +252,7 @@ pub(crate) fn provider_effort_event_if_dropped(
 pub(crate) fn provider_effort_for_spawn_json(
     agent: &serde_json::Value,
     provider: Provider,
-) -> Option<ProviderEffort> {
+) -> Result<Option<ProviderEffort>, LifecycleError> {
     provider_effort_from_raw(
         agent.get("effort").and_then(serde_json::Value::as_str),
         provider,
@@ -307,10 +307,16 @@ pub(super) fn quick_start_depth_guard(
     requested_team: Option<&str>,
     _strict_real_runtime: bool,
 ) -> Result<QuickStartDepth, LifecycleError> {
-    let env_parent = std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
-        .ok()
-        .map(|value| value.trim().to_string())
-        .filter(|value| !value.is_empty());
+    // OWNER_TEAM_ID is injected into every worker process. It is parent
+    // context only when the target quick-start workspace is the same workspace
+    // that produced the environment; otherwise a worker launching a fresh
+    // external workspace would inherit a false nesting parent.
+    let env_parent = owner_context_matches_workspace(workspace).then(|| {
+        std::env::var("TEAM_AGENT_OWNER_TEAM_ID")
+            .ok()
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty())
+    }).flatten();
     let parent = env_parent;
     let Some(parent) = parent else {
         let state = crate::state::persist::load_runtime_state(workspace)
@@ -365,6 +371,18 @@ pub(super) fn quick_start_depth_guard(
 /// purpose: 从 runtime state 推断父团队键
 /// returns: 活跃团队键，且该团队确有 running 席位时返回它，否则 None
 /// ---
+fn owner_context_matches_workspace(workspace: &Path) -> bool {
+    let Some(env_workspace) = std::env::var_os("TEAM_AGENT_WORKSPACE") else {
+        return false;
+    };
+    let env_workspace = PathBuf::from(env_workspace);
+    env_workspace == workspace
+        || std::fs::canonicalize(&env_workspace)
+            .ok()
+            .zip(std::fs::canonicalize(workspace).ok())
+            .is_some_and(|(env_path, target_path)| env_path == target_path)
+}
+
 pub(super) fn infer_parent_team_from_active_state(state: &serde_json::Value) -> Option<String> {
     let active = explicit_active_team_key(state)?;
     let team = state

package/crates/team-agent/src/lifecycle/launch/spawn.rs

@@ -152,7 +152,7 @@ pub(super) fn spawn_agents(
         // 0.4.x provider effort MVP step 4 + 7: resolve effort and emit
         // unsupported warning event when the spec asked for an effort the
         // provider can't satisfy.
-        let agent_effort = provider_effort_for_spawn(agent, provider);
+        let agent_effort = provider_effort_for_spawn(agent, provider)?;
         if let Some(event_value) = provider_effort_event_if_dropped(agent, provider, agent_id_raw) {
             let _ = crate::event_log::EventLog::new(workspace)
                 .write("provider.effort_unsupported", event_value);

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -355,7 +355,7 @@ pub(super) fn spawn_agent_window(
     let command_model = profile_launch.command_overrides.model.as_deref().or(model);
     // 0.4.x provider effort MVP: restart/resume preserves effort from the
     // persisted agent JSON (state's agent["effort"] field, set by launch).
-    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider);
+    let restart_effort = crate::lifecycle::launch::provider_effort_for_spawn_json(agent, provider)?;
     if let Some(event_value) = crate::lifecycle::launch::provider_effort_event_if_dropped_json(
         agent,
         provider,

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

@@ -99,17 +99,17 @@ fn stale_snapshot_cannot_flip_status_or_diagnose_ok_readiness() {
     let case = B0HideOneCase::new("status-diagnose-hide-one");
     let root = case.current_state();
     save_runtime_state(&case.workspace, &root).expect("seed current root state");
-    let probe = brief_probe::install_trusted_nodeprobe(
+    let tmux = brief_probe::install_native_tmux(
         &case.workspace.join("probe"),
         NEW_ENDPOINT,
         SESSION,
         WORKER,
         "%new",
-        "fake",
+        "bash",
     );
     let _path = case.env.with_env(
         "PATH",
-        &brief_probe::path_with_probe(&probe, std::env::var_os("PATH").as_deref()),
+        &brief_probe::path_with_probe(&tmux, std::env::var_os("PATH").as_deref()),
     );
 
     let status_before = case.run_json(&[

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