@team-agent/installer 0.5.101 → 0.5.103

package/Cargo.lock

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

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

@@ -290,6 +290,7 @@ pub(crate) fn default_help() -> String {
         &["claim-leader", "takeover", "attach-leader"],
     );
     out.push_str("\nWorkflow: `team-agent models --provider pi`, then quick-start/add-agent/start-agent, then `team-agent send AGENT MESSAGE`.\n");
+    out.push_str("Model catalogs: pi, cursor_agent, codex, claude, claude_code.\n");
     out.push_str("Provider launchers:\n  team-agent codex|claude|copilot|grok|cursor|pi ...\n");
     out.push_str("\nRun `team-agent <command> --help` for command flags.");
     out
@@ -340,7 +341,7 @@ fn command_help(command: Option<&str>) -> String {
         .to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
         Some("status") => "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]\n\n输出七字段：name/provider/runtime_status/activity/health/session_name/tmux_command；人读与 --json 使用同一投影。缺少可靠定位或原生 tmux/process 采样时显示 unknown；tmux_command 可复制到对应目标。--summary/--detail 仅保留兼容性，不增加诊断字段。".to_string(),
-        Some("models") => "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, and display name. Cursor uses the local `agent --list-models` catalog.".to_string(),
+        Some("models") => "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]\n\nLists exact provider model ids with case-insensitive multi-word search across provider, vendor, id, display name, and source aliases. Uses each provider's native catalog; Codex uses `codex debug models` and Claude uses SDK stream-json initialize.".to_string(),
         Some("leaders") => "usage: team-agent leaders [QUERY|--search TEXT] [--all|--stale] [--json] | --prune [--dry-run] [--json]\n\nLists LIVE leaders by default. Use --all to include retained STALE entries, --stale to inspect only STALE entries, QUERY or --search TEXT to match workspace/team/name fields, and --prune to remove only entries proven terminal by canonical state. --dry-run is valid only with --prune.".to_string(),
         Some("shutdown") => "usage: team-agent shutdown [--workspace WORKSPACE] [--team TEAM] [--keep-logs] [--json]".to_string(),
         Some("restart") => "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json] [--detail]".to_string(),

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

@@ -3,292 +3,157 @@ use super::{CliError, CmdOutput, CmdResult, ExitCode, ModelsArgs};
 use serde_json::{json, Value};
 #[cfg(test)]
 use std::collections::BTreeMap;
+#[cfg(test)]
 use std::path::Path;
+#[cfg(test)]
 use std::time::Duration;
+
+#[cfg(test)]
 const CATALOG_TIMEOUT: Duration = Duration::from_secs(10);
+#[cfg(test)]
 const MAX_CATALOG_BYTES: u64 = 1024 * 1024;
+type ModelRecord = crate::provider::model_catalog::ModelRecord;
 
+#[cfg(test)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum CatalogFormat {
     Pi,
     CursorAgent,
 }
 
-#[derive(Clone, Debug)]
-struct ModelRecord {
-    provider: String,
-    vendor: String,
-    id: String,
-    display_name: String,
-    default: Option<bool>,
-}
-
 pub fn cmd_models(args: &ModelsArgs) -> Result<CmdResult, CliError> {
-    let (program, format) = match args.provider.as_str() {
-        "pi" => (Path::new("pi"), CatalogFormat::Pi),
-        "cursor_agent" => (Path::new("agent"), CatalogFormat::CursorAgent),
-        provider => {
-            return Ok(failure(
-                args,
-                &format!("unsupported model provider {provider:?}"),
-            ))
+    let records = match crate::provider::model_catalog::discover_model_catalog(&args.provider) {
+        Ok(records) => records,
+        Err(error) => {
+            let message = error.message(&args.provider);
+            let action = error.action(&args.provider);
+            return Ok(failure_with_action(args, &message, &action));
         }
     };
-    cmd_models_with_format(args, program, format, CATALOG_TIMEOUT, MAX_CATALOG_BYTES)
-}
-
-/// Existing injectable Pi boundary retained for deterministic command/timeout tests.
-fn cmd_models_with(
-    args: &ModelsArgs,
-    program: &Path,
-    timeout: Duration,
-    max_bytes: u64,
-) -> Result<CmdResult, CliError> {
-    cmd_models_with_format(args, program, CatalogFormat::Pi, timeout, max_bytes)
+    render_catalog(args, records)
 }
 
-fn cmd_models_with_format(
-    args: &ModelsArgs,
-    program: &Path,
-    format: CatalogFormat,
-    timeout: Duration,
-    max_bytes: u64,
-) -> Result<CmdResult, CliError> {
-    let bytes = match run_catalog(program, timeout, max_bytes) {
-        Ok(bytes) => bytes,
-        Err(message) => return Ok(failure(args, &catalog_error_prefix(format, message))),
-    };
-    let all = match parse_catalog(&bytes, format) {
-        Ok(models) => models,
-        Err(message) => return Ok(failure(args, &message)),
-    };
+fn render_catalog(args: &ModelsArgs, all: Vec<ModelRecord>) -> Result<CmdResult, CliError> {
     let visible = args.search.as_deref().map_or_else(
         || all.clone(),
-        |search| {
-            all.iter()
-                .filter(|model| model_matches(model, search))
-                .cloned()
-                .collect::<Vec<_>>()
-        },
+        |search| all.iter().filter(|model| crate::provider::model_catalog::model_matches(model, search)).cloned().collect(),
     );
-    let current = current_model_for(format, &all);
-    let entries: Vec<Value> = visible
-        .iter()
-        .map(|model| {
-            json!({
-                "role_model": model.id,
-                "current": if format == CatalogFormat::Pi {
-                    json!(current.as_deref() == Some(model.id.as_str()))
-                } else {
-                    Value::Null
-                },
-                "provider": model.provider,
-                "vendor": model.vendor,
-                "model_id": model.id,
-                "display_name": model.display_name,
-                "default": model.default,
-            })
-        })
-        .collect();
+    let current = if args.provider == "pi" {
+        current_role_model(&all.iter().map(|model| model.id.clone()).collect::<Vec<_>>())
+    } else {
+        None
+    };
+    let entries: Vec<Value> = visible.iter().map(|model| json!({
+        "role_model": model.id,
+        "current": if args.provider == "pi" { json!(current.as_deref() == Some(model.id.as_str())) } else { Value::Null },
+        "provider": model.provider,
+        "vendor": model.vendor,
+        "model_id": model.id,
+        "display_name": model.display_name,
+        "default": model.default,
+        "aliases": model.aliases,
+    })).collect();
     let provider = args.provider.as_str();
     let value = json!({
         "schema_version": "models.v1", "ok": true, "provider": provider, "models": entries,
         "auth": "ok", "auth_basis": "catalog_visibility", "current_role_model": current, "search": args.search,
     });
     if args.json {
-        let text = serde_json::to_string_pretty(&value)?;
         Ok(CmdResult {
-            output: CmdOutput::Human(text),
+            output: CmdOutput::Human(serde_json::to_string_pretty(&value)?),
             exit: ExitCode::Ok,
             as_json: false,
             preserve_json_order: true,
         })
     } else {
-        let mut lines = vec![format!(
-            "models.v1 | {provider} models (copyable model_id):"
-        )];
+        let mut lines = vec![format!("models.v1 | {provider} models (copyable model_id):")];
         lines.push("PROVIDER VENDOR MODEL_ID DISPLAY_NAME CURRENT DEFAULT".to_string());
-        lines.extend(visible.iter().map(|model| {
-            format!(
-                "{} {} {} {} {} {}",
-                model.provider,
-                model.vendor,
-                model.id,
-                model.display_name,
-                if format == CatalogFormat::Pi {
-                    (current.as_deref() == Some(model.id.as_str())).to_string()
-                } else {
-                    "—".to_string()
-                },
-                model
-                    .default
-                    .map_or_else(|| "—".to_string(), |value| value.to_string()),
-            )
-        }));
-        lines.push(format!(
-            "auth: ok (catalog_visibility); {} model(s)",
-            visible.len()
-        ));
+        lines.extend(visible.iter().map(|model| format!(
+            "{} {} {} {} {} {}", model.provider, model.vendor, model.id, model.display_name,
+            if args.provider == "pi" { (current.as_deref() == Some(model.id.as_str())).to_string() } else { "—".to_string() },
+            model.default.map_or_else(|| "—".to_string(), |value| value.to_string()),
+        )));
+        lines.push(format!("auth: ok (catalog_visibility); {} model(s)", visible.len()));
         if visible.is_empty() {
-            lines.push("No models matched --search/query.".to_string());
+            lines.push("No models matched --search/query; rerun without a search to list the full catalog.".to_string());
         }
         Ok(CmdResult::human(lines.join("\n")))
     }
 }
 
+/// Existing injectable Pi boundary retained for deterministic command/timeout tests.
+#[cfg(test)]
+fn cmd_models_with(args: &ModelsArgs, program: &Path, timeout: Duration, max_bytes: u64) -> Result<CmdResult, CliError> {
+    cmd_models_with_format(args, program, CatalogFormat::Pi, timeout, max_bytes)
+}
+
+#[cfg(test)]
+fn cmd_models_with_format(args: &ModelsArgs, program: &Path, format: CatalogFormat, timeout: Duration, max_bytes: u64) -> Result<CmdResult, CliError> {
+    let bytes = match run_catalog(program, timeout, max_bytes) {
+        Ok(bytes) => bytes,
+        Err(message) => return Ok(failure(args, &message)),
+    };
+    let all = match parse_catalog(&bytes, format) {
+        Ok(models) => models,
+        Err(message) => return Ok(failure(args, &message)),
+    };
+    render_catalog(args, all)
+}
+
+#[cfg(test)]
 fn parse_catalog(bytes: &[u8], format: CatalogFormat) -> Result<Vec<ModelRecord>, String> {
-    match format {
-        CatalogFormat::Pi => crate::lifecycle::launch::pi_mcp::parse_pi_list_models_table(bytes)
-            .map(|models| {
-                models
-                    .into_iter()
-                    .map(|id| {
-                        let vendor = id
-                            .split_once('/')
-                            .map_or_else(|| "pi".to_string(), |(vendor, _)| vendor.to_string());
-                        ModelRecord {
-                            provider: "pi".to_string(),
-                            vendor,
-                            display_name: id.clone(),
-                            id,
-                            default: None,
-                        }
-                    })
-                    .collect()
-            })
-            .map_err(safe_catalog_error),
-        CatalogFormat::CursorAgent => parse_cursor_catalog(bytes),
-    }
+    let provider = match format { CatalogFormat::Pi => "pi", CatalogFormat::CursorAgent => "cursor_agent" };
+    let result = match format {
+        CatalogFormat::Pi => crate::provider::model_catalog::parse_pi_catalog(bytes),
+        CatalogFormat::CursorAgent => crate::provider::model_catalog::parse_cursor_catalog(bytes),
+    };
+    result.map_err(|error| error.message(provider))
 }
 
+#[cfg(test)]
 fn parse_cursor_catalog(bytes: &[u8]) -> Result<Vec<ModelRecord>, String> {
-    let text = std::str::from_utf8(bytes)
-        .map_err(|_| "Cursor model catalog is not valid UTF-8".to_string())?;
-    let mut models = Vec::new();
-    for line in text.lines() {
-        let line = line.trim();
-        if line.is_empty()
-            || line
-                .trim_end_matches(':')
-                .eq_ignore_ascii_case("available models")
-        {
-            continue;
-        }
-        let Some((id, display)) = line.split_once(" - ") else {
-            return Err("Cursor model catalog contains a malformed row".to_string());
-        };
-        let id = id.trim();
-        if id.is_empty() || id.chars().any(char::is_whitespace) || display.trim().is_empty() {
-            return Err("Cursor model catalog contains a malformed row".to_string());
-        }
-        if models.iter().any(|model: &ModelRecord| model.id == id) {
-            return Err("Cursor model catalog contains duplicate model ids".to_string());
-        }
-        let default = display.trim_end().ends_with("(default)");
-        let display_name = display.trim().strip_suffix("(default)").map_or_else(
-            || display.trim().to_string(),
-            |name| name.trim().to_string(),
-        );
-        let vendor = id
-            .split_once('-')
-            .map_or_else(|| "cursor".to_string(), |(vendor, _)| vendor.to_string());
-        models.push(ModelRecord {
-            provider: "cursor_agent".to_string(),
-            vendor,
-            id: id.to_string(),
-            display_name,
-            default: Some(default),
-        });
-    }
-    if models.is_empty() {
-        return Err("Cursor model catalog is empty".to_string());
-    }
-    Ok(models)
+    crate::provider::model_catalog::parse_cursor_catalog(bytes)
+        .map_err(|error| error.message("cursor_agent"))
 }
 
+#[cfg(test)]
 fn model_matches(model: &ModelRecord, search: &str) -> bool {
-    let fields = [
-        model.provider.as_str(),
-        model.vendor.as_str(),
-        model.id.as_str(),
-        model.display_name.as_str(),
-    ];
-    search
-        .split_whitespace()
-        .map(str::to_lowercase)
-        .all(|needle| {
-            fields
-                .iter()
-                .any(|field| field.to_lowercase().contains(needle.as_str()))
-        })
+    crate::provider::model_catalog::model_matches(model, search)
 }
 
+#[cfg(test)]
 fn current_model_for(format: CatalogFormat, models: &[ModelRecord]) -> Option<String> {
     match format {
-        CatalogFormat::Pi => current_role_model(
-            &models
-                .iter()
-                .map(|model| model.id.clone())
-                .collect::<Vec<_>>(),
-        ),
-        // Cursor's catalog does not expose the active role model; never mark a
-        // catalog default as current without an explicit runtime identity.
+        CatalogFormat::Pi => current_role_model(&models.iter().map(|model| model.id.clone()).collect::<Vec<_>>()),
         CatalogFormat::CursorAgent => None,
     }
 }
 
-fn catalog_error_prefix(format: CatalogFormat, message: String) -> String {
-    match format {
-        CatalogFormat::Pi => message,
-        CatalogFormat::CursorAgent => message.replace("Pi", "Cursor"),
-    }
-}
-
+#[cfg(test)]
 fn failure(args: &ModelsArgs, message: &str) -> CmdResult {
-    let executable = if args.provider == "cursor_agent" {
-        "agent"
-    } else {
-        "pi"
-    };
     let action = if message.starts_with("unsupported model provider") {
-        "choose a supported provider: pi or cursor_agent".to_string()
+        "choose a supported provider: pi, cursor_agent, codex, claude, or claude_code".to_string()
     } else {
-        format!(
-            "install or repair the PATH-first `{executable}` executable, then retry `team-agent models --provider {}`",
-            args.provider
-        )
+        let executable = match args.provider.as_str() {
+            "cursor_agent" => "agent",
+            "codex" => "codex",
+            "claude" | "claude_code" => "claude",
+            _ => "pi",
+        };
+        format!("install or repair the PATH-first `{executable}` executable, then retry `team-agent models --provider {}`", args.provider)
     };
+    failure_with_action(args, message, &action)
+}
+
+fn failure_with_action(args: &ModelsArgs, message: &str, action: &str) -> CmdResult {
     let value = json!({ "schema_version": "models.v1", "ok": false, "provider": args.provider, "auth": "not_ready", "auth_basis": "catalog_visibility", "models": Value::Array(Vec::new()), "current_role_model": Value::Null, "error": message, "action": action });
     if args.json {
-        let text = serde_json::to_string_pretty(&value)
-            .unwrap_or_else(|_| "{\"schema_version\":\"models.v1\",\"ok\":false}".to_string());
-        CmdResult {
-            output: CmdOutput::Human(text),
-            exit: ExitCode::Error,
-            as_json: false,
-            preserve_json_order: true,
-        }
+        let text = serde_json::to_string_pretty(&value).unwrap_or_else(|_| "{\"schema_version\":\"models.v1\",\"ok\":false}".to_string());
+        CmdResult { output: CmdOutput::Human(text), exit: ExitCode::Error, as_json: false, preserve_json_order: true }
     } else {
         CmdResult { output: CmdOutput::Human(format!("models.v1 | error: {message}\naction: {action}\nauth: not_ready (catalog_visibility)")), exit: ExitCode::Error, as_json: false, preserve_json_order: false }
     }
 }
-
-fn safe_catalog_error(error: crate::provider::ProviderError) -> String {
-    let text = error.to_string();
-    if text.contains("not UTF-8") {
-        "Pi model catalog is not valid UTF-8".into()
-    } else if text.contains("duplicate") {
-        "Pi model catalog contains duplicate model ids".into()
-    } else if text.contains("header") {
-        "Pi model catalog has an unexpected header".into()
-    } else if text.contains("row") {
-        "Pi model catalog contains a malformed row".into()
-    } else if text.contains("empty") || text.contains("no models") {
-        "Pi model catalog is empty".into()
-    } else {
-        "Pi model catalog is invalid".into()
-    }
-}
 fn current_role_model(models: &[String]) -> Option<String> {
     current_role_model_from(
         models,
@@ -309,6 +174,7 @@ fn current_role_model_from(
 }
 
 /// Injectable executable, deadline, and byte-limit boundary for deterministic tests.
+#[cfg(test)]
 fn run_catalog(program: &Path, timeout: Duration, max_bytes: u64) -> Result<Vec<u8>, String> {
     crate::lifecycle::launch::pi_mcp::run_pi_catalog(program, timeout, max_bytes)
 }
@@ -995,7 +861,7 @@ mod tests {
         assert!(text.contains("No models matched --search") && text.contains("auth: ok"));
         let refusal = crate::cli::emit::__test_dispatch(
             "models",
-            &["--provider".into(), "codex".into()],
+            &["--provider".into(), "cloud".into()],
             Path::new("/tmp"),
         );
         assert!(matches!(refusal, Ok(ExitCode::Error)));
@@ -1095,14 +961,14 @@ mod tests {
         );
         assert_eq!(
             crate::cli::run(
-                &["models".into(), "--provider".into(), "codex".into()],
+                &["models".into(), "--provider".into(), "cloud".into()],
                 Path::new("/tmp")
             ),
             ExitCode::Error
         );
         assert_eq!(
             crate::cli::spec::command_spec("models").unwrap().usage,
-            "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]"
+            "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]"
         );
     }
 

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

@@ -147,7 +147,7 @@ pub(crate) const COMMAND_SPECS: &[CommandSpec] = &[
     CommandSpec { name: "quick-start", tier: CommandTier::Core, category: CommandCategory::Start, kind: CommandKind::Dispatch(DispatchKind::QuickStart), summary: "start or attach a team from TEAM.md", usage: "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--backend tmux|conpty] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },
     CommandSpec { name: "send", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Send), summary: "persist a message for an in-team short name or fully-qualified logical recipient", usage: "usage: team-agent send TO MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--mailbox] [--json]\nTO forms are co-equal: an in-team short name (for example `team-agent send reviewer \"Review\"`) or `<workspace>::<team>/<agent>`.", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: Some("next compatibility release"), action: Some("use positional logical TO and the returned message id"), governance: None },
     CommandSpec { name: "status", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Status), summary: "show current team status", usage: "usage: team-agent status [AGENT] [--workspace WORKSPACE] [--team TEAM] [--summary|--json] [--detail]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
-    CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models [--provider pi|cursor_agent] [QUERY|--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
+    CommandSpec { name: "models", tier: CommandTier::Core, category: CommandCategory::Observe, kind: CommandKind::Dispatch(DispatchKind::Models), summary: "list exact provider model ids", usage: "usage: team-agent models [--provider pi|cursor_agent|codex|claude|claude_code] [QUERY|--search TEXT] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "results", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Results), summary: "read reported results for a case", usage: "usage: team-agent results --case CASE_ID [--workspace WORKSPACE] [--team TEAM] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "wait", tier: CommandTier::Core, category: CommandCategory::Daily, kind: CommandKind::Dispatch(DispatchKind::Wait), summary: "block until a task result is stored", usage: "usage: team-agent wait --task TASK [--workspace WORKSPACE] [--json]", default_help: false, command_help: true, suggestion_index: true, token_usage: TokenUsage::No, sunset: None, action: None, governance: None },
     CommandSpec { name: "restart", tier: CommandTier::Core, category: CommandCategory::TeamLifecycle, kind: CommandKind::Dispatch(DispatchKind::Restart), summary: "restart the selected team", usage: "usage: team-agent restart [WORKSPACE] [--team TEAM] [--allow-fresh] [--session-converge-deadline SECONDS] [--json]", default_help: true, command_help: true, suggestion_index: true, token_usage: TokenUsage::Conditional, sunset: None, action: None, governance: None },

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()))
     );
 }