@team-agent/installer 0.5.111 → 0.5.113

package/crates/team-agent/src/db/schema.rs

@@ -1,7 +1,7 @@
 //!
 //! `team.db` schema 初始化(真相源 `message_store/schema.py` + `schema_migration.py`)。
 //!
-//! slice 1:fresh DB schema —— 8 表 DDL、6 索引、ALTER 式列迁移、agent_health 重建、
+//! slice 1:fresh DB schema —— 7 表 DDL、6 索引、ALTER 式列迁移、agent_health 重建、
 //! WAL/busy_timeout pragmas、`user_version = SCHEMA_VERSION`。
 //! slice 2(待做):列**顺序**漂移的整表 rebuild(`ensure_table_layout`/`_rebuild_tables`)
 //! 与 `schema_diagnosis`,验 legacy_team_db_fixture + schema_migration 契约。
@@ -15,14 +15,13 @@ use crate::db::DbError;
 /// `schema.py:90`。
 pub const SCHEMA_VERSION: i64 = 5;
 
-/// 8 张表的 DDL(逐字照搬 `schema.py:initialize_schema` 的内联建表;含 `if not exists`)。
+/// 7 张表的 DDL(逐字照搬 `schema.py:initialize_schema` 的内联建表;含 `if not exists`)。
 /// 顺序与 Python 一致(leader_notification_log 在 ensure 块后创建)。
 const CREATE_MESSAGES: &str = "create table if not exists messages (\n              message_id text primary key,\n              owner_team_id text,\n              task_id text,\n              sender text,\n              recipient text,\n              reply_to text,\n              requires_ack integer,\n              status text,\n              content text,\n              presentation text not null default '{\"sink\":\"leader\",\"class\":\"message\"}',\n              artifact_refs text,\n              created_at text,\n              updated_at text,\n              delivered_at text,\n              acknowledged_at text,\n              error text,\n              delivery_attempts integer not null default 0\n            )";
 const CREATE_RESULTS: &str = "create table if not exists results (\n              result_id text primary key,\n              owner_team_id text,\n              task_id text not null,\n              agent_id text not null,\n              envelope text not null,\n              status text not null,\n              created_at text not null\n            )";
 const CREATE_SCHEDULED_EVENTS: &str = "create table if not exists scheduled_events (\n              id integer primary key,\n              owner_team_id text,\n              due_at text not null,\n              target text not null,\n              kind text not null,\n              payload_json text not null,\n              status text not null,\n              created_at text not null,\n              fired_at text,\n              result_json text\n            )";
 const CREATE_DELIVERY_TOKENS: &str = "create table if not exists delivery_tokens (\n              message_id text primary key,\n              unique_token text not null,\n              injected_at text not null,\n              visible_at text,\n              consumed_at text,\n              failed_at text,\n              failure_reason text\n            )";
 const CREATE_AGENT_HEALTH: &str = "create table if not exists agent_health (\n              owner_team_id text,\n              agent_id text not null,\n              status text not null,\n              last_output_at text,\n              context_usage_pct integer,\n              current_task_id text,\n              updated_at text not null,\n              unique(owner_team_id, agent_id)\n            )";
-const CREATE_PEER_ALLOWLIST: &str = "create table if not exists peer_allowlist (\n              a text not null,\n              b text not null,\n              created_at text not null,\n              primary key (a, b)\n            )";
 const CREATE_RESULT_WATCHERS: &str = "create table if not exists result_watchers (\n              watcher_id text primary key,\n              owner_team_id text,\n              task_id text,\n              agent_id text,\n              message_id text,\n              leader_id text not null,\n              recipient text,\n              status text not null,\n              created_at text not null,\n              completed_at text,\n              result_id text,\n              notified_message_id text,\n              error text\n            )";
 const CREATE_LEADER_NOTIFICATION_LOG: &str = "create table if not exists leader_notification_log (\n              result_id text not null,\n              owner_team_id text not null default '',\n              owner_epoch integer not null default 0,\n              leader_session_uuid text,\n              notified_message_id text not null,\n              notified_at text not null,\n              leader_pane_id_at_notify text,\n              envelope_content_hash text,\n              primary key (result_id, owner_team_id, owner_epoch)\n            )";
 const CREATE_AGENT_HEALTH_NEW: &str = "create table agent_health_new (\n              owner_team_id text,\n              agent_id text not null,\n              status text not null,\n              last_output_at text,\n              context_usage_pct integer,\n              current_task_id text,\n              updated_at text not null,\n              unique(owner_team_id, agent_id)\n            )";
@@ -96,7 +95,6 @@ const AGENT_HEALTH_COLUMNS: &[&str] = &[
     "current_task_id",
     "updated_at",
 ];
-const PEER_ALLOWLIST_COLUMNS: &[&str] = &["a", "b", "created_at"];
 const RESULT_WATCHER_COLUMNS: &[&str] = &[
     "owner_team_id",
     "watcher_id",
@@ -249,7 +247,6 @@ pub fn initialize_schema(
         CREATE_SCHEDULED_EVENTS,
         CREATE_DELIVERY_TOKENS,
         CREATE_AGENT_HEALTH,
-        CREATE_PEER_ALLOWLIST,
         CREATE_RESULT_WATCHERS,
     ] {
         tx.execute(ddl, [])?;
@@ -293,7 +290,6 @@ pub fn initialize_schema(
     )?;
     ensure_table_columns(&tx, "delivery_tokens", DELIVERY_TOKEN_COLUMNS, &[])?;
     migrate_agent_health_owner_team_id(&tx)?;
-    ensure_table_columns(&tx, "peer_allowlist", PEER_ALLOWLIST_COLUMNS, &[])?;
     ensure_table_columns(
         &tx,
         "result_watchers",
@@ -333,7 +329,28 @@ mod tests {
         conn
     }
 
-    // golden 由 Python initialize_schema 新建 DB 取(team-agent-public@439bef8)。
+    #[test]
+    fn retired_peer_allowlist_is_neither_created_nor_managed() {
+        let conn = fresh();
+        assert!(table_layout(&conn, "peer_allowlist").unwrap().is_empty());
+        // Legacy residue may have an obsolete layout. Initialization must leave
+        // its data alone, not rebuild/drop it or require it for schema health.
+        conn.execute_batch(
+            "create table peer_allowlist (legacy_payload text);\n             insert into peer_allowlist values ('preserve-this-row');",
+        )
+        .unwrap();
+        initialize_schema(&conn, None).unwrap();
+        assert!(crate::db::migration::ensure_table_layout(&conn, SCHEMA_VERSION, None)
+            .unwrap()
+            .is_empty());
+        assert_eq!(table_layout(&conn, "peer_allowlist").unwrap(), ["legacy_payload"]);
+        let value: String = conn.query_row("select legacy_payload from peer_allowlist", [], |row| row.get(0)).unwrap();
+        assert_eq!(value, "preserve-this-row");
+        let version: i64 = conn.query_row("pragma user_version", [], |row| row.get(0)).unwrap();
+        assert_eq!(version, 5);
+    }
+
+    // Fresh managed schema, excluding retired legacy tables.
     #[test]
     fn fresh_schema_matches_python_sqlite_master() {
         let conn = fresh();
@@ -356,7 +373,6 @@ mod tests {
             ("idx_scheduled_events_owner_team_id", "index"),
             ("leader_notification_log", "table"),
             ("messages", "table"),
-            ("peer_allowlist", "table"),
             ("result_watchers", "table"),
             ("results", "table"),
             ("scheduled_events", "table"),
@@ -419,9 +435,9 @@ mod tests {
         assert_eq!(idx, 6, "二次 init 后 6 个 named index 仍在");
     }
 
-    // 全 8 表逐列 (name, type, notnull, dflt, pk) golden(Python initialize_schema table_info)。
+    // Managed tables: (name, type, notnull, dflt, pk).
     #[test]
-    fn per_column_table_info_all_eight_tables() {
+    fn per_column_table_info_managed_tables() {
         type Col = (&'static str, &'static str, i64, Option<&'static str>, i64);
         let golden: &[(&str, &[Col])] = &[
             (
@@ -503,14 +519,6 @@ mod tests {
                     ("updated_at", "TEXT", 1, None, 0),
                 ],
             ),
-            (
-                "peer_allowlist",
-                &[
-                    ("a", "TEXT", 1, None, 1),
-                    ("b", "TEXT", 1, None, 2),
-                    ("created_at", "TEXT", 1, None, 0),
-                ],
-            ),
             (
                 "result_watchers",
                 &[
@@ -582,7 +590,7 @@ mod tests {
         ];
         let got: Vec<(&str, &str)> = idx.iter().map(|(n, s)| (n.as_str(), s.as_str())).collect();
         assert_eq!(got, want);
-        // 7 个 sqlite_autoindex(每个有 pk/unique 约束的表各一)。
+        // 6 个 sqlite_autoindex(每个有 pk/unique 约束的表各一)。
         let auto: Vec<String> = conn
             .prepare(
                 "select name from sqlite_master where type='index' and sql is null order by name",
@@ -599,7 +607,6 @@ mod tests {
                 "sqlite_autoindex_delivery_tokens_1",
                 "sqlite_autoindex_leader_notification_log_1",
                 "sqlite_autoindex_messages_1",
-                "sqlite_autoindex_peer_allowlist_1",
                 "sqlite_autoindex_result_watchers_1",
                 "sqlite_autoindex_results_1",
             ]

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

@@ -17,30 +17,6 @@ use super::{
     OwnerBindResult, TeamOwner,
 };
 
-// ── leader::identity — leader_identity / 身份上下文 ──
-
-/// `leader_identity`(card §47;`__init__.py:355`)。`team-agent identity` 入口。
-/// 返回 uuid_prefix + 身份字段(JSON dict,CLI 直出)。
-pub fn leader_identity(workspace: &Path, team: Option<&str>) -> Result<Value, LeaderError> {
-    let state = crate::state::persist::load_runtime_state(workspace)?;
-    let identity = leader_identity_context(workspace, team, Some(&state))?;
-    Ok(json!({
-        "ok": true,
-        "uuid_prefix": prefix(identity.leader_session_uuid.as_str(), 12),
-        "machine_fingerprint": identity.machine_fingerprint,
-        "workspace_abspath": identity.workspace_abspath.to_string_lossy(),
-        "os_user": identity.os_user,
-        "team_id": identity.team_id.as_str(),
-        "current_pane_id": std::env::var("TEAM_AGENT_LEADER_PANE_ID")
-            .ok()
-            .filter(|v| !v.is_empty())
-            .or_else(|| std::env::var("TMUX_PANE").ok().filter(|v| !v.is_empty())),
-        "last_seen_at": get_path_str(&state, &["leader_receiver", "attached_at"])
-            .or_else(|| get_path_str(&state, &["leader_receiver", "last_seen_at"])),
-        "source": serde_json::to_value(identity.leader_session_uuid_source)?,
-    }))
-}
-
 /// `_leader_identity_context`(`__init__.py:192`)。派生 leader 身份上下文(override / state / derive)。
 pub fn leader_identity_context(
     workspace: &Path,

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/byte_findings.rs

@@ -353,23 +353,3 @@ fn attach_leader_to_state_nonfirst_does_not_overwrite_owner_or_advance_epoch() {
         "non-first-time attach must NOT advance owner_epoch (golden keeps 3); Rust bumps to 4"
     );
 }
-
-// C3 [WARN] — leader_identity.current_pane_id honors TEAM_AGENT_LEADER_PANE_ID priority (golden
-// :366 = env(TEAM_AGENT_LEADER_PANE_ID) or env(TMUX_PANE) or None). Rust owner_bind.rs:32 reads
-// TMUX_PANE only. RED: with TEAM_AGENT_LEADER_PANE_ID set + TMUX_PANE unset, current_pane_id must be
-// the LEADER_PANE_ID. (Sibling gap, noted: last_seen_at = receiver.attached_at OR receiver.last_seen_at;
-// Rust reads attached_at only.)
-#[test]
-#[serial_test::serial(env)]
-fn c3_leader_identity_current_pane_honors_leader_pane_id_env() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[
-        ("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None),
-        ("TEAM_AGENT_LEADER_PANE_ID", Some("%foo")),
-        ("TMUX_PANE", None),
-    ]);
-    let ws = p2_temp_ws("c3_pane_env");
-    let v = leader_identity(&ws, None).unwrap();
-    assert_eq!(v["current_pane_id"], serde_json::json!("%foo"),
-            "golden :366 current_pane_id = TEAM_AGENT_LEADER_PANE_ID or TMUX_PANE or None; Rust reads TMUX_PANE only");
-}

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

@@ -23,38 +23,6 @@ fn leader_identity_context_derives_when_no_override_no_state() {
     assert_eq!(id.leader_session_uuid.as_str().len(), 32);
 }
 
-// leader_identity:CLI 直出 dict(__init__.py:355-369)。unimplemented → RED。
-// 强化:uuid_prefix 必须 == leader_identity_context 派生 uuid 的前 12 hex(绑到真值,
-// 而非任意 12 字符);整个 dict 的 machine_fingerprint/os_user/team_id/source 必须与 context 一致。
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_ties_prefix_and_fields_to_derived_context() {
-    let ws = std::env::temp_dir().join(format!("ta_rs_lid_{}", std::process::id()));
-    std::fs::create_dir_all(&ws).unwrap();
-    // 空 state → context 走 derive(无 override/无 state uuid)。
-    let ctx = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
-    let expected_prefix = &ctx.leader_session_uuid.as_str()[..12];
-    let v = leader_identity(&ws, None).unwrap();
-    assert_eq!(v["ok"], serde_json::json!(true));
-    // uuid_prefix 绑到派生真值的前 12 hex(错的 12 字符串会被抓)。
-    assert_eq!(v["uuid_prefix"].as_str().unwrap(), expected_prefix);
-    // 其余身份字段与 context 字节一致。
-    assert_eq!(
-        v["machine_fingerprint"].as_str().unwrap(),
-        ctx.machine_fingerprint
-    );
-    assert_eq!(v["os_user"].as_str().unwrap(), ctx.os_user);
-    assert_eq!(v["team_id"].as_str().unwrap(), ctx.team_id.as_str());
-    // source == 派生侧 "derived"(无 override → 不是 "override"/"env")。
-    assert_eq!(v["source"], serde_json::json!("derived"));
-    assert_eq!(
-        ctx.leader_session_uuid_source,
-        LeaderSessionUuidSource::Derived
-    );
-    // CLI 直出形态:current_pane_id / last_seen_at 在无 env/无 receiver 时为 null。
-    assert_eq!(v["last_seen_at"], serde_json::Value::Null);
-}
-
 // =====================================================================
 // 13. leader_start_plan(unimplemented → RED):钉 mode 选择 + leader_env 导出键。
 // =====================================================================
@@ -323,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/leader/tests/lease_claim.rs

@@ -398,61 +398,6 @@ fn claim_lease_no_incident_caller_not_live_refused_under_n_rn3_any_live_pane() {
     assert_eq!(r.reason, Some(LeaseReason::CallerPaneNotLive));
 }
 
-// ── 14b. leader_identity dict — workspace_abspath key (golden __init__.py:363) ──
-//
-// LOCK→RED: leader_identity IS implemented (owner_bind.rs:22) but its dict
-// OMITS the golden `workspace_abspath` key (probe_lid.py shows it sits between
-// machine_fingerprint and os_user). This pins the missing key so the porter
-// must add it. Fails today (key absent → null) = RED against the omission.
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_includes_workspace_abspath_key() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
-    let ws = p2_temp_ws("lid_wsabs");
-    let v = leader_identity(&ws, None).unwrap();
-    let ctx = leader_identity_context(&ws, None, Some(&serde_json::json!({}))).unwrap();
-    // golden key present + equals the resolved workspace abspath from context.
-    assert!(
-        v.get("workspace_abspath").is_some(),
-        "golden leader_identity dict carries 'workspace_abspath' (probe_lid.py)"
-    );
-    assert_eq!(
-        v["workspace_abspath"].as_str().unwrap(),
-        ctx.workspace_abspath.to_string_lossy(),
-        "workspace_abspath must equal the context's resolved abspath"
-    );
-}
-
-// LOCK — leader_identity key ORDER & full key set (golden probe_lid.py):
-// [ok, uuid_prefix, machine_fingerprint, workspace_abspath, os_user, team_id,
-//  current_pane_id, last_seen_at, source]. Pins the 9-key surface CLI emits.
-#[test]
-#[serial_test::serial(env)]
-fn leader_identity_dict_has_exact_nine_golden_keys() {
-    let _g = ENV_LOCK.lock().unwrap_or_else(|p| p.into_inner());
-    let _e = EnvGuard::apply(&[("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE", None)]);
-    let ws = p2_temp_ws("lid_keys");
-    let v = leader_identity(&ws, None).unwrap();
-    let obj = v.as_object().expect("leader_identity → JSON object");
-    for key in [
-        "ok",
-        "uuid_prefix",
-        "machine_fingerprint",
-        "workspace_abspath",
-        "os_user",
-        "team_id",
-        "current_pane_id",
-        "last_seen_at",
-        "source",
-    ] {
-        assert!(
-            obj.contains_key(key),
-            "golden leader_identity dict must carry '{key}'"
-        );
-    }
-}
-
 // ═════════════════════════════════════════════════════════════════════════
 // WAVE-2 Lane B — leader-lease DIVERGENCE round (adversarial review @ 2cd71ce).
 // The lease gate is green but NOT byte-parity. Golden: leader/__init__.py

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"));
+    }
+}