@team-agent/installer 0.5.100 → 0.5.102

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.100"
+version = "0.5.102"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.100"
+version = "0.5.102"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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

@@ -94,6 +94,14 @@ pub(crate) fn classify_tmux_server_error(error_text: &str) -> &'static str {
 }
 
 pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value, Value) {
+    diagnose_runtime_with_workspace(None, state, backend)
+}
+
+fn diagnose_runtime_with_workspace(
+    workspace: Option<&std::path::Path>,
+    state: &Value,
+    backend: &dyn Transport,
+) -> (Value, Value) {
     let mut issues = Vec::new();
     let mut repairs = Vec::new();
 
@@ -248,12 +256,25 @@ pub(crate) fn diagnose_runtime(state: &Value, backend: &dyn Transport) -> (Value
                         .and_then(Value::as_str)
                         .filter(|path| !path.is_empty())
                         .map(crate::provider::RolloutPath::new);
-                    let identity_probe =
-                        crate::lifecycle::restart::session_identity_probe_for_agent(
-                            &crate::model::ids::AgentId::new(agent_id.clone()),
-                            provider,
-                            rollout_path.as_ref(),
-                        );
+                    let agent_identity = crate::model::ids::AgentId::new(agent_id.clone());
+                    let identity_probe = workspace
+                        .map(|workspace| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent_with_fork_ancestry(
+                                workspace,
+                                state,
+                                &agent_identity,
+                                agent_state,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        })
+                        .unwrap_or_else(|| {
+                            crate::lifecycle::restart::session_identity_probe_for_agent(
+                                &agent_identity,
+                                provider,
+                                rollout_path.as_ref(),
+                            )
+                        });
                     if identity_probe.identity_ok == Some(false) {
                         let issue = format!("session_identity_mismatch:{agent_id}");
                         issues.push(json!(issue));
@@ -304,7 +325,8 @@ pub(crate) fn diagnose_runtime_for_workspace(
     selected_team_key: Option<&str>,
     coordinator_health: &crate::coordinator::HealthReport,
 ) -> (Value, Value) {
-    let (mut issues, mut repairs) = diagnose_runtime(state, backend);
+    let (mut issues, mut repairs) =
+        diagnose_runtime_with_workspace(Some(workspace), state, backend);
     append_live_leader_workspace_mismatch_issue(
         workspace,
         state,

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

@@ -2926,14 +2926,30 @@ pub mod lifecycle_port {
         let source = crate::model::ids::AgentId::new(source_agent);
         let dest = crate::model::ids::AgentId::new(as_agent_id);
         match crate::lifecycle::fork_agent(workspace, &source, &dest, label, true, team) {
-            Ok(report) => Ok(json!({
-                "ok": true,
-                "source_agent_id": report.source_agent_id.as_str(),
-                "new_agent_id": report.new_agent_id.as_str(),
-                "session_id": report.session_id.as_ref().map(|session| session.as_str()),
-                "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
-                "backing_state": report.backing_state,
-            })),
+            Ok(report) => {
+                let mut value = json!({
+                    "ok": true,
+                    "source_agent_id": report.source_agent_id.as_str(),
+                    "new_agent_id": report.new_agent_id.as_str(),
+                    "session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                    "new_session_id": report.session_id.as_ref().map(|session| session.as_str()),
+                    "backing_state": report.backing_state,
+                });
+                if let (Some(details), Some(object)) = (report.pi_fork, value.as_object_mut()) {
+                    object.insert("status".to_string(), json!("forked"));
+                    object.insert("target".to_string(), json!(report.new_agent_id.as_str()));
+                    object.insert(
+                        "source_session_id".to_string(),
+                        json!(details.source_session_id.as_str()),
+                    );
+                    object.insert("session_id".to_string(), json!(details.session_id.as_str()));
+                    object.insert(
+                        "backing_path".to_string(),
+                        json!(details.backing_path.0.to_string_lossy().to_string()),
+                    );
+                }
+                Ok(value)
+            }
             Err(e) => Ok(error_value(e)),
         }
     }

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

@@ -414,31 +414,6 @@ fn valid_result_envelope() -> serde_json::Value {
         "next_actions": []
     })
 }
-fn seed_collect_state(ws: &std::path::Path) {
-    seed_team_spec(ws);
-    crate::state::persist::save_runtime_state(
-        ws,
-        &json!({
-            "agents": {"fake_impl": {"status": "idle"}},
-            "tasks": [{
-                "id": "task_impl",
-                "title": "Fake implementation",
-                "type": "implementation",
-                "assignee": "fake_impl",
-                "deps": [],
-                "acceptance": ["fake result collected"],
-                "status": "pending",
-                "requires_tools": [],
-                "files": [],
-                "risk": "low"
-            }],
-            "session_name": Value::Null,
-            "active_team_key": Value::Null,
-            "spec_path": ws.join("team.spec.yaml").to_string_lossy()
-        }),
-    )
-    .unwrap();
-}
 fn seed_uncollected_result(ws: &std::path::Path, result_id: &str) {
     let store = crate::message_store::MessageStore::open(ws).unwrap();
     let conn = crate::db::schema::open_db(store.db_path()).unwrap();
@@ -450,18 +425,6 @@ fn seed_uncollected_result(ws: &std::path::Path, result_id: &str) {
         )
         .unwrap();
 }
-fn read_state(ws: &std::path::Path) -> serde_json::Value {
-    serde_json::from_str(
-        &std::fs::read_to_string(crate::state::persist::runtime_state_path(ws)).unwrap(),
-    )
-    .unwrap()
-}
-fn read_events(ws: &std::path::Path) -> Vec<serde_json::Value> {
-    crate::event_log::EventLog::new(ws).tail(50).unwrap()
-}
-fn seeded_team_key(ws: &std::path::Path) -> String {
-    ws.file_name().unwrap().to_string_lossy().to_string()
-}
 fn json_output(result: CmdResult) -> serde_json::Value {
     match result.output {
         CmdOutput::Json(v) => v,
@@ -590,40 +553,3 @@ fn remove_agent_from_spec_refusal_is_not_success_envelope() {
         "refused remove-agent must not delete the spec-defined agent"
     );
 }
-#[test]
-fn stuck_cancel_persists_suppression_and_stuck_list_reads_state() {
-    let ws = tmp_workspace();
-    seed_collect_state(&ws);
-    let out = messaging::stuck_cancel(&ws, "fake_impl", None, "leader").unwrap();
-    let team_key = seeded_team_key(&ws);
-    assert_eq!(out["ok"], json!(true));
-    assert_eq!(
-        out["alert_types"],
-        json!(["cross_worker_deadlock", "idle_fallback", "stuck"])
-    );
-    assert!(
-        out["suppressed"]["idle_fallback"]["snapshot"]["assigned_task_ids"]
-            .as_array()
-            .unwrap()
-            .contains(&json!("task_impl"))
-    );
-    let state = read_state(&ws);
-    assert_eq!(
-        state["coordinator"]["suppressed_idle_alerts"][&team_key]["fake_impl"]["idle_fallback"]
-            ["suppressed_by"],
-        json!("leader")
-    );
-    assert!(
-        read_events(&ws)
-            .iter()
-            .any(|e| e["event"] == json!("coordinator.idle_alert_suppressed")
-                && e["agent_id"] == json!("fake_impl")),
-        "stuck_cancel must write coordinator.idle_alert_suppressed"
-    );
-    let listed = messaging::stuck_list(&ws).unwrap();
-    assert_eq!(
-        listed["suppressed_idle_alerts"]["fake_impl"]["stuck"]["suppressed_by"],
-        json!("leader"),
-        "stuck-list must read the persisted state mirror, not return a hard-coded empty list"
-    );
-}

package/crates/team-agent/src/compiler/tests.rs

@@ -163,25 +163,21 @@ fn front_matter_body_lstrip_strips_only_newlines() {
 }
 
 #[test]
-fn front_matter_unterminated_errors() {
-    let p = write_tmp("unterminated.md", "---\nname: x\n");
-    let err = read_front_matter(&p).unwrap_err();
-    assert!(
-        err.to_string().contains("unterminated front matter"),
-        "got: {err}"
-    );
+fn front_matter_unterminated_falls_back_to_plain_text() {
+    let text = "---\nname: x\n";
+    let p = write_tmp("unterminated.md", text);
+    let (meta, body) = read_front_matter(&p).expect("unterminated front matter is plain text");
+    assert_eq!(meta, Value::Map(Vec::new()));
+    assert_eq!(body, text);
 }
 
 #[test]
-fn front_matter_non_object_errors() {
-    // A YAML list in the block → "front matter must be a YAML object" (compiler.py:183-184).
-    let p = write_tmp("list.md", "---\n- a\n- b\n---\nbody\n");
-    let err = read_front_matter(&p).unwrap_err();
-    assert!(
-        err.to_string()
-            .contains("front matter must be a YAML object"),
-        "got: {err}"
-    );
+fn front_matter_non_object_falls_back_to_plain_text() {
+    let text = "---\n- a\n- b\n---\nbody\n";
+    let p = write_tmp("list.md", text);
+    let (meta, body) = read_front_matter(&p).expect("non-object front matter is plain text");
+    assert_eq!(meta, Value::Map(Vec::new()));
+    assert_eq!(body, text);
 }
 
 // ───────────────────────────── compile_team: full dict parity ─────────────────────────────
@@ -395,7 +391,7 @@ const ROLE_MISSING_PROVIDER: &str = "\
 ---
 name: implementer
 role: Implementation Engineer
-model: gpt-5.5
+model: team-agent/qwen3.8-27b
 auth_mode: subscription
 dangerously_skip_permissions: false
 tools:
@@ -406,13 +402,14 @@ Implement bounded tasks.
 ";
 
 #[test]
-fn compile_missing_required_provider_field_errors() {
+fn compile_missing_provider_defaults_to_pi() {
     let team = build_team(TEAM_BASE, &[("implementer.md", ROLE_MISSING_PROVIDER)], &[]);
-    let err = compile_team(&team).unwrap_err();
-    assert!(
-        err.to_string()
-            .contains("missing front matter field provider"),
-        "got: {err}"
+    let spec = compile_team(&team).expect("an omitted provider defaults to Pi");
+    let agent = agent0(&spec);
+    assert_eq!(agent.get("provider"), Some(&Value::Str("pi".to_string())));
+    assert_eq!(
+        agent.get("model"),
+        Some(&Value::Str("team-agent/qwen3.8-27b".to_string()))
     );
 }
 

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

@@ -44,48 +44,38 @@ pub struct IgnoredTeamField {
     pub value: String,
 }
 
-/// `compiler._read_front_matter` (compiler.py:173-185).
-///
-/// Reads `path` (UTF-8). If the text does not start with `"---\n"`, returns
-/// `({}, full_text)`. Otherwise splits on the first `"\n---"` after byte 4:
-/// unterminated (no closing marker) → `ValidationError "{path}: unterminated
-/// front matter"`; the front-matter block is parsed via `simple_yaml.loads`
-/// (empty block → `{}`); a non-dict block → `ValidationError "{path}: front
-/// matter must be a YAML object"`. The body is everything after the closing
-/// marker, `lstrip("\n")` (leading NEWLINES only — not other whitespace).
+/// Read optional YAML front matter; malformed or non-object headers are plain text.
 pub fn read_front_matter(path: &Path) -> Result<(Value, String), ModelError> {
     let text = fs::read_to_string(path)
         .map_err(|e| ModelError::Runtime(format!("{}: {e}", path.display())))?;
     let text = text.replace("\r\n", "\n").replace('\r', "\n");
+    let empty_meta = || Value::Map(Vec::new());
     let Some(rest) = text.strip_prefix("---\n") else {
-        return Ok((Value::Map(Vec::new()), text));
+        return Ok((empty_meta(), text));
     };
-    let Some(close) = rest.find("\n---") else {
-        return Err(ModelError::Validation(format!(
-            "{}: unterminated front matter",
-            path.display()
-        )));
+
+    let mut offset = 0;
+    let mut close = None;
+    for line in rest.split_inclusive('\n') {
+        if line.strip_suffix('\n').unwrap_or(line) == "---" {
+            close = Some(offset);
+            break;
+        }
+        offset += line.len();
+    }
+    let Some(close) = close else {
+        return Ok((empty_meta(), text));
     };
-    let raw_meta = rest.get(..close).ok_or_else(|| {
-        ModelError::Validation(format!("{}: unterminated front matter", path.display()))
-    })?;
-    let after_meta = rest.get(close..).ok_or_else(|| {
-        ModelError::Validation(format!("{}: unterminated front matter", path.display()))
-    })?;
-    let after_marker = after_meta.strip_prefix("\n---").ok_or_else(|| {
-        ModelError::Validation(format!("{}: unterminated front matter", path.display()))
-    })?;
+    let raw_meta = &rest[..close];
     let meta = if raw_meta.trim().is_empty() {
-        Value::Map(Vec::new())
+        empty_meta()
     } else {
-        yaml::loads(raw_meta)?
+        match yaml::loads(raw_meta) {
+            Ok(meta) if meta.is_map() => meta,
+            _ => return Ok((empty_meta(), text)),
+        }
     };
-    if !meta.is_map() {
-        return Err(ModelError::Validation(format!(
-            "{}: front matter must be a YAML object",
-            path.display()
-        )));
-    }
+    let after_marker = &rest[close + 3..];
     Ok((meta, after_marker.trim_start_matches('\n').to_string()))
 }
 
@@ -161,7 +151,7 @@ pub fn compile_team(team_dir: &Path) -> Result<Value, ModelError> {
     let workspace = paths::team_workspace(team_dir)?;
     let workspace_s = workspace.display().to_string();
     let team_name =
-        string_field(&team_meta, "name").unwrap_or_else(|| team_dir_parent_name(team_dir));
+        string_field(&team_meta, "name").unwrap_or_else(|| workspace_dir_name(&workspace));
     let objective = string_field(&team_meta, "objective")
         .or_else(|| non_empty_trimmed(&team_body))
         .unwrap_or_else(|| "Team Agent document-driven team.".to_string());
@@ -487,9 +477,23 @@ fn compile_role_agent_with_mode(
     let (meta, body) = read_front_matter(role_path)?;
     let communication_mode =
         communication_mode_field(&meta, role_path)?.unwrap_or(team_communication_mode);
-    let id = required_string(&meta, role_path, "name")?;
-    let role = required_string(&meta, role_path, "role")?;
-    let provider = required_string(&meta, role_path, "provider")?;
+    let id = string_field(&meta, "agent_id")
+        .or_else(|| string_field(&meta, "name"))
+        .filter(|id| !id.trim().is_empty())
+        .or_else(|| {
+            role_path
+                .file_stem()
+                .and_then(|stem| stem.to_str())
+                .filter(|stem| !stem.is_empty())
+                .map(ToString::to_string)
+        })
+        .unwrap_or_else(|| "worker".to_string());
+    let role = string_field(&meta, "role")
+        .filter(|role| !role.trim().is_empty())
+        .unwrap_or_else(|| id.clone());
+    let provider = string_field(&meta, "provider")
+        .filter(|provider| !provider.trim().is_empty())
+        .unwrap_or_else(|| "pi".to_string());
     require_explicit_grok_role_model(&meta, role_path, &provider)?;
     require_explicit_cursor_role_model(&meta, role_path, &provider)?;
     validate_pi_role_fields(&meta, role_path, &provider)?;
@@ -498,7 +502,7 @@ fn compile_role_agent_with_mode(
         string_field(&meta, "model")
             .filter(|value| !value.trim().is_empty())
             .map(Value::Str)
-            .unwrap_or(Value::Null)
+            .unwrap_or_else(|| Value::Str("openai-codex/gpt-6-luna".to_string()))
     } else {
         resolve_model(&meta, team_meta, &provider)
     };
@@ -532,11 +536,9 @@ fn compile_role_agent_with_mode(
                 ("file", Value::Null),
             ]),
         ),
-        // 0.5.66 bypass 单源:compiler 透传角色 md 的 `dangerously_skip_permissions`
-        // (必填 bool,spec 校验保证存在)。取代旧"恒发 permission_mode: restricted"。
         (
             "dangerously_skip_permissions",
-            Value::Bool(required_dangerously_skip_permissions(&meta, role_path)?),
+            Value::Bool(optional_dangerously_skip_permissions(&meta)),
         ),
         (
             "communication_mode",
@@ -555,6 +557,9 @@ fn compile_role_agent_with_mode(
             ]),
         ),
     ];
+    if let Some(label) = string_field(&meta, "label") {
+        agent_items.insert(1, ("label", Value::Str(label)));
+    }
     if let Some(profile) = string_field(&meta, "profile") {
         agent_items.push(("profile", Value::Str(profile)));
     }
@@ -572,6 +577,7 @@ fn compile_role_agent_with_mode(
             })?;
             Some(parsed)
         }
+        _ if is_pi => Some(ProviderEffort::Max),
         _ => None,
     };
     let team_effort = match string_field(team_meta, "provider_effort") {
@@ -668,15 +674,6 @@ fn string_field(meta: &Value, key: &str) -> Option<String> {
         .map(ToString::to_string)
 }
 
-fn required_string(meta: &Value, path: &Path, key: &str) -> Result<String, ModelError> {
-    string_field(meta, key).ok_or_else(|| {
-        ModelError::Validation(format!(
-            "{}: missing front matter field {key}",
-            path.display()
-        ))
-    })
-}
-
 /// 缺 model 时框架会填内建默认（grok 上是 grok-4），席位因此静默拿到
 /// 与角色文件无关的模型和上下文窗口，而 argv 看起来完全正常。
 /// 角色文件必须自己写死；内建默认、team 级默认、CLI 全局默认都是隐式来源。
@@ -746,19 +743,10 @@ fn validate_pi_role_fields(meta: &Value, path: &Path, provider: &str) -> Result<
     Ok(())
 }
 
-/// 0.5.66 bypass 单源:角色 md 的 `dangerously_skip_permissions` 必填 bool。
-/// 缺 = 编译失败(消息含硬串);非 bool = 同 fail-loud。
-fn required_dangerously_skip_permissions(meta: &Value, path: &Path) -> Result<bool, ModelError> {
+fn optional_dangerously_skip_permissions(meta: &Value) -> bool {
     match meta.get("dangerously_skip_permissions") {
-        Some(Value::Bool(value)) => Ok(*value),
-        Some(_) => Err(ModelError::Validation(format!(
-            "{}: front matter field dangerously_skip_permissions must be a boolean. This field must be declared explicitly; it controls whether the agent launches with permission prompts bypassed.",
-            path.display()
-        ))),
-        None => Err(ModelError::Validation(format!(
-            "{}: missing front matter field dangerously_skip_permissions. This field must be declared explicitly; it controls whether the agent launches with permission prompts bypassed.",
-            path.display()
-        ))),
+        Some(Value::Bool(value)) => *value,
+        _ => true,
     }
 }
 
@@ -880,10 +868,9 @@ fn non_empty_trimmed(text: &str) -> Option<String> {
     }
 }
 
-fn team_dir_parent_name(team_dir: &Path) -> String {
-    team_dir
-        .parent()
-        .and_then(Path::file_name)
+fn workspace_dir_name(workspace: &Path) -> String {
+    workspace
+        .file_name()
         .and_then(|s| s.to_str())
         .filter(|s| !s.is_empty())
         .unwrap_or("team")

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

@@ -105,12 +105,7 @@ fn s3_process_worker() {
             assert_eq!(line.trim(), "commit");
         });
     }
-    let tools = crate::mcp_server::TeamOrchestratorTools::with_identity(
-        &dir, Some(crate::model::ids::AgentId::new("leader")), team.map(crate::model::ids::TeamKey::new),
-    );
     match action.as_str() {
-        "assign" => { tools.assign_task(&payload, Some("bounded contract")).unwrap(); }
-        "note" => { println!("S3 note={:?}", tools.update_state(payload.as_str().unwrap()).unwrap()); }
         "collect" => {
             let output = crate::messaging::results::collect_for_team(&dir, Some(&dir.join("result.json")), false, team).unwrap();
             assert_eq!(output["ok"], true);
@@ -152,10 +147,7 @@ fn s3_tick_preserves_tasks_notes_and_siblings() {
         seed(dir, false);
         let hook: SaveHook = Box::new(|ws, observed| {
             assert_eq!(observed["agents"]["w1"]["worker_state"], "DEAD", "tick must produce a real observation delta");
-            write(ws.as_path(), "assign", Some("T1"), task("new-task"));
-            write(ws.as_path(), "note", Some("T1"), json!("concurrent note"));
             write(ws.as_path(), "collect", Some("T1"), Value::Null);
-            write(ws.as_path(), "note", Some("T2"), json!("sibling note"));
             write(ws.as_path(), "sibling", None, Value::Null);
             let latest = disk(ws.as_path());
             assert_eq!(latest["teams"]["T1"]["agents"]["w1"]["pane_id"], observed["agents"]["w1"]["pane_id"]);
@@ -166,11 +158,11 @@ fn s3_tick_preserves_tasks_notes_and_siblings() {
         assert!(report.ok, "tick must save its observation: {report:?}");
         let state = disk(dir);
         let team = &state["teams"]["T1"];
+        assert_eq!(team["tasks"][0]["id"], "original");
         assert_eq!(team["tasks"][0]["accepted_result_id"], "result-original");
-        assert!(team["tasks"].as_array().unwrap().iter().any(|row| row["id"] == "new-task"));
-        assert_eq!(team["notes"], json!(["original note", "concurrent note"]));
+        assert_eq!(team["notes"], json!(["original note"]));
         assert_eq!(team["agents"]["w1"]["worker_state"], "DEAD");
-        assert_eq!(state["teams"]["T2"]["notes"], json!(["original note", "sibling note"]));
+        assert_eq!(state["teams"]["T2"]["notes"], json!(["original note"]));
         assert_eq!(state["teams"]["T3"]["notes"], json!(["third"]));
         assert_eq!(state["tasks"], team["tasks"]);
         assert_eq!(StateRepository::new(dir).load_team(Some("T1")).unwrap()["tasks"], team["tasks"]);
@@ -179,50 +171,26 @@ fn s3_tick_preserves_tasks_notes_and_siblings() {
 }
 
 #[test]
-fn s3_business_writers_commit_once_on_latest() {
-    isolated("s3_business_writers_commit_once_on_latest", |root| {
-        for (i, (left, right)) in [
-            (("assign", task("left")), ("assign", task("right"))),
-            (("note", json!("same note")), ("note", json!("same note"))),
-            (("note", json!("same note")), ("assign", task("right"))),
-            (("collect", Value::Null), ("assign", task("right"))),
-            (("collect", Value::Null), ("note", json!("same note"))),
-        ].into_iter().enumerate() {
-            let dir = root.join(i.to_string());
-            seed(&dir, false);
-            let waiting = start_writer(&dir, left.0, Some("T1"), left.1, true);
-            write(&dir, right.0, Some("T1"), right.1);
-            finish(waiting, true);
-            let state = disk(&dir);
-            let team = &state["teams"]["T1"];
-            if left.0 == "assign" { assert!(team["tasks"].as_array().unwrap().iter().any(|task| task["id"] == "left")); }
-            if right.0 == "assign" { assert!(team["tasks"].as_array().unwrap().iter().any(|task| task["id"] == "right")); }
-            if left.0 == "collect" { assert_eq!(team["tasks"][0]["accepted_result_id"], "result-original"); }
-            let notes = usize::from(left.0 == "note") + usize::from(right.0 == "note");
-            assert_eq!(team["notes"].as_array().unwrap().len(), 1 + notes);
-            if left.0 == "note" && right.0 == "assign" {
-                let markdown = std::fs::read_to_string(dir.join(".team/runtime/T1/team_state.md")).unwrap();
-                assert!(markdown.contains("right"), "note must render the committed task view: {markdown}");
-            }
-            if left.0 == "collect" {
-                write(&dir, "assign", Some("T1"), json!({"id": "original", "assignee": "w1", "title": "edited"}));
-                assert_eq!(disk(&dir)["teams"]["T1"]["tasks"][0]["accepted_result_id"], "result-original");
-            }
-            println!("S3 pair {i} canonical={team}");
-        }
+fn s3_result_collection_commit_preserves_concurrent_sibling() {
+    isolated("s3_result_collection_commit_preserves_concurrent_sibling", |dir| {
+        seed(dir, false);
+        let waiting = start_writer(&dir, "collect", Some("T1"), Value::Null, true);
+        write(&dir, "sibling", None, Value::Null);
+        finish(waiting, true);
+        let state = disk(&dir);
+        assert_eq!(state["teams"]["T1"]["tasks"][0]["accepted_result_id"], "result-original");
+        assert_eq!(state["teams"]["T3"]["notes"], json!(["third"]));
+        assert_eq!(state["teams"]["T2"]["notes"], json!(["original note"]));
     });
 }
 
 #[test]
-fn s3_legacy_note_and_collection_keep_independent_updates() {
-    isolated("s3_legacy_note_and_collection_keep_independent_updates", |dir| {
+fn s3_legacy_result_collection_preserves_root_shape() {
+    isolated("s3_legacy_result_collection_preserves_root_shape", |dir| {
         seed(dir, true);
-        let waiting = start_writer(dir, "collect", None, Value::Null, true);
-        write(dir, "note", None, json!("legacy note"));
-        finish(waiting, true);
+        write(dir, "collect", None, Value::Null);
         let state = disk(dir);
         assert_eq!(state["tasks"][0]["accepted_result_id"], "result-original");
-        assert_eq!(state["notes"], json!(["original note", "legacy note"]));
         assert!(state.get("teams").is_none(), "legacy single Team shape remains valid");
     });
 }

package/crates/team-agent/src/leader/start.rs

@@ -304,20 +304,7 @@ fn leader_start_plan_with_ambient_authority(
             identity.team_id.as_str(),
         );
         let prompt = crate::lifecycle::worker_command_context::compile_pi_leader_system_prompt();
-        let team_mcp_tools = [
-            "assign_task",
-            "send_message",
-            "update_state",
-            "get_team_status",
-            "stop_agent",
-            "reset_agent",
-            "add_agent",
-            "clone_agent",
-            "fork_agent",
-            "request_human",
-            "stuck_list",
-            "stuck_cancel",
-        ];
+        let team_mcp_tools = ["send_message", "report_result", "get_team_status"];
         crate::lifecycle::launch::pi_mcp::materialize_pi_plan(
             crate::lifecycle::launch::pi_mcp::PiMaterializeRequest {
                 workspace,