@team-agent/installer 0.5.69 → 0.5.71

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

@@ -2522,10 +2522,10 @@ fn write_restart_agent_failed_event(
                 "session_id": decision.session_id.as_ref().map(|session| session.as_str()),
                 "phase": phase,
                 "error": error,
-                "action": format!(
-                    "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                    decision.agent_id,
-                    decision.agent_id
+                "action": restart_failure_action(
+                    &decision.agent_id,
+                    phase,
+                    decision.session_id.as_ref(),
                 ),
                 "log": format!(
                     ".team/logs/coordinator.log and .team/runtime/state.json agent={}",
@@ -3008,14 +3008,30 @@ fn restart_failure_next_actions(failed_agents: &[RestartFailedAgent]) -> Vec<Str
     failed_agents
         .iter()
         .map(|failure| {
-            format!(
-                "inspect worker {} output, then restart that worker with `team-agent restart-agent {}` or rerun `team-agent restart --allow-fresh`",
-                failure.agent_id, failure.agent_id
+            restart_failure_action(
+                &failure.agent_id,
+                &failure.phase,
+                failure.session_id.as_ref(),
             )
         })
         .collect()
 }
 
+pub(crate) fn restart_failure_action(
+    agent_id: &AgentId,
+    phase: &str,
+    session_id: Option<&SessionId>,
+) -> String {
+    if phase == "spawn" && session_id.is_none() {
+        return format!(
+            "worker {agent_id} failed before a pane was created; inspect the reported provider error, then rerun `team-agent restart --allow-fresh`"
+        );
+    }
+    format!(
+        "inspect worker {agent_id} output, then reset that worker with `team-agent reset-agent {agent_id}` or rerun `team-agent restart --allow-fresh`"
+    )
+}
+
 fn start_mode_wire(mode: StartMode) -> &'static str {
     match mode {
         StartMode::Resumed => "resumed",

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

@@ -92,7 +92,8 @@ pub(crate) use rebuild::restart_with_transport_with_session_convergence_deadline
 // timer + worker timing writer so `lifecycle::launch::launch_with_transport_in_workspace`
 // can emit the same instrumentation event family with `source="launch"`.
 pub(crate) use rebuild::{
-    provider_wire_from_state, write_worker_spawn_timing_event, RestartPhaseTimer,
+    provider_wire_from_state, restart_failure_action, write_worker_spawn_timing_event,
+    RestartPhaseTimer,
 };
 pub use rebuild::{restart, restart_with_session_convergence_deadline};
 pub(crate) use rebuild::{

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

@@ -18,8 +18,8 @@ fn command_for_model(model: &str) -> Vec<String> {
     build_pi_command_argv(PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/w1/team-mcp.ts"),
-        model,
-        effort: ProviderEffort::Medium,
+        model: Some(model),
+        effort: Some(ProviderEffort::Medium),
         system_prompt: "worker contract",
         tool_categories: &["mcp_team"],
         session_dir: Path::new("/workspace/.team/runtime/pi/t1/w1/sessions"),

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

@@ -7,8 +7,8 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
     PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts"),
-        model: "team-agent/qwen3.8-27b",
-        effort: ProviderEffort::High,
+        model: Some("team-agent/qwen3.8-27b"),
+        effort: Some(ProviderEffort::High),
         system_prompt: "frozen worker prompt",
         tool_categories: &["mcp_team", "fs_read", "fs_write", "execute_bash"],
         session_dir: Path::new("/workspace/.team/runtime/pi/team-a/worker-a/sessions"),
@@ -18,7 +18,20 @@ fn request(session: PiSessionSelector<'static>) -> PiCommandRequest<'static> {
 }
 
 #[test]
-fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
+fn pi_command_omits_unset_model_and_thinking_flags() {
+    let mut request = request(PiSessionSelector::Fresh {
+        session_id: "a2320d4e-7b3a-44ae-b3b8-d5de57033b01",
+    });
+    request.model = None;
+    request.effort = None;
+    let argv = build_pi_command_argv(request).expect("Pi provider defaults");
+
+    assert!(!argv.iter().any(|arg| arg == "--model"), "argv={argv:?}");
+    assert!(!argv.iter().any(|arg| arg == "--thinking"), "argv={argv:?}");
+}
+
+#[test]
+fn pi_command_preserves_direct_pi_defaults_with_only_team_runtime_additions() {
     let fresh = build_pi_command_argv(request(PiSessionSelector::Fresh {
         session_id: "da8c3622-2378-4d05-a26c-e826a6ef6d63",
     }))
@@ -27,23 +40,14 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
         fresh,
         [
             "/verified/pi",
-            "--no-extensions",
             "-e",
             "/workspace/.team/runtime/pi/team-a/worker-a/team-mcp.ts",
-            "--no-approve",
-            "--no-context-files",
-            "--no-skills",
-            "--no-prompt-templates",
-            "--tui-mode",
-            "regular",
             "--model",
             "team-agent/qwen3.8-27b",
             "--thinking",
             "high",
-            "--system-prompt",
+            "--append-system-prompt",
             "frozen worker prompt",
-            "--tools",
-            "bash,edit,mcp,read,write",
             "--session-dir",
             "/workspace/.team/runtime/pi/team-a/worker-a/sessions",
             "--session-id",
@@ -88,6 +92,14 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
             "--force",
             "--trust",
             "--sandbox",
+            "--no-extensions",
+            "--no-approve",
+            "--no-context-files",
+            "--no-skills",
+            "--no-prompt-templates",
+            "--tui-mode",
+            "--tools",
+            "--system-prompt",
         ] {
             assert!(
                 !argv.iter().any(|arg| arg == forbidden),
@@ -98,23 +110,26 @@ fn pi_command_is_exact_regular_tui_and_has_no_ambient_flags() {
 }
 
 #[test]
-fn pi_command_uses_no_context_no_extensions_no_approve() {
+fn pi_command_keeps_direct_plugins_skills_context_auth_and_tools() {
     let argv = build_pi_command_argv(request(PiSessionSelector::Fresh {
         session_id: "76f682b1-ecc3-4586-850f-ab2e2bb04cb3",
     }))
     .expect("fresh Pi command");
 
-    for required in [
+    for forbidden in [
         "--no-context-files",
         "--no-extensions",
         "--no-approve",
         "--no-skills",
         "--no-prompt-templates",
+        "--tools",
+        "--system-prompt",
+        "--tui-mode",
     ] {
         assert_eq!(
-            argv.iter().filter(|arg| arg.as_str() == required).count(),
-            1,
-            "required isolation flag must occur once: {required}; argv={argv:?}"
+            argv.iter().filter(|arg| arg.as_str() == forbidden).count(),
+            0,
+            "TeamMate Pi must preserve the direct Pi default instead of adding {forbidden}; argv={argv:?}"
         );
     }
     assert!(argv.windows(2).any(|pair| {
@@ -124,5 +139,7 @@ fn pi_command_uses_no_context_no_extensions_no_approve() {
         ]
     }));
     assert_eq!(argv.iter().filter(|arg| arg.as_str() == "-e").count(), 1);
-    assert!(!argv.iter().any(|arg| arg == "--approve"));
+    assert!(argv
+        .windows(2)
+        .any(|pair| pair == ["--append-system-prompt", "frozen worker prompt"]));
 }

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

@@ -14,6 +14,13 @@ const CATALOG: &[u8] = include_bytes!("fixtures/pi_list_models_g0.stdout.txt");
 static NEXT_ROLE: AtomicU32 = AtomicU32::new(0);
 
 fn compile_pi_role(front_matter: &str) -> Result<CompiledRole, ModelError> {
+    compile_pi_role_with_team(front_matter, &Value::Map(Vec::new()))
+}
+
+fn compile_pi_role_with_team(
+    front_matter: &str,
+    team_meta: &Value,
+) -> Result<CompiledRole, ModelError> {
     let seq = NEXT_ROLE.fetch_add(1, Ordering::Relaxed);
     let root = std::env::temp_dir().join(format!(
         "team-agent-pi-compiler-{}-{seq}",
@@ -26,7 +33,7 @@ fn compile_pi_role(front_matter: &str) -> Result<CompiledRole, ModelError> {
         format!("---\n{front_matter}\n---\nPi worker contract.\n"),
     )
     .expect("write role fixture");
-    let result = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace");
+    let result = compile_role_agent(&role, team_meta, "/workspace");
     std::fs::remove_dir_all(root).expect("remove role fixture root");
     result
 }
@@ -48,8 +55,8 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
     build_pi_command_argv(PiCommandRequest {
         executable: Path::new("/verified/pi"),
         extension: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/team-mcp.ts"),
-        model,
-        effort,
+        model: Some(model),
+        effort: Some(effort),
         system_prompt: "Pi worker contract.",
         tool_categories: tools,
         session_dir: Path::new("/workspace/.team/runtime/pi/t1/pi-worker/sessions"),
@@ -62,19 +69,15 @@ fn command(tools: &[&str], effort: ProviderEffort, model: &str) -> Result<Vec<St
 }
 
 #[test]
-fn pi_role_requires_qualified_model_explicit_effort_and_mcp_team() {
+fn pi_role_requires_mcp_team_and_preserves_provider_defaults() {
     let positive = compile_pi_role(&valid_role_with(""));
     assert!(positive.is_ok(), "fully explicit Pi role must compile");
 
-    let missing_model = valid_role_with("").replace("model: team-agent/qwen3.8-27b\n", "");
-    let missing_effort = valid_role_with("").replace("effort: medium\n", "");
     let missing_mcp = valid_role_with("").replace("  - mcp_team\n", "");
     let unqualified =
         valid_role_with("").replace("model: team-agent/qwen3.8-27b", "model: qwen3.8-27b");
 
     for (label, role) in [
-        ("model", missing_model),
-        ("effort", missing_effort),
         ("mcp_team", missing_mcp),
         ("qualified exact model", unqualified),
     ] {
@@ -85,13 +88,45 @@ fn pi_role_requires_qualified_model_explicit_effort_and_mcp_team() {
         );
     }
 
+    let defaults = valid_role_with("")
+        .replace("model: team-agent/qwen3.8-27b\n", "")
+        .replace("effort: medium\n", "");
+    let team_meta = Value::Map(vec![
+        (
+            "provider_models".to_string(),
+            Value::Map(vec![(
+                "pi".to_string(),
+                Value::Str("team-default/forced-model".to_string()),
+            )]),
+        ),
+        (
+            "default_model".to_string(),
+            Value::Str("global-default/forced-model".to_string()),
+        ),
+        (
+            "provider_effort".to_string(),
+            Value::Str("high".to_string()),
+        ),
+    ]);
+    let compiled = compile_pi_role_with_team(&defaults, &team_meta)
+        .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"
+    );
+    assert!(
+        compiled.agent.get("effort").is_none(),
+        "omitted Pi effort must not inherit a synthesized framework default"
+    );
+
     let models = parse_pi_list_models_table(CATALOG).expect("catalog fixture");
     assert!(select_exact_pi_model(&models, "team-agent/qwen3.8-27b").is_ok());
     assert!(select_exact_pi_model(&models, "foo/bar").is_err());
 }
 
 #[test]
-fn pi_role_requires_intrinsic_unrestricted_ack_true() {
+fn pi_role_uses_standard_bypass_field_without_fabricating_argv() {
     let compiled = compile_pi_role(&valid_role_with("")).expect("true acknowledgement");
     assert_eq!(
         compiled.agent.get("dangerously_skip_permissions"),
@@ -122,10 +157,16 @@ fn pi_role_requires_intrinsic_unrestricted_ack_true() {
         "dangerously_skip_permissions: true",
         "dangerously_skip_permissions: false",
     );
-    let error = compile_error(compile_pi_role(&false_ack));
-    let text = error.to_string();
+    let compiled = compile_pi_role(&false_ack).expect("standard false bypass value");
+    assert_eq!(
+        compiled.agent.get("dangerously_skip_permissions"),
+        Some(&Value::Bool(false))
+    );
+
+    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("dangerously_skip_permissions") && text.contains("true"),
+        text.contains("missing front matter field dangerously_skip_permissions"),
         "got {text}"
     );
 }
@@ -153,7 +194,7 @@ fn pi_max_effort_is_supported_without_model_suffix() {
 }
 
 #[test]
-fn pi_tools_allowlist_keeps_mcp_and_rejects_unknown_categories() {
+fn pi_role_tools_validate_team_capabilities_without_replacing_direct_pi_tools() {
     assert_eq!(pi_tool_mapping("mcp_team"), PiToolMapping::Mcp);
     assert_eq!(
         pi_tool_mapping("fs_read"),
@@ -194,14 +235,9 @@ fn pi_tools_allowlist_keeps_mcp_and_rejects_unknown_categories() {
         ProviderEffort::Medium,
         "team-agent/qwen3.8-27b",
     )
-    .expect("known allowlist");
-    let tools = argv
-        .windows(2)
-        .find(|pair| pair[0] == "--tools")
-        .map(|pair| pair[1].as_str())
-        .expect("--tools value");
-    assert_eq!(
-        tools, "bash,edit,find,grep,ls,mcp,read,write",
-        "tools must be sorted and deduplicated"
+    .expect("known standard role tools");
+    assert!(
+        !argv.iter().any(|arg| arg == "--tools"),
+        "role tools validate Team Agent capabilities but must not replace direct Pi tools: {argv:?}"
     );
 }

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

@@ -224,12 +224,27 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     );
     let leader = parse_pi_leader_args(&leader_argv[2..])
         .expect("leader exact model and effort must compile into the shared plan input");
-    assert_eq!(leader.model, "team-agent/qwen3.8-27b");
-    assert_eq!(leader.effort, ProviderEffort::Max);
+    assert_eq!(leader.model.as_deref(), Some("team-agent/qwen3.8-27b"));
+    assert_eq!(leader.effort, Some(ProviderEffort::Max));
+
+    let defaults = parse_pi_leader_args(&[]).expect("leader provider defaults");
+    assert_eq!(defaults.model, None);
+    assert_eq!(defaults.effort, None);
+    assert_eq!(
+        parse_pi_leader_args(&["--thinking".to_string(), "medium".to_string()])
+            .expect("explicit thinking only")
+            .effort,
+        Some(ProviderEffort::Medium)
+    );
+    assert_eq!(
+        parse_pi_leader_args(&["--model".to_string(), "team-agent/qwen3.8-27b".to_string(),])
+            .expect("explicit model only")
+            .model
+            .as_deref(),
+        Some("team-agent/qwen3.8-27b")
+    );
 
     for invalid in [
-        vec!["--thinking".to_string(), "medium".to_string()],
-        vec!["--model".to_string(), "team-agent/qwen3.8-27b".to_string()],
         vec![
             "--model".to_string(),
             "qwen3.8-27b".to_string(),
@@ -247,7 +262,7 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
     ] {
         assert!(
             parse_pi_leader_args(&invalid).is_err(),
-            "leader input must refuse missing, ambiguous, or materializer-owned fields: {invalid:?}"
+            "leader input must refuse ambiguous or materializer-owned fields: {invalid:?}"
         );
     }
 
@@ -267,12 +282,15 @@ fn pi_leader_and_teammate_body(hermetic: &HermeticTestEnv) {
 
     std::fs::write(
         &role,
-        "---\nname: worker-a\nrole: developer\nprovider: pi\nauth_mode: subscription\neffort: max\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\nworker contract\n",
+        "---\nname: worker-a\nrole: developer\nprovider: pi\nauth_mode: subscription\ntools:\n  - mcp_team\ndangerously_skip_permissions: true\n---\nworker contract\n",
     )
-    .expect("write missing-model teammate role");
+    .expect("write provider-default teammate role");
+    let defaults = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace")
+        .expect("provider: pi teammate may use Pi model and effort defaults");
+    assert_eq!(defaults.agent.get("model"), Some(&Value::Null));
     assert!(
-        compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace").is_err(),
-        "provider: pi teammate without an exact model must refuse"
+        defaults.agent.get("effort").is_none(),
+        "omitted Pi model and effort must remain absent"
     );
     std::fs::remove_dir_all(root).expect("remove role fixture");