@team-agent/installer 0.5.112 → 0.5.113

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

@@ -209,7 +209,7 @@ fn csv_agent_status(
     health: Option<&serde_json::Map<String, Value>>,
 ) -> &'static str {
     if stale_agent_bucket(agent).is_some() {
-        return "错误";
+        return "error";
     }
     let raw = agent
         .get("status")
@@ -226,7 +226,7 @@ fn csv_agent_status(
         || matches!(hstatus.as_str(), "failed" | "error" | "spawn_failed")
         || matches!(raw.as_str(), "stopped" | "done")
     {
-        return "错误";
+        return "error";
     }
     let pane_present = agent
         .get("pane_id")
@@ -239,21 +239,21 @@ fn csv_agent_status(
             .filter(|pane| !pane.is_empty())
             .is_some();
     if matches!(raw.as_str(), "running" | "busy" | "working") && !pane_present {
-        return "错误";
+        return "error";
     }
     // 0.5.35 R4: canonical UNKNOWN beats legacy WORKING in human CSV too.
     if canonical_worker_state_is_unknown(agent) {
-        return "未知";
+        return "unknown";
     }
     if raw == "idle" || hstatus == "idle" {
-        return "空闲";
+        return "idle";
     }
     if matches!(raw.as_str(), "running" | "busy" | "working")
         || matches!(hstatus.as_str(), "running" | "working" | "busy")
     {
-        return "工作";
+        return "working";
     }
-    "错误"
+    "error"
 }
 
 /// `_latest_result_line`(`commands.py:333-337`):agent_id/summary/created_at 渲染单行。

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

@@ -420,7 +420,7 @@ fn format_status_csv_preserves_agent_order_and_collapses_errors() {
     });
     assert_eq!(
             format_status_csv(&data),
-            "zeta,空闲\nalpha,工作\nerr_failed,错误\nerr_missing_pane,错误\nerr_unknown,错误\nerr_stopped,错误"
+            "zeta,idle\nalpha,working\nerr_failed,error\nerr_missing_pane,error\nerr_unknown,error\nerr_stopped,error"
         );
 }
 
@@ -489,7 +489,7 @@ fn cli_error_payload_plain_runtime() {
     assert_eq!(payload.error, "some other error");
     assert_eq!(
         payload.action,
-        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
+        "Run team-agent doctor --workspace . for the selected team, or inspect the error log shown here."
     );
     assert_eq!(payload.log, "/tmp/y.log");
     assert_eq!(payload.reason, None);
@@ -511,7 +511,7 @@ fn cli_error_payload_tmux_conflict_quick_start_enrichment() {
     // context reset is only through restart --allow-fresh with explicit consent.
     assert_eq!(
             payload.action,
-            "终端会话 `my-team` 已存在，可能是你的已有队伍。恢复用 team-agent restart；只有明确同意丢弃旧对话才用 --allow-fresh。另建队伍请修改 TEAM.md 的 name 后再 quick-start；不要关闭已有队伍凑成功。"
+            "Terminal session `my-team` already exists and may belong to your existing team. Resume with team-agent restart; use --allow-fresh only after explicitly accepting loss of saved context. To create another team, change the name in TEAM.md before quick-start. Do not shut down an existing team to bypass this refusal."
         );
     let next = payload.next_actions.as_ref().unwrap();
     assert_eq!(next.len(), 2);
@@ -529,11 +529,11 @@ fn cli_error_payload_tmux_conflict_non_quick_start_enrichment() {
     assert_eq!(payload.session_name.as_deref(), Some("my-team"));
     assert_eq!(
         payload.action,
-        "终端会话 `my-team` 已存在，可能属于运行中的队伍。不要关闭它；请使用另一个队伍名称后再启动。"
+        "Terminal session `my-team` already exists and may belong to a running team. Do not shut it down; choose another team name before starting."
     );
     let next = payload.next_actions.as_ref().unwrap();
     assert_eq!(next.len(), 1);
-    assert!(next[0].contains("队伍") && next[0].contains("名称"));
+    assert!(next[0].contains("team") && next[0].contains("name"));
 }
 
 #[test]
@@ -749,7 +749,7 @@ fn cmd_leader_passthrough_help_is_pure_human_guidance() {
             let result = cmd_leader_passthrough(provider, &[alias.into()], &cwd).unwrap();
             assert_eq!(result.exit, ExitCode::Ok);
             assert!(
-                matches!(&result.output, CmdOutput::Human(text) if text.contains(provider) && text.contains("用法") && text.contains("Examples") && text.contains("下一步"))
+                matches!(&result.output, CmdOutput::Human(text) if text.contains(provider) && text.contains("Usage") && text.contains("Examples") && text.contains("Next Action"))
             );
         }
     }

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

@@ -457,7 +457,7 @@ fn red_send_target_none_is_not_broadcast() {
     assert_eq!(send_target(None, Some("*")), MessageTarget::Broadcast);
 }
 
-// Unified doctor human output is triage only, including the comms gate.
+// Doctor retains bounded triage navigation plus complete diagnostic details.
 #[test]
 fn cmd_doctor_comms_human_is_compact_triage_without_boundary_prefix() {
     let mut args = DoctorArgs {
@@ -483,8 +483,9 @@ fn cmd_doctor_comms_human_is_compact_triage_without_boundary_prefix() {
     };
     assert_eq!(text, crate::cli::triage::render("doctor", &report));
     assert!(text.starts_with("doctor:"));
-    assert_eq!(text.lines().count(), 1 + report["issues"].as_array().unwrap().len()
+    assert_eq!(text.lines().count(), 2 + report["issues"].as_array().unwrap().len()
         + report["suggested_repairs"].as_array().unwrap().len());
+    assert!(text.lines().last().unwrap().starts_with("details: "));
 }
 
 // ---- #13 / #27 (P2): run() must NOT treat 'claude_code' as a passthrough trigger ----

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

@@ -257,7 +257,7 @@ fn inbox_excludes_leader_stage_result_notifications() {
 // the deterministic check sub-shapes (run_id is a random uuid; not value-locked). ────────────────
 #[test]
 fn comms_selftest_golden_boundary_scope_and_check_shapes() {
-    let boundary = "这里只检查终端连接是否一致，不实际发送消息，也不证明队友已回复。";
+    let boundary = "This checks terminal connection consistency only; it does not send a message or prove that a worker replied.";
     let ws = tmp_workspace();
     let v = diagnose_port::comms_selftest(&ws, None, None).expect("comms_selftest");
     let obj = v.as_object().expect("comms dict");

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

@@ -377,21 +377,21 @@ fn send_to_name_mutual_exclusion() {
     let args = named_send_args(&cwd, Some("team-a/qa"), Some("%1"), None, &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("cannot be combined")),
         "expected --to-name mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, Some("worker"), &["hello"]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("不能同时")),
+        matches!(err, CliError::Usage(ref message) if message.contains("--to-name/--pane/--to") && message.contains("cannot be combined")),
         "expected --to-name/--to mutual exclusion, got {err:?}"
     );
 
     let args = named_send_args(&cwd, Some("team-a/qa"), None, None, &[]);
     let err = cmd_send(&args).unwrap_err();
     assert!(
-        matches!(err, CliError::Usage(ref message) if message == "请填写任务内容；--to-name 不能发送空消息"),
+        matches!(err, CliError::Usage(ref message) if message == "Provide a task message; --to-name cannot send an empty message"),
         "expected empty-message usage error, got {err:?}"
     );
     let _ = std::fs::remove_dir_all(&cwd);

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

@@ -641,11 +641,11 @@ fn cmd_send_joins_message_with_single_space() {
                 // 应立即失败以强制重新审视，而不是悄悄跑一条从未验过的分支。
                 assert!(
                     !delivered,
-                    "hermetic seed 不应产生 delivered=true；tier 假设变了"
+                    "hermetic seed must not produce delivered=true; the fixture assumption changed"
                 );
                 assert_eq!(
                     v.get("reminder").and_then(|reminder| reminder.as_str()),
-                    Some("任务已收下，但还未确认送到队友对话。查看 team-agent status/doctor，等真实回复，不反复重发。")
+                    Some("Task accepted, but delivery is unconfirmed. Check team-agent status/doctor; wait for an actual reply without repeated sends.")
                 );
             }
         }
@@ -665,15 +665,15 @@ fn cmd_send_default_human_output_is_brief_without_false_delivered() {
         "send must separate outcome and next action: {text}"
     );
     assert!(
-        lines[0].contains("任务已收下") && lines[0].contains("还未送到队友的对话"),
+        lines[0].contains("Task accepted") && lines[0].contains("delivery to the agent's conversation is still pending"),
         "queued send must report its true pending outcome: {text}"
     );
     assert!(
-        lines[1].contains("下一步")
+        lines[1].contains("Next:")
             && lines[1].contains("team-agent status")
             && lines[1].contains("doctor")
-            && lines[1].contains("等真实回复")
-            && lines[1].contains("不反复重发"),
+            && lines[1].contains("wait for an actual reply")
+            && lines[1].contains("without repeated sends"),
         "queued send must give honest next steps: {text}"
     );
     assert!(
@@ -951,7 +951,7 @@ fn cmd_send_unknown_task_surfaces_golden_error_envelope_not_silent() {
     );
     assert_eq!(
         payload.action,
-        "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
+        "Run team-agent doctor --workspace . for the selected team, or inspect the error log shown here."
     );
     let _ = std::fs::remove_dir_all(&ws);
 }

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

@@ -56,9 +56,34 @@ pub(crate) fn render(command: &str, report: &Value) -> String {
     for repair in repairs {
         lines.push(bounded(format!("repair: {}", summarize(repair, true))));
     }
+    // Short triage lines are navigation, not the authoritative refusal. Retain
+    // complete causes/actions as JSON, without dumping unrelated runtime or
+    // provider diagnostics. Values have already crossed the redaction boundary.
+    let details = diagnostic_details(&report);
+    if details.as_object().is_some_and(|details| !details.is_empty()) {
+        lines.push(format!("details: {details}"));
+    }
     lines.join("\n")
 }
 
+// Shared by doctor/diagnose and send. Never include message bodies, profiles or
+// unrelated runtime/provider dumps in a command's diagnostic output.
+pub(crate) fn diagnostic_details(report: &Value) -> Value {
+    let report = crate::redaction::redact_external_value(report);
+    let mut details = serde_json::Map::new();
+    for key in [
+        "error", "status", "summary", "reason", "blockers", "action",
+        "next_action", "next_actions", "issues", "suggested_repairs",
+        "state_path", "log", "schema_error", "stage", "delivery_status",
+        "message_status", "verification", "channel", "turn_verification",
+    ] {
+        if let Some(value) = report.get(key) {
+            details.insert(key.to_string(), value.clone());
+        }
+    }
+    Value::Object(details)
+}
+
 fn array_items(value: Option<&Value>) -> &[Value] {
     value.and_then(Value::as_array).map(Vec::as_slice).unwrap_or(&[])
 }
@@ -126,6 +151,7 @@ fn bounded(line: String) -> String {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used)]
     use super::*;
     use serde_json::json;
 
@@ -149,12 +175,37 @@ mod tests {
     #[test]
     fn renderer_sanitizes_and_bounds_utf8_lines() {
         let report = json!({"ok": false, "issues": ["问题\n".to_string() + &"x".repeat(200)]});
-        for line in render("doctor", &report).lines() {
-            assert!(line.len() <= LINE_LIMIT_BYTES);
+        let output = render("doctor", &report);
+        for line in output.lines() {
+            if let Some(details) = line.strip_prefix("details: ") {
+                let parsed: Value = serde_json::from_str(details).unwrap();
+                assert_eq!(parsed.get("issues"), report.get("issues"));
+            } else {
+                assert!(line.len() <= LINE_LIMIT_BYTES);
+            }
             assert!(!line.chars().any(char::is_control));
         }
     }
 
+    #[test]
+    fn renderer_preserves_typed_failure_details_and_long_actions() {
+        let action = "inspect the precise failure ".repeat(20);
+        let report = json!({
+            "ok": false,
+            "status": "preflight_blocked",
+            "reason": "exact refusal",
+            "blockers": [{"stage": "database", "reason": "permission denied"}],
+            "next_actions": [action],
+            "state_path": "/tmp/workspace/.team/runtime/state.json"
+        });
+        let output = render("doctor", &report);
+        let details = output.lines().find_map(|line| line.strip_prefix("details: ")).unwrap();
+        let parsed: Value = serde_json::from_str(details).unwrap();
+        for key in ["status", "reason", "blockers", "next_actions", "state_path"] {
+            assert_eq!(parsed.get(key), report.get(key), "lost {key}");
+        }
+    }
+
     #[test]
     fn renderer_projects_secret_findings_without_values() {
         let report = json!({

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

@@ -84,7 +84,7 @@ impl CliError {
             ok: false,
             error: error.clone(),
             action: if super::spec::command_spec(command).is_some() {
-                "先运行 team-agent doctor --workspace . 检查所选队伍，或查看此处列出的错误日志。"
+                "Run team-agent doctor --workspace . for the selected team, or inspect the error log shown here."
             } else {
                 "run `team-agent doctor` or inspect the log path shown here"
             }
@@ -99,27 +99,27 @@ impl CliError {
             payload.session_name = Some(session.clone());
             if command == "quick-start" {
                 payload.action = format!(
-                    "终端会话 `{session}` 已存在，可能是你的已有队伍。恢复用 team-agent restart；只有明确同意丢弃旧对话才用 --allow-fresh。另建队伍请修改 TEAM.md 的 name 后再 quick-start；不要关闭已有队伍凑成功。"
+                    "Terminal session `{session}` already exists and may belong to your existing team. Resume with team-agent restart; use --allow-fresh only after explicitly accepting loss of saved context. To create another team, change the name in TEAM.md before quick-start. Do not shut down an existing team to bypass this refusal."
                 );
                 payload.next_actions = Some(vec![
-                    "如果是自己的已有队伍，使用 team-agent restart 恢复。".to_string(),
-                    "如要另建队伍，修改 TEAM.md 的 name 后再运行 team-agent quick-start。"
+                    "If this is your existing team, resume it with team-agent restart.".to_string(),
+                    "To create another team, change the name in TEAM.md before running team-agent quick-start."
                         .to_string(),
                 ]);
             } else {
                 payload.action = format!(
-                    "终端会话 `{session}` 已存在，可能属于运行中的队伍。不要关闭它；请使用另一个队伍名称后再启动。"
+                    "Terminal session `{session}` already exists and may belong to a running team. Do not shut it down; choose another team name before starting."
                 );
-                payload.next_actions = Some(vec!["请使用另一个队伍名称后再启动。".to_string()]);
+                payload.next_actions = Some(vec!["Choose another team name before starting.".to_string()]);
             }
         } else if error.contains("Team Agent launcher flag")
             && error.contains("must appear before --")
         {
             payload.action =
-                String::from("将主控启动选项放在 -- 前面；-- 后面只能是工具自己的参数。");
+                String::from("Place Team Agent launcher options before --; only native provider arguments belong after --.");
         } else if error.contains("managed launcher refuses a different ambient tmux server") {
             payload.action = String::from(
-                "先退出当前 tmux 客户端再重试；只有明确需要嵌套连接时才在 -- 前加 --allow-nested-attach。",
+                "Leave the current tmux client before retrying. Add --allow-nested-attach before -- only when nested attachment is intentional.",
             );
         }
         payload

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

@@ -7,6 +7,18 @@ use std::sync::atomic::{AtomicU32, Ordering};
 
 static COUNTER: AtomicU32 = AtomicU32::new(0);
 
+#[test]
+fn cursor_effort_is_rejected_by_shared_admission_for_every_level() {
+    for effort in ["low", "medium", "high", "xhigh", "max", "ultra"] {
+        let role = write_tmp("cursor.md", &format!("---\nprovider: cursor_agent\neffort: {effort}\n---\nRole\n"));
+        let error = compile_role_agent(&role, &Value::Map(Vec::new()), "/workspace")
+            .err()
+            .expect("Cursor must reject effort before command construction");
+        assert!(error.to_string().contains("cursor_agent does not support effort; the Cursor CLI has no --effort flag"));
+        fs::remove_dir_all(role.parent().unwrap()).unwrap();
+    }
+}
+
 fn unique_base() -> PathBuf {
     let n = COUNTER.fetch_add(1, Ordering::Relaxed);
     std::env::temp_dir().join(format!("ta_rs_compile_{}_{}", std::process::id(), n))

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

@@ -590,15 +590,6 @@ fn compile_role_agent_with_mode(
                 effort.as_str()
             )));
         }
-        if provider_enum == Provider::CursorAgent {
-            return Err(ModelError::Validation(format!(
-                "{}: cursor_agent does not support effort '{}'. \
-The Cursor CLI has no `--effort` flag; the framework must not drop the field and still launch. \
-Remove effort from the role file (do not map it into `--model[effort=]` until that form is measured).",
-                role_path.display(),
-                effort.as_str()
-            )));
-        }
         agent_items.push(("effort", Value::Str(effort.as_str().to_string())));
     }
     Ok(CompiledRole {

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

@@ -403,6 +403,11 @@ pub(crate) fn leader_env_for_identity(
             "1".to_string(),
         );
     }
+    // Managed providers run after `sh -lc`; restore the launcher's native
+    // executable lookup path at invocation, not just in the tmux client env.
+    if let Some(path) = std::env::var_os("PATH").and_then(|path| path.into_string().ok()) {
+        leader_env.insert("PATH".to_string(), path);
+    }
     leader_env
 }
 

package/crates/team-agent/src/leader/tests/identity.rs

@@ -291,6 +291,27 @@ fn copilot_leader_env_disables_terminal_title_only_for_copilot() {
     }
 }
 
+#[test]
+#[serial_test::serial(env)]
+fn leader_env_preserves_native_path_for_managed_shell_wrapper() {
+    let _lock = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
+    let native_path = "/tmp/native leader/bin:/usr/bin:/bin";
+    let _env = EnvGuard::apply(&[("PATH", Some(native_path))]);
+    let ws = p2_temp_ws("native_path");
+    let identity = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
+    let env = leader_env_for_identity(Provider::Pi, &identity);
+    assert_eq!(env.get("PATH").map(String::as_str), Some(native_path));
+    let command = crate::tmux_backend::leader_shell_wrapper_command(
+        &["pi".to_string(), "--name".to_string(), "leader".to_string()],
+        &ws, &env, &[], "pi",
+    );
+    assert!(command.contains("PATH='/tmp/native leader/bin:/usr/bin:/bin'"));
+    assert!(command.find("PATH=").unwrap() < command.find(" pi --name leader").unwrap());
+    assert_eq!(env.get("TEAM_AGENT_TEAM_ID").map(String::as_str), Some(identity.team_id.as_str()));
+    let _unset = EnvGuard::apply(&[("PATH", None)]);
+    assert!(!leader_env_for_identity(Provider::Pi, &identity).contains_key("PATH"));
+}
+
 // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
 // Lock CORRECT Python v0.2.11 leader-identity behavior the contracts missed.
 // Golden re-probed via /tmp/probe_p2_leader.py vs team-agent-public @ 439bef8

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

@@ -476,26 +476,62 @@ pub(super) fn annotate_persisted_team_depth(
 }
 
 /// ---
-/// purpose: 判断 runtime state 里是否已存在该 quick-start 团队
-/// returns: 活跃键、teams 表、投影出的团队键、身份字段或 session 名任一命中即 true
+/// purpose: 判断目标团队是否已有 worker runtime，已证明的 Leader-only 登记不算初始化
+/// returns: 未初始化的有效 Leader-only 登记为 false；已有或无法分类的目标 runtime 为 true
 /// ---
 pub(super) fn runtime_state_has_quick_start_team(state: &serde_json::Value, team: &str) -> bool {
-    explicit_active_team_key(state).as_deref() == Some(team)
-        || state
-            .get("teams")
-            .and_then(serde_json::Value::as_object)
-            .is_some_and(|teams| {
-                teams.contains_key(team)
-                    || teams
-                        .values()
-                        .any(|entry| json_team_identity_matches(entry, team))
-            })
+    let entry = state
+        .get("teams")
+        .and_then(serde_json::Value::as_object)
+        .and_then(|teams| teams.get(team));
+    if let Some(entry) = entry {
+        return !is_quick_start_leader_bootstrap(entry);
+    }
+    // Legacy aliases still identify existing/ambiguous runtime, not a proven
+    // canonical bootstrap record. Do not grant fresh creation through an alias.
+    if state
+        .get("teams")
+        .and_then(serde_json::Value::as_object)
+        .is_some_and(|teams| teams.values().any(|entry| json_team_identity_matches(entry, team)))
+    {
+        return true;
+    }
+    let matches = explicit_active_team_key(state).as_deref() == Some(team)
         || crate::state::projection::team_state_key(state) == team
         || json_team_identity_matches(state, team)
         || state
             .get("session_name")
             .and_then(serde_json::Value::as_str)
-            .is_some_and(|session| session == team || session.strip_prefix("team-") == Some(team))
+            .is_some_and(|session| session == team || session.strip_prefix("team-") == Some(team));
+    matches && !is_quick_start_leader_bootstrap(state)
+}
+
+// An empty agent table alone is not fresh: stopped/removed/partial teams keep
+// their spec, session or task history. Only a coherent attached leader binding
+// with no worker initialization evidence may proceed through first creation.
+pub(super) fn is_quick_start_leader_bootstrap(state: &serde_json::Value) -> bool {
+    if !state.is_object()
+        || state.get("teams").is_some_and(|teams| !teams.is_object())
+        || !state.get("agents").and_then(serde_json::Value::as_object).is_some_and(|agents| agents.is_empty())
+        || state.get("spec_path").is_some()
+        || state.get("team_dir").is_some_and(|dir| !dir.is_null())
+        || state.get("session_name").is_some_and(|session| !session.is_null())
+        || state.get("tasks").is_some_and(|tasks| {
+            !tasks.as_object().is_some_and(|tasks| tasks.is_empty())
+                && !tasks.as_array().is_some_and(|tasks| tasks.is_empty())
+        })
+        || state.get("status").is_some_and(|status| status.as_str() != Some("alive"))
+        || state.get("archived_at").is_some_and(|value| !value.is_null())
+    {
+        return false;
+    }
+    let owner = state.get("team_owner");
+    let receiver = state.get("leader_receiver");
+    let owner_pane = owner.and_then(|owner| owner.get("pane_id")).and_then(serde_json::Value::as_str).filter(|pane| !pane.is_empty());
+    let receiver_pane = receiver.and_then(|receiver| receiver.get("pane_id")).and_then(serde_json::Value::as_str);
+    owner_pane.is_some()
+        && owner_pane == receiver_pane
+        && receiver.and_then(|receiver| receiver.get("status")).and_then(serde_json::Value::as_str) == Some("attached")
 }
 
 /// ---
@@ -513,3 +549,126 @@ pub(super) fn json_team_identity_matches(state: &serde_json::Value, team: &str)
             .and_then(serde_json::Value::as_str)
             .is_some_and(|value| value == team)
 }
+
+#[cfg(test)]
+mod quick_start_runtime_identity_tests {
+    use super::runtime_state_has_quick_start_team;
+    use serde_json::{json, Value};
+
+    fn leader_bootstrap() -> Value {
+        json!({
+            "agents": {},
+            "session_name": null,
+            "tasks": {},
+            "team_owner": {"pane_id": "%0", "provider": "pi", "owner_epoch": 1},
+            "leader_receiver": {"pane_id": "%0", "status": "attached", "session_name": "team-agent-leader-pi-fixture"},
+            "leader_client": {"diagnostic_only": true}
+        })
+    }
+
+    #[test]
+    fn current_launcher_seed_is_not_initialized_and_is_not_mutated() {
+        let seed = leader_bootstrap();
+        let state = json!({"active_team_key": "current", "team_key": "current", "teams": {"current": seed}});
+        let before = state.clone();
+        assert!(!runtime_state_has_quick_start_team(&state, "current"));
+        assert_eq!(state, before);
+    }
+
+    #[test]
+    fn real_native_managed_launcher_empty_array_shape_is_fresh_and_unchanged() {
+        let mut entry = leader_bootstrap();
+        entry["tasks"] = json!([]);
+        entry["is_external_leader"] = json!(false);
+        entry["team_key"] = json!("current");
+        entry["tmux_socket"] = json!("/private/tmp/fixture-native-leader");
+        entry["owner_epoch"] = json!(1);
+        entry["team_owner"]["machine_fingerprint"] = json!("");
+        entry["team_owner"]["leader_session_uuid"] = json!("fixture-native-uuid");
+        entry["leader_receiver"]["owner_epoch"] = json!(1);
+        entry["leader_receiver"]["leader_session_uuid"] = json!("fixture-native-uuid");
+        let state = json!({
+            "agents": {}, "tasks": [], "session_name": null,
+            "active_team_key": "current", "team_key": "current",
+            "teams": {"current": entry}
+        });
+        let before = state.clone();
+        assert!(!runtime_state_has_quick_start_team(&state, "current"));
+        assert_eq!(state, before);
+    }
+
+    #[test]
+    fn legacy_flat_leader_binding_can_initialize() {
+        let mut state = leader_bootstrap();
+        state["active_team_key"] = json!("current");
+        assert!(!runtime_state_has_quick_start_team(&state, "current"));
+    }
+
+    #[test]
+    fn stopped_removed_partial_and_unknown_teams_remain_existing() {
+        let cases = [
+            ("agents", json!({"worker": {"status": "stopped"}})),
+            ("spec_path", json!("/tmp/current/team.spec.yaml")),
+            ("spec_path", Value::Null),
+            ("team_dir", json!("/tmp/.team/current")),
+            ("session_name", json!("team-current")),
+            ("session_name", json!("team-agent-leader-stale-worker-field")),
+            ("tasks", json!({"finished_task": {"status": "done"}})),
+            ("tasks", json!([{"status": "done"}])),
+            ("tasks", Value::Null),
+            ("tasks", json!("unknown")),
+            ("tasks", json!(false)),
+            ("tasks", json!(0)),
+            ("status", json!("stopped")),
+            ("archived_at", json!("2026-10-08")),
+            ("agents", Value::Null),
+            ("agents", json!([])),
+            ("team_owner", Value::Null),
+            ("leader_receiver", json!({"pane_id": "%99", "status": "attached"})),
+            ("leader_receiver", json!({"pane_id": "%0", "status": "pending"})),
+        ];
+        for (key, value) in cases {
+            let mut entry = leader_bootstrap();
+            entry[key] = value;
+            let state = json!({"active_team_key": "current", "teams": {"current": entry}});
+            assert!(runtime_state_has_quick_start_team(&state, "current"), "must protect {key}: {state}");
+        }
+        for entry in [json!({}), Value::Null, json!({"agents": {}, "session_name": null})] {
+            let state = json!({"teams": {"current": entry}});
+            assert!(runtime_state_has_quick_start_team(&state, "current"));
+        }
+    }
+
+    #[test]
+    fn malformed_team_tables_do_not_allow_flat_bootstrap_to_bypass_the_guard() {
+        for teams in [Value::Null, json!([]), json!("damaged")] {
+            let mut state = leader_bootstrap();
+            state["active_team_key"] = json!("current");
+            state["teams"] = teams;
+            assert!(runtime_state_has_quick_start_team(&state, "current"));
+        }
+    }
+
+    #[test]
+    fn only_the_requested_team_supplies_initialization_evidence() {
+        let state = json!({
+            "active_team_key": "other", "spec_path": "/tmp/other/spec.yaml",
+            "session_name": "team-other", "agents": {"other_worker": {}},
+            "teams": {
+                "other": {"spec_path": "/tmp/other/spec.yaml", "agents": {"other_worker": {}}},
+                "current": leader_bootstrap()
+            }
+        });
+        assert!(!runtime_state_has_quick_start_team(&state, "current"));
+        assert!(runtime_state_has_quick_start_team(&state, "other"));
+        assert!(!runtime_state_has_quick_start_team(&state, "new-team"));
+    }
+
+    #[test]
+    fn ambiguous_legacy_identity_is_not_fresh() {
+        let mut first = leader_bootstrap();
+        first["name"] = json!("current");
+        let state = json!({"teams": {"first": first, "second": {"name": "current"}}});
+        assert!(runtime_state_has_quick_start_team(&state, "current"));
+    }
+}