@team-agent/installer 0.5.86 → 0.5.91

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -595,36 +595,16 @@ fn report_result_valid_envelope_returns_ok_with_result_id() {
 }
 
 #[test]
-fn report_result_funnels_into_leader_delivery_primitive_not_queued_scheduled_event() {
-    // #230 N31/N32 funnel (cr verdict §3 I-3 + MUST-8):
-    //
-    // [OLD assertion] report_result inserted a parallel `scheduled_events(kind='send',
-    // target='leader', status='pending')` row + returned `notification_status="queued"`,
-    // and the worker-facing tool body claimed success while leader had not yet seen the
-    // result. That queued-only path was MUST-8 / I-3 violating — `notification_status=
-    // queued` was returned as success but the leader pane never actually got the text.
-    //
-    // [NEW assertion] report_result now synchronously funnels through the shared leader-
-    // delivery primitive (`send_to_leader_receiver`), creating a `messages` row that
-    // `deliver_pending_messages` picks up on the same tick (NO `scheduled_events` row).
-    // Without a bound leader pane (this fixture has no `leader_receiver.pane_id`), the
-    // primitive returns I-4 `rebind_required` (Blocked / ok=false) — the row is persisted
-    // as `failed` for audit and the tool body's `notification_status` is `rebind_required`,
-    // NOT a misleading `queued` success. The contract grep that bans `queue_report_result_
-    // notification` / `notification_status="queued[_only]"` literals in `results.rs` is the
-    // direct mechanical counterpart of this assertion.
-    let ws = tmp_ws("reportnotify");
+fn report_result_auto_finalizes_and_queues_compact_leader_notification() {
+    let ws = tmp_ws("reportauto");
     crate::state::persist::save_runtime_state(
         &ws,
         &serde_json::json!({
-            "session_name": null,
-            "leader": {"id": "leader"},
             "agents": {"worker": {"status": "running"}},
             "tasks": [{"id": "task_1", "status": "running", "assignee": "worker"}]
         }),
     )
     .unwrap();
-    let store = store_for(&ws);
     let envelope = json(serde_json::json!({
         "schema_version": "result_envelope_v1",
         "task_id": "task_1",
@@ -639,63 +619,97 @@ fn report_result_funnels_into_leader_delivery_primitive_not_queued_scheduled_eve
     }));
 
     let out = report_result(&ws, &envelope).unwrap();
-    let result_id = out
-        .get("result_id")
-        .and_then(|v| v.as_str())
-        .expect("report_result returns generated result_id");
-    assert!(
-        result_id.starts_with("res_"),
-        "MessageStore.add_result generates res_* ids; got {result_id}"
-    );
+    assert_eq!(out["finalization_status"], "auto_finalized");
+    assert_eq!(out["notification_status"], "queued");
+    assert_eq!(out["leader_notified"], false);
 
-    // No `scheduled_events` rows: the queued parallel path is gone.
+    let store = store_for(&ws);
     let conn = seed_conn(&store);
-    let scheduled_count: i64 = conn
-        .query_row("select count(*) from scheduled_events", [], |row| {
-            row.get(0)
-        })
+    let result_status: String = conn
+        .query_row("select status from results", [], |row| row.get(0))
+        .unwrap();
+    let message_count: i64 = conn
+        .query_row("select count(*) from messages", [], |row| row.get(0))
+        .unwrap();
+    assert_eq!(result_status, "collected");
+    assert_eq!(message_count, 1);
+    let (presentation, content): (String, String) = conn
+        .query_row(
+            "select presentation, content from messages",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
         .unwrap();
     assert_eq!(
-        scheduled_count, 0,
-        "N31/N32 funnel: report_result must NOT insert a parallel scheduled_events 'send' row; the leader-delivery primitive is the single funnel"
-    );
-
-    // Tool body: no `queued`/`queued_only` notification_status. Without a bound leader
-    // pane this fixture surfaces I-4 `rebind_required` (ok=false on the leader delivery,
-    // but the result row + audit trail are durable for rebind replay).
-    assert_eq!(
-        out.get("notification_status").and_then(|v| v.as_str()),
-        Some("rebind_required"),
-        "I-4: unbound leader pane → rebind_required, never queued/queued_only success"
+        serde_json::from_str::<serde_json::Value>(&presentation).unwrap()["class"],
+        "stage_result"
     );
+    assert!(content.len() < 320, "leader notification must stay compact");
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(state["tasks"][0]["status"], "done");
     assert_eq!(
-        out.get("leader_notified").and_then(|v| v.as_bool()),
-        Some(false),
-        "I-4: leader_notified=false when no leader pane is bound"
+        state["tasks"][0]["accepted_result_id"].as_str().is_some(),
+        true
     );
     assert!(
-        out.get("notification_event_id")
-            .is_some_and(|v| v.is_null()),
-        "no scheduled_events row → notification_event_id is null"
+        std::fs::read_to_string(ws.join(".team/logs/events.jsonl"))
+            .unwrap()
+            .contains("\"collect.result\"")
     );
+}
 
-    // Audit events: the funnel emits leader_receiver.delivery_blocked (I-4 rebind),
-    // and the legacy mcp.report_result_notify_queued audit is gone.
-    let events_path = ws.join(".team").join("logs").join("events.jsonl");
-    let event_lines =
-        std::fs::read_to_string(events_path).expect("report_result writes events.jsonl");
-    assert!(
-        event_lines.contains("\"leader_receiver.delivery_blocked\""),
-        "I-4 rebind path must emit leader_receiver.delivery_blocked audit; got {event_lines}",
-    );
-    assert!(
-        !event_lines.contains("mcp.report_result_notify_queued"),
-        "legacy queued-notification audit must be gone; got {event_lines}",
-    );
-    assert!(
-        event_lines.contains("\"mcp.report_result\""),
-        "report_result still emits its own audit event; got {event_lines}",
-    );
+#[test]
+fn report_result_message_scope_finalizes_latest_assigned_task() {
+    let ws = tmp_ws("reportauto-message");
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &serde_json::json!({
+            "active_team_key": "team-a",
+            "teams": {
+                "team-a": {
+                    "agents": {"worker": {"status": "running"}},
+                    "tasks": [{"id": "task_initial", "status": "pending", "assignee": "worker"}]
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let store = store_for(&ws);
+    let conn = seed_conn(&store);
+    conn.execute(
+        "insert into messages(message_id, owner_team_id, sender, recipient, status, content, created_at) values (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        rusqlite::params![
+            "msg_turn",
+            "team-a",
+            "leader",
+            "worker",
+            "delivered",
+            "complete the task",
+            "2026-09-19T00:00:00Z",
+        ],
+    )
+    .unwrap();
+    let envelope = json(serde_json::json!({
+        "schema_version": "result_envelope_v1",
+        "task_id": "msg_turn",
+        "agent_id": "worker",
+        "status": "success",
+        "summary": "done",
+        "changes": [],
+        "tests": [],
+        "risks": [],
+        "artifacts": [],
+        "next_actions": []
+    }));
+
+    let out = report_result(&ws, &envelope).unwrap();
+    assert_eq!(out["finalization_status"], "auto_finalized");
+    assert_eq!(out["notification_status"], "queued");
+    let state = crate::state::persist::load_runtime_state(&ws).unwrap();
+    assert_eq!(state["teams"]["team-a"]["tasks"][0]["status"], "done");
+    assert!(state["teams"]["team-a"]["tasks"][0]["accepted_result_id"]
+        .as_str()
+        .is_some());
 }
 
 #[test]
@@ -2423,56 +2437,6 @@ fn retry_result_deliveries_retries_notify_failed_watcher() {
     );
 }
 
-// ════════════════════════════════════════════════════════════════════════
-// GROUP W — collect_results_and_notify_watchers orchestration shape.
-// results.py:430-447.
-// ════════════════════════════════════════════════════════════════════════
-
-#[test]
-fn collect_results_and_notify_watchers_returns_concrete_ok_shape() {
-    // SEEDED contract (results.py:430-447): with NO uncollected results, collect() is
-    // skipped (the `if store.results(uncollected_only=True)` guard is false), so the
-    // result stays {ok:true, collected_results:[]}; a seeded notify_failed watcher
-    // whose result_id has no matching results row is resolved to None by
-    // retry_result_deliveries → skipped → notified stays []. Probed golden (against
-    // exactly this fixture): {"ok": true, "collected": 0, "notified": []}.
-    // (The previous test asserted only out["ok"].is_some(), trivially passed by
-    // {"ok": false}.)
-    let ws = tmp_ws("collectnotify");
-    let store = store_for(&ws);
-    let log = EventLog::new(&ws);
-
-    seed_watcher(
-        &store,
-        "w-orphan",
-        "team-a",
-        "t1",
-        "alice",
-        "notify_failed",
-        Some("res_missing"),
-        None,
-    );
-
-    let out = collect_results_and_notify_watchers(&ws, &log).unwrap();
-    assert_eq!(
-        out.get("ok").and_then(|v| v.as_bool()),
-        Some(true),
-        "ok==true"
-    );
-    assert_eq!(
-        out.get("collected").and_then(|v| v.as_i64()),
-        Some(0),
-        "no uncollected results → collected==0"
-    );
-    assert_eq!(
-        out.get("notified")
-            .and_then(|v| v.as_array())
-            .map(|a| a.len()),
-        Some(0),
-        "orphan watcher (missing result) is skipped → notified empty"
-    );
-}
-
 // ════════════════════════════════════════════════════════════════════════
 // GROUP X — delivered_result_message content-level dedupe lookup +
 // result_id_from_text dual (scheduler send dedupe path). result_delivery.py:394.
@@ -2892,27 +2856,19 @@ fn r8_attach_requeue_exhausted_to_notify_failed_golden_attach_event() {
     );
 }
 
-// E15/E23 双投守卫:report_result 的 pane fallback 必须被 `if !outcome.ok` 守为
-// deliver 失败时的真兜底,绝不在 deliver 成功后无条件再投一次(=用户看到两条同内容回复)。
+// E15/E23 single-funnel guard: report_result presents a compact result through
+// the shared leader receiver and does not carry a private direct-inject retry.
 #[test]
-fn e15_direct_inject_is_gated_by_deliver_failure_not_unconditional() {
+fn e15_report_result_uses_shared_leader_receiver_without_private_retry() {
     let src = include_str!("../results.rs");
-    // E23:旧 private direct inject 已合并到 shared deliver_to_leader_fallback_pane primitive。
-    let gate = "if !outcome.ok {";
-    let fallback_call = "deliver_to_leader_fallback_pane(";
-    let gate_pos = src.find(gate);
-    assert!(
-        gate_pos.is_some(),
-        "E15/E23: pane fallback must be gated by `if !outcome.ok` (deliver-fail fallback)"
-    );
-    let fallback_after_gate = src[gate_pos.unwrap()..].find(fallback_call);
     assert!(
-        fallback_after_gate.is_some(),
-        "E15/E23: report_result fallback must call the shared fallback pane primitive after the failure gate"
+        src.contains("send_to_leader_receiver_with_presentation"),
+        "E15/E23: report_result must use the shared leader receiver presentation funnel"
     );
     assert!(
-        !src.contains("inject_leader_notification_direct"),
-        "E23: private direct inject must stay deleted; all callers use deliver_to_leader_fallback_pane"
+        !src.contains("inject_leader_notification_direct")
+            && !src.contains("deliver_to_leader_fallback_pane"),
+        "E23: private direct and removed fallback inject paths must stay deleted"
     );
 }
 

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

@@ -27,7 +27,7 @@ use super::{MessagingError, WatcherNotice, RESULT_DELIVERY_MAX_ATTEMPTS};
 
 /// `notify_result_watchers` (`result_delivery.py:38`):匹配 + 去重 + (有界) 投递 result 给 leader
 /// watcher。**恰好一次** (Gap 32/38):同 result_id 多 watcher → 1 次注入,余 `superseded`。
-/// 去重唯一原语 = [`MessageStore::claim_leader_notification_delivery`]。`collect`/coordinator tick 调。
+/// 去重唯一原语 = [`MessageStore::claim_leader_notification_delivery`]。由 watcher/rebind recovery 调用。
 pub(crate) fn notify_result_watchers(
     workspace: &Path,
     result: &serde_json::Value,

package/crates/team-agent/src/model/enums.rs

@@ -86,9 +86,8 @@ impl ProviderEffort {
         matches!(self, Self::Max)
     }
 
-    /// True when the given provider supports this effort level. `max` is
-    /// Claude-only; other levels are supported by Claude, Codex, and Grok.
-    /// Copilot/Gemini/CursorAgent/Fake ignore the field (warning at runtime).
+    /// Native command support. Claude/Pi accept max; Codex/Grok accept
+    /// the other levels. Use resolve_for_provider for admission/ignore policy.
     pub fn is_supported_by(self, provider: Provider) -> bool {
         match provider {
             Provider::Claude | Provider::ClaudeCode | Provider::Pi => true,
@@ -98,6 +97,21 @@ impl ProviderEffort {
             }
         }
     }
+
+    /// One admission policy for compiler, direct specs and runtime commands.
+    /// Ok(None) preserves the legacy warning-and-ignore providers.
+    pub fn resolve_for_provider(self, provider: Provider) -> Result<Option<Self>, &'static str> {
+        if provider == Provider::CursorAgent {
+            return Err("cursor_agent does not support effort; the Cursor CLI has no --effort flag");
+        }
+        if self.is_supported_by(provider) {
+            Ok(Some(self))
+        } else if self.is_claude_only() {
+            Err("effort 'max' is only supported by claude/claude_code/pi")
+        } else {
+            Ok(None)
+        }
+    }
 }
 
 /// auth 模式(`AUTH_MODES` `profiles/constants.py:6`)。

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

@@ -18,7 +18,7 @@ use crate::model::ids::TaskId;
 use crate::model::task_graph::{find_dependency_cycle, TaskNode};
 use crate::model::yaml::Value as Yaml;
 use crate::model::yaml;
-use crate::provider::wire::{is_claude_family, parse_canonical_provider};
+use crate::provider::wire::parse_canonical_provider;
 
 /// result_envelope_v1 顶层 required(= allowed)。
 const RESULT_REQUIRED: &[&str] = &[
@@ -463,15 +463,16 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
                     "{path}/effort: unknown effort '{raw}' (allowed: low|medium|high|xhigh|max)"
                 ));
             }
-            Some(effort) if effort.is_claude_only() => {
+            Some(effort) => {
                 let provider = agent.get("provider").and_then(Yaml::as_str).unwrap_or("");
-                if !parse_canonical_provider(provider).is_some_and(is_claude_family) {
-                    errors.push(format!(
-                        "{path}/effort: effort '{raw}' is only supported by claude/claude_code (provider: {provider})"
-                    ));
+                if let Some(provider_enum) = parse_canonical_provider(provider) {
+                    if let Err(reason) = effort.resolve_for_provider(provider_enum) {
+                        errors.push(format!(
+                            "{path}/effort: {reason} (effort: {raw}; provider: {provider})"
+                        ));
+                    }
                 }
             }
-            Some(_) => {}
         }
     }
     check_keys_y(

package/crates/team-agent/src/provider/wire.rs

@@ -231,7 +231,7 @@ mod tests {
         );
         assert!(
             model_spec_rs.contains("parse_canonical_provider")
-                && model_spec_rs.contains("is_claude_family"),
+                && model_spec_rs.contains("resolve_for_provider"),
             "model spec must validate providers through typed helpers"
         );
         assert!(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.86",
+  "version": "0.5.91",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.86",
-    "@team-agent/cli-darwin-x64": "0.5.86",
-    "@team-agent/cli-linux-x64": "0.5.86"
+    "@team-agent/cli-darwin-arm64": "0.5.91",
+    "@team-agent/cli-darwin-x64": "0.5.91",
+    "@team-agent/cli-linux-x64": "0.5.91"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",

package/skills/team-agent/SKILL.md

@@ -7,7 +7,7 @@ last_verified_against: "0.5.66"
 
 # Team Agent
 
-Sealed appliance for someone who just got the CLI. Operator handbook (permissions, models, routing, recovery): `docs/reference/team-agent-operator.md`.
+Sealed appliance for someone who just got the CLI. Operator handbook (permissions, models, routing, recovery): `references/team-agent-operator.md`.
 
 If `team-agent --version` does not match `last_verified_against`, do not copy examples as current truth. Learn from the live CLI:
 
@@ -29,11 +29,11 @@ team-agent doctor --help
 
 **On failure:** if the CLI prints a structured `action`, run that `action` first, then stop. Do not guess flags. `coordinator.session_missing` is a self-healing transient — re-check `status --json`; do not shutdown because of it.
 
-The current user-facing agent is the leader (orchestrate only). Workers call `report_result` exactly once. Nested teams: `skills/team-agent/references/team-in-team.md`.
+The current user-facing agent is the leader (orchestrate only). Workers call `report_result` exactly once. Nested teams: `references/team-in-team.md`.
 
 ## Provider Capability Matrix
 
-Claude / Codex / Copilot / Gemini / fake: `docs/reference/team-agent-operator.md`. These two are in the runtime but were missing from that table:
+Claude / Codex / Copilot / Gemini / fake: `references/team-agent-operator.md`. These two are in the runtime but were missing from that table:
 `quick-start` / `restart` / `claim-leader` JSON is compact by default (`ok`, `status`/`reason`, next action, attach/send, and `readiness.all_workers_spawned`); pass `--detail` only for internal diagnostics.
 
 | Provider | Resume | Turn-state detection | Per-worker model override | Native session fork |

package/skills/team-agent/command-coverage.json

@@ -96,13 +96,6 @@
       "owner": "runtime-owner:provider-launcher",
       "plan": "Use a per-call hermetic codex PATH shim and assert the exact dangerous flag argv log plus the bound CLI exit/output without invoking a real provider."
     },
-    {
-      "command": "team-agent collect",
-      "bucket": "declared_gap",
-      "covered": false,
-      "owner": "runtime-owner:results",
-      "plan": "Execute the exact human collect argv after a worker result and bind assertions to presentation and consumption of that same result."
-    },
     {
       "command": "team-agent doctor",
       "bucket": "declared_gap",
@@ -118,14 +111,14 @@
       "plan": "Use an isolated provider/session fixture or authorized subscription gate and bind assertions to fork success or its exact rollback refusal."
     },
     {
-      "command": "team-agent inbox",
+      "command": "team-agent inbox <agent_id> -n 3",
       "bucket": "declared_gap",
       "covered": false,
       "owner": "runtime-owner:messaging",
       "plan": "Execute the exact default inbox argv and bind assertions to its selected recipient and message or empty-state output."
     },
     {
-      "command": "team-agent inbox coder",
+      "command": "team-agent inbox coder -n 3",
       "bucket": "declared_gap",
       "covered": false,
       "owner": "runtime-owner:messaging",