@team-agent/installer 0.5.101 → 0.5.103

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",
@@ -575,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") {
@@ -671,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 全局默认都是隐式来源。
@@ -749,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,
     }
 }
 
@@ -883,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,

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

@@ -15,14 +15,13 @@
 
 use std::collections::BTreeSet;
 use std::fs::OpenOptions;
-use std::io::{Read, Write};
+use std::io::Write;
 #[cfg(test)]
 use std::cell::RefCell;
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-use std::sync::mpsc;
-use std::time::{Duration, Instant};
+use std::process::Command;
+use std::time::Duration;
 
 use sha2::{Digest, Sha256};
 
@@ -132,62 +131,9 @@ pub(crate) fn new_pi_session_id() -> SessionId {
 /// errors: 非 UTF-8、header/row 异常、重复或空 catalog 时返回 ProviderError
 /// ---
 pub(crate) fn parse_pi_list_models_table(bytes: &[u8]) -> Result<Vec<String>, ProviderError> {
-    let text = std::str::from_utf8(bytes).map_err(|error| {
-        ProviderError::Command(format!("Pi model catalog is not UTF-8: {error}"))
-    })?;
-    let mut lines = text.lines();
-    let header = lines
-        .next()
-        .ok_or_else(|| ProviderError::Command("Pi model catalog is empty".to_string()))?;
-    let header_columns = header.split_whitespace().collect::<Vec<_>>();
-    if header_columns.get(0) != Some(&"provider") || header_columns.get(1) != Some(&"model") {
-        return Err(ProviderError::Command(
-            "Pi model catalog has an unexpected header".to_string(),
-        ));
-    }
-    let mut seen = BTreeSet::new();
-    let mut models = Vec::new();
-    for (index, line) in lines.enumerate() {
-        if line.trim().is_empty() {
-            continue;
-        }
-        let malformed = || {
-            ProviderError::Command(format!(
-                "Pi model catalog row {} is malformed",
-                index + 2
-            ))
-        };
-        let (provider, model) = line
-            .trim()
-            .split_once(char::is_whitespace)
-            .ok_or_else(malformed)?;
-        let mut model = model.trim();
-        // Pi prints the raw model id, which may contain spaces. Only the
-        // capability columns following it are single whitespace-free values.
-        for _ in 2..header_columns.len() {
-            model = model
-                .rsplit_once(char::is_whitespace)
-                .ok_or_else(malformed)?
-                .0
-                .trim_end();
-        }
-        if model.is_empty() {
-            return Err(malformed());
-        }
-        let exact = format!("{provider}/{model}");
-        if !seen.insert(exact.clone()) {
-            return Err(ProviderError::Command(format!(
-                "Pi model catalog contains duplicate exact id {exact:?}"
-            )));
-        }
-        models.push(exact);
-    }
-    if models.is_empty() {
-        return Err(ProviderError::Command(
-            "Pi model catalog contains no models".to_string(),
-        ));
-    }
-    Ok(models)
+    crate::provider::model_catalog::parse_pi_catalog(bytes)
+        .map(|records| records.into_iter().map(|record| record.id).collect())
+        .map_err(|error| ProviderError::Command(error.pi_legacy_message()))
 }
 
 /// ---
@@ -658,43 +604,6 @@ fn observe_pi_catalog_test(f: impl FnOnce(&mut PiCatalogTestContext)) {
     });
 }
 
-fn spawn_catalog_reader(
-    stdout: std::process::ChildStdout,
-    max_bytes: u64,
-) -> mpsc::Receiver<(std::io::Result<usize>, Vec<u8>)> {
-    let (sender, receiver) = mpsc::channel();
-    std::thread::spawn(move || {
-        let mut bytes = Vec::new();
-        let result = stdout.take(max_bytes + 1).read_to_end(&mut bytes);
-        let _ = sender.send((result, bytes));
-    });
-    receiver
-}
-
-fn finish_catalog_reader(
-    receiver: mpsc::Receiver<(std::io::Result<usize>, Vec<u8>)>,
-    status: std::process::ExitStatus,
-    timeout: Duration,
-    max_bytes: u64,
-) -> Result<Vec<u8>, String> {
-    let (result, bytes) = match receiver.recv_timeout(timeout) {
-        Ok(value) => value,
-        Err(_) => {
-            #[cfg(test)]
-            observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
-            return Err("Pi model catalog command timed out".to_string());
-        }
-    };
-    if !status.success() {
-        return Err("Pi model catalog command failed".into());
-    }
-    result.map_err(|_| "Pi model catalog could not be read".to_string())?;
-    if bytes.len() as u64 > max_bytes {
-        return Err("Pi model catalog exceeds the bounded output limit".into());
-    }
-    Ok(bytes)
-}
-
 #[cfg(test)]
 pub(crate) fn run_pi_catalog_after_parent_exit_for_test(
     stdout: std::process::ChildStdout,
@@ -708,86 +617,53 @@ pub(crate) fn run_pi_catalog_after_parent_exit_for_test(
         context.observation.parent_exit_success = Some(status.success());
         context.observation.parent_exit_code = status.code();
     });
-    finish_catalog_reader(
-        spawn_catalog_reader(stdout, max_bytes),
-        status,
-        timeout,
-        max_bytes,
+    crate::provider::model_catalog::finish_stdout_after_exit(
+        stdout, status, timeout, max_bytes, &mut PiCatalogObserver,
     )
+    .map_err(|error| error.pi_legacy_message())
 }
 
-/// Discover candidates with one PATH-first catalog observation. This deliberately
-/// does not resolve adapters or scan wrapper chains; callers use it only for
-/// rejecting an unqualified role model before lifecycle mutation.
+/// Shared bounded native-command runner; launch preflight keeps its exact model gate.
 pub(crate) fn run_pi_catalog(
     executable: &Path,
     timeout: Duration,
     max_bytes: u64,
 ) -> Result<Vec<u8>, String> {
-    let mut command = Command::new(executable);
-    command.arg("--list-models");
+    let mut extra_env = Vec::new();
     #[cfg(test)]
     observe_pi_catalog_test(|context| {
         context.observation.spawn_count += 1;
         context.observation.argv.push("--list-models".to_string());
-        command.env("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT", &context.receipt);
+        extra_env.push(("TEAM_AGENT_MODELS_TIMEOUT_RECEIPT".into(), context.receipt.as_os_str().into()));
         if let Some(mode) = context.helper_mode.as_deref() {
-            command.env("TEAM_AGENT_MODELS_TIMEOUT_MODE", mode);
+            extra_env.push(("TEAM_AGENT_MODELS_TIMEOUT_MODE".into(), mode.into()));
         }
     });
-    let mut child = command
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::null())
-        .spawn()
-        .map_err(|error| {
-            #[cfg(test)]
-            {
-                eprintln!(
-                    "run_pi_catalog spawn failed kind={:?} raw_os_error={:?}",
-                    error.kind(),
-                    error.raw_os_error()
-                );
-            }
-            let _ = error;
-            "Pi executable is unavailable on PATH".to_string()
-        })?;
+    crate::provider::model_catalog::run_command(
+        executable, &["--list-models"], None, None, &[], &extra_env, timeout, max_bytes,
+        &mut PiCatalogObserver,
+    )
+    .map_err(|error| error.pi_legacy_message())
+}
+
+struct PiCatalogObserver;
+impl crate::provider::model_catalog::CatalogObserver for PiCatalogObserver {
     #[cfg(test)]
-    observe_pi_catalog_test(|context| context.observation.parent_pid = Some(child.id()));
-    let stdout = child.stdout.take().ok_or_else(|| {
-        let _ = child.kill();
-        let _ = child.wait();
-        "Pi model catalog output unavailable".to_string()
-    })?;
-    let receiver = spawn_catalog_reader(stdout, max_bytes);
-    let start = Instant::now();
-    loop {
-        match child.try_wait() {
-            Ok(Some(status)) => {
-                #[cfg(test)]
-                observe_pi_catalog_test(|context| {
-                    context.observation.parent_exit_success = Some(status.success());
-                    context.observation.parent_exit_code = status.code();
-                });
-                return finish_catalog_reader(
-                    receiver,
-                    status,
-                    timeout.saturating_sub(start.elapsed()),
-                    max_bytes,
-                );
-            }
-            Ok(None) if start.elapsed() < timeout => std::thread::sleep(Duration::from_millis(20)),
-            Ok(None) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return Err("Pi model catalog command timed out".into());
-            }
-            Err(_) => {
-                let _ = child.kill();
-                let _ = child.wait();
-                return Err("Pi model catalog command could not be observed".into());
-            }
-        }
+    fn spawned(&mut self, pid: u32) {
+        observe_pi_catalog_test(|context| context.observation.parent_pid = Some(pid));
+    }
+
+    #[cfg(test)]
+    fn exited(&mut self, status: &std::process::ExitStatus) {
+        observe_pi_catalog_test(|context| {
+            context.observation.parent_exit_success = Some(status.success());
+            context.observation.parent_exit_code = status.code();
+        });
+    }
+
+    #[cfg(test)]
+    fn output_timeout(&mut self) {
+        observe_pi_catalog_test(|context| context.observation.reader_timeout = true);
     }
 }
 

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

@@ -167,7 +167,7 @@ pub(super) fn spawn_agents(
                     model: command_model,
                     effort: agent_effort,
                     system_prompt: &system_prompt,
-                    team_mcp_tools: &["send_message", "report_result"],
+                    team_mcp_tools: &["send_message", "report_result", "get_team_status"],
                     mcp_config: &mcp_config,
                     session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
                 },

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

@@ -397,7 +397,7 @@ pub(super) fn spawn_agent_window(
             model: command_model,
             effort: restart_effort,
             system_prompt: &system_prompt,
-            team_mcp_tools: &["send_message", "report_result"],
+            team_mcp_tools: &["send_message", "report_result", "get_team_status"],
             mcp_config: &mcp_config,
             session_scope: crate::lifecycle::launch::pi_mcp::PiSessionScope::Isolated,
         };

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

@@ -532,22 +532,6 @@ fn reset_stopped_true_still_rechecks_same_role_residue_before_start() {
     );
 }
 
-#[test]
-fn mcp_reset_output_exposes_capture_outcome_and_weak_reset_proof() {
-    let src = include_str!(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/src/mcp_server/lifecycle_tools/agent_ops.rs"
-    ));
-    let reset = source_section(src, "pub(crate) fn reset_agent", "pub(crate) fn fork_agent");
-    let json_object = reset_success_json_object(reset);
-    let missing = ["\"capture_state\":", "\"reset_proof\":", "\"transcript_missing\"", "\"attribution_ambiguous\"", "\"weak\""]
-        .into_iter().filter(|needle| !json_object.contains(needle)).collect::<Vec<_>>();
-    assert!(
-        missing.is_empty(),
-        "P0 MCP reset: ok=true/status=reset must expose additive capture_state and reset_proof=weak inside the ResetAgentOutcome::Reset serde_json::json! object; missing={missing:?}; reset_json={json_object}"
-    );
-}
-
 #[test]
 #[serial(env)]
 fn abnormal_shell_pane_with_live_delivery_is_not_dead_and_dedupe_ignores_size() {
@@ -972,15 +956,3 @@ impl ProviderRegistry for RealAdapterRegistry {
         get_adapter(provider)
     }
 }
-
-fn source_section<'a>(src: &'a str, start: &str, end: &str) -> &'a str { let start = src.find(start).unwrap_or(0); let rest = &src[start..]; &rest[..rest.find(end).unwrap_or(rest.len())] }
-
-fn reset_success_json_object(reset_src: &str) -> &str {
-    let success = source_section(reset_src, "ResetAgentOutcome::Reset", "ResetAgentOutcome::Refused");
-    let macro_start = success.find("serde_json::json!({").expect("reset success json object"); let object_start = macro_start + success[macro_start..].find('{').unwrap(); let mut depth = 0_i32;
-    for (offset, ch) in success[object_start..].char_indices() {
-        if ch == '{' { depth += 1; } if ch == '}' { depth -= 1; }
-        if depth == 0 { return &success[object_start..object_start + offset + 1]; }
-    }
-    panic!("unterminated reset success json object")
-}

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

@@ -108,12 +108,13 @@ fn pi_role_ignores_tools_and_preserves_provider_defaults() {
         .expect("Pi model and effort may use provider defaults");
     assert_eq!(
         compiled.agent.get("model"),
-        Some(&Value::Null),
-        "omitted Pi model must not inherit a synthesized framework default"
+        Some(&Value::Str("openai-codex/gpt-6-luna".to_string())),
+        "omitted Pi model uses the Luna default rather than team metadata"
     );
-    assert!(
-        compiled.agent.get("effort").is_none(),
-        "omitted Pi effort must not inherit a synthesized framework default"
+    assert_eq!(
+        compiled.agent.get("effort"),
+        Some(&Value::Str("max".to_string())),
+        "omitted Pi effort uses the global max default rather than team metadata"
     );
 
     let models = parse_pi_list_models_table(CATALOG).expect("catalog fixture");
@@ -160,10 +161,11 @@ fn pi_role_uses_standard_bypass_field_without_fabricating_argv() {
     );
 
     let missing_ack = valid_role_with("").replace("dangerously_skip_permissions: true\n", "");
-    let text = compile_error(compile_pi_role(&missing_ack)).to_string();
-    assert!(
-        text.contains("missing front matter field dangerously_skip_permissions"),
-        "got {text}"
+    let compiled = compile_pi_role(&missing_ack)
+        .expect("omitted bypass metadata defaults to true");
+    assert_eq!(
+        compiled.agent.get("dangerously_skip_permissions"),
+        Some(&Value::Bool(true))
     );
 }