@team-agent/installer 0.5.101 → 0.5.102

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.101"
+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.101"
+version = "0.5.102"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

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",
@@ -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/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))
     );
 }